diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index de144ee6104c..73467ad267e8 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,8 +1,8 @@
 # This file defines our primary CI workflow that runs on pull requests
 # and also on pushes to special branches (auto, try).
 #
-# The actual definition of the executed jobs is calculated by a Python
-# script located at src/ci/github-actions/ci.py, which
+# The actual definition of the executed jobs is calculated by the
+# `src/ci/citool` crate, which
 # uses job definition data from src/ci/github-actions/jobs.yml.
 # You should primarily modify the `jobs.yml` file if you want to modify
 # what jobs are executed in CI.
@@ -56,7 +56,10 @@ jobs:
       - name: Calculate the CI job matrix
         env:
           COMMIT_MESSAGE: ${{ github.event.head_commit.message }}
-        run: python3 src/ci/github-actions/ci.py calculate-job-matrix >> $GITHUB_OUTPUT
+        run: |
+          cd src/ci/citool
+          cargo test
+          cargo run calculate-job-matrix >> $GITHUB_OUTPUT
         id: jobs
   job:
     name: ${{ matrix.full_name }}
@@ -179,6 +182,20 @@ jobs:
       - name: show the current environment
         run: src/ci/scripts/dump-environment.sh
 
+      # Temporary fix to unblock CI
+      # Remove the latest Windows SDK for 32-bit Windows MSVC builds.
+      # See issue https://github.com/rust-lang/rust/issues/137733 for more details.
+      - name: Remove Windows SDK 10.0.26100.0
+        shell: powershell
+        if: ${{ matrix.name == 'i686-msvc-1' || matrix.name == 'i686-msvc-2' || matrix.name == 'dist-i686-msvc' }}
+        run: |
+          $kits = (Get-ItemProperty -path 'HKLM:\SOFTWARE\Microsoft\Windows Kits\Installed Roots').KitsRoot10
+          $sdk_version = "10.0.26100.0"
+
+          foreach ($kind in 'Bin', 'Lib', 'Include') {
+            Remove-Item -Force -Recurse $kits\$kind\$sdk_version -ErrorAction Continue
+          }
+
       - name: run the build
         # Redirect stderr to stdout to avoid reordering the two streams in the GHA logs.
         run: src/ci/scripts/run-build-from-ci.sh 2>&1
diff --git a/Cargo.lock b/Cargo.lock
index 4401489813a4..72f2d4f6cd39 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -358,7 +358,7 @@ dependencies = [
  "cargo_metadata 0.18.1",
  "directories",
  "rustc-build-sysroot",
- "rustc_tools_util",
+ "rustc_tools_util 0.4.0",
  "rustc_version",
  "serde",
  "serde_json",
@@ -407,9 +407,9 @@ version = "0.1.0"
 
 [[package]]
 name = "cc"
-version = "1.2.13"
+version = "1.2.16"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "c7777341816418c02e033934a09f20dc0ccaf65a5201ef8a450ae0105a573fda"
+checksum = "be714c154be609ec7f5dad223a33bf1482fff90472de28f7362806e6d4832b8c"
 dependencies = [
  "shlex",
 ]
@@ -522,7 +522,7 @@ checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
 
 [[package]]
 name = "clippy"
-version = "0.1.86"
+version = "0.1.87"
 dependencies = [
  "anstream",
  "cargo_metadata 0.18.1",
@@ -539,7 +539,7 @@ dependencies = [
  "quote",
  "regex",
  "rinja",
- "rustc_tools_util",
+ "rustc_tools_util 0.4.2",
  "serde",
  "serde_json",
  "syn 2.0.96",
@@ -553,7 +553,7 @@ dependencies = [
 
 [[package]]
 name = "clippy_config"
-version = "0.1.86"
+version = "0.1.87"
 dependencies = [
  "clippy_utils",
  "itertools",
@@ -578,7 +578,7 @@ dependencies = [
 
 [[package]]
 name = "clippy_lints"
-version = "0.1.86"
+version = "0.1.87"
 dependencies = [
  "arrayvec",
  "cargo_metadata 0.18.1",
@@ -601,7 +601,7 @@ dependencies = [
 
 [[package]]
 name = "clippy_utils"
-version = "0.1.86"
+version = "0.1.87"
 dependencies = [
  "arrayvec",
  "itertools",
@@ -3207,6 +3207,7 @@ dependencies = [
  "rustc_abi",
  "rustc_ast",
  "rustc_ast_pretty",
+ "rustc_attr_parsing",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_feature",
@@ -3215,6 +3216,7 @@ dependencies = [
  "rustc_index",
  "rustc_macros",
  "rustc_middle",
+ "rustc_parse",
  "rustc_session",
  "rustc_span",
  "rustc_target",
@@ -3263,14 +3265,10 @@ dependencies = [
  "rustc_ast",
  "rustc_ast_pretty",
  "rustc_data_structures",
- "rustc_errors",
- "rustc_feature",
- "rustc_fluent_macro",
- "rustc_lexer",
  "rustc_macros",
  "rustc_serialize",
- "rustc_session",
  "rustc_span",
+ "thin-vec",
 ]
 
 [[package]]
@@ -3285,11 +3283,13 @@ dependencies = [
  "rustc_errors",
  "rustc_feature",
  "rustc_fluent_macro",
+ "rustc_hir",
  "rustc_lexer",
  "rustc_macros",
  "rustc_serialize",
  "rustc_session",
  "rustc_span",
+ "thin-vec",
 ]
 
 [[package]]
@@ -3342,6 +3342,7 @@ dependencies = [
  "rustc_expand",
  "rustc_feature",
  "rustc_fluent_macro",
+ "rustc_hir",
  "rustc_index",
  "rustc_lexer",
  "rustc_lint_defs",
@@ -3598,6 +3599,7 @@ dependencies = [
  "rustc_abi",
  "rustc_ast",
  "rustc_ast_pretty",
+ "rustc_attr_data_structures",
  "rustc_data_structures",
  "rustc_error_codes",
  "rustc_error_messages",
@@ -3632,6 +3634,7 @@ dependencies = [
  "rustc_errors",
  "rustc_feature",
  "rustc_fluent_macro",
+ "rustc_hir",
  "rustc_lexer",
  "rustc_lint_defs",
  "rustc_macros",
@@ -3690,6 +3693,7 @@ dependencies = [
  "rustc_abi",
  "rustc_arena",
  "rustc_ast",
+ "rustc_attr_data_structures",
  "rustc_data_structures",
  "rustc_hashes",
  "rustc_index",
@@ -3737,6 +3741,7 @@ dependencies = [
  "rustc_abi",
  "rustc_ast",
  "rustc_ast_pretty",
+ "rustc_attr_parsing",
  "rustc_hir",
  "rustc_span",
 ]
@@ -3911,6 +3916,7 @@ dependencies = [
  "rustc_target",
  "rustc_trait_selection",
  "rustc_type_ir",
+ "smallvec",
  "tracing",
  "unicode-security",
 ]
@@ -4244,6 +4250,7 @@ name = "rustc_query_impl"
 version = "0.0.0"
 dependencies = [
  "measureme",
+ "rustc_attr_data_structures",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_hashes",
@@ -4266,6 +4273,7 @@ dependencies = [
  "rustc-rayon-core",
  "rustc_abi",
  "rustc_ast",
+ "rustc_attr_data_structures",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_feature",
@@ -4316,6 +4324,7 @@ version = "0.0.0"
 dependencies = [
  "bitflags",
  "rustc_abi",
+ "rustc_ast",
  "rustc_data_structures",
  "rustc_hir",
  "rustc_middle",
@@ -4412,6 +4421,7 @@ dependencies = [
  "punycode",
  "rustc-demangle",
  "rustc_abi",
+ "rustc_ast",
  "rustc_data_structures",
  "rustc_errors",
  "rustc_hashes",
@@ -4444,6 +4454,10 @@ version = "0.4.0"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "3316159ab19e19d1065ecc49278e87f767a9dae9fae80348d2b4d4fa4ae02d4d"
 
+[[package]]
+name = "rustc_tools_util"
+version = "0.4.2"
+
 [[package]]
 name = "rustc_trait_selection"
 version = "0.0.0"
@@ -4491,8 +4505,6 @@ dependencies = [
  "rustc_abi",
  "rustc_data_structures",
  "rustc_hir",
- "rustc_infer",
- "rustc_macros",
  "rustc_middle",
  "rustc_span",
  "tracing",
@@ -4571,6 +4583,7 @@ dependencies = [
  "itertools",
  "minifier",
  "pulldown-cmark 0.9.6",
+ "pulldown-cmark-escape",
  "regex",
  "rinja",
  "rustdoc-json-types",
diff --git a/compiler/rustc_abi/src/callconv.rs b/compiler/rustc_abi/src/callconv.rs
index 4529ab8058e9..a21e1aee9b08 100644
--- a/compiler/rustc_abi/src/callconv.rs
+++ b/compiler/rustc_abi/src/callconv.rs
@@ -74,7 +74,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
                 Ok(HomogeneousAggregate::Homogeneous(Reg { kind, size: self.size }))
             }
 
-            BackendRepr::Vector { .. } => {
+            BackendRepr::SimdVector { .. } => {
                 assert!(!self.is_zst());
                 Ok(HomogeneousAggregate::Homogeneous(Reg {
                     kind: RegKind::Vector,
diff --git a/compiler/rustc_abi/src/layout.rs b/compiler/rustc_abi/src/layout.rs
index 3f83787ea376..d3ae6a29f10f 100644
--- a/compiler/rustc_abi/src/layout.rs
+++ b/compiler/rustc_abi/src/layout.rs
@@ -386,13 +386,15 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                     BackendRepr::Memory { sized: true }
                 }
                 // Vectors require at least element alignment, else disable the opt
-                BackendRepr::Vector { element, count: _ } if element.align(dl).abi > align.abi => {
+                BackendRepr::SimdVector { element, count: _ }
+                    if element.align(dl).abi > align.abi =>
+                {
                     BackendRepr::Memory { sized: true }
                 }
                 // the alignment tests passed and we can use this
                 BackendRepr::Scalar(..)
                 | BackendRepr::ScalarPair(..)
-                | BackendRepr::Vector { .. }
+                | BackendRepr::SimdVector { .. }
                 | BackendRepr::Memory { .. } => repr,
             },
         };
@@ -464,7 +466,7 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                     hide_niches(a);
                     hide_niches(b);
                 }
-                BackendRepr::Vector { element, count: _ } => hide_niches(element),
+                BackendRepr::SimdVector { element, count: _ } => hide_niches(element),
                 BackendRepr::Memory { sized: _ } => {}
             }
             st.largest_niche = None;
@@ -1314,7 +1316,9 @@ impl<Cx: HasDataLayout> LayoutCalculator<Cx> {
                         match field.backend_repr {
                             // For plain scalars, or vectors of them, we can't unpack
                             // newtypes for `#[repr(C)]`, as that affects C ABIs.
-                            BackendRepr::Scalar(_) | BackendRepr::Vector { .. } if optimize_abi => {
+                            BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. }
+                                if optimize_abi =>
+                            {
                                 abi = field.backend_repr;
                             }
                             // But scalar pairs are Rust-specific and get
diff --git a/compiler/rustc_abi/src/layout/ty.rs b/compiler/rustc_abi/src/layout/ty.rs
index 221e990ae863..03f3f043c218 100644
--- a/compiler/rustc_abi/src/layout/ty.rs
+++ b/compiler/rustc_abi/src/layout/ty.rs
@@ -219,7 +219,7 @@ impl<'a, Ty> TyAndLayout<'a, Ty> {
         C: HasDataLayout,
     {
         match self.backend_repr {
-            BackendRepr::Vector { .. } => self.size == expected_size,
+            BackendRepr::SimdVector { .. } => self.size == expected_size,
             BackendRepr::Memory { .. } => {
                 if self.fields.count() == 1 && self.fields.offset(0).bytes() == 0 {
                     self.field(cx, 0).is_single_vector_element(cx, expected_size)
diff --git a/compiler/rustc_abi/src/lib.rs b/compiler/rustc_abi/src/lib.rs
index 81e4e255f379..2197dd68eaf6 100644
--- a/compiler/rustc_abi/src/lib.rs
+++ b/compiler/rustc_abi/src/lib.rs
@@ -1410,7 +1410,7 @@ impl AddressSpace {
 pub enum BackendRepr {
     Scalar(Scalar),
     ScalarPair(Scalar, Scalar),
-    Vector {
+    SimdVector {
         element: Scalar,
         count: u64,
     },
@@ -1426,9 +1426,9 @@ impl BackendRepr {
     #[inline]
     pub fn is_unsized(&self) -> bool {
         match *self {
-            BackendRepr::Scalar(_) | BackendRepr::ScalarPair(..) | BackendRepr::Vector { .. } => {
-                false
-            }
+            BackendRepr::Scalar(_)
+            | BackendRepr::ScalarPair(..)
+            | BackendRepr::SimdVector { .. } => false,
             BackendRepr::Memory { sized } => !sized,
         }
     }
@@ -1467,7 +1467,7 @@ impl BackendRepr {
             BackendRepr::Scalar(s) => Some(s.align(cx).abi),
             BackendRepr::ScalarPair(s1, s2) => Some(s1.align(cx).max(s2.align(cx)).abi),
             // The align of a Vector can vary in surprising ways
-            BackendRepr::Vector { .. } | BackendRepr::Memory { .. } => None,
+            BackendRepr::SimdVector { .. } | BackendRepr::Memory { .. } => None,
         }
     }
 
@@ -1489,7 +1489,7 @@ impl BackendRepr {
                 Some(size)
             }
             // The size of a Vector can vary in surprising ways
-            BackendRepr::Vector { .. } | BackendRepr::Memory { .. } => None,
+            BackendRepr::SimdVector { .. } | BackendRepr::Memory { .. } => None,
         }
     }
 
@@ -1500,8 +1500,8 @@ impl BackendRepr {
             BackendRepr::ScalarPair(s1, s2) => {
                 BackendRepr::ScalarPair(s1.to_union(), s2.to_union())
             }
-            BackendRepr::Vector { element, count } => {
-                BackendRepr::Vector { element: element.to_union(), count }
+            BackendRepr::SimdVector { element, count } => {
+                BackendRepr::SimdVector { element: element.to_union(), count }
             }
             BackendRepr::Memory { .. } => BackendRepr::Memory { sized: true },
         }
@@ -1513,8 +1513,8 @@ impl BackendRepr {
             // We do *not* ignore the sign since it matters for some ABIs (e.g. s390x).
             (BackendRepr::Scalar(l), BackendRepr::Scalar(r)) => l.primitive() == r.primitive(),
             (
-                BackendRepr::Vector { element: element_l, count: count_l },
-                BackendRepr::Vector { element: element_r, count: count_r },
+                BackendRepr::SimdVector { element: element_l, count: count_l },
+                BackendRepr::SimdVector { element: element_r, count: count_r },
             ) => element_l.primitive() == element_r.primitive() && count_l == count_r,
             (BackendRepr::ScalarPair(l1, l2), BackendRepr::ScalarPair(r1, r2)) => {
                 l1.primitive() == r1.primitive() && l2.primitive() == r2.primitive()
@@ -1735,7 +1735,7 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
     /// Returns `true` if this is an aggregate type (including a ScalarPair!)
     pub fn is_aggregate(&self) -> bool {
         match self.backend_repr {
-            BackendRepr::Scalar(_) | BackendRepr::Vector { .. } => false,
+            BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => false,
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => true,
         }
     }
@@ -1877,9 +1877,9 @@ impl<FieldIdx: Idx, VariantIdx: Idx> LayoutData<FieldIdx, VariantIdx> {
     /// non-trivial alignment constraints. You probably want to use `is_1zst` instead.
     pub fn is_zst(&self) -> bool {
         match self.backend_repr {
-            BackendRepr::Scalar(_) | BackendRepr::ScalarPair(..) | BackendRepr::Vector { .. } => {
-                false
-            }
+            BackendRepr::Scalar(_)
+            | BackendRepr::ScalarPair(..)
+            | BackendRepr::SimdVector { .. } => false,
             BackendRepr::Memory { sized } => sized && self.size.bytes() == 0,
         }
     }
diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 29c1d34a125a..5c44fda22624 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -39,7 +39,7 @@ pub use crate::format::*;
 use crate::ptr::P;
 use crate::token::{self, CommentKind, Delimiter};
 use crate::tokenstream::{DelimSpan, LazyAttrTokenStream, TokenStream};
-use crate::util::parser::{AssocOp, ExprPrecedence};
+use crate::util::parser::{ExprPrecedence, Fixity};
 
 /// A "Label" is an identifier of some point in sources,
 /// e.g. in the following code:
@@ -937,8 +937,37 @@ impl BinOpKind {
         matches!(self, BinOpKind::And | BinOpKind::Or)
     }
 
+    pub fn precedence(&self) -> ExprPrecedence {
+        use BinOpKind::*;
+        match *self {
+            Mul | Div | Rem => ExprPrecedence::Product,
+            Add | Sub => ExprPrecedence::Sum,
+            Shl | Shr => ExprPrecedence::Shift,
+            BitAnd => ExprPrecedence::BitAnd,
+            BitXor => ExprPrecedence::BitXor,
+            BitOr => ExprPrecedence::BitOr,
+            Lt | Gt | Le | Ge | Eq | Ne => ExprPrecedence::Compare,
+            And => ExprPrecedence::LAnd,
+            Or => ExprPrecedence::LOr,
+        }
+    }
+
+    pub fn fixity(&self) -> Fixity {
+        use BinOpKind::*;
+        match self {
+            Eq | Ne | Lt | Le | Gt | Ge => Fixity::None,
+            Add | Sub | Mul | Div | Rem | And | Or | BitXor | BitAnd | BitOr | Shl | Shr => {
+                Fixity::Left
+            }
+        }
+    }
+
     pub fn is_comparison(self) -> bool {
-        crate::util::parser::AssocOp::from_ast_binop(self).is_comparison()
+        use BinOpKind::*;
+        match self {
+            Eq | Ne | Lt | Le | Gt | Ge => true,
+            Add | Sub | Mul | Div | Rem | And | Or | BitXor | BitAnd | BitOr | Shl | Shr => false,
+        }
     }
 
     /// Returns `true` if the binary operator takes its arguments by value.
@@ -1332,7 +1361,7 @@ impl Expr {
             ExprKind::Range(..) => ExprPrecedence::Range,
 
             // Binop-like expr kinds, handled by `AssocOp`.
-            ExprKind::Binary(op, ..) => AssocOp::from_ast_binop(op.node).precedence(),
+            ExprKind::Binary(op, ..) => op.node.precedence(),
             ExprKind::Cast(..) => ExprPrecedence::Cast,
 
             ExprKind::Assign(..) |
@@ -1424,6 +1453,15 @@ pub enum RangeLimits {
     Closed,
 }
 
+impl RangeLimits {
+    pub fn as_str(&self) -> &'static str {
+        match self {
+            RangeLimits::HalfOpen => "..",
+            RangeLimits::Closed => "..=",
+        }
+    }
+}
+
 /// A method call (e.g. `x.foo::<Bar, Baz>(a, b, c)`).
 #[derive(Clone, Encodable, Decodable, Debug)]
 pub struct MethodCall {
diff --git a/compiler/rustc_ast/src/ast_traits.rs b/compiler/rustc_ast/src/ast_traits.rs
index 346edc87c86b..4a2d95593850 100644
--- a/compiler/rustc_ast/src/ast_traits.rs
+++ b/compiler/rustc_ast/src/ast_traits.rs
@@ -202,9 +202,6 @@ impl HasTokens for Nonterminal {
             Nonterminal::NtItem(item) => item.tokens(),
             Nonterminal::NtStmt(stmt) => stmt.tokens(),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens(),
-            Nonterminal::NtPat(pat) => pat.tokens(),
-            Nonterminal::NtMeta(attr_item) => attr_item.tokens(),
-            Nonterminal::NtPath(path) => path.tokens(),
             Nonterminal::NtBlock(block) => block.tokens(),
         }
     }
@@ -213,9 +210,6 @@ impl HasTokens for Nonterminal {
             Nonterminal::NtItem(item) => item.tokens_mut(),
             Nonterminal::NtStmt(stmt) => stmt.tokens_mut(),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => expr.tokens_mut(),
-            Nonterminal::NtPat(pat) => pat.tokens_mut(),
-            Nonterminal::NtMeta(attr_item) => attr_item.tokens_mut(),
-            Nonterminal::NtPath(path) => path.tokens_mut(),
             Nonterminal::NtBlock(block) => block.tokens_mut(),
         }
     }
diff --git a/compiler/rustc_ast/src/attr/mod.rs b/compiler/rustc_ast/src/attr/mod.rs
index df2f4b887124..4d613085d793 100644
--- a/compiler/rustc_ast/src/attr/mod.rs
+++ b/compiler/rustc_ast/src/attr/mod.rs
@@ -14,7 +14,7 @@ use crate::ast::{
     PathSegment, Safety,
 };
 use crate::ptr::P;
-use crate::token::{self, CommentKind, Delimiter, Token};
+use crate::token::{self, CommentKind, Delimiter, InvisibleOrigin, MetaVarKind, Token};
 use crate::tokenstream::{
     DelimSpan, LazyAttrTokenStream, Spacing, TokenStream, TokenStreamIter, TokenTree,
 };
@@ -405,11 +405,17 @@ impl MetaItem {
                 let span = span.with_hi(segments.last().unwrap().ident.span.hi());
                 Path { span, segments, tokens: None }
             }
-            Some(TokenTree::Token(Token { kind: token::Interpolated(nt), .. }, _)) => match &**nt {
-                token::Nonterminal::NtMeta(item) => return item.meta(item.path.span),
-                token::Nonterminal::NtPath(path) => (**path).clone(),
-                _ => return None,
-            },
+            Some(TokenTree::Delimited(
+                _span,
+                _spacing,
+                Delimiter::Invisible(InvisibleOrigin::MetaVar(
+                    MetaVarKind::Meta { .. } | MetaVarKind::Path,
+                )),
+                _stream,
+            )) => {
+                // This path is currently unreachable in the test suite.
+                unreachable!()
+            }
             Some(TokenTree::Token(
                 Token { kind: token::OpenDelim(_) | token::CloseDelim(_), .. },
                 _,
diff --git a/compiler/rustc_ast/src/mut_visit.rs b/compiler/rustc_ast/src/mut_visit.rs
index 40b29fdba250..9be364e320b7 100644
--- a/compiler/rustc_ast/src/mut_visit.rs
+++ b/compiler/rustc_ast/src/mut_visit.rs
@@ -905,16 +905,8 @@ fn visit_nonterminal<T: MutVisitor>(vis: &mut T, nt: &mut token::Nonterminal) {
                 vis.flat_map_stmt(stmt).expect_one("expected visitor to produce exactly one item")
             })
         }),
-        token::NtPat(pat) => vis.visit_pat(pat),
         token::NtExpr(expr) => vis.visit_expr(expr),
         token::NtLiteral(expr) => vis.visit_expr(expr),
-        token::NtMeta(item) => {
-            let AttrItem { unsafety: _, path, args, tokens } = item.deref_mut();
-            vis.visit_path(path);
-            visit_attr_args(vis, args);
-            visit_lazy_tts(vis, tokens);
-        }
-        token::NtPath(path) => vis.visit_path(path),
     }
 }
 
diff --git a/compiler/rustc_ast/src/token.rs b/compiler/rustc_ast/src/token.rs
index 97d121909f8d..6cd0e15c557f 100644
--- a/compiler/rustc_ast/src/token.rs
+++ b/compiler/rustc_ast/src/token.rs
@@ -90,7 +90,10 @@ pub enum MetaVarKind {
     Ident,
     Lifetime,
     Literal,
-    Meta,
+    Meta {
+        /// Will `AttrItem::meta` succeed on this, if reparsed?
+        has_meta_form: bool,
+    },
     Path,
     Vis,
     TT,
@@ -110,7 +113,7 @@ impl fmt::Display for MetaVarKind {
             MetaVarKind::Ident => sym::ident,
             MetaVarKind::Lifetime => sym::lifetime,
             MetaVarKind::Literal => sym::literal,
-            MetaVarKind::Meta => sym::meta,
+            MetaVarKind::Meta { .. } => sym::meta,
             MetaVarKind::Path => sym::path,
             MetaVarKind::Vis => sym::vis,
             MetaVarKind::TT => sym::tt,
@@ -621,8 +624,7 @@ impl Token {
                 matches!(&**nt,
                     NtBlock(..)   |
                     NtExpr(..)    |
-                    NtLiteral(..) |
-                    NtPath(..)
+                    NtLiteral(..)
                 ),
             OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
                 MetaVarKind::Block |
@@ -658,14 +660,11 @@ impl Token {
                 matches!(&**nt,
                     | NtExpr(..)
                     | NtLiteral(..)
-                    | NtMeta(..)
-                    | NtPat(..)
-                    | NtPath(..)
                 ),
             OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
                 MetaVarKind::Expr { .. } |
                 MetaVarKind::Literal |
-                MetaVarKind::Meta |
+                MetaVarKind::Meta { .. } |
                 MetaVarKind::Pat(_) |
                 MetaVarKind::Path |
                 MetaVarKind::Ty { .. }
@@ -689,7 +688,6 @@ impl Token {
             Lifetime(..)                | // lifetime bound in trait object
             Lt | BinOp(Shl)             | // associated path
             PathSep                      => true, // global path
-            Interpolated(ref nt) => matches!(&**nt, NtPath(..)),
             OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(
                 MetaVarKind::Ty { .. } |
                 MetaVarKind::Path
@@ -848,27 +846,16 @@ impl Token {
         self.ident().is_some_and(|(ident, _)| ident.name == name)
     }
 
-    /// Returns `true` if the token is an interpolated path.
-    fn is_whole_path(&self) -> bool {
-        if let Interpolated(nt) = &self.kind
-            && let NtPath(..) = &**nt
-        {
-            return true;
-        }
-
-        false
-    }
-
     /// Is this a pre-parsed expression dropped into the token stream
     /// (which happens while parsing the result of macro expansion)?
     pub fn is_whole_expr(&self) -> bool {
         if let Interpolated(nt) = &self.kind
-            && let NtExpr(_) | NtLiteral(_) | NtPath(_) | NtBlock(_) = &**nt
+            && let NtExpr(_) | NtLiteral(_) | NtBlock(_) = &**nt
         {
-            return true;
+            true
+        } else {
+            matches!(self.is_metavar_seq(), Some(MetaVarKind::Path))
         }
-
-        false
     }
 
     /// Is the token an interpolated block (`$b:block`)?
@@ -894,7 +881,7 @@ impl Token {
     pub fn is_path_start(&self) -> bool {
         self == &PathSep
             || self.is_qpath_start()
-            || self.is_whole_path()
+            || matches!(self.is_metavar_seq(), Some(MetaVarKind::Path))
             || self.is_path_segment_keyword()
             || self.is_ident() && !self.is_reserved_ident()
     }
@@ -1075,12 +1062,8 @@ pub enum Nonterminal {
     NtItem(P<ast::Item>),
     NtBlock(P<ast::Block>),
     NtStmt(P<ast::Stmt>),
-    NtPat(P<ast::Pat>),
     NtExpr(P<ast::Expr>),
     NtLiteral(P<ast::Expr>),
-    /// Stuff inside brackets for attributes
-    NtMeta(P<ast::AttrItem>),
-    NtPath(P<ast::Path>),
 }
 
 #[derive(Debug, Copy, Clone, PartialEq, Eq, Encodable, Decodable, Hash, HashStable_Generic)]
@@ -1172,10 +1155,7 @@ impl Nonterminal {
             NtItem(item) => item.span,
             NtBlock(block) => block.span,
             NtStmt(stmt) => stmt.span,
-            NtPat(pat) => pat.span,
             NtExpr(expr) | NtLiteral(expr) => expr.span,
-            NtMeta(attr_item) => attr_item.span(),
-            NtPath(path) => path.span,
         }
     }
 
@@ -1184,11 +1164,8 @@ impl Nonterminal {
             NtItem(..) => "item",
             NtBlock(..) => "block",
             NtStmt(..) => "statement",
-            NtPat(..) => "pattern",
             NtExpr(..) => "expression",
             NtLiteral(..) => "literal",
-            NtMeta(..) => "attribute",
-            NtPath(..) => "path",
         }
     }
 }
@@ -1209,11 +1186,8 @@ impl fmt::Debug for Nonterminal {
             NtItem(..) => f.pad("NtItem(..)"),
             NtBlock(..) => f.pad("NtBlock(..)"),
             NtStmt(..) => f.pad("NtStmt(..)"),
-            NtPat(..) => f.pad("NtPat(..)"),
             NtExpr(..) => f.pad("NtExpr(..)"),
             NtLiteral(..) => f.pad("NtLiteral(..)"),
-            NtMeta(..) => f.pad("NtMeta(..)"),
-            NtPath(..) => f.pad("NtPath(..)"),
         }
     }
 }
diff --git a/compiler/rustc_ast/src/tokenstream.rs b/compiler/rustc_ast/src/tokenstream.rs
index 1123ea3a449b..49ae8cc78fc5 100644
--- a/compiler/rustc_ast/src/tokenstream.rs
+++ b/compiler/rustc_ast/src/tokenstream.rs
@@ -468,9 +468,6 @@ impl TokenStream {
                 TokenStream::token_alone(token::Semi, stmt.span)
             }
             Nonterminal::NtStmt(stmt) => TokenStream::from_ast(stmt),
-            Nonterminal::NtPat(pat) => TokenStream::from_ast(pat),
-            Nonterminal::NtMeta(attr) => TokenStream::from_ast(attr),
-            Nonterminal::NtPath(path) => TokenStream::from_ast(path),
             Nonterminal::NtExpr(expr) | Nonterminal::NtLiteral(expr) => TokenStream::from_ast(expr),
         }
     }
diff --git a/compiler/rustc_ast/src/util/parser.rs b/compiler/rustc_ast/src/util/parser.rs
index 8f2b7a23c01c..69454967eed6 100644
--- a/compiler/rustc_ast/src/util/parser.rs
+++ b/compiler/rustc_ast/src/util/parser.rs
@@ -1,59 +1,21 @@
 use rustc_span::kw;
 
-use crate::ast::{self, BinOpKind};
+use crate::ast::{self, BinOpKind, RangeLimits};
 use crate::token::{self, BinOpToken, Token};
 
-/// Associative operator with precedence.
-///
-/// This is the enum which specifies operator precedence and fixity to the parser.
+/// Associative operator.
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum AssocOp {
-    /// `+`
-    Add,
-    /// `-`
-    Subtract,
-    /// `*`
-    Multiply,
-    /// `/`
-    Divide,
-    /// `%`
-    Modulus,
-    /// `&&`
-    LAnd,
-    /// `||`
-    LOr,
-    /// `^`
-    BitXor,
-    /// `&`
-    BitAnd,
-    /// `|`
-    BitOr,
-    /// `<<`
-    ShiftLeft,
-    /// `>>`
-    ShiftRight,
-    /// `==`
-    Equal,
-    /// `<`
-    Less,
-    /// `<=`
-    LessEqual,
-    /// `!=`
-    NotEqual,
-    /// `>`
-    Greater,
-    /// `>=`
-    GreaterEqual,
+    /// A binary op.
+    Binary(BinOpKind),
+    /// `?=` where ? is one of the assignable BinOps
+    AssignOp(BinOpKind),
     /// `=`
     Assign,
-    /// `?=` where ? is one of the BinOpToken
-    AssignOp(BinOpToken),
     /// `as`
-    As,
-    /// `..` range
-    DotDot,
-    /// `..=` range
-    DotDotEq,
+    Cast,
+    /// `..` or `..=` range
+    Range(RangeLimits),
 }
 
 #[derive(PartialEq, Debug)]
@@ -67,81 +29,56 @@ pub enum Fixity {
 }
 
 impl AssocOp {
-    /// Creates a new AssocOP from a token
+    /// Creates a new AssocOp from a token.
     pub fn from_token(t: &Token) -> Option<AssocOp> {
         use AssocOp::*;
         match t.kind {
-            token::BinOpEq(k) => Some(AssignOp(k)),
             token::Eq => Some(Assign),
-            token::BinOp(BinOpToken::Star) => Some(Multiply),
-            token::BinOp(BinOpToken::Slash) => Some(Divide),
-            token::BinOp(BinOpToken::Percent) => Some(Modulus),
-            token::BinOp(BinOpToken::Plus) => Some(Add),
-            token::BinOp(BinOpToken::Minus) => Some(Subtract),
-            token::BinOp(BinOpToken::Shl) => Some(ShiftLeft),
-            token::BinOp(BinOpToken::Shr) => Some(ShiftRight),
-            token::BinOp(BinOpToken::And) => Some(BitAnd),
-            token::BinOp(BinOpToken::Caret) => Some(BitXor),
-            token::BinOp(BinOpToken::Or) => Some(BitOr),
-            token::Lt => Some(Less),
-            token::Le => Some(LessEqual),
-            token::Ge => Some(GreaterEqual),
-            token::Gt => Some(Greater),
-            token::EqEq => Some(Equal),
-            token::Ne => Some(NotEqual),
-            token::AndAnd => Some(LAnd),
-            token::OrOr => Some(LOr),
-            token::DotDot => Some(DotDot),
-            token::DotDotEq => Some(DotDotEq),
+            token::BinOp(BinOpToken::Plus) => Some(Binary(BinOpKind::Add)),
+            token::BinOp(BinOpToken::Minus) => Some(Binary(BinOpKind::Sub)),
+            token::BinOp(BinOpToken::Star) => Some(Binary(BinOpKind::Mul)),
+            token::BinOp(BinOpToken::Slash) => Some(Binary(BinOpKind::Div)),
+            token::BinOp(BinOpToken::Percent) => Some(Binary(BinOpKind::Rem)),
+            token::BinOp(BinOpToken::Caret) => Some(Binary(BinOpKind::BitXor)),
+            token::BinOp(BinOpToken::And) => Some(Binary(BinOpKind::BitAnd)),
+            token::BinOp(BinOpToken::Or) => Some(Binary(BinOpKind::BitOr)),
+            token::BinOp(BinOpToken::Shl) => Some(Binary(BinOpKind::Shl)),
+            token::BinOp(BinOpToken::Shr) => Some(Binary(BinOpKind::Shr)),
+            token::BinOpEq(BinOpToken::Plus) => Some(AssignOp(BinOpKind::Add)),
+            token::BinOpEq(BinOpToken::Minus) => Some(AssignOp(BinOpKind::Sub)),
+            token::BinOpEq(BinOpToken::Star) => Some(AssignOp(BinOpKind::Mul)),
+            token::BinOpEq(BinOpToken::Slash) => Some(AssignOp(BinOpKind::Div)),
+            token::BinOpEq(BinOpToken::Percent) => Some(AssignOp(BinOpKind::Rem)),
+            token::BinOpEq(BinOpToken::Caret) => Some(AssignOp(BinOpKind::BitXor)),
+            token::BinOpEq(BinOpToken::And) => Some(AssignOp(BinOpKind::BitAnd)),
+            token::BinOpEq(BinOpToken::Or) => Some(AssignOp(BinOpKind::BitOr)),
+            token::BinOpEq(BinOpToken::Shl) => Some(AssignOp(BinOpKind::Shl)),
+            token::BinOpEq(BinOpToken::Shr) => Some(AssignOp(BinOpKind::Shr)),
+            token::Lt => Some(Binary(BinOpKind::Lt)),
+            token::Le => Some(Binary(BinOpKind::Le)),
+            token::Ge => Some(Binary(BinOpKind::Ge)),
+            token::Gt => Some(Binary(BinOpKind::Gt)),
+            token::EqEq => Some(Binary(BinOpKind::Eq)),
+            token::Ne => Some(Binary(BinOpKind::Ne)),
+            token::AndAnd => Some(Binary(BinOpKind::And)),
+            token::OrOr => Some(Binary(BinOpKind::Or)),
+            token::DotDot => Some(Range(RangeLimits::HalfOpen)),
             // DotDotDot is no longer supported, but we need some way to display the error
-            token::DotDotDot => Some(DotDotEq),
+            token::DotDotEq | token::DotDotDot => Some(Range(RangeLimits::Closed)),
             // `<-` should probably be `< -`
-            token::LArrow => Some(Less),
-            _ if t.is_keyword(kw::As) => Some(As),
+            token::LArrow => Some(Binary(BinOpKind::Lt)),
+            _ if t.is_keyword(kw::As) => Some(Cast),
             _ => None,
         }
     }
 
-    /// Creates a new AssocOp from ast::BinOpKind.
-    pub fn from_ast_binop(op: BinOpKind) -> Self {
-        use AssocOp::*;
-        match op {
-            BinOpKind::Lt => Less,
-            BinOpKind::Gt => Greater,
-            BinOpKind::Le => LessEqual,
-            BinOpKind::Ge => GreaterEqual,
-            BinOpKind::Eq => Equal,
-            BinOpKind::Ne => NotEqual,
-            BinOpKind::Mul => Multiply,
-            BinOpKind::Div => Divide,
-            BinOpKind::Rem => Modulus,
-            BinOpKind::Add => Add,
-            BinOpKind::Sub => Subtract,
-            BinOpKind::Shl => ShiftLeft,
-            BinOpKind::Shr => ShiftRight,
-            BinOpKind::BitAnd => BitAnd,
-            BinOpKind::BitXor => BitXor,
-            BinOpKind::BitOr => BitOr,
-            BinOpKind::And => LAnd,
-            BinOpKind::Or => LOr,
-        }
-    }
-
     /// Gets the precedence of this operator
     pub fn precedence(&self) -> ExprPrecedence {
         use AssocOp::*;
         match *self {
-            As => ExprPrecedence::Cast,
-            Multiply | Divide | Modulus => ExprPrecedence::Product,
-            Add | Subtract => ExprPrecedence::Sum,
-            ShiftLeft | ShiftRight => ExprPrecedence::Shift,
-            BitAnd => ExprPrecedence::BitAnd,
-            BitXor => ExprPrecedence::BitXor,
-            BitOr => ExprPrecedence::BitOr,
-            Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => ExprPrecedence::Compare,
-            LAnd => ExprPrecedence::LAnd,
-            LOr => ExprPrecedence::LOr,
-            DotDot | DotDotEq => ExprPrecedence::Range,
+            Cast => ExprPrecedence::Cast,
+            Binary(bin_op) => bin_op.precedence(),
+            Range(_) => ExprPrecedence::Range,
             Assign | AssignOp(_) => ExprPrecedence::Assign,
         }
     }
@@ -152,22 +89,17 @@ impl AssocOp {
         // NOTE: it is a bug to have an operators that has same precedence but different fixities!
         match *self {
             Assign | AssignOp(_) => Fixity::Right,
-            As | Multiply | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd
-            | BitXor | BitOr | LAnd | LOr => Fixity::Left,
-            Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | DotDot | DotDotEq => {
-                Fixity::None
-            }
+            Binary(binop) => binop.fixity(),
+            Cast => Fixity::Left,
+            Range(_) => Fixity::None,
         }
     }
 
     pub fn is_comparison(&self) -> bool {
         use AssocOp::*;
         match *self {
-            Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual => true,
-            Assign | AssignOp(_) | As | Multiply | Divide | Modulus | Add | Subtract
-            | ShiftLeft | ShiftRight | BitAnd | BitXor | BitOr | LAnd | LOr | DotDot | DotDotEq => {
-                false
-            }
+            Binary(binop) => binop.is_comparison(),
+            Assign | AssignOp(_) | Cast | Range(_) => false,
         }
     }
 
@@ -175,34 +107,7 @@ impl AssocOp {
         use AssocOp::*;
         match *self {
             Assign | AssignOp(_) => true,
-            Less | Greater | LessEqual | GreaterEqual | Equal | NotEqual | As | Multiply
-            | Divide | Modulus | Add | Subtract | ShiftLeft | ShiftRight | BitAnd | BitXor
-            | BitOr | LAnd | LOr | DotDot | DotDotEq => false,
-        }
-    }
-
-    pub fn to_ast_binop(&self) -> Option<BinOpKind> {
-        use AssocOp::*;
-        match *self {
-            Less => Some(BinOpKind::Lt),
-            Greater => Some(BinOpKind::Gt),
-            LessEqual => Some(BinOpKind::Le),
-            GreaterEqual => Some(BinOpKind::Ge),
-            Equal => Some(BinOpKind::Eq),
-            NotEqual => Some(BinOpKind::Ne),
-            Multiply => Some(BinOpKind::Mul),
-            Divide => Some(BinOpKind::Div),
-            Modulus => Some(BinOpKind::Rem),
-            Add => Some(BinOpKind::Add),
-            Subtract => Some(BinOpKind::Sub),
-            ShiftLeft => Some(BinOpKind::Shl),
-            ShiftRight => Some(BinOpKind::Shr),
-            BitAnd => Some(BinOpKind::BitAnd),
-            BitXor => Some(BinOpKind::BitXor),
-            BitOr => Some(BinOpKind::BitOr),
-            LAnd => Some(BinOpKind::And),
-            LOr => Some(BinOpKind::Or),
-            Assign | AssignOp(_) | As | DotDot | DotDotEq => None,
+            Cast | Binary(_) | Range(_) => false,
         }
     }
 
@@ -212,20 +117,23 @@ impl AssocOp {
     /// parentheses while having a high degree of confidence on the correctness of the suggestion.
     pub fn can_continue_expr_unambiguously(&self) -> bool {
         use AssocOp::*;
+        use BinOpKind::*;
         matches!(
             self,
-            BitXor | // `{ 42 } ^ 3`
             Assign | // `{ 42 } = { 42 }`
-            Divide | // `{ 42 } / 42`
-            Modulus | // `{ 42 } % 2`
-            ShiftRight | // `{ 42 } >> 2`
-            LessEqual | // `{ 42 } <= 3`
-            Greater | // `{ 42 } > 3`
-            GreaterEqual | // `{ 42 } >= 3`
+            Binary(
+                BitXor | // `{ 42 } ^ 3`
+                Div | // `{ 42 } / 42`
+                Rem | // `{ 42 } % 2`
+                Shr | // `{ 42 } >> 2`
+                Le | // `{ 42 } <= 3`
+                Gt | // `{ 42 } > 3`
+                Ge   // `{ 42 } >= 3`
+            ) |
             AssignOp(_) | // `{ 42 } +=`
             // Equal | // `{ 42 } == { 42 }`    Accepting these here would regress incorrect
             // NotEqual | // `{ 42 } != { 42 }  struct literals parser recovery.
-            As // `{ 42 } as usize`
+            Cast // `{ 42 } as usize`
         )
     }
 }
diff --git a/compiler/rustc_ast_lowering/Cargo.toml b/compiler/rustc_ast_lowering/Cargo.toml
index 3215ce6b0cb4..2ec4f4b05551 100644
--- a/compiler/rustc_ast_lowering/Cargo.toml
+++ b/compiler/rustc_ast_lowering/Cargo.toml
@@ -11,6 +11,7 @@ doctest = false
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
+rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
@@ -19,6 +20,7 @@ rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_middle = { path = "../rustc_middle" }
+rustc_parse = { path = "../rustc_parse" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
diff --git a/compiler/rustc_ast_lowering/messages.ftl b/compiler/rustc_ast_lowering/messages.ftl
index 1b91c33742d8..906fb213ee77 100644
--- a/compiler/rustc_ast_lowering/messages.ftl
+++ b/compiler/rustc_ast_lowering/messages.ftl
@@ -37,11 +37,11 @@ ast_lowering_bad_return_type_notation_inputs =
     .suggestion = remove the input types
 
 ast_lowering_bad_return_type_notation_needs_dots = return type notation arguments must be elided with `..`
-    .suggestion = add `..`
+    .suggestion = use the correct syntax by adding `..` to the arguments
 
 ast_lowering_bad_return_type_notation_output =
     return type not allowed with return type notation
-    .suggestion = remove the return type
+ast_lowering_bad_return_type_notation_output_suggestion = use the right argument notation and remove the return type
 
 ast_lowering_bad_return_type_notation_position = return type notation not allowed in this position yet
 
@@ -88,7 +88,7 @@ ast_lowering_invalid_abi_clobber_abi =
     invalid ABI for `clobber_abi`
     .note = the following ABIs are supported on this target: {$supported_abis}
 
-ast_lowering_invalid_abi_suggestion = did you mean
+ast_lowering_invalid_abi_suggestion = there's a similarly named valid ABI `{$suggestion}`
 
 ast_lowering_invalid_asm_template_modifier_const =
     asm template modifiers are not allowed for `const` arguments
diff --git a/compiler/rustc_ast_lowering/src/asm.rs b/compiler/rustc_ast_lowering/src/asm.rs
index cfd32fc066f4..87af7959a884 100644
--- a/compiler/rustc_ast_lowering/src/asm.rs
+++ b/compiler/rustc_ast_lowering/src/asm.rs
@@ -195,7 +195,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                         }
                     }
                     InlineAsmOperand::Const { anon_const } => hir::InlineAsmOperand::Const {
-                        anon_const: self.lower_anon_const_to_anon_const(anon_const),
+                        anon_const: self.lower_const_block(anon_const),
                     },
                     InlineAsmOperand::Sym { sym } => {
                         let static_def_id = self
diff --git a/compiler/rustc_ast_lowering/src/block.rs b/compiler/rustc_ast_lowering/src/block.rs
index 88ce6f80e10b..1d9ca6bb9c8c 100644
--- a/compiler/rustc_ast_lowering/src/block.rs
+++ b/compiler/rustc_ast_lowering/src/block.rs
@@ -108,7 +108,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         };
         let span = self.lower_span(l.span);
         let source = hir::LocalSource::Normal;
-        self.lower_attrs(hir_id, &l.attrs);
+        self.lower_attrs(hir_id, &l.attrs, l.span);
         self.arena.alloc(hir::LetStmt { hir_id, ty, pat, init, els, span, source })
     }
 
diff --git a/compiler/rustc_ast_lowering/src/errors.rs b/compiler/rustc_ast_lowering/src/errors.rs
index f31e2db051d8..ceeb5dffbea0 100644
--- a/compiler/rustc_ast_lowering/src/errors.rs
+++ b/compiler/rustc_ast_lowering/src/errors.rs
@@ -46,8 +46,9 @@ pub(crate) struct TupleStructWithDefault {
 #[derive(Subdiagnostic)]
 #[suggestion(
     ast_lowering_invalid_abi_suggestion,
-    code = "{suggestion}",
-    applicability = "maybe-incorrect"
+    code = "\"{suggestion}\"",
+    applicability = "maybe-incorrect",
+    style = "verbose"
 )]
 pub(crate) struct InvalidAbiSuggestion {
     #[primary_span]
@@ -372,24 +373,39 @@ pub(crate) struct InclusiveRangeWithNoEnd {
     pub span: Span,
 }
 
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    ast_lowering_bad_return_type_notation_output_suggestion,
+    applicability = "machine-applicable",
+    style = "verbose"
+)]
+/// Given `T: Tr<m() -> Ret>` or `T: Tr<m(Ty) -> Ret>`, suggest `T: Tr<m(..)>`.
+pub(crate) struct RTNSuggestion {
+    #[suggestion_part(code = "")]
+    pub output: Span,
+    #[suggestion_part(code = "(..)")]
+    pub input: Span,
+}
+
 #[derive(Diagnostic)]
 pub(crate) enum BadReturnTypeNotation {
     #[diag(ast_lowering_bad_return_type_notation_inputs)]
     Inputs {
         #[primary_span]
-        #[suggestion(code = "()", applicability = "maybe-incorrect")]
+        #[suggestion(code = "(..)", applicability = "machine-applicable", style = "verbose")]
         span: Span,
     },
     #[diag(ast_lowering_bad_return_type_notation_output)]
     Output {
         #[primary_span]
-        #[suggestion(code = "", applicability = "maybe-incorrect")]
         span: Span,
+        #[subdiagnostic]
+        suggestion: RTNSuggestion,
     },
     #[diag(ast_lowering_bad_return_type_notation_needs_dots)]
     NeedsDots {
         #[primary_span]
-        #[suggestion(code = "(..)", applicability = "maybe-incorrect")]
+        #[suggestion(code = "(..)", applicability = "machine-applicable", style = "verbose")]
         span: Span,
     },
     #[diag(ast_lowering_bad_return_type_notation_position)]
diff --git a/compiler/rustc_ast_lowering/src/expr.rs b/compiler/rustc_ast_lowering/src/expr.rs
index af53c7ec2157..9c3db7abc1cc 100644
--- a/compiler/rustc_ast_lowering/src/expr.rs
+++ b/compiler/rustc_ast_lowering/src/expr.rs
@@ -77,9 +77,8 @@ impl<'hir> LoweringContext<'_, 'hir> {
                         self.attrs.insert(
                             ex.hir_id.local_id,
                             &*self.arena.alloc_from_iter(
-                                e.attrs
-                                    .iter()
-                                    .map(|a| self.lower_attr(a))
+                                self.lower_attrs_vec(&e.attrs, e.span)
+                                    .into_iter()
                                     .chain(old_attrs.iter().cloned()),
                             ),
                         );
@@ -98,7 +97,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             }
 
             let expr_hir_id = self.lower_node_id(e.id);
-            self.lower_attrs(expr_hir_id, &e.attrs);
+            self.lower_attrs(expr_hir_id, &e.attrs, e.span);
 
             let kind = match &e.kind {
                 ExprKind::Array(exprs) => hir::ExprKind::Array(self.lower_exprs(exprs)),
@@ -670,12 +669,15 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let guard = arm.guard.as_ref().map(|cond| self.lower_expr(cond));
         let hir_id = self.next_id();
         let span = self.lower_span(arm.span);
-        self.lower_attrs(hir_id, &arm.attrs);
+        self.lower_attrs(hir_id, &arm.attrs, arm.span);
         let is_never_pattern = pat.is_never_pattern();
-        let body = if let Some(body) = &arm.body
+        // We need to lower the body even if it's unneeded for never pattern in match,
+        // ensure that we can get HirId for DefId if need (issue #137708).
+        let body = arm.body.as_ref().map(|x| self.lower_expr(x));
+        let body = if let Some(body) = body
             && !is_never_pattern
         {
-            self.lower_expr(body)
+            body
         } else {
             // Either `body.is_none()` or `is_never_pattern` here.
             if !is_never_pattern {
@@ -839,6 +841,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                     style: AttrStyle::Outer,
                     span: unstable_span,
                 }],
+                span,
             );
         }
     }
@@ -1673,7 +1676,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_expr_field(&mut self, f: &ExprField) -> hir::ExprField<'hir> {
         let hir_id = self.lower_node_id(f.id);
-        self.lower_attrs(hir_id, &f.attrs);
+        self.lower_attrs(hir_id, &f.attrs, f.span);
         hir::ExprField {
             hir_id,
             ident: self.lower_ident(f.ident),
@@ -1936,7 +1939,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         //
         // Also, add the attributes to the outer returned expr node.
         let expr = self.expr_drop_temps_mut(for_span, match_expr);
-        self.lower_attrs(expr.hir_id, &e.attrs);
+        self.lower_attrs(expr.hir_id, &e.attrs, e.span);
         expr
     }
 
@@ -1993,7 +1996,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             let val_ident = Ident::with_dummy_span(sym::val);
             let (val_pat, val_pat_nid) = self.pat_ident(span, val_ident);
             let val_expr = self.expr_ident(span, val_ident, val_pat_nid);
-            self.lower_attrs(val_expr.hir_id, &attrs);
+            self.lower_attrs(val_expr.hir_id, &attrs, span);
             let continue_pat = self.pat_cf_continue(unstable_span, val_pat);
             self.arm(continue_pat, val_expr)
         };
@@ -2024,7 +2027,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
                 let ret_expr = self.checked_return(Some(from_residual_expr));
                 self.arena.alloc(self.expr(try_span, ret_expr))
             };
-            self.lower_attrs(ret_expr.hir_id, &attrs);
+            self.lower_attrs(ret_expr.hir_id, &attrs, ret_expr.span);
 
             let break_pat = self.pat_cf_break(try_span, residual_local);
             self.arm(break_pat, ret_expr)
diff --git a/compiler/rustc_ast_lowering/src/item.rs b/compiler/rustc_ast_lowering/src/item.rs
index 1d3db64b47ed..15802101f71a 100644
--- a/compiler/rustc_ast_lowering/src/item.rs
+++ b/compiler/rustc_ast_lowering/src/item.rs
@@ -11,7 +11,7 @@ use rustc_index::{IndexSlice, IndexVec};
 use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
 use rustc_span::edit_distance::find_best_match_for_name;
-use rustc_span::{DesugaringKind, Ident, Span, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::instrument;
@@ -93,7 +93,8 @@ impl<'a, 'hir> ItemLowerer<'a, 'hir> {
         debug_assert_eq!(self.resolver.node_id_to_def_id[&CRATE_NODE_ID], CRATE_DEF_ID);
         self.with_lctx(CRATE_NODE_ID, |lctx| {
             let module = lctx.lower_mod(&c.items, &c.spans);
-            lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs);
+            // FIXME(jdonszelman): is dummy span ever a problem here?
+            lctx.lower_attrs(hir::CRATE_HIR_ID, &c.attrs, DUMMY_SP);
             hir::OwnerNode::Crate(module)
         })
     }
@@ -157,7 +158,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let mut ident = i.ident;
         let vis_span = self.lower_span(i.vis.span);
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
-        let attrs = self.lower_attrs(hir_id, &i.attrs);
+        let attrs = self.lower_attrs(hir_id, &i.attrs, i.span);
         let kind = self.lower_item_kind(i.span, i.id, hir_id, &mut ident, attrs, vis_span, &i.kind);
         let item = hir::Item {
             owner_id: hir_id.expect_owner(),
@@ -620,7 +621,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     fn lower_foreign_item(&mut self, i: &ForeignItem) -> &'hir hir::ForeignItem<'hir> {
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
         let owner_id = hir_id.expect_owner();
-        let attrs = self.lower_attrs(hir_id, &i.attrs);
+        let attrs = self.lower_attrs(hir_id, &i.attrs, i.span);
         let item = hir::ForeignItem {
             owner_id,
             ident: self.lower_ident(i.ident),
@@ -678,7 +679,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_variant(&mut self, v: &Variant) -> hir::Variant<'hir> {
         let hir_id = self.lower_node_id(v.id);
-        self.lower_attrs(hir_id, &v.attrs);
+        self.lower_attrs(hir_id, &v.attrs, v.span);
         hir::Variant {
             hir_id,
             def_id: self.local_def_id(v.id),
@@ -740,7 +741,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
     ) -> hir::FieldDef<'hir> {
         let ty = self.lower_ty(&f.ty, ImplTraitContext::Disallowed(ImplTraitPosition::FieldTy));
         let hir_id = self.lower_node_id(f.id);
-        self.lower_attrs(hir_id, &f.attrs);
+        self.lower_attrs(hir_id, &f.attrs, f.span);
         hir::FieldDef {
             span: self.lower_span(f.span),
             hir_id,
@@ -759,7 +760,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_trait_item(&mut self, i: &AssocItem) -> &'hir hir::TraitItem<'hir> {
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
-        let attrs = self.lower_attrs(hir_id, &i.attrs);
+        let attrs = self.lower_attrs(hir_id, &i.attrs, i.span);
         let trait_item_def_id = hir_id.expect_owner();
 
         let (generics, kind, has_default) = match &i.kind {
@@ -895,7 +896,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
         let has_value = true;
         let (defaultness, _) = self.lower_defaultness(i.kind.defaultness(), has_value);
         let hir_id = hir::HirId::make_owner(self.current_hir_id_owner.def_id);
-        let attrs = self.lower_attrs(hir_id, &i.attrs);
+        let attrs = self.lower_attrs(hir_id, &i.attrs, i.span);
 
         let (generics, kind) = match &i.kind {
             AssocItemKind::Const(box ConstItem { generics, ty, expr, .. }) => self.lower_generics(
@@ -1056,7 +1057,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
 
     fn lower_param(&mut self, param: &Param) -> hir::Param<'hir> {
         let hir_id = self.lower_node_id(param.id);
-        self.lower_attrs(hir_id, &param.attrs);
+        self.lower_attrs(hir_id, &param.attrs, param.span);
         hir::Param {
             hir_id,
             pat: self.lower_pat(&param.pat),
@@ -1509,7 +1510,7 @@ impl<'hir> LoweringContext<'_, 'hir> {
             span: abi.span,
             suggestion: suggested_name.map(|suggested_name| InvalidAbiSuggestion {
                 span: abi.span,
-                suggestion: format!("\"{suggested_name}\""),
+                suggestion: suggested_name.to_string(),
             }),
             command: "rustc --print=calling-conventions".to_string(),
         });
diff --git a/compiler/rustc_ast_lowering/src/lib.rs b/compiler/rustc_ast_lowering/src/lib.rs
index b865cbedbbb7..13edcc10c9e2 100644
--- a/compiler/rustc_ast_lowering/src/lib.rs
+++ b/compiler/rustc_ast_lowering/src/lib.rs
@@ -45,6 +45,7 @@ use std::sync::Arc;
 
 use rustc_ast::node_id::NodeMap;
 use rustc_ast::{self as ast, *};
+use rustc_attr_parsing::{AttributeParser, OmitDoc};
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -60,7 +61,8 @@ use rustc_macros::extension;
 use rustc_middle::span_bug;
 use rustc_middle::ty::{ResolverAstLowering, TyCtxt};
 use rustc_session::parse::{add_feature_diagnostics, feature_err};
-use rustc_span::{DUMMY_SP, DesugaringKind, Ident, Span, Symbol, kw, sym};
+use rustc_span::symbol::{Ident, Symbol, kw, sym};
+use rustc_span::{DUMMY_SP, DesugaringKind, Span};
 use smallvec::{SmallVec, smallvec};
 use thin_vec::ThinVec;
 use tracing::{debug, instrument, trace};
@@ -137,10 +139,13 @@ struct LoweringContext<'a, 'hir> {
     allow_async_iterator: Arc<[Symbol]>,
     allow_for_await: Arc<[Symbol]>,
     allow_async_fn_traits: Arc<[Symbol]>,
+
+    attribute_parser: AttributeParser<'hir>,
 }
 
 impl<'a, 'hir> LoweringContext<'a, 'hir> {
     fn new(tcx: TyCtxt<'hir>, resolver: &'a mut ResolverAstLowering) -> Self {
+        let registered_tools = tcx.registered_tools(()).iter().map(|x| x.name).collect();
         Self {
             // Pseudo-globals.
             tcx,
@@ -181,6 +186,8 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
             // FIXME(gen_blocks): how does `closure_track_caller`/`async_fn_track_caller`
             // interact with `gen`/`async gen` blocks
             allow_async_iterator: [sym::gen_future, sym::async_iterator].into(),
+
+            attribute_parser: AttributeParser::new(tcx.sess, tcx.features(), registered_tools),
         }
     }
 
@@ -216,7 +223,6 @@ impl ResolverAstLowering {
         None
     }
 
-    /// Obtains resolution for a `NodeId` with a single resolution.
     fn get_partial_res(&self, id: NodeId) -> Option<PartialRes> {
         self.partial_res_map.get(&id).copied()
     }
@@ -855,45 +861,38 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         ret
     }
 
-    fn lower_attrs(&mut self, id: HirId, attrs: &[Attribute]) -> &'hir [hir::Attribute] {
+    fn lower_attrs(
+        &mut self,
+        id: HirId,
+        attrs: &[Attribute],
+        target_span: Span,
+    ) -> &'hir [hir::Attribute] {
         if attrs.is_empty() {
             &[]
         } else {
+            let lowered_attrs = self.lower_attrs_vec(attrs, self.lower_span(target_span));
+
             debug_assert_eq!(id.owner, self.current_hir_id_owner);
-            let ret = self.arena.alloc_from_iter(attrs.iter().map(|a| self.lower_attr(a)));
-            debug_assert!(!ret.is_empty());
-            self.attrs.insert(id.local_id, ret);
-            ret
+            let ret = self.arena.alloc_from_iter(lowered_attrs);
+
+            // this is possible if an item contained syntactical attribute,
+            // but none of them parse succesfully or all of them were ignored
+            // for not being built-in attributes at all. They could be remaining
+            // unexpanded attributes used as markers in proc-macro derives for example.
+            // This will have emitted some diagnostics for the misparse, but will then
+            // not emit the attribute making the list empty.
+            if ret.is_empty() {
+                &[]
+            } else {
+                self.attrs.insert(id.local_id, ret);
+                ret
+            }
         }
     }
 
-    fn lower_attr(&self, attr: &Attribute) -> hir::Attribute {
-        // Note that we explicitly do not walk the path. Since we don't really
-        // lower attributes (we use the AST version) there is nowhere to keep
-        // the `HirId`s. We don't actually need HIR version of attributes anyway.
-        // Tokens are also not needed after macro expansion and parsing.
-        let kind = match attr.kind {
-            AttrKind::Normal(ref normal) => hir::AttrKind::Normal(Box::new(hir::AttrItem {
-                unsafety: self.lower_safety(normal.item.unsafety, hir::Safety::Safe),
-                path: hir::AttrPath {
-                    segments: normal
-                        .item
-                        .path
-                        .segments
-                        .iter()
-                        .map(|i| i.ident)
-                        .collect::<Vec<_>>()
-                        .into_boxed_slice(),
-                    span: normal.item.path.span,
-                },
-                args: self.lower_attr_args(&normal.item.args),
-            })),
-            AttrKind::DocComment(comment_kind, data) => {
-                hir::AttrKind::DocComment(comment_kind, data)
-            }
-        };
-
-        hir::Attribute { kind, id: attr.id, style: attr.style, span: self.lower_span(attr.span) }
+    fn lower_attrs_vec(&self, attrs: &[Attribute], target_span: Span) -> Vec<hir::Attribute> {
+        self.attribute_parser
+            .parse_attribute_list(attrs, target_span, OmitDoc::Lower, |s| self.lower_span(s))
     }
 
     fn alias_attrs(&mut self, id: HirId, target_id: HirId) {
@@ -905,34 +904,6 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         }
     }
 
-    fn lower_attr_args(&self, args: &AttrArgs) -> hir::AttrArgs {
-        match args {
-            AttrArgs::Empty => hir::AttrArgs::Empty,
-            AttrArgs::Delimited(args) => hir::AttrArgs::Delimited(self.lower_delim_args(args)),
-            // This is an inert key-value attribute - it will never be visible to macros
-            // after it gets lowered to HIR. Therefore, we can extract literals to handle
-            // nonterminals in `#[doc]` (e.g. `#[doc = $e]`).
-            &AttrArgs::Eq { eq_span, ref expr } => {
-                // In valid code the value always ends up as a single literal. Otherwise, a dummy
-                // literal suffices because the error is handled elsewhere.
-                let lit = if let ExprKind::Lit(token_lit) = expr.kind
-                    && let Ok(lit) = MetaItemLit::from_token_lit(token_lit, expr.span)
-                {
-                    lit
-                } else {
-                    let guar = self.dcx().has_errors().unwrap();
-                    MetaItemLit {
-                        symbol: kw::Empty,
-                        suffix: None,
-                        kind: LitKind::Err(guar),
-                        span: DUMMY_SP,
-                    }
-                };
-                hir::AttrArgs::Eq { eq_span, expr: lit }
-            }
-        }
-    }
-
     fn lower_delim_args(&self, args: &DelimArgs) -> DelimArgs {
         DelimArgs { dspan: args.dspan, delim: args.delim, tokens: args.tokens.flattened() }
     }
@@ -955,19 +926,27 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                     if let Some(first_char) = constraint.ident.as_str().chars().next()
                         && first_char.is_ascii_lowercase()
                     {
-                        let mut err = if !data.inputs.is_empty() {
-                            self.dcx().create_err(errors::BadReturnTypeNotation::Inputs {
-                                span: data.inputs_span,
-                            })
-                        } else if let FnRetTy::Ty(ty) = &data.output {
-                            self.dcx().create_err(errors::BadReturnTypeNotation::Output {
-                                span: data.inputs_span.shrink_to_hi().to(ty.span),
-                            })
-                        } else {
-                            self.dcx().create_err(errors::BadReturnTypeNotation::NeedsDots {
-                                span: data.inputs_span,
-                            })
+                        tracing::info!(?data, ?data.inputs);
+                        let err = match (&data.inputs[..], &data.output) {
+                            ([_, ..], FnRetTy::Default(_)) => {
+                                errors::BadReturnTypeNotation::Inputs { span: data.inputs_span }
+                            }
+                            ([], FnRetTy::Default(_)) => {
+                                errors::BadReturnTypeNotation::NeedsDots { span: data.inputs_span }
+                            }
+                            // The case `T: Trait<method(..) -> Ret>` is handled in the parser.
+                            (_, FnRetTy::Ty(ty)) => {
+                                let span = data.inputs_span.shrink_to_hi().to(ty.span);
+                                errors::BadReturnTypeNotation::Output {
+                                    span,
+                                    suggestion: errors::RTNSuggestion {
+                                        output: span,
+                                        input: data.inputs_span,
+                                    },
+                                }
+                            }
                         };
+                        let mut err = self.dcx().create_err(err);
                         if !self.tcx.features().return_type_notation()
                             && self.tcx.sess.is_nightly_build()
                         {
@@ -1845,7 +1824,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
         let (name, kind) = self.lower_generic_param_kind(param, source);
 
         let hir_id = self.lower_node_id(param.id);
-        self.lower_attrs(hir_id, &param.attrs);
+        self.lower_attrs(hir_id, &param.attrs, param.span());
         hir::GenericParam {
             hir_id,
             def_id: self.local_def_id(param.id),
diff --git a/compiler/rustc_ast_lowering/src/pat.rs b/compiler/rustc_ast_lowering/src/pat.rs
index e1f3afbcf590..2dcfe7c745da 100644
--- a/compiler/rustc_ast_lowering/src/pat.rs
+++ b/compiler/rustc_ast_lowering/src/pat.rs
@@ -93,7 +93,7 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
 
                         let fs = self.arena.alloc_from_iter(fields.iter().map(|f| {
                             let hir_id = self.lower_node_id(f.id);
-                            self.lower_attrs(hir_id, &f.attrs);
+                            self.lower_attrs(hir_id, &f.attrs, f.span);
 
                             hir::PatField {
                                 hir_id,
diff --git a/compiler/rustc_ast_lowering/src/path.rs b/compiler/rustc_ast_lowering/src/path.rs
index 55d064773132..6b6244b05aa9 100644
--- a/compiler/rustc_ast_lowering/src/path.rs
+++ b/compiler/rustc_ast_lowering/src/path.rs
@@ -13,7 +13,7 @@ use tracing::{debug, instrument};
 
 use super::errors::{
     AsyncBoundNotOnTrait, AsyncBoundOnlyForFnTraits, BadReturnTypeNotation,
-    GenericTypeWithParentheses, UseAngleBrackets,
+    GenericTypeWithParentheses, RTNSuggestion, UseAngleBrackets,
 };
 use super::{
     AllowReturnTypeNotation, GenericArgsCtor, GenericArgsMode, ImplTraitContext, ImplTraitPosition,
@@ -268,19 +268,27 @@ impl<'a, 'hir> LoweringContext<'a, 'hir> {
                 }
                 GenericArgs::Parenthesized(data) => match generic_args_mode {
                     GenericArgsMode::ReturnTypeNotation => {
-                        let mut err = if !data.inputs.is_empty() {
-                            self.dcx().create_err(BadReturnTypeNotation::Inputs {
-                                span: data.inputs_span,
-                            })
-                        } else if let FnRetTy::Ty(ty) = &data.output {
-                            self.dcx().create_err(BadReturnTypeNotation::Output {
-                                span: data.inputs_span.shrink_to_hi().to(ty.span),
-                            })
-                        } else {
-                            self.dcx().create_err(BadReturnTypeNotation::NeedsDots {
-                                span: data.inputs_span,
-                            })
+                        tracing::info!(?data, ?data.inputs);
+                        let err = match (&data.inputs[..], &data.output) {
+                            ([_, ..], FnRetTy::Default(_)) => {
+                                BadReturnTypeNotation::Inputs { span: data.inputs_span }
+                            }
+                            ([], FnRetTy::Default(_)) => {
+                                BadReturnTypeNotation::NeedsDots { span: data.inputs_span }
+                            }
+                            // The case `T: Trait<method(..) -> Ret>` is handled in the parser.
+                            (_, FnRetTy::Ty(ty)) => {
+                                let span = data.inputs_span.shrink_to_hi().to(ty.span);
+                                BadReturnTypeNotation::Output {
+                                    span,
+                                    suggestion: RTNSuggestion {
+                                        output: span,
+                                        input: data.inputs_span,
+                                    },
+                                }
+                            }
                         };
+                        let mut err = self.dcx().create_err(err);
                         if !self.tcx.features().return_type_notation()
                             && self.tcx.sess.is_nightly_build()
                         {
diff --git a/compiler/rustc_ast_passes/messages.ftl b/compiler/rustc_ast_passes/messages.ftl
index 5a0ec865f9d4..25944392a52a 100644
--- a/compiler/rustc_ast_passes/messages.ftl
+++ b/compiler/rustc_ast_passes/messages.ftl
@@ -207,8 +207,6 @@ ast_passes_precise_capturing_duplicated = duplicate `use<...>` precise capturing
 
 ast_passes_precise_capturing_not_allowed_here = `use<...>` precise capturing syntax not allowed in {$loc}
 
-ast_passes_stability_outside_std = stability attributes may not be used outside of the standard library
-
 ast_passes_static_without_body =
     free static item without body
     .suggestion = provide a definition for the static
diff --git a/compiler/rustc_ast_passes/src/errors.rs b/compiler/rustc_ast_passes/src/errors.rs
index 6eb9bb1c0daf..8e53e600f7ac 100644
--- a/compiler/rustc_ast_passes/src/errors.rs
+++ b/compiler/rustc_ast_passes/src/errors.rs
@@ -535,7 +535,6 @@ pub(crate) struct WhereClauseBeforeTypeAlias {
 }
 
 #[derive(Subdiagnostic)]
-
 pub(crate) enum WhereClauseBeforeTypeAliasSugg {
     #[suggestion(ast_passes_remove_suggestion, applicability = "machine-applicable", code = "")]
     Remove {
@@ -732,13 +731,6 @@ pub(crate) struct AssociatedSuggestion2 {
     pub potential_assoc: Ident,
 }
 
-#[derive(Diagnostic)]
-#[diag(ast_passes_stability_outside_std, code = E0734)]
-pub(crate) struct StabilityOutsideStd {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(ast_passes_feature_on_non_nightly, code = E0554)]
 pub(crate) struct FeatureOnNonNightly {
diff --git a/compiler/rustc_ast_passes/src/feature_gate.rs b/compiler/rustc_ast_passes/src/feature_gate.rs
index e5d8013058f6..0f80e49320ed 100644
--- a/compiler/rustc_ast_passes/src/feature_gate.rs
+++ b/compiler/rustc_ast_passes/src/feature_gate.rs
@@ -178,18 +178,6 @@ impl<'a> Visitor<'a> for PostExpansionVisitor<'a> {
                 );
             }
         }
-
-        // Emit errors for non-staged-api crates.
-        if !self.features.staged_api() {
-            if attr.has_name(sym::unstable)
-                || attr.has_name(sym::stable)
-                || attr.has_name(sym::rustc_const_unstable)
-                || attr.has_name(sym::rustc_const_stable)
-                || attr.has_name(sym::rustc_default_body_unstable)
-            {
-                self.sess.dcx().emit_err(errors::StabilityOutsideStd { span: attr.span });
-            }
-        }
     }
 
     fn visit_item(&mut self, i: &'a ast::Item) {
diff --git a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
index 4b1374ceef31..496323a35b8d 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state/expr.rs
@@ -5,7 +5,7 @@ use itertools::{Itertools, Position};
 use rustc_ast::ptr::P;
 use rustc_ast::util::classify;
 use rustc_ast::util::literal::escape_byte_str_symbol;
-use rustc_ast::util::parser::{self, AssocOp, ExprPrecedence, Fixity};
+use rustc_ast::util::parser::{self, ExprPrecedence, Fixity};
 use rustc_ast::{
     self as ast, BlockCheckMode, FormatAlignment, FormatArgPosition, FormatArgsPiece, FormatCount,
     FormatDebugHex, FormatSign, FormatTrait, token,
@@ -279,12 +279,11 @@ impl<'a> State<'a> {
         rhs: &ast::Expr,
         fixup: FixupContext,
     ) {
-        let assoc_op = AssocOp::from_ast_binop(op.node);
-        let binop_prec = assoc_op.precedence();
+        let binop_prec = op.node.precedence();
         let left_prec = lhs.precedence();
         let right_prec = rhs.precedence();
 
-        let (mut left_needs_paren, right_needs_paren) = match assoc_op.fixity() {
+        let (mut left_needs_paren, right_needs_paren) = match op.node.fixity() {
             Fixity::Left => (left_prec < binop_prec, right_prec <= binop_prec),
             Fixity::Right => (left_prec <= binop_prec, right_prec < binop_prec),
             Fixity::None => (left_prec <= binop_prec, right_prec <= binop_prec),
diff --git a/compiler/rustc_attr_data_structures/Cargo.toml b/compiler/rustc_attr_data_structures/Cargo.toml
index 19d0d5a306d6..b18923c337ff 100644
--- a/compiler/rustc_attr_data_structures/Cargo.toml
+++ b/compiler/rustc_attr_data_structures/Cargo.toml
@@ -5,16 +5,12 @@ edition = "2024"
 
 [dependencies]
 # tidy-alphabetical-start
-rustc_abi = { path = "../rustc_abi" }
-rustc_ast = { path = "../rustc_ast" }
-rustc_ast_pretty = { path = "../rustc_ast_pretty" }
-rustc_data_structures = { path = "../rustc_data_structures" }
-rustc_errors = { path = "../rustc_errors" }
-rustc_feature = { path = "../rustc_feature" }
-rustc_fluent_macro = { path = "../rustc_fluent_macro" }
-rustc_lexer = { path = "../rustc_lexer" }
-rustc_macros = { path = "../rustc_macros" }
-rustc_serialize = { path = "../rustc_serialize" }
-rustc_session = { path = "../rustc_session" }
-rustc_span = { path = "../rustc_span" }
+rustc_abi = {path = "../rustc_abi"}
+rustc_ast = {path = "../rustc_ast"}
+rustc_ast_pretty = {path = "../rustc_ast_pretty"}
+rustc_data_structures = {path = "../rustc_data_structures"}
+rustc_macros = {path = "../rustc_macros"}
+rustc_serialize = {path = "../rustc_serialize"}
+rustc_span = {path = "../rustc_span"}
+thin-vec = "0.2.12"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_attr_data_structures/src/attributes.rs b/compiler/rustc_attr_data_structures/src/attributes.rs
index b4027a096c53..d2d1285b0756 100644
--- a/compiler/rustc_attr_data_structures/src/attributes.rs
+++ b/compiler/rustc_attr_data_structures/src/attributes.rs
@@ -1,9 +1,12 @@
 use rustc_abi::Align;
-use rustc_ast as ast;
-use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+use rustc_ast::token::CommentKind;
+use rustc_ast::{self as ast, AttrStyle};
+use rustc_macros::{Decodable, Encodable, HashStable_Generic, PrintAttribute};
+use rustc_span::hygiene::Transparency;
 use rustc_span::{Span, Symbol};
+use thin_vec::ThinVec;
 
-use crate::RustcVersion;
+use crate::{DefaultBodyStability, PartialConstStability, PrintAttribute, RustcVersion, Stability};
 
 #[derive(Copy, Clone, PartialEq, Encodable, Decodable, Debug, HashStable_Generic)]
 pub enum InlineAttr {
@@ -54,7 +57,7 @@ impl OptimizeAttr {
     }
 }
 
-#[derive(Clone, Debug, Encodable, Decodable)]
+#[derive(Clone, Debug, Encodable, Decodable, HashStable_Generic, PrintAttribute)]
 pub enum DiagnosticAttribute {
     // tidy-alphabetical-start
     DoNotRecommend,
@@ -62,7 +65,7 @@ pub enum DiagnosticAttribute {
     // tidy-alphabetical-end
 }
 
-#[derive(PartialEq, Debug, Encodable, Decodable, Copy, Clone)]
+#[derive(PartialEq, Debug, Encodable, Decodable, Copy, Clone, HashStable_Generic, PrintAttribute)]
 pub enum ReprAttr {
     ReprInt(IntType),
     ReprRust,
@@ -71,6 +74,8 @@ pub enum ReprAttr {
     ReprSimd,
     ReprTransparent,
     ReprAlign(Align),
+    // this one is just so we can emit a lint for it
+    ReprEmpty,
 }
 pub use ReprAttr::*;
 
@@ -80,13 +85,13 @@ pub enum TransparencyError {
 }
 
 #[derive(Eq, PartialEq, Debug, Copy, Clone)]
-#[derive(Encodable, Decodable)]
+#[derive(Encodable, Decodable, HashStable_Generic, PrintAttribute)]
 pub enum IntType {
     SignedInt(ast::IntTy),
     UnsignedInt(ast::UintTy),
 }
 
-#[derive(Copy, Debug, Encodable, Decodable, Clone, HashStable_Generic)]
+#[derive(Copy, Debug, Encodable, Decodable, Clone, HashStable_Generic, PrintAttribute)]
 pub struct Deprecation {
     pub since: DeprecatedSince,
     /// The note to issue a reason.
@@ -98,7 +103,7 @@ pub struct Deprecation {
 }
 
 /// Release in which an API is deprecated.
-#[derive(Copy, Debug, Encodable, Decodable, Clone, HashStable_Generic)]
+#[derive(Copy, Debug, Encodable, Decodable, Clone, HashStable_Generic, PrintAttribute)]
 pub enum DeprecatedSince {
     RustcVersion(RustcVersion),
     /// Deprecated in the future ("to be determined").
@@ -132,3 +137,64 @@ impl Deprecation {
         matches!(self.since, DeprecatedSince::RustcVersion(_))
     }
 }
+
+/// Represent parsed, *built in*, inert attributes.
+///
+/// That means attributes that are not actually ever expanded.
+/// For more information on this, see the module docs on the [`rustc_attr_parsing`] crate.
+/// They're instead used as markers, to guide the compilation process in various way in most every stage of the compiler.
+/// These are kept around after the AST, into the HIR and further on.
+///
+/// The word "parsed" could be a little misleading here, because the parser already parses
+/// attributes early on. However, the result, an [`ast::Attribute`]
+/// is only parsed at a high level, still containing a token stream in many cases. That is
+/// because the structure of the contents varies from attribute to attribute.
+/// With a parsed attribute I mean that each attribute is processed individually into a
+/// final structure, which on-site (the place where the attribute is useful for, think the
+/// the place where `must_use` is checked) little to no extra parsing or validating needs to
+/// happen.
+///
+/// For more docs, look in [`rustc_attr_parsing`].
+///
+/// [`rustc_attr_parsing`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_attr_parsing/index.html
+#[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable, PrintAttribute)]
+pub enum AttributeKind {
+    // tidy-alphabetical-start
+    AllowConstFnUnstable(ThinVec<Symbol>),
+    AllowInternalUnstable(ThinVec<(Symbol, Span)>),
+    BodyStability {
+        stability: DefaultBodyStability,
+        /// Span of the `#[rustc_default_body_unstable(...)]` attribute
+        span: Span,
+    },
+    Confusables {
+        symbols: ThinVec<Symbol>,
+        // FIXME(jdonszelmann): remove when target validation code is moved
+        first_span: Span,
+    },
+    ConstStability {
+        stability: PartialConstStability,
+        /// Span of the `#[rustc_const_stable(...)]` or `#[rustc_const_unstable(...)]` attribute
+        span: Span,
+    },
+    ConstStabilityIndirect,
+    Deprecation {
+        deprecation: Deprecation,
+        span: Span,
+    },
+    Diagnostic(DiagnosticAttribute),
+    DocComment {
+        style: AttrStyle,
+        kind: CommentKind,
+        span: Span,
+        comment: Symbol,
+    },
+    MacroTransparency(Transparency),
+    Repr(ThinVec<(ReprAttr, Span)>),
+    Stability {
+        stability: Stability,
+        /// Span of the `#[stable(...)]` or `#[unstable(...)]` attribute
+        span: Span,
+    },
+    // tidy-alphabetical-end
+}
diff --git a/compiler/rustc_attr_data_structures/src/lib.rs b/compiler/rustc_attr_data_structures/src/lib.rs
index 4f204aeab640..e4bb459e6df5 100644
--- a/compiler/rustc_attr_data_structures/src/lib.rs
+++ b/compiler/rustc_attr_data_structures/src/lib.rs
@@ -10,7 +10,142 @@ mod attributes;
 mod stability;
 mod version;
 
+use std::num::NonZero;
+
 pub use attributes::*;
-pub(crate) use rustc_session::HashStableContext;
+use rustc_abi::Align;
+use rustc_ast::token::CommentKind;
+use rustc_ast::{AttrStyle, IntTy, UintTy};
+use rustc_ast_pretty::pp::Printer;
+use rustc_span::hygiene::Transparency;
+use rustc_span::{Span, Symbol};
 pub use stability::*;
+use thin_vec::ThinVec;
 pub use version::*;
+
+/// Requirements for a `StableHashingContext` to be used in this crate.
+/// This is a hack to allow using the `HashStable_Generic` derive macro
+/// instead of implementing everything in `rustc_middle`.
+pub trait HashStableContext: rustc_ast::HashStableContext + rustc_abi::HashStableContext {}
+
+/// This trait is used to print attributes in `rustc_hir_pretty`.
+///
+/// For structs and enums it can be derived using [`rustc_macros::PrintAttribute`].
+/// The output will look a lot like a `Debug` implementation, but fields of several types
+/// like [`Span`]s and empty tuples, are gracefully skipped so they don't clutter the
+/// representation much.
+pub trait PrintAttribute {
+    fn print_something(&self) -> bool;
+    fn print_attribute(&self, p: &mut Printer);
+}
+
+impl<T: PrintAttribute> PrintAttribute for &T {
+    fn print_something(&self) -> bool {
+        T::print_something(self)
+    }
+
+    fn print_attribute(&self, p: &mut Printer) {
+        T::print_attribute(self, p)
+    }
+}
+impl<T: PrintAttribute> PrintAttribute for Option<T> {
+    fn print_something(&self) -> bool {
+        self.as_ref().is_some_and(|x| x.print_something())
+    }
+    fn print_attribute(&self, p: &mut Printer) {
+        if let Some(i) = self {
+            T::print_attribute(i, p)
+        }
+    }
+}
+impl<T: PrintAttribute> PrintAttribute for ThinVec<T> {
+    fn print_something(&self) -> bool {
+        self.is_empty() || self[0].print_something()
+    }
+    fn print_attribute(&self, p: &mut Printer) {
+        let mut last_printed = false;
+        p.word("[");
+        for i in self {
+            if last_printed {
+                p.word_space(",");
+            }
+            i.print_attribute(p);
+            last_printed = i.print_something();
+        }
+        p.word("]");
+    }
+}
+macro_rules! print_skip {
+    ($($t: ty),* $(,)?) => {$(
+        impl PrintAttribute for $t {
+            fn print_something(&self) -> bool { false }
+            fn print_attribute(&self, _: &mut Printer) { }
+        })*
+    };
+}
+
+macro_rules! print_disp {
+    ($($t: ty),* $(,)?) => {$(
+        impl PrintAttribute for $t {
+            fn print_something(&self) -> bool { true }
+            fn print_attribute(&self, p: &mut Printer) {
+                p.word(format!("{}", self));
+            }
+        }
+    )*};
+}
+macro_rules! print_debug {
+    ($($t: ty),* $(,)?) => {$(
+        impl PrintAttribute for $t {
+            fn print_something(&self) -> bool { true }
+            fn print_attribute(&self, p: &mut Printer) {
+                p.word(format!("{:?}", self));
+            }
+        }
+    )*};
+}
+
+macro_rules! print_tup {
+    (num_print_something $($ts: ident)*) => { 0 $(+ $ts.print_something() as usize)* };
+    () => {};
+    ($t: ident $($ts: ident)*) => {
+        #[allow(non_snake_case, unused)]
+        impl<$t: PrintAttribute, $($ts: PrintAttribute),*> PrintAttribute for ($t, $($ts),*) {
+            fn print_something(&self) -> bool {
+                let ($t, $($ts),*) = self;
+                print_tup!(num_print_something $t $($ts)*) != 0
+            }
+
+            fn print_attribute(&self, p: &mut Printer) {
+                let ($t, $($ts),*) = self;
+                let parens = print_tup!(num_print_something $t $($ts)*) > 1;
+                if parens {
+                    p.word("(");
+                }
+
+                let mut printed_anything = $t.print_something();
+
+                $t.print_attribute(p);
+
+                $(
+                    if printed_anything && $ts.print_something() {
+                        p.word_space(",");
+                        printed_anything = true;
+                    }
+                    $ts.print_attribute(p);
+                )*
+
+                if parens {
+                    p.word(")");
+                }
+            }
+        }
+
+        print_tup!($($ts)*);
+    };
+}
+
+print_tup!(A B C D E F G H);
+print_skip!(Span, ());
+print_disp!(Symbol, u16, bool, NonZero<u32>);
+print_debug!(UintTy, IntTy, Align, AttrStyle, CommentKind, Transparency);
diff --git a/compiler/rustc_attr_data_structures/src/stability.rs b/compiler/rustc_attr_data_structures/src/stability.rs
index c2213fc9ed88..c0ca08a60f8b 100644
--- a/compiler/rustc_attr_data_structures/src/stability.rs
+++ b/compiler/rustc_attr_data_structures/src/stability.rs
@@ -1,9 +1,9 @@
 use std::num::NonZero;
 
-use rustc_macros::{Decodable, Encodable, HashStable_Generic};
+use rustc_macros::{Decodable, Encodable, HashStable_Generic, PrintAttribute};
 use rustc_span::{Symbol, sym};
 
-use crate::RustcVersion;
+use crate::{PrintAttribute, RustcVersion};
 
 /// The version placeholder that recently stabilized features contain inside the
 /// `since` field of the `#[stable]` attribute.
@@ -21,7 +21,7 @@ pub const VERSION_PLACEHOLDER: &str = concat!("CURRENT_RUSTC_VERSIO", "N");
 /// - `#[stable]`
 /// - `#[unstable]`
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub struct Stability {
     pub level: StabilityLevel,
     pub feature: Symbol,
@@ -43,7 +43,7 @@ impl Stability {
 
 /// Represents the `#[rustc_const_unstable]` and `#[rustc_const_stable]` attributes.
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub struct ConstStability {
     pub level: StabilityLevel,
     pub feature: Symbol,
@@ -83,7 +83,7 @@ impl ConstStability {
 /// Excludes `const_stable_indirect`. This is necessary because when `-Zforce-unstable-if-unmarked`
 /// is set, we need to encode standalone `#[rustc_const_stable_indirect]` attributes
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub struct PartialConstStability {
     pub level: StabilityLevel,
     pub feature: Symbol,
@@ -103,7 +103,7 @@ impl PartialConstStability {
 
 /// The available stability levels.
 #[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub enum StabilityLevel {
     /// `#[unstable]`
     Unstable {
@@ -145,7 +145,7 @@ pub enum StabilityLevel {
 
 /// Rust release in which a feature is stabilized.
 #[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, PartialOrd, Ord, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub enum StableSince {
     /// also stores the original symbol for printing
     Version(RustcVersion),
@@ -171,7 +171,7 @@ impl StabilityLevel {
 }
 
 #[derive(Encodable, Decodable, PartialEq, Copy, Clone, Debug, Eq, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub enum UnstableReason {
     None,
     Default,
@@ -180,7 +180,7 @@ pub enum UnstableReason {
 
 /// Represents the `#[rustc_default_body_unstable]` attribute.
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub struct DefaultBodyStability {
     pub level: StabilityLevel,
     pub feature: Symbol,
diff --git a/compiler/rustc_attr_data_structures/src/version.rs b/compiler/rustc_attr_data_structures/src/version.rs
index 6be875ad4be8..69b0e041d819 100644
--- a/compiler/rustc_attr_data_structures/src/version.rs
+++ b/compiler/rustc_attr_data_structures/src/version.rs
@@ -1,9 +1,13 @@
 use std::fmt::{self, Display};
 
-use rustc_macros::{Decodable, Encodable, HashStable_Generic, current_rustc_version};
+use rustc_macros::{
+    Decodable, Encodable, HashStable_Generic, PrintAttribute, current_rustc_version,
+};
+
+use crate::PrintAttribute;
 
 #[derive(Encodable, Decodable, Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, Hash)]
-#[derive(HashStable_Generic)]
+#[derive(HashStable_Generic, PrintAttribute)]
 pub struct RustcVersion {
     pub major: u16,
     pub minor: u16,
diff --git a/compiler/rustc_attr_parsing/Cargo.toml b/compiler/rustc_attr_parsing/Cargo.toml
index f681e9397d9f..c335eeb5f712 100644
--- a/compiler/rustc_attr_parsing/Cargo.toml
+++ b/compiler/rustc_attr_parsing/Cargo.toml
@@ -13,9 +13,11 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
+rustc_hir = { path = "../rustc_hir" }
 rustc_lexer = { path = "../rustc_lexer" }
 rustc_macros = { path = "../rustc_macros" }
 rustc_serialize = { path = "../rustc_serialize" }
 rustc_session = { path = "../rustc_session" }
 rustc_span = { path = "../rustc_span" }
+thin-vec = "0.2.12"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_attr_parsing/messages.ftl b/compiler/rustc_attr_parsing/messages.ftl
index faa2865cb913..45174c9582d3 100644
--- a/compiler/rustc_attr_parsing/messages.ftl
+++ b/compiler/rustc_attr_parsing/messages.ftl
@@ -6,6 +6,8 @@ attr_parsing_deprecated_item_suggestion =
     .help = add `#![feature(deprecated_suggestion)]` to the crate root
     .note = see #94785 for more details
 
+attr_parsing_empty_confusables =
+    expected at least one confusable name
 attr_parsing_expected_one_cfg_pattern =
     expected 1 cfg-pattern
 
@@ -21,8 +23,8 @@ attr_parsing_expects_feature_list =
 attr_parsing_expects_features =
     `{$name}` expects feature names
 
-attr_parsing_incorrect_meta_item =
-    incorrect meta item
+attr_parsing_incorrect_meta_item = expected a quoted string literal
+attr_parsing_incorrect_meta_item_suggestion = consider surrounding this with quotes
 
 attr_parsing_incorrect_repr_format_align_one_arg =
     incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
@@ -88,18 +90,20 @@ attr_parsing_multiple_stability_levels =
 attr_parsing_non_ident_feature =
     'feature' is not an identifier
 
+attr_parsing_repr_ident =
+    meta item in `repr` must be an identifier
+
 attr_parsing_rustc_allowed_unstable_pairing =
     `rustc_allowed_through_unstable_modules` attribute must be paired with a `stable` attribute
 
-attr_parsing_rustc_const_stable_indirect_pairing =
-    `const_stable_indirect` attribute does not make sense on `rustc_const_stable` function, its behavior is already implied
-
 attr_parsing_rustc_promotable_pairing =
     `rustc_promotable` attribute must be paired with either a `rustc_const_unstable` or a `rustc_const_stable` attribute
 
 attr_parsing_soft_no_args =
     `soft` should not have any arguments
 
+attr_parsing_stability_outside_std = stability attributes may not be used outside of the standard library
+
 attr_parsing_unknown_meta_item =
     unknown meta item '{$item}'
     .label = expected one of {$expected}
@@ -107,6 +111,10 @@ attr_parsing_unknown_meta_item =
 attr_parsing_unknown_version_literal =
     unknown version literal format, assuming it refers to a future version
 
+attr_parsing_unrecognized_repr_hint =
+    unrecognized representation hint
+    .help = valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
+
 attr_parsing_unstable_cfg_target_compact =
     compact `cfg(target(..))` is experimental and subject to change
 
@@ -122,3 +130,8 @@ attr_parsing_unsupported_literal_generic =
     unsupported literal
 attr_parsing_unsupported_literal_suggestion =
     consider removing the prefix
+
+attr_parsing_unused_multiple =
+    multiple `{$name}` attributes
+    .suggestion = remove this attribute
+    .note = attribute also specified here
diff --git a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
index 13d246b08a8f..d37ede86cfd2 100644
--- a/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/allow_unstable.rs
@@ -1,49 +1,67 @@
-use rustc_ast::attr::{AttributeExt, filter_by_name};
-use rustc_session::Session;
-use rustc_span::{Symbol, sym};
+use std::iter;
 
+use rustc_attr_data_structures::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+
+use super::{CombineAttributeParser, ConvertFn};
+use crate::context::AcceptContext;
+use crate::parser::ArgParser;
 use crate::session_diagnostics;
 
-pub fn allow_internal_unstable(
-    sess: &Session,
-    attrs: &[impl AttributeExt],
-) -> impl Iterator<Item = Symbol> {
-    allow_unstable(sess, attrs, sym::allow_internal_unstable)
+pub(crate) struct AllowInternalUnstableParser;
+impl CombineAttributeParser for AllowInternalUnstableParser {
+    const PATH: &'static [rustc_span::Symbol] = &[sym::allow_internal_unstable];
+    type Item = (Symbol, Span);
+    const CONVERT: ConvertFn<Self::Item> = AttributeKind::AllowInternalUnstable;
+
+    fn extend<'a>(
+        cx: &'a AcceptContext<'a>,
+        args: &'a ArgParser<'a>,
+    ) -> impl IntoIterator<Item = Self::Item> + 'a {
+        parse_unstable(cx, args, Self::PATH[0]).into_iter().zip(iter::repeat(cx.attr_span))
+    }
 }
 
-pub fn rustc_allow_const_fn_unstable(
-    sess: &Session,
-    attrs: &[impl AttributeExt],
-) -> impl Iterator<Item = Symbol> {
-    allow_unstable(sess, attrs, sym::rustc_allow_const_fn_unstable)
+pub(crate) struct AllowConstFnUnstableParser;
+impl CombineAttributeParser for AllowConstFnUnstableParser {
+    const PATH: &'static [rustc_span::Symbol] = &[sym::rustc_allow_const_fn_unstable];
+    type Item = Symbol;
+    const CONVERT: ConvertFn<Self::Item> = AttributeKind::AllowConstFnUnstable;
+
+    fn extend<'a>(
+        cx: &'a AcceptContext<'a>,
+        args: &'a ArgParser<'a>,
+    ) -> impl IntoIterator<Item = Self::Item> + 'a {
+        parse_unstable(cx, args, Self::PATH[0])
+    }
 }
 
-fn allow_unstable(
-    sess: &Session,
-    attrs: &[impl AttributeExt],
+fn parse_unstable<'a>(
+    cx: &AcceptContext<'_>,
+    args: &'a ArgParser<'a>,
     symbol: Symbol,
-) -> impl Iterator<Item = Symbol> {
-    let attrs = filter_by_name(attrs, symbol);
-    let list = attrs
-        .filter_map(move |attr| {
-            attr.meta_item_list().or_else(|| {
-                sess.dcx().emit_err(session_diagnostics::ExpectsFeatureList {
-                    span: attr.span(),
-                    name: symbol.to_ident_string(),
-                });
-                None
-            })
-        })
-        .flatten();
+) -> impl IntoIterator<Item = Symbol> {
+    let mut res = Vec::new();
 
-    list.into_iter().filter_map(move |it| {
-        let name = it.ident().map(|ident| ident.name);
-        if name.is_none() {
-            sess.dcx().emit_err(session_diagnostics::ExpectsFeatures {
-                span: it.span(),
+    let Some(list) = args.list() else {
+        cx.emit_err(session_diagnostics::ExpectsFeatureList {
+            span: cx.attr_span,
+            name: symbol.to_ident_string(),
+        });
+        return res;
+    };
+
+    for param in list.mixed() {
+        let param_span = param.span();
+        if let Some(ident) = param.meta_item().and_then(|i| i.word_without_args()) {
+            res.push(ident.name);
+        } else {
+            cx.emit_err(session_diagnostics::ExpectsFeatures {
+                span: param_span,
                 name: symbol.to_ident_string(),
             });
         }
-        name
-    })
+    }
+
+    res
 }
diff --git a/compiler/rustc_attr_parsing/src/attributes/cfg.rs b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
index bb9aaaa2fea9..0d6d521b40c6 100644
--- a/compiler/rustc_attr_parsing/src/attributes/cfg.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/cfg.rs
@@ -1,6 +1,4 @@
-//! Parsing and validation of builtin attributes
-
-use rustc_ast::{self as ast, LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NodeId};
+use rustc_ast::{LitKind, MetaItem, MetaItemInner, MetaItemKind, MetaItemLit, NodeId};
 use rustc_ast_pretty::pprust;
 use rustc_attr_data_structures::RustcVersion;
 use rustc_feature::{Features, GatedCfg, find_gated_cfg};
@@ -9,10 +7,11 @@ use rustc_session::config::ExpectedValues;
 use rustc_session::lint::BuiltinLintDiag;
 use rustc_session::lint::builtin::UNEXPECTED_CFGS;
 use rustc_session::parse::feature_err;
-use rustc_span::{Span, Symbol, kw, sym};
+use rustc_span::symbol::kw;
+use rustc_span::{Span, Symbol, sym};
 
-use crate::util::UnsupportedLiteralReason;
-use crate::{fluent_generated, parse_version, session_diagnostics};
+use crate::session_diagnostics::{self, UnsupportedLiteralReason};
+use crate::{fluent_generated, parse_version};
 
 #[derive(Clone, Debug)]
 pub struct Condition {
@@ -25,7 +24,7 @@ pub struct Condition {
 
 /// Tests if a cfg-pattern matches the cfg set
 pub fn cfg_matches(
-    cfg: &ast::MetaItemInner,
+    cfg: &MetaItemInner,
     sess: &Session,
     lint_node_id: NodeId,
     features: Option<&Features>,
@@ -80,7 +79,7 @@ fn gate_cfg(gated_cfg: &GatedCfg, cfg_span: Span, sess: &Session, features: &Fea
 /// Evaluate a cfg-like condition (with `any` and `all`), using `eval` to
 /// evaluate individual items.
 pub fn eval_condition(
-    cfg: &ast::MetaItemInner,
+    cfg: &MetaItemInner,
     sess: &Session,
     features: Option<&Features>,
     eval: &mut impl FnMut(Condition) -> bool,
@@ -88,8 +87,8 @@ pub fn eval_condition(
     let dcx = sess.dcx();
 
     let cfg = match cfg {
-        ast::MetaItemInner::MetaItem(meta_item) => meta_item,
-        ast::MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(b), .. }) => {
+        MetaItemInner::MetaItem(meta_item) => meta_item,
+        MetaItemInner::Lit(MetaItemLit { kind: LitKind::Bool(b), .. }) => {
             if let Some(features) = features {
                 // we can't use `try_gate_cfg` as symbols don't differentiate between `r#true`
                 // and `true`, and we want to keep the former working without feature gate
@@ -118,7 +117,7 @@ pub fn eval_condition(
     };
 
     match &cfg.kind {
-        ast::MetaItemKind::List(mis) if cfg.name_or_empty() == sym::version => {
+        MetaItemKind::List(mis) if cfg.name_or_empty() == sym::version => {
             try_gate_cfg(sym::version, cfg.span, sess, features);
             let (min_version, span) = match &mis[..] {
                 [MetaItemInner::Lit(MetaItemLit { kind: LitKind::Str(sym, ..), span, .. })] => {
@@ -150,7 +149,7 @@ pub fn eval_condition(
                 RustcVersion::CURRENT >= min_version
             }
         }
-        ast::MetaItemKind::List(mis) => {
+        MetaItemKind::List(mis) => {
             for mi in mis.iter() {
                 if mi.meta_item_or_bool().is_none() {
                     dcx.emit_err(session_diagnostics::UnsupportedLiteral {
@@ -209,12 +208,7 @@ pub fn eval_condition(
                             seg.ident.name = Symbol::intern(&format!("target_{}", seg.ident.name));
                         }
 
-                        res & eval_condition(
-                            &ast::MetaItemInner::MetaItem(mi),
-                            sess,
-                            features,
-                            eval,
-                        )
+                        res & eval_condition(&MetaItemInner::MetaItem(mi), sess, features, eval)
                     })
                 }
                 _ => {
@@ -226,7 +220,7 @@ pub fn eval_condition(
                 }
             }
         }
-        ast::MetaItemKind::Word | MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {
+        MetaItemKind::Word | MetaItemKind::NameValue(..) if cfg.path.segments.len() != 1 => {
             dcx.emit_err(session_diagnostics::CfgPredicateIdentifier { span: cfg.path.span });
             true
         }
@@ -239,7 +233,7 @@ pub fn eval_condition(
             });
             true
         }
-        ast::MetaItemKind::Word | ast::MetaItemKind::NameValue(..) => {
+        MetaItemKind::Word | MetaItemKind::NameValue(..) => {
             let ident = cfg.ident().expect("multi-segment cfg predicate");
             eval(Condition {
                 name: ident.name,
diff --git a/compiler/rustc_attr_parsing/src/attributes/confusables.rs b/compiler/rustc_attr_parsing/src/attributes/confusables.rs
index 2ced759fd888..6cff952fcf22 100644
--- a/compiler/rustc_attr_parsing/src/attributes/confusables.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/confusables.rs
@@ -1,21 +1,58 @@
-//! Parsing and validation of builtin attributes
+use rustc_attr_data_structures::AttributeKind;
+use rustc_span::{Span, Symbol, sym};
+use thin_vec::ThinVec;
 
-use rustc_ast::MetaItemInner;
-use rustc_ast::attr::AttributeExt;
-use rustc_span::Symbol;
+use super::{AcceptMapping, AttributeParser};
+use crate::context::FinalizeContext;
+use crate::session_diagnostics;
 
-/// Read the content of a `rustc_confusables` attribute, and return the list of candidate names.
-pub fn parse_confusables(attr: &impl AttributeExt) -> Option<Vec<Symbol>> {
-    let metas = attr.meta_item_list()?;
-
-    let mut candidates = Vec::new();
-
-    for meta in metas {
-        let MetaItemInner::Lit(meta_lit) = meta else {
-            return None;
-        };
-        candidates.push(meta_lit.symbol);
-    }
-
-    Some(candidates)
+#[derive(Default)]
+pub(crate) struct ConfusablesParser {
+    confusables: ThinVec<Symbol>,
+    first_span: Option<Span>,
+}
+
+impl AttributeParser for ConfusablesParser {
+    const ATTRIBUTES: AcceptMapping<Self> = &[(&[sym::rustc_confusables], |this, cx, args| {
+        let Some(list) = args.list() else {
+            // FIXME(jdonszelmann): error when not a list? Bring validation code here.
+            //       NOTE: currently subsequent attributes are silently ignored using
+            //       tcx.get_attr().
+            return;
+        };
+
+        if list.is_empty() {
+            cx.emit_err(session_diagnostics::EmptyConfusables { span: cx.attr_span });
+        }
+
+        for param in list.mixed() {
+            let span = param.span();
+
+            let Some(lit) = param.lit() else {
+                cx.emit_err(session_diagnostics::IncorrectMetaItem {
+                    span,
+                    suggestion: Some(session_diagnostics::IncorrectMetaItemSuggestion {
+                        lo: span.shrink_to_lo(),
+                        hi: span.shrink_to_hi(),
+                    }),
+                });
+                continue;
+            };
+
+            this.confusables.push(lit.symbol);
+        }
+
+        this.first_span.get_or_insert(cx.attr_span);
+    })];
+
+    fn finalize(self, _cx: &FinalizeContext<'_>) -> Option<AttributeKind> {
+        if self.confusables.is_empty() {
+            return None;
+        }
+
+        Some(AttributeKind::Confusables {
+            symbols: self.confusables,
+            first_span: self.first_span.unwrap(),
+        })
+    }
 }
diff --git a/compiler/rustc_attr_parsing/src/attributes/deprecation.rs b/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
index d7415a7198fd..7d1417446b21 100644
--- a/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/deprecation.rs
@@ -1,121 +1,122 @@
-//! Parsing and validation of builtin attributes
-
-use rustc_ast::attr::AttributeExt;
-use rustc_ast::{MetaItem, MetaItemInner};
-use rustc_ast_pretty::pprust;
-use rustc_attr_data_structures::{DeprecatedSince, Deprecation};
-use rustc_feature::Features;
-use rustc_session::Session;
+use rustc_attr_data_structures::{AttributeKind, DeprecatedSince, Deprecation};
+use rustc_span::symbol::Ident;
 use rustc_span::{Span, Symbol, sym};
 
-use super::util::UnsupportedLiteralReason;
-use crate::{parse_version, session_diagnostics};
+use super::SingleAttributeParser;
+use super::util::parse_version;
+use crate::context::AcceptContext;
+use crate::parser::ArgParser;
+use crate::session_diagnostics;
+use crate::session_diagnostics::UnsupportedLiteralReason;
 
-/// Finds the deprecation attribute. `None` if none exists.
-pub fn find_deprecation(
-    sess: &Session,
-    features: &Features,
-    attrs: &[impl AttributeExt],
-) -> Option<(Deprecation, Span)> {
-    let mut depr: Option<(Deprecation, Span)> = None;
-    let is_rustc = features.staged_api();
+pub(crate) struct DeprecationParser;
 
-    'outer: for attr in attrs {
-        if !attr.has_name(sym::deprecated) {
-            continue;
+fn get(
+    cx: &AcceptContext<'_>,
+    ident: Ident,
+    param_span: Span,
+    arg: &ArgParser<'_>,
+    item: &Option<Symbol>,
+) -> Option<Symbol> {
+    if item.is_some() {
+        cx.emit_err(session_diagnostics::MultipleItem {
+            span: param_span,
+            item: ident.to_string(),
+        });
+        return None;
+    }
+    if let Some(v) = arg.name_value() {
+        if let Some(value_str) = v.value_as_str() {
+            Some(value_str)
+        } else {
+            let lit = v.value_as_lit();
+            cx.emit_err(session_diagnostics::UnsupportedLiteral {
+                span: v.value_span,
+                reason: UnsupportedLiteralReason::DeprecatedString,
+                is_bytestr: lit.kind.is_bytestr(),
+                start_point_span: cx.sess().source_map().start_point(lit.span),
+            });
+            None
         }
+    } else {
+        // FIXME(jdonszelmann): suggestion?
+        cx.emit_err(session_diagnostics::IncorrectMetaItem { span: param_span, suggestion: None });
+        None
+    }
+}
+
+impl SingleAttributeParser for DeprecationParser {
+    const PATH: &'static [rustc_span::Symbol] = &[sym::deprecated];
+
+    fn on_duplicate(cx: &AcceptContext<'_>, first_span: rustc_span::Span) {
+        // FIXME(jdonszelmann): merge with errors from check_attrs.rs
+        cx.emit_err(session_diagnostics::UnusedMultiple {
+            this: cx.attr_span,
+            other: first_span,
+            name: sym::deprecated,
+        });
+    }
+
+    fn convert(cx: &AcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        let features = cx.features();
 
         let mut since = None;
         let mut note = None;
         let mut suggestion = None;
 
-        if attr.is_doc_comment() {
-            continue;
-        } else if attr.is_word() {
-        } else if let Some(value) = attr.value_str() {
-            note = Some(value)
-        } else if let Some(list) = attr.meta_item_list() {
-            let get = |meta: &MetaItem, item: &mut Option<Symbol>| {
-                if item.is_some() {
-                    sess.dcx().emit_err(session_diagnostics::MultipleItem {
-                        span: meta.span,
-                        item: pprust::path_to_string(&meta.path),
+        let is_rustc = features.staged_api();
+
+        if let Some(value) = args.name_value()
+            && let Some(value_str) = value.value_as_str()
+        {
+            note = Some(value_str)
+        } else if let Some(list) = args.list() {
+            for param in list.mixed() {
+                let param_span = param.span();
+                let Some(param) = param.meta_item() else {
+                    cx.emit_err(session_diagnostics::UnsupportedLiteral {
+                        span: param_span,
+                        reason: UnsupportedLiteralReason::DeprecatedKvPair,
+                        is_bytestr: false,
+                        start_point_span: cx.sess().source_map().start_point(param_span),
                     });
-                    return false;
-                }
-                if let Some(v) = meta.value_str() {
-                    *item = Some(v);
-                    true
-                } else {
-                    if let Some(lit) = meta.name_value_literal() {
-                        sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
-                            span: lit.span,
-                            reason: UnsupportedLiteralReason::DeprecatedString,
-                            is_bytestr: lit.kind.is_bytestr(),
-                            start_point_span: sess.source_map().start_point(lit.span),
-                        });
-                    } else {
-                        sess.dcx()
-                            .emit_err(session_diagnostics::IncorrectMetaItem { span: meta.span });
+                    return None;
+                };
+
+                let (ident, arg) = param.word_or_empty();
+
+                match ident.name {
+                    sym::since => {
+                        since = Some(get(cx, ident, param_span, arg, &since)?);
                     }
-                    false
-                }
-            };
-
-            for meta in &list {
-                match meta {
-                    MetaItemInner::MetaItem(mi) => match mi.name_or_empty() {
-                        sym::since => {
-                            if !get(mi, &mut since) {
-                                continue 'outer;
-                            }
-                        }
-                        sym::note => {
-                            if !get(mi, &mut note) {
-                                continue 'outer;
-                            }
-                        }
-                        sym::suggestion => {
-                            if !features.deprecated_suggestion() {
-                                sess.dcx().emit_err(
-                                    session_diagnostics::DeprecatedItemSuggestion {
-                                        span: mi.span,
-                                        is_nightly: sess.is_nightly_build(),
-                                        details: (),
-                                    },
-                                );
-                            }
-
-                            if !get(mi, &mut suggestion) {
-                                continue 'outer;
-                            }
-                        }
-                        _ => {
-                            sess.dcx().emit_err(session_diagnostics::UnknownMetaItem {
-                                span: meta.span(),
-                                item: pprust::path_to_string(&mi.path),
-                                expected: if features.deprecated_suggestion() {
-                                    &["since", "note", "suggestion"]
-                                } else {
-                                    &["since", "note"]
-                                },
+                    sym::note => {
+                        note = Some(get(cx, ident, param_span, arg, &note)?);
+                    }
+                    sym::suggestion => {
+                        if !features.deprecated_suggestion() {
+                            cx.emit_err(session_diagnostics::DeprecatedItemSuggestion {
+                                span: param_span,
+                                is_nightly: cx.sess().is_nightly_build(),
+                                details: (),
                             });
-                            continue 'outer;
                         }
-                    },
-                    MetaItemInner::Lit(lit) => {
-                        sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
-                            span: lit.span,
-                            reason: UnsupportedLiteralReason::DeprecatedKvPair,
-                            is_bytestr: false,
-                            start_point_span: sess.source_map().start_point(lit.span),
+
+                        suggestion = Some(get(cx, ident, param_span, arg, &suggestion)?);
+                    }
+                    _ => {
+                        cx.emit_err(session_diagnostics::UnknownMetaItem {
+                            span: param_span,
+                            item: ident.to_string(),
+                            expected: if features.deprecated_suggestion() {
+                                &["since", "note", "suggestion"]
+                            } else {
+                                &["since", "note"]
+                            },
                         });
-                        continue 'outer;
+                        return None;
                     }
                 }
             }
-        } else {
-            continue;
         }
 
         let since = if let Some(since) = since {
@@ -126,23 +127,24 @@ pub fn find_deprecation(
             } else if let Some(version) = parse_version(since) {
                 DeprecatedSince::RustcVersion(version)
             } else {
-                sess.dcx().emit_err(session_diagnostics::InvalidSince { span: attr.span() });
+                cx.emit_err(session_diagnostics::InvalidSince { span: cx.attr_span });
                 DeprecatedSince::Err
             }
         } else if is_rustc {
-            sess.dcx().emit_err(session_diagnostics::MissingSince { span: attr.span() });
+            cx.emit_err(session_diagnostics::MissingSince { span: cx.attr_span });
             DeprecatedSince::Err
         } else {
             DeprecatedSince::Unspecified
         };
 
         if is_rustc && note.is_none() {
-            sess.dcx().emit_err(session_diagnostics::MissingNote { span: attr.span() });
-            continue;
+            cx.emit_err(session_diagnostics::MissingNote { span: cx.attr_span });
+            return None;
         }
 
-        depr = Some((Deprecation { since, note, suggestion }, attr.span()));
+        Some(AttributeKind::Deprecation {
+            deprecation: Deprecation { since, note, suggestion },
+            span: cx.attr_span,
+        })
     }
-
-    depr
 }
diff --git a/compiler/rustc_attr_parsing/src/attributes/mod.rs b/compiler/rustc_attr_parsing/src/attributes/mod.rs
index a78e0b54b64a..6ecd6b4d7dbb 100644
--- a/compiler/rustc_attr_parsing/src/attributes/mod.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/mod.rs
@@ -1,17 +1,152 @@
-mod allow_unstable;
-mod cfg;
-mod confusables;
-mod deprecation;
-mod repr;
-mod stability;
-mod transparency;
+//! This module defines traits for attribute parsers, little state machines that recognize and parse
+//! attributes out of a longer list of attributes. The main trait is called [`AttributeParser`].
+//! You can find more docs about [`AttributeParser`]s on the trait itself.
+//! However, for many types of attributes, implementing [`AttributeParser`] is not necessary.
+//! It allows for a lot of flexibility you might not want.
+//!
+//! Specifically, you might not care about managing the state of your [`AttributeParser`]
+//! state machine yourself. In this case you can choose to implement:
+//!
+//! - [`SingleAttributeParser`]: makes it easy to implement an attribute which should error if it
+//! appears more than once in a list of attributes
+//! - [`CombineAttributeParser`]: makes it easy to implement an attribute which should combine the
+//! contents of attributes, if an attribute appear multiple times in a list
+//!
+//! Attributes should be added to [`ATTRIBUTE_MAPPING`](crate::context::ATTRIBUTE_MAPPING) to be parsed.
 
-pub mod util;
+use std::marker::PhantomData;
 
-pub use allow_unstable::*;
-pub use cfg::*;
-pub use confusables::*;
-pub use deprecation::*;
-pub use repr::*;
-pub use stability::*;
-pub use transparency::*;
+use rustc_attr_data_structures::AttributeKind;
+use rustc_span::Span;
+use thin_vec::ThinVec;
+
+use crate::context::{AcceptContext, FinalizeContext};
+use crate::parser::ArgParser;
+
+pub(crate) mod allow_unstable;
+pub(crate) mod cfg;
+pub(crate) mod confusables;
+pub(crate) mod deprecation;
+pub(crate) mod repr;
+pub(crate) mod stability;
+pub(crate) mod transparency;
+pub(crate) mod util;
+
+type AcceptFn<T> = fn(&mut T, &AcceptContext<'_>, &ArgParser<'_>);
+type AcceptMapping<T> = &'static [(&'static [rustc_span::Symbol], AcceptFn<T>)];
+
+/// An [`AttributeParser`] is a type which searches for syntactic attributes.
+///
+/// Parsers are often tiny state machines that gets to see all syntactical attributes on an item.
+/// [`Default::default`] creates a fresh instance that sits in some kind of initial state, usually that the
+/// attribute it is looking for was not yet seen.
+///
+/// Then, it defines what paths this group will accept in [`AttributeParser::ATTRIBUTES`].
+/// These are listed as pairs, of symbols and function pointers. The function pointer will
+/// be called when that attribute is found on an item, which can influence the state of the little
+/// state machine.
+///
+/// Finally, after all attributes on an item have been seen, and possibly been accepted,
+/// the [`finalize`](AttributeParser::finalize) functions for all attribute parsers are called. Each can then report
+/// whether it has seen the attribute it has been looking for.
+///
+/// The state machine is automatically reset to parse attributes on the next item.
+pub(crate) trait AttributeParser: Default + 'static {
+    /// The symbols for the attributes that this parser is interested in.
+    ///
+    /// If an attribute has this symbol, the `accept` function will be called on it.
+    const ATTRIBUTES: AcceptMapping<Self>;
+
+    /// The parser has gotten a chance to accept the attributes on an item,
+    /// here it can produce an attribute.
+    fn finalize(self, cx: &FinalizeContext<'_>) -> Option<AttributeKind>;
+}
+
+/// Alternative to [`AttributeParser`] that automatically handles state management.
+/// A slightly simpler and more restricted way to convert attributes.
+/// Assumes that an attribute can only appear a single time on an item,
+/// and errors when it sees more.
+///
+/// [`Single<T> where T: SingleAttributeParser`](Single) implements [`AttributeParser`].
+///
+/// [`SingleAttributeParser`] can only convert attributes one-to-one, and cannot combine multiple
+/// attributes together like is necessary for `#[stable()]` and `#[unstable()]` for example.
+pub(crate) trait SingleAttributeParser: 'static {
+    const PATH: &'static [rustc_span::Symbol];
+
+    /// Caled when a duplicate attribute is found.
+    ///
+    /// `first_span` is the span of the first occurrence of this attribute.
+    // FIXME(jdonszelmann): default error
+    fn on_duplicate(cx: &AcceptContext<'_>, first_span: Span);
+
+    /// Converts a single syntactical attribute to a single semantic attribute, or [`AttributeKind`]
+    fn convert(cx: &AcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind>;
+}
+
+pub(crate) struct Single<T: SingleAttributeParser>(PhantomData<T>, Option<(AttributeKind, Span)>);
+
+impl<T: SingleAttributeParser> Default for Single<T> {
+    fn default() -> Self {
+        Self(Default::default(), Default::default())
+    }
+}
+
+impl<T: SingleAttributeParser> AttributeParser for Single<T> {
+    const ATTRIBUTES: AcceptMapping<Self> = &[(T::PATH, |group: &mut Single<T>, cx, args| {
+        if let Some((_, s)) = group.1 {
+            T::on_duplicate(cx, s);
+            return;
+        }
+
+        if let Some(pa) = T::convert(cx, args) {
+            group.1 = Some((pa, cx.attr_span));
+        }
+    })];
+
+    fn finalize(self, _cx: &FinalizeContext<'_>) -> Option<AttributeKind> {
+        Some(self.1?.0)
+    }
+}
+
+type ConvertFn<E> = fn(ThinVec<E>) -> AttributeKind;
+
+/// Alternative to [`AttributeParser`] that automatically handles state management.
+/// If multiple attributes appear on an element, combines the values of each into a
+/// [`ThinVec`].
+/// [`Combine<T> where T: CombineAttributeParser`](Combine) implements [`AttributeParser`].
+///
+/// [`CombineAttributeParser`] can only convert a single kind of attribute, and cannot combine multiple
+/// attributes together like is necessary for `#[stable()]` and `#[unstable()]` for example.
+pub(crate) trait CombineAttributeParser: 'static {
+    const PATH: &'static [rustc_span::Symbol];
+
+    type Item;
+    const CONVERT: ConvertFn<Self::Item>;
+
+    /// Converts a single syntactical attribute to a number of elements of the semantic attribute, or [`AttributeKind`]
+    fn extend<'a>(
+        cx: &'a AcceptContext<'a>,
+        args: &'a ArgParser<'a>,
+    ) -> impl IntoIterator<Item = Self::Item> + 'a;
+}
+
+pub(crate) struct Combine<T: CombineAttributeParser>(
+    PhantomData<T>,
+    ThinVec<<T as CombineAttributeParser>::Item>,
+);
+
+impl<T: CombineAttributeParser> Default for Combine<T> {
+    fn default() -> Self {
+        Self(Default::default(), Default::default())
+    }
+}
+
+impl<T: CombineAttributeParser> AttributeParser for Combine<T> {
+    const ATTRIBUTES: AcceptMapping<Self> =
+        &[(T::PATH, |group: &mut Combine<T>, cx, args| group.1.extend(T::extend(cx, args)))];
+
+    fn finalize(self, _cx: &FinalizeContext<'_>) -> Option<AttributeKind> {
+        if self.1.is_empty() { None } else { Some(T::CONVERT(self.1)) }
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/attributes/repr.rs b/compiler/rustc_attr_parsing/src/attributes/repr.rs
index 28c381160b87..26ca637faec6 100644
--- a/compiler/rustc_attr_parsing/src/attributes/repr.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/repr.rs
@@ -1,15 +1,13 @@
-//! Parsing and validation of builtin attributes
-
 use rustc_abi::Align;
-use rustc_ast::attr::AttributeExt;
-use rustc_ast::{self as ast, MetaItemKind};
-use rustc_attr_data_structures::IntType;
-use rustc_attr_data_structures::ReprAttr::*;
-use rustc_session::Session;
-use rustc_span::{Symbol, sym};
+use rustc_ast::{IntTy, LitIntType, LitKind, UintTy};
+use rustc_attr_data_structures::{AttributeKind, IntType, ReprAttr};
+use rustc_span::{Span, Symbol, sym};
 
-use crate::ReprAttr;
-use crate::session_diagnostics::{self, IncorrectReprFormatGenericCause};
+use super::{CombineAttributeParser, ConvertFn};
+use crate::context::AcceptContext;
+use crate::parser::{ArgParser, MetaItemListParser, MetaItemParser};
+use crate::session_diagnostics;
+use crate::session_diagnostics::IncorrectReprFormatGenericCause;
 
 /// Parse #[repr(...)] forms.
 ///
@@ -18,185 +16,216 @@ use crate::session_diagnostics::{self, IncorrectReprFormatGenericCause};
 /// the same discriminant size that the corresponding C enum would or C
 /// structure layout, `packed` to remove padding, and `transparent` to delegate representation
 /// concerns to the only non-ZST field.
-pub fn find_repr_attrs(sess: &Session, attr: &impl AttributeExt) -> Vec<ReprAttr> {
-    if attr.has_name(sym::repr) { parse_repr_attr(sess, attr) } else { Vec::new() }
+// FIXME(jdonszelmann): is a vec the right representation here even? isn't it just a struct?
+pub(crate) struct ReprParser;
+
+impl CombineAttributeParser for ReprParser {
+    type Item = (ReprAttr, Span);
+    const PATH: &'static [rustc_span::Symbol] = &[sym::repr];
+    const CONVERT: ConvertFn<Self::Item> = AttributeKind::Repr;
+
+    fn extend<'a>(
+        cx: &'a AcceptContext<'a>,
+        args: &'a ArgParser<'a>,
+    ) -> impl IntoIterator<Item = Self::Item> + 'a {
+        let mut reprs = Vec::new();
+
+        let Some(list) = args.list() else {
+            return reprs;
+        };
+
+        if list.is_empty() {
+            // this is so validation can emit a lint
+            reprs.push((ReprAttr::ReprEmpty, cx.attr_span));
+        }
+
+        for param in list.mixed() {
+            if let Some(_) = param.lit() {
+                cx.emit_err(session_diagnostics::ReprIdent { span: cx.attr_span });
+                continue;
+            }
+
+            reprs.extend(
+                param.meta_item().and_then(|mi| parse_repr(cx, &mi)).map(|r| (r, param.span())),
+            );
+        }
+
+        reprs
+    }
 }
 
-pub fn parse_repr_attr(sess: &Session, attr: &impl AttributeExt) -> Vec<ReprAttr> {
-    assert!(attr.has_name(sym::repr), "expected `#[repr(..)]`, found: {attr:?}");
-    let mut acc = Vec::new();
-    let dcx = sess.dcx();
-
-    if let Some(items) = attr.meta_item_list() {
-        for item in items {
-            let mut recognised = false;
-            if item.is_word() {
-                let hint = match item.name_or_empty() {
-                    sym::Rust => Some(ReprRust),
-                    sym::C => Some(ReprC),
-                    sym::packed => Some(ReprPacked(Align::ONE)),
-                    sym::simd => Some(ReprSimd),
-                    sym::transparent => Some(ReprTransparent),
-                    sym::align => {
-                        sess.dcx().emit_err(session_diagnostics::InvalidReprAlignNeedArg {
-                            span: item.span(),
-                        });
-                        recognised = true;
-                        None
-                    }
-                    name => int_type_of_word(name).map(ReprInt),
-                };
-
-                if let Some(h) = hint {
-                    recognised = true;
-                    acc.push(h);
-                }
-            } else if let Some((name, value)) = item.singleton_lit_list() {
-                let mut literal_error = None;
-                let mut err_span = item.span();
-                if name == sym::align {
-                    recognised = true;
-                    match parse_alignment(&value.kind) {
-                        Ok(literal) => acc.push(ReprAlign(literal)),
-                        Err(message) => {
-                            err_span = value.span;
-                            literal_error = Some(message)
-                        }
-                    };
-                } else if name == sym::packed {
-                    recognised = true;
-                    match parse_alignment(&value.kind) {
-                        Ok(literal) => acc.push(ReprPacked(literal)),
-                        Err(message) => {
-                            err_span = value.span;
-                            literal_error = Some(message)
-                        }
-                    };
-                } else if matches!(name, sym::Rust | sym::C | sym::simd | sym::transparent)
-                    || int_type_of_word(name).is_some()
-                {
-                    recognised = true;
-                    sess.dcx().emit_err(session_diagnostics::InvalidReprHintNoParen {
-                        span: item.span(),
-                        name: name.to_ident_string(),
-                    });
-                }
-                if let Some(literal_error) = literal_error {
-                    sess.dcx().emit_err(session_diagnostics::InvalidReprGeneric {
-                        span: err_span,
-                        repr_arg: name.to_ident_string(),
-                        error_part: literal_error,
-                    });
-                }
-            } else if let Some(meta_item) = item.meta_item() {
-                match &meta_item.kind {
-                    MetaItemKind::NameValue(value) => {
-                        if meta_item.has_name(sym::align) || meta_item.has_name(sym::packed) {
-                            let name = meta_item.name_or_empty().to_ident_string();
-                            recognised = true;
-                            sess.dcx().emit_err(session_diagnostics::IncorrectReprFormatGeneric {
-                                span: item.span(),
-                                repr_arg: &name,
-                                cause: IncorrectReprFormatGenericCause::from_lit_kind(
-                                    item.span(),
-                                    &value.kind,
-                                    &name,
-                                ),
-                            });
-                        } else if matches!(
-                            meta_item.name_or_empty(),
-                            sym::Rust | sym::C | sym::simd | sym::transparent
-                        ) || int_type_of_word(meta_item.name_or_empty()).is_some()
-                        {
-                            recognised = true;
-                            sess.dcx().emit_err(session_diagnostics::InvalidReprHintNoValue {
-                                span: meta_item.span,
-                                name: meta_item.name_or_empty().to_ident_string(),
-                            });
-                        }
-                    }
-                    MetaItemKind::List(nested_items) => {
-                        if meta_item.has_name(sym::align) {
-                            recognised = true;
-                            if let [nested_item] = nested_items.as_slice() {
-                                sess.dcx().emit_err(
-                                    session_diagnostics::IncorrectReprFormatExpectInteger {
-                                        span: nested_item.span(),
-                                    },
-                                );
-                            } else {
-                                sess.dcx().emit_err(
-                                    session_diagnostics::IncorrectReprFormatAlignOneArg {
-                                        span: meta_item.span,
-                                    },
-                                );
-                            }
-                        } else if meta_item.has_name(sym::packed) {
-                            recognised = true;
-                            if let [nested_item] = nested_items.as_slice() {
-                                sess.dcx().emit_err(
-                                    session_diagnostics::IncorrectReprFormatPackedExpectInteger {
-                                        span: nested_item.span(),
-                                    },
-                                );
-                            } else {
-                                sess.dcx().emit_err(
-                                    session_diagnostics::IncorrectReprFormatPackedOneOrZeroArg {
-                                        span: meta_item.span,
-                                    },
-                                );
-                            }
-                        } else if matches!(
-                            meta_item.name_or_empty(),
-                            sym::Rust | sym::C | sym::simd | sym::transparent
-                        ) || int_type_of_word(meta_item.name_or_empty()).is_some()
-                        {
-                            recognised = true;
-                            sess.dcx().emit_err(session_diagnostics::InvalidReprHintNoParen {
-                                span: meta_item.span,
-                                name: meta_item.name_or_empty().to_ident_string(),
-                            });
-                        }
-                    }
-                    _ => (),
-                }
-            }
-            if !recognised {
-                // Not a word we recognize. This will be caught and reported by
-                // the `check_mod_attrs` pass, but this pass doesn't always run
-                // (e.g. if we only pretty-print the source), so we have to gate
-                // the `span_delayed_bug` call as follows:
-                if sess.opts.pretty.is_none_or(|pp| pp.needs_analysis()) {
-                    dcx.span_delayed_bug(item.span(), "unrecognized representation hint");
-                }
-            }
-        }
-    }
-    acc
+macro_rules! int_pat {
+    () => {
+        sym::i8
+            | sym::u8
+            | sym::i16
+            | sym::u16
+            | sym::i32
+            | sym::u32
+            | sym::i64
+            | sym::u64
+            | sym::i128
+            | sym::u128
+            | sym::isize
+            | sym::usize
+    };
 }
 
 fn int_type_of_word(s: Symbol) -> Option<IntType> {
-    use rustc_attr_data_structures::IntType::*;
+    use IntType::*;
 
     match s {
-        sym::i8 => Some(SignedInt(ast::IntTy::I8)),
-        sym::u8 => Some(UnsignedInt(ast::UintTy::U8)),
-        sym::i16 => Some(SignedInt(ast::IntTy::I16)),
-        sym::u16 => Some(UnsignedInt(ast::UintTy::U16)),
-        sym::i32 => Some(SignedInt(ast::IntTy::I32)),
-        sym::u32 => Some(UnsignedInt(ast::UintTy::U32)),
-        sym::i64 => Some(SignedInt(ast::IntTy::I64)),
-        sym::u64 => Some(UnsignedInt(ast::UintTy::U64)),
-        sym::i128 => Some(SignedInt(ast::IntTy::I128)),
-        sym::u128 => Some(UnsignedInt(ast::UintTy::U128)),
-        sym::isize => Some(SignedInt(ast::IntTy::Isize)),
-        sym::usize => Some(UnsignedInt(ast::UintTy::Usize)),
+        sym::i8 => Some(SignedInt(IntTy::I8)),
+        sym::u8 => Some(UnsignedInt(UintTy::U8)),
+        sym::i16 => Some(SignedInt(IntTy::I16)),
+        sym::u16 => Some(UnsignedInt(UintTy::U16)),
+        sym::i32 => Some(SignedInt(IntTy::I32)),
+        sym::u32 => Some(UnsignedInt(UintTy::U32)),
+        sym::i64 => Some(SignedInt(IntTy::I64)),
+        sym::u64 => Some(UnsignedInt(UintTy::U64)),
+        sym::i128 => Some(SignedInt(IntTy::I128)),
+        sym::u128 => Some(UnsignedInt(UintTy::U128)),
+        sym::isize => Some(SignedInt(IntTy::Isize)),
+        sym::usize => Some(UnsignedInt(UintTy::Usize)),
         _ => None,
     }
 }
 
-pub fn parse_alignment(node: &ast::LitKind) -> Result<Align, &'static str> {
-    if let ast::LitKind::Int(literal, ast::LitIntType::Unsuffixed) = node {
+fn parse_repr(cx: &AcceptContext<'_>, param: &MetaItemParser<'_>) -> Option<ReprAttr> {
+    use ReprAttr::*;
+
+    // FIXME(jdonszelmann): invert the parsing here to match on the word first and then the
+    // structure.
+    let (ident, args) = param.word_or_empty();
+
+    match (ident.name, args) {
+        (sym::align, ArgParser::NoArgs) => {
+            cx.emit_err(session_diagnostics::InvalidReprAlignNeedArg { span: ident.span });
+            None
+        }
+        (sym::align, ArgParser::List(l)) => parse_repr_align(cx, l, param.span(), AlignKind::Align),
+
+        (sym::packed, ArgParser::NoArgs) => Some(ReprPacked(Align::ONE)),
+        (sym::packed, ArgParser::List(l)) => {
+            parse_repr_align(cx, l, param.span(), AlignKind::Packed)
+        }
+
+        (sym::align | sym::packed, ArgParser::NameValue(l)) => {
+            cx.emit_err(session_diagnostics::IncorrectReprFormatGeneric {
+                span: param.span(),
+                // FIXME(jdonszelmann) can just be a string in the diag type
+                repr_arg: &ident.to_string(),
+                cause: IncorrectReprFormatGenericCause::from_lit_kind(
+                    param.span(),
+                    &l.value_as_lit().kind,
+                    ident.name.as_str(),
+                ),
+            });
+            None
+        }
+
+        (sym::Rust, ArgParser::NoArgs) => Some(ReprRust),
+        (sym::C, ArgParser::NoArgs) => Some(ReprC),
+        (sym::simd, ArgParser::NoArgs) => Some(ReprSimd),
+        (sym::transparent, ArgParser::NoArgs) => Some(ReprTransparent),
+        (i @ int_pat!(), ArgParser::NoArgs) => {
+            // int_pat!() should make sure it always parses
+            Some(ReprInt(int_type_of_word(i).unwrap()))
+        }
+
+        (
+            sym::Rust | sym::C | sym::simd | sym::transparent | int_pat!(),
+            ArgParser::NameValue(_),
+        ) => {
+            cx.emit_err(session_diagnostics::InvalidReprHintNoValue {
+                span: param.span(),
+                name: ident.to_string(),
+            });
+            None
+        }
+        (sym::Rust | sym::C | sym::simd | sym::transparent | int_pat!(), ArgParser::List(_)) => {
+            cx.emit_err(session_diagnostics::InvalidReprHintNoParen {
+                span: param.span(),
+                name: ident.to_string(),
+            });
+            None
+        }
+
+        _ => {
+            cx.emit_err(session_diagnostics::UnrecognizedReprHint { span: param.span() });
+            None
+        }
+    }
+}
+
+enum AlignKind {
+    Packed,
+    Align,
+}
+
+fn parse_repr_align(
+    cx: &AcceptContext<'_>,
+    list: &MetaItemListParser<'_>,
+    param_span: Span,
+    align_kind: AlignKind,
+) -> Option<ReprAttr> {
+    use AlignKind::*;
+
+    let Some(align) = list.single() else {
+        match align_kind {
+            Packed => {
+                cx.emit_err(session_diagnostics::IncorrectReprFormatPackedOneOrZeroArg {
+                    span: param_span,
+                });
+            }
+            Align => {
+                cx.dcx().emit_err(session_diagnostics::IncorrectReprFormatAlignOneArg {
+                    span: param_span,
+                });
+            }
+        }
+
+        return None;
+    };
+
+    let Some(lit) = align.lit() else {
+        match align_kind {
+            Packed => {
+                cx.emit_err(session_diagnostics::IncorrectReprFormatPackedExpectInteger {
+                    span: align.span(),
+                });
+            }
+            Align => {
+                cx.emit_err(session_diagnostics::IncorrectReprFormatExpectInteger {
+                    span: align.span(),
+                });
+            }
+        }
+
+        return None;
+    };
+
+    match parse_alignment(&lit.kind) {
+        Ok(literal) => Some(match align_kind {
+            AlignKind::Packed => ReprAttr::ReprPacked(literal),
+            AlignKind::Align => ReprAttr::ReprAlign(literal),
+        }),
+        Err(message) => {
+            cx.emit_err(session_diagnostics::InvalidReprGeneric {
+                span: lit.span,
+                repr_arg: match align_kind {
+                    Packed => "packed".to_string(),
+                    Align => "align".to_string(),
+                },
+                error_part: message,
+            });
+            None
+        }
+    }
+}
+
+fn parse_alignment(node: &LitKind) -> Result<Align, &'static str> {
+    if let LitKind::Int(literal, LitIntType::Unsuffixed) = node {
         // `Align::from_bytes` accepts 0 as an input, check is_power_of_two() first
         if literal.get().is_power_of_two() {
             // Only possible error is larger than 2^29
diff --git a/compiler/rustc_attr_parsing/src/attributes/stability.rs b/compiler/rustc_attr_parsing/src/attributes/stability.rs
index 454b8b5de82b..6d76456e83c8 100644
--- a/compiler/rustc_attr_parsing/src/attributes/stability.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/stability.rs
@@ -1,266 +1,258 @@
-//! Parsing and validation of builtin attributes
-
 use std::num::NonZero;
 
-use rustc_ast::MetaItem;
-use rustc_ast::attr::AttributeExt;
-use rustc_ast_pretty::pprust;
 use rustc_attr_data_structures::{
-    ConstStability, DefaultBodyStability, Stability, StabilityLevel, StableSince, UnstableReason,
-    VERSION_PLACEHOLDER,
+    AttributeKind, DefaultBodyStability, PartialConstStability, Stability, StabilityLevel,
+    StableSince, UnstableReason, VERSION_PLACEHOLDER,
 };
 use rustc_errors::ErrorGuaranteed;
-use rustc_session::Session;
 use rustc_span::{Span, Symbol, kw, sym};
 
-use crate::attributes::util::UnsupportedLiteralReason;
-use crate::{parse_version, session_diagnostics};
+use super::util::parse_version;
+use super::{AcceptMapping, AttributeParser, SingleAttributeParser};
+use crate::context::{AcceptContext, FinalizeContext};
+use crate::parser::{ArgParser, MetaItemParser};
+use crate::session_diagnostics::{self, UnsupportedLiteralReason};
 
-/// Collects stability info from `stable`/`unstable`/`rustc_allowed_through_unstable_modules`
-/// attributes in `attrs`. Returns `None` if no stability attributes are found.
-pub fn find_stability(
-    sess: &Session,
-    attrs: &[impl AttributeExt],
-    item_sp: Span,
-) -> Option<(Stability, Span)> {
-    let mut stab: Option<(Stability, Span)> = None;
-    let mut allowed_through_unstable_modules = None;
+macro_rules! reject_outside_std {
+    ($cx: ident) => {
+        // Emit errors for non-staged-api crates.
+        if !$cx.features().staged_api() {
+            $cx.emit_err(session_diagnostics::StabilityOutsideStd { span: $cx.attr_span });
+            return;
+        }
+    };
+}
 
-    for attr in attrs {
-        match attr.name_or_empty() {
-            sym::rustc_allowed_through_unstable_modules => {
-                // The value is mandatory, but avoid ICEs in case such code reaches this function.
-                allowed_through_unstable_modules = Some(attr.value_str().unwrap_or_else(|| {
-                    sess.dcx().span_delayed_bug(
-                        item_sp,
-                        "`#[rustc_allowed_through_unstable_modules]` without deprecation message",
-                    );
-                    kw::Empty
-                }))
-            }
-            sym::unstable => {
-                if stab.is_some() {
-                    sess.dcx().emit_err(session_diagnostics::MultipleStabilityLevels {
-                        span: attr.span(),
-                    });
-                    break;
-                }
+#[derive(Default)]
+pub(crate) struct StabilityParser {
+    allowed_through_unstable_modules: Option<Symbol>,
+    stability: Option<(Stability, Span)>,
+}
 
-                if let Some((feature, level)) = parse_unstability(sess, attr) {
-                    stab = Some((Stability { level, feature }, attr.span()));
-                }
-            }
-            sym::stable => {
-                if stab.is_some() {
-                    sess.dcx().emit_err(session_diagnostics::MultipleStabilityLevels {
-                        span: attr.span(),
-                    });
-                    break;
-                }
-                if let Some((feature, level)) = parse_stability(sess, attr) {
-                    stab = Some((Stability { level, feature }, attr.span()));
-                }
-            }
-            _ => {}
+impl StabilityParser {
+    /// Checks, and emits an error when a stability (or unstability) was already set, which would be a duplicate.
+    fn check_duplicate(&self, cx: &AcceptContext<'_>) -> bool {
+        if let Some((_, _)) = self.stability {
+            cx.emit_err(session_diagnostics::MultipleStabilityLevels { span: cx.attr_span });
+            true
+        } else {
+            false
         }
     }
+}
 
-    if let Some(allowed_through_unstable_modules) = allowed_through_unstable_modules {
-        match &mut stab {
-            Some((
+impl AttributeParser for StabilityParser {
+    const ATTRIBUTES: AcceptMapping<Self> = &[
+        (&[sym::stable], |this, cx, args| {
+            reject_outside_std!(cx);
+            if !this.check_duplicate(cx)
+                && let Some((feature, level)) = parse_stability(cx, args)
+            {
+                this.stability = Some((Stability { level, feature }, cx.attr_span));
+            }
+        }),
+        (&[sym::unstable], |this, cx, args| {
+            reject_outside_std!(cx);
+            if !this.check_duplicate(cx)
+                && let Some((feature, level)) = parse_unstability(cx, args)
+            {
+                this.stability = Some((Stability { level, feature }, cx.attr_span));
+            }
+        }),
+        (&[sym::rustc_allowed_through_unstable_modules], |this, cx, args| {
+            reject_outside_std!(cx);
+            this.allowed_through_unstable_modules =
+                Some(match args.name_value().and_then(|i| i.value_as_str()) {
+                    Some(msg) => msg,
+                    None => kw::Empty,
+                });
+        }),
+    ];
+
+    fn finalize(mut self, cx: &FinalizeContext<'_>) -> Option<AttributeKind> {
+        if let Some(atum) = self.allowed_through_unstable_modules {
+            if let Some((
                 Stability {
-                    level: StabilityLevel::Stable { allowed_through_unstable_modules: in_stab, .. },
+                    level: StabilityLevel::Stable { ref mut allowed_through_unstable_modules, .. },
                     ..
                 },
                 _,
-            )) => *in_stab = Some(allowed_through_unstable_modules),
-            _ => {
-                sess.dcx()
-                    .emit_err(session_diagnostics::RustcAllowedUnstablePairing { span: item_sp });
+            )) = self.stability
+            {
+                *allowed_through_unstable_modules = Some(atum);
+            } else {
+                cx.dcx().emit_err(session_diagnostics::RustcAllowedUnstablePairing {
+                    span: cx.target_span,
+                });
             }
         }
-    }
 
-    stab
-}
+        let (stability, span) = self.stability?;
 
-/// Collects stability info from `rustc_const_stable`/`rustc_const_unstable`/`rustc_promotable`
-/// attributes in `attrs`. Returns `None` if no stability attributes are found.
-pub fn find_const_stability(
-    sess: &Session,
-    attrs: &[impl AttributeExt],
-    item_sp: Span,
-) -> Option<(ConstStability, Span)> {
-    let mut const_stab: Option<(ConstStability, Span)> = None;
-    let mut promotable = false;
-    let mut const_stable_indirect = false;
-
-    for attr in attrs {
-        match attr.name_or_empty() {
-            sym::rustc_promotable => promotable = true,
-            sym::rustc_const_stable_indirect => const_stable_indirect = true,
-            sym::rustc_const_unstable => {
-                if const_stab.is_some() {
-                    sess.dcx().emit_err(session_diagnostics::MultipleStabilityLevels {
-                        span: attr.span(),
-                    });
-                    break;
-                }
-
-                if let Some((feature, level)) = parse_unstability(sess, attr) {
-                    const_stab = Some((
-                        ConstStability {
-                            level,
-                            feature,
-                            const_stable_indirect: false,
-                            promotable: false,
-                        },
-                        attr.span(),
-                    ));
-                }
-            }
-            sym::rustc_const_stable => {
-                if const_stab.is_some() {
-                    sess.dcx().emit_err(session_diagnostics::MultipleStabilityLevels {
-                        span: attr.span(),
-                    });
-                    break;
-                }
-                if let Some((feature, level)) = parse_stability(sess, attr) {
-                    const_stab = Some((
-                        ConstStability {
-                            level,
-                            feature,
-                            const_stable_indirect: false,
-                            promotable: false,
-                        },
-                        attr.span(),
-                    ));
-                }
-            }
-            _ => {}
-        }
-    }
-
-    // Merge promotable and const_stable_indirect into stability info
-    if promotable {
-        match &mut const_stab {
-            Some((stab, _)) => stab.promotable = promotable,
-            _ => {
-                _ = sess
-                    .dcx()
-                    .emit_err(session_diagnostics::RustcPromotablePairing { span: item_sp })
-            }
-        }
-    }
-    if const_stable_indirect {
-        match &mut const_stab {
-            Some((stab, _)) => {
-                if stab.is_const_unstable() {
-                    stab.const_stable_indirect = true;
-                } else {
-                    _ = sess.dcx().emit_err(session_diagnostics::RustcConstStableIndirectPairing {
-                        span: item_sp,
-                    })
-                }
-            }
-            _ => {
-                // This function has no const stability attribute, but has `const_stable_indirect`.
-                // We ignore that; unmarked functions are subject to recursive const stability
-                // checks by default so we do carry out the user's intent.
-            }
-        }
-    }
-
-    const_stab
-}
-
-/// Calculates the const stability for a const function in a `-Zforce-unstable-if-unmarked` crate
-/// without the `staged_api` feature.
-pub fn unmarked_crate_const_stab(
-    _sess: &Session,
-    attrs: &[impl AttributeExt],
-    regular_stab: Stability,
-) -> ConstStability {
-    assert!(regular_stab.level.is_unstable());
-    // The only attribute that matters here is `rustc_const_stable_indirect`.
-    // We enforce recursive const stability rules for those functions.
-    let const_stable_indirect =
-        attrs.iter().any(|a| a.name_or_empty() == sym::rustc_const_stable_indirect);
-    ConstStability {
-        feature: regular_stab.feature,
-        const_stable_indirect,
-        promotable: false,
-        level: regular_stab.level,
+        Some(AttributeKind::Stability { stability, span })
     }
 }
 
-/// Collects stability info from `rustc_default_body_unstable` attributes in `attrs`.
-/// Returns `None` if no stability attributes are found.
-pub fn find_body_stability(
-    sess: &Session,
-    attrs: &[impl AttributeExt],
-) -> Option<(DefaultBodyStability, Span)> {
-    let mut body_stab: Option<(DefaultBodyStability, Span)> = None;
-
-    for attr in attrs {
-        if attr.has_name(sym::rustc_default_body_unstable) {
-            if body_stab.is_some() {
-                sess.dcx()
-                    .emit_err(session_diagnostics::MultipleStabilityLevels { span: attr.span() });
-                break;
-            }
-
-            if let Some((feature, level)) = parse_unstability(sess, attr) {
-                body_stab = Some((DefaultBodyStability { level, feature }, attr.span()));
-            }
-        }
-    }
-
-    body_stab
+// FIXME(jdonszelmann) change to Single
+#[derive(Default)]
+pub(crate) struct BodyStabilityParser {
+    stability: Option<(DefaultBodyStability, Span)>,
 }
 
-fn insert_or_error(sess: &Session, meta: &MetaItem, item: &mut Option<Symbol>) -> Option<()> {
+impl AttributeParser for BodyStabilityParser {
+    const ATTRIBUTES: AcceptMapping<Self> =
+        &[(&[sym::rustc_default_body_unstable], |this, cx, args| {
+            reject_outside_std!(cx);
+            if this.stability.is_some() {
+                cx.dcx()
+                    .emit_err(session_diagnostics::MultipleStabilityLevels { span: cx.attr_span });
+            } else if let Some((feature, level)) = parse_unstability(cx, args) {
+                this.stability = Some((DefaultBodyStability { level, feature }, cx.attr_span));
+            }
+        })];
+
+    fn finalize(self, _cx: &FinalizeContext<'_>) -> Option<AttributeKind> {
+        let (stability, span) = self.stability?;
+
+        Some(AttributeKind::BodyStability { stability, span })
+    }
+}
+
+pub(crate) struct ConstStabilityIndirectParser;
+// FIXME(jdonszelmann): single word attribute group when we have these
+impl SingleAttributeParser for ConstStabilityIndirectParser {
+    const PATH: &'static [rustc_span::Symbol] = &[sym::rustc_const_stable_indirect];
+
+    // ignore
+    fn on_duplicate(_cx: &AcceptContext<'_>, _first_span: Span) {}
+
+    fn convert(_cx: &AcceptContext<'_>, _args: &ArgParser<'_>) -> Option<AttributeKind> {
+        Some(AttributeKind::ConstStabilityIndirect)
+    }
+}
+
+#[derive(Default)]
+pub(crate) struct ConstStabilityParser {
+    promotable: bool,
+    stability: Option<(PartialConstStability, Span)>,
+}
+
+impl ConstStabilityParser {
+    /// Checks, and emits an error when a stability (or unstability) was already set, which would be a duplicate.
+    fn check_duplicate(&self, cx: &AcceptContext<'_>) -> bool {
+        if let Some((_, _)) = self.stability {
+            cx.emit_err(session_diagnostics::MultipleStabilityLevels { span: cx.attr_span });
+            true
+        } else {
+            false
+        }
+    }
+}
+
+impl AttributeParser for ConstStabilityParser {
+    const ATTRIBUTES: AcceptMapping<Self> = &[
+        (&[sym::rustc_const_stable], |this, cx, args| {
+            reject_outside_std!(cx);
+
+            if !this.check_duplicate(cx)
+                && let Some((feature, level)) = parse_stability(cx, args)
+            {
+                this.stability = Some((
+                    PartialConstStability { level, feature, promotable: false },
+                    cx.attr_span,
+                ));
+            }
+        }),
+        (&[sym::rustc_const_unstable], |this, cx, args| {
+            reject_outside_std!(cx);
+            if !this.check_duplicate(cx)
+                && let Some((feature, level)) = parse_unstability(cx, args)
+            {
+                this.stability = Some((
+                    PartialConstStability { level, feature, promotable: false },
+                    cx.attr_span,
+                ));
+            }
+        }),
+        (&[sym::rustc_promotable], |this, cx, _| {
+            reject_outside_std!(cx);
+            this.promotable = true;
+        }),
+    ];
+
+    fn finalize(mut self, cx: &FinalizeContext<'_>) -> Option<AttributeKind> {
+        if self.promotable {
+            if let Some((ref mut stab, _)) = self.stability {
+                stab.promotable = true;
+            } else {
+                cx.dcx()
+                    .emit_err(session_diagnostics::RustcPromotablePairing { span: cx.target_span });
+            }
+        }
+
+        let (stability, span) = self.stability?;
+
+        Some(AttributeKind::ConstStability { stability, span })
+    }
+}
+
+/// Tries to insert the value of a `key = value` meta item into an option.
+///
+/// Emits an error when either the option was already Some, or the arguments weren't of form
+/// `name = value`
+fn insert_value_into_option_or_error(
+    cx: &AcceptContext<'_>,
+    param: &MetaItemParser<'_>,
+    item: &mut Option<Symbol>,
+) -> Option<()> {
     if item.is_some() {
-        sess.dcx().emit_err(session_diagnostics::MultipleItem {
-            span: meta.span,
-            item: pprust::path_to_string(&meta.path),
+        cx.emit_err(session_diagnostics::MultipleItem {
+            span: param.span(),
+            item: param.path_without_args().to_string(),
         });
         None
-    } else if let Some(v) = meta.value_str() {
-        *item = Some(v);
+    } else if let Some(v) = param.args().name_value()
+        && let Some(s) = v.value_as_str()
+    {
+        *item = Some(s);
         Some(())
     } else {
-        sess.dcx().emit_err(session_diagnostics::IncorrectMetaItem { span: meta.span });
+        cx.emit_err(session_diagnostics::IncorrectMetaItem {
+            span: param.span(),
+            suggestion: None,
+        });
         None
     }
 }
 
 /// Read the content of a `stable`/`rustc_const_stable` attribute, and return the feature name and
 /// its stability information.
-fn parse_stability(sess: &Session, attr: &impl AttributeExt) -> Option<(Symbol, StabilityLevel)> {
-    let metas = attr.meta_item_list()?;
-
+pub(crate) fn parse_stability(
+    cx: &AcceptContext<'_>,
+    args: &ArgParser<'_>,
+) -> Option<(Symbol, StabilityLevel)> {
     let mut feature = None;
     let mut since = None;
-    for meta in metas {
-        let Some(mi) = meta.meta_item() else {
-            sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
-                span: meta.span(),
+
+    for param in args.list()?.mixed() {
+        let param_span = param.span();
+        let Some(param) = param.meta_item() else {
+            cx.emit_err(session_diagnostics::UnsupportedLiteral {
+                span: param_span,
                 reason: UnsupportedLiteralReason::Generic,
                 is_bytestr: false,
-                start_point_span: sess.source_map().start_point(meta.span()),
+                start_point_span: cx.sess().source_map().start_point(param_span),
             });
             return None;
         };
 
-        match mi.name_or_empty() {
-            sym::feature => insert_or_error(sess, mi, &mut feature)?,
-            sym::since => insert_or_error(sess, mi, &mut since)?,
+        match param.word_or_empty_without_args().name {
+            sym::feature => insert_value_into_option_or_error(cx, &param, &mut feature)?,
+            sym::since => insert_value_into_option_or_error(cx, &param, &mut since)?,
             _ => {
-                sess.dcx().emit_err(session_diagnostics::UnknownMetaItem {
-                    span: meta.span(),
-                    item: pprust::path_to_string(&mi.path),
+                cx.emit_err(session_diagnostics::UnknownMetaItem {
+                    span: param_span,
+                    item: param.path_without_args().to_string(),
                     expected: &["feature", "since"],
                 });
                 return None;
@@ -271,9 +263,9 @@ fn parse_stability(sess: &Session, attr: &impl AttributeExt) -> Option<(Symbol,
     let feature = match feature {
         Some(feature) if rustc_lexer::is_ident(feature.as_str()) => Ok(feature),
         Some(_bad_feature) => {
-            Err(sess.dcx().emit_err(session_diagnostics::NonIdentFeature { span: attr.span() }))
+            Err(cx.emit_err(session_diagnostics::NonIdentFeature { span: cx.attr_span }))
         }
-        None => Err(sess.dcx().emit_err(session_diagnostics::MissingFeature { span: attr.span() })),
+        None => Err(cx.emit_err(session_diagnostics::MissingFeature { span: cx.attr_span })),
     };
 
     let since = if let Some(since) = since {
@@ -282,11 +274,11 @@ fn parse_stability(sess: &Session, attr: &impl AttributeExt) -> Option<(Symbol,
         } else if let Some(version) = parse_version(since) {
             StableSince::Version(version)
         } else {
-            sess.dcx().emit_err(session_diagnostics::InvalidSince { span: attr.span() });
+            cx.emit_err(session_diagnostics::InvalidSince { span: cx.attr_span });
             StableSince::Err
         }
     } else {
-        sess.dcx().emit_err(session_diagnostics::MissingSince { span: attr.span() });
+        cx.emit_err(session_diagnostics::MissingSince { span: cx.attr_span });
         StableSince::Err
     };
 
@@ -299,46 +291,48 @@ fn parse_stability(sess: &Session, attr: &impl AttributeExt) -> Option<(Symbol,
     }
 }
 
-/// Read the content of a `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
+// Read the content of a `unstable`/`rustc_const_unstable`/`rustc_default_body_unstable`
 /// attribute, and return the feature name and its stability information.
-fn parse_unstability(sess: &Session, attr: &impl AttributeExt) -> Option<(Symbol, StabilityLevel)> {
-    let metas = attr.meta_item_list()?;
-
+pub(crate) fn parse_unstability(
+    cx: &AcceptContext<'_>,
+    args: &ArgParser<'_>,
+) -> Option<(Symbol, StabilityLevel)> {
     let mut feature = None;
     let mut reason = None;
     let mut issue = None;
     let mut issue_num = None;
     let mut is_soft = false;
     let mut implied_by = None;
-    for meta in metas {
-        let Some(mi) = meta.meta_item() else {
-            sess.dcx().emit_err(session_diagnostics::UnsupportedLiteral {
-                span: meta.span(),
+    for param in args.list()?.mixed() {
+        let Some(param) = param.meta_item() else {
+            cx.emit_err(session_diagnostics::UnsupportedLiteral {
+                span: param.span(),
                 reason: UnsupportedLiteralReason::Generic,
                 is_bytestr: false,
-                start_point_span: sess.source_map().start_point(meta.span()),
+                start_point_span: cx.sess().source_map().start_point(param.span()),
             });
             return None;
         };
 
-        match mi.name_or_empty() {
-            sym::feature => insert_or_error(sess, mi, &mut feature)?,
-            sym::reason => insert_or_error(sess, mi, &mut reason)?,
+        let (word, args) = param.word_or_empty();
+        match word.name {
+            sym::feature => insert_value_into_option_or_error(cx, &param, &mut feature)?,
+            sym::reason => insert_value_into_option_or_error(cx, &param, &mut reason)?,
             sym::issue => {
-                insert_or_error(sess, mi, &mut issue)?;
+                insert_value_into_option_or_error(cx, &param, &mut issue)?;
 
-                // These unwraps are safe because `insert_or_error` ensures the meta item
+                // These unwraps are safe because `insert_value_into_option_or_error` ensures the meta item
                 // is a name/value pair string literal.
                 issue_num = match issue.unwrap().as_str() {
                     "none" => None,
-                    issue => match issue.parse::<NonZero<u32>>() {
+                    issue_str => match issue_str.parse::<NonZero<u32>>() {
                         Ok(num) => Some(num),
                         Err(err) => {
-                            sess.dcx().emit_err(
+                            cx.emit_err(
                                 session_diagnostics::InvalidIssueString {
-                                    span: mi.span,
+                                    span: param.span(),
                                     cause: session_diagnostics::InvalidIssueStringCause::from_int_error_kind(
-                                        mi.name_value_literal_span().unwrap(),
+                                        args.name_value().unwrap().value_span,
                                         err.kind(),
                                     ),
                                 },
@@ -349,16 +343,16 @@ fn parse_unstability(sess: &Session, attr: &impl AttributeExt) -> Option<(Symbol
                 };
             }
             sym::soft => {
-                if !mi.is_word() {
-                    sess.dcx().emit_err(session_diagnostics::SoftNoArgs { span: mi.span });
+                if !args.no_args() {
+                    cx.emit_err(session_diagnostics::SoftNoArgs { span: param.span() });
                 }
                 is_soft = true;
             }
-            sym::implied_by => insert_or_error(sess, mi, &mut implied_by)?,
+            sym::implied_by => insert_value_into_option_or_error(cx, &param, &mut implied_by)?,
             _ => {
-                sess.dcx().emit_err(session_diagnostics::UnknownMetaItem {
-                    span: meta.span(),
-                    item: pprust::path_to_string(&mi.path),
+                cx.emit_err(session_diagnostics::UnknownMetaItem {
+                    span: param.span(),
+                    item: param.path_without_args().to_string(),
                     expected: &["feature", "reason", "issue", "soft", "implied_by"],
                 });
                 return None;
@@ -369,14 +363,13 @@ fn parse_unstability(sess: &Session, attr: &impl AttributeExt) -> Option<(Symbol
     let feature = match feature {
         Some(feature) if rustc_lexer::is_ident(feature.as_str()) => Ok(feature),
         Some(_bad_feature) => {
-            Err(sess.dcx().emit_err(session_diagnostics::NonIdentFeature { span: attr.span() }))
+            Err(cx.emit_err(session_diagnostics::NonIdentFeature { span: cx.attr_span }))
         }
-        None => Err(sess.dcx().emit_err(session_diagnostics::MissingFeature { span: attr.span() })),
+        None => Err(cx.emit_err(session_diagnostics::MissingFeature { span: cx.attr_span })),
     };
 
-    let issue = issue.ok_or_else(|| {
-        sess.dcx().emit_err(session_diagnostics::MissingIssue { span: attr.span() })
-    });
+    let issue =
+        issue.ok_or_else(|| cx.emit_err(session_diagnostics::MissingIssue { span: cx.attr_span }));
 
     match (feature, issue) {
         (Ok(feature), Ok(_)) => {
diff --git a/compiler/rustc_attr_parsing/src/attributes/transparency.rs b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
index f4065a770484..ad83a1f7af80 100644
--- a/compiler/rustc_attr_parsing/src/attributes/transparency.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/transparency.rs
@@ -1,36 +1,33 @@
-use rustc_ast::attr::AttributeExt;
-use rustc_attr_data_structures::TransparencyError;
+use rustc_attr_data_structures::AttributeKind;
 use rustc_span::hygiene::Transparency;
 use rustc_span::sym;
 
-pub fn find_transparency(
-    attrs: &[impl AttributeExt],
-    macro_rules: bool,
-) -> (Transparency, Option<TransparencyError>) {
-    let mut transparency = None;
-    let mut error = None;
-    for attr in attrs {
-        if attr.has_name(sym::rustc_macro_transparency) {
-            if let Some((_, old_span)) = transparency {
-                error = Some(TransparencyError::MultipleTransparencyAttrs(old_span, attr.span()));
-                break;
-            } else if let Some(value) = attr.value_str() {
-                transparency = Some((
-                    match value {
-                        sym::transparent => Transparency::Transparent,
-                        sym::semitransparent => Transparency::SemiTransparent,
-                        sym::opaque => Transparency::Opaque,
-                        _ => {
-                            error =
-                                Some(TransparencyError::UnknownTransparency(value, attr.span()));
-                            continue;
-                        }
-                    },
-                    attr.span(),
-                ));
-            }
-        }
+use super::{AcceptContext, SingleAttributeParser};
+use crate::parser::ArgParser;
+
+pub(crate) struct TransparencyParser;
+
+// FIXME(jdonszelmann): make these proper diagnostics
+#[allow(rustc::untranslatable_diagnostic)]
+#[allow(rustc::diagnostic_outside_of_impl)]
+impl SingleAttributeParser for TransparencyParser {
+    const PATH: &'static [rustc_span::Symbol] = &[sym::rustc_macro_transparency];
+
+    fn on_duplicate(cx: &crate::context::AcceptContext<'_>, first_span: rustc_span::Span) {
+        cx.dcx().span_err(vec![first_span, cx.attr_span], "multiple macro transparency attributes");
+    }
+
+    fn convert(cx: &AcceptContext<'_>, args: &ArgParser<'_>) -> Option<AttributeKind> {
+        match args.name_value().and_then(|nv| nv.value_as_str()) {
+            Some(sym::transparent) => Some(Transparency::Transparent),
+            Some(sym::semitransparent) => Some(Transparency::SemiTransparent),
+            Some(sym::opaque) => Some(Transparency::Opaque),
+            Some(other) => {
+                cx.dcx().span_err(cx.attr_span, format!("unknown macro transparency: `{other}`"));
+                None
+            }
+            None => None,
+        }
+        .map(AttributeKind::MacroTransparency)
     }
-    let fallback = if macro_rules { Transparency::SemiTransparent } else { Transparency::Opaque };
-    (transparency.map_or(fallback, |t| t.0), error)
 }
diff --git a/compiler/rustc_attr_parsing/src/attributes/util.rs b/compiler/rustc_attr_parsing/src/attributes/util.rs
index e36f7dfff5a5..05a9029c59aa 100644
--- a/compiler/rustc_attr_parsing/src/attributes/util.rs
+++ b/compiler/rustc_attr_parsing/src/attributes/util.rs
@@ -3,22 +3,6 @@ use rustc_attr_data_structures::RustcVersion;
 use rustc_feature::is_builtin_attr_name;
 use rustc_span::{Symbol, sym};
 
-pub(crate) enum UnsupportedLiteralReason {
-    Generic,
-    CfgString,
-    CfgBoolean,
-    DeprecatedString,
-    DeprecatedKvPair,
-}
-
-pub fn is_builtin_attr(attr: &impl AttributeExt) -> bool {
-    attr.is_doc_comment() || attr.ident().is_some_and(|ident| is_builtin_attr_name(ident.name))
-}
-
-pub fn find_crate_name(attrs: &[impl AttributeExt]) -> Option<Symbol> {
-    first_attr_value_str_by_name(attrs, sym::crate_name)
-}
-
 /// Parse a rustc version number written inside string literal in an attribute,
 /// like appears in `since = "1.0.0"`. Suffixes like "-dev" and "-nightly" are
 /// not accepted in this position, unlike when parsing CFG_RELEASE.
@@ -34,3 +18,11 @@ pub fn parse_version(s: Symbol) -> Option<RustcVersion> {
     let patch = digits.next().unwrap_or("0").parse().ok()?;
     Some(RustcVersion { major, minor, patch })
 }
+
+pub fn is_builtin_attr(attr: &impl AttributeExt) -> bool {
+    attr.is_doc_comment() || attr.ident().is_some_and(|ident| is_builtin_attr_name(ident.name))
+}
+
+pub fn find_crate_name(attrs: &[impl AttributeExt]) -> Option<Symbol> {
+    first_attr_value_str_by_name(attrs, sym::crate_name)
+}
diff --git a/compiler/rustc_attr_parsing/src/context.rs b/compiler/rustc_attr_parsing/src/context.rs
new file mode 100644
index 000000000000..0e6b0bab082e
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/context.rs
@@ -0,0 +1,351 @@
+use std::cell::RefCell;
+use std::collections::BTreeMap;
+use std::ops::Deref;
+use std::sync::LazyLock;
+
+use rustc_ast::{self as ast, DelimArgs};
+use rustc_attr_data_structures::AttributeKind;
+use rustc_errors::{DiagCtxtHandle, Diagnostic};
+use rustc_feature::Features;
+use rustc_hir::{AttrArgs, AttrItem, AttrPath, Attribute, HashIgnoredAttrId};
+use rustc_session::Session;
+use rustc_span::symbol::kw;
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span, Symbol, sym};
+
+use crate::attributes::allow_unstable::{AllowConstFnUnstableParser, AllowInternalUnstableParser};
+use crate::attributes::confusables::ConfusablesParser;
+use crate::attributes::deprecation::DeprecationParser;
+use crate::attributes::repr::ReprParser;
+use crate::attributes::stability::{
+    BodyStabilityParser, ConstStabilityIndirectParser, ConstStabilityParser, StabilityParser,
+};
+use crate::attributes::transparency::TransparencyParser;
+use crate::attributes::{AttributeParser as _, Combine, Single};
+use crate::parser::{ArgParser, MetaItemParser};
+
+macro_rules! attribute_groups {
+    (
+        pub(crate) static $name: ident = [$($names: ty),* $(,)?];
+    ) => {
+        pub(crate) static $name: LazyLock<(
+            BTreeMap<&'static [Symbol], Vec<Box<dyn Fn(&AcceptContext<'_>, &ArgParser<'_>) + Send + Sync>>>,
+            Vec<Box<dyn Send + Sync + Fn(&FinalizeContext<'_>) -> Option<AttributeKind>>>
+        )> = LazyLock::new(|| {
+            let mut accepts = BTreeMap::<_, Vec<Box<dyn Fn(&AcceptContext<'_>, &ArgParser<'_>) + Send + Sync>>>::new();
+            let mut finalizes = Vec::<Box<dyn Send + Sync + Fn(&FinalizeContext<'_>) -> Option<AttributeKind>>>::new();
+            $(
+                {
+                    thread_local! {
+                        static STATE_OBJECT: RefCell<$names> = RefCell::new(<$names>::default());
+                    };
+
+                    for (k, v) in <$names>::ATTRIBUTES {
+                        accepts.entry(*k).or_default().push(Box::new(|cx, args| {
+                            STATE_OBJECT.with_borrow_mut(|s| {
+                                v(s, cx, args)
+                            })
+                        }));
+                    }
+
+                    finalizes.push(Box::new(|cx| {
+                        let state = STATE_OBJECT.take();
+                        state.finalize(cx)
+                    }));
+                }
+            )*
+
+            (accepts, finalizes)
+        });
+    };
+}
+
+attribute_groups!(
+    pub(crate) static ATTRIBUTE_MAPPING = [
+        // tidy-alphabetical-start
+        BodyStabilityParser,
+        ConfusablesParser,
+        ConstStabilityParser,
+        StabilityParser,
+        // tidy-alphabetical-end
+
+        // tidy-alphabetical-start
+        Combine<AllowConstFnUnstableParser>,
+        Combine<AllowInternalUnstableParser>,
+        Combine<ReprParser>,
+        // tidy-alphabetical-end
+
+        // tidy-alphabetical-start
+        Single<ConstStabilityIndirectParser>,
+        Single<DeprecationParser>,
+        Single<TransparencyParser>,
+        // tidy-alphabetical-end
+    ];
+);
+
+/// Context given to every attribute parser when accepting
+///
+/// Gives [`AttributeParser`]s enough information to create errors, for example.
+pub(crate) struct AcceptContext<'a> {
+    pub(crate) group_cx: &'a FinalizeContext<'a>,
+    /// The span of the attribute currently being parsed
+    pub(crate) attr_span: Span,
+}
+
+impl<'a> AcceptContext<'a> {
+    pub(crate) fn emit_err(&self, diag: impl Diagnostic<'a>) -> ErrorGuaranteed {
+        if self.limit_diagnostics {
+            self.dcx().create_err(diag).delay_as_bug()
+        } else {
+            self.dcx().emit_err(diag)
+        }
+    }
+}
+
+impl<'a> Deref for AcceptContext<'a> {
+    type Target = FinalizeContext<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.group_cx
+    }
+}
+
+/// Context given to every attribute parser during finalization.
+///
+/// Gives [`AttributeParser`](crate::attributes::AttributeParser)s enough information to create errors, for example.
+pub(crate) struct FinalizeContext<'a> {
+    /// The parse context, gives access to the session and the
+    /// diagnostics context.
+    pub(crate) cx: &'a AttributeParser<'a>,
+    /// The span of the syntactical component this attribute was applied to
+    pub(crate) target_span: Span,
+}
+
+impl<'a> Deref for FinalizeContext<'a> {
+    type Target = AttributeParser<'a>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.cx
+    }
+}
+
+#[derive(PartialEq, Clone, Copy, Debug)]
+pub enum OmitDoc {
+    Lower,
+    Skip,
+}
+
+/// Context created once, for example as part of the ast lowering
+/// context, through which all attributes can be lowered.
+pub struct AttributeParser<'sess> {
+    #[expect(dead_code)] // FIXME(jdonszelmann): needed later to verify we parsed all attributes
+    tools: Vec<Symbol>,
+    sess: &'sess Session,
+    features: Option<&'sess Features>,
+
+    /// *only* parse attributes with this symbol.
+    ///
+    /// Used in cases where we want the lowering infrastructure for
+    /// parse just a single attribute.
+    parse_only: Option<Symbol>,
+
+    /// Can be used to instruct parsers to reduce the number of diagnostics it emits.
+    /// Useful when using `parse_limited` and you know the attr will be reparsed later.
+    pub(crate) limit_diagnostics: bool,
+}
+
+impl<'sess> AttributeParser<'sess> {
+    /// This method allows you to parse attributes *before* you have access to features or tools.
+    /// One example where this is necessary, is to parse `feature` attributes themselves for
+    /// example.
+    ///
+    /// Try to use this as little as possible. Attributes *should* be lowered during `rustc_ast_lowering`.
+    /// Some attributes require access to features to parse, which would crash if you tried to do so
+    /// through [`parse_limited`](Self::parse_limited).
+    ///
+    /// To make sure use is limited, supply a `Symbol` you'd like to parse. Only attributes with
+    /// that symbol are picked out of the list of instructions and parsed. Those are returned.
+    pub fn parse_limited(
+        sess: &'sess Session,
+        attrs: &[ast::Attribute],
+        sym: Symbol,
+        target_span: Span,
+        limit_diagnostics: bool,
+    ) -> Option<Attribute> {
+        let mut parsed = Self {
+            sess,
+            features: None,
+            tools: Vec::new(),
+            parse_only: Some(sym),
+            limit_diagnostics,
+        }
+        .parse_attribute_list(attrs, target_span, OmitDoc::Skip, std::convert::identity);
+
+        assert!(parsed.len() <= 1);
+
+        parsed.pop()
+    }
+
+    pub fn new(sess: &'sess Session, features: &'sess Features, tools: Vec<Symbol>) -> Self {
+        Self { sess, features: Some(features), tools, parse_only: None, limit_diagnostics: false }
+    }
+
+    pub(crate) fn sess(&self) -> &'sess Session {
+        self.sess
+    }
+
+    pub(crate) fn features(&self) -> &'sess Features {
+        self.features.expect("features not available at this point in the compiler")
+    }
+
+    pub(crate) fn dcx(&self) -> DiagCtxtHandle<'sess> {
+        self.sess.dcx()
+    }
+
+    /// Parse a list of attributes.
+    ///
+    /// `target_span` is the span of the thing this list of attributes is applied to,
+    /// and when `omit_doc` is set, doc attributes are filtered out.
+    pub fn parse_attribute_list<'a>(
+        &'a self,
+        attrs: &'a [ast::Attribute],
+        target_span: Span,
+        omit_doc: OmitDoc,
+
+        lower_span: impl Copy + Fn(Span) -> Span,
+    ) -> Vec<Attribute> {
+        let mut attributes = Vec::new();
+
+        let group_cx = FinalizeContext { cx: self, target_span };
+
+        for attr in attrs {
+            // if we're only looking for a single attribute,
+            // skip all the ones we don't care about
+            if let Some(expected) = self.parse_only {
+                if attr.name_or_empty() != expected {
+                    continue;
+                }
+            }
+
+            // sometimes, for example for `#![doc = include_str!("readme.md")]`,
+            // doc still contains a non-literal. You might say, when we're lowering attributes
+            // that's expanded right? But no, sometimes, when parsing attributes on macros,
+            // we already use the lowering logic and these are still there. So, when `omit_doc`
+            // is set we *also* want to ignore these
+            if omit_doc == OmitDoc::Skip && attr.name_or_empty() == sym::doc {
+                continue;
+            }
+
+            match &attr.kind {
+                ast::AttrKind::DocComment(comment_kind, symbol) => {
+                    if omit_doc == OmitDoc::Skip {
+                        continue;
+                    }
+
+                    attributes.push(Attribute::Parsed(AttributeKind::DocComment {
+                        style: attr.style,
+                        kind: *comment_kind,
+                        span: lower_span(attr.span),
+                        comment: *symbol,
+                    }))
+                }
+                // // FIXME: make doc attributes go through a proper attribute parser
+                // ast::AttrKind::Normal(n) if n.name_or_empty() == sym::doc => {
+                //     let p = GenericMetaItemParser::from_attr(&n, self.dcx());
+                //
+                //     attributes.push(Attribute::Parsed(AttributeKind::DocComment {
+                //         style: attr.style,
+                //         kind: CommentKind::Line,
+                //         span: attr.span,
+                //         comment: p.args().name_value(),
+                //     }))
+                // }
+                ast::AttrKind::Normal(n) => {
+                    let parser = MetaItemParser::from_attr(n, self.dcx());
+                    let (path, args) = parser.deconstruct();
+                    let parts = path.segments().map(|i| i.name).collect::<Vec<_>>();
+
+                    if let Some(accepts) = ATTRIBUTE_MAPPING.0.get(parts.as_slice()) {
+                        for f in accepts {
+                            let cx = AcceptContext {
+                                group_cx: &group_cx,
+                                attr_span: lower_span(attr.span),
+                            };
+
+                            f(&cx, &args)
+                        }
+                    } else {
+                        // if we're here, we must be compiling a tool attribute... Or someone forgot to
+                        // parse their fancy new attribute. Let's warn them in any case. If you are that
+                        // person, and you really your attribute should remain unparsed, carefully read the
+                        // documentation in this module and if you still think so you can add an exception
+                        // to this assertion.
+
+                        // FIXME(jdonszelmann): convert other attributes, and check with this that
+                        // we caught em all
+                        // const FIXME_TEMPORARY_ATTR_ALLOWLIST: &[Symbol] = &[sym::cfg];
+                        // assert!(
+                        //     self.tools.contains(&parts[0]) || true,
+                        //     // || FIXME_TEMPORARY_ATTR_ALLOWLIST.contains(&parts[0]),
+                        //     "attribute {path} wasn't parsed and isn't a know tool attribute",
+                        // );
+
+                        attributes.push(Attribute::Unparsed(Box::new(AttrItem {
+                            path: AttrPath::from_ast(&n.item.path),
+                            args: self.lower_attr_args(&n.item.args, lower_span),
+                            id: HashIgnoredAttrId { attr_id: attr.id },
+                            style: attr.style,
+                            span: lower_span(attr.span),
+                        })));
+                    }
+                }
+            }
+        }
+
+        let mut parsed_attributes = Vec::new();
+        for f in &ATTRIBUTE_MAPPING.1 {
+            if let Some(attr) = f(&group_cx) {
+                parsed_attributes.push(Attribute::Parsed(attr));
+            }
+        }
+
+        attributes.extend(parsed_attributes);
+
+        attributes
+    }
+
+    fn lower_attr_args(&self, args: &ast::AttrArgs, lower_span: impl Fn(Span) -> Span) -> AttrArgs {
+        match args {
+            ast::AttrArgs::Empty => AttrArgs::Empty,
+            ast::AttrArgs::Delimited(args) => AttrArgs::Delimited(DelimArgs {
+                dspan: args.dspan,
+                delim: args.delim,
+                tokens: args.tokens.flattened(),
+            }),
+            // This is an inert key-value attribute - it will never be visible to macros
+            // after it gets lowered to HIR. Therefore, we can extract literals to handle
+            // nonterminals in `#[doc]` (e.g. `#[doc = $e]`).
+            ast::AttrArgs::Eq { eq_span, expr } => {
+                // In valid code the value always ends up as a single literal. Otherwise, a dummy
+                // literal suffices because the error is handled elsewhere.
+                let lit = if let ast::ExprKind::Lit(token_lit) = expr.kind
+                    && let Ok(lit) =
+                        ast::MetaItemLit::from_token_lit(token_lit, lower_span(expr.span))
+                {
+                    lit
+                } else {
+                    let guar = self.dcx().span_delayed_bug(
+                        args.span().unwrap_or(DUMMY_SP),
+                        "expr in place where literal is expected (builtin attr parsing)",
+                    );
+                    ast::MetaItemLit {
+                        symbol: kw::Empty,
+                        suffix: None,
+                        kind: ast::LitKind::Err(guar),
+                        span: DUMMY_SP,
+                    }
+                };
+                AttrArgs::Eq { eq_span: lower_span(*eq_span), expr: lit }
+            }
+        }
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/lib.rs b/compiler/rustc_attr_parsing/src/lib.rs
index a1264a6875f6..9841166b37db 100644
--- a/compiler/rustc_attr_parsing/src/lib.rs
+++ b/compiler/rustc_attr_parsing/src/lib.rs
@@ -1,8 +1,79 @@
-//! Functions and types dealing with attributes and meta items.
+//! Centralized logic for parsing and attributes.
 //!
-//! FIXME(Centril): For now being, much of the logic is still in `rustc_ast::attr`.
-//! The goal is to move the definition of `MetaItem` and things that don't need to be in `syntax`
-//! to this crate.
+//! Part of a series of crates:
+//! - rustc_attr_data_structures: contains types that the parsers parse into
+//! - rustc_attr_parsing: this crate
+//! - (in the future): rustc_attr_validation
+//!
+//! History: Check out [#131229](https://github.com/rust-lang/rust/issues/131229).
+//! There used to be only one definition of attributes in the compiler: `ast::Attribute`.
+//! These were then parsed or validated or both in places distributed all over the compiler.
+//! This was a mess...
+//!
+//! Attributes are markers on items.
+//! Many of them are actually attribute-like proc-macros, and are expanded to some other rust syntax.
+//! This could either be a user provided proc macro, or something compiler provided.
+//! `derive` is an example of one that the compiler provides.
+//! These are built-in, but they have a valid expansion to Rust tokens and are thus called "active".
+//! I personally like calling these *active* compiler-provided attributes, built-in *macros*,
+//! because they still expand, and this helps to differentiate them from built-in *attributes*.
+//! However, I'll be the first to admit that the naming here can be confusing.
+//!
+//! The alternative to active attributes, are inert attributes.
+//! These can occur in user code (proc-macro helper attributes).
+//! But what's important is, many built-in attributes are inert like this.
+//! There is nothing they expand to during the macro expansion process,
+//! sometimes because they literally cannot expand to something that is valid Rust.
+//! They are really just markers to guide the compilation process.
+//! An example is `#[inline(...)]` which changes how code for functions is generated.
+//!
+//! ```text
+//!                      Active                 Inert
+//!              ┌──────────────────────┬──────────────────────┐
+//!              │     (mostly in)      │    these are parsed  │
+//!              │ rustc_builtin_macros │        here!         │
+//!              │                      │                      │
+//!              │                      │                      │
+//!              │    #[derive(...)]    │    #[stable()]       │
+//!     Built-in │    #[cfg()]          │    #[inline()]       │
+//!              │    #[cfg_attr()]     │    #[repr()]         │
+//!              │                      │                      │
+//!              │                      │                      │
+//!              │                      │                      │
+//!              ├──────────────────────┼──────────────────────┤
+//!              │                      │                      │
+//!              │                      │                      │
+//!              │                      │       `b` in         │
+//!              │                      │ #[proc_macro_derive( │
+//! User created │ #[proc_macro_attr()] │    a,                │
+//!              │                      │    attributes(b)     │
+//!              │                      │ ]                    │
+//!              │                      │                      │
+//!              │                      │                      │
+//!              │                      │                      │
+//!              └──────────────────────┴──────────────────────┘
+//! ```
+//!
+//! In this crate, syntactical attributes (sequences of tokens that look like
+//! `#[something(something else)]`) are parsed into more semantic attributes, markers on items.
+//! Multiple syntactic attributes might influence a single semantic attribute. For example,
+//! `#[stable(...)]` and `#[unstable()]` cannot occur together, and both semantically define
+//! a "stability" of an item. So, the stability attribute has an
+//! [`AttributeParser`](attributes::AttributeParser) that recognizes both the `#[stable()]`
+//! and `#[unstable()]` syntactic attributes, and at the end produce a single [`AttributeKind::Stability`].
+//!
+//! As a rule of thumb, when a syntactical attribute can be applied more than once, they should be
+//! combined into a single semantic attribute. For example:
+//!
+//! ```
+//! #[repr(C)]
+//! #[repr(packed)]
+//! struct Meow {}
+//! ```
+//!
+//! should result in a single `AttributeKind::Repr` containing a list of repr annotations, in this
+//! case `C` and `packed`. This is equivalent to writing `#[repr(C, packed)]` in a single
+//! syntactical annotation.
 
 // tidy-alphabetical-start
 #![allow(internal_features)]
@@ -12,11 +83,59 @@
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
+#[macro_use]
 mod attributes;
+mod context;
+pub mod parser;
 mod session_diagnostics;
 
-pub use attributes::*;
+pub use attributes::cfg::*;
+pub use attributes::util::{find_crate_name, is_builtin_attr, parse_version};
+pub use context::{AttributeParser, OmitDoc};
 pub use rustc_attr_data_structures::*;
-pub use util::{find_crate_name, is_builtin_attr, parse_version};
 
 rustc_fluent_macro::fluent_messages! { "../messages.ftl" }
+
+/// Finds attributes in sequences of attributes by pattern matching.
+///
+/// A little like `matches` but for attributes.
+///
+/// ```rust,ignore (illustrative)
+/// // finds the repr attribute
+/// if let Some(r) = find_attr!(attrs, AttributeKind::Repr(r) => r) {
+///
+/// }
+///
+/// // checks if one has matched
+/// if find_attr!(attrs, AttributeKind::Repr(_)) {
+///
+/// }
+/// ```
+///
+/// Often this requires you to first end up with a list of attributes.
+/// A common way to get those is through `tcx.get_all_attrs(did)`
+#[macro_export]
+macro_rules! find_attr {
+    ($attributes_list: expr, $pattern: pat $(if $guard: expr)?) => {{
+        $crate::find_attr!($attributes_list, $pattern $(if $guard)? => ()).is_some()
+    }};
+
+    ($attributes_list: expr, $pattern: pat $(if $guard: expr)? => $e: expr) => {{
+        fn check_attribute_iterator<'a>(_: &'_ impl IntoIterator<Item = &'a rustc_hir::Attribute>) {}
+        check_attribute_iterator(&$attributes_list);
+
+        let find_attribute = |iter| {
+            for i in $attributes_list {
+                match i {
+                    rustc_hir::Attribute::Parsed($pattern) $(if $guard)? => {
+                        return Some($e);
+                    }
+                    _ => {}
+                }
+            }
+
+            None
+        };
+        find_attribute($attributes_list)
+    }};
+}
diff --git a/compiler/rustc_attr_parsing/src/parser.rs b/compiler/rustc_attr_parsing/src/parser.rs
new file mode 100644
index 000000000000..96fc9d7d9ac4
--- /dev/null
+++ b/compiler/rustc_attr_parsing/src/parser.rs
@@ -0,0 +1,607 @@
+//! This is in essence an (improved) duplicate of `rustc_ast/attr/mod.rs`.
+//! That module is intended to be deleted in its entirety.
+//!
+//! FIXME(jdonszelmann): delete `rustc_ast/attr/mod.rs`
+
+use std::fmt::{Debug, Display};
+use std::iter::Peekable;
+
+use rustc_ast::token::{self, Delimiter, Token};
+use rustc_ast::tokenstream::{TokenStreamIter, TokenTree};
+use rustc_ast::{AttrArgs, DelimArgs, Expr, ExprKind, LitKind, MetaItemLit, NormalAttr, Path};
+use rustc_ast_pretty::pprust;
+use rustc_errors::DiagCtxtHandle;
+use rustc_hir::{self as hir, AttrPath};
+use rustc_span::symbol::{Ident, kw};
+use rustc_span::{ErrorGuaranteed, Span, Symbol};
+
+pub struct SegmentIterator<'a> {
+    offset: usize,
+    path: &'a PathParser<'a>,
+}
+
+impl<'a> Iterator for SegmentIterator<'a> {
+    type Item = &'a Ident;
+
+    fn next(&mut self) -> Option<Self::Item> {
+        if self.offset >= self.path.len() {
+            return None;
+        }
+
+        let res = match self.path {
+            PathParser::Ast(ast_path) => &ast_path.segments[self.offset].ident,
+            PathParser::Attr(attr_path) => &attr_path.segments[self.offset],
+        };
+
+        self.offset += 1;
+        Some(res)
+    }
+}
+
+#[derive(Clone, Debug)]
+pub enum PathParser<'a> {
+    Ast(&'a Path),
+    Attr(AttrPath),
+}
+
+impl<'a> PathParser<'a> {
+    pub fn get_attribute_path(&self) -> hir::AttrPath {
+        AttrPath {
+            segments: self.segments().copied().collect::<Vec<_>>().into_boxed_slice(),
+            span: self.span(),
+        }
+    }
+
+    pub fn segments(&'a self) -> impl Iterator<Item = &'a Ident> {
+        SegmentIterator { offset: 0, path: self }
+    }
+
+    pub fn span(&self) -> Span {
+        match self {
+            PathParser::Ast(path) => path.span,
+            PathParser::Attr(attr_path) => attr_path.span,
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        match self {
+            PathParser::Ast(path) => path.segments.len(),
+            PathParser::Attr(attr_path) => attr_path.segments.len(),
+        }
+    }
+
+    pub fn segments_is(&self, segments: &[Symbol]) -> bool {
+        self.len() == segments.len() && self.segments().zip(segments).all(|(a, b)| a.name == *b)
+    }
+
+    pub fn word(&self) -> Option<Ident> {
+        (self.len() == 1).then(|| **self.segments().next().as_ref().unwrap())
+    }
+
+    pub fn word_or_empty(&self) -> Ident {
+        self.word().unwrap_or_else(Ident::empty)
+    }
+
+    /// Asserts that this MetaItem is some specific word.
+    ///
+    /// See [`word`](Self::word) for examples of what a word is.
+    pub fn word_is(&self, sym: Symbol) -> bool {
+        self.word().map(|i| i.name == sym).unwrap_or(false)
+    }
+}
+
+impl Display for PathParser<'_> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            PathParser::Ast(path) => write!(f, "{}", pprust::path_to_string(path)),
+            PathParser::Attr(attr_path) => write!(f, "{attr_path}"),
+        }
+    }
+}
+
+#[derive(Clone, Debug)]
+#[must_use]
+pub enum ArgParser<'a> {
+    NoArgs,
+    List(MetaItemListParser<'a>),
+    NameValue(NameValueParser),
+}
+
+impl<'a> ArgParser<'a> {
+    pub fn span(&self) -> Option<Span> {
+        match self {
+            Self::NoArgs => None,
+            Self::List(l) => Some(l.span),
+            Self::NameValue(n) => Some(n.value_span.with_lo(n.eq_span.lo())),
+        }
+    }
+
+    pub fn from_attr_args(value: &'a AttrArgs, dcx: DiagCtxtHandle<'a>) -> Self {
+        match value {
+            AttrArgs::Empty => Self::NoArgs,
+            AttrArgs::Delimited(args) if args.delim == Delimiter::Parenthesis => {
+                Self::List(MetaItemListParser::new(args, dcx))
+            }
+            AttrArgs::Delimited(args) => {
+                Self::List(MetaItemListParser { sub_parsers: vec![], span: args.dspan.entire() })
+            }
+            AttrArgs::Eq { eq_span, expr } => Self::NameValue(NameValueParser {
+                eq_span: *eq_span,
+                value: expr_to_lit(dcx, &expr, *eq_span),
+                value_span: expr.span,
+            }),
+        }
+    }
+
+    /// Asserts that this MetaItem is a list
+    ///
+    /// Some examples:
+    ///
+    /// - `#[allow(clippy::complexity)]`: `(clippy::complexity)` is a list
+    /// - `#[rustfmt::skip::macros(target_macro_name)]`: `(target_macro_name)` is a list
+    pub fn list(&self) -> Option<&MetaItemListParser<'a>> {
+        match self {
+            Self::List(l) => Some(l),
+            Self::NameValue(_) | Self::NoArgs => None,
+        }
+    }
+
+    /// Asserts that this MetaItem is a name-value pair.
+    ///
+    /// Some examples:
+    ///
+    /// - `#[clippy::cyclomatic_complexity = "100"]`: `clippy::cyclomatic_complexity = "100"` is a name value pair,
+    ///   where the name is a path (`clippy::cyclomatic_complexity`). You already checked the path
+    ///   to get an `ArgParser`, so this method will effectively only assert that the `= "100"` is
+    ///   there
+    /// - `#[doc = "hello"]`: `doc = "hello`  is also a name value pair
+    pub fn name_value(&self) -> Option<&NameValueParser> {
+        match self {
+            Self::NameValue(n) => Some(n),
+            Self::List(_) | Self::NoArgs => None,
+        }
+    }
+
+    /// Asserts that there are no arguments
+    pub fn no_args(&self) -> bool {
+        matches!(self, Self::NoArgs)
+    }
+}
+
+/// Inside lists, values could be either literals, or more deeply nested meta items.
+/// This enum represents that.
+///
+/// Choose which one you want using the provided methods.
+#[derive(Debug, Clone)]
+pub enum MetaItemOrLitParser<'a> {
+    MetaItemParser(MetaItemParser<'a>),
+    Lit(MetaItemLit),
+    Err(Span, ErrorGuaranteed),
+}
+
+impl<'a> MetaItemOrLitParser<'a> {
+    pub fn span(&self) -> Span {
+        match self {
+            MetaItemOrLitParser::MetaItemParser(generic_meta_item_parser) => {
+                generic_meta_item_parser.span()
+            }
+            MetaItemOrLitParser::Lit(meta_item_lit) => meta_item_lit.span,
+            MetaItemOrLitParser::Err(span, _) => *span,
+        }
+    }
+
+    pub fn lit(&self) -> Option<&MetaItemLit> {
+        match self {
+            MetaItemOrLitParser::Lit(meta_item_lit) => Some(meta_item_lit),
+            _ => None,
+        }
+    }
+
+    pub fn meta_item(&self) -> Option<&MetaItemParser<'a>> {
+        match self {
+            MetaItemOrLitParser::MetaItemParser(parser) => Some(parser),
+            _ => None,
+        }
+    }
+}
+
+/// Utility that deconstructs a MetaItem into usable parts.
+///
+/// MetaItems are syntactically extremely flexible, but specific attributes want to parse
+/// them in custom, more restricted ways. This can be done using this struct.
+///
+/// MetaItems consist of some path, and some args. The args could be empty. In other words:
+///
+/// - `name` -> args are empty
+/// - `name(...)` -> args are a [`list`](ArgParser::list), which is the bit between the parentheses
+/// - `name = value`-> arg is [`name_value`](ArgParser::name_value), where the argument is the
+///   `= value` part
+///
+/// The syntax of MetaItems can be found at <https://doc.rust-lang.org/reference/attributes.html>
+#[derive(Clone)]
+pub struct MetaItemParser<'a> {
+    path: PathParser<'a>,
+    args: ArgParser<'a>,
+}
+
+impl<'a> Debug for MetaItemParser<'a> {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("MetaItemParser")
+            .field("path", &self.path)
+            .field("args", &self.args)
+            .finish()
+    }
+}
+
+impl<'a> MetaItemParser<'a> {
+    /// Create a new parser from a [`NormalAttr`], which is stored inside of any
+    /// [`ast::Attribute`](rustc_ast::Attribute)
+    pub fn from_attr(attr: &'a NormalAttr, dcx: DiagCtxtHandle<'a>) -> Self {
+        Self {
+            path: PathParser::Ast(&attr.item.path),
+            args: ArgParser::from_attr_args(&attr.item.args, dcx),
+        }
+    }
+}
+
+impl<'a> MetaItemParser<'a> {
+    pub fn span(&self) -> Span {
+        if let Some(other) = self.args.span() {
+            self.path.span().with_hi(other.hi())
+        } else {
+            self.path.span()
+        }
+    }
+
+    /// Gets just the path, without the args.
+    pub fn path_without_args(&self) -> PathParser<'a> {
+        self.path.clone()
+    }
+
+    /// Gets just the args parser, without caring about the path.
+    pub fn args(&self) -> &ArgParser<'a> {
+        &self.args
+    }
+
+    pub fn deconstruct(&self) -> (PathParser<'a>, &ArgParser<'a>) {
+        (self.path_without_args(), self.args())
+    }
+
+    /// Asserts that this MetaItem starts with a path. Some examples:
+    ///
+    /// - `#[rustfmt::skip]`: `rustfmt::skip` is a path
+    /// - `#[allow(clippy::complexity)]`: `clippy::complexity` is a path
+    /// - `#[inline]`: `inline` is a single segment path
+    pub fn path(&self) -> (PathParser<'a>, &ArgParser<'a>) {
+        self.deconstruct()
+    }
+
+    /// Asserts that this MetaItem starts with a word, or single segment path.
+    /// Doesn't return the args parser.
+    ///
+    /// For examples. see [`Self::word`]
+    pub fn word_without_args(&self) -> Option<Ident> {
+        Some(self.word()?.0)
+    }
+
+    /// Like [`word`](Self::word), but returns an empty symbol instead of None
+    pub fn word_or_empty_without_args(&self) -> Ident {
+        self.word_or_empty().0
+    }
+
+    /// Asserts that this MetaItem starts with a word, or single segment path.
+    ///
+    /// Some examples:
+    /// - `#[inline]`: `inline` is a word
+    /// - `#[rustfmt::skip]`: `rustfmt::skip` is a path,
+    ///   and not a word and should instead be parsed using [`path`](Self::path)
+    pub fn word(&self) -> Option<(Ident, &ArgParser<'a>)> {
+        let (path, args) = self.deconstruct();
+        Some((path.word()?, args))
+    }
+
+    /// Like [`word`](Self::word), but returns an empty symbol instead of None
+    pub fn word_or_empty(&self) -> (Ident, &ArgParser<'a>) {
+        let (path, args) = self.deconstruct();
+        (path.word().unwrap_or(Ident::empty()), args)
+    }
+
+    /// Asserts that this MetaItem starts with some specific word.
+    ///
+    /// See [`word`](Self::word) for examples of what a word is.
+    pub fn word_is(&self, sym: Symbol) -> Option<&ArgParser<'a>> {
+        self.path_without_args().word_is(sym).then(|| self.args())
+    }
+
+    /// Asserts that this MetaItem starts with some specific path.
+    ///
+    /// See [`word`](Self::path) for examples of what a word is.
+    pub fn path_is(&self, segments: &[Symbol]) -> Option<&ArgParser<'a>> {
+        self.path_without_args().segments_is(segments).then(|| self.args())
+    }
+}
+
+#[derive(Clone)]
+pub struct NameValueParser {
+    pub eq_span: Span,
+    value: MetaItemLit,
+    pub value_span: Span,
+}
+
+impl Debug for NameValueParser {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        f.debug_struct("NameValueParser")
+            .field("eq_span", &self.eq_span)
+            .field("value", &self.value)
+            .field("value_span", &self.value_span)
+            .finish()
+    }
+}
+
+impl NameValueParser {
+    pub fn value_as_lit(&self) -> &MetaItemLit {
+        &self.value
+    }
+
+    pub fn value_as_str(&self) -> Option<Symbol> {
+        self.value_as_lit().kind.str()
+    }
+}
+
+fn expr_to_lit(dcx: DiagCtxtHandle<'_>, expr: &Expr, span: Span) -> MetaItemLit {
+    // In valid code the value always ends up as a single literal. Otherwise, a dummy
+    // literal suffices because the error is handled elsewhere.
+    if let ExprKind::Lit(token_lit) = expr.kind
+        && let Ok(lit) = MetaItemLit::from_token_lit(token_lit, expr.span)
+    {
+        lit
+    } else {
+        let guar = dcx.span_delayed_bug(
+            span,
+            "expr in place where literal is expected (builtin attr parsing)",
+        );
+        MetaItemLit { symbol: kw::Empty, suffix: None, kind: LitKind::Err(guar), span }
+    }
+}
+
+struct MetaItemListParserContext<'a> {
+    // the tokens inside the delimiters, so `#[some::attr(a b c)]` would have `a b c` inside
+    inside_delimiters: Peekable<TokenStreamIter<'a>>,
+    dcx: DiagCtxtHandle<'a>,
+}
+
+impl<'a> MetaItemListParserContext<'a> {
+    fn done(&mut self) -> bool {
+        self.inside_delimiters.peek().is_none()
+    }
+
+    fn next_path(&mut self) -> Option<AttrPath> {
+        // FIXME: Share code with `parse_path`.
+        let tt = self.inside_delimiters.next().map(|tt| TokenTree::uninterpolate(tt));
+
+        match tt.as_deref()? {
+            &TokenTree::Token(
+                Token { kind: ref kind @ (token::Ident(..) | token::PathSep), span },
+                _,
+            ) => {
+                // here we have either an ident or pathsep `::`.
+
+                let mut segments = if let &token::Ident(name, _) = kind {
+                    // when we lookahead another pathsep, more path's coming
+                    if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
+                        self.inside_delimiters.peek()
+                    {
+                        self.inside_delimiters.next();
+                        vec![Ident::new(name, span)]
+                    } else {
+                        // else we have a single identifier path, that's all
+                        return Some(AttrPath {
+                            segments: vec![Ident::new(name, span)].into_boxed_slice(),
+                            span,
+                        });
+                    }
+                } else {
+                    // if `::` is all we get, we just got a path root
+                    vec![Ident::new(kw::PathRoot, span)]
+                };
+
+                // one segment accepted. accept n more
+                loop {
+                    // another ident?
+                    if let Some(&TokenTree::Token(Token { kind: token::Ident(name, _), span }, _)) =
+                        self.inside_delimiters
+                            .next()
+                            .map(|tt| TokenTree::uninterpolate(tt))
+                            .as_deref()
+                    {
+                        segments.push(Ident::new(name, span));
+                    } else {
+                        return None;
+                    }
+                    // stop unless we see another `::`
+                    if let Some(TokenTree::Token(Token { kind: token::PathSep, .. }, _)) =
+                        self.inside_delimiters.peek()
+                    {
+                        self.inside_delimiters.next();
+                    } else {
+                        break;
+                    }
+                }
+                let span = span.with_hi(segments.last().unwrap().span.hi());
+                Some(AttrPath { segments: segments.into_boxed_slice(), span })
+            }
+            TokenTree::Token(Token { kind: token::OpenDelim(_) | token::CloseDelim(_), .. }, _) => {
+                None
+            }
+            _ => {
+                // malformed attributes can get here. We can't crash, but somewhere else should've
+                // already warned for this.
+                None
+            }
+        }
+    }
+
+    fn value(&mut self) -> Option<MetaItemLit> {
+        match self.inside_delimiters.next() {
+            Some(TokenTree::Delimited(.., Delimiter::Invisible(_), inner_tokens)) => {
+                MetaItemListParserContext {
+                    inside_delimiters: inner_tokens.iter().peekable(),
+                    dcx: self.dcx,
+                }
+                .value()
+            }
+            Some(TokenTree::Token(token, _)) => MetaItemLit::from_token(token),
+            _ => None,
+        }
+    }
+
+    /// parses one element on the inside of a list attribute like `#[my_attr( <insides> )]`
+    ///
+    /// parses a path followed be either:
+    /// 1. nothing (a word attr)
+    /// 2. a parenthesized list
+    /// 3. an equals sign and a literal (name-value)
+    ///
+    /// Can also parse *just* a literal. This is for cases like as `#[my_attr("literal")]`
+    /// where no path is given before the literal
+    ///
+    /// Some exceptions too for interpolated attributes which are already pre-processed
+    fn next(&mut self) -> Option<MetaItemOrLitParser<'a>> {
+        // a list element is either a literal
+        if let Some(TokenTree::Token(token, _)) = self.inside_delimiters.peek()
+            && let Some(lit) = MetaItemLit::from_token(token)
+        {
+            self.inside_delimiters.next();
+            return Some(MetaItemOrLitParser::Lit(lit));
+        }
+
+        // or a path.
+        let path =
+            if let Some(TokenTree::Token(Token { kind: token::Interpolated(_), span, .. }, _)) =
+                self.inside_delimiters.peek()
+            {
+                self.inside_delimiters.next();
+                // We go into this path if an expr ended up in an attribute that
+                // expansion did not turn into a literal. Say, `#[repr(align(macro!()))]`
+                // where the macro didn't expand to a literal. An error is already given
+                // for this at this point, and then we do continue. This makes this path
+                // reachable...
+                let e = self.dcx.span_delayed_bug(
+                    *span,
+                    "expr in place where literal is expected (builtin attr parsing)",
+                );
+
+                return Some(MetaItemOrLitParser::Err(*span, e));
+            } else {
+                self.next_path()?
+            };
+
+        // Paths can be followed by:
+        // - `(more meta items)` (another list)
+        // - `= lit` (a name-value)
+        // - nothing
+        Some(MetaItemOrLitParser::MetaItemParser(match self.inside_delimiters.peek() {
+            Some(TokenTree::Delimited(dspan, _, Delimiter::Parenthesis, inner_tokens)) => {
+                self.inside_delimiters.next();
+
+                MetaItemParser {
+                    path: PathParser::Attr(path),
+                    args: ArgParser::List(MetaItemListParser::new_tts(
+                        inner_tokens.iter(),
+                        dspan.entire(),
+                        self.dcx,
+                    )),
+                }
+            }
+            Some(TokenTree::Delimited(_, ..)) => {
+                self.inside_delimiters.next();
+                // self.dcx.span_delayed_bug(span.entire(), "wrong delimiters");
+                return None;
+            }
+            Some(TokenTree::Token(Token { kind: token::Eq, span }, _)) => {
+                self.inside_delimiters.next();
+                let value = self.value()?;
+                MetaItemParser {
+                    path: PathParser::Attr(path),
+                    args: ArgParser::NameValue(NameValueParser {
+                        eq_span: *span,
+                        value_span: value.span,
+                        value,
+                    }),
+                }
+            }
+            _ => MetaItemParser { path: PathParser::Attr(path), args: ArgParser::NoArgs },
+        }))
+    }
+
+    fn parse(mut self, span: Span) -> MetaItemListParser<'a> {
+        let mut sub_parsers = Vec::new();
+
+        while !self.done() {
+            let Some(n) = self.next() else {
+                continue;
+            };
+            sub_parsers.push(n);
+
+            match self.inside_delimiters.peek() {
+                None | Some(TokenTree::Token(Token { kind: token::Comma, .. }, _)) => {
+                    self.inside_delimiters.next();
+                }
+                Some(_) => {}
+            }
+        }
+
+        MetaItemListParser { sub_parsers, span }
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct MetaItemListParser<'a> {
+    sub_parsers: Vec<MetaItemOrLitParser<'a>>,
+    pub span: Span,
+}
+
+impl<'a> MetaItemListParser<'a> {
+    fn new(delim: &'a DelimArgs, dcx: DiagCtxtHandle<'a>) -> MetaItemListParser<'a> {
+        MetaItemListParser::new_tts(delim.tokens.iter(), delim.dspan.entire(), dcx)
+    }
+
+    fn new_tts(tts: TokenStreamIter<'a>, span: Span, dcx: DiagCtxtHandle<'a>) -> Self {
+        MetaItemListParserContext { inside_delimiters: tts.peekable(), dcx }.parse(span)
+    }
+
+    /// Lets you pick and choose as what you want to parse each element in the list
+    pub fn mixed<'s>(&'s self) -> impl Iterator<Item = &'s MetaItemOrLitParser<'a>> + 's {
+        self.sub_parsers.iter()
+    }
+
+    pub fn len(&self) -> usize {
+        self.sub_parsers.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.len() == 0
+    }
+
+    /// Asserts that every item in the list is another list starting with a word.
+    ///
+    /// See [`MetaItemParser::word`] for examples of words.
+    pub fn all_word_list<'s>(&'s self) -> Option<Vec<(Ident, &'s ArgParser<'a>)>> {
+        self.mixed().map(|i| i.meta_item()?.word()).collect()
+    }
+
+    /// Asserts that every item in the list is another list starting with a full path.
+    ///
+    /// See [`MetaItemParser::path`] for examples of paths.
+    pub fn all_path_list<'s>(&'s self) -> Option<Vec<(PathParser<'a>, &'s ArgParser<'a>)>> {
+        self.mixed().map(|i| Some(i.meta_item()?.path())).collect()
+    }
+
+    /// Returns Some if the list contains only a single element.
+    ///
+    /// Inside the Some is the parser to parse this single element.
+    pub fn single(&self) -> Option<&MetaItemOrLitParser<'a>> {
+        let mut iter = self.mixed();
+        iter.next().filter(|_| iter.next().is_none())
+    }
+}
diff --git a/compiler/rustc_attr_parsing/src/session_diagnostics.rs b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
index 92bc2a8aeb05..9d34b807ac2f 100644
--- a/compiler/rustc_attr_parsing/src/session_diagnostics.rs
+++ b/compiler/rustc_attr_parsing/src/session_diagnostics.rs
@@ -6,9 +6,16 @@ use rustc_errors::{Applicability, Diag, DiagCtxtHandle, Diagnostic, EmissionGuar
 use rustc_macros::{Diagnostic, Subdiagnostic};
 use rustc_span::{Span, Symbol};
 
-use crate::attributes::util::UnsupportedLiteralReason;
 use crate::fluent_generated as fluent;
 
+pub(crate) enum UnsupportedLiteralReason {
+    Generic,
+    CfgString,
+    CfgBoolean,
+    DeprecatedString,
+    DeprecatedKvPair,
+}
+
 #[derive(Diagnostic)]
 #[diag(attr_parsing_expected_one_cfg_pattern, code = E0536)]
 pub(crate) struct ExpectedOneCfgPattern {
@@ -39,6 +46,21 @@ pub(crate) struct MultipleItem {
 pub(crate) struct IncorrectMetaItem {
     #[primary_span]
     pub span: Span,
+
+    #[subdiagnostic]
+    pub suggestion: Option<IncorrectMetaItemSuggestion>,
+}
+
+#[derive(Subdiagnostic)]
+#[multipart_suggestion(
+    attr_parsing_incorrect_meta_item_suggestion,
+    applicability = "maybe-incorrect"
+)]
+pub(crate) struct IncorrectMetaItemSuggestion {
+    #[suggestion_part(code = "\"")]
+    pub lo: Span,
+    #[suggestion_part(code = "\"")]
+    pub hi: Span,
 }
 
 /// Error code: E0541
@@ -337,13 +359,6 @@ pub(crate) struct RustcPromotablePairing {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(attr_parsing_rustc_const_stable_indirect_pairing)]
-pub(crate) struct RustcConstStableIndirectPairing {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(attr_parsing_rustc_allowed_unstable_pairing, code = E0789)]
 pub(crate) struct RustcAllowedUnstablePairing {
@@ -423,3 +438,44 @@ pub(crate) struct UnknownVersionLiteral {
     #[primary_span]
     pub span: Span,
 }
+
+// FIXME(jdonszelmann) duplicated from `rustc_passes`, remove once `check_attr` is integrated.
+#[derive(Diagnostic)]
+#[diag(attr_parsing_unused_multiple)]
+pub(crate) struct UnusedMultiple {
+    #[primary_span]
+    #[suggestion(code = "", applicability = "machine-applicable")]
+    pub this: Span,
+    #[note]
+    pub other: Span,
+    pub name: Symbol,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_stability_outside_std, code = E0734)]
+pub(crate) struct StabilityOutsideStd {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_empty_confusables)]
+pub(crate) struct EmptyConfusables {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_repr_ident, code = E0565)]
+pub(crate) struct ReprIdent {
+    #[primary_span]
+    pub span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(attr_parsing_unrecognized_repr_hint, code = E0552)]
+#[help]
+pub(crate) struct UnrecognizedReprHint {
+    #[primary_span]
+    pub span: Span,
+}
diff --git a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
index f33f2ab58e05..2694a1eda78d 100644
--- a/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/conflict_errors.rs
@@ -287,7 +287,6 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                 None => "value".to_owned(),
             };
             if needs_note {
-                let ty = self.infcx.tcx.short_string(ty, err.long_ty_path());
                 if let Some(local) = place.as_local() {
                     let span = self.body.local_decls[local].source_info.span;
                     err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
diff --git a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
index 5e83d2ffa97a..29cc749877b3 100644
--- a/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/move_errors.rs
@@ -596,10 +596,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                         self.suggest_cloning(err, place_ty, expr, None);
                     }
 
-                    let ty = self.infcx.tcx.short_string(place_ty, err.long_ty_path());
                     err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
                         is_partial_move: false,
-                        ty,
+                        ty: place_ty,
                         place: &place_desc,
                         span,
                     });
@@ -629,10 +628,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     self.suggest_cloning(err, place_ty, expr, Some(use_spans));
                 }
 
-                let ty = self.infcx.tcx.short_string(place_ty, err.long_ty_path());
                 err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
                     is_partial_move: false,
-                    ty,
+                    ty: place_ty,
                     place: &place_desc,
                     span: use_span,
                 });
@@ -833,10 +831,9 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
                     self.suggest_cloning(err, bind_to.ty, expr, None);
                 }
 
-                let ty = self.infcx.tcx.short_string(bind_to.ty, err.long_ty_path());
                 err.subdiagnostic(crate::session_diagnostics::TypeNoCopy::Label {
                     is_partial_move: false,
-                    ty,
+                    ty: bind_to.ty,
                     place: place_desc,
                     span: binding_span,
                 });
diff --git a/compiler/rustc_borrowck/src/diagnostics/region_name.rs b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
index be28f84debd9..a15f9744bf31 100644
--- a/compiler/rustc_borrowck/src/diagnostics/region_name.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/region_name.rs
@@ -194,8 +194,8 @@ impl Display for RegionName {
 }
 
 impl rustc_errors::IntoDiagArg for RegionName {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
+        self.to_string().into_diag_arg(path)
     }
 }
 
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index a98984a4b4c7..68e0ab0933e6 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -648,7 +648,7 @@ impl<'a, 'tcx> ResultsVisitor<'a, 'tcx, Borrowck<'a, 'tcx>> for MirBorrowckCtxt<
             | StatementKind::StorageLive(..) => {}
             // This does not affect borrowck
             StatementKind::BackwardIncompatibleDropHint { place, reason: BackwardIncompatibleDropReason::Edition2024 } => {
-                self.check_backward_incompatible_drop(location, (**place, span), state);
+                self.check_backward_incompatible_drop(location, **place, state);
             }
             StatementKind::StorageDead(local) => {
                 self.access_place(
@@ -1174,7 +1174,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
     fn check_backward_incompatible_drop(
         &mut self,
         location: Location,
-        (place, place_span): (Place<'tcx>, Span),
+        place: Place<'tcx>,
         state: &BorrowckDomain,
     ) {
         let tcx = self.infcx.tcx;
diff --git a/compiler/rustc_borrowck/src/session_diagnostics.rs b/compiler/rustc_borrowck/src/session_diagnostics.rs
index 11b30c145c2c..4be5d0dbf428 100644
--- a/compiler/rustc_borrowck/src/session_diagnostics.rs
+++ b/compiler/rustc_borrowck/src/session_diagnostics.rs
@@ -459,17 +459,17 @@ pub(crate) enum OnClosureNote<'a> {
 }
 
 #[derive(Subdiagnostic)]
-pub(crate) enum TypeNoCopy<'a> {
+pub(crate) enum TypeNoCopy<'a, 'tcx> {
     #[label(borrowck_ty_no_impl_copy)]
     Label {
         is_partial_move: bool,
-        ty: String,
+        ty: Ty<'tcx>,
         place: &'a str,
         #[primary_span]
         span: Span,
     },
     #[note(borrowck_ty_no_impl_copy)]
-    Note { is_partial_move: bool, ty: String, place: &'a str },
+    Note { is_partial_move: bool, ty: Ty<'tcx>, place: &'a str },
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
index 12e8be41614b..dc35d5eb89c9 100644
--- a/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
+++ b/compiler/rustc_borrowck/src/type_check/liveness/trace.rs
@@ -4,7 +4,6 @@ use rustc_index::interval::IntervalSet;
 use rustc_infer::infer::canonical::QueryRegionConstraints;
 use rustc_infer::infer::outlives::for_liveness;
 use rustc_middle::mir::{BasicBlock, Body, ConstraintCategory, HasLocalDecls, Local, Location};
-use rustc_middle::span_bug;
 use rustc_middle::traits::query::DropckOutlivesResult;
 use rustc_middle::ty::relate::Relate;
 use rustc_middle::ty::{Ty, TyCtxt, TypeVisitable, TypeVisitableExt};
@@ -12,7 +11,7 @@ use rustc_mir_dataflow::ResultsCursor;
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::{HasMoveData, MoveData, MovePathIndex};
 use rustc_mir_dataflow::points::{DenseLocationMap, PointIndex};
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, ErrorGuaranteed, Span};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits::ObligationCtxt;
 use rustc_trait_selection::traits::query::dropck_outlives;
@@ -608,7 +607,7 @@ impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
             Ok(TypeOpOutput { output, constraints, .. }) => {
                 DropData { dropck_result: output, region_constraint_data: constraints }
             }
-            Err(_) => {
+            Err(ErrorGuaranteed { .. }) => {
                 // We don't run dropck on HIR, and dropck looks inside fields of
                 // types, so there's no guarantee that it succeeds. We also
                 // can't rely on the the `ErrorGuaranteed` from `fully_perform` here
@@ -631,10 +630,10 @@ impl<'tcx> LivenessContext<'_, '_, '_, 'tcx> {
                         }
                     };
 
+                    // Could have no errors if a type lowering error, say, caused the query
+                    // to fail.
                     if !errors.is_empty() {
                         typeck.infcx.err_ctxt().report_fulfillment_errors(errors);
-                    } else {
-                        span_bug!(span, "Rerunning drop data query produced no error.");
                     }
                 });
                 DropData { dropck_result: Default::default(), region_constraint_data: None }
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index bd0d98028ae8..6d05696e146f 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -38,7 +38,7 @@ use rustc_mir_dataflow::move_paths::MoveData;
 use rustc_mir_dataflow::points::DenseLocationMap;
 use rustc_span::def_id::CRATE_DEF_ID;
 use rustc_span::source_map::Spanned;
-use rustc_span::{DUMMY_SP, Span, sym};
+use rustc_span::{Span, sym};
 use rustc_trait_selection::traits::query::type_op::custom::scrape_region_constraints;
 use rustc_trait_selection::traits::query::type_op::{TypeOp, TypeOpOutput};
 use tracing::{debug, instrument, trace};
@@ -51,7 +51,6 @@ use crate::polonius::legacy::{PoloniusFacts, PoloniusLocationTable};
 use crate::polonius::{PoloniusContext, PoloniusLivenessContext};
 use crate::region_infer::TypeTest;
 use crate::region_infer::values::{LivenessValues, PlaceholderIndex, PlaceholderIndices};
-use crate::renumber::RegionCtxt;
 use crate::session_diagnostics::{MoveUnsized, SimdIntrinsicArgConst};
 use crate::type_check::free_region_relations::{CreateResult, UniversalRegionRelations};
 use crate::universal_regions::{DefiningTy, UniversalRegions};
@@ -2121,35 +2120,31 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
                                 //
                                 // Note that other checks (such as denying `dyn Send` -> `dyn
                                 // Debug`) are in `rustc_hir_typeck`.
-                                if let ty::Dynamic(src_tty, ..) = src_tail.kind()
-                                    && let ty::Dynamic(dst_tty, ..) = dst_tail.kind()
+                                if let ty::Dynamic(src_tty, _src_lt, _) = *src_tail.kind()
+                                    && let ty::Dynamic(dst_tty, dst_lt, _) = *dst_tail.kind()
                                     && src_tty.principal().is_some()
                                     && dst_tty.principal().is_some()
                                 {
                                     // Remove auto traits.
                                     // Auto trait checks are handled in `rustc_hir_typeck` as FCW.
-                                    let src_obj = tcx.mk_ty_from_kind(ty::Dynamic(
+                                    let src_obj = Ty::new_dynamic(
+                                        tcx,
                                         tcx.mk_poly_existential_predicates(
                                             &src_tty.without_auto_traits().collect::<Vec<_>>(),
                                         ),
-                                        tcx.lifetimes.re_static,
+                                        // FIXME: Once we disallow casting `*const dyn Trait + 'short`
+                                        // to `*const dyn Trait + 'long`, then this can just be `src_lt`.
+                                        dst_lt,
                                         ty::Dyn,
-                                    ));
-                                    let dst_obj = tcx.mk_ty_from_kind(ty::Dynamic(
+                                    );
+                                    let dst_obj = Ty::new_dynamic(
+                                        tcx,
                                         tcx.mk_poly_existential_predicates(
                                             &dst_tty.without_auto_traits().collect::<Vec<_>>(),
                                         ),
-                                        tcx.lifetimes.re_static,
+                                        dst_lt,
                                         ty::Dyn,
-                                    ));
-
-                                    // Replace trait object lifetimes with fresh vars, to allow
-                                    // casts like
-                                    // `*mut dyn FnOnce() + 'a` -> `*mut dyn FnOnce() + 'static`
-                                    let src_obj =
-                                        freshen_single_trait_object_lifetime(self.infcx, src_obj);
-                                    let dst_obj =
-                                        freshen_single_trait_object_lifetime(self.infcx, dst_obj);
+                                    );
 
                                     debug!(?src_tty, ?dst_tty, ?src_obj, ?dst_obj);
 
@@ -2707,16 +2702,3 @@ impl<'tcx> TypeOp<'tcx> for InstantiateOpaqueType<'tcx> {
         Ok(output)
     }
 }
-
-fn freshen_single_trait_object_lifetime<'tcx>(
-    infcx: &BorrowckInferCtxt<'tcx>,
-    ty: Ty<'tcx>,
-) -> Ty<'tcx> {
-    let &ty::Dynamic(tty, _, dyn_kind @ ty::Dyn) = ty.kind() else { bug!("expected trait object") };
-
-    let fresh = infcx
-        .next_region_var(rustc_infer::infer::RegionVariableOrigin::MiscVariable(DUMMY_SP), || {
-            RegionCtxt::Unknown
-        });
-    infcx.tcx.mk_ty_from_kind(ty::Dynamic(tty, fresh, dyn_kind))
-}
diff --git a/compiler/rustc_builtin_macros/Cargo.toml b/compiler/rustc_builtin_macros/Cargo.toml
index f29be2ee8185..b5f4f2efd1f5 100644
--- a/compiler/rustc_builtin_macros/Cargo.toml
+++ b/compiler/rustc_builtin_macros/Cargo.toml
@@ -20,6 +20,7 @@ rustc_errors = { path = "../rustc_errors" }
 rustc_expand = { path = "../rustc_expand" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
+rustc_hir = { path = "../rustc_hir" }
 rustc_index = { path = "../rustc_index" }
 rustc_lexer = { path = "../rustc_lexer" }
 rustc_lint_defs = { path = "../rustc_lint_defs" }
diff --git a/compiler/rustc_builtin_macros/src/autodiff.rs b/compiler/rustc_builtin_macros/src/autodiff.rs
index 8d7ac6de8010..6d9c35756574 100644
--- a/compiler/rustc_builtin_macros/src/autodiff.rs
+++ b/compiler/rustc_builtin_macros/src/autodiff.rs
@@ -3,7 +3,6 @@
 //! configs (autodiff enabled or disabled), so we have to add cfg's to each import.
 //! FIXME(ZuseZ4): Remove this once we have a smarter linter.
 
-#[cfg(llvm_enzyme)]
 mod llvm_enzyme {
     use std::str::FromStr;
     use std::string::String;
@@ -130,10 +129,14 @@ mod llvm_enzyme {
         meta_item: &ast::MetaItem,
         mut item: Annotatable,
     ) -> Vec<Annotatable> {
+        if cfg!(not(llvm_enzyme)) {
+            ecx.sess.dcx().emit_err(errors::AutoDiffSupportNotBuild { span: meta_item.span });
+            return vec![item];
+        }
         let dcx = ecx.sess.dcx();
         // first get the annotable item:
         let (sig, is_impl): (FnSig, bool) = match &item {
-            Annotatable::Item(ref iitem) => {
+            Annotatable::Item(iitem) => {
                 let sig = match &iitem.kind {
                     ItemKind::Fn(box ast::Fn { sig, .. }) => sig,
                     _ => {
@@ -143,7 +146,7 @@ mod llvm_enzyme {
                 };
                 (sig.clone(), false)
             }
-            Annotatable::AssocItem(ref assoc_item, _) => {
+            Annotatable::AssocItem(assoc_item, _) => {
                 let sig = match &assoc_item.kind {
                     ast::AssocItemKind::Fn(box ast::Fn { sig, .. }) => sig,
                     _ => {
@@ -171,8 +174,8 @@ mod llvm_enzyme {
         let sig_span = ecx.with_call_site_ctxt(sig.span);
 
         let (vis, primal) = match &item {
-            Annotatable::Item(ref iitem) => (iitem.vis.clone(), iitem.ident.clone()),
-            Annotatable::AssocItem(ref assoc_item, _) => {
+            Annotatable::Item(iitem) => (iitem.vis.clone(), iitem.ident.clone()),
+            Annotatable::AssocItem(assoc_item, _) => {
                 (assoc_item.vis.clone(), assoc_item.ident.clone())
             }
             _ => {
@@ -801,25 +804,4 @@ mod llvm_enzyme {
     }
 }
 
-#[cfg(not(llvm_enzyme))]
-mod ad_fallback {
-    use rustc_ast::ast;
-    use rustc_expand::base::{Annotatable, ExtCtxt};
-    use rustc_span::Span;
-
-    use crate::errors;
-    pub(crate) fn expand(
-        ecx: &mut ExtCtxt<'_>,
-        _expand_span: Span,
-        meta_item: &ast::MetaItem,
-        item: Annotatable,
-    ) -> Vec<Annotatable> {
-        ecx.sess.dcx().emit_err(errors::AutoDiffSupportNotBuild { span: meta_item.span });
-        return vec![item];
-    }
-}
-
-#[cfg(not(llvm_enzyme))]
-pub(crate) use ad_fallback::expand;
-#[cfg(llvm_enzyme)]
 pub(crate) use llvm_enzyme::expand;
diff --git a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
index 234ec8582165..6b59ac258275 100644
--- a/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
+++ b/compiler/rustc_builtin_macros/src/deriving/generic/mod.rs
@@ -185,8 +185,9 @@ use rustc_ast::{
     self as ast, AnonConst, BindingMode, ByRef, EnumDef, Expr, GenericArg, GenericParamKind,
     Generics, Mutability, PatKind, VariantData,
 };
-use rustc_attr_parsing as attr;
+use rustc_attr_parsing::{AttributeKind, AttributeParser, ReprPacked};
 use rustc_expand::base::{Annotatable, ExtCtxt};
+use rustc_hir::Attribute;
 use rustc_span::{DUMMY_SP, Ident, Span, Symbol, kw, sym};
 use thin_vec::{ThinVec, thin_vec};
 use ty::{Bounds, Path, Ref, Self_, Ty};
@@ -480,14 +481,10 @@ impl<'a> TraitDef<'a> {
     ) {
         match item {
             Annotatable::Item(item) => {
-                let is_packed = item.attrs.iter().any(|attr| {
-                    for r in attr::find_repr_attrs(cx.sess, attr) {
-                        if let attr::ReprPacked(_) = r {
-                            return true;
-                        }
-                    }
-                    false
-                });
+                let is_packed = matches!(
+                    AttributeParser::parse_limited(cx.sess, &item.attrs, sym::repr, item.span, true),
+                    Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.iter().any(|(x, _)| matches!(x, ReprPacked(..)))
+                );
 
                 let newitem = match &item.kind {
                     ast::ItemKind::Struct(struct_def, generics) => self.expand_struct_def(
diff --git a/compiler/rustc_builtin_macros/src/errors.rs b/compiler/rustc_builtin_macros/src/errors.rs
index 6213bd802c75..ab1e0d8ee896 100644
--- a/compiler/rustc_builtin_macros/src/errors.rs
+++ b/compiler/rustc_builtin_macros/src/errors.rs
@@ -144,10 +144,8 @@ pub(crate) struct AllocMustStatics {
     pub(crate) span: Span,
 }
 
-#[cfg(llvm_enzyme)]
 pub(crate) use autodiff::*;
 
-#[cfg(llvm_enzyme)]
 mod autodiff {
     use super::*;
     #[derive(Diagnostic)]
@@ -203,9 +201,7 @@ mod autodiff {
     }
 }
 
-#[cfg(not(llvm_enzyme))]
 pub(crate) use ad_fallback::*;
-#[cfg(not(llvm_enzyme))]
 mod ad_fallback {
     use super::*;
     #[derive(Diagnostic)]
diff --git a/compiler/rustc_codegen_cranelift/example/mini_core.rs b/compiler/rustc_codegen_cranelift/example/mini_core.rs
index 79820232496a..72c9df59d833 100644
--- a/compiler/rustc_codegen_cranelift/example/mini_core.rs
+++ b/compiler/rustc_codegen_cranelift/example/mini_core.rs
@@ -620,70 +620,31 @@ pub union MaybeUninit<T> {
 
 pub mod intrinsics {
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn size_of<T>() -> usize {
-        loop {}
-    }
+    pub fn size_of<T>() -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn size_of_val<T: ?::Sized>(_val: *const T) -> usize {
-        loop {}
-    }
+    pub unsafe fn size_of_val<T: ?::Sized>(_val: *const T) -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn min_align_of<T>() -> usize {
-        loop {}
-    }
+    pub fn min_align_of<T>() -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn min_align_of_val<T: ?::Sized>(_val: *const T) -> usize {
-        loop {}
-    }
+    pub unsafe fn min_align_of_val<T: ?::Sized>(_val: *const T) -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize) {
-        loop {}
-    }
+    pub unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize);
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn transmute<T, U>(_e: T) -> U {
-        loop {}
-    }
+    pub unsafe fn transmute<T, U>(_e: T) -> U;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn ctlz_nonzero<T>(_x: T) -> u32 {
-        loop {}
-    }
+    pub unsafe fn ctlz_nonzero<T>(_x: T) -> u32;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn needs_drop<T: ?::Sized>() -> bool {
-        loop {}
-    }
+    pub fn needs_drop<T: ?::Sized>() -> bool;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn bitreverse<T>(_x: T) -> T {
-        loop {}
-    }
+    pub fn bitreverse<T>(_x: T) -> T;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn bswap<T>(_x: T) -> T {
-        loop {}
-    }
+    pub fn bswap<T>(_x: T) -> T;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize) {
-        loop {}
-    }
+    pub unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize);
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn unreachable() -> ! {
-        loop {}
-    }
+    pub unsafe fn unreachable() -> !;
 }
 
 pub mod libc {
diff --git a/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch b/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch
index 364a6a035ab8..bedc6ca11b3f 100644
--- a/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch
+++ b/compiler/rustc_codegen_cranelift/patches/0029-stdlib-Disable-f16-and-f128-in-compiler-builtins.patch
@@ -16,8 +16,8 @@ index 7165c3e48af..968552ad435 100644
  
  [dependencies]
  core = { path = "../core", public = true }
--compiler_builtins = { version = "=0.1.147", features = ['rustc-dep-of-std'] }
-+compiler_builtins = { version = "=0.1.147", features = ['rustc-dep-of-std', 'no-f16-f128'] }
+-compiler_builtins = { version = "=0.1.148", features = ['rustc-dep-of-std'] }
++compiler_builtins = { version = "=0.1.148", features = ['rustc-dep-of-std', 'no-f16-f128'] }
  
  [dev-dependencies]
  rand = { version = "0.8.5", default-features = false, features = ["alloc"] }
diff --git a/compiler/rustc_codegen_cranelift/src/abi/mod.rs b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
index 756a2226753f..e8076ce77abc 100644
--- a/compiler/rustc_codegen_cranelift/src/abi/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/abi/mod.rs
@@ -402,9 +402,13 @@ pub(crate) fn codegen_terminator_call<'tcx>(
 
         if is_call_from_compiler_builtins_to_upstream_monomorphization(fx.tcx, instance) {
             if target.is_some() {
-                let caller = with_no_trimmed_paths!(fx.tcx.def_path_str(fx.instance.def_id()));
-                let callee = with_no_trimmed_paths!(fx.tcx.def_path_str(def_id));
-                fx.tcx.dcx().emit_err(CompilerBuiltinsCannotCall { caller, callee });
+                let caller_def = fx.instance.def_id();
+                let e = CompilerBuiltinsCannotCall {
+                    span: fx.tcx.def_span(caller_def),
+                    caller: with_no_trimmed_paths!(fx.tcx.def_path_str(caller_def)),
+                    callee: with_no_trimmed_paths!(fx.tcx.def_path_str(def_id)),
+                };
+                fx.tcx.dcx().emit_err(e);
             } else {
                 fx.bcx.ins().trap(TrapCode::user(2).unwrap());
                 return;
diff --git a/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs b/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs
index b28c4c9539ce..06d89bc9ea7d 100644
--- a/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs
+++ b/compiler/rustc_codegen_cranelift/src/abi/pass_mode.rs
@@ -84,7 +84,7 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                     AbiParam::new(scalar_to_clif_type(tcx, scalar)),
                     attrs
                 )],
-                BackendRepr::Vector { .. } => {
+                BackendRepr::SimdVector { .. } => {
                     let vector_ty = crate::intrinsics::clif_vector_type(tcx, self.layout);
                     smallvec![AbiParam::new(vector_ty)]
                 }
@@ -135,7 +135,7 @@ impl<'tcx> ArgAbiExt<'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
                 BackendRepr::Scalar(scalar) => {
                     (None, vec![AbiParam::new(scalar_to_clif_type(tcx, scalar))])
                 }
-                BackendRepr::Vector { .. } => {
+                BackendRepr::SimdVector { .. } => {
                     let vector_ty = crate::intrinsics::clif_vector_type(tcx, self.layout);
                     (None, vec![AbiParam::new(vector_ty)])
                 }
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
index 4d9bed8652cb..6735ae024d1c 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -53,7 +53,7 @@ fn report_atomic_type_validation_error<'tcx>(
 
 pub(crate) fn clif_vector_type<'tcx>(tcx: TyCtxt<'tcx>, layout: TyAndLayout<'tcx>) -> Type {
     let (element, count) = match layout.backend_repr {
-        BackendRepr::Vector { element, count } => (element, count),
+        BackendRepr::SimdVector { element, count } => (element, count),
         _ => unreachable!(),
     };
 
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
index fcccda62355c..dd6d8dbb6f5e 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@@ -116,8 +116,8 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             });
         }
 
-        // simd_shuffle_generic<T, U, const I: &[u32]>(x: T, y: T) -> U
-        sym::simd_shuffle_generic => {
+        // simd_shuffle_const_generic<T, U, const I: &[u32]>(x: T, y: T) -> U
+        sym::simd_shuffle_const_generic => {
             let [x, y] = args else {
                 bug!("wrong number of args for intrinsic {intrinsic}");
             };
@@ -460,64 +460,6 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             });
         }
 
-        sym::simd_fpow => {
-            intrinsic_args!(fx, args => (a, b); intrinsic);
-
-            if !a.layout().ty.is_simd() {
-                report_simd_type_validation_error(fx, intrinsic, span, a.layout().ty);
-                return;
-            }
-
-            simd_pair_for_each_lane(fx, a, b, ret, &|fx, lane_ty, _ret_lane_ty, a_lane, b_lane| {
-                match lane_ty.kind() {
-                    ty::Float(FloatTy::F32) => fx.lib_call(
-                        "powf",
-                        vec![AbiParam::new(types::F32), AbiParam::new(types::F32)],
-                        vec![AbiParam::new(types::F32)],
-                        &[a_lane, b_lane],
-                    )[0],
-                    ty::Float(FloatTy::F64) => fx.lib_call(
-                        "pow",
-                        vec![AbiParam::new(types::F64), AbiParam::new(types::F64)],
-                        vec![AbiParam::new(types::F64)],
-                        &[a_lane, b_lane],
-                    )[0],
-                    _ => unreachable!("{:?}", lane_ty),
-                }
-            });
-        }
-
-        sym::simd_fpowi => {
-            intrinsic_args!(fx, args => (a, exp); intrinsic);
-            let exp = exp.load_scalar(fx);
-
-            if !a.layout().ty.is_simd() {
-                report_simd_type_validation_error(fx, intrinsic, span, a.layout().ty);
-                return;
-            }
-
-            simd_for_each_lane(
-                fx,
-                a,
-                ret,
-                &|fx, lane_ty, _ret_lane_ty, lane| match lane_ty.kind() {
-                    ty::Float(FloatTy::F32) => fx.lib_call(
-                        "__powisf2", // compiler-builtins
-                        vec![AbiParam::new(types::F32), AbiParam::new(types::I32)],
-                        vec![AbiParam::new(types::F32)],
-                        &[lane, exp],
-                    )[0],
-                    ty::Float(FloatTy::F64) => fx.lib_call(
-                        "__powidf2", // compiler-builtins
-                        vec![AbiParam::new(types::F64), AbiParam::new(types::I32)],
-                        vec![AbiParam::new(types::F64)],
-                        &[lane, exp],
-                    )[0],
-                    _ => unreachable!("{:?}", lane_ty),
-                },
-            );
-        }
-
         sym::simd_fsin
         | sym::simd_fcos
         | sym::simd_fexp
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index 1b3f86c8405d..cc739fefcd06 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -173,9 +173,11 @@ impl<'tcx> CValue<'tcx> {
             CValueInner::ByRef(ptr, None) => {
                 let clif_ty = match layout.backend_repr {
                     BackendRepr::Scalar(scalar) => scalar_to_clif_type(fx.tcx, scalar),
-                    BackendRepr::Vector { element, count } => scalar_to_clif_type(fx.tcx, element)
-                        .by(u32::try_from(count).unwrap())
-                        .unwrap(),
+                    BackendRepr::SimdVector { element, count } => {
+                        scalar_to_clif_type(fx.tcx, element)
+                            .by(u32::try_from(count).unwrap())
+                            .unwrap()
+                    }
                     _ => unreachable!("{:?}", layout.ty),
                 };
                 let mut flags = MemFlags::new();
diff --git a/compiler/rustc_codegen_gcc/example/mini_core.rs b/compiler/rustc_codegen_gcc/example/mini_core.rs
index 2ff1d757fd4e..3dad35bc4ce4 100644
--- a/compiler/rustc_codegen_gcc/example/mini_core.rs
+++ b/compiler/rustc_codegen_gcc/example/mini_core.rs
@@ -591,70 +591,31 @@ pub union MaybeUninit<T> {
 
 pub mod intrinsics {
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn size_of<T>() -> usize {
-        loop {}
-    }
+    pub fn size_of<T>() -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn size_of_val<T: ?::Sized>(_val: *const T) -> usize {
-        loop {}
-    }
+    pub unsafe fn size_of_val<T: ?::Sized>(_val: *const T) -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn min_align_of<T>() -> usize {
-        loop {}
-    }
+    pub fn min_align_of<T>() -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn min_align_of_val<T: ?::Sized>(_val: *const T) -> usize {
-        loop {}
-    }
+    pub unsafe fn min_align_of_val<T: ?::Sized>(_val: *const T) -> usize;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize) {
-        loop {}
-    }
+    pub unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize);
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn transmute<T, U>(_e: T) -> U {
-        loop {}
-    }
+    pub unsafe fn transmute<T, U>(_e: T) -> U;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn ctlz_nonzero<T>(_x: T) -> u32 {
-        loop {}
-    }
+    pub unsafe fn ctlz_nonzero<T>(_x: T) -> u32;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn needs_drop<T: ?::Sized>() -> bool {
-        loop {}
-    }
+    pub fn needs_drop<T: ?::Sized>() -> bool;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn bitreverse<T>(_x: T) -> T {
-        loop {}
-    }
+    pub fn bitreverse<T>(_x: T) -> T;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn bswap<T>(_x: T) -> T {
-        loop {}
-    }
+    pub fn bswap<T>(_x: T) -> T;
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize) {
-        loop {}
-    }
+    pub unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize);
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub unsafe fn unreachable() -> ! {
-        loop {}
-    }
+    pub unsafe fn unreachable() -> !;
 }
 
 pub mod libc {
diff --git a/compiler/rustc_codegen_gcc/src/back/lto.rs b/compiler/rustc_codegen_gcc/src/back/lto.rs
index cb4caec8c326..e5221c7da319 100644
--- a/compiler/rustc_codegen_gcc/src/back/lto.rs
+++ b/compiler/rustc_codegen_gcc/src/back/lto.rs
@@ -632,17 +632,16 @@ pub unsafe fn optimize_thin_module(
             Arc::new(SyncContext::new(context))
         }
     };
-    let module = ModuleCodegen {
-        module_llvm: GccContext {
+    let module = ModuleCodegen::new_regular(
+        thin_module.name().to_string(),
+        GccContext {
             context,
             should_combine_object_files,
             // TODO(antoyo): use the correct relocation model here.
             relocation_model: RelocModel::Pic,
             temp_dir: None,
         },
-        name: thin_module.name().to_string(),
-        kind: ModuleKind::Regular,
-    };
+    );
     /*{
         let target = &*module.module_llvm.tm;
         let llmod = module.module_llvm.llmod();
diff --git a/compiler/rustc_codegen_gcc/src/base.rs b/compiler/rustc_codegen_gcc/src/base.rs
index 962f4b161d78..9b495174a3fa 100644
--- a/compiler/rustc_codegen_gcc/src/base.rs
+++ b/compiler/rustc_codegen_gcc/src/base.rs
@@ -4,10 +4,10 @@ use std::sync::Arc;
 use std::time::Instant;
 
 use gccjit::{CType, Context, FunctionType, GlobalKind};
+use rustc_codegen_ssa::ModuleCodegen;
 use rustc_codegen_ssa::base::maybe_create_entry_wrapper;
 use rustc_codegen_ssa::mono_item::MonoItemExt;
 use rustc_codegen_ssa::traits::DebugInfoCodegenMethods;
-use rustc_codegen_ssa::{ModuleCodegen, ModuleKind};
 use rustc_middle::dep_graph;
 use rustc_middle::mir::mono::Linkage;
 #[cfg(feature = "master")]
@@ -237,16 +237,15 @@ pub fn compile_codegen_unit(
             }
         }
 
-        ModuleCodegen {
-            name: cgu_name.to_string(),
-            module_llvm: GccContext {
+        ModuleCodegen::new_regular(
+            cgu_name.to_string(),
+            GccContext {
                 context: Arc::new(SyncContext::new(context)),
                 relocation_model: tcx.sess.relocation_model(),
                 should_combine_object_files: false,
                 temp_dir: None,
             },
-            kind: ModuleKind::Regular,
-        }
+        )
     }
 
     (module, cost)
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
index f8672c072999..f38622074f18 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/mod.rs
@@ -312,7 +312,7 @@ impl<'a, 'gcc, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'a, 'gcc, 'tc
                 let layout = self.layout_of(tp_ty).layout;
                 let _use_integer_compare = match layout.backend_repr() {
                     Scalar(_) | ScalarPair(_, _) => true,
-                    Vector { .. } => false,
+                    SimdVector { .. } => false,
                     Memory { .. } => {
                         // For rusty ABIs, small aggregates are actually passed
                         // as `RegKind::Integer` (see `FnAbi::adjust_for_abi`),
diff --git a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
index 84cd5b002fbb..8b454ab2a424 100644
--- a/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
+++ b/compiler/rustc_codegen_gcc/src/intrinsic/simd.rs
@@ -772,8 +772,6 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
             sym::simd_floor => "floor",
             sym::simd_fma => "fma",
             sym::simd_relaxed_fma => "fma", // FIXME: this should relax to non-fused multiply-add when necessary
-            sym::simd_fpowi => "__builtin_powi",
-            sym::simd_fpow => "pow",
             sym::simd_fsin => "sin",
             sym::simd_fsqrt => "sqrt",
             sym::simd_round => "round",
@@ -788,24 +786,16 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
         let mut vector_elements = vec![];
         for i in 0..in_len {
             let index = bx.context.new_rvalue_from_long(bx.ulong_type, i as i64);
-            // we have to treat fpowi specially, since fpowi's second argument is always an i32
             let mut arguments = vec![];
-            if name == sym::simd_fpowi {
-                arguments = vec![
-                    bx.extract_element(args[0].immediate(), index).to_rvalue(),
-                    args[1].immediate(),
-                ];
-            } else {
-                for arg in args {
-                    let mut element = bx.extract_element(arg.immediate(), index).to_rvalue();
-                    // FIXME: it would probably be better to not have casts here and use the proper
-                    // instructions.
-                    if let Some(typ) = cast_type {
-                        element = bx.context.new_cast(None, element, typ);
-                    }
-                    arguments.push(element);
+            for arg in args {
+                let mut element = bx.extract_element(arg.immediate(), index).to_rvalue();
+                // FIXME: it would probably be better to not have casts here and use the proper
+                // instructions.
+                if let Some(typ) = cast_type {
+                    element = bx.context.new_cast(None, element, typ);
                 }
-            };
+                arguments.push(element);
+            }
             let mut result = bx.context.new_call(None, function, &arguments);
             if cast_type.is_some() {
                 result = bx.context.new_cast(None, result, elem_ty);
@@ -829,8 +819,6 @@ pub fn generic_simd_intrinsic<'a, 'gcc, 'tcx>(
             | sym::simd_floor
             | sym::simd_fma
             | sym::simd_relaxed_fma
-            | sym::simd_fpow
-            | sym::simd_fpowi
             | sym::simd_fsin
             | sym::simd_fsqrt
             | sym::simd_round
diff --git a/compiler/rustc_codegen_gcc/src/lib.rs b/compiler/rustc_codegen_gcc/src/lib.rs
index 6455bcec6851..9d91aab72ab3 100644
--- a/compiler/rustc_codegen_gcc/src/lib.rs
+++ b/compiler/rustc_codegen_gcc/src/lib.rs
@@ -393,7 +393,7 @@ impl WriteBackendMethods for GccCodegenBackend {
     unsafe fn optimize(
         _cgcx: &CodegenContext<Self>,
         _dcx: DiagCtxtHandle<'_>,
-        module: &ModuleCodegen<Self::Module>,
+        module: &mut ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<(), FatalError> {
         module.module_llvm.context.set_optimization_level(to_gcc_opt_level(config.opt_level));
diff --git a/compiler/rustc_codegen_gcc/src/type_of.rs b/compiler/rustc_codegen_gcc/src/type_of.rs
index bac4fc51300a..ae98b3d0b56e 100644
--- a/compiler/rustc_codegen_gcc/src/type_of.rs
+++ b/compiler/rustc_codegen_gcc/src/type_of.rs
@@ -63,7 +63,7 @@ fn uncached_gcc_type<'gcc, 'tcx>(
 ) -> Type<'gcc> {
     match layout.backend_repr {
         BackendRepr::Scalar(_) => bug!("handled elsewhere"),
-        BackendRepr::Vector { ref element, count } => {
+        BackendRepr::SimdVector { ref element, count } => {
             let element = layout.scalar_gcc_type_at(cx, element, Size::ZERO);
             let element =
                 // NOTE: gcc doesn't allow pointer types in vectors.
@@ -178,7 +178,7 @@ pub trait LayoutGccExt<'tcx> {
 impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
     fn is_gcc_immediate(&self) -> bool {
         match self.backend_repr {
-            BackendRepr::Scalar(_) | BackendRepr::Vector { .. } => true,
+            BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => true,
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => false,
         }
     }
@@ -186,9 +186,9 @@ impl<'tcx> LayoutGccExt<'tcx> for TyAndLayout<'tcx> {
     fn is_gcc_scalar_pair(&self) -> bool {
         match self.backend_repr {
             BackendRepr::ScalarPair(..) => true,
-            BackendRepr::Scalar(_) | BackendRepr::Vector { .. } | BackendRepr::Memory { .. } => {
-                false
-            }
+            BackendRepr::Scalar(_)
+            | BackendRepr::SimdVector { .. }
+            | BackendRepr::Memory { .. } => false,
         }
     }
 
diff --git a/compiler/rustc_codegen_gcc/tests/run/abort1.rs b/compiler/rustc_codegen_gcc/tests/run/abort1.rs
index 385e41a68817..fe46d9ae4184 100644
--- a/compiler/rustc_codegen_gcc/tests/run/abort1.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/abort1.rs
@@ -36,10 +36,7 @@ mod intrinsics {
 
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
 }
 
 /*
diff --git a/compiler/rustc_codegen_gcc/tests/run/abort2.rs b/compiler/rustc_codegen_gcc/tests/run/abort2.rs
index 6c66a930e074..4123f4f4beeb 100644
--- a/compiler/rustc_codegen_gcc/tests/run/abort2.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/abort2.rs
@@ -36,10 +36,7 @@ mod intrinsics {
 
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
 }
 
 /*
diff --git a/compiler/rustc_codegen_gcc/tests/run/assign.rs b/compiler/rustc_codegen_gcc/tests/run/assign.rs
index 4d414c577a65..286155852d50 100644
--- a/compiler/rustc_codegen_gcc/tests/run/assign.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/assign.rs
@@ -59,10 +59,7 @@ mod libc {
 mod intrinsics {
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
 }
 
 #[lang = "panic"]
diff --git a/compiler/rustc_codegen_gcc/tests/run/mut_ref.rs b/compiler/rustc_codegen_gcc/tests/run/mut_ref.rs
index 9be64f991ee0..b0215860406e 100644
--- a/compiler/rustc_codegen_gcc/tests/run/mut_ref.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/mut_ref.rs
@@ -61,10 +61,7 @@ mod libc {
 mod intrinsics {
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
 }
 
 #[lang = "panic"]
diff --git a/compiler/rustc_codegen_gcc/tests/run/operations.rs b/compiler/rustc_codegen_gcc/tests/run/operations.rs
index c92d3cc0b8fb..8ba7a4c5ed8c 100644
--- a/compiler/rustc_codegen_gcc/tests/run/operations.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/operations.rs
@@ -67,10 +67,7 @@ mod libc {
 mod intrinsics {
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
 }
 
 #[lang = "panic"]
diff --git a/compiler/rustc_codegen_gcc/tests/run/static.rs b/compiler/rustc_codegen_gcc/tests/run/static.rs
index 80c8782c4b1a..c3c8121b1e19 100644
--- a/compiler/rustc_codegen_gcc/tests/run/static.rs
+++ b/compiler/rustc_codegen_gcc/tests/run/static.rs
@@ -49,10 +49,7 @@ mod intrinsics {
 
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    pub fn abort() -> ! {
-        loop {}
-    }
+    pub fn abort() -> !;
 }
 
 mod libc {
diff --git a/compiler/rustc_codegen_llvm/src/asm.rs b/compiler/rustc_codegen_llvm/src/asm.rs
index be5673eddf93..e8a697431571 100644
--- a/compiler/rustc_codegen_llvm/src/asm.rs
+++ b/compiler/rustc_codegen_llvm/src/asm.rs
@@ -939,9 +939,10 @@ fn llvm_fixup_input<'ll, 'tcx>(
             }
             bx.insert_element(bx.const_undef(vec_ty), value, bx.const_i32(0))
         }
-        (AArch64(AArch64InlineAsmRegClass::vreg_low16), BackendRepr::Vector { element, count })
-            if layout.size.bytes() == 8 =>
-        {
+        (
+            AArch64(AArch64InlineAsmRegClass::vreg_low16),
+            BackendRepr::SimdVector { element, count },
+        ) if layout.size.bytes() == 8 => {
             let elem_ty = llvm_asm_scalar_type(bx.cx, element);
             let vec_ty = bx.cx.type_vector(elem_ty, count);
             let indices: Vec<_> = (0..count * 2).map(|x| bx.const_i32(x as i32)).collect();
@@ -954,7 +955,7 @@ fn llvm_fixup_input<'ll, 'tcx>(
         }
         (
             X86(X86InlineAsmRegClass::xmm_reg | X86InlineAsmRegClass::zmm_reg),
-            BackendRepr::Vector { .. },
+            BackendRepr::SimdVector { .. },
         ) if layout.size.bytes() == 64 => bx.bitcast(value, bx.cx.type_vector(bx.cx.type_f64(), 8)),
         (
             X86(
@@ -989,7 +990,7 @@ fn llvm_fixup_input<'ll, 'tcx>(
                 | X86InlineAsmRegClass::ymm_reg
                 | X86InlineAsmRegClass::zmm_reg,
             ),
-            BackendRepr::Vector { element, count: count @ (8 | 16) },
+            BackendRepr::SimdVector { element, count: count @ (8 | 16) },
         ) if element.primitive() == Primitive::Float(Float::F16) => {
             bx.bitcast(value, bx.type_vector(bx.type_i16(), count))
         }
@@ -1026,7 +1027,7 @@ fn llvm_fixup_input<'ll, 'tcx>(
                 | ArmInlineAsmRegClass::qreg_low4
                 | ArmInlineAsmRegClass::qreg_low8,
             ),
-            BackendRepr::Vector { element, count: count @ (4 | 8) },
+            BackendRepr::SimdVector { element, count: count @ (4 | 8) },
         ) if element.primitive() == Primitive::Float(Float::F16) => {
             bx.bitcast(value, bx.type_vector(bx.type_i16(), count))
         }
@@ -1099,9 +1100,10 @@ fn llvm_fixup_output<'ll, 'tcx>(
             }
             value
         }
-        (AArch64(AArch64InlineAsmRegClass::vreg_low16), BackendRepr::Vector { element, count })
-            if layout.size.bytes() == 8 =>
-        {
+        (
+            AArch64(AArch64InlineAsmRegClass::vreg_low16),
+            BackendRepr::SimdVector { element, count },
+        ) if layout.size.bytes() == 8 => {
             let elem_ty = llvm_asm_scalar_type(bx.cx, element);
             let vec_ty = bx.cx.type_vector(elem_ty, count * 2);
             let indices: Vec<_> = (0..count).map(|x| bx.const_i32(x as i32)).collect();
@@ -1114,7 +1116,7 @@ fn llvm_fixup_output<'ll, 'tcx>(
         }
         (
             X86(X86InlineAsmRegClass::xmm_reg | X86InlineAsmRegClass::zmm_reg),
-            BackendRepr::Vector { .. },
+            BackendRepr::SimdVector { .. },
         ) if layout.size.bytes() == 64 => bx.bitcast(value, layout.llvm_type(bx.cx)),
         (
             X86(
@@ -1145,7 +1147,7 @@ fn llvm_fixup_output<'ll, 'tcx>(
                 | X86InlineAsmRegClass::ymm_reg
                 | X86InlineAsmRegClass::zmm_reg,
             ),
-            BackendRepr::Vector { element, count: count @ (8 | 16) },
+            BackendRepr::SimdVector { element, count: count @ (8 | 16) },
         ) if element.primitive() == Primitive::Float(Float::F16) => {
             bx.bitcast(value, bx.type_vector(bx.type_f16(), count))
         }
@@ -1182,7 +1184,7 @@ fn llvm_fixup_output<'ll, 'tcx>(
                 | ArmInlineAsmRegClass::qreg_low4
                 | ArmInlineAsmRegClass::qreg_low8,
             ),
-            BackendRepr::Vector { element, count: count @ (4 | 8) },
+            BackendRepr::SimdVector { element, count: count @ (4 | 8) },
         ) if element.primitive() == Primitive::Float(Float::F16) => {
             bx.bitcast(value, bx.type_vector(bx.type_f16(), count))
         }
@@ -1243,9 +1245,10 @@ fn llvm_fixup_output_type<'ll, 'tcx>(
             let count = 16 / layout.size.bytes();
             cx.type_vector(elem_ty, count)
         }
-        (AArch64(AArch64InlineAsmRegClass::vreg_low16), BackendRepr::Vector { element, count })
-            if layout.size.bytes() == 8 =>
-        {
+        (
+            AArch64(AArch64InlineAsmRegClass::vreg_low16),
+            BackendRepr::SimdVector { element, count },
+        ) if layout.size.bytes() == 8 => {
             let elem_ty = llvm_asm_scalar_type(cx, element);
             cx.type_vector(elem_ty, count * 2)
         }
@@ -1256,7 +1259,7 @@ fn llvm_fixup_output_type<'ll, 'tcx>(
         }
         (
             X86(X86InlineAsmRegClass::xmm_reg | X86InlineAsmRegClass::zmm_reg),
-            BackendRepr::Vector { .. },
+            BackendRepr::SimdVector { .. },
         ) if layout.size.bytes() == 64 => cx.type_vector(cx.type_f64(), 8),
         (
             X86(
@@ -1284,7 +1287,7 @@ fn llvm_fixup_output_type<'ll, 'tcx>(
                 | X86InlineAsmRegClass::ymm_reg
                 | X86InlineAsmRegClass::zmm_reg,
             ),
-            BackendRepr::Vector { element, count: count @ (8 | 16) },
+            BackendRepr::SimdVector { element, count: count @ (8 | 16) },
         ) if element.primitive() == Primitive::Float(Float::F16) => {
             cx.type_vector(cx.type_i16(), count)
         }
@@ -1321,7 +1324,7 @@ fn llvm_fixup_output_type<'ll, 'tcx>(
                 | ArmInlineAsmRegClass::qreg_low4
                 | ArmInlineAsmRegClass::qreg_low8,
             ),
-            BackendRepr::Vector { element, count: count @ (4 | 8) },
+            BackendRepr::SimdVector { element, count: count @ (4 | 8) },
         ) if element.primitive() == Primitive::Float(Float::F16) => {
             cx.type_vector(cx.type_i16(), count)
         }
diff --git a/compiler/rustc_codegen_llvm/src/back/archive.rs b/compiler/rustc_codegen_llvm/src/back/archive.rs
index 93553f3f3648..0a161442933a 100644
--- a/compiler/rustc_codegen_llvm/src/back/archive.rs
+++ b/compiler/rustc_codegen_llvm/src/back/archive.rs
@@ -132,14 +132,33 @@ fn get_llvm_object_symbols(
     if err.is_null() {
         return Ok(true);
     } else {
-        return Err(unsafe { *Box::from_raw(err as *mut io::Error) });
+        let error = unsafe { *Box::from_raw(err as *mut io::Error) };
+        // These are the magic constants for LLVM bitcode files:
+        // https://github.com/llvm/llvm-project/blob/7eadc1960d199676f04add402bb0aa6f65b7b234/llvm/lib/BinaryFormat/Magic.cpp#L90-L97
+        if buf.starts_with(&[0xDE, 0xCE, 0x17, 0x0B]) || buf.starts_with(&[b'B', b'C', 0xC0, 0xDE])
+        {
+            // For LLVM bitcode, failure to read the symbols is not fatal. The bitcode may have been
+            // produced by a newer LLVM version that the one linked to rustc. This is fine provided
+            // that the linker does use said newer LLVM version. We skip writing the symbols for the
+            // bitcode to the symbol table of the archive. Traditional linkers don't like this, but
+            // newer linkers like lld, mold and wild ignore the symbol table anyway, so if they link
+            // against a new enough LLVM it will work out in the end.
+            // LLVM's archive writer also has this same behavior of only warning about invalid
+            // bitcode since https://github.com/llvm/llvm-project/pull/96848
+
+            // We don't have access to the DiagCtxt here to produce a nice warning in the correct format.
+            eprintln!("warning: Failed to read symbol table from LLVM bitcode: {}", error);
+            return Ok(true);
+        } else {
+            return Err(error);
+        }
     }
 
     unsafe extern "C" fn callback(state: *mut c_void, symbol_name: *const c_char) -> *mut c_void {
         let f = unsafe { &mut *(state as *mut &mut dyn FnMut(&[u8]) -> io::Result<()>) };
         match f(unsafe { CStr::from_ptr(symbol_name) }.to_bytes()) {
             Ok(()) => std::ptr::null_mut(),
-            Err(err) => Box::into_raw(Box::new(err)) as *mut c_void,
+            Err(err) => Box::into_raw(Box::new(err) as Box<io::Error>) as *mut c_void,
         }
     }
 
@@ -148,7 +167,7 @@ fn get_llvm_object_symbols(
         Box::into_raw(Box::new(io::Error::new(
             io::ErrorKind::Other,
             format!("LLVM error: {}", error.to_string_lossy()),
-        ))) as *mut c_void
+        )) as Box<io::Error>) as *mut c_void
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/back/lto.rs b/compiler/rustc_codegen_llvm/src/back/lto.rs
index 99906ea7bce3..668795191a29 100644
--- a/compiler/rustc_codegen_llvm/src/back/lto.rs
+++ b/compiler/rustc_codegen_llvm/src/back/lto.rs
@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 use std::ffi::{CStr, CString};
 use std::fs::File;
 use std::path::Path;
+use std::ptr::NonNull;
 use std::sync::Arc;
 use std::{io, iter, slice};
 
@@ -305,11 +306,8 @@ fn fat_lto(
             assert!(!serialized_modules.is_empty(), "must have at least one serialized module");
             let (buffer, name) = serialized_modules.remove(0);
             info!("no in-memory regular modules to choose from, parsing {:?}", name);
-            ModuleCodegen {
-                module_llvm: ModuleLlvm::parse(cgcx, &name, buffer.data(), dcx)?,
-                name: name.into_string().unwrap(),
-                kind: ModuleKind::Regular,
-            }
+            let llvm_module = ModuleLlvm::parse(cgcx, &name, buffer.data(), dcx)?;
+            ModuleCodegen::new_regular(name.into_string().unwrap(), llvm_module)
         }
     };
     {
@@ -655,14 +653,14 @@ pub(crate) fn run_pass_manager(
     }
 
     unsafe {
-        write::llvm_optimize(cgcx, dcx, module, config, opt_level, opt_stage, stage)?;
+        write::llvm_optimize(cgcx, dcx, module, None, config, opt_level, opt_stage, stage)?;
     }
 
     if cfg!(llvm_enzyme) && enable_ad {
         let opt_stage = llvm::OptStage::FatLTO;
         let stage = write::AutodiffStage::PostAD;
         unsafe {
-            write::llvm_optimize(cgcx, dcx, module, config, opt_level, opt_stage, stage)?;
+            write::llvm_optimize(cgcx, dcx, module, None, config, opt_level, opt_stage, stage)?;
         }
 
         // This is the final IR, so people should be able to inspect the optimized autodiff output.
@@ -729,6 +727,11 @@ impl ThinBuffer {
             ThinBuffer(buffer)
         }
     }
+
+    pub unsafe fn from_raw_ptr(ptr: *mut llvm::ThinLTOBuffer) -> ThinBuffer {
+        let mut ptr = NonNull::new(ptr).unwrap();
+        ThinBuffer(unsafe { ptr.as_mut() })
+    }
 }
 
 impl ThinBufferMethods for ThinBuffer {
@@ -772,11 +775,11 @@ pub(crate) unsafe fn optimize_thin_module(
     // crates but for locally codegened modules we may be able to reuse
     // that LLVM Context and Module.
     let module_llvm = ModuleLlvm::parse(cgcx, module_name, thin_module.data(), dcx)?;
-    let mut module = ModuleCodegen {
-        module_llvm,
-        name: thin_module.name().to_string(),
-        kind: ModuleKind::Regular,
-    };
+    let mut module = ModuleCodegen::new_regular(thin_module.name(), module_llvm);
+    // Given that the newly created module lacks a thinlto buffer for embedding, we need to re-add it here.
+    if cgcx.config(ModuleKind::Regular).embed_bitcode() {
+        module.thin_lto_buffer = Some(thin_module.data().to_vec());
+    }
     {
         let target = &*module.module_llvm.tm;
         let llmod = module.module_llvm.llmod();
@@ -793,7 +796,9 @@ pub(crate) unsafe fn optimize_thin_module(
         {
             let _timer =
                 cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_rename", thin_module.name());
-            unsafe { llvm::LLVMRustPrepareThinLTORename(thin_module.shared.data.0, llmod, target) };
+            unsafe {
+                llvm::LLVMRustPrepareThinLTORename(thin_module.shared.data.0, llmod, target.raw())
+            };
             save_temp_bitcode(cgcx, &module, "thin-lto-after-rename");
         }
 
@@ -823,7 +828,7 @@ pub(crate) unsafe fn optimize_thin_module(
             let _timer =
                 cgcx.prof.generic_activity_with_arg("LLVM_thin_lto_import", thin_module.name());
             if unsafe {
-                !llvm::LLVMRustPrepareThinLTOImport(thin_module.shared.data.0, llmod, target)
+                !llvm::LLVMRustPrepareThinLTOImport(thin_module.shared.data.0, llmod, target.raw())
             } {
                 return Err(write::llvm_err(dcx, LlvmError::PrepareThinLtoModule));
             }
diff --git a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
index f075f332462f..dfde45955906 100644
--- a/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
+++ b/compiler/rustc_codegen_llvm/src/back/owned_target_machine.rs
@@ -1,6 +1,5 @@
 use std::ffi::{CStr, c_char};
 use std::marker::PhantomData;
-use std::ops::Deref;
 use std::ptr::NonNull;
 
 use rustc_data_structures::small_c_str::SmallCStr;
@@ -80,12 +79,12 @@ impl OwnedTargetMachine {
             .map(|tm_unique| Self { tm_unique, phantom: PhantomData })
             .ok_or_else(|| LlvmError::CreateTargetMachine { triple: SmallCStr::from(triple) })
     }
-}
 
-impl Deref for OwnedTargetMachine {
-    type Target = llvm::TargetMachine;
-
-    fn deref(&self) -> &Self::Target {
+    /// Returns inner `llvm::TargetMachine` type.
+    ///
+    /// This could be a `Deref` implementation, but `llvm::TargetMachine` is an extern type and
+    /// `Deref::Target: ?Sized`.
+    pub fn raw(&self) -> &llvm::TargetMachine {
         // SAFETY: constructing ensures we have a valid pointer created by
         // llvm::LLVMRustCreateTargetMachine.
         unsafe { self.tm_unique.as_ref() }
diff --git a/compiler/rustc_codegen_llvm/src/back/write.rs b/compiler/rustc_codegen_llvm/src/back/write.rs
index b67890c04657..bead4c82a812 100644
--- a/compiler/rustc_codegen_llvm/src/back/write.rs
+++ b/compiler/rustc_codegen_llvm/src/back/write.rs
@@ -1,6 +1,7 @@
 use std::ffi::{CStr, CString};
 use std::io::{self, Write};
 use std::path::{Path, PathBuf};
+use std::ptr::null_mut;
 use std::sync::Arc;
 use std::{fs, slice, str};
 
@@ -15,7 +16,7 @@ use rustc_codegen_ssa::back::write::{
     TargetMachineFactoryFn,
 };
 use rustc_codegen_ssa::traits::*;
-use rustc_codegen_ssa::{CompiledModule, ModuleCodegen};
+use rustc_codegen_ssa::{CompiledModule, ModuleCodegen, ModuleKind};
 use rustc_data_structures::profiling::SelfProfilerRef;
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_errors::{DiagCtxtHandle, FatalError, Level};
@@ -551,6 +552,7 @@ pub(crate) unsafe fn llvm_optimize(
     cgcx: &CodegenContext<LlvmCodegenBackend>,
     dcx: DiagCtxtHandle<'_>,
     module: &ModuleCodegen<ModuleLlvm>,
+    thin_lto_buffer: Option<&mut *mut llvm::ThinLTOBuffer>,
     config: &ModuleConfig,
     opt_level: config::OptLevel,
     opt_stage: llvm::OptStage,
@@ -584,7 +586,17 @@ pub(crate) unsafe fn llvm_optimize(
         vectorize_loop = config.vectorize_loop;
     }
     trace!(?unroll_loops, ?vectorize_slp, ?vectorize_loop, ?run_enzyme);
-    let using_thin_buffers = opt_stage == llvm::OptStage::PreLinkThinLTO || config.bitcode_needed();
+    if thin_lto_buffer.is_some() {
+        assert!(
+            matches!(
+                opt_stage,
+                llvm::OptStage::PreLinkNoLTO
+                    | llvm::OptStage::PreLinkFatLTO
+                    | llvm::OptStage::PreLinkThinLTO
+            ),
+            "the bitcode for LTO can only be obtained at the pre-link stage"
+        );
+    }
     let pgo_gen_path = get_pgo_gen_path(config);
     let pgo_use_path = get_pgo_use_path(config);
     let pgo_sample_use_path = get_pgo_sample_use_path(config);
@@ -637,14 +649,16 @@ pub(crate) unsafe fn llvm_optimize(
     let result = unsafe {
         llvm::LLVMRustOptimize(
             module.module_llvm.llmod(),
-            &*module.module_llvm.tm,
+            &*module.module_llvm.tm.raw(),
             to_pass_builder_opt_level(opt_level),
             opt_stage,
             cgcx.opts.cg.linker_plugin_lto.enabled(),
             config.no_prepopulate_passes,
             config.verify_llvm_ir,
             config.lint_llvm_ir,
-            using_thin_buffers,
+            thin_lto_buffer,
+            config.emit_thin_lto,
+            config.emit_thin_lto_summary,
             config.merge_functions,
             unroll_loops,
             vectorize_slp,
@@ -675,7 +689,7 @@ pub(crate) unsafe fn llvm_optimize(
 pub(crate) unsafe fn optimize(
     cgcx: &CodegenContext<LlvmCodegenBackend>,
     dcx: DiagCtxtHandle<'_>,
-    module: &ModuleCodegen<ModuleLlvm>,
+    module: &mut ModuleCodegen<ModuleLlvm>,
     config: &ModuleConfig,
 ) -> Result<(), FatalError> {
     let _timer = cgcx.prof.generic_activity_with_arg("LLVM_module_optimize", &*module.name);
@@ -705,9 +719,53 @@ pub(crate) unsafe fn optimize(
         // Otherwise we pretend AD is already done and run the normal opt pipeline (=PostAD).
         let consider_ad = cfg!(llvm_enzyme) && config.autodiff.contains(&config::AutoDiff::Enable);
         let autodiff_stage = if consider_ad { AutodiffStage::PreAD } else { AutodiffStage::PostAD };
-        return unsafe {
-            llvm_optimize(cgcx, dcx, module, config, opt_level, opt_stage, autodiff_stage)
+        // The embedded bitcode is used to run LTO/ThinLTO.
+        // The bitcode obtained during the `codegen` phase is no longer suitable for performing LTO.
+        // It may have undergone LTO due to ThinLocal, so we need to obtain the embedded bitcode at
+        // this point.
+        let mut thin_lto_buffer = if (module.kind == ModuleKind::Regular
+            && config.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full))
+            || config.emit_thin_lto_summary
+        {
+            Some(null_mut())
+        } else {
+            None
         };
+        unsafe {
+            llvm_optimize(
+                cgcx,
+                dcx,
+                module,
+                thin_lto_buffer.as_mut(),
+                config,
+                opt_level,
+                opt_stage,
+                autodiff_stage,
+            )
+        }?;
+        if let Some(thin_lto_buffer) = thin_lto_buffer {
+            let thin_lto_buffer = unsafe { ThinBuffer::from_raw_ptr(thin_lto_buffer) };
+            module.thin_lto_buffer = Some(thin_lto_buffer.data().to_vec());
+            let bc_summary_out =
+                cgcx.output_filenames.temp_path(OutputType::ThinLinkBitcode, module_name);
+            if config.emit_thin_lto_summary
+                && let Some(thin_link_bitcode_filename) = bc_summary_out.file_name()
+            {
+                let summary_data = thin_lto_buffer.thin_link_data();
+                cgcx.prof.artifact_size(
+                    "llvm_bitcode_summary",
+                    thin_link_bitcode_filename.to_string_lossy(),
+                    summary_data.len() as u64,
+                );
+                let _timer = cgcx.prof.generic_activity_with_arg(
+                    "LLVM_module_codegen_emit_bitcode_summary",
+                    &*module.name,
+                );
+                if let Err(err) = fs::write(&bc_summary_out, summary_data) {
+                    dcx.emit_err(WriteBytecode { path: &bc_summary_out, err });
+                }
+            }
+        }
     }
     Ok(())
 }
@@ -760,59 +818,41 @@ pub(crate) unsafe fn codegen(
         // otherwise requested.
 
         let bc_out = cgcx.output_filenames.temp_path(OutputType::Bitcode, module_name);
-        let bc_summary_out =
-            cgcx.output_filenames.temp_path(OutputType::ThinLinkBitcode, module_name);
         let obj_out = cgcx.output_filenames.temp_path(OutputType::Object, module_name);
 
         if config.bitcode_needed() {
-            let _timer = cgcx
-                .prof
-                .generic_activity_with_arg("LLVM_module_codegen_make_bitcode", &*module.name);
-            let thin = ThinBuffer::new(llmod, config.emit_thin_lto, config.emit_thin_lto_summary);
-            let data = thin.data();
-
-            if let Some(bitcode_filename) = bc_out.file_name() {
-                cgcx.prof.artifact_size(
-                    "llvm_bitcode",
-                    bitcode_filename.to_string_lossy(),
-                    data.len() as u64,
-                );
-            }
-
-            if config.emit_thin_lto_summary
-                && let Some(thin_link_bitcode_filename) = bc_summary_out.file_name()
-            {
-                let summary_data = thin.thin_link_data();
-                cgcx.prof.artifact_size(
-                    "llvm_bitcode_summary",
-                    thin_link_bitcode_filename.to_string_lossy(),
-                    summary_data.len() as u64,
-                );
-
-                let _timer = cgcx.prof.generic_activity_with_arg(
-                    "LLVM_module_codegen_emit_bitcode_summary",
-                    &*module.name,
-                );
-                if let Err(err) = fs::write(&bc_summary_out, summary_data) {
-                    dcx.emit_err(WriteBytecode { path: &bc_summary_out, err });
-                }
-            }
-
             if config.emit_bc || config.emit_obj == EmitObj::Bitcode {
+                let thin = {
+                    let _timer = cgcx.prof.generic_activity_with_arg(
+                        "LLVM_module_codegen_make_bitcode",
+                        &*module.name,
+                    );
+                    ThinBuffer::new(llmod, config.emit_thin_lto, false)
+                };
+                let data = thin.data();
                 let _timer = cgcx
                     .prof
                     .generic_activity_with_arg("LLVM_module_codegen_emit_bitcode", &*module.name);
+                if let Some(bitcode_filename) = bc_out.file_name() {
+                    cgcx.prof.artifact_size(
+                        "llvm_bitcode",
+                        bitcode_filename.to_string_lossy(),
+                        data.len() as u64,
+                    );
+                }
                 if let Err(err) = fs::write(&bc_out, data) {
                     dcx.emit_err(WriteBytecode { path: &bc_out, err });
                 }
             }
 
-            if config.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full) {
+            if config.embed_bitcode() && module.kind == ModuleKind::Regular {
                 let _timer = cgcx
                     .prof
                     .generic_activity_with_arg("LLVM_module_codegen_embed_bitcode", &*module.name);
+                let thin_bc =
+                    module.thin_lto_buffer.as_deref().expect("cannot find embedded bitcode");
                 unsafe {
-                    embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, data);
+                    embed_bitcode(cgcx, llcx, llmod, &config.bc_cmdline, &thin_bc);
                 }
             }
         }
@@ -875,7 +915,7 @@ pub(crate) unsafe fn codegen(
             };
             write_output_file(
                 dcx,
-                tm,
+                tm.raw(),
                 config.no_builtins,
                 llmod,
                 &path,
@@ -909,7 +949,7 @@ pub(crate) unsafe fn codegen(
 
                 write_output_file(
                     dcx,
-                    tm,
+                    tm.raw(),
                     config.no_builtins,
                     llmod,
                     &obj_out,
diff --git a/compiler/rustc_codegen_llvm/src/base.rs b/compiler/rustc_codegen_llvm/src/base.rs
index d35c7945baec..6bd27914dbd1 100644
--- a/compiler/rustc_codegen_llvm/src/base.rs
+++ b/compiler/rustc_codegen_llvm/src/base.rs
@@ -13,10 +13,10 @@
 
 use std::time::Instant;
 
+use rustc_codegen_ssa::ModuleCodegen;
 use rustc_codegen_ssa::base::maybe_create_entry_wrapper;
 use rustc_codegen_ssa::mono_item::MonoItemExt;
 use rustc_codegen_ssa::traits::*;
-use rustc_codegen_ssa::{ModuleCodegen, ModuleKind};
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_middle::dep_graph;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrs;
@@ -133,11 +133,7 @@ pub(crate) fn compile_codegen_unit(
             }
         }
 
-        ModuleCodegen {
-            name: cgu_name.to_string(),
-            module_llvm: llvm_module,
-            kind: ModuleKind::Regular,
-        }
+        ModuleCodegen::new_regular(cgu_name.to_string(), llvm_module)
     }
 
     (module, cost)
diff --git a/compiler/rustc_codegen_llvm/src/builder.rs b/compiler/rustc_codegen_llvm/src/builder.rs
index 677a9cd3e90e..3f20350d0efd 100644
--- a/compiler/rustc_codegen_llvm/src/builder.rs
+++ b/compiler/rustc_codegen_llvm/src/builder.rs
@@ -405,7 +405,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
         // Emit KCFI operand bundle
         let kcfi_bundle = self.kcfi_operand_bundle(fn_attrs, fn_abi, instance, llfn);
-        if let Some(kcfi_bundle) = kcfi_bundle.as_deref() {
+        if let Some(kcfi_bundle) = kcfi_bundle.as_ref().map(|b| b.raw()) {
             bundles.push(kcfi_bundle);
         }
 
@@ -1433,7 +1433,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
 
         // Emit KCFI operand bundle
         let kcfi_bundle = self.kcfi_operand_bundle(fn_attrs, fn_abi, instance, llfn);
-        if let Some(kcfi_bundle) = kcfi_bundle.as_deref() {
+        if let Some(kcfi_bundle) = kcfi_bundle.as_ref().map(|b| b.raw()) {
             bundles.push(kcfi_bundle);
         }
 
@@ -1782,7 +1782,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
 
         // Emit KCFI operand bundle
         let kcfi_bundle = self.kcfi_operand_bundle(fn_attrs, fn_abi, instance, llfn);
-        if let Some(kcfi_bundle) = kcfi_bundle.as_deref() {
+        if let Some(kcfi_bundle) = kcfi_bundle.as_ref().map(|b| b.raw()) {
             bundles.push(kcfi_bundle);
         }
 
diff --git a/compiler/rustc_codegen_llvm/src/common.rs b/compiler/rustc_codegen_llvm/src/common.rs
index f17d98fa242b..0621b893e755 100644
--- a/compiler/rustc_codegen_llvm/src/common.rs
+++ b/compiler/rustc_codegen_llvm/src/common.rs
@@ -77,7 +77,7 @@ impl<'ll> Funclet<'ll> {
     }
 
     pub(crate) fn bundle(&self) -> &llvm::OperandBundle<'ll> {
-        &self.operand
+        self.operand.raw()
     }
 }
 
diff --git a/compiler/rustc_codegen_llvm/src/context.rs b/compiler/rustc_codegen_llvm/src/context.rs
index e7952bc95e7f..ed8426ae1974 100644
--- a/compiler/rustc_codegen_llvm/src/context.rs
+++ b/compiler/rustc_codegen_llvm/src/context.rs
@@ -205,7 +205,7 @@ pub(crate) unsafe fn create_module<'ll>(
     {
         let tm = crate::back::write::create_informational_target_machine(tcx.sess, false);
         unsafe {
-            llvm::LLVMRustSetDataLayoutFromTargetMachine(llmod, &tm);
+            llvm::LLVMRustSetDataLayoutFromTargetMachine(llmod, tm.raw());
         }
 
         let llvm_data_layout = unsafe { llvm::LLVMGetDataLayoutStr(llmod) };
diff --git a/compiler/rustc_codegen_llvm/src/intrinsic.rs b/compiler/rustc_codegen_llvm/src/intrinsic.rs
index dfbb5bc1731d..0272667e2239 100644
--- a/compiler/rustc_codegen_llvm/src/intrinsic.rs
+++ b/compiler/rustc_codegen_llvm/src/intrinsic.rs
@@ -470,7 +470,7 @@ impl<'ll, 'tcx> IntrinsicCallBuilderMethods<'tcx> for Builder<'_, 'll, 'tcx> {
                 let layout = self.layout_of(tp_ty).layout;
                 let use_integer_compare = match layout.backend_repr() {
                     Scalar(_) | ScalarPair(_, _) => true,
-                    Vector { .. } => false,
+                    SimdVector { .. } => false,
                     Memory { .. } => {
                         // For rusty ABIs, small aggregates are actually passed
                         // as `RegKind::Integer` (see `FnAbi::adjust_for_abi`),
@@ -1329,7 +1329,7 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
         ));
     }
 
-    if name == sym::simd_shuffle_generic {
+    if name == sym::simd_shuffle_const_generic {
         let idx = fn_args[2].expect_const().to_value().valtree.unwrap_branch();
         let n = idx.len() as u64;
 
@@ -1581,8 +1581,6 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
             sym::simd_floor => ("floor", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_fma => ("fma", bx.type_func(&[vec_ty, vec_ty, vec_ty], vec_ty)),
             sym::simd_relaxed_fma => ("fmuladd", bx.type_func(&[vec_ty, vec_ty, vec_ty], vec_ty)),
-            sym::simd_fpowi => ("powi", bx.type_func(&[vec_ty, bx.type_i32()], vec_ty)),
-            sym::simd_fpow => ("pow", bx.type_func(&[vec_ty, vec_ty], vec_ty)),
             sym::simd_fsin => ("sin", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_fsqrt => ("sqrt", bx.type_func(&[vec_ty], vec_ty)),
             sym::simd_round => ("round", bx.type_func(&[vec_ty], vec_ty)),
@@ -1615,8 +1613,6 @@ fn generic_simd_intrinsic<'ll, 'tcx>(
             | sym::simd_flog
             | sym::simd_floor
             | sym::simd_fma
-            | sym::simd_fpow
-            | sym::simd_fpowi
             | sym::simd_fsin
             | sym::simd_fsqrt
             | sym::simd_relaxed_fma
diff --git a/compiler/rustc_codegen_llvm/src/lib.rs b/compiler/rustc_codegen_llvm/src/lib.rs
index e9e1b644f183..c88372db4913 100644
--- a/compiler/rustc_codegen_llvm/src/lib.rs
+++ b/compiler/rustc_codegen_llvm/src/lib.rs
@@ -194,7 +194,7 @@ impl WriteBackendMethods for LlvmCodegenBackend {
     unsafe fn optimize(
         cgcx: &CodegenContext<Self>,
         dcx: DiagCtxtHandle<'_>,
-        module: &ModuleCodegen<Self::Module>,
+        module: &mut ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<(), FatalError> {
         unsafe { back::write::optimize(cgcx, dcx, module, config) }
diff --git a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
index 3c2c6964a3d7..25ca34988034 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/enzyme_ffi.rs
@@ -42,10 +42,10 @@ pub use self::Enzyme_AD::*;
 #[cfg(llvm_enzyme)]
 pub mod Enzyme_AD {
     use libc::c_void;
-    extern "C" {
+    unsafe extern "C" {
         pub fn EnzymeSetCLBool(arg1: *mut ::std::os::raw::c_void, arg2: u8);
     }
-    extern "C" {
+    unsafe extern "C" {
         static mut EnzymePrintPerf: c_void;
         static mut EnzymePrintActivity: c_void;
         static mut EnzymePrintType: c_void;
diff --git a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
index da91e6edbcfb..2dc14e4613d2 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/ffi.rs
@@ -2425,7 +2425,9 @@ unsafe extern "C" {
         NoPrepopulatePasses: bool,
         VerifyIR: bool,
         LintIR: bool,
-        UseThinLTOBuffers: bool,
+        ThinLTOBuffer: Option<&mut *mut ThinLTOBuffer>,
+        EmitThinLTO: bool,
+        EmitThinLTOSummary: bool,
         MergeFunctions: bool,
         UnrollLoops: bool,
         SLPVectorize: bool,
diff --git a/compiler/rustc_codegen_llvm/src/llvm/mod.rs b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
index 5ec934241314..a36226b25a24 100644
--- a/compiler/rustc_codegen_llvm/src/llvm/mod.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm/mod.rs
@@ -1,7 +1,6 @@
 #![allow(non_snake_case)]
 
 use std::ffi::{CStr, CString};
-use std::ops::Deref;
 use std::ptr;
 use std::str::FromStr;
 use std::string::FromUtf8Error;
@@ -355,6 +354,16 @@ impl<'a> OperandBundleOwned<'a> {
         };
         OperandBundleOwned { raw: ptr::NonNull::new(raw).unwrap() }
     }
+
+    /// Returns inner `OperandBundle` type.
+    ///
+    /// This could be a `Deref` implementation, but `OperandBundle` contains an extern type and
+    /// `Deref::Target: ?Sized`.
+    pub(crate) fn raw(&self) -> &OperandBundle<'a> {
+        // SAFETY: The returned reference is opaque and can only used for FFI.
+        // It is valid for as long as `&self` is.
+        unsafe { self.raw.as_ref() }
+    }
 }
 
 impl Drop for OperandBundleOwned<'_> {
@@ -365,16 +374,6 @@ impl Drop for OperandBundleOwned<'_> {
     }
 }
 
-impl<'a> Deref for OperandBundleOwned<'a> {
-    type Target = OperandBundle<'a>;
-
-    fn deref(&self) -> &Self::Target {
-        // SAFETY: The returned reference is opaque and can only used for FFI.
-        // It is valid for as long as `&self` is.
-        unsafe { self.raw.as_ref() }
-    }
-}
-
 pub(crate) fn add_module_flag_u32(
     module: &Module,
     merge_behavior: ModuleFlagMergeBehavior,
diff --git a/compiler/rustc_codegen_llvm/src/llvm_util.rs b/compiler/rustc_codegen_llvm/src/llvm_util.rs
index b4b5d6a5b194..5cc4f4ab9e67 100644
--- a/compiler/rustc_codegen_llvm/src/llvm_util.rs
+++ b/compiler/rustc_codegen_llvm/src/llvm_util.rs
@@ -281,6 +281,8 @@ pub(crate) fn to_llvm_features<'a>(sess: &Session, s: &'a str) -> Option<LLVMFea
         ("riscv32" | "riscv64", "zaamo") if get_version().0 < 19 => None,
         ("riscv32" | "riscv64", "zabha") if get_version().0 < 19 => None,
         ("riscv32" | "riscv64", "zalrsc") if get_version().0 < 19 => None,
+        ("riscv32" | "riscv64", "zama16b") if get_version().0 < 19 => None,
+        ("riscv32" | "riscv64", "zacas") if get_version().0 < 20 => None,
         // Enable the evex512 target feature if an avx512 target feature is enabled.
         ("x86", s) if s.starts_with("avx512") => {
             Some(LLVMFeature::with_dependency(s, TargetFeatureFoldStrength::EnableOnly("evex512")))
@@ -329,7 +331,8 @@ pub(crate) fn target_features_cfg(sess: &Session, allow_unstable: bool) -> Vec<S
                 if let Some(feat) = to_llvm_features(sess, feature) {
                     for llvm_feature in feat {
                         let cstr = SmallCStr::new(llvm_feature);
-                        if !unsafe { llvm::LLVMRustHasFeature(&target_machine, cstr.as_ptr()) } {
+                        if !unsafe { llvm::LLVMRustHasFeature(target_machine.raw(), cstr.as_ptr()) }
+                        {
                             return false;
                         }
                     }
@@ -451,8 +454,8 @@ pub(crate) fn print(req: &PrintRequest, out: &mut String, sess: &Session) {
     require_inited();
     let tm = create_informational_target_machine(sess, false);
     match req.kind {
-        PrintKind::TargetCPUs => print_target_cpus(sess, &tm, out),
-        PrintKind::TargetFeatures => print_target_features(sess, &tm, out),
+        PrintKind::TargetCPUs => print_target_cpus(sess, tm.raw(), out),
+        PrintKind::TargetFeatures => print_target_features(sess, tm.raw(), out),
         _ => bug!("rustc_codegen_llvm can't handle print request: {:?}", req),
     }
 }
diff --git a/compiler/rustc_codegen_llvm/src/type_of.rs b/compiler/rustc_codegen_llvm/src/type_of.rs
index ba01fbff3853..4e7096da502d 100644
--- a/compiler/rustc_codegen_llvm/src/type_of.rs
+++ b/compiler/rustc_codegen_llvm/src/type_of.rs
@@ -19,7 +19,7 @@ fn uncached_llvm_type<'a, 'tcx>(
 ) -> &'a Type {
     match layout.backend_repr {
         BackendRepr::Scalar(_) => bug!("handled elsewhere"),
-        BackendRepr::Vector { element, count } => {
+        BackendRepr::SimdVector { element, count } => {
             let element = layout.scalar_llvm_type_at(cx, element);
             return cx.type_vector(element, count);
         }
@@ -171,7 +171,7 @@ pub(crate) trait LayoutLlvmExt<'tcx> {
 impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
     fn is_llvm_immediate(&self) -> bool {
         match self.backend_repr {
-            BackendRepr::Scalar(_) | BackendRepr::Vector { .. } => true,
+            BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => true,
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => false,
         }
     }
@@ -179,9 +179,9 @@ impl<'tcx> LayoutLlvmExt<'tcx> for TyAndLayout<'tcx> {
     fn is_llvm_scalar_pair(&self) -> bool {
         match self.backend_repr {
             BackendRepr::ScalarPair(..) => true,
-            BackendRepr::Scalar(_) | BackendRepr::Vector { .. } | BackendRepr::Memory { .. } => {
-                false
-            }
+            BackendRepr::Scalar(_)
+            | BackendRepr::SimdVector { .. }
+            | BackendRepr::Memory { .. } => false,
         }
     }
 
diff --git a/compiler/rustc_codegen_ssa/Cargo.toml b/compiler/rustc_codegen_ssa/Cargo.toml
index 83d847f2d155..1346efcb87c2 100644
--- a/compiler/rustc_codegen_ssa/Cargo.toml
+++ b/compiler/rustc_codegen_ssa/Cargo.toml
@@ -11,7 +11,7 @@ bitflags = "2.4.1"
 bstr = "1.11.3"
 # Pinned so `cargo update` bumps don't cause breakage. Please also update the
 # `cc` in `rustc_llvm` if you update the `cc` here.
-cc = "=1.2.13"
+cc = "=1.2.16"
 either = "1.5.0"
 itertools = "0.12"
 pathdiff = "0.2.0"
diff --git a/compiler/rustc_codegen_ssa/src/assert_module_sources.rs b/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
index 27331ce4ca66..32f689608f81 100644
--- a/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
+++ b/compiler/rustc_codegen_ssa/src/assert_module_sources.rs
@@ -94,7 +94,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
                 other => {
                     self.tcx
                         .dcx()
-                        .emit_fatal(errors::UnknownReuseKind { span: attr.span, kind: other });
+                        .emit_fatal(errors::UnknownReuseKind { span: attr.span(), kind: other });
                 }
             }
         } else {
@@ -102,7 +102,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
         };
 
         if !self.tcx.sess.opts.unstable_opts.query_dep_graph {
-            self.tcx.dcx().emit_fatal(errors::MissingQueryDepGraph { span: attr.span });
+            self.tcx.dcx().emit_fatal(errors::MissingQueryDepGraph { span: attr.span() });
         }
 
         if !self.check_config(attr) {
@@ -115,7 +115,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
 
         if !user_path.starts_with(&crate_name) {
             self.tcx.dcx().emit_fatal(errors::MalformedCguName {
-                span: attr.span,
+                span: attr.span(),
                 user_path,
                 crate_name,
             });
@@ -145,7 +145,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
             let cgu_names: Vec<&str> =
                 self.available_cgus.items().map(|cgu| cgu.as_str()).into_sorted_stable_ord();
             self.tcx.dcx().emit_err(errors::NoModuleNamed {
-                span: attr.span,
+                span: attr.span(),
                 user_path,
                 cgu_name,
                 cgu_names: cgu_names.join(", "),
@@ -155,7 +155,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
         self.cgu_reuse_tracker.set_expectation(
             cgu_name,
             user_path,
-            attr.span,
+            attr.span(),
             expected_reuse,
             comp_kind,
         );
@@ -175,7 +175,7 @@ impl<'tcx> AssertModuleSource<'tcx> {
             }
         }
 
-        self.tcx.dcx().emit_fatal(errors::NoField { span: attr.span, name });
+        self.tcx.dcx().emit_fatal(errors::NoField { span: attr.span(), name });
     }
 
     /// Scan for a `cfg="foo"` attribute and check whether we have a
@@ -211,7 +211,7 @@ impl fmt::Display for CguReuse {
 }
 
 impl IntoDiagArg for CguReuse {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.to_string()))
     }
 }
diff --git a/compiler/rustc_codegen_ssa/src/back/apple.rs b/compiler/rustc_codegen_ssa/src/back/apple.rs
index d9c5c3e5af96..bfa7635a869f 100644
--- a/compiler/rustc_codegen_ssa/src/back/apple.rs
+++ b/compiler/rustc_codegen_ssa/src/back/apple.rs
@@ -2,6 +2,7 @@ use std::env;
 use std::fmt::{Display, from_fn};
 use std::num::ParseIntError;
 
+use rustc_middle::middle::exported_symbols::SymbolExportKind;
 use rustc_session::Session;
 use rustc_target::spec::Target;
 
@@ -26,6 +27,89 @@ pub(super) fn macho_platform(target: &Target) -> u32 {
     }
 }
 
+/// Add relocation and section data needed for a symbol to be considered
+/// undefined by ld64.
+///
+/// The relocation must be valid, and hence must point to a valid piece of
+/// machine code, and hence this is unfortunately very architecture-specific.
+///
+///
+/// # New architectures
+///
+/// The values here are basically the same as emitted by the following program:
+///
+/// ```c
+/// // clang -c foo.c -target $CLANG_TARGET
+/// void foo(void);
+///
+/// extern int bar;
+///
+/// void* foobar[2] = {
+///     (void*)foo,
+///     (void*)&bar,
+///     // ...
+/// };
+/// ```
+///
+/// Can be inspected with:
+/// ```console
+/// objdump --macho --reloc foo.o
+/// objdump --macho --full-contents foo.o
+/// ```
+pub(super) fn add_data_and_relocation(
+    file: &mut object::write::Object<'_>,
+    section: object::write::SectionId,
+    symbol: object::write::SymbolId,
+    target: &Target,
+    kind: SymbolExportKind,
+) -> object::write::Result<()> {
+    let authenticated_pointer =
+        kind == SymbolExportKind::Text && target.llvm_target.starts_with("arm64e");
+
+    let data: &[u8] = match target.pointer_width {
+        _ if authenticated_pointer => &[0, 0, 0, 0, 0, 0, 0, 0x80],
+        32 => &[0; 4],
+        64 => &[0; 8],
+        pointer_width => unimplemented!("unsupported Apple pointer width {pointer_width:?}"),
+    };
+
+    if target.arch == "x86_64" {
+        // Force alignment for the entire section to be 16 on x86_64.
+        file.section_mut(section).append_data(&[], 16);
+    } else {
+        // Elsewhere, the section alignment is the same as the pointer width.
+        file.section_mut(section).append_data(&[], target.pointer_width as u64);
+    }
+
+    let offset = file.section_mut(section).append_data(data, data.len() as u64);
+
+    let flags = if authenticated_pointer {
+        object::write::RelocationFlags::MachO {
+            r_type: object::macho::ARM64_RELOC_AUTHENTICATED_POINTER,
+            r_pcrel: false,
+            r_length: 3,
+        }
+    } else if target.arch == "arm" {
+        // FIXME(madsmtm): Remove once `object` supports 32-bit ARM relocations:
+        // https://github.com/gimli-rs/object/pull/757
+        object::write::RelocationFlags::MachO {
+            r_type: object::macho::ARM_RELOC_VANILLA,
+            r_pcrel: false,
+            r_length: 2,
+        }
+    } else {
+        object::write::RelocationFlags::Generic {
+            kind: object::RelocationKind::Absolute,
+            encoding: object::RelocationEncoding::Generic,
+            size: target.pointer_width as u8,
+        }
+    };
+
+    file.add_relocation(section, object::write::Relocation { offset, addend: 0, symbol, flags })?;
+
+    Ok(())
+}
+
 /// Deployment target or SDK version.
 ///
 /// The size of the numbers in here are limited by Mach-O's `LC_BUILD_VERSION`.
diff --git a/compiler/rustc_codegen_ssa/src/back/link.rs b/compiler/rustc_codegen_ssa/src/back/link.rs
index 4c0764502694..5054ae561c04 100644
--- a/compiler/rustc_codegen_ssa/src/back/link.rs
+++ b/compiler/rustc_codegen_ssa/src/back/link.rs
@@ -1726,8 +1726,12 @@ fn exec_linker(
         args.push_str(
             &Escape {
                 arg: arg.to_str().unwrap(),
-                // LLD also uses MSVC-like parsing for @-files by default when running on windows hosts
-                is_like_msvc: sess.target.is_like_msvc || (cfg!(windows) && flavor.uses_lld()),
+                // Windows-style escaping for @-files is used by
+                // - all linkers targeting MSVC-like targets, including LLD
+                // - all LLD flavors running on Windows hosts
+                // С/С++ compilers use Posix-style escaping (except clang-cl, which we do not use).
+                is_like_msvc: sess.target.is_like_msvc
+                    || (cfg!(windows) && flavor.uses_lld() && !flavor.uses_cc()),
             }
             .to_string(),
         );
@@ -2058,8 +2062,8 @@ fn add_post_link_args(cmd: &mut dyn Linker, sess: &Session, flavor: LinkerFlavor
 /// linker, and since they never participate in the linking, using `KEEP` in the linker scripts
 /// can't keep them either. This causes #47384.
 ///
-/// To keep them around, we could use `--whole-archive` and equivalents to force rlib to
-/// participate in linking like object files, but this proves to be expensive (#93791). Therefore
+/// To keep them around, we could use `--whole-archive`, `-force_load` and equivalents to force rlib
+/// to participate in linking like object files, but this proves to be expensive (#93791). Therefore
 /// we instead just introduce an undefined reference to them. This could be done by `-u` command
 /// line option to the linker or `EXTERN(...)` in linker scripts, however they does not only
 /// introduce an undefined reference, but also make them the GC roots, preventing `--gc-sections`
@@ -2101,8 +2105,20 @@ fn add_linked_symbol_object(
         file.set_mangling(object::write::Mangling::None);
     }
 
+    // ld64 requires a relocation to load undefined symbols, see below.
+    // Not strictly needed if linking with lld, but might as well do it there too.
+    let ld64_section_helper = if file.format() == object::BinaryFormat::MachO {
+        Some(file.add_section(
+            file.segment_name(object::write::StandardSegment::Data).to_vec(),
+            "__data".into(),
+            object::SectionKind::Data,
+        ))
+    } else {
+        None
+    };
+
     for (sym, kind) in symbols.iter() {
-        file.add_symbol(object::write::Symbol {
+        let symbol = file.add_symbol(object::write::Symbol {
             name: sym.clone().into(),
             value: 0,
             size: 0,
@@ -2116,6 +2132,47 @@ fn add_linked_symbol_object(
             section: object::write::SymbolSection::Undefined,
             flags: object::SymbolFlags::None,
         });
+
+        // The linker shipped with Apple's Xcode, ld64, works a bit differently from other linkers.
+        //
+        // Code-wise, the relevant parts of ld64 are roughly:
+        // 1. Find the `ArchiveLoadMode` based on commandline options, default to `parseObjects`.
+        //    https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/Options.cpp#L924-L932
+        //    https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/Options.h#L55
+        //
+        // 2. Read the archive table of contents (__.SYMDEF file).
+        //    https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/parsers/archive_file.cpp#L294-L325
+        //
+        // 3. Begin linking by loading "atoms" from input files.
+        //    https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/doc/design/linker.html
+        //    https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/InputFiles.cpp#L1349
+        //
+        //   a. Directly specified object files (`.o`) are parsed immediately.
+        //      https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/parsers/macho_relocatable_file.cpp#L4611-L4627
+        //
+        //     - Undefined symbols are not atoms (`n_value > 0` denotes a common symbol).
+        //       https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/parsers/macho_relocatable_file.cpp#L2455-L2468
+        //       https://maskray.me/blog/2022-02-06-all-about-common-symbols
+        //
+        //     - Relocations/fixups are atoms.
+        //       https://github.com/apple-oss-distributions/ld64/blob/ce6341ae966b3451aa54eeb049f2be865afbd578/src/ld/parsers/macho_relocatable_file.cpp#L2088-L2114
+        //
+        //   b. Archives are not parsed yet.
+        //      https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/parsers/archive_file.cpp#L467-L577
+        //
+        // 4. When a symbol is needed by an atom, parse the object file that contains the symbol.
+        //    https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/InputFiles.cpp#L1417-L1491
+        //    https://github.com/apple-oss-distributions/ld64/blob/ld64-954.16/src/ld/parsers/archive_file.cpp#L579-L597
+        //
+        // All of the steps above are fairly similar to other linkers, except that **it completely
+        // ignores undefined symbols**.
+        //
+        // So to make this trick work on ld64, we need to do something else to load the relevant
+        // object files. We do this by inserting a relocation (fixup) for each symbol.
+        if let Some(section) = ld64_section_helper {
+            apple::add_data_and_relocation(&mut file, section, symbol, &sess.target, *kind)
+                .expect("failed adding relocation");
+        }
     }
 
     let path = tmpdir.join("symbols.o");
diff --git a/compiler/rustc_codegen_ssa/src/back/linker.rs b/compiler/rustc_codegen_ssa/src/back/linker.rs
index 8900405c1b8f..818edaf66031 100644
--- a/compiler/rustc_codegen_ssa/src/back/linker.rs
+++ b/compiler/rustc_codegen_ssa/src/back/linker.rs
@@ -1939,14 +1939,14 @@ impl<'a> Linker for LlbcLinker<'a> {
     }
 
     fn optimize(&mut self) {
-        match self.sess.opts.optimize {
+        self.link_arg(match self.sess.opts.optimize {
             OptLevel::No => "-O0",
             OptLevel::Less => "-O1",
             OptLevel::More => "-O2",
             OptLevel::Aggressive => "-O3",
             OptLevel::Size => "-Os",
             OptLevel::SizeMin => "-Oz",
-        };
+        });
     }
 
     fn full_relro(&mut self) {}
diff --git a/compiler/rustc_codegen_ssa/src/back/metadata.rs b/compiler/rustc_codegen_ssa/src/back/metadata.rs
index 236507ac0cd2..3aacbcde1a78 100644
--- a/compiler/rustc_codegen_ssa/src/back/metadata.rs
+++ b/compiler/rustc_codegen_ssa/src/back/metadata.rs
@@ -373,7 +373,11 @@ pub(crate) fn create_object_file(sess: &Session) -> Option<write::Object<'static
         Architecture::Avr => {
             // Resolve the ISA revision and set
             // the appropriate EF_AVR_ARCH flag.
-            ef_avr_arch(&sess.target.options.cpu)
+            if let Some(ref cpu) = sess.opts.cg.target_cpu {
+                ef_avr_arch(cpu)
+            } else {
+                bug!("AVR CPU not explicitly specified")
+            }
         }
         Architecture::Csky => {
             let e_flags = match sess.target.options.abi.as_ref() {
diff --git a/compiler/rustc_codegen_ssa/src/back/write.rs b/compiler/rustc_codegen_ssa/src/back/write.rs
index f008bd12ed8f..c8bb229998ea 100644
--- a/compiler/rustc_codegen_ssa/src/back/write.rs
+++ b/compiler/rustc_codegen_ssa/src/back/write.rs
@@ -278,6 +278,10 @@ impl ModuleConfig {
             || self.emit_obj == EmitObj::Bitcode
             || self.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full)
     }
+
+    pub fn embed_bitcode(&self) -> bool {
+        self.emit_obj == EmitObj::ObjectCode(BitcodeSection::Full)
+    }
 }
 
 /// Configuration passed to the function returned by the `target_machine_factory`.
@@ -877,14 +881,14 @@ pub(crate) fn compute_per_cgu_lto_type(
 
 fn execute_optimize_work_item<B: ExtraBackendMethods>(
     cgcx: &CodegenContext<B>,
-    module: ModuleCodegen<B::Module>,
+    mut module: ModuleCodegen<B::Module>,
     module_config: &ModuleConfig,
 ) -> Result<WorkItemResult<B>, FatalError> {
     let dcx = cgcx.create_dcx();
     let dcx = dcx.handle();
 
     unsafe {
-        B::optimize(cgcx, dcx, &module, module_config)?;
+        B::optimize(cgcx, dcx, &mut module, module_config)?;
     }
 
     // After we've done the initial round of optimizations we need to
diff --git a/compiler/rustc_codegen_ssa/src/base.rs b/compiler/rustc_codegen_ssa/src/base.rs
index 40238f4b4915..63f2f8fa3d17 100644
--- a/compiler/rustc_codegen_ssa/src/base.rs
+++ b/compiler/rustc_codegen_ssa/src/base.rs
@@ -5,7 +5,9 @@ use std::time::{Duration, Instant};
 
 use itertools::Itertools;
 use rustc_abi::FIRST_VARIANT;
+use rustc_ast as ast;
 use rustc_ast::expand::allocator::{ALLOCATOR_METHODS, AllocatorKind, global_fn_name};
+use rustc_attr_parsing::OptimizeAttr;
 use rustc_data_structures::fx::{FxHashMap, FxIndexSet};
 use rustc_data_structures::profiling::{get_resident_set_size, print_time_passes_entry};
 use rustc_data_structures::sync::par_map;
@@ -29,7 +31,6 @@ use rustc_span::{DUMMY_SP, Symbol, sym};
 use rustc_trait_selection::infer::{BoundRegionConversionTime, TyCtxtInferExt};
 use rustc_trait_selection::traits::{ObligationCause, ObligationCtxt};
 use tracing::{debug, info};
-use {rustc_ast as ast, rustc_attr_parsing as attr};
 
 use crate::assert_module_sources::CguReuse;
 use crate::back::link::are_upstream_rust_objects_already_included;
@@ -686,7 +687,7 @@ pub fn codegen_crate<B: ExtraBackendMethods>(
         submit_codegened_module_to_llvm(
             &backend,
             &ongoing_codegen.coordinator.sender,
-            ModuleCodegen { name: llmod_id, module_llvm, kind: ModuleKind::Allocator },
+            ModuleCodegen::new_allocator(llmod_id, module_llvm),
             cost,
         );
     }
@@ -1061,7 +1062,7 @@ pub(crate) fn provide(providers: &mut Providers) {
 
         let any_for_speed = defids.items().any(|id| {
             let CodegenFnAttrs { optimize, .. } = tcx.codegen_fn_attrs(*id);
-            matches!(optimize, attr::OptimizeAttr::Speed)
+            matches!(optimize, OptimizeAttr::Speed)
         });
 
         if any_for_speed {
diff --git a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
index 97bc84c0b698..673740b4aab9 100644
--- a/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
+++ b/compiler/rustc_codegen_ssa/src/codegen_attrs.rs
@@ -5,7 +5,8 @@ use rustc_ast::expand::autodiff_attrs::{
     AutoDiffAttrs, DiffActivity, DiffMode, valid_input_activity, valid_ret_activity,
 };
 use rustc_ast::{MetaItem, MetaItemInner, attr};
-use rustc_attr_parsing::{InlineAttr, InstructionSetAttr, OptimizeAttr};
+use rustc_attr_parsing::ReprAttr::ReprAlign;
+use rustc_attr_parsing::{AttributeKind, InlineAttr, InstructionSetAttr, OptimizeAttr};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::codes::*;
 use rustc_errors::{DiagMessage, SubdiagMessage, struct_span_code_err};
@@ -104,12 +105,26 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
             if let Fn | AssocFn | Variant | Ctor(..) = def_kind {
                 Some(tcx.fn_sig(did))
             } else {
-                tcx.dcx()
-                    .span_delayed_bug(attr.span, "this attribute can only be applied to functions");
+                tcx.dcx().span_delayed_bug(
+                    attr.span(),
+                    "this attribute can only be applied to functions",
+                );
                 None
             }
         };
 
+        if let hir::Attribute::Parsed(p) = attr {
+            match p {
+                AttributeKind::Repr(reprs) => {
+                    codegen_fn_attrs.alignment = reprs
+                        .iter()
+                        .find_map(|(r, _)| if let ReprAlign(x) = r { Some(*x) } else { None });
+                }
+
+                _ => {}
+            }
+        }
+
         let Some(Ident { name, .. }) = attr.ident() else {
             continue;
         };
@@ -130,14 +145,14 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 if tcx.opt_item_name(did.to_def_id()).is_some() {
                     codegen_fn_attrs.flags |= CodegenFnAttrFlags::NO_MANGLE;
                     mixed_export_name_no_mangle_lint_state.track_no_mangle(
-                        attr.span,
+                        attr.span(),
                         tcx.local_def_id_to_hir_id(did),
                         attr,
                     );
                 } else {
                     tcx.dcx()
                         .struct_span_err(
-                            attr.span,
+                            attr.span(),
                             format!(
                                 "`#[no_mangle]` cannot be used on {} {} as it has no name",
                                 tcx.def_descr_article(did.to_def_id()),
@@ -158,7 +173,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                             feature_err(
                                 &tcx.sess,
                                 sym::used_with_arg,
-                                attr.span,
+                                attr.span(),
                                 "`#[used(linker)]` is currently unstable",
                             )
                             .emit();
@@ -170,7 +185,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                             feature_err(
                                 &tcx.sess,
                                 sym::used_with_arg,
-                                attr.span,
+                                attr.span(),
                                 "`#[used(compiler)]` is currently unstable",
                             )
                             .emit();
@@ -178,7 +193,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                         codegen_fn_attrs.flags |= CodegenFnAttrFlags::USED;
                     }
                     Some(_) => {
-                        tcx.dcx().emit_err(errors::ExpectedUsedSymbol { span: attr.span });
+                        tcx.dcx().emit_err(errors::ExpectedUsedSymbol { span: attr.span() });
                     }
                     None => {
                         // Unfortunately, unconditionally using `llvm.used` causes
@@ -223,7 +238,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 {
                     struct_span_code_err!(
                         tcx.dcx(),
-                        attr.span,
+                        attr.span(),
                         E0737,
                         "`#[track_caller]` requires Rust ABI"
                     )
@@ -231,12 +246,12 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 }
                 if is_closure
                     && !tcx.features().closure_track_caller()
-                    && !attr.span.allows_unstable(sym::closure_track_caller)
+                    && !attr.span().allows_unstable(sym::closure_track_caller)
                 {
                     feature_err(
                         &tcx.sess,
                         sym::closure_track_caller,
-                        attr.span,
+                        attr.span(),
                         "`#[track_caller]` on closures is currently unstable",
                     )
                     .emit();
@@ -250,19 +265,19 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                         // so it may not contain any null characters.
                         struct_span_code_err!(
                             tcx.dcx(),
-                            attr.span,
+                            attr.span(),
                             E0648,
                             "`export_name` may not contain null characters"
                         )
                         .emit();
                     }
                     codegen_fn_attrs.export_name = Some(s);
-                    mixed_export_name_no_mangle_lint_state.track_export_name(attr.span);
+                    mixed_export_name_no_mangle_lint_state.track_export_name(attr.span());
                 }
             }
             sym::target_feature => {
                 let Some(sig) = tcx.hir_node_by_def_id(did).fn_sig() else {
-                    tcx.dcx().span_delayed_bug(attr.span, "target_feature applied to non-fn");
+                    tcx.dcx().span_delayed_bug(attr.span(), "target_feature applied to non-fn");
                     continue;
                 };
                 let safe_target_features =
@@ -292,7 +307,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                         // `main`, `start`, and other functions that are not usually
                         // allowed.
                     } else {
-                        check_target_feature_trait_unsafe(tcx, did, attr.span);
+                        check_target_feature_trait_unsafe(tcx, did, attr.span());
                     }
                 }
                 from_target_feature_attr(
@@ -310,7 +325,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
 
                         if tcx.is_mutable_static(did.into()) {
                             let mut diag = tcx.dcx().struct_span_err(
-                                attr.span,
+                                attr.span(),
                                 "extern mutable statics are not allowed with `#[linkage]`",
                             );
                             diag.note(
@@ -329,7 +344,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                 if let Some(val) = attr.value_str() {
                     if val.as_str().bytes().any(|b| b == 0) {
                         let msg = format!("illegal null byte in link_section value: `{val}`");
-                        tcx.dcx().span_err(attr.span, msg);
+                        tcx.dcx().span_err(attr.span(), msg);
                     } else {
                         codegen_fn_attrs.link_section = Some(val);
                     }
@@ -337,13 +352,13 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
             }
             sym::link_name => codegen_fn_attrs.link_name = attr.value_str(),
             sym::link_ordinal => {
-                link_ordinal_span = Some(attr.span);
+                link_ordinal_span = Some(attr.span());
                 if let ordinal @ Some(_) = check_link_ordinal(tcx, attr) {
                     codegen_fn_attrs.link_ordinal = ordinal;
                 }
             }
             sym::no_sanitize => {
-                no_sanitize_span = Some(attr.span);
+                no_sanitize_span = Some(attr.span());
                 if let Some(list) = attr.meta_item_list() {
                     for item in list.iter() {
                         match item.name_or_empty() {
@@ -381,7 +396,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                                 {
                                     struct_span_code_err!(
                                         tcx.dcx(),
-                                        attr.span,
+                                        attr.span(),
                                         E0779,
                                         "target does not support `#[instruction_set]`"
                                     )
@@ -393,7 +408,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                                 _ => {
                                     struct_span_code_err!(
                                         tcx.dcx(),
-                                        attr.span,
+                                        attr.span(),
                                         E0779,
                                         "invalid instruction set specified",
                                     )
@@ -405,7 +420,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                         [] => {
                             struct_span_code_err!(
                                 tcx.dcx(),
-                                attr.span,
+                                attr.span(),
                                 E0778,
                                 "`#[instruction_set]` requires an argument"
                             )
@@ -415,7 +430,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                         _ => {
                             struct_span_code_err!(
                                 tcx.dcx(),
-                                attr.span,
+                                attr.span(),
                                 E0779,
                                 "cannot specify more than one instruction set"
                             )
@@ -424,27 +439,6 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                         }
                     })
             }
-            sym::repr => {
-                codegen_fn_attrs.alignment = if let Some(items) = attr.meta_item_list()
-                    && let [item] = items.as_slice()
-                    && let Some((sym::align, literal)) = item.singleton_lit_list()
-                {
-                    rustc_attr_parsing::parse_alignment(&literal.kind)
-                        .inspect_err(|msg| {
-                            struct_span_code_err!(
-                                tcx.dcx(),
-                                literal.span,
-                                E0589,
-                                "invalid `repr(align)` attribute: {}",
-                                msg
-                            )
-                            .emit();
-                        })
-                        .ok()
-                } else {
-                    None
-                };
-            }
             sym::patchable_function_entry => {
                 codegen_fn_attrs.patchable_function_entry = attr.meta_item_list().and_then(|l| {
                     let mut prefix = None;
@@ -510,7 +504,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
                     }
 
                     if let (None, None) = (prefix, entry) {
-                        tcx.dcx().span_err(attr.span, "must specify at least one parameter");
+                        tcx.dcx().span_err(attr.span(), "must specify at least one parameter");
                     }
 
                     Some(PatchableFunctionEntry::from_prefix_and_entry(
@@ -536,18 +530,19 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         let Some(ref items) = attr.meta_item_list() else {
             return ia;
         };
+        inline_span = Some(attr.span());
 
-        inline_span = Some(attr.span);
         let [item] = &items[..] else {
-            struct_span_code_err!(tcx.dcx(), attr.span, E0534, "expected one argument").emit();
+            struct_span_code_err!(tcx.dcx(), attr.span(), E0534, "expected one argument").emit();
             return InlineAttr::None;
         };
+
         if item.has_name(sym::always) {
             InlineAttr::Always
         } else if item.has_name(sym::never) {
             InlineAttr::Never
         } else {
-            struct_span_code_err!(tcx.dcx(), item.span(), E0535, "invalid argument")
+            struct_span_code_err!(tcx.dcx(), items[0].span(), E0535, "invalid argument")
                 .with_help("valid inline arguments are `always` and `never`")
                 .emit();
 
@@ -560,9 +555,9 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         }
 
         if attr.is_word() {
-            InlineAttr::Force { attr_span: attr.span, reason: None }
+            InlineAttr::Force { attr_span: attr.span(), reason: None }
         } else if let Some(val) = attr.value_str() {
-            InlineAttr::Force { attr_span: attr.span, reason: Some(val) }
+            InlineAttr::Force { attr_span: attr.span(), reason: Some(val) }
         } else {
             debug!("`rustc_force_inline` not checked by attribute validation");
             ia
@@ -582,16 +577,16 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         }
         let err = |sp, s| struct_span_code_err!(tcx.dcx(), sp, E0722, "{}", s).emit();
         if attr.is_word() {
-            err(attr.span, "expected one argument");
+            err(attr.span(), "expected one argument");
             return ia;
         }
         let Some(ref items) = attr.meta_item_list() else {
             return OptimizeAttr::Default;
         };
 
-        inline_span = Some(attr.span);
+        inline_span = Some(attr.span());
         let [item] = &items[..] else {
-            err(attr.span, "expected one argument");
+            err(attr.span(), "expected one argument");
             return OptimizeAttr::Default;
         };
         if item.has_name(sym::size) {
@@ -703,7 +698,7 @@ fn codegen_fn_attrs(tcx: TyCtxt<'_>, did: LocalDefId) -> CodegenFnAttrs {
         let span = tcx
             .get_attrs(did, sym::target_feature)
             .next()
-            .map_or_else(|| tcx.def_span(did), |a| a.span);
+            .map_or_else(|| tcx.def_span(did), |a| a.span());
         tcx.dcx()
             .create_err(errors::TargetFeatureDisableOrEnable {
                 features,
@@ -752,7 +747,7 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Option<u16> {
     use rustc_ast::{LitIntType, LitKind, MetaItemLit};
     let meta_item_list = attr.meta_item_list()?;
     let [sole_meta_list] = &meta_item_list[..] else {
-        tcx.dcx().emit_err(errors::InvalidLinkOrdinalNargs { span: attr.span });
+        tcx.dcx().emit_err(errors::InvalidLinkOrdinalNargs { span: attr.span() });
         return None;
     };
     if let Some(MetaItemLit { kind: LitKind::Int(ordinal, LitIntType::Unsuffixed), .. }) =
@@ -776,13 +771,13 @@ fn check_link_ordinal(tcx: TyCtxt<'_>, attr: &hir::Attribute) -> Option<u16> {
         } else {
             let msg = format!("ordinal value in `link_ordinal` is too large: `{ordinal}`");
             tcx.dcx()
-                .struct_span_err(attr.span, msg)
+                .struct_span_err(attr.span(), msg)
                 .with_note("the value may not exceed `u16::MAX`")
                 .emit();
             None
         }
     } else {
-        tcx.dcx().emit_err(errors::InvalidLinkOrdinalFormat { span: attr.span });
+        tcx.dcx().emit_err(errors::InvalidLinkOrdinalFormat { span: attr.span() });
         None
     }
 }
@@ -828,7 +823,7 @@ impl<'a> MixedExportNameAndNoMangleState<'a> {
             export_name: Some(export_name),
             no_mangle: Some(no_mangle),
             hir_id: Some(hir_id),
-            no_mangle_attr: Some(no_mangle_attr),
+            no_mangle_attr: Some(_),
         } = self
         {
             tcx.emit_node_span_lint(
@@ -837,7 +832,7 @@ impl<'a> MixedExportNameAndNoMangleState<'a> {
                 no_mangle,
                 errors::MixedExportNameAndNoMangle {
                     no_mangle,
-                    no_mangle_attr: rustc_hir_pretty::attribute_to_string(&tcx, no_mangle_attr),
+                    no_mangle_attr: "#[unsafe(no_mangle)]".to_string(),
                     export_name,
                     removal_span: no_mangle,
                 },
@@ -869,7 +864,7 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
         _ => {
             //FIXME(ZuseZ4): Once we fixed our parser, we should also prohibit the two-attribute
             //branch above.
-            span_bug!(attrs[1].span, "cg_ssa: rustc_autodiff should only exist once per source");
+            span_bug!(attrs[1].span(), "cg_ssa: rustc_autodiff should only exist once per source");
         }
     };
 
@@ -881,12 +876,12 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
     }
 
     let [mode, input_activities @ .., ret_activity] = &list[..] else {
-        span_bug!(attr.span, "rustc_autodiff attribute must contain mode and activities");
+        span_bug!(attr.span(), "rustc_autodiff attribute must contain mode and activities");
     };
     let mode = if let MetaItemInner::MetaItem(MetaItem { path: p1, .. }) = mode {
         p1.segments.first().unwrap().ident
     } else {
-        span_bug!(attr.span, "rustc_autodiff attribute must contain mode");
+        span_bug!(attr.span(), "rustc_autodiff attribute must contain mode");
     };
 
     // parse mode
@@ -902,7 +897,7 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
     let ret_symbol = if let MetaItemInner::MetaItem(MetaItem { path: p1, .. }) = ret_activity {
         p1.segments.first().unwrap().ident
     } else {
-        span_bug!(attr.span, "rustc_autodiff attribute must contain the return activity");
+        span_bug!(attr.span(), "rustc_autodiff attribute must contain the return activity");
     };
 
     // Then parse it into an actual DiffActivity
@@ -937,11 +932,11 @@ fn autodiff_attrs(tcx: TyCtxt<'_>, id: DefId) -> Option<AutoDiffAttrs> {
 
     for &input in &arg_activities {
         if !valid_input_activity(mode, input) {
-            span_bug!(attr.span, "Invalid input activity {} for {} mode", input, mode);
+            span_bug!(attr.span(), "Invalid input activity {} for {} mode", input, mode);
         }
     }
     if !valid_ret_activity(mode, ret_activity) {
-        span_bug!(attr.span, "Invalid return activity {} for {} mode", ret_activity, mode);
+        span_bug!(attr.span(), "Invalid return activity {} for {} mode", ret_activity, mode);
     }
 
     Some(AutoDiffAttrs { mode, ret_activity, input_activity: arg_activities })
diff --git a/compiler/rustc_codegen_ssa/src/errors.rs b/compiler/rustc_codegen_ssa/src/errors.rs
index 3ddbe4aeeec5..7e28961599f0 100644
--- a/compiler/rustc_codegen_ssa/src/errors.rs
+++ b/compiler/rustc_codegen_ssa/src/errors.rs
@@ -161,7 +161,7 @@ impl<'a> CopyPath<'a> {
 struct DebugArgPath<'a>(pub &'a Path);
 
 impl IntoDiagArg for DebugArgPath<'_> {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         DiagArgValue::Str(Cow::Owned(format!("{:?}", self.0)))
     }
 }
@@ -1087,7 +1087,7 @@ pub enum ExpectedPointerMutability {
 }
 
 impl IntoDiagArg for ExpectedPointerMutability {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         match self {
             ExpectedPointerMutability::Mut => DiagArgValue::Str(Cow::Borrowed("*mut")),
             ExpectedPointerMutability::Not => DiagArgValue::Str(Cow::Borrowed("*_")),
@@ -1180,6 +1180,8 @@ pub(crate) struct ErrorCreatingRemarkDir {
 pub struct CompilerBuiltinsCannotCall {
     pub caller: String,
     pub callee: String,
+    #[primary_span]
+    pub span: Span,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_codegen_ssa/src/lib.rs b/compiler/rustc_codegen_ssa/src/lib.rs
index 9d2ac219d592..4e758bfdec39 100644
--- a/compiler/rustc_codegen_ssa/src/lib.rs
+++ b/compiler/rustc_codegen_ssa/src/lib.rs
@@ -75,9 +75,29 @@ pub struct ModuleCodegen<M> {
     pub name: String,
     pub module_llvm: M,
     pub kind: ModuleKind,
+    /// Saving the ThinLTO buffer for embedding in the object file.
+    pub thin_lto_buffer: Option<Vec<u8>>,
 }
 
 impl<M> ModuleCodegen<M> {
+    pub fn new_regular(name: impl Into<String>, module: M) -> Self {
+        Self {
+            name: name.into(),
+            module_llvm: module,
+            kind: ModuleKind::Regular,
+            thin_lto_buffer: None,
+        }
+    }
+
+    pub fn new_allocator(name: impl Into<String>, module: M) -> Self {
+        Self {
+            name: name.into(),
+            module_llvm: module,
+            kind: ModuleKind::Allocator,
+            thin_lto_buffer: None,
+        }
+    }
+
     pub fn into_compiled_module(
         self,
         emit_obj: bool,
diff --git a/compiler/rustc_codegen_ssa/src/mir/block.rs b/compiler/rustc_codegen_ssa/src/mir/block.rs
index 1e52c6394635..e2a9b540d306 100644
--- a/compiler/rustc_codegen_ssa/src/mir/block.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/block.rs
@@ -165,9 +165,13 @@ impl<'a, 'tcx> TerminatorCodegenHelper<'tcx> {
         if let Some(instance) = instance {
             if is_call_from_compiler_builtins_to_upstream_monomorphization(tcx, instance) {
                 if destination.is_some() {
-                    let caller = with_no_trimmed_paths!(tcx.def_path_str(fx.instance.def_id()));
-                    let callee = with_no_trimmed_paths!(tcx.def_path_str(instance.def_id()));
-                    tcx.dcx().emit_err(CompilerBuiltinsCannotCall { caller, callee });
+                    let caller_def = fx.instance.def_id();
+                    let e = CompilerBuiltinsCannotCall {
+                        span: tcx.def_span(caller_def),
+                        caller: with_no_trimmed_paths!(tcx.def_path_str(caller_def)),
+                        callee: with_no_trimmed_paths!(tcx.def_path_str(instance.def_id())),
+                    };
+                    tcx.dcx().emit_err(e);
                 } else {
                     info!(
                         "compiler_builtins call to diverging function {:?} replaced with abort",
diff --git a/compiler/rustc_codegen_ssa/src/mir/mod.rs b/compiler/rustc_codegen_ssa/src/mir/mod.rs
index ba28720afecd..0758e5d04567 100644
--- a/compiler/rustc_codegen_ssa/src/mir/mod.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/mod.rs
@@ -3,7 +3,7 @@ use std::iter;
 use rustc_index::IndexVec;
 use rustc_index::bit_set::DenseBitSet;
 use rustc_middle::middle::codegen_fn_attrs::CodegenFnAttrFlags;
-use rustc_middle::mir::{UnwindTerminateReason, traversal};
+use rustc_middle::mir::{Local, UnwindTerminateReason, traversal};
 use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt, HasTypingEnv, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt, TypeFoldable, TypeVisitableExt};
 use rustc_middle::{bug, mir, span_bug};
@@ -240,7 +240,7 @@ pub fn codegen_mir<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>>(
     let local_values = {
         let args = arg_local_refs(&mut start_bx, &mut fx, &memory_locals);
 
-        let mut allocate_local = |local| {
+        let mut allocate_local = |local: Local| {
             let decl = &mir.local_decls[local];
             let layout = start_bx.layout_of(fx.monomorphize(decl.ty));
             assert!(!layout.ty.has_erasable_regions());
diff --git a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
index 0593fb420c30..96d1ab018f60 100644
--- a/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/naked_asm.rs
@@ -349,7 +349,7 @@ fn wasm_type<'tcx>(
         PassMode::Direct(_) => {
             let direct_type = match arg_abi.layout.backend_repr {
                 BackendRepr::Scalar(scalar) => wasm_primitive(scalar.primitive(), ptr_type),
-                BackendRepr::Vector { .. } => "v128",
+                BackendRepr::SimdVector { .. } => "v128",
                 BackendRepr::Memory { .. } => {
                     // FIXME: remove this branch once the wasm32-unknown-unknown ABI is fixed
                     let _ = WasmCAbi::Legacy;
diff --git a/compiler/rustc_codegen_ssa/src/mir/operand.rs b/compiler/rustc_codegen_ssa/src/mir/operand.rs
index 461cf1b8acda..4b33bdeadba4 100644
--- a/compiler/rustc_codegen_ssa/src/mir/operand.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/operand.rs
@@ -359,7 +359,7 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
         let offset = self.layout.fields.offset(i);
 
         if !bx.is_backend_ref(self.layout) && bx.is_backend_ref(field) {
-            if let BackendRepr::Vector { count, .. } = self.layout.backend_repr
+            if let BackendRepr::SimdVector { count, .. } = self.layout.backend_repr
                 && let BackendRepr::Memory { sized: true } = field.backend_repr
                 && count.is_power_of_two()
             {
@@ -404,7 +404,7 @@ impl<'a, 'tcx, V: CodegenObject> OperandRef<'tcx, V> {
                 }
             };
             OperandValue::Immediate(match field.backend_repr {
-                BackendRepr::Vector { .. } => imm,
+                BackendRepr::SimdVector { .. } => imm,
                 BackendRepr::Scalar(out_scalar) => {
                     let Some(in_scalar) = in_scalar else {
                         span_bug!(
@@ -666,7 +666,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
                     // However, some SIMD types do not actually use the vector ABI
                     // (in particular, packed SIMD types do not). Ensure we exclude those.
                     let layout = bx.layout_of(constant_ty);
-                    if let BackendRepr::Vector { .. } = layout.backend_repr {
+                    if let BackendRepr::SimdVector { .. } = layout.backend_repr {
                         let (llval, ty) = self.immediate_const_vector(bx, constant);
                         return OperandRef {
                             val: OperandValue::Immediate(llval),
diff --git a/compiler/rustc_codegen_ssa/src/mir/place.rs b/compiler/rustc_codegen_ssa/src/mir/place.rs
index edd09b9c3c5f..00e01e47fee3 100644
--- a/compiler/rustc_codegen_ssa/src/mir/place.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/place.rs
@@ -2,7 +2,7 @@ use rustc_abi::Primitive::{Int, Pointer};
 use rustc_abi::{Align, BackendRepr, FieldsShape, Size, TagEncoding, VariantIdx, Variants};
 use rustc_middle::mir::PlaceTy;
 use rustc_middle::mir::interpret::Scalar;
-use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
+use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Ty};
 use rustc_middle::{bug, mir};
 use tracing::{debug, instrument};
@@ -168,7 +168,11 @@ impl<'a, 'tcx, V: CodegenObject> PlaceRef<'tcx, V> {
             };
             let val = PlaceValue {
                 llval,
-                llextra: if bx.cx().type_has_metadata(field.ty) { self.val.llextra } else { None },
+                llextra: if bx.cx().tcx().type_has_metadata(field.ty, bx.cx().typing_env()) {
+                    self.val.llextra
+                } else {
+                    None
+                },
                 align: effective_field_align,
             };
             val.with_type(field)
diff --git a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
index 1eebe04225be..67555d403320 100644
--- a/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
+++ b/compiler/rustc_codegen_ssa/src/mir/rvalue.rs
@@ -3,7 +3,7 @@ use std::assert_matches::assert_matches;
 use arrayvec::ArrayVec;
 use rustc_abi::{self as abi, FIRST_VARIANT, FieldIdx};
 use rustc_middle::ty::adjustment::PointerCoercion;
-use rustc_middle::ty::layout::{HasTyCtxt, LayoutOf, TyAndLayout};
+use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, LayoutOf, TyAndLayout};
 use rustc_middle::ty::{self, Instance, Ty, TyCtxt};
 use rustc_middle::{bug, mir, span_bug};
 use rustc_session::config::OptLevel;
@@ -878,7 +878,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
 
         let ty = cg_place.layout.ty;
         assert!(
-            if bx.cx().type_has_metadata(ty) {
+            if bx.cx().tcx().type_has_metadata(ty, bx.cx().typing_env()) {
                 matches!(val, OperandValue::Pair(..))
             } else {
                 matches!(val, OperandValue::Immediate(..))
@@ -1190,7 +1190,7 @@ impl<'a, 'tcx, Bx: BuilderMethods<'a, 'tcx>> FunctionCx<'a, 'tcx, Bx> {
             assert!(!self.cx.is_backend_scalar_pair(layout));
             OperandValueKind::Immediate(match layout.backend_repr {
                 abi::BackendRepr::Scalar(s) => s,
-                abi::BackendRepr::Vector { element, .. } => element,
+                abi::BackendRepr::SimdVector { element, .. } => element,
                 x => span_bug!(self.mir.span, "Couldn't translate {x:?} as backend immediate"),
             })
         } else if self.cx.is_backend_scalar_pair(layout) {
diff --git a/compiler/rustc_codegen_ssa/src/traits/type_.rs b/compiler/rustc_codegen_ssa/src/traits/type_.rs
index c178ebc596e1..fbd927d0d663 100644
--- a/compiler/rustc_codegen_ssa/src/traits/type_.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/type_.rs
@@ -1,7 +1,7 @@
 use rustc_abi::{AddressSpace, Float, Integer, Reg};
 use rustc_middle::bug;
+use rustc_middle::ty::Ty;
 use rustc_middle::ty::layout::{HasTyCtxt, HasTypingEnv, TyAndLayout};
-use rustc_middle::ty::{self, Ty};
 use rustc_target::callconv::{ArgAbi, CastTarget, FnAbi};
 
 use super::BackendTypes;
@@ -84,19 +84,6 @@ pub trait DerivedTypeCodegenMethods<'tcx>:
     fn type_is_freeze(&self, ty: Ty<'tcx>) -> bool {
         ty.is_freeze(self.tcx(), self.typing_env())
     }
-
-    fn type_has_metadata(&self, ty: Ty<'tcx>) -> bool {
-        if ty.is_sized(self.tcx(), self.typing_env()) {
-            return false;
-        }
-
-        let tail = self.tcx().struct_tail_for_codegen(ty, self.typing_env());
-        match tail.kind() {
-            ty::Foreign(..) => false,
-            ty::Str | ty::Slice(..) | ty::Dynamic(..) => true,
-            _ => bug!("unexpected unsized tail: {:?}", tail),
-        }
-    }
 }
 
 impl<'tcx, T> DerivedTypeCodegenMethods<'tcx> for T where
diff --git a/compiler/rustc_codegen_ssa/src/traits/write.rs b/compiler/rustc_codegen_ssa/src/traits/write.rs
index 97fe614aa10c..c77efdd17287 100644
--- a/compiler/rustc_codegen_ssa/src/traits/write.rs
+++ b/compiler/rustc_codegen_ssa/src/traits/write.rs
@@ -40,7 +40,7 @@ pub trait WriteBackendMethods: 'static + Sized + Clone {
     unsafe fn optimize(
         cgcx: &CodegenContext<Self>,
         dcx: DiagCtxtHandle<'_>,
-        module: &ModuleCodegen<Self::Module>,
+        module: &mut ModuleCodegen<Self::Module>,
         config: &ModuleConfig,
     ) -> Result<(), FatalError>;
     fn optimize_fat(
diff --git a/compiler/rustc_const_eval/messages.ftl b/compiler/rustc_const_eval/messages.ftl
index eecc6690f515..ccf9b240d408 100644
--- a/compiler/rustc_const_eval/messages.ftl
+++ b/compiler/rustc_const_eval/messages.ftl
@@ -109,6 +109,8 @@ const_eval_frame_note_inner = inside {$where_ ->
     *[other] {""}
 }
 
+const_eval_frame_note_last = the failure occurred here
+
 const_eval_in_bounds_test = out-of-bounds pointer use
 const_eval_incompatible_calling_conventions =
     calling a function with calling convention {$callee_conv} using calling convention {$caller_conv}
@@ -300,8 +302,7 @@ const_eval_overflow_arith =
 const_eval_overflow_shift =
     overflowing shift by {$shift_amount} in `{$intrinsic}`
 
-const_eval_panic =
-    the evaluated program panicked at '{$msg}', {$file}:{$line}:{$col}
+const_eval_panic = evaluation panicked: {$msg}
 
 const_eval_panic_non_str = argument to `panic!()` in a const context must have type `&str`
 
diff --git a/compiler/rustc_const_eval/src/check_consts/mod.rs b/compiler/rustc_const_eval/src/check_consts/mod.rs
index 52e000858b4c..607cb2e497d8 100644
--- a/compiler/rustc_const_eval/src/check_consts/mod.rs
+++ b/compiler/rustc_const_eval/src/check_consts/mod.rs
@@ -4,12 +4,13 @@
 //! has interior mutability or needs to be dropped, as well as the visitor that emits errors when
 //! it finds operations that are invalid in a certain context.
 
+use rustc_attr_parsing::{AttributeKind, find_attr};
 use rustc_errors::DiagCtxtHandle;
+use rustc_hir as hir;
 use rustc_hir::def_id::{DefId, LocalDefId};
 use rustc_middle::ty::{self, PolyFnSig, TyCtxt};
 use rustc_middle::{bug, mir};
 use rustc_span::Symbol;
-use {rustc_attr_parsing as attr, rustc_hir as hir};
 
 pub use self::qualifs::Qualif;
 
@@ -81,7 +82,8 @@ pub fn rustc_allow_const_fn_unstable(
     feature_gate: Symbol,
 ) -> bool {
     let attrs = tcx.hir().attrs(tcx.local_def_id_to_hir_id(def_id));
-    attr::rustc_allow_const_fn_unstable(tcx.sess, attrs).any(|name| name == feature_gate)
+
+    find_attr!(attrs, AttributeKind::AllowConstFnUnstable(syms) if syms.contains(&feature_gate))
 }
 
 /// Returns `true` if the given `def_id` (trait or function) is "safe to expose on stable".
@@ -92,6 +94,11 @@ pub fn rustc_allow_const_fn_unstable(
 /// world into two functions: those that are safe to expose on stable (and hence may not use
 /// unstable features, not even recursively), and those that are not.
 pub fn is_fn_or_trait_safe_to_expose_on_stable(tcx: TyCtxt<'_>, def_id: DefId) -> bool {
+    // A default body in a `#[const_trait]` is const-stable when the trait is const-stable.
+    if tcx.is_const_default_method(def_id) {
+        return is_fn_or_trait_safe_to_expose_on_stable(tcx, tcx.parent(def_id));
+    }
+
     match tcx.lookup_const_stability(def_id) {
         None => {
             // In a `staged_api` crate, we do enforce recursive const stability for all unmarked
diff --git a/compiler/rustc_const_eval/src/const_eval/error.rs b/compiler/rustc_const_eval/src/const_eval/error.rs
index cc21a18af3a0..ffb32fa41eb5 100644
--- a/compiler/rustc_const_eval/src/const_eval/error.rs
+++ b/compiler/rustc_const_eval/src/const_eval/error.rs
@@ -48,11 +48,8 @@ impl MachineStopType for ConstEvalErrKind {
             | ModifiedGlobal
             | WriteThroughImmutablePointer => {}
             AssertFailure(kind) => kind.add_args(adder),
-            Panic { msg, line, col, file } => {
-                adder("msg".into(), msg.into_diag_arg());
-                adder("file".into(), file.into_diag_arg());
-                adder("line".into(), line.into_diag_arg());
-                adder("col".into(), col.into_diag_arg());
+            Panic { msg, .. } => {
+                adder("msg".into(), msg.into_diag_arg(&mut None));
             }
         }
     }
@@ -72,7 +69,7 @@ pub fn get_span_and_frames<'tcx>(
     let mut stacktrace = Frame::generate_stacktrace_from_stack(stack);
     // Filter out `requires_caller_location` frames.
     stacktrace.retain(|frame| !frame.instance.def.requires_caller_location(*tcx));
-    let span = stacktrace.first().map(|f| f.span).unwrap_or(tcx.span);
+    let span = stacktrace.last().map(|f| f.span).unwrap_or(tcx.span);
 
     let mut frames = Vec::new();
 
@@ -115,6 +112,20 @@ pub fn get_span_and_frames<'tcx>(
         }
     }
 
+    // In `rustc`, we present const-eval errors from the outer-most place first to the inner-most.
+    // So we reverse the frames here. The first frame will be the same as the span from the current
+    // `TyCtxtAt<'_>`, so we remove it as it would be redundant.
+    frames.reverse();
+    if frames.len() > 0 {
+        frames.remove(0);
+    }
+    if let Some(last) = frames.last_mut()
+        // If the span is not going to be printed, we don't want the span label for `is_last`.
+        && tcx.sess.source_map().span_to_snippet(last.span.source_callsite()).is_ok()
+    {
+        last.has_label = true;
+    }
+
     (span, frames)
 }
 
diff --git a/compiler/rustc_const_eval/src/errors.rs b/compiler/rustc_const_eval/src/errors.rs
index c08495c012f8..b020eeccf717 100644
--- a/compiler/rustc_const_eval/src/errors.rs
+++ b/compiler/rustc_const_eval/src/errors.rs
@@ -6,6 +6,7 @@ use rustc_abi::WrappingRange;
 use rustc_errors::codes::*;
 use rustc_errors::{
     Diag, DiagArgValue, DiagCtxtHandle, DiagMessage, Diagnostic, EmissionGuarantee, Level,
+    MultiSpan, SubdiagMessageOp, Subdiagnostic,
 };
 use rustc_hir::ConstContext;
 use rustc_macros::{Diagnostic, LintDiagnostic, Subdiagnostic};
@@ -17,6 +18,7 @@ use rustc_middle::mir::interpret::{
 use rustc_middle::ty::{self, Mutability, Ty};
 use rustc_span::{Span, Symbol};
 
+use crate::fluent_generated as fluent;
 use crate::interpret::InternKind;
 
 #[derive(Diagnostic)]
@@ -278,14 +280,31 @@ pub(crate) struct NonConstImplNote {
     pub span: Span,
 }
 
-#[derive(Subdiagnostic, Clone)]
-#[note(const_eval_frame_note)]
+#[derive(Clone)]
 pub struct FrameNote {
-    #[primary_span]
     pub span: Span,
     pub times: i32,
     pub where_: &'static str,
     pub instance: String,
+    pub has_label: bool,
+}
+
+impl Subdiagnostic for FrameNote {
+    fn add_to_diag_with<G: EmissionGuarantee, F: SubdiagMessageOp<G>>(
+        self,
+        diag: &mut Diag<'_, G>,
+        f: &F,
+    ) {
+        diag.arg("times", self.times);
+        diag.arg("where_", self.where_);
+        diag.arg("instance", self.instance);
+        let mut span: MultiSpan = self.span.into();
+        if self.has_label && !self.span.is_dummy() {
+            span.push_span_label(self.span, fluent::const_eval_frame_note_last);
+        }
+        let msg = f(diag, fluent::const_eval_frame_note.into());
+        diag.span_note(span, msg);
+    }
 }
 
 #[derive(Subdiagnostic)]
@@ -967,7 +986,7 @@ impl ReportErrorExt for ResourceExhaustionInfo {
 }
 
 impl rustc_errors::IntoDiagArg for InternKind {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(match self {
             InternKind::Static(Mutability::Not) => "static",
             InternKind::Static(Mutability::Mut) => "static_mut",
diff --git a/compiler/rustc_const_eval/src/interpret/stack.rs b/compiler/rustc_const_eval/src/interpret/stack.rs
index 7d0e0492792a..d7b03776bc48 100644
--- a/compiler/rustc_const_eval/src/interpret/stack.rs
+++ b/compiler/rustc_const_eval/src/interpret/stack.rs
@@ -231,13 +231,19 @@ impl<'tcx> FrameInfo<'tcx> {
     pub fn as_note(&self, tcx: TyCtxt<'tcx>) -> errors::FrameNote {
         let span = self.span;
         if tcx.def_key(self.instance.def_id()).disambiguated_data.data == DefPathData::Closure {
-            errors::FrameNote { where_: "closure", span, instance: String::new(), times: 0 }
+            errors::FrameNote {
+                where_: "closure",
+                span,
+                instance: String::new(),
+                times: 0,
+                has_label: false,
+            }
         } else {
             let instance = format!("{}", self.instance);
             // Note: this triggers a `must_produce_diag` state, which means that if we ever get
             // here we must emit a diagnostic. We should never display a `FrameInfo` unless we
             // actually want to emit a warning or error to the user.
-            errors::FrameNote { where_: "instance", span, instance, times: 0 }
+            errors::FrameNote { where_: "instance", span, instance, times: 0, has_label: false }
         }
     }
 }
diff --git a/compiler/rustc_const_eval/src/interpret/validity.rs b/compiler/rustc_const_eval/src/interpret/validity.rs
index 40dec0cb39e7..eb3f552cd278 100644
--- a/compiler/rustc_const_eval/src/interpret/validity.rs
+++ b/compiler/rustc_const_eval/src/interpret/validity.rs
@@ -1296,7 +1296,7 @@ impl<'rt, 'tcx, M: Machine<'tcx>> ValueVisitor<'tcx, M> for ValidityVisitor<'rt,
                     self.visit_scalar(b, b_layout)?;
                 }
             }
-            BackendRepr::Vector { .. } => {
+            BackendRepr::SimdVector { .. } => {
                 // No checks here, we assume layout computation gets this right.
                 // (This is harder to check since Miri does not represent these as `Immediate`. We
                 // also cannot use field projections since this might be a newtype around a vector.)
diff --git a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
index 6426bca2332d..d7e97f32bae9 100644
--- a/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
+++ b/compiler/rustc_const_eval/src/util/check_validity_requirement.rs
@@ -117,7 +117,7 @@ fn check_validity_requirement_lax<'tcx>(
             BackendRepr::ScalarPair(s1, s2) => {
                 scalar_allows_raw_init(s1) && scalar_allows_raw_init(s2)
             }
-            BackendRepr::Vector { element: s, count } => count == 0 || scalar_allows_raw_init(s),
+            BackendRepr::SimdVector { element: s, count } => count == 0 || scalar_allows_raw_init(s),
             BackendRepr::Memory { .. } => true, // Fields are checked below.
         };
     if !valid {
diff --git a/compiler/rustc_data_structures/src/flat_map_in_place.rs b/compiler/rustc_data_structures/src/flat_map_in_place.rs
index e66b00b75576..6d718059f9c8 100644
--- a/compiler/rustc_data_structures/src/flat_map_in_place.rs
+++ b/compiler/rustc_data_structures/src/flat_map_in_place.rs
@@ -1,4 +1,4 @@
-use std::ptr;
+use std::{mem, ptr};
 
 use smallvec::{Array, SmallVec};
 use thin_vec::ThinVec;
@@ -13,39 +13,44 @@ pub trait FlatMapInPlace<T>: Sized {
 // The implementation of this method is syntactically identical for all the
 // different vector types.
 macro_rules! flat_map_in_place {
-    () => {
+    ($vec:ident $( where T: $bound:path)?) => {
         fn flat_map_in_place<F, I>(&mut self, mut f: F)
         where
             F: FnMut(T) -> I,
             I: IntoIterator<Item = T>,
         {
+            struct LeakGuard<'a, T $(: $bound)?>(&'a mut $vec<T>);
+
+            impl<'a, T $(: $bound)?> Drop for LeakGuard<'a, T> {
+                fn drop(&mut self) {
+                    unsafe {
+                        self.0.set_len(0); // make sure we just leak elements in case of panic
+                    }
+                }
+            }
+
+            let this = LeakGuard(self);
+
             let mut read_i = 0;
             let mut write_i = 0;
             unsafe {
-                let mut old_len = self.len();
-                self.set_len(0); // make sure we just leak elements in case of panic
-
-                while read_i < old_len {
+                while read_i < this.0.len() {
                     // move the read_i'th item out of the vector and map it
                     // to an iterator
-                    let e = ptr::read(self.as_ptr().add(read_i));
+                    let e = ptr::read(this.0.as_ptr().add(read_i));
                     let iter = f(e).into_iter();
                     read_i += 1;
 
                     for e in iter {
                         if write_i < read_i {
-                            ptr::write(self.as_mut_ptr().add(write_i), e);
+                            ptr::write(this.0.as_mut_ptr().add(write_i), e);
                             write_i += 1;
                         } else {
                             // If this is reached we ran out of space
                             // in the middle of the vector.
                             // However, the vector is in a valid state here,
                             // so we just do a somewhat inefficient insert.
-                            self.set_len(old_len);
-                            self.insert(write_i, e);
-
-                            old_len = self.len();
-                            self.set_len(0);
+                            this.0.insert(write_i, e);
 
                             read_i += 1;
                             write_i += 1;
@@ -54,20 +59,23 @@ macro_rules! flat_map_in_place {
                 }
 
                 // write_i tracks the number of actually written new items.
-                self.set_len(write_i);
+                this.0.set_len(write_i);
+
+                // The ThinVec is in a sane state again. Prevent the LeakGuard from leaking the data.
+                mem::forget(this);
             }
         }
     };
 }
 
 impl<T> FlatMapInPlace<T> for Vec<T> {
-    flat_map_in_place!();
+    flat_map_in_place!(Vec);
 }
 
 impl<T, A: Array<Item = T>> FlatMapInPlace<T> for SmallVec<A> {
-    flat_map_in_place!();
+    flat_map_in_place!(SmallVec where T: Array);
 }
 
 impl<T> FlatMapInPlace<T> for ThinVec<T> {
-    flat_map_in_place!();
+    flat_map_in_place!(ThinVec);
 }
diff --git a/compiler/rustc_data_structures/src/sharded.rs b/compiler/rustc_data_structures/src/sharded.rs
index 65488c73d3cd..5a53f8af5f8c 100644
--- a/compiler/rustc_data_structures/src/sharded.rs
+++ b/compiler/rustc_data_structures/src/sharded.rs
@@ -143,6 +143,9 @@ pub fn shards() -> usize {
 pub type ShardedHashMap<K, V> = Sharded<FxHashMap<K, V>>;
 
 impl<K: Eq, V> ShardedHashMap<K, V> {
+    pub fn with_capacity(cap: usize) -> Self {
+        Self::new(|| FxHashMap::with_capacity_and_hasher(cap, rustc_hash::FxBuildHasher::default()))
+    }
     pub fn len(&self) -> usize {
         self.lock_shards().map(|shard| shard.len()).sum()
     }
diff --git a/compiler/rustc_data_structures/src/sorted_map.rs b/compiler/rustc_data_structures/src/sorted_map.rs
index 066ea03b4ace..a01a420dfbd6 100644
--- a/compiler/rustc_data_structures/src/sorted_map.rs
+++ b/compiler/rustc_data_structures/src/sorted_map.rs
@@ -1,4 +1,5 @@
 use std::borrow::Borrow;
+use std::cmp::Ordering;
 use std::fmt::Debug;
 use std::mem;
 use std::ops::{Bound, Index, IndexMut, RangeBounds};
@@ -156,6 +157,38 @@ impl<K: Ord, V> SortedMap<K, V> {
         &self.data[start..end]
     }
 
+    /// `sm.range_is_empty(r)` == `sm.range(r).is_empty()`, but is faster.
+    #[inline]
+    pub fn range_is_empty<R>(&self, range: R) -> bool
+    where
+        R: RangeBounds<K>,
+    {
+        // `range` must (via `range_slice_indices`) search for the start and
+        // end separately. But here we can do a single binary search for the
+        // entire range. If a single `x` matching `range` is found then the
+        // range is *not* empty.
+        self.data
+            .binary_search_by(|(x, _)| {
+                // Is `x` below `range`?
+                match range.start_bound() {
+                    Bound::Included(start) if x < start => return Ordering::Less,
+                    Bound::Excluded(start) if x <= start => return Ordering::Less,
+                    _ => {}
+                };
+
+                // Is `x` above `range`?
+                match range.end_bound() {
+                    Bound::Included(end) if x > end => return Ordering::Greater,
+                    Bound::Excluded(end) if x >= end => return Ordering::Greater,
+                    _ => {}
+                };
+
+                // `x` must be within `range`.
+                Ordering::Equal
+            })
+            .is_err()
+    }
+
     #[inline]
     pub fn remove_range<R>(&mut self, range: R)
     where
diff --git a/compiler/rustc_data_structures/src/sorted_map/index_map.rs b/compiler/rustc_data_structures/src/sorted_map/index_map.rs
index 1654867739f0..b38b09d60ebf 100644
--- a/compiler/rustc_data_structures/src/sorted_map/index_map.rs
+++ b/compiler/rustc_data_structures/src/sorted_map/index_map.rs
@@ -147,7 +147,7 @@ impl<I: Idx, K: Ord, V> FromIterator<(K, V)> for SortedIndexMultiMap<I, K, V> {
     where
         J: IntoIterator<Item = (K, V)>,
     {
-        let items = IndexVec::from_iter(iter);
+        let items = IndexVec::<I, _>::from_iter(iter);
         let mut idx_sorted_by_item_key: Vec<_> = items.indices().collect();
 
         // `sort_by_key` is stable, so insertion order is preserved for duplicate items.
diff --git a/compiler/rustc_error_codes/src/error_codes/E0094.md b/compiler/rustc_error_codes/src/error_codes/E0094.md
index efbfa0851a83..909da368f2b6 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0094.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0094.md
@@ -7,12 +7,8 @@ Erroneous code example:
 #![allow(internal_features)]
 
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-fn size_of<T, U>() -> usize // error: intrinsic has wrong number
-                            //        of type parameters
-{
-    loop {}
-}
+fn size_of<T, U>() -> usize; // error: intrinsic has wrong number
+                             //        of type parameters
 ```
 
 Please check that you provided the right number of type parameters
@@ -24,9 +20,5 @@ Example:
 #![allow(internal_features)]
 
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-fn size_of<T>() -> usize // ok!
-{
-    loop {}
-}
+fn size_of<T>() -> usize; // ok!
 ```
diff --git a/compiler/rustc_error_codes/src/error_codes/E0133.md b/compiler/rustc_error_codes/src/error_codes/E0133.md
index 8ca3f03ce156..854cca3d10ff 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0133.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0133.md
@@ -45,6 +45,7 @@ unsafe fn g() {
 ```
 
 Linting against this is controlled via the `unsafe_op_in_unsafe_fn` lint, which
-is `allow` by default but will be upgraded to `warn` in a future edition.
+is `warn` by default in the 2024 edition and `allow` by default in earlier
+editions.
 
 [unsafe-section]: https://doc.rust-lang.org/book/ch19-01-unsafe-rust.html
diff --git a/compiler/rustc_error_codes/src/error_codes/E0374.md b/compiler/rustc_error_codes/src/error_codes/E0374.md
index 6d7dc88823c9..63c243b54ff2 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0374.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0374.md
@@ -1,5 +1,5 @@
-`CoerceUnsized` was implemented on a struct which does not contain a field with
-an unsized type.
+`CoerceUnsized` or `DispatchFromDyn` was implemented on a struct which does not
+contain a field that is being unsized.
 
 Example of erroneous code:
 
@@ -11,47 +11,20 @@ struct Foo<T: ?Sized> {
     a: i32,
 }
 
-// error: Struct `Foo` has no unsized fields that need `CoerceUnsized`.
+// error: Struct `Foo` has no unsized fields that need to be coerced.
 impl<T, U> CoerceUnsized<Foo<U>> for Foo<T>
     where T: CoerceUnsized<U> {}
 ```
 
-An [unsized type][1] is any type where the compiler does not know the length or
-alignment of at compile time. Any struct containing an unsized type is also
-unsized.
+`CoerceUnsized` is used to coerce structs that have a field that can be unsized,
+like a custom `MyBox<T>` being unsized to `MyBox<dyn Trait>`. `DispatchFromDyn`
+is used to dispatch from `MyBox<dyn Trait>` to `MyBox<Self>` in a dyn-compatible
+trait.
 
-[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
+If the struct doesn't have any fields of unsized types then there is no
+meaningful way to implement `CoerceUnsized` or `DispatchFromDyn`, since
+there is no coercion taking place.
 
-`CoerceUnsized` is used to coerce one struct containing an unsized type
-into another struct containing a different unsized type. If the struct
-doesn't have any fields of unsized types then you don't need explicit
-coercion to get the types you want. To fix this you can either
-not try to implement `CoerceUnsized` or you can add a field that is
-unsized to the struct.
-
-Example:
-
-```
-#![feature(coerce_unsized)]
-use std::ops::CoerceUnsized;
-
-// We don't need to impl `CoerceUnsized` here.
-struct Foo {
-    a: i32,
-}
-
-// We add the unsized type field to the struct.
-struct Bar<T: ?Sized> {
-    a: i32,
-    b: T,
-}
-
-// The struct has an unsized field so we can implement
-// `CoerceUnsized` for it.
-impl<T, U> CoerceUnsized<Bar<U>> for Bar<T>
-    where T: CoerceUnsized<U> {}
-```
-
-Note that `CoerceUnsized` is mainly used by smart pointers like `Box`, `Rc`
-and `Arc` to be able to mark that they can coerce unsized types that they
-are pointing at.
+Note that `CoerceUnsized` and `DispatchFromDyn` is mainly used by smart pointers
+like `Box`, `Rc` and `Arc` to be able to mark that they can coerce unsized types
+that they are pointing at.
diff --git a/compiler/rustc_error_codes/src/error_codes/E0375.md b/compiler/rustc_error_codes/src/error_codes/E0375.md
index 71e530571650..7abb3b6afd02 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0375.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0375.md
@@ -1,5 +1,5 @@
-`CoerceUnsized` was implemented on a struct which contains more than one field
-with an unsized type.
+`CoerceUnsized` or `DispatchFromDyn` was implemented on a struct which contains
+more than one field that is being unsized.
 
 Erroneous code example:
 
@@ -17,39 +17,14 @@ struct Foo<T: ?Sized, U: ?Sized> {
 impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
 ```
 
-A struct with more than one field containing an unsized type cannot implement
-`CoerceUnsized`. This only occurs when you are trying to coerce one of the
-types in your struct to another type in the struct. In this case we try to
-impl `CoerceUnsized` from `T` to `U` which are both types that the struct
-takes. An [unsized type][1] is any type that the compiler doesn't know the
-length or alignment of at compile time. Any struct containing an unsized type
-is also unsized.
+`CoerceUnsized` is used to coerce structs that have a field that can be unsized,
+like a custom `MyBox<T>` being unsized to `MyBox<dyn Trait>`. `DispatchFromDyn`
+is used to dispatch from `MyBox<dyn Trait>` to `MyBox<Self>` in a dyn-compatible
+trait.
 
-`CoerceUnsized` only allows for coercion from a structure with a single
-unsized type field to another struct with a single unsized type field.
-In fact Rust only allows for a struct to have one unsized type in a struct
-and that unsized type must be the last field in the struct. So having two
-unsized types in a single struct is not allowed by the compiler. To fix this
-use only one field containing an unsized type in the struct and then use
-multiple structs to manage each unsized type field you need.
+If the struct has multiple fields that must be unsized, then the compiler has no
+way to generate a valid implementation of `CoerceUnsized` or `DispatchFromDyn`.
 
-Example:
-
-```
-#![feature(coerce_unsized)]
-use std::ops::CoerceUnsized;
-
-struct Foo<T: ?Sized> {
-    a: i32,
-    b: T,
-}
-
-impl <T, U> CoerceUnsized<Foo<U>> for Foo<T>
-    where T: CoerceUnsized<U> {}
-
-fn coerce_foo<T: CoerceUnsized<U>, U>(t: T) -> Foo<U> {
-    Foo { a: 12i32, b: t } // we use coercion to get the `Foo<U>` type we need
-}
-```
-
-[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
+Note that `CoerceUnsized` and `DispatchFromDyn` is mainly used by smart pointers
+like `Box`, `Rc` and `Arc` to be able to mark that they can coerce unsized types
+that they are pointing at.
diff --git a/compiler/rustc_error_codes/src/error_codes/E0376.md b/compiler/rustc_error_codes/src/error_codes/E0376.md
index 50de15bd30f0..5b564ec22fcb 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0376.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0376.md
@@ -1,8 +1,11 @@
-`CoerceUnsized` was implemented on something that isn't a struct.
+#### Note: this error code is no longer emitted by the compiler.
+
+`CoerceUnsized` or `DispatchFromDyn` was implemented between two types that
+are not structs.
 
 Erroneous code example:
 
-```compile_fail,E0376
+```compile_fail,E0377
 #![feature(coerce_unsized)]
 use std::ops::CoerceUnsized;
 
@@ -14,33 +17,4 @@ struct Foo<T: ?Sized> {
 impl<T, U> CoerceUnsized<U> for Foo<T> {}
 ```
 
-`CoerceUnsized` can only be implemented for a struct. Unsized types are
-already able to be coerced without an implementation of `CoerceUnsized`
-whereas a struct containing an unsized type needs to know the unsized type
-field it's containing is able to be coerced. An [unsized type][1]
-is any type that the compiler doesn't know the length or alignment of at
-compile time. Any struct containing an unsized type is also unsized.
-
-[1]: https://doc.rust-lang.org/book/ch19-04-advanced-types.html#dynamically-sized-types-and-the-sized-trait
-
-The `CoerceUnsized` trait takes a struct type. Make sure the type you are
-providing to `CoerceUnsized` is a struct with only the last field containing an
-unsized type.
-
-Example:
-
-```
-#![feature(coerce_unsized)]
-use std::ops::CoerceUnsized;
-
-struct Foo<T> {
-    a: T,
-}
-
-// The `Foo<U>` is a struct so `CoerceUnsized` can be implemented
-impl<T, U> CoerceUnsized<Foo<U>> for Foo<T> where T: CoerceUnsized<U> {}
-```
-
-Note that in Rust, structs can only contain an unsized type if the field
-containing the unsized type is the last and only unsized type field in the
-struct.
+`CoerceUnsized` or `DispatchFromDyn` can only be implemented between structs.
diff --git a/compiler/rustc_error_codes/src/error_codes/E0377.md b/compiler/rustc_error_codes/src/error_codes/E0377.md
index b1d36406332b..cd2b26260a8a 100644
--- a/compiler/rustc_error_codes/src/error_codes/E0377.md
+++ b/compiler/rustc_error_codes/src/error_codes/E0377.md
@@ -1,5 +1,5 @@
-The trait `CoerceUnsized` may only be implemented for a coercion between
-structures with the same definition.
+`CoerceUnsized` or `DispatchFromDyn` may only be implemented between structs
+of the same type.
 
 Example of erroneous code:
 
@@ -20,10 +20,15 @@ pub struct Bar<T: ?Sized> {
 impl<T, U> CoerceUnsized<Bar<U>> for Foo<T> where T: CoerceUnsized<U> {}
 ```
 
-When attempting to implement `CoerceUnsized`, the `impl` signature must look
-like: `impl CoerceUnsized<Type<U>> for Type<T> where T: CoerceUnsized<U>`;
-the *implementer* and *`CoerceUnsized` type parameter* must be the same
-type. In this example, `Bar` and `Foo` (even though structurally identical)
-are *not* the same type and are rejected. Learn more about the `CoerceUnsized`
-trait and DST coercion in
-[the `CoerceUnsized` docs](../std/ops/trait.CoerceUnsized.html).
+`CoerceUnsized` is used to coerce structs that have a field that can be unsized,
+like a custom `MyBox<T>` being unsized to `MyBox<dyn Trait>`. `DispatchFromDyn`
+is used to dispatch from `MyBox<dyn Trait>` to `MyBox<Self>` in a dyn-compatible
+trait.
+
+The compiler cannot support coercions between structs of different types, so
+a valid implementation of `CoerceUnsized` or `DispatchFromDyn` should be
+implemented between the same struct with different generic parameters.
+
+Note that `CoerceUnsized` and `DispatchFromDyn` is mainly used by smart pointers
+like `Box`, `Rc` and `Arc` to be able to mark that they can coerce unsized types
+that they are pointing at.
diff --git a/compiler/rustc_errors/Cargo.toml b/compiler/rustc_errors/Cargo.toml
index c1d8cd9bb9ed..b11793c190a1 100644
--- a/compiler/rustc_errors/Cargo.toml
+++ b/compiler/rustc_errors/Cargo.toml
@@ -10,6 +10,7 @@ derive_setters = "0.1.6"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
+rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_error_codes = { path = "../rustc_error_codes" }
 rustc_error_messages = { path = "../rustc_error_messages" }
diff --git a/compiler/rustc_errors/src/diagnostic.rs b/compiler/rustc_errors/src/diagnostic.rs
index 29a74ed3f4e4..7fffeaddb866 100644
--- a/compiler/rustc_errors/src/diagnostic.rs
+++ b/compiler/rustc_errors/src/diagnostic.rs
@@ -148,11 +148,17 @@ where
 /// converted rather than on `DiagArgValue`, which enables types from other `rustc_*` crates to
 /// implement this.
 pub trait IntoDiagArg {
-    fn into_diag_arg(self) -> DiagArgValue;
+    /// Convert `Self` into a `DiagArgValue` suitable for rendering in a diagnostic.
+    ///
+    /// It takes a `path` where "long values" could be written to, if the `DiagArgValue` is too big
+    /// for displaying on the terminal. This path comes from the `Diag` itself. When rendering
+    /// values that come from `TyCtxt`, like `Ty<'_>`, they can use `TyCtxt::short_string`. If a
+    /// value has no shortening logic that could be used, the argument can be safely ignored.
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue;
 }
 
 impl IntoDiagArg for DiagArgValue {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         self
     }
 }
@@ -395,7 +401,7 @@ impl DiagInner {
     }
 
     pub(crate) fn arg(&mut self, name: impl Into<DiagArgName>, arg: impl IntoDiagArg) {
-        self.args.insert(name.into(), arg.into_diag_arg());
+        self.args.insert(name.into(), arg.into_diag_arg(&mut self.long_ty_path));
     }
 
     /// Fields used for Hash, and PartialEq trait.
diff --git a/compiler/rustc_errors/src/diagnostic_impls.rs b/compiler/rustc_errors/src/diagnostic_impls.rs
index 7f383946c146..cb2e1769fa1c 100644
--- a/compiler/rustc_errors/src/diagnostic_impls.rs
+++ b/compiler/rustc_errors/src/diagnostic_impls.rs
@@ -8,6 +8,7 @@ use std::process::ExitStatus;
 use rustc_abi::TargetDataLayoutErrors;
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast_pretty::pprust;
+use rustc_attr_data_structures::RustcVersion;
 use rustc_macros::Subdiagnostic;
 use rustc_span::edition::Edition;
 use rustc_span::{Ident, MacroRulesNormalizedIdent, Span, Symbol};
@@ -24,8 +25,8 @@ use crate::{
 pub struct DiagArgFromDisplay<'a>(pub &'a dyn fmt::Display);
 
 impl IntoDiagArg for DiagArgFromDisplay<'_> {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.0.to_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.0.to_string().into_diag_arg(path)
     }
 }
 
@@ -42,8 +43,8 @@ impl<'a, T: fmt::Display> From<&'a T> for DiagArgFromDisplay<'a> {
 }
 
 impl<'a, T: Clone + IntoDiagArg> IntoDiagArg for &'a T {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.clone().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.clone().into_diag_arg(path)
     }
 }
 
@@ -52,8 +53,8 @@ macro_rules! into_diag_arg_using_display {
     ($( $ty:ty ),+ $(,)?) => {
         $(
             impl IntoDiagArg for $ty {
-                fn into_diag_arg(self) -> DiagArgValue {
-                    self.to_string().into_diag_arg()
+                fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+                    self.to_string().into_diag_arg(path)
                 }
             }
         )+
@@ -64,13 +65,13 @@ macro_rules! into_diag_arg_for_number {
     ($( $ty:ty ),+ $(,)?) => {
         $(
             impl IntoDiagArg for $ty {
-                fn into_diag_arg(self) -> DiagArgValue {
+                fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
                     // Convert to a string if it won't fit into `Number`.
                     #[allow(irrefutable_let_patterns)]
                     if let Ok(n) = TryInto::<i32>::try_into(self) {
                         DiagArgValue::Number(n)
                     } else {
-                        self.to_string().into_diag_arg()
+                        self.to_string().into_diag_arg(path)
                     }
                 }
             }
@@ -96,27 +97,33 @@ into_diag_arg_using_display!(
     rustc_abi::ExternAbi,
 );
 
+impl IntoDiagArg for RustcVersion {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        DiagArgValue::Str(Cow::Owned(self.to_string()))
+    }
+}
+
 impl<I: rustc_type_ir::Interner> IntoDiagArg for rustc_type_ir::TraitRef<I> {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_string().into_diag_arg(path)
     }
 }
 
 impl<I: rustc_type_ir::Interner> IntoDiagArg for rustc_type_ir::ExistentialTraitRef<I> {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_string().into_diag_arg(path)
     }
 }
 
 impl<I: rustc_type_ir::Interner> IntoDiagArg for rustc_type_ir::UnevaluatedConst<I> {
-    fn into_diag_arg(self) -> DiagArgValue {
-        format!("{self:?}").into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        format!("{self:?}").into_diag_arg(path)
     }
 }
 
 impl<I: rustc_type_ir::Interner> IntoDiagArg for rustc_type_ir::FnSig<I> {
-    fn into_diag_arg(self) -> DiagArgValue {
-        format!("{self:?}").into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        format!("{self:?}").into_diag_arg(path)
     }
 }
 
@@ -124,15 +131,15 @@ impl<I: rustc_type_ir::Interner, T> IntoDiagArg for rustc_type_ir::Binder<I, T>
 where
     T: IntoDiagArg,
 {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.skip_binder().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.skip_binder().into_diag_arg(path)
     }
 }
 
 into_diag_arg_for_number!(i8, u8, i16, u16, i32, u32, i64, u64, i128, u128, isize, usize);
 
 impl IntoDiagArg for bool {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         if self {
             DiagArgValue::Str(Cow::Borrowed("true"))
         } else {
@@ -142,13 +149,13 @@ impl IntoDiagArg for bool {
 }
 
 impl IntoDiagArg for char {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(format!("{self:?}")))
     }
 }
 
 impl IntoDiagArg for Vec<char> {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::StrListSepByAnd(
             self.into_iter().map(|c| Cow::Owned(format!("{c:?}"))).collect(),
         )
@@ -156,49 +163,49 @@ impl IntoDiagArg for Vec<char> {
 }
 
 impl IntoDiagArg for Symbol {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.to_ident_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_ident_string().into_diag_arg(path)
     }
 }
 
 impl<'a> IntoDiagArg for &'a str {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_string().into_diag_arg(path)
     }
 }
 
 impl IntoDiagArg for String {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self))
     }
 }
 
 impl<'a> IntoDiagArg for Cow<'a, str> {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.into_owned()))
     }
 }
 
 impl<'a> IntoDiagArg for &'a Path {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.display().to_string()))
     }
 }
 
 impl IntoDiagArg for PathBuf {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.display().to_string()))
     }
 }
 
 impl IntoDiagArg for PanicStrategy {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.desc().to_string()))
     }
 }
 
 impl IntoDiagArg for hir::ConstContext {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(match self {
             hir::ConstContext::ConstFn => "const_fn",
             hir::ConstContext::Static(_) => "static",
@@ -208,49 +215,49 @@ impl IntoDiagArg for hir::ConstContext {
 }
 
 impl IntoDiagArg for ast::Expr {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(pprust::expr_to_string(&self)))
     }
 }
 
 impl IntoDiagArg for ast::Path {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(pprust::path_to_string(&self)))
     }
 }
 
 impl IntoDiagArg for ast::token::Token {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(pprust::token_to_string(&self))
     }
 }
 
 impl IntoDiagArg for ast::token::TokenKind {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(pprust::token_kind_to_string(&self))
     }
 }
 
 impl IntoDiagArg for FloatTy {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(self.name_str()))
     }
 }
 
 impl IntoDiagArg for std::ffi::CString {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))
     }
 }
 
 impl IntoDiagArg for rustc_data_structures::small_c_str::SmallCStr {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Owned(self.to_string_lossy().into_owned()))
     }
 }
 
 impl IntoDiagArg for ast::Visibility {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         let s = pprust::vis_to_string(&self);
         let s = s.trim_end().to_string();
         DiagArgValue::Str(Cow::Owned(s))
@@ -258,49 +265,49 @@ impl IntoDiagArg for ast::Visibility {
 }
 
 impl IntoDiagArg for rustc_lint_defs::Level {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(self.to_cmd_flag()))
     }
 }
 
 impl<Id> IntoDiagArg for hir::def::Res<Id> {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(self.descr()))
     }
 }
 
 impl IntoDiagArg for DiagLocation {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::from(self.to_string()))
     }
 }
 
 impl IntoDiagArg for Backtrace {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::from(self.to_string()))
     }
 }
 
 impl IntoDiagArg for Level {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::from(self.to_string()))
     }
 }
 
 impl IntoDiagArg for ClosureKind {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(self.as_str().into())
     }
 }
 
 impl IntoDiagArg for hir::def::Namespace {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(self.descr()))
     }
 }
 
 impl IntoDiagArg for ExprPrecedence {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Number(self as i32)
     }
 }
@@ -321,7 +328,7 @@ impl<S> FromIterator<S> for DiagSymbolList<S> {
 }
 
 impl<S: std::fmt::Display> IntoDiagArg for DiagSymbolList<S> {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::StrListSepByAnd(
             self.0.into_iter().map(|sym| Cow::Owned(format!("`{sym}`"))).collect(),
         )
diff --git a/compiler/rustc_errors/src/lib.rs b/compiler/rustc_errors/src/lib.rs
index ceed0cd94fc9..f2b133f56773 100644
--- a/compiler/rustc_errors/src/lib.rs
+++ b/compiler/rustc_errors/src/lib.rs
@@ -15,7 +15,6 @@
 #![feature(box_into_inner)]
 #![feature(box_patterns)]
 #![feature(error_reporter)]
-#![feature(extract_if)]
 #![feature(if_let_guard)]
 #![feature(let_chains)]
 #![feature(negative_impls)]
diff --git a/compiler/rustc_expand/Cargo.toml b/compiler/rustc_expand/Cargo.toml
index 33bada106ca7..0ba139ea5cc5 100644
--- a/compiler/rustc_expand/Cargo.toml
+++ b/compiler/rustc_expand/Cargo.toml
@@ -17,6 +17,7 @@ rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
 rustc_fluent_macro = { path = "../rustc_fluent_macro" }
+rustc_hir = { path = "../rustc_hir" }
 rustc_lexer = { path = "../rustc_lexer" }
 rustc_lint_defs = { path = "../rustc_lint_defs" }
 rustc_macros = { path = "../rustc_macros" }
diff --git a/compiler/rustc_expand/src/base.rs b/compiler/rustc_expand/src/base.rs
index 819694d1cdc1..4a250145308c 100644
--- a/compiler/rustc_expand/src/base.rs
+++ b/compiler/rustc_expand/src/base.rs
@@ -11,11 +11,12 @@ use rustc_ast::token::Nonterminal;
 use rustc_ast::tokenstream::TokenStream;
 use rustc_ast::visit::{AssocCtxt, Visitor};
 use rustc_ast::{self as ast, AttrVec, Attribute, HasAttrs, Item, NodeId, PatKind};
-use rustc_attr_parsing::{self as attr, Deprecation, Stability};
+use rustc_attr_parsing::{AttributeKind, Deprecation, Stability, find_attr};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::sync;
 use rustc_errors::{DiagCtxtHandle, ErrorGuaranteed, PResult};
 use rustc_feature::Features;
+use rustc_hir as hir;
 use rustc_lint_defs::{BufferedEarlyLint, RegisteredTools};
 use rustc_parse::MACRO_ARGUMENTS;
 use rustc_parse::parser::Parser;
@@ -838,19 +839,23 @@ impl SyntaxExtension {
     /// and other properties converted from attributes.
     pub fn new(
         sess: &Session,
-        features: &Features,
         kind: SyntaxExtensionKind,
         span: Span,
         helper_attrs: Vec<Symbol>,
         edition: Edition,
         name: Symbol,
-        attrs: &[impl AttributeExt],
+        attrs: &[hir::Attribute],
         is_local: bool,
     ) -> SyntaxExtension {
         let allow_internal_unstable =
-            rustc_attr_parsing::allow_internal_unstable(sess, attrs).collect::<Vec<Symbol>>();
+            find_attr!(attrs, AttributeKind::AllowInternalUnstable(i) => i)
+                .map(|i| i.as_slice())
+                .unwrap_or_default();
+        // FIXME(jdonszelman): allow_internal_unsafe isn't yet new-style
+        // let allow_internal_unsafe = find_attr!(attrs, AttributeKind::AllowInternalUnsafe);
+        let allow_internal_unsafe =
+            ast::attr::find_by_name(attrs, sym::allow_internal_unsafe).is_some();
 
-        let allow_internal_unsafe = ast::attr::contains_name(attrs, sym::allow_internal_unsafe);
         let local_inner_macros = ast::attr::find_by_name(attrs, sym::macro_export)
             .and_then(|macro_export| macro_export.meta_item_list())
             .is_some_and(|l| ast::attr::list_contains_name(&l, sym::local_inner_macros));
@@ -867,16 +872,17 @@ impl SyntaxExtension {
                 )
             })
             .unwrap_or_else(|| (None, helper_attrs));
-        let stability = attr::find_stability(sess, attrs, span);
-        let const_stability = attr::find_const_stability(sess, attrs, span);
-        let body_stability = attr::find_body_stability(sess, attrs);
-        if let Some((_, sp)) = const_stability {
+
+        let stability = find_attr!(attrs, AttributeKind::Stability{stability, ..} => *stability);
+
+        // FIXME(jdonszelmann): make it impossible to miss the or_else in the typesystem
+        if let Some(sp) = find_attr!(attrs, AttributeKind::ConstStability{span, ..} => *span) {
             sess.dcx().emit_err(errors::MacroConstStability {
                 span: sp,
                 head_span: sess.source_map().guess_head_span(span),
             });
         }
-        if let Some((_, sp)) = body_stability {
+        if let Some(sp) = find_attr!(attrs, AttributeKind::BodyStability{span, ..} => *span) {
             sess.dcx().emit_err(errors::MacroBodyStability {
                 span: sp,
                 head_span: sess.source_map().guess_head_span(span),
@@ -887,9 +893,10 @@ impl SyntaxExtension {
             kind,
             span,
             allow_internal_unstable: (!allow_internal_unstable.is_empty())
-                .then(|| allow_internal_unstable.into()),
-            stability: stability.map(|(s, _)| s),
-            deprecation: attr::find_deprecation(sess, features, attrs).map(|(d, _)| d),
+                // FIXME(jdonszelmann): avoid the into_iter/collect?
+                .then(|| allow_internal_unstable.iter().map(|i| i.0).collect::<Vec<_>>().into()),
+            stability,
+            deprecation: find_attr!(attrs, AttributeKind::Deprecation{deprecation, ..} => *deprecation),
             helper_attrs,
             edition,
             builtin_name,
diff --git a/compiler/rustc_expand/src/mbe/macro_rules.rs b/compiler/rustc_expand/src/mbe/macro_rules.rs
index b02a9b93c8af..cc7e3e651050 100644
--- a/compiler/rustc_expand/src/mbe/macro_rules.rs
+++ b/compiler/rustc_expand/src/mbe/macro_rules.rs
@@ -3,17 +3,17 @@ use std::collections::hash_map::Entry;
 use std::{mem, slice};
 
 use ast::token::IdentIsRaw;
-use rustc_ast::attr::AttributeExt;
 use rustc_ast::token::NtPatKind::*;
 use rustc_ast::token::TokenKind::*;
 use rustc_ast::token::{self, Delimiter, NonterminalKind, Token, TokenKind};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream};
 use rustc_ast::{self as ast, DUMMY_NODE_ID, NodeId};
 use rustc_ast_pretty::pprust;
-use rustc_attr_parsing::{self as attr, TransparencyError};
+use rustc_attr_parsing::{AttributeKind, find_attr};
 use rustc_data_structures::fx::{FxHashMap, FxIndexMap};
 use rustc_errors::{Applicability, ErrorGuaranteed};
 use rustc_feature::Features;
+use rustc_hir as hir;
 use rustc_lint_defs::BuiltinLintDiag;
 use rustc_lint_defs::builtin::{
     RUST_2021_INCOMPATIBLE_OR_PATTERNS, SEMICOLON_IN_EXPRESSIONS_FROM_MACROS,
@@ -371,7 +371,7 @@ pub fn compile_declarative_macro(
     features: &Features,
     macro_def: &ast::MacroDef,
     ident: Ident,
-    attrs: &[impl AttributeExt],
+    attrs: &[hir::Attribute],
     span: Span,
     node_id: NodeId,
     edition: Edition,
@@ -379,7 +379,6 @@ pub fn compile_declarative_macro(
     let mk_syn_ext = |expander| {
         SyntaxExtension::new(
             sess,
-            features,
             SyntaxExtensionKind::LegacyBang(expander),
             span,
             Vec::new(),
@@ -391,7 +390,6 @@ pub fn compile_declarative_macro(
     };
     let dummy_syn_ext = |guar| (mk_syn_ext(Box::new(DummyExpander(guar))), Vec::new());
 
-    let dcx = sess.dcx();
     let lhs_nm = Ident::new(sym::lhs, span);
     let rhs_nm = Ident::new(sym::rhs, span);
     let tt_spec = Some(NonterminalKind::TT);
@@ -542,16 +540,8 @@ pub fn compile_declarative_macro(
 
     check_emission(macro_check::check_meta_variables(&sess.psess, node_id, span, &lhses, &rhses));
 
-    let (transparency, transparency_error) = attr::find_transparency(attrs, macro_rules);
-    match transparency_error {
-        Some(TransparencyError::UnknownTransparency(value, span)) => {
-            dcx.span_err(span, format!("unknown macro transparency: `{value}`"));
-        }
-        Some(TransparencyError::MultipleTransparencyAttrs(old_span, new_span)) => {
-            dcx.span_err(vec![old_span, new_span], "multiple macro transparency attributes");
-        }
-        None => {}
-    }
+    let transparency = find_attr!(attrs, AttributeKind::MacroTransparency(x) => *x)
+        .unwrap_or(Transparency::fallback(macro_rules));
 
     if let Some(guar) = guar {
         // To avoid warning noise, only consider the rules of this
diff --git a/compiler/rustc_expand/src/mbe/transcribe.rs b/compiler/rustc_expand/src/mbe/transcribe.rs
index 7fe9fa7937d9..70107c80147f 100644
--- a/compiler/rustc_expand/src/mbe/transcribe.rs
+++ b/compiler/rustc_expand/src/mbe/transcribe.rs
@@ -279,9 +279,9 @@ pub(super) fn transcribe<'a>(
                 if let Some(cur_matched) = lookup_cur_matched(ident, interp, &repeats) {
                     // We wrap the tokens in invisible delimiters, unless they are already wrapped
                     // in invisible delimiters with the same `MetaVarKind`. Because some proc
-                    // macros can't multiple layers of invisible delimiters of the same
+                    // macros can't handle multiple layers of invisible delimiters of the same
                     // `MetaVarKind`. This loses some span info, though it hopefully won't matter.
-                    let mut mk_delimited = |mv_kind, mut stream: TokenStream| {
+                    let mut mk_delimited = |mk_span, mv_kind, mut stream: TokenStream| {
                         if stream.len() == 1 {
                             let tree = stream.iter().next().unwrap();
                             if let TokenTree::Delimited(_, _, delim, inner) = tree
@@ -295,6 +295,7 @@ pub(super) fn transcribe<'a>(
                         // Emit as a token stream within `Delimiter::Invisible` to maintain
                         // parsing priorities.
                         marker.visit_span(&mut sp);
+                        with_metavar_spans(|mspans| mspans.insert(mk_span, sp));
                         // Both the open delim and close delim get the same span, which covers the
                         // `$foo` in the decl macro RHS.
                         TokenTree::Delimited(
@@ -322,12 +323,32 @@ pub(super) fn transcribe<'a>(
                             let kind = token::NtLifetime(*ident, *is_raw);
                             TokenTree::token_alone(kind, sp)
                         }
+                        MatchedSingle(ParseNtResult::Pat(pat, pat_kind)) => mk_delimited(
+                            pat.span,
+                            MetaVarKind::Pat(*pat_kind),
+                            TokenStream::from_ast(pat),
+                        ),
                         MatchedSingle(ParseNtResult::Ty(ty)) => {
                             let is_path = matches!(&ty.kind, TyKind::Path(None, _path));
-                            mk_delimited(MetaVarKind::Ty { is_path }, TokenStream::from_ast(ty))
+                            mk_delimited(
+                                ty.span,
+                                MetaVarKind::Ty { is_path },
+                                TokenStream::from_ast(ty),
+                            )
+                        }
+                        MatchedSingle(ParseNtResult::Meta(attr_item)) => {
+                            let has_meta_form = attr_item.meta_kind().is_some();
+                            mk_delimited(
+                                attr_item.span(),
+                                MetaVarKind::Meta { has_meta_form },
+                                TokenStream::from_ast(attr_item),
+                            )
+                        }
+                        MatchedSingle(ParseNtResult::Path(path)) => {
+                            mk_delimited(path.span, MetaVarKind::Path, TokenStream::from_ast(path))
                         }
                         MatchedSingle(ParseNtResult::Vis(vis)) => {
-                            mk_delimited(MetaVarKind::Vis, TokenStream::from_ast(vis))
+                            mk_delimited(vis.span, MetaVarKind::Vis, TokenStream::from_ast(vis))
                         }
                         MatchedSingle(ParseNtResult::Nt(nt)) => {
                             // Other variables are emitted into the output stream as groups with
diff --git a/compiler/rustc_feature/src/builtin_attrs.rs b/compiler/rustc_feature/src/builtin_attrs.rs
index b2ada8fe61ef..306535bf7642 100644
--- a/compiler/rustc_feature/src/builtin_attrs.rs
+++ b/compiler/rustc_feature/src/builtin_attrs.rs
@@ -1005,17 +1005,13 @@ pub static BUILTIN_ATTRIBUTES: &[BuiltinAttribute] = &[
         rustc_intrinsic, Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::Yes, intrinsics,
         "the `#[rustc_intrinsic]` attribute is used to declare intrinsics as function items",
     ),
-    gated!(
-        rustc_intrinsic_must_be_overridden, Normal, template!(Word), ErrorFollowing, EncodeCrossCrate::Yes, intrinsics,
-        "the `#[rustc_intrinsic_must_be_overridden]` attribute is used to declare intrinsics without real bodies",
-    ),
     rustc_attr!(
         rustc_no_mir_inline, Normal, template!(Word), WarnFollowing, EncodeCrossCrate::Yes,
         "#[rustc_no_mir_inline] prevents the MIR inliner from inlining a function while not affecting codegen"
     ),
     rustc_attr!(
         rustc_force_inline, Normal, template!(Word, NameValueStr: "reason"), WarnFollowing, EncodeCrossCrate::Yes,
-        "#![rustc_force_inline] forces a free function to be inlined"
+        "#[rustc_force_inline] forces a free function to be inlined"
     ),
 
     // ==========================================================================
diff --git a/compiler/rustc_feature/src/removed.rs b/compiler/rustc_feature/src/removed.rs
index 60e7788f2c05..fc58b66ad35e 100644
--- a/compiler/rustc_feature/src/removed.rs
+++ b/compiler/rustc_feature/src/removed.rs
@@ -100,6 +100,15 @@ declare_features! (
      Some("renamed to `doc_notable_trait`")),
     /// Allows using `#[unsafe_destructor_blind_to_params]` (RFC 1238).
     (removed, dropck_parametricity, "1.38.0", Some(28498), None),
+    /// Allows making `dyn Trait` well-formed even if `Trait` is not dyn compatible[^1].
+    /// In that case, `dyn Trait: Trait` does not hold. Moreover, coercions and
+    /// casts in safe Rust to `dyn Trait` for such a `Trait` is also forbidden.
+    ///
+    /// Renamed from `object_safe_for_dispatch`.
+    ///
+    /// [^1]: Formerly known as "object safe".
+    (removed, dyn_compatible_for_dispatch, "1.83.0", Some(43561),
+     Some("removed, not used heavily and represented additional complexity in dyn compatibility")),
     /// Uses generic effect parameters for ~const bounds
     (removed, effects, "1.84.0", Some(102090),
      Some("removed, redundant with `#![feature(const_trait_impl)]`")),
diff --git a/compiler/rustc_feature/src/unstable.rs b/compiler/rustc_feature/src/unstable.rs
index fe643e9a7d1d..0acd3b0f8002 100644
--- a/compiler/rustc_feature/src/unstable.rs
+++ b/compiler/rustc_feature/src/unstable.rs
@@ -270,14 +270,6 @@ declare_features! (
     (unstable, doc_notable_trait, "1.52.0", Some(45040)),
     /// Allows using the `may_dangle` attribute (RFC 1327).
     (unstable, dropck_eyepatch, "1.10.0", Some(34761)),
-    /// Allows making `dyn Trait` well-formed even if `Trait` is not dyn compatible[^1].
-    /// In that case, `dyn Trait: Trait` does not hold. Moreover, coercions and
-    /// casts in safe Rust to `dyn Trait` for such a `Trait` is also forbidden.
-    ///
-    /// Renamed from `object_safe_for_dispatch`.
-    ///
-    /// [^1]: Formerly known as "object safe".
-    (unstable, dyn_compatible_for_dispatch, "1.83.0", Some(43561)),
     /// Allows using the `#[fundamental]` attribute.
     (unstable, fundamental, "1.0.0", Some(29635)),
     /// Allows using `#[link_name="llvm.*"]`.
@@ -516,6 +508,8 @@ declare_features! (
     (incomplete, generic_const_exprs, "1.56.0", Some(76560)),
     /// Allows generic parameters and where-clauses on free & associated const items.
     (incomplete, generic_const_items, "1.73.0", Some(113521)),
+    /// Allows the type of const generics to depend on generic parameters
+    (incomplete, generic_const_parameter_types, "CURRENT_RUSTC_VERSION", Some(137626)),
     /// Allows any generic constants being used as pattern type range ends
     (incomplete, generic_pattern_types, "1.86.0", Some(136574)),
     /// Allows registering static items globally, possibly across crates, to iterate over at runtime.
diff --git a/compiler/rustc_hir/Cargo.toml b/compiler/rustc_hir/Cargo.toml
index 98300fc40fbe..7ca8539845a0 100644
--- a/compiler/rustc_hir/Cargo.toml
+++ b/compiler/rustc_hir/Cargo.toml
@@ -9,6 +9,7 @@ odht = { version = "0.3.1", features = ["nightly"] }
 rustc_abi = { path = "../rustc_abi" }
 rustc_arena = { path = "../rustc_arena" }
 rustc_ast = { path = "../rustc_ast" }
+rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hashes = { path = "../rustc_hashes" }
 rustc_index = { path = "../rustc_index" }
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index 61f64e62058f..399f1f4b2373 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -1,18 +1,20 @@
+// ignore-tidy-filelength
 use std::fmt;
 
 use rustc_abi::ExternAbi;
-// ignore-tidy-filelength
 use rustc_ast::attr::AttributeExt;
 use rustc_ast::token::CommentKind;
-use rustc_ast::util::parser::{AssocOp, ExprPrecedence};
+use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast::{
-    self as ast, AttrId, AttrStyle, DelimArgs, FloatTy, InlineAsmOptions, InlineAsmTemplatePiece,
-    IntTy, Label, LitIntType, LitKind, MetaItemInner, MetaItemLit, TraitObjectSyntax, UintTy,
+    self as ast, FloatTy, InlineAsmOptions, InlineAsmTemplatePiece, IntTy, Label, LitIntType,
+    LitKind, TraitObjectSyntax, UintTy, UnsafeBinderCastKind,
 };
 pub use rustc_ast::{
-    BinOp, BinOpKind, BindingMode, BorrowKind, BoundConstness, BoundPolarity, ByRef, CaptureBy,
-    ImplPolarity, IsAuto, Movability, Mutability, UnOp, UnsafeBinderCastKind,
+    AttrId, AttrStyle, BinOp, BinOpKind, BindingMode, BorrowKind, BoundConstness, BoundPolarity,
+    ByRef, CaptureBy, DelimArgs, ImplPolarity, IsAuto, MetaItemInner, MetaItemLit, Movability,
+    Mutability, UnOp,
 };
+use rustc_attr_data_structures::AttributeKind;
 use rustc_data_structures::fingerprint::Fingerprint;
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::tagged_ptr::TaggedRef;
@@ -1009,174 +1011,248 @@ pub enum AttrArgs {
     },
 }
 
-#[derive(Clone, Debug, Encodable, Decodable)]
-pub enum AttrKind {
-    /// A normal attribute.
-    Normal(Box<AttrItem>),
-
-    /// A doc comment (e.g. `/// ...`, `//! ...`, `/** ... */`, `/*! ... */`).
-    /// Doc attributes (e.g. `#[doc="..."]`) are represented with the `Normal`
-    /// variant (which is much less compact and thus more expensive).
-    DocComment(CommentKind, Symbol),
-}
-
 #[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable)]
 pub struct AttrPath {
     pub segments: Box<[Ident]>,
     pub span: Span,
 }
 
+impl AttrPath {
+    pub fn from_ast(path: &ast::Path) -> Self {
+        AttrPath {
+            segments: path.segments.iter().map(|i| i.ident).collect::<Vec<_>>().into_boxed_slice(),
+            span: path.span,
+        }
+    }
+}
+
+impl fmt::Display for AttrPath {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        write!(f, "{}", self.segments.iter().map(|i| i.to_string()).collect::<Vec<_>>().join("::"))
+    }
+}
+
 #[derive(Clone, Debug, HashStable_Generic, Encodable, Decodable)]
 pub struct AttrItem {
-    pub unsafety: Safety,
     // Not lowered to hir::Path because we have no NodeId to resolve to.
     pub path: AttrPath,
     pub args: AttrArgs,
-}
-
-#[derive(Clone, Debug, Encodable, Decodable)]
-pub struct Attribute {
-    pub kind: AttrKind,
-    pub id: AttrId,
+    pub id: HashIgnoredAttrId,
     /// Denotes if the attribute decorates the following construct (outer)
     /// or the construct this attribute is contained within (inner).
     pub style: AttrStyle,
+    /// Span of the entire attribute
     pub span: Span,
 }
 
+/// The derived implementation of [`HashStable_Generic`] on [`Attribute`]s shouldn't hash
+/// [`AttrId`]s. By wrapping them in this, we make sure we never do.
+#[derive(Copy, Debug, Encodable, Decodable, Clone)]
+pub struct HashIgnoredAttrId {
+    pub attr_id: AttrId,
+}
+
+#[derive(Clone, Debug, Encodable, Decodable, HashStable_Generic)]
+pub enum Attribute {
+    /// A parsed built-in attribute.
+    ///
+    /// Each attribute has a span connected to it. However, you must be somewhat careful using it.
+    /// That's because sometimes we merge multiple attributes together, like when an item has
+    /// multiple `repr` attributes. In this case the span might not be very useful.
+    Parsed(AttributeKind),
+
+    /// An attribute that could not be parsed, out of a token-like representation.
+    /// This is the case for custom tool attributes.
+    Unparsed(Box<AttrItem>),
+}
+
 impl Attribute {
     pub fn get_normal_item(&self) -> &AttrItem {
-        match &self.kind {
-            AttrKind::Normal(normal) => &normal,
-            AttrKind::DocComment(..) => panic!("unexpected doc comment"),
+        match &self {
+            Attribute::Unparsed(normal) => &normal,
+            _ => panic!("unexpected parsed attribute"),
         }
     }
 
     pub fn unwrap_normal_item(self) -> AttrItem {
-        match self.kind {
-            AttrKind::Normal(normal) => *normal,
-            AttrKind::DocComment(..) => panic!("unexpected doc comment"),
+        match self {
+            Attribute::Unparsed(normal) => *normal,
+            _ => panic!("unexpected parsed attribute"),
         }
     }
 
     pub fn value_lit(&self) -> Option<&MetaItemLit> {
-        match &self.kind {
-            AttrKind::Normal(box AttrItem { args: AttrArgs::Eq { expr, .. }, .. }) => Some(expr),
+        match &self {
+            Attribute::Unparsed(n) => match n.as_ref() {
+                AttrItem { args: AttrArgs::Eq { eq_span: _, expr }, .. } => Some(expr),
+                _ => None,
+            },
             _ => None,
         }
     }
 }
 
 impl AttributeExt for Attribute {
+    #[inline]
     fn id(&self) -> AttrId {
-        self.id
+        match &self {
+            Attribute::Unparsed(u) => u.id.attr_id,
+            _ => panic!(),
+        }
     }
 
+    #[inline]
     fn meta_item_list(&self) -> Option<ThinVec<ast::MetaItemInner>> {
-        match &self.kind {
-            AttrKind::Normal(box AttrItem { args: AttrArgs::Delimited(d), .. }) => {
-                ast::MetaItemKind::list_from_tokens(d.tokens.clone())
-            }
+        match &self {
+            Attribute::Unparsed(n) => match n.as_ref() {
+                AttrItem { args: AttrArgs::Delimited(d), .. } => {
+                    ast::MetaItemKind::list_from_tokens(d.tokens.clone())
+                }
+                _ => None,
+            },
             _ => None,
         }
     }
 
+    #[inline]
     fn value_str(&self) -> Option<Symbol> {
         self.value_lit().and_then(|x| x.value_str())
     }
 
+    #[inline]
     fn value_span(&self) -> Option<Span> {
         self.value_lit().map(|i| i.span)
     }
 
     /// For a single-segment attribute, returns its name; otherwise, returns `None`.
+    #[inline]
     fn ident(&self) -> Option<Ident> {
-        match &self.kind {
-            AttrKind::Normal(box AttrItem {
-                path: AttrPath { segments: box [ident], .. }, ..
-            }) => Some(*ident),
+        match &self {
+            Attribute::Unparsed(n) => {
+                if let [ident] = n.path.segments.as_ref() {
+                    Some(*ident)
+                } else {
+                    None
+                }
+            }
             _ => None,
         }
     }
 
+    #[inline]
     fn path_matches(&self, name: &[Symbol]) -> bool {
-        match &self.kind {
-            AttrKind::Normal(n) => n.path.segments.iter().map(|segment| &segment.name).eq(name),
-            AttrKind::DocComment(..) => false,
+        match &self {
+            Attribute::Unparsed(n) => {
+                n.path.segments.len() == name.len()
+                    && n.path.segments.iter().zip(name).all(|(s, n)| s.name == *n)
+            }
+            _ => false,
         }
     }
 
+    #[inline]
     fn is_doc_comment(&self) -> bool {
-        matches!(self.kind, AttrKind::DocComment(..))
+        matches!(self, Attribute::Parsed(AttributeKind::DocComment { .. }))
     }
 
+    #[inline]
     fn span(&self) -> Span {
-        self.span
-    }
-
-    fn is_word(&self) -> bool {
-        matches!(self.kind, AttrKind::Normal(box AttrItem { args: AttrArgs::Empty, .. }))
-    }
-
-    fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
-        match &self.kind {
-            AttrKind::Normal(n) => Some(n.path.segments.iter().copied().collect()),
-            AttrKind::DocComment(..) => None,
+        match &self {
+            Attribute::Unparsed(u) => u.span,
+            // FIXME: should not be needed anymore when all attrs are parsed
+            Attribute::Parsed(AttributeKind::Deprecation { span, .. }) => *span,
+            Attribute::Parsed(AttributeKind::DocComment { span, .. }) => *span,
+            a => panic!("can't get the span of an arbitrary parsed attribute: {a:?}"),
         }
     }
 
-    fn doc_str(&self) -> Option<Symbol> {
-        match &self.kind {
-            AttrKind::DocComment(.., data) => Some(*data),
-            AttrKind::Normal(_) if self.has_name(sym::doc) => self.value_str(),
+    #[inline]
+    fn is_word(&self) -> bool {
+        match &self {
+            Attribute::Unparsed(n) => {
+                matches!(n.args, AttrArgs::Empty)
+            }
+            _ => false,
+        }
+    }
+
+    #[inline]
+    fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
+        match &self {
+            Attribute::Unparsed(n) => Some(n.path.segments.iter().copied().collect()),
             _ => None,
         }
     }
+
+    #[inline]
+    fn doc_str(&self) -> Option<Symbol> {
+        match &self {
+            Attribute::Parsed(AttributeKind::DocComment { comment, .. }) => Some(*comment),
+            Attribute::Unparsed(_) if self.has_name(sym::doc) => self.value_str(),
+            _ => None,
+        }
+    }
+    #[inline]
     fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
-        match &self.kind {
-            AttrKind::DocComment(kind, data) => Some((*data, *kind)),
-            AttrKind::Normal(_) if self.name_or_empty() == sym::doc => {
+        match &self {
+            Attribute::Parsed(AttributeKind::DocComment { kind, comment, .. }) => {
+                Some((*comment, *kind))
+            }
+            Attribute::Unparsed(_) if self.name_or_empty() == sym::doc => {
                 self.value_str().map(|s| (s, CommentKind::Line))
             }
             _ => None,
         }
     }
 
+    #[inline]
     fn style(&self) -> AttrStyle {
-        self.style
+        match &self {
+            Attribute::Unparsed(u) => u.style,
+            Attribute::Parsed(AttributeKind::DocComment { style, .. }) => *style,
+            _ => panic!(),
+        }
     }
 }
 
 // FIXME(fn_delegation): use function delegation instead of manually forwarding
 impl Attribute {
+    #[inline]
     pub fn id(&self) -> AttrId {
         AttributeExt::id(self)
     }
 
+    #[inline]
     pub fn name_or_empty(&self) -> Symbol {
         AttributeExt::name_or_empty(self)
     }
 
+    #[inline]
     pub fn meta_item_list(&self) -> Option<ThinVec<MetaItemInner>> {
         AttributeExt::meta_item_list(self)
     }
 
+    #[inline]
     pub fn value_str(&self) -> Option<Symbol> {
         AttributeExt::value_str(self)
     }
 
+    #[inline]
     pub fn value_span(&self) -> Option<Span> {
         AttributeExt::value_span(self)
     }
 
+    #[inline]
     pub fn ident(&self) -> Option<Ident> {
         AttributeExt::ident(self)
     }
 
+    #[inline]
     pub fn path_matches(&self, name: &[Symbol]) -> bool {
         AttributeExt::path_matches(self, name)
     }
 
+    #[inline]
     pub fn is_doc_comment(&self) -> bool {
         AttributeExt::is_doc_comment(self)
     }
@@ -1186,34 +1262,42 @@ impl Attribute {
         AttributeExt::has_name(self, name)
     }
 
+    #[inline]
     pub fn span(&self) -> Span {
         AttributeExt::span(self)
     }
 
+    #[inline]
     pub fn is_word(&self) -> bool {
         AttributeExt::is_word(self)
     }
 
+    #[inline]
     pub fn path(&self) -> SmallVec<[Symbol; 1]> {
         AttributeExt::path(self)
     }
 
+    #[inline]
     pub fn ident_path(&self) -> Option<SmallVec<[Ident; 1]>> {
         AttributeExt::ident_path(self)
     }
 
+    #[inline]
     pub fn doc_str(&self) -> Option<Symbol> {
         AttributeExt::doc_str(self)
     }
 
+    #[inline]
     pub fn is_proc_macro_attr(&self) -> bool {
         AttributeExt::is_proc_macro_attr(self)
     }
 
+    #[inline]
     pub fn doc_str_and_comment_kind(&self) -> Option<(Symbol, CommentKind)> {
         AttributeExt::doc_str_and_comment_kind(self)
     }
 
+    #[inline]
     pub fn style(&self) -> AttrStyle {
         AttributeExt::style(self)
     }
@@ -1599,6 +1683,12 @@ pub enum PatKind<'hir> {
     /// The `HirId` is the canonical ID for the variable being bound,
     /// (e.g., in `Ok(x) | Err(x)`, both `x` use the same canonical ID),
     /// which is the pattern ID of the first `x`.
+    ///
+    /// The `BindingMode` is what's provided by the user, before match
+    /// ergonomics are applied. For the binding mode actually in use,
+    /// see [`TypeckResults::extract_binding_mode`].
+    ///
+    /// [`TypeckResults::extract_binding_mode`]: ../../rustc_middle/ty/struct.TypeckResults.html#method.extract_binding_mode
     Binding(BindingMode, HirId, Ident, Option<&'hir Pat<'hir>>),
 
     /// A struct or struct variant pattern (e.g., `Variant {x, y, ..}`).
@@ -2040,7 +2130,7 @@ impl Expr<'_> {
             | ExprKind::Become(..) => ExprPrecedence::Jump,
 
             // Binop-like expr kinds, handled by `AssocOp`.
-            ExprKind::Binary(op, ..) => AssocOp::from_ast_binop(op.node).precedence(),
+            ExprKind::Binary(op, ..) => op.node.precedence(),
             ExprKind::Cast(..) => ExprPrecedence::Cast,
 
             ExprKind::Assign(..) |
@@ -3422,7 +3512,7 @@ pub enum InlineAsmOperand<'hir> {
         out_expr: Option<&'hir Expr<'hir>>,
     },
     Const {
-        anon_const: &'hir AnonConst,
+        anon_const: ConstBlock,
     },
     SymFn {
         expr: &'hir Expr<'hir>,
diff --git a/compiler/rustc_hir/src/intravisit.rs b/compiler/rustc_hir/src/intravisit.rs
index d5fa7ec366b2..e349e23f7dcf 100644
--- a/compiler/rustc_hir/src/intravisit.rs
+++ b/compiler/rustc_hir/src/intravisit.rs
@@ -1447,7 +1447,7 @@ pub fn walk_inline_asm<'v, V: Visitor<'v>>(
                 visit_opt!(visitor, visit_expr, out_expr);
             }
             InlineAsmOperand::Const { anon_const, .. } => {
-                try_visit!(visitor.visit_anon_const(anon_const));
+                try_visit!(visitor.visit_inline_const(anon_const));
             }
             InlineAsmOperand::SymFn { expr, .. } => {
                 try_visit!(visitor.visit_expr(expr));
diff --git a/compiler/rustc_hir/src/stable_hash_impls.rs b/compiler/rustc_hir/src/stable_hash_impls.rs
index d7c8a3d5c0a5..2709a826549c 100644
--- a/compiler/rustc_hir/src/stable_hash_impls.rs
+++ b/compiler/rustc_hir/src/stable_hash_impls.rs
@@ -1,17 +1,21 @@
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher, ToStableHashKey};
 use rustc_span::def_id::DefPathHash;
 
+use crate::HashIgnoredAttrId;
 use crate::hir::{
-    Attribute, AttributeMap, BodyId, Crate, ForeignItemId, ImplItemId, ItemId, OwnerNodes,
-    TraitItemId,
+    AttributeMap, BodyId, Crate, ForeignItemId, ImplItemId, ItemId, OwnerNodes, TraitItemId,
 };
 use crate::hir_id::{HirId, ItemLocalId};
 
 /// Requirements for a `StableHashingContext` to be used in this crate.
 /// This is a hack to allow using the `HashStable_Generic` derive macro
 /// instead of implementing everything in `rustc_middle`.
-pub trait HashStableContext: rustc_ast::HashStableContext + rustc_abi::HashStableContext {
-    fn hash_attr(&mut self, _: &Attribute, hasher: &mut StableHasher);
+pub trait HashStableContext:
+    rustc_attr_data_structures::HashStableContext
+    + rustc_ast::HashStableContext
+    + rustc_abi::HashStableContext
+{
+    fn hash_attr_id(&mut self, id: &HashIgnoredAttrId, hasher: &mut StableHasher);
 }
 
 impl<HirCtx: crate::HashStableContext> ToStableHashKey<HirCtx> for HirId {
@@ -114,8 +118,8 @@ impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Crate<'_> {
     }
 }
 
-impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for Attribute {
+impl<HirCtx: crate::HashStableContext> HashStable<HirCtx> for HashIgnoredAttrId {
     fn hash_stable(&self, hcx: &mut HirCtx, hasher: &mut StableHasher) {
-        hcx.hash_attr(self, hasher)
+        hcx.hash_attr_id(self, hasher)
     }
 }
diff --git a/compiler/rustc_hir_analysis/messages.ftl b/compiler/rustc_hir_analysis/messages.ftl
index 47d5976be09e..3f75cce00922 100644
--- a/compiler/rustc_hir_analysis/messages.ftl
+++ b/compiler/rustc_hir_analysis/messages.ftl
@@ -85,6 +85,10 @@ hir_analysis_cmse_output_stack_spill =
     .note1 = functions with the `{$abi}` ABI must pass their result via the available return registers
     .note2 = the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
+hir_analysis_coerce_multi = implementing `{$trait_name}` does not allow multiple fields to be coerced
+    .note = the trait `{$trait_name}` may only be implemented when a single field is being coerced
+    .label = these fields must be coerced for `{$trait_name}` to be valid
+
 hir_analysis_coerce_pointee_no_field = `CoercePointee` can only be derived on `struct`s with at least one field
 
 hir_analysis_coerce_pointee_no_user_validity_assertion = asserting applicability of `derive(CoercePointee)` on a target data is forbidden
@@ -95,12 +99,12 @@ hir_analysis_coerce_pointee_not_struct = `derive(CoercePointee)` is only applica
 
 hir_analysis_coerce_pointee_not_transparent = `derive(CoercePointee)` is only applicable to `struct` with `repr(transparent)` layout
 
+hir_analysis_coerce_unsized_field_validity = for `{$ty}` to have a valid implementation of `{$trait_name}`, it must be possible to coerce the field of type `{$field_ty}`
+    .label = `{$field_ty}` must be a pointer, reference, or smart pointer that is allowed to be unsized
+
 hir_analysis_coerce_unsized_may = the trait `{$trait_name}` may only be implemented for a coercion between structures
 
-hir_analysis_coerce_unsized_multi = implementing the trait `CoerceUnsized` requires multiple coercions
-    .note = `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced
-    .coercions_note = currently, {$number} fields need coercions: {$coercions}
-    .label = requires multiple coercions
+hir_analysis_coerce_zero = implementing `{$trait_name}` requires a field to be coerced
 
 hir_analysis_coercion_between_struct_same_note = expected coercion between the same definition; expected `{$source_path}`, found `{$target_path}`
 
@@ -139,10 +143,6 @@ hir_analysis_cross_crate_traits = cross-crate traits with a default impl, like `
 hir_analysis_cross_crate_traits_defined = cross-crate traits with a default impl, like `{$traits}`, can only be implemented for a struct/enum type defined in the current crate
     .label = can't implement cross-crate trait for type in another crate
 
-hir_analysis_dispatch_from_dyn_multi = implementing the `DispatchFromDyn` trait requires multiple coercions
-    .note = the trait `DispatchFromDyn` may only be implemented for a coercion between structures with a single field being coerced
-    .coercions_note = currently, {$number} fields need coercions: {$coercions}
-
 hir_analysis_dispatch_from_dyn_repr = structs implementing `DispatchFromDyn` may not have `#[repr(packed)]` or `#[repr(C)]`
 
 hir_analysis_dispatch_from_dyn_zst = the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment that don't mention type/const generics, and nothing else
@@ -605,6 +605,8 @@ hir_analysis_unused_generic_parameter_adt_no_phantom_data_help =
 hir_analysis_unused_generic_parameter_ty_alias_help =
     consider removing `{$param_name}` or referring to it in the body of the type alias
 
+hir_analysis_useless_impl_item = this item cannot be used as its where bounds are not satisfied for the `Self` type
+
 hir_analysis_value_of_associated_struct_already_specified =
     the value of the associated type `{$item_name}` in trait `{$def_path}` is already specified
     .label = re-bound here
diff --git a/compiler/rustc_hir_analysis/src/check/check.rs b/compiler/rustc_hir_analysis/src/check/check.rs
index 3236e0a3644d..f2331f3fd8e1 100644
--- a/compiler/rustc_hir_analysis/src/check/check.rs
+++ b/compiler/rustc_hir_analysis/src/check/check.rs
@@ -2,6 +2,8 @@ use std::cell::LazyCell;
 use std::ops::ControlFlow;
 
 use rustc_abi::FieldIdx;
+use rustc_attr_parsing::AttributeKind;
+use rustc_attr_parsing::ReprAttr::ReprPacked;
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::MultiSpan;
 use rustc_errors::codes::*;
@@ -990,6 +992,32 @@ fn check_impl_items_against_trait<'tcx>(
 
     let trait_def = tcx.trait_def(trait_ref.def_id);
 
+    let infcx = tcx.infer_ctxt().ignoring_regions().build(TypingMode::non_body_analysis());
+
+    let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
+    let cause = ObligationCause::misc(tcx.def_span(impl_id), impl_id);
+    let param_env = tcx.param_env(impl_id);
+
+    let self_is_guaranteed_unsized = match tcx
+        .struct_tail_raw(
+            trait_ref.self_ty(),
+            |ty| {
+                ocx.structurally_normalize_ty(&cause, param_env, ty).unwrap_or_else(|_| {
+                    Ty::new_error_with_message(
+                        tcx,
+                        tcx.def_span(impl_id),
+                        "struct tail should be computable",
+                    )
+                })
+            },
+            || (),
+        )
+        .kind()
+    {
+        ty::Dynamic(_, _, ty::DynKind::Dyn) | ty::Slice(_) | ty::Str => true,
+        _ => false,
+    };
+
     for &impl_item in impl_item_refs {
         let ty_impl_item = tcx.associated_item(impl_item);
         let ty_trait_item = if let Some(trait_item_id) = ty_impl_item.trait_item_def_id {
@@ -1019,6 +1047,15 @@ fn check_impl_items_against_trait<'tcx>(
             }
         }
 
+        if self_is_guaranteed_unsized && tcx.generics_require_sized_self(ty_trait_item.def_id) {
+            tcx.emit_node_span_lint(
+                rustc_lint_defs::builtin::DEAD_CODE,
+                tcx.local_def_id_to_hir_id(ty_impl_item.def_id.expect_local()),
+                tcx.def_span(ty_impl_item.def_id),
+                errors::UselessImplItem,
+            )
+        }
+
         check_specialization_validity(
             tcx,
             trait_def,
@@ -1042,7 +1079,11 @@ fn check_impl_items_against_trait<'tcx>(
                 .as_ref()
                 .is_some_and(|node_item| node_item.item.defaultness(tcx).has_value());
 
-            if !is_implemented && tcx.defaultness(impl_id).is_final() {
+            if !is_implemented
+                && tcx.defaultness(impl_id).is_final()
+                // unsized types don't need to implement methods that have `Self: Sized` bounds.
+                && !(self_is_guaranteed_unsized && tcx.generics_require_sized_self(trait_item_id))
+            {
                 missing_items.push(tcx.associated_item(trait_item_id));
             }
 
@@ -1114,7 +1155,7 @@ fn check_impl_items_against_trait<'tcx>(
         if let Some(missing_items) = must_implement_one_of {
             let attr_span = tcx
                 .get_attr(trait_ref.def_id, sym::rustc_must_implement_one_of)
-                .map(|attr| attr.span);
+                .map(|attr| attr.span());
 
             missing_items_must_implement_one_of_err(
                 tcx,
@@ -1203,11 +1244,13 @@ fn check_simd(tcx: TyCtxt<'_>, sp: Span, def_id: LocalDefId) {
 pub(super) fn check_packed(tcx: TyCtxt<'_>, sp: Span, def: ty::AdtDef<'_>) {
     let repr = def.repr();
     if repr.packed() {
-        for attr in tcx.get_attrs(def.did(), sym::repr) {
-            for r in attr::parse_repr_attr(tcx.sess, attr) {
-                if let attr::ReprPacked(pack) = r
+        if let Some(reprs) =
+            attr::find_attr!(tcx.get_all_attrs(def.did()), AttributeKind::Repr(r) => r)
+        {
+            for (r, _) in reprs {
+                if let ReprPacked(pack) = r
                     && let Some(repr_pack) = repr.pack
-                    && pack != repr_pack
+                    && pack != &repr_pack
                 {
                     struct_span_code_err!(
                         tcx.dcx(),
@@ -1419,16 +1462,19 @@ fn check_enum(tcx: TyCtxt<'_>, def_id: LocalDefId) {
     def.destructor(tcx); // force the destructor to be evaluated
 
     if def.variants().is_empty() {
-        if let Some(attr) = tcx.get_attrs(def_id, sym::repr).next() {
-            struct_span_code_err!(
-                tcx.dcx(),
-                attr.span,
-                E0084,
-                "unsupported representation for zero-variant enum"
-            )
-            .with_span_label(tcx.def_span(def_id), "zero-variant enum")
-            .emit();
-        }
+        attr::find_attr!(
+            tcx.get_all_attrs(def_id),
+            AttributeKind::Repr(rs) => {
+                struct_span_code_err!(
+                    tcx.dcx(),
+                    rs.first().unwrap().1,
+                    E0084,
+                    "unsupported representation for zero-variant enum"
+                )
+                .with_span_label(tcx.def_span(def_id), "zero-variant enum")
+                .emit();
+            }
+        );
     }
 
     let repr_type_ty = def.repr().discr_type().to_ty(tcx);
diff --git a/compiler/rustc_hir_analysis/src/check/entry.rs b/compiler/rustc_hir_analysis/src/check/entry.rs
index 25c2f8554b7f..3bad36da9990 100644
--- a/compiler/rustc_hir_analysis/src/check/entry.rs
+++ b/compiler/rustc_hir_analysis/src/check/entry.rs
@@ -99,7 +99,7 @@ fn check_main_fn_ty(tcx: TyCtxt<'_>, main_def_id: DefId) {
     }
 
     for attr in tcx.get_attrs(main_def_id, sym::track_caller) {
-        tcx.dcx().emit_err(errors::TrackCallerOnMain { span: attr.span, annotated: main_span });
+        tcx.dcx().emit_err(errors::TrackCallerOnMain { span: attr.span(), annotated: main_span });
         error = true;
     }
 
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsic.rs b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
index d468027602cf..42d785c8dd0f 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsic.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsic.rs
@@ -645,7 +645,6 @@ pub fn check_intrinsic_type(
             | sym::simd_xor
             | sym::simd_fmin
             | sym::simd_fmax
-            | sym::simd_fpow
             | sym::simd_saturating_add
             | sym::simd_saturating_sub => (1, 0, vec![param(0), param(0)], param(0)),
             sym::simd_arith_offset => (2, 0, vec![param(0), param(1)], param(0)),
@@ -668,7 +667,6 @@ pub fn check_intrinsic_type(
             | sym::simd_floor
             | sym::simd_round
             | sym::simd_trunc => (1, 0, vec![param(0)], param(0)),
-            sym::simd_fpowi => (1, 0, vec![param(0), tcx.types.i32], param(0)),
             sym::simd_fma | sym::simd_relaxed_fma => {
                 (1, 0, vec![param(0), param(0), param(0)], param(0))
             }
@@ -699,7 +697,7 @@ pub fn check_intrinsic_type(
             | sym::simd_reduce_min
             | sym::simd_reduce_max => (2, 0, vec![param(0)], param(1)),
             sym::simd_shuffle => (3, 0, vec![param(0), param(0), param(1)], param(2)),
-            sym::simd_shuffle_generic => (2, 1, vec![param(0), param(0)], param(1)),
+            sym::simd_shuffle_const_generic => (2, 1, vec![param(0), param(0)], param(1)),
 
             other => {
                 tcx.dcx().emit_err(UnrecognizedIntrinsicFunction { span, name: other });
diff --git a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs b/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
index e1727fc48a83..590ade516ec6 100644
--- a/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
+++ b/compiler/rustc_hir_analysis/src/check/intrinsicck.rs
@@ -1,5 +1,3 @@
-use std::assert_matches::debug_assert_matches;
-
 use rustc_abi::FieldIdx;
 use rustc_ast::InlineAsmTemplatePiece;
 use rustc_data_structures::fx::FxIndexSet;
@@ -21,28 +19,30 @@ pub struct InlineAsmCtxt<'a, 'tcx: 'a> {
     typing_env: ty::TypingEnv<'tcx>,
     target_features: &'tcx FxIndexSet<Symbol>,
     expr_ty: Box<dyn Fn(&hir::Expr<'tcx>) -> Ty<'tcx> + 'a>,
+    node_ty: Box<dyn Fn(hir::HirId) -> Ty<'tcx> + 'a>,
 }
 
 enum NonAsmTypeReason<'tcx> {
     UnevaluatedSIMDArrayLength(DefId, ty::Const<'tcx>),
     Invalid(Ty<'tcx>),
     InvalidElement(DefId, Ty<'tcx>),
+    NotSizedPtr(Ty<'tcx>),
 }
 
 impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
     pub fn new(
         tcx: TyCtxt<'tcx>,
         def_id: LocalDefId,
-        get_operand_ty: impl Fn(&hir::Expr<'tcx>) -> Ty<'tcx> + 'a,
+        typing_env: ty::TypingEnv<'tcx>,
+        expr_ty: impl Fn(&hir::Expr<'tcx>) -> Ty<'tcx> + 'a,
+        node_ty: impl Fn(hir::HirId) -> Ty<'tcx> + 'a,
     ) -> Self {
         InlineAsmCtxt {
             tcx,
-            typing_env: ty::TypingEnv {
-                typing_mode: ty::TypingMode::non_body_analysis(),
-                param_env: ty::ParamEnv::empty(),
-            },
+            typing_env,
             target_features: tcx.asm_target_features(def_id),
-            expr_ty: Box::new(get_operand_ty),
+            expr_ty: Box::new(expr_ty),
+            node_ty: Box::new(node_ty),
         }
     }
 
@@ -50,6 +50,10 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
         (self.expr_ty)(expr)
     }
 
+    fn node_ty(&self, hir_id: hir::HirId) -> Ty<'tcx> {
+        (self.node_ty)(hir_id)
+    }
+
     // FIXME(compiler-errors): This could use `<$ty as Pointee>::Metadata == ()`
     fn is_thin_ptr_ty(&self, ty: Ty<'tcx>) -> bool {
         // Type still may have region variables, but `Sized` does not depend
@@ -83,7 +87,13 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
             ty::Float(FloatTy::F64) => Ok(InlineAsmType::F64),
             ty::Float(FloatTy::F128) => Ok(InlineAsmType::F128),
             ty::FnPtr(..) => Ok(asm_ty_isize),
-            ty::RawPtr(ty, _) if self.is_thin_ptr_ty(ty) => Ok(asm_ty_isize),
+            ty::RawPtr(elem_ty, _) => {
+                if self.is_thin_ptr_ty(elem_ty) {
+                    Ok(asm_ty_isize)
+                } else {
+                    Err(NonAsmTypeReason::NotSizedPtr(ty))
+                }
+            }
             ty::Adt(adt, args) if adt.repr().simd() => {
                 let fields = &adt.non_enum_variant().fields;
                 let field = &fields[FieldIdx::ZERO];
@@ -189,6 +199,16 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
                             can be used as arguments for inline assembly",
                         ).emit();
                     }
+                    NonAsmTypeReason::NotSizedPtr(ty) => {
+                        let msg = format!(
+                            "cannot use value of unsized pointer type `{ty}` for inline assembly"
+                        );
+                        self.tcx
+                            .dcx()
+                            .struct_span_err(expr.span, msg)
+                            .with_note("only sized pointers can be used in inline assembly")
+                            .emit();
+                    }
                     NonAsmTypeReason::InvalidElement(did, ty) => {
                         let msg = format!(
                             "cannot use SIMD vector with element type `{ty}` for inline assembly"
@@ -472,12 +492,23 @@ impl<'a, 'tcx> InlineAsmCtxt<'a, 'tcx> {
                         );
                     }
                 }
-                // Typeck has checked that Const operands are integers.
                 hir::InlineAsmOperand::Const { anon_const } => {
-                    debug_assert_matches!(
-                        self.tcx.type_of(anon_const.def_id).instantiate_identity().kind(),
-                        ty::Error(_) | ty::Int(_) | ty::Uint(_)
-                    );
+                    let ty = self.node_ty(anon_const.hir_id);
+                    match ty.kind() {
+                        ty::Error(_) => {}
+                        _ if ty.is_integral() => {}
+                        _ => {
+                            self.tcx
+                                .dcx()
+                                .struct_span_err(op_sp, "invalid type for `const` operand")
+                                .with_span_label(
+                                    self.tcx.def_span(anon_const.def_id),
+                                    format!("is {} `{}`", ty.kind().article(), ty),
+                                )
+                                .with_help("`const` operands must be of an integer type")
+                                .emit();
+                        }
+                    }
                 }
                 // Typeck has checked that SymFn refers to a function.
                 hir::InlineAsmOperand::SymFn { expr } => {
diff --git a/compiler/rustc_hir_analysis/src/check/wfcheck.rs b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
index e6ea6eddcaaf..d72cf00293f0 100644
--- a/compiler/rustc_hir_analysis/src/check/wfcheck.rs
+++ b/compiler/rustc_hir_analysis/src/check/wfcheck.rs
@@ -966,7 +966,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
             let ty = tcx.type_of(param.def_id).instantiate_identity();
 
             if tcx.features().unsized_const_params() {
-                enter_wf_checking_ctxt(tcx, hir_ty.span, param.def_id, |wfcx| {
+                enter_wf_checking_ctxt(tcx, hir_ty.span, tcx.local_parent(param.def_id), |wfcx| {
                     wfcx.register_bound(
                         ObligationCause::new(
                             hir_ty.span,
@@ -980,7 +980,7 @@ fn check_param_wf(tcx: TyCtxt<'_>, param: &hir::GenericParam<'_>) -> Result<(),
                     Ok(())
                 })
             } else if tcx.features().adt_const_params() {
-                enter_wf_checking_ctxt(tcx, hir_ty.span, param.def_id, |wfcx| {
+                enter_wf_checking_ctxt(tcx, hir_ty.span, tcx.local_parent(param.def_id), |wfcx| {
                     wfcx.register_bound(
                         ObligationCause::new(
                             hir_ty.span,
diff --git a/compiler/rustc_hir_analysis/src/coherence/builtin.rs b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
index b46b805f0a9d..cee2f487639d 100644
--- a/compiler/rustc_hir_analysis/src/coherence/builtin.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/builtin.rs
@@ -17,7 +17,7 @@ use rustc_middle::ty::print::PrintTraitRefExt as _;
 use rustc_middle::ty::{
     self, Ty, TyCtxt, TypeVisitableExt, TypingMode, suggest_constraining_type_params,
 };
-use rustc_span::{DUMMY_SP, Span};
+use rustc_span::{DUMMY_SP, Span, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::traits::misc::{
     ConstParamTyImplementationError, CopyImplementationError, InfringingFieldsReason,
@@ -195,8 +195,14 @@ fn visit_implementation_of_coerce_unsized(checker: &Checker<'_>) -> Result<(), E
     // Just compute this for the side-effects, in particular reporting
     // errors; other parts of the code may demand it for the info of
     // course.
-    let span = tcx.def_span(impl_did);
-    tcx.at(span).ensure_ok().coerce_unsized_info(impl_did)
+    tcx.ensure_ok().coerce_unsized_info(impl_did)
+}
+
+fn is_from_coerce_pointee_derive(tcx: TyCtxt<'_>, span: Span) -> bool {
+    span.ctxt()
+        .outer_expn_data()
+        .macro_def_id
+        .is_some_and(|def_id| tcx.is_diagnostic_item(sym::CoercePointee, def_id))
 }
 
 fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<(), ErrorGuaranteed> {
@@ -206,17 +212,29 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
     debug!("visit_implementation_of_dispatch_from_dyn: impl_did={:?}", impl_did);
 
     let span = tcx.def_span(impl_did);
+    let trait_name = "DispatchFromDyn";
 
     let dispatch_from_dyn_trait = tcx.require_lang_item(LangItem::DispatchFromDyn, Some(span));
 
     let source = trait_ref.self_ty();
-    assert!(!source.has_escaping_bound_vars());
     let target = {
         assert_eq!(trait_ref.def_id, dispatch_from_dyn_trait);
 
         trait_ref.args.type_at(1)
     };
 
+    // Check `CoercePointee` impl is WF -- if not, then there's no reason to report
+    // redundant errors for `DispatchFromDyn`. This is best effort, though.
+    let mut res = Ok(());
+    tcx.for_each_relevant_impl(
+        tcx.require_lang_item(LangItem::CoerceUnsized, Some(span)),
+        source,
+        |impl_def_id| {
+            res = res.and(tcx.ensure_ok().coerce_unsized_info(impl_def_id));
+        },
+    );
+    res?;
+
     debug!("visit_implementation_of_dispatch_from_dyn: {:?} -> {:?}", source, target);
 
     let param_env = tcx.param_env(impl_did);
@@ -242,26 +260,25 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
             if def_a != def_b {
                 let source_path = tcx.def_path_str(def_a.did());
                 let target_path = tcx.def_path_str(def_b.did());
-
-                return Err(tcx.dcx().emit_err(errors::DispatchFromDynCoercion {
+                return Err(tcx.dcx().emit_err(errors::CoerceSameStruct {
                     span,
-                    trait_name: "DispatchFromDyn",
+                    trait_name,
                     note: true,
                     source_path,
                     target_path,
                 }));
             }
 
-            let mut res = Ok(());
             if def_a.repr().c() || def_a.repr().packed() {
-                res = Err(tcx.dcx().emit_err(errors::DispatchFromDynRepr { span }));
+                return Err(tcx.dcx().emit_err(errors::DispatchFromDynRepr { span }));
             }
 
             let fields = &def_a.non_enum_variant().fields;
 
+            let mut res = Ok(());
             let coerced_fields = fields
-                .iter()
-                .filter(|field| {
+                .iter_enumerated()
+                .filter_map(|(i, field)| {
                     // Ignore PhantomData fields
                     let unnormalized_ty = tcx.type_of(field.did).instantiate_identity();
                     if tcx
@@ -272,7 +289,7 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
                         .unwrap_or(unnormalized_ty)
                         .is_phantom_data()
                     {
-                        return false;
+                        return None;
                     }
 
                     let ty_a = field.ty(tcx, args_a);
@@ -290,7 +307,7 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
                             && !ty_a.has_non_region_param()
                         {
                             // ignore 1-ZST fields
-                            return false;
+                            return None;
                         }
 
                         res = Err(tcx.dcx().emit_err(errors::DispatchFromDynZST {
@@ -299,64 +316,57 @@ fn visit_implementation_of_dispatch_from_dyn(checker: &Checker<'_>) -> Result<()
                             ty: ty_a,
                         }));
 
-                        return false;
+                        None
+                    } else {
+                        Some((i, ty_a, ty_b, tcx.def_span(field.did)))
                     }
-
-                    true
                 })
                 .collect::<Vec<_>>();
+            res?;
 
             if coerced_fields.is_empty() {
-                res = Err(tcx.dcx().emit_err(errors::DispatchFromDynSingle {
+                return Err(tcx.dcx().emit_err(errors::CoerceNoField {
                     span,
-                    trait_name: "DispatchFromDyn",
+                    trait_name,
                     note: true,
                 }));
-            } else if coerced_fields.len() > 1 {
-                res = Err(tcx.dcx().emit_err(errors::DispatchFromDynMulti {
-                    span,
-                    coercions_note: true,
-                    number: coerced_fields.len(),
-                    coercions: coerced_fields
-                        .iter()
-                        .map(|field| {
-                            format!(
-                                "`{}` (`{}` to `{}`)",
-                                field.name,
-                                field.ty(tcx, args_a),
-                                field.ty(tcx, args_b),
-                            )
-                        })
-                        .collect::<Vec<_>>()
-                        .join(", "),
-                }));
-            } else {
+            } else if let &[(_, ty_a, ty_b, field_span)] = &coerced_fields[..] {
                 let ocx = ObligationCtxt::new_with_diagnostics(&infcx);
-                for field in coerced_fields {
-                    ocx.register_obligation(Obligation::new(
-                        tcx,
-                        cause.clone(),
-                        param_env,
-                        ty::TraitRef::new(
-                            tcx,
-                            dispatch_from_dyn_trait,
-                            [field.ty(tcx, args_a), field.ty(tcx, args_b)],
-                        ),
-                    ));
-                }
+                ocx.register_obligation(Obligation::new(
+                    tcx,
+                    cause.clone(),
+                    param_env,
+                    ty::TraitRef::new(tcx, dispatch_from_dyn_trait, [ty_a, ty_b]),
+                ));
                 let errors = ocx.select_all_or_error();
                 if !errors.is_empty() {
-                    res = Err(infcx.err_ctxt().report_fulfillment_errors(errors));
+                    if is_from_coerce_pointee_derive(tcx, span) {
+                        return Err(tcx.dcx().emit_err(errors::CoerceFieldValidity {
+                            span,
+                            trait_name,
+                            ty: trait_ref.self_ty(),
+                            field_span,
+                            field_ty: ty_a,
+                        }));
+                    } else {
+                        return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
+                    }
                 }
 
                 // Finally, resolve all regions.
-                res = res.and(ocx.resolve_regions_and_report_errors(impl_did, param_env, []));
+                ocx.resolve_regions_and_report_errors(impl_did, param_env, [])?;
+
+                Ok(())
+            } else {
+                return Err(tcx.dcx().emit_err(errors::CoerceMulti {
+                    span,
+                    trait_name,
+                    number: coerced_fields.len(),
+                    fields: coerced_fields.iter().map(|(_, _, _, s)| *s).collect::<Vec<_>>().into(),
+                }));
             }
-            res
         }
-        _ => Err(tcx
-            .dcx()
-            .emit_err(errors::CoerceUnsizedMay { span, trait_name: "DispatchFromDyn" })),
+        _ => Err(tcx.dcx().emit_err(errors::CoerceUnsizedNonStruct { span, trait_name })),
     }
 }
 
@@ -366,13 +376,14 @@ pub(crate) fn coerce_unsized_info<'tcx>(
 ) -> Result<CoerceUnsizedInfo, ErrorGuaranteed> {
     debug!("compute_coerce_unsized_info(impl_did={:?})", impl_did);
     let span = tcx.def_span(impl_did);
+    let trait_name = "CoerceUnsized";
 
     let coerce_unsized_trait = tcx.require_lang_item(LangItem::CoerceUnsized, Some(span));
-
     let unsize_trait = tcx.require_lang_item(LangItem::Unsize, Some(span));
 
     let source = tcx.type_of(impl_did).instantiate_identity();
     let trait_ref = tcx.impl_trait_ref(impl_did).unwrap().instantiate_identity();
+
     assert_eq!(trait_ref.def_id, coerce_unsized_trait);
     let target = trait_ref.args.type_at(1);
     debug!("visit_implementation_of_coerce_unsized: {:?} -> {:?} (bound)", source, target);
@@ -399,9 +410,9 @@ pub(crate) fn coerce_unsized_info<'tcx>(
                 )
                 .emit();
         }
-        (mt_a.ty, mt_b.ty, unsize_trait, None)
+        (mt_a.ty, mt_b.ty, unsize_trait, None, span)
     };
-    let (source, target, trait_def_id, kind) = match (source.kind(), target.kind()) {
+    let (source, target, trait_def_id, kind, field_span) = match (source.kind(), target.kind()) {
         (&ty::Ref(r_a, ty_a, mutbl_a), &ty::Ref(r_b, ty_b, mutbl_b)) => {
             infcx.sub_regions(infer::RelateObjectBound(span), r_b, r_a);
             let mt_a = ty::TypeAndMut { ty: ty_a, mutbl: mutbl_a };
@@ -422,9 +433,9 @@ pub(crate) fn coerce_unsized_info<'tcx>(
             if def_a != def_b {
                 let source_path = tcx.def_path_str(def_a.did());
                 let target_path = tcx.def_path_str(def_b.did());
-                return Err(tcx.dcx().emit_err(errors::DispatchFromDynSame {
+                return Err(tcx.dcx().emit_err(errors::CoerceSameStruct {
                     span,
-                    trait_name: "CoerceUnsized",
+                    trait_name,
                     note: true,
                     source_path,
                     target_path,
@@ -504,14 +515,14 @@ pub(crate) fn coerce_unsized_info<'tcx>(
 
                     // Collect up all fields that were significantly changed
                     // i.e., those that contain T in coerce_unsized T -> U
-                    Some((i, a, b))
+                    Some((i, a, b, tcx.def_span(f.did)))
                 })
                 .collect::<Vec<_>>();
 
             if diff_fields.is_empty() {
-                return Err(tcx.dcx().emit_err(errors::CoerceUnsizedOneField {
+                return Err(tcx.dcx().emit_err(errors::CoerceNoField {
                     span,
-                    trait_name: "CoerceUnsized",
+                    trait_name,
                     note: true,
                 }));
             } else if diff_fields.len() > 1 {
@@ -522,27 +533,21 @@ pub(crate) fn coerce_unsized_info<'tcx>(
                     tcx.def_span(impl_did)
                 };
 
-                return Err(tcx.dcx().emit_err(errors::CoerceUnsizedMulti {
+                return Err(tcx.dcx().emit_err(errors::CoerceMulti {
                     span,
-                    coercions_note: true,
+                    trait_name,
                     number: diff_fields.len(),
-                    coercions: diff_fields
-                        .iter()
-                        .map(|&(i, a, b)| format!("`{}` (`{}` to `{}`)", fields[i].name, a, b))
-                        .collect::<Vec<_>>()
-                        .join(", "),
+                    fields: diff_fields.iter().map(|(_, _, _, s)| *s).collect::<Vec<_>>().into(),
                 }));
             }
 
-            let (i, a, b) = diff_fields[0];
+            let (i, a, b, field_span) = diff_fields[0];
             let kind = ty::adjustment::CustomCoerceUnsized::Struct(i);
-            (a, b, coerce_unsized_trait, Some(kind))
+            (a, b, coerce_unsized_trait, Some(kind), field_span)
         }
 
         _ => {
-            return Err(tcx
-                .dcx()
-                .emit_err(errors::DispatchFromDynStruct { span, trait_name: "CoerceUnsized" }));
+            return Err(tcx.dcx().emit_err(errors::CoerceUnsizedNonStruct { span, trait_name }));
         }
     };
 
@@ -557,12 +562,23 @@ pub(crate) fn coerce_unsized_info<'tcx>(
     );
     ocx.register_obligation(obligation);
     let errors = ocx.select_all_or_error();
+
     if !errors.is_empty() {
-        infcx.err_ctxt().report_fulfillment_errors(errors);
+        if is_from_coerce_pointee_derive(tcx, span) {
+            return Err(tcx.dcx().emit_err(errors::CoerceFieldValidity {
+                span,
+                trait_name,
+                ty: trait_ref.self_ty(),
+                field_span,
+                field_ty: source,
+            }));
+        } else {
+            return Err(infcx.err_ctxt().report_fulfillment_errors(errors));
+        }
     }
 
     // Finally, resolve all regions.
-    let _ = ocx.resolve_regions_and_report_errors(impl_did, param_env, []);
+    ocx.resolve_regions_and_report_errors(impl_did, param_env, [])?;
 
     Ok(CoerceUnsizedInfo { custom_kind: kind })
 }
diff --git a/compiler/rustc_hir_analysis/src/coherence/mod.rs b/compiler/rustc_hir_analysis/src/coherence/mod.rs
index 1bc60087ab5e..0245d4c9fe4b 100644
--- a/compiler/rustc_hir_analysis/src/coherence/mod.rs
+++ b/compiler/rustc_hir_analysis/src/coherence/mod.rs
@@ -199,11 +199,7 @@ fn check_object_overlap<'tcx>(
 
         for component_def_id in component_def_ids {
             if !tcx.is_dyn_compatible(component_def_id) {
-                // Without the 'dyn_compatible_for_dispatch' feature this is an error
-                // which will be reported by wfcheck. Ignore it here.
-                // This is tested by `coherence-impl-trait-for-trait-dyn-compatible.rs`.
-                // With the feature enabled, the trait is not implemented automatically,
-                // so this is valid.
+                // This is a WF error tested by `coherence-impl-trait-for-trait-dyn-compatible.rs`.
             } else {
                 let mut supertrait_def_ids = elaborate::supertrait_def_ids(tcx, component_def_id);
                 if supertrait_def_ids
diff --git a/compiler/rustc_hir_analysis/src/collect.rs b/compiler/rustc_hir_analysis/src/collect.rs
index dd91d70b004b..027aa5554a40 100644
--- a/compiler/rustc_hir_analysis/src/collect.rs
+++ b/compiler/rustc_hir_analysis/src/collect.rs
@@ -1074,7 +1074,6 @@ fn lower_variant<'tcx>(
         def.ctor().map(|(kind, _, def_id)| (kind, def_id.to_def_id())),
         discr,
         fields,
-        adt_kind,
         parent_did.to_def_id(),
         recovered,
         adt_kind == AdtKind::Struct && tcx.has_attr(parent_did, sym::non_exhaustive)
@@ -1202,7 +1201,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
         // and that they are all identifiers
         .and_then(|attr| match attr.meta_item_list() {
             Some(items) if items.len() < 2 => {
-                tcx.dcx().emit_err(errors::MustImplementOneOfAttribute { span: attr.span });
+                tcx.dcx().emit_err(errors::MustImplementOneOfAttribute { span: attr.span() });
 
                 None
             }
@@ -1214,7 +1213,7 @@ fn trait_def(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::TraitDef {
                     tcx.dcx().emit_err(errors::MustBeNameOfAssociatedFunction { span });
                 })
                 .ok()
-                .zip(Some(attr.span)),
+                .zip(Some(attr.span())),
             // Error is reported by `rustc_attr!`
             None => None,
         })
@@ -1823,6 +1822,9 @@ fn const_param_default<'tcx>(
         ),
     };
     let icx = ItemCtxt::new(tcx, def_id);
-    let ct = icx.lowerer().lower_const_arg(default_ct, FeedConstTy::Param(def_id.to_def_id()));
+    let identity_args = ty::GenericArgs::identity_for_item(tcx, def_id);
+    let ct = icx
+        .lowerer()
+        .lower_const_arg(default_ct, FeedConstTy::Param(def_id.to_def_id(), identity_args));
     ty::EarlyBinder::bind(ct)
 }
diff --git a/compiler/rustc_hir_analysis/src/collect/dump.rs b/compiler/rustc_hir_analysis/src/collect/dump.rs
index 63c445fa6a3d..4debd3977f50 100644
--- a/compiler/rustc_hir_analysis/src/collect/dump.rs
+++ b/compiler/rustc_hir_analysis/src/collect/dump.rs
@@ -111,14 +111,14 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                 let trait_ref = tcx.impl_trait_ref(def_id).unwrap().instantiate_identity();
                 if trait_ref.has_non_region_param() {
                     tcx.dcx().span_err(
-                        attr.span,
+                        attr.span(),
                         "`rustc_dump_vtable` must be applied to non-generic impl",
                     );
                     continue;
                 }
                 if !tcx.is_dyn_compatible(trait_ref.def_id) {
                     tcx.dcx().span_err(
-                        attr.span,
+                        attr.span(),
                         "`rustc_dump_vtable` must be applied to dyn-compatible trait",
                     );
                     continue;
@@ -127,7 +127,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                     .try_normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), trait_ref)
                 else {
                     tcx.dcx().span_err(
-                        attr.span,
+                        attr.span(),
                         "`rustc_dump_vtable` applied to impl header that cannot be normalized",
                     );
                     continue;
@@ -138,7 +138,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                 let ty = tcx.type_of(def_id).instantiate_identity();
                 if ty.has_non_region_param() {
                     tcx.dcx().span_err(
-                        attr.span,
+                        attr.span(),
                         "`rustc_dump_vtable` must be applied to non-generic type",
                     );
                     continue;
@@ -147,13 +147,14 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
                     tcx.try_normalize_erasing_regions(ty::TypingEnv::fully_monomorphized(), ty)
                 else {
                     tcx.dcx().span_err(
-                        attr.span,
+                        attr.span(),
                         "`rustc_dump_vtable` applied to type alias that cannot be normalized",
                     );
                     continue;
                 };
                 let ty::Dynamic(data, _, _) = *ty.kind() else {
-                    tcx.dcx().span_err(attr.span, "`rustc_dump_vtable` to type alias of dyn type");
+                    tcx.dcx()
+                        .span_err(attr.span(), "`rustc_dump_vtable` to type alias of dyn type");
                     continue;
                 };
                 if let Some(principal) = data.principal() {
@@ -166,7 +167,7 @@ pub(crate) fn vtables<'tcx>(tcx: TyCtxt<'tcx>) {
             }
             _ => {
                 tcx.dcx().span_err(
-                    attr.span,
+                    attr.span(),
                     "`rustc_dump_vtable` only applies to impl, or type alias of dyn type",
                 );
                 continue;
diff --git a/compiler/rustc_hir_analysis/src/collect/generics_of.rs b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
index 2cdd9a3a9348..af1338e50d00 100644
--- a/compiler/rustc_hir_analysis/src/collect/generics_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/generics_of.rs
@@ -186,17 +186,6 @@ pub(super) fn generics_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Generics {
                     {
                         Some(parent_did)
                     }
-                    // Exclude `GlobalAsm` here which cannot have generics.
-                    Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. })
-                        if asm.operands.iter().any(|(op, _op_sp)| match op {
-                            hir::InlineAsmOperand::Const { anon_const } => {
-                                anon_const.hir_id == hir_id
-                            }
-                            _ => false,
-                        }) =>
-                    {
-                        Some(parent_did)
-                    }
                     Node::TyPat(_) => Some(parent_did),
                     _ => None,
                 }
diff --git a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
index 5b511d270743..2022127a15b0 100644
--- a/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/predicates_of.rs
@@ -223,10 +223,7 @@ fn gather_explicit_predicates_of(tcx: TyCtxt<'_>, def_id: LocalDefId) -> ty::Gen
             }
             hir::GenericParamKind::Const { .. } => {
                 let param_def_id = param.def_id.to_def_id();
-                let ct_ty = tcx
-                    .type_of(param_def_id)
-                    .no_bound_vars()
-                    .expect("const parameters cannot be generic");
+                let ct_ty = tcx.type_of(param_def_id).instantiate_identity();
                 let ct = icx.lowerer().lower_const_param(param_def_id, param.hir_id);
                 predicates
                     .insert((ty::ClauseKind::ConstArgHasType(ct, ct_ty).upcast(tcx), param.span));
@@ -940,12 +937,6 @@ impl<'tcx> ItemCtxt<'tcx> {
     }
 }
 
-/// Compute the conditions that need to hold for a conditionally-const item to be const.
-/// That is, compute the set of `~const` where clauses for a given item.
-///
-/// This query also computes the `~const` where clauses for associated types, which are
-/// not "const", but which have item bounds which may be `~const`. These must hold for
-/// the `~const` item bound to hold.
 pub(super) fn const_conditions<'tcx>(
     tcx: TyCtxt<'tcx>,
     def_id: LocalDefId,
@@ -1063,7 +1054,9 @@ pub(super) fn explicit_implied_const_bounds<'tcx>(
     def_id: LocalDefId,
 ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::PolyTraitRef<'tcx>, Span)]> {
     if !tcx.is_conditionally_const(def_id) {
-        bug!("const_conditions invoked for item that is not conditionally const: {def_id:?}");
+        bug!(
+            "explicit_implied_const_bounds invoked for item that is not conditionally const: {def_id:?}"
+        );
     }
 
     let bounds = match tcx.opt_rpitit_info(def_id.to_def_id()) {
diff --git a/compiler/rustc_hir_analysis/src/collect/type_of.rs b/compiler/rustc_hir_analysis/src/collect/type_of.rs
index d564dc9699a8..6936544838c8 100644
--- a/compiler/rustc_hir_analysis/src/collect/type_of.rs
+++ b/compiler/rustc_hir_analysis/src/collect/type_of.rs
@@ -8,7 +8,7 @@ use rustc_middle::query::plumbing::CyclePlaceholder;
 use rustc_middle::ty::fold::fold_regions;
 use rustc_middle::ty::print::with_forced_trimmed_paths;
 use rustc_middle::ty::util::IntTypeExt;
-use rustc_middle::ty::{self, Article, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
+use rustc_middle::ty::{self, IsSuggestable, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_span::{DUMMY_SP, Ident, Span};
 
@@ -35,13 +35,6 @@ fn anon_const_type_of<'tcx>(icx: &ItemCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx
     let parent_node_id = tcx.parent_hir_id(hir_id);
     let parent_node = tcx.hir_node(parent_node_id);
 
-    let find_const = |&(op, op_sp)| match op {
-        hir::InlineAsmOperand::Const { anon_const } if anon_const.hir_id == hir_id => {
-            Some((anon_const, op_sp))
-        }
-        _ => None,
-    };
-
     match parent_node {
         // Anon consts "inside" the type system.
         Node::ConstArg(&ConstArg {
@@ -50,31 +43,6 @@ fn anon_const_type_of<'tcx>(icx: &ItemCtxt<'tcx>, def_id: LocalDefId) -> Ty<'tcx
             ..
         }) if anon_hir_id == hir_id => const_arg_anon_type_of(icx, arg_hir_id, span),
 
-        // Anon consts outside the type system.
-        Node::Expr(&Expr { kind: ExprKind::InlineAsm(asm), .. })
-        | Node::Item(&Item { kind: ItemKind::GlobalAsm { asm, .. }, .. })
-            if let Some((anon_const, op_sp)) = asm.operands.iter().find_map(find_const) =>
-        {
-            let ty = tcx.typeck(def_id).node_type(hir_id);
-
-            match ty.kind() {
-                ty::Error(_) => ty,
-                ty::Int(_) | ty::Uint(_) => ty,
-                _ => {
-                    let guar = tcx
-                        .dcx()
-                        .struct_span_err(op_sp, "invalid type for `const` operand")
-                        .with_span_label(
-                            tcx.def_span(anon_const.def_id),
-                            format!("is {} `{}`", ty.kind().article(), ty),
-                        )
-                        .with_help("`const` operands must be of an integer type")
-                        .emit();
-
-                    Ty::new_error(tcx, guar)
-                }
-            }
-        }
         Node::Variant(Variant { disr_expr: Some(e), .. }) if e.hir_id == hir_id => {
             tcx.adt_def(tcx.hir_get_parent_item(hir_id)).repr().discr_type().to_ty(tcx)
         }
diff --git a/compiler/rustc_hir_analysis/src/errors.rs b/compiler/rustc_hir_analysis/src/errors.rs
index 1a0b0edb2570..852533ff5c95 100644
--- a/compiler/rustc_hir_analysis/src/errors.rs
+++ b/compiler/rustc_hir_analysis/src/errors.rs
@@ -908,6 +908,10 @@ pub(crate) enum ImplNotMarkedDefault {
     },
 }
 
+#[derive(LintDiagnostic)]
+#[diag(hir_analysis_useless_impl_item)]
+pub(crate) struct UselessImplItem;
+
 #[derive(Diagnostic)]
 #[diag(hir_analysis_missing_trait_item, code = E0046)]
 pub(crate) struct MissingTraitItem {
@@ -1164,18 +1168,6 @@ pub(crate) struct InherentTyOutside {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(hir_analysis_coerce_unsized_may, code = E0378)]
-pub(crate) struct DispatchFromDynCoercion<'a> {
-    #[primary_span]
-    pub span: Span,
-    pub trait_name: &'a str,
-    #[note(hir_analysis_coercion_between_struct_same_note)]
-    pub note: bool,
-    pub source_path: String,
-    pub target_path: String,
-}
-
 #[derive(Diagnostic)]
 #[diag(hir_analysis_dispatch_from_dyn_repr, code = E0378)]
 pub(crate) struct DispatchFromDynRepr {
@@ -1293,41 +1285,40 @@ pub(crate) struct DispatchFromDynZST<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_coerce_unsized_may, code = E0378)]
-pub(crate) struct DispatchFromDynSingle<'a> {
+#[diag(hir_analysis_coerce_zero, code = E0374)]
+pub(crate) struct CoerceNoField {
     #[primary_span]
     pub span: Span,
-    pub trait_name: &'a str,
+    pub trait_name: &'static str,
     #[note(hir_analysis_coercion_between_struct_single_note)]
     pub note: bool,
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_dispatch_from_dyn_multi, code = E0378)]
-#[note]
-pub(crate) struct DispatchFromDynMulti {
+#[diag(hir_analysis_coerce_multi, code = E0375)]
+pub(crate) struct CoerceMulti {
+    pub trait_name: &'static str,
     #[primary_span]
     pub span: Span,
-    #[note(hir_analysis_coercions_note)]
-    pub coercions_note: bool,
     pub number: usize,
-    pub coercions: String,
-}
-
-#[derive(Diagnostic)]
-#[diag(hir_analysis_coerce_unsized_may, code = E0376)]
-pub(crate) struct DispatchFromDynStruct<'a> {
-    #[primary_span]
-    pub span: Span,
-    pub trait_name: &'a str,
+    #[note]
+    pub fields: MultiSpan,
 }
 
 #[derive(Diagnostic)]
 #[diag(hir_analysis_coerce_unsized_may, code = E0377)]
-pub(crate) struct DispatchFromDynSame<'a> {
+pub(crate) struct CoerceUnsizedNonStruct {
     #[primary_span]
     pub span: Span,
-    pub trait_name: &'a str,
+    pub trait_name: &'static str,
+}
+
+#[derive(Diagnostic)]
+#[diag(hir_analysis_coerce_unsized_may, code = E0377)]
+pub(crate) struct CoerceSameStruct {
+    #[primary_span]
+    pub span: Span,
+    pub trait_name: &'static str,
     #[note(hir_analysis_coercion_between_struct_same_note)]
     pub note: bool,
     pub source_path: String,
@@ -1335,34 +1326,15 @@ pub(crate) struct DispatchFromDynSame<'a> {
 }
 
 #[derive(Diagnostic)]
-#[diag(hir_analysis_coerce_unsized_may, code = E0374)]
-pub(crate) struct CoerceUnsizedOneField<'a> {
+#[diag(hir_analysis_coerce_unsized_field_validity)]
+pub(crate) struct CoerceFieldValidity<'tcx> {
     #[primary_span]
     pub span: Span,
-    pub trait_name: &'a str,
-    #[note(hir_analysis_coercion_between_struct_single_note)]
-    pub note: bool,
-}
-
-#[derive(Diagnostic)]
-#[diag(hir_analysis_coerce_unsized_multi, code = E0375)]
-#[note]
-pub(crate) struct CoerceUnsizedMulti {
-    #[primary_span]
+    pub ty: Ty<'tcx>,
+    pub trait_name: &'static str,
     #[label]
-    pub span: Span,
-    #[note(hir_analysis_coercions_note)]
-    pub coercions_note: bool,
-    pub number: usize,
-    pub coercions: String,
-}
-
-#[derive(Diagnostic)]
-#[diag(hir_analysis_coerce_unsized_may, code = E0378)]
-pub(crate) struct CoerceUnsizedMay<'a> {
-    #[primary_span]
-    pub span: Span,
-    pub trait_name: &'a str,
+    pub field_span: Span,
+    pub field_ty: Ty<'tcx>,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
index d644a1f224c7..922578792ba8 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/errors.rs
@@ -789,7 +789,11 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
                 Some(args.constraints.iter().filter_map(|constraint| {
                     let ident = constraint.ident;
-                    let trait_def = path.res.def_id();
+
+                    let Res::Def(DefKind::Trait, trait_def) = path.res else {
+                        return None;
+                    };
+
                     let assoc_item = tcx.associated_items(trait_def).find_by_name_and_kind(
                         tcx,
                         ident,
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
index 8d58a3bfbd3c..fa58f12c553c 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/generics.rs
@@ -273,7 +273,7 @@ pub fn lower_generic_args<'tcx: 'a, 'a>(
 
                             // We lower to an infer even when the feature gate is not enabled
                             // as it is useful for diagnostics to be able to see a `ConstKind::Infer`
-                            args.push(ctx.provided_kind(param, arg));
+                            args.push(ctx.provided_kind(&args, param, arg));
                             args_iter.next();
                             params.next();
                         }
diff --git a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
index 750770178eef..a0f848f07c4b 100644
--- a/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
+++ b/compiler/rustc_hir_analysis/src/hir_ty_lowering/mod.rs
@@ -232,12 +232,15 @@ impl AssocItemQSelf {
 /// Use this enum with `<dyn HirTyLowerer>::lower_const_arg` to instruct it with the
 /// desired behavior.
 #[derive(Debug, Clone, Copy)]
-pub enum FeedConstTy {
+pub enum FeedConstTy<'a, 'tcx> {
     /// Feed the type.
     ///
     /// The `DefId` belongs to the const param that we are supplying
     /// this (anon) const arg to.
-    Param(DefId),
+    ///
+    /// The list of generic args is used to instantiate the parameters
+    /// used by the type of the const param specified by `DefId`.
+    Param(DefId, &'a [ty::GenericArg<'tcx>]),
     /// Don't feed the type.
     No,
 }
@@ -298,6 +301,7 @@ pub trait GenericArgsLowerer<'a, 'tcx> {
 
     fn provided_kind(
         &mut self,
+        preceding_args: &[ty::GenericArg<'tcx>],
         param: &ty::GenericParamDef,
         arg: &GenericArg<'tcx>,
     ) -> ty::GenericArg<'tcx>;
@@ -481,6 +485,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
 
             fn provided_kind(
                 &mut self,
+                preceding_args: &[ty::GenericArg<'tcx>],
                 param: &ty::GenericParamDef,
                 arg: &GenericArg<'tcx>,
             ) -> ty::GenericArg<'tcx> {
@@ -526,7 +531,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                     (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => self
                         .lowerer
                         // Ambig portions of `ConstArg` are handled in the match arm below
-                        .lower_const_arg(ct.as_unambig_ct(), FeedConstTy::Param(param.def_id))
+                        .lower_const_arg(
+                            ct.as_unambig_ct(),
+                            FeedConstTy::Param(param.def_id, preceding_args),
+                        )
                         .into(),
                     (&GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
                         self.lowerer.ct_infer(Some(param), inf.span).into()
@@ -582,8 +590,7 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
                         let ty = tcx
                             .at(self.span)
                             .type_of(param.def_id)
-                            .no_bound_vars()
-                            .expect("const parameter types cannot be generic");
+                            .instantiate(tcx, preceding_args);
                         if let Err(guar) = ty.error_reported() {
                             return ty::Const::new_error(tcx, guar).into();
                         }
@@ -2107,14 +2114,50 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
     pub fn lower_const_arg(
         &self,
         const_arg: &hir::ConstArg<'tcx>,
-        feed: FeedConstTy,
+        feed: FeedConstTy<'_, 'tcx>,
     ) -> Const<'tcx> {
         let tcx = self.tcx();
 
-        if let FeedConstTy::Param(param_def_id) = feed
+        if let FeedConstTy::Param(param_def_id, args) = feed
             && let hir::ConstArgKind::Anon(anon) = &const_arg.kind
         {
-            tcx.feed_anon_const_type(anon.def_id, tcx.type_of(param_def_id));
+            let anon_const_type = tcx.type_of(param_def_id).instantiate(tcx, args);
+
+            // We must error if the instantiated type has any inference variables as we will
+            // use this type to feed the `type_of` and query results must not contain inference
+            // variables otherwise we will ICE.
+            //
+            // We also error if the type contains any regions as effectively any region will wind
+            // up as a region variable in mir borrowck. It would also be somewhat concerning if
+            // hir typeck was using equality but mir borrowck wound up using subtyping as that could
+            // result in a non-infer in hir typeck but a region variable in borrowck.
+            //
+            // FIXME(generic_const_parameter_types): Ideally we remove these errors one day when
+            // we have the ability to intermix typeck of anon const const args with the parent
+            // bodies typeck.
+            if tcx.features().generic_const_parameter_types()
+                && (anon_const_type.has_free_regions() || anon_const_type.has_erased_regions())
+            {
+                let e = tcx.dcx().span_err(
+                    const_arg.span(),
+                    "anonymous constants with lifetimes in their type are not yet supported",
+                );
+                tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
+                return ty::Const::new_error(tcx, e);
+            }
+            if anon_const_type.has_non_region_infer() {
+                let e = tcx.dcx().span_err(
+                    const_arg.span(),
+                    "anonymous constants with inferred types are not yet supported",
+                );
+                tcx.feed_anon_const_type(anon.def_id, ty::EarlyBinder::bind(Ty::new_error(tcx, e)));
+                return ty::Const::new_error(tcx, e);
+            }
+
+            tcx.feed_anon_const_type(
+                anon.def_id,
+                ty::EarlyBinder::bind(tcx.type_of(param_def_id).instantiate(tcx, args)),
+            );
         }
 
         let hir_id = const_arg.hir_id;
@@ -2230,10 +2273,10 @@ impl<'tcx> dyn HirTyLowerer<'tcx> + '_ {
         let expr = &tcx.hir_body(anon.body).value;
         debug!(?expr);
 
-        let ty = tcx
-            .type_of(anon.def_id)
-            .no_bound_vars()
-            .expect("const parameter types cannot be generic");
+        // FIXME(generic_const_parameter_types): We should use the proper generic args
+        // here. It's only used as a hint for literals so doesn't matter too much to use the right
+        // generic arguments, just weaker type inference.
+        let ty = tcx.type_of(anon.def_id).instantiate_identity();
 
         match self.try_lower_anon_const_lit(ty, expr) {
             Some(v) => v,
diff --git a/compiler/rustc_hir_analysis/src/lib.rs b/compiler/rustc_hir_analysis/src/lib.rs
index bdfbd540e40a..cf18bab950ae 100644
--- a/compiler/rustc_hir_analysis/src/lib.rs
+++ b/compiler/rustc_hir_analysis/src/lib.rs
@@ -260,7 +260,7 @@ pub fn lower_ty<'tcx>(tcx: TyCtxt<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
 pub fn lower_const_arg_for_rustdoc<'tcx>(
     tcx: TyCtxt<'tcx>,
     hir_ct: &hir::ConstArg<'tcx>,
-    feed: FeedConstTy,
+    feed: FeedConstTy<'_, 'tcx>,
 ) -> Const<'tcx> {
     let env_def_id = tcx.hir_get_parent_item(hir_ct.hir_id);
     collect::ItemCtxt::new(tcx, env_def_id.def_id).lowerer().lower_const_arg(hir_ct, feed)
diff --git a/compiler/rustc_hir_analysis/src/variance/mod.rs b/compiler/rustc_hir_analysis/src/variance/mod.rs
index a7760326bb4c..0800d99e9452 100644
--- a/compiler/rustc_hir_analysis/src/variance/mod.rs
+++ b/compiler/rustc_hir_analysis/src/variance/mod.rs
@@ -198,6 +198,10 @@ fn variance_of_opaque(
             ty::ClauseKind::Trait(ty::TraitPredicate {
                 trait_ref: ty::TraitRef { def_id: _, args, .. },
                 polarity: _,
+            })
+            | ty::ClauseKind::HostEffect(ty::HostEffectPredicate {
+                trait_ref: ty::TraitRef { def_id: _, args, .. },
+                constness: _,
             }) => {
                 for arg in &args[1..] {
                     arg.visit_with(&mut collector);
diff --git a/compiler/rustc_hir_pretty/Cargo.toml b/compiler/rustc_hir_pretty/Cargo.toml
index f5d7dbd3f96e..86989d1e55b4 100644
--- a/compiler/rustc_hir_pretty/Cargo.toml
+++ b/compiler/rustc_hir_pretty/Cargo.toml
@@ -8,6 +8,7 @@ edition = "2024"
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
 rustc_ast_pretty = { path = "../rustc_ast_pretty" }
+rustc_attr_parsing = { path = "../rustc_attr_parsing" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_span = { path = "../rustc_span" }
 # tidy-alphabetical-end
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index 167bed5f6502..e06398cf3c41 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -10,12 +10,13 @@ use std::cell::Cell;
 use std::vec;
 
 use rustc_abi::ExternAbi;
-use rustc_ast::util::parser::{self, AssocOp, ExprPrecedence, Fixity};
-use rustc_ast::{DUMMY_NODE_ID, DelimArgs};
+use rustc_ast::util::parser::{self, ExprPrecedence, Fixity};
+use rustc_ast::{AttrStyle, DUMMY_NODE_ID, DelimArgs};
 use rustc_ast_pretty::pp::Breaks::{Consistent, Inconsistent};
 use rustc_ast_pretty::pp::{self, Breaks};
 use rustc_ast_pretty::pprust::state::MacHeader;
 use rustc_ast_pretty::pprust::{Comments, PrintState};
+use rustc_attr_parsing::{AttributeKind, PrintAttribute};
 use rustc_hir::{
     BindingMode, ByRef, ConstArgKind, GenericArg, GenericBound, GenericParam, GenericParamKind,
     HirId, ImplicitSelfKind, LifetimeParamKind, Node, PatKind, PreciseCapturingArg, RangeEnd, Term,
@@ -80,65 +81,48 @@ impl<'a> State<'a> {
         (self.attrs)(id)
     }
 
-    fn print_inner_attributes(&mut self, attrs: &[hir::Attribute]) -> bool {
-        self.print_either_attributes(attrs, ast::AttrStyle::Inner, false, true)
+    fn print_attrs_as_inner(&mut self, attrs: &[hir::Attribute]) {
+        self.print_either_attributes(attrs, ast::AttrStyle::Inner)
     }
 
-    fn print_outer_attributes(&mut self, attrs: &[hir::Attribute]) -> bool {
-        self.print_either_attributes(attrs, ast::AttrStyle::Outer, false, true)
+    fn print_attrs_as_outer(&mut self, attrs: &[hir::Attribute]) {
+        self.print_either_attributes(attrs, ast::AttrStyle::Outer)
     }
 
-    fn print_either_attributes(
-        &mut self,
-        attrs: &[hir::Attribute],
-        kind: ast::AttrStyle,
-        is_inline: bool,
-        trailing_hardbreak: bool,
-    ) -> bool {
-        let mut printed = false;
+    fn print_either_attributes(&mut self, attrs: &[hir::Attribute], style: ast::AttrStyle) {
+        if attrs.is_empty() {
+            return;
+        }
+
         for attr in attrs {
-            if attr.style == kind {
-                self.print_attribute_inline(attr, is_inline);
-                if is_inline {
-                    self.nbsp();
-                }
-                printed = true;
-            }
+            self.print_attribute_inline(attr, style);
         }
-        if printed && trailing_hardbreak && !is_inline {
-            self.hardbreak_if_not_bol();
-        }
-        printed
+        self.hardbreak_if_not_bol();
     }
 
-    fn print_attribute_inline(&mut self, attr: &hir::Attribute, is_inline: bool) {
-        if !is_inline {
-            self.hardbreak_if_not_bol();
-        }
-        self.maybe_print_comment(attr.span.lo());
-        match &attr.kind {
-            hir::AttrKind::Normal(normal) => {
-                match attr.style {
+    fn print_attribute_inline(&mut self, attr: &hir::Attribute, style: AttrStyle) {
+        match &attr {
+            hir::Attribute::Unparsed(unparsed) => {
+                self.maybe_print_comment(unparsed.span.lo());
+                match style {
                     ast::AttrStyle::Inner => self.word("#!["),
                     ast::AttrStyle::Outer => self.word("#["),
                 }
-                if normal.unsafety == hir::Safety::Unsafe {
-                    self.word("unsafe(");
-                }
-                self.print_attr_item(&normal, attr.span);
-                if normal.unsafety == hir::Safety::Unsafe {
-                    self.word(")");
-                }
+                self.print_attr_item(&unparsed, unparsed.span);
                 self.word("]");
             }
-            hir::AttrKind::DocComment(comment_kind, data) => {
+            hir::Attribute::Parsed(AttributeKind::DocComment { style, kind, comment, .. }) => {
                 self.word(rustc_ast_pretty::pprust::state::doc_comment_to_string(
-                    *comment_kind,
-                    attr.style,
-                    *data,
+                    *kind, *style, *comment,
                 ));
                 self.hardbreak()
             }
+            hir::Attribute::Parsed(pa) => {
+                self.word("#[attr=\"");
+                pa.print_attribute(self);
+                self.word("\")]");
+                self.hardbreak()
+            }
         }
     }
 
@@ -162,7 +146,7 @@ impl<'a> State<'a> {
                     false,
                     None,
                     *delim,
-                    tokens,
+                    &tokens,
                     true,
                     span,
                 ),
@@ -307,7 +291,7 @@ where
 }
 
 pub fn attribute_to_string(ann: &dyn PpAnn, attr: &hir::Attribute) -> String {
-    to_string(ann, |s| s.print_attribute_inline(attr, false))
+    to_string(ann, |s| s.print_attribute_inline(attr, AttrStyle::Outer))
 }
 
 pub fn ty_to_string(ann: &dyn PpAnn, ty: &hir::Ty<'_>) -> String {
@@ -370,7 +354,7 @@ impl<'a> State<'a> {
     }
 
     fn print_mod(&mut self, _mod: &hir::Mod<'_>, attrs: &[hir::Attribute]) {
-        self.print_inner_attributes(attrs);
+        self.print_attrs_as_inner(attrs);
         for &item_id in _mod.item_ids {
             self.ann.nested(self, Nested::Item(item_id));
         }
@@ -487,7 +471,7 @@ impl<'a> State<'a> {
     fn print_foreign_item(&mut self, item: &hir::ForeignItem<'_>) {
         self.hardbreak_if_not_bol();
         self.maybe_print_comment(item.span.lo());
-        self.print_outer_attributes(self.attrs(item.hir_id()));
+        self.print_attrs_as_outer(self.attrs(item.hir_id()));
         match item.kind {
             hir::ForeignItemKind::Fn(sig, arg_names, generics) => {
                 self.head("");
@@ -591,7 +575,7 @@ impl<'a> State<'a> {
         self.hardbreak_if_not_bol();
         self.maybe_print_comment(item.span.lo());
         let attrs = self.attrs(item.hir_id());
-        self.print_outer_attributes(attrs);
+        self.print_attrs_as_outer(attrs);
         self.ann.pre(self, AnnNode::Item(item));
         match item.kind {
             hir::ItemKind::ExternCrate(orig_name) => {
@@ -687,7 +671,7 @@ impl<'a> State<'a> {
                 self.head("extern");
                 self.word_nbsp(abi.to_string());
                 self.bopen();
-                self.print_inner_attributes(self.attrs(item.hir_id()));
+                self.print_attrs_as_inner(self.attrs(item.hir_id()));
                 for item in items {
                     self.ann.nested(self, Nested::ForeignItem(item.id));
                 }
@@ -755,7 +739,7 @@ impl<'a> State<'a> {
 
                 self.space();
                 self.bopen();
-                self.print_inner_attributes(attrs);
+                self.print_attrs_as_inner(attrs);
                 for impl_item in items {
                     self.ann.nested(self, Nested::ImplItem(impl_item.id));
                 }
@@ -847,7 +831,7 @@ impl<'a> State<'a> {
         for v in variants {
             self.space_if_not_bol();
             self.maybe_print_comment(v.span.lo());
-            self.print_outer_attributes(self.attrs(v.hir_id));
+            self.print_attrs_as_outer(self.attrs(v.hir_id));
             self.ibox(INDENT_UNIT);
             self.print_variant(v);
             self.word(",");
@@ -880,7 +864,7 @@ impl<'a> State<'a> {
                     self.popen();
                     self.commasep(Inconsistent, struct_def.fields(), |s, field| {
                         s.maybe_print_comment(field.span.lo());
-                        s.print_outer_attributes(s.attrs(field.hir_id));
+                        s.print_attrs_as_outer(s.attrs(field.hir_id));
                         s.print_type(field.ty);
                     });
                     self.pclose();
@@ -907,7 +891,7 @@ impl<'a> State<'a> {
         for field in fields {
             self.hardbreak_if_not_bol();
             self.maybe_print_comment(field.span.lo());
-            self.print_outer_attributes(self.attrs(field.hir_id));
+            self.print_attrs_as_outer(self.attrs(field.hir_id));
             self.print_ident(field.ident);
             self.word_nbsp(":");
             self.print_type(field.ty);
@@ -943,7 +927,7 @@ impl<'a> State<'a> {
         self.ann.pre(self, AnnNode::SubItem(ti.hir_id()));
         self.hardbreak_if_not_bol();
         self.maybe_print_comment(ti.span.lo());
-        self.print_outer_attributes(self.attrs(ti.hir_id()));
+        self.print_attrs_as_outer(self.attrs(ti.hir_id()));
         match ti.kind {
             hir::TraitItemKind::Const(ty, default) => {
                 self.print_associated_const(ti.ident, ti.generics, ty, default);
@@ -971,7 +955,7 @@ impl<'a> State<'a> {
         self.ann.pre(self, AnnNode::SubItem(ii.hir_id()));
         self.hardbreak_if_not_bol();
         self.maybe_print_comment(ii.span.lo());
-        self.print_outer_attributes(self.attrs(ii.hir_id()));
+        self.print_attrs_as_outer(self.attrs(ii.hir_id()));
 
         match ii.kind {
             hir::ImplItemKind::Const(ty, expr) => {
@@ -1074,7 +1058,7 @@ impl<'a> State<'a> {
         self.ann.pre(self, AnnNode::Block(blk));
         self.bopen();
 
-        self.print_inner_attributes(attrs);
+        self.print_attrs_as_inner(attrs);
 
         for st in blk.stmts {
             self.print_stmt(st);
@@ -1264,7 +1248,7 @@ impl<'a> State<'a> {
             self.space();
         }
         self.cbox(INDENT_UNIT);
-        self.print_outer_attributes(self.attrs(field.hir_id));
+        self.print_attrs_as_outer(self.attrs(field.hir_id));
         if !field.is_shorthand {
             self.print_ident(field.ident);
             self.word_space(":");
@@ -1312,12 +1296,11 @@ impl<'a> State<'a> {
     }
 
     fn print_expr_binary(&mut self, op: hir::BinOp, lhs: &hir::Expr<'_>, rhs: &hir::Expr<'_>) {
-        let assoc_op = AssocOp::from_ast_binop(op.node);
-        let binop_prec = assoc_op.precedence();
+        let binop_prec = op.node.precedence();
         let left_prec = lhs.precedence();
         let right_prec = rhs.precedence();
 
-        let (mut left_needs_paren, right_needs_paren) = match assoc_op.fixity() {
+        let (mut left_needs_paren, right_needs_paren) = match op.node.fixity() {
             Fixity::Left => (left_prec < binop_prec, right_prec <= binop_prec),
             Fixity::Right => (left_prec <= binop_prec, right_prec < binop_prec),
             Fixity::None => (left_prec <= binop_prec, right_prec <= binop_prec),
@@ -1430,7 +1413,8 @@ impl<'a> State<'a> {
                 hir::InlineAsmOperand::Const { ref anon_const } => {
                     s.word("const");
                     s.space();
-                    s.print_anon_const(anon_const);
+                    // Not using `print_inline_const` to avoid additional `const { ... }`
+                    s.ann.nested(s, Nested::Body(anon_const.body))
                 }
                 hir::InlineAsmOperand::SymFn { ref expr } => {
                     s.word("sym_fn");
@@ -1461,7 +1445,7 @@ impl<'a> State<'a> {
 
     fn print_expr(&mut self, expr: &hir::Expr<'_>) {
         self.maybe_print_comment(expr.span.lo());
-        self.print_outer_attributes(self.attrs(expr.hir_id));
+        self.print_attrs_as_outer(self.attrs(expr.hir_id));
         self.ibox(INDENT_UNIT);
         self.ann.pre(self, AnnNode::Expr(expr));
         match expr.kind {
@@ -1677,8 +1661,8 @@ impl<'a> State<'a> {
             }
             hir::ExprKind::UnsafeBinderCast(kind, expr, ty) => {
                 match kind {
-                    hir::UnsafeBinderCastKind::Wrap => self.word("wrap_binder!("),
-                    hir::UnsafeBinderCastKind::Unwrap => self.word("unwrap_binder!("),
+                    ast::UnsafeBinderCastKind::Wrap => self.word("wrap_binder!("),
+                    ast::UnsafeBinderCastKind::Unwrap => self.word("unwrap_binder!("),
                 }
                 self.print_expr(expr);
                 if let Some(ty) = ty {
@@ -2073,7 +2057,7 @@ impl<'a> State<'a> {
             self.space();
         }
         self.cbox(INDENT_UNIT);
-        self.print_outer_attributes(self.attrs(field.hir_id));
+        self.print_attrs_as_outer(self.attrs(field.hir_id));
         if !field.is_shorthand {
             self.print_ident(field.ident);
             self.word_nbsp(":");
@@ -2083,7 +2067,7 @@ impl<'a> State<'a> {
     }
 
     fn print_param(&mut self, arg: &hir::Param<'_>) {
-        self.print_outer_attributes(self.attrs(arg.hir_id));
+        self.print_attrs_as_outer(self.attrs(arg.hir_id));
         self.print_pat(arg.pat);
     }
 
@@ -2118,7 +2102,7 @@ impl<'a> State<'a> {
         self.cbox(INDENT_UNIT);
         self.ann.pre(self, AnnNode::Arm(arm));
         self.ibox(0);
-        self.print_outer_attributes(self.attrs(arm.hir_id));
+        self.print_attrs_as_outer(self.attrs(arm.hir_id));
         self.print_pat(arm.pat);
         self.space();
         if let Some(ref g) = arm.guard {
diff --git a/compiler/rustc_hir_typeck/messages.ftl b/compiler/rustc_hir_typeck/messages.ftl
index a994b31aeb43..ed80bc3e7be7 100644
--- a/compiler/rustc_hir_typeck/messages.ftl
+++ b/compiler/rustc_hir_typeck/messages.ftl
@@ -10,6 +10,7 @@ hir_typeck_address_of_temporary_taken = cannot take address of a temporary
 hir_typeck_arg_mismatch_indeterminate = argument type mismatch was detected, but rustc had trouble determining where
     .note = we would appreciate a bug report: https://github.com/rust-lang/rust/issues/new
 
+hir_typeck_as_deref_suggestion = consider using `as_deref` here
 hir_typeck_base_expression_double_dot = base expression required after `..`
 hir_typeck_base_expression_double_dot_add_expr = add a base expression here
 hir_typeck_base_expression_double_dot_enable_default_field_values =
@@ -27,6 +28,9 @@ hir_typeck_cannot_cast_to_bool = cannot cast `{$expr_ty}` as `bool`
     .help = compare with zero instead
     .label = unsupported cast
 
+hir_typeck_cant_dereference = type `{$ty}` cannot be dereferenced
+hir_typeck_cant_dereference_label = can't be dereferenced
+
 hir_typeck_cast_enum_drop = cannot cast enum `{$expr_ty}` into integer `{$cast_ty}` because it implements `Drop`
 
 hir_typeck_cast_thin_pointer_to_wide_pointer = cannot cast thin pointer `{$expr_ty}` to wide pointer `{$cast_ty}`
@@ -72,6 +76,9 @@ hir_typeck_dependency_on_unit_never_type_fallback = this function depends on nev
 
 hir_typeck_deref_is_empty = this expression `Deref`s to `{$deref_ty}` which implements `is_empty`
 
+hir_typeck_expected_array_or_slice = expected an array or slice, found `{$ty}`
+hir_typeck_expected_array_or_slice_label = pattern cannot match with input type `{$ty}`
+
 hir_typeck_expected_default_return_type = expected `()` because of default return type
 
 hir_typeck_expected_return_type = expected `{$expected}` because of return type
@@ -112,7 +119,11 @@ hir_typeck_int_to_fat = cannot cast `{$expr_ty}` to a pointer that {$known_wide
 hir_typeck_int_to_fat_label = creating a `{$cast_ty}` requires both an address and {$metadata}
 hir_typeck_int_to_fat_label_nightly = consider casting this expression to `*const ()`, then using `core::ptr::from_raw_parts`
 
-hir_typeck_invalid_callee = expected function, found {$ty}
+hir_typeck_invalid_callee = expected function, found {$found}
+hir_typeck_invalid_defined = `{$path}` defined here
+hir_typeck_invalid_defined_kind = {$kind} `{$path}` defined here
+hir_typeck_invalid_fn_defined = `{$func}` defined here returns `{$ty}`
+hir_typeck_invalid_local = `{$local_name}` has type `{$ty}`
 
 hir_typeck_lossy_provenance_int2ptr =
     strict provenance disallows casting integer `{$expr_ty}` to pointer `{$cast_ty}`
@@ -142,6 +153,12 @@ hir_typeck_no_associated_item = no {$item_kind} named `{$item_name}` found for {
     *[other] {" "}in the current scope
 }
 
+hir_typeck_no_field_on_type = no field `{$field}` on type `{$ty}`
+
+hir_typeck_no_field_on_variant = no field named `{$field}` on enum variant `{$container}::{$ident}`
+hir_typeck_no_field_on_variant_enum = this enum variant...
+hir_typeck_no_field_on_variant_field = ...does not have this field
+
 hir_typeck_note_caller_chooses_ty_for_ty_param = the caller chooses a type for `{$ty_param_name}` which can be different from `{$found_ty}`
 
 hir_typeck_note_edition_guide = for more on editions, read https://doc.rust-lang.org/edition-guide
@@ -183,6 +200,8 @@ hir_typeck_self_ctor_from_outer_item = can't reference `Self` constructor from o
     .label = the inner item doesn't inherit generics from this impl, so `Self` is invalid to reference
     .suggestion = replace `Self` with the actual type
 
+hir_typeck_slicing_suggestion = consider slicing here
+
 hir_typeck_struct_expr_non_exhaustive =
     cannot create non-exhaustive {$what} using struct expression
 
diff --git a/compiler/rustc_hir_typeck/src/callee.rs b/compiler/rustc_hir_typeck/src/callee.rs
index d18869b6d90c..5e00161f693f 100644
--- a/compiler/rustc_hir_typeck/src/callee.rs
+++ b/compiler/rustc_hir_typeck/src/callee.rs
@@ -23,7 +23,7 @@ use tracing::{debug, instrument};
 use super::method::MethodCallee;
 use super::method::probe::ProbeScope;
 use super::{Expectation, FnCtxt, TupleArgumentsFlag};
-use crate::errors;
+use crate::{errors, fluent_generated};
 
 /// Checks that it is legal to call methods of the trait corresponding
 /// to `trait_id` (this only cares about the trait, not the specific
@@ -674,13 +674,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
 
         let callee_ty = self.resolve_vars_if_possible(callee_ty);
+        let mut path = None;
         let mut err = self.dcx().create_err(errors::InvalidCallee {
             span: callee_expr.span,
-            ty: match &unit_variant {
+            ty: callee_ty,
+            found: match &unit_variant {
                 Some((_, kind, path)) => format!("{kind} `{path}`"),
-                None => format!("`{callee_ty}`"),
+                None => format!("`{}`", self.tcx.short_string(callee_ty, &mut path)),
             },
         });
+        *err.long_ty_path() = path;
         if callee_ty.references_error() {
             err.downgrade_to_delayed_bug();
         }
@@ -780,27 +783,33 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         if let Some(span) = self.tcx.hir().res_span(def) {
             let callee_ty = callee_ty.to_string();
             let label = match (unit_variant, inner_callee_path) {
-                (Some((_, kind, path)), _) => Some(format!("{kind} `{path}` defined here")),
-                (_, Some(hir::QPath::Resolved(_, path))) => self
-                    .tcx
-                    .sess
-                    .source_map()
-                    .span_to_snippet(path.span)
-                    .ok()
-                    .map(|p| format!("`{p}` defined here returns `{callee_ty}`")),
+                (Some((_, kind, path)), _) => {
+                    err.arg("kind", kind);
+                    err.arg("path", path);
+                    Some(fluent_generated::hir_typeck_invalid_defined_kind)
+                }
+                (_, Some(hir::QPath::Resolved(_, path))) => {
+                    self.tcx.sess.source_map().span_to_snippet(path.span).ok().map(|p| {
+                        err.arg("func", p);
+                        fluent_generated::hir_typeck_invalid_fn_defined
+                    })
+                }
                 _ => {
                     match def {
                         // Emit a different diagnostic for local variables, as they are not
                         // type definitions themselves, but rather variables *of* that type.
-                        Res::Local(hir_id) => Some(format!(
-                            "`{}` has type `{}`",
-                            self.tcx.hir().name(hir_id),
-                            callee_ty
-                        )),
-                        Res::Def(kind, def_id) if kind.ns() == Some(Namespace::ValueNS) => {
-                            Some(format!("`{}` defined here", self.tcx.def_path_str(def_id),))
+                        Res::Local(hir_id) => {
+                            err.arg("local_name", self.tcx.hir().name(hir_id));
+                            Some(fluent_generated::hir_typeck_invalid_local)
+                        }
+                        Res::Def(kind, def_id) if kind.ns() == Some(Namespace::ValueNS) => {
+                            err.arg("path", self.tcx.def_path_str(def_id));
+                            Some(fluent_generated::hir_typeck_invalid_defined)
+                        }
+                        _ => {
+                            err.arg("path", callee_ty);
+                            Some(fluent_generated::hir_typeck_invalid_defined)
                         }
-                        _ => Some(format!("`{callee_ty}` defined here")),
                     }
                 }
             };
diff --git a/compiler/rustc_hir_typeck/src/cast.rs b/compiler/rustc_hir_typeck/src/cast.rs
index f5f6ada12c3c..ea4ec345ad0c 100644
--- a/compiler/rustc_hir_typeck/src/cast.rs
+++ b/compiler/rustc_hir_typeck/src/cast.rs
@@ -548,17 +548,19 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                 err.emit();
             }
             CastError::SizedUnsizedCast => {
+                let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
+                let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
                 fcx.dcx().emit_err(errors::CastThinPointerToWidePointer {
                     span: self.span,
-                    expr_ty: self.expr_ty,
-                    cast_ty: fcx.ty_to_string(self.cast_ty),
+                    expr_ty,
+                    cast_ty,
                     teach: fcx.tcx.sess.teach(E0607),
                 });
             }
             CastError::IntToWideCast(known_metadata) => {
                 let expr_if_nightly = fcx.tcx.sess.is_nightly_build().then_some(self.expr_span);
                 let cast_ty = fcx.resolve_vars_if_possible(self.cast_ty);
-                let expr_ty = fcx.ty_to_string(self.expr_ty);
+                let expr_ty = fcx.resolve_vars_if_possible(self.expr_ty);
                 let metadata = known_metadata.unwrap_or("type-specific metadata");
                 let known_wide = known_metadata.is_some();
                 let span = self.cast_span;
@@ -893,20 +895,22 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                         // e.g. we want to allow `dyn T -> (dyn T,)`, etc.
                         //
                         // We also need to skip auto traits to emit an FCW and not an error.
-                        let src_obj = tcx.mk_ty_from_kind(ty::Dynamic(
+                        let src_obj = Ty::new_dynamic(
+                            tcx,
                             tcx.mk_poly_existential_predicates(
                                 &src_tty.without_auto_traits().collect::<Vec<_>>(),
                             ),
                             tcx.lifetimes.re_erased,
                             ty::Dyn,
-                        ));
-                        let dst_obj = tcx.mk_ty_from_kind(ty::Dynamic(
+                        );
+                        let dst_obj = Ty::new_dynamic(
+                            tcx,
                             tcx.mk_poly_existential_predicates(
                                 &dst_tty.without_auto_traits().collect::<Vec<_>>(),
                             ),
                             tcx.lifetimes.re_erased,
                             ty::Dyn,
-                        ));
+                        );
 
                         // `dyn Src = dyn Dst`, this checks for matching traits/generics/projections
                         // This is `fcx.demand_eqtype`, but inlined to give a better error.
@@ -1164,10 +1168,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
             if let Some((deref_ty, _)) = derefed {
                 // Give a note about what the expr derefs to.
                 if deref_ty != self.expr_ty.peel_refs() {
-                    err.subdiagnostic(errors::DerefImplsIsEmpty {
-                        span: self.expr_span,
-                        deref_ty: fcx.ty_to_string(deref_ty),
-                    });
+                    err.subdiagnostic(errors::DerefImplsIsEmpty { span: self.expr_span, deref_ty });
                 }
 
                 // Create a multipart suggestion: add `!` and `.is_empty()` in
@@ -1175,7 +1176,7 @@ impl<'a, 'tcx> CastCheck<'tcx> {
                 err.subdiagnostic(errors::UseIsEmpty {
                     lo: self.expr_span.shrink_to_lo(),
                     hi: self.span.with_lo(self.expr_span.hi()),
-                    expr_ty: fcx.ty_to_string(self.expr_ty),
+                    expr_ty: self.expr_ty,
                 });
             }
         }
diff --git a/compiler/rustc_hir_typeck/src/errors.rs b/compiler/rustc_hir_typeck/src/errors.rs
index 1bf8aa4f78d4..20688a5b949d 100644
--- a/compiler/rustc_hir_typeck/src/errors.rs
+++ b/compiler/rustc_hir_typeck/src/errors.rs
@@ -91,7 +91,7 @@ pub(crate) enum ReturnLikeStatementKind {
 }
 
 impl IntoDiagArg for ReturnLikeStatementKind {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         let kind = match self {
             Self::Return => "return",
             Self::Become => "become",
@@ -454,12 +454,83 @@ impl HelpUseLatestEdition {
     }
 }
 
+#[derive(Diagnostic)]
+#[diag(hir_typeck_no_field_on_type, code = E0609)]
+pub(crate) struct NoFieldOnType<'tcx> {
+    #[primary_span]
+    pub(crate) span: Span,
+    pub(crate) ty: Ty<'tcx>,
+    pub(crate) field: Ident,
+}
+
+#[derive(Diagnostic)]
+#[diag(hir_typeck_no_field_on_variant, code = E0609)]
+pub(crate) struct NoFieldOnVariant<'tcx> {
+    #[primary_span]
+    pub(crate) span: Span,
+    pub(crate) container: Ty<'tcx>,
+    pub(crate) ident: Ident,
+    pub(crate) field: Ident,
+    #[label(hir_typeck_no_field_on_variant_enum)]
+    pub(crate) enum_span: Span,
+    #[label(hir_typeck_no_field_on_variant_field)]
+    pub(crate) field_span: Span,
+}
+
+#[derive(Diagnostic)]
+#[diag(hir_typeck_cant_dereference, code = E0614)]
+pub(crate) struct CantDereference<'tcx> {
+    #[primary_span]
+    #[label(hir_typeck_cant_dereference_label)]
+    pub(crate) span: Span,
+    pub(crate) ty: Ty<'tcx>,
+}
+
+#[derive(Diagnostic)]
+#[diag(hir_typeck_expected_array_or_slice, code = E0529)]
+pub(crate) struct ExpectedArrayOrSlice<'tcx> {
+    #[primary_span]
+    #[label(hir_typeck_expected_array_or_slice_label)]
+    pub(crate) span: Span,
+    pub(crate) ty: Ty<'tcx>,
+    pub(crate) slice_pat_semantics: bool,
+    #[subdiagnostic]
+    pub(crate) as_deref: Option<AsDerefSuggestion>,
+    #[subdiagnostic]
+    pub(crate) slicing: Option<SlicingSuggestion>,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(
+    hir_typeck_as_deref_suggestion,
+    code = ".as_deref()",
+    style = "verbose",
+    applicability = "maybe-incorrect"
+)]
+pub(crate) struct AsDerefSuggestion {
+    #[primary_span]
+    pub(crate) span: Span,
+}
+
+#[derive(Subdiagnostic)]
+#[suggestion(
+    hir_typeck_slicing_suggestion,
+    code = "[..]",
+    style = "verbose",
+    applicability = "maybe-incorrect"
+)]
+pub(crate) struct SlicingSuggestion {
+    #[primary_span]
+    pub(crate) span: Span,
+}
+
 #[derive(Diagnostic)]
 #[diag(hir_typeck_invalid_callee, code = E0618)]
-pub(crate) struct InvalidCallee {
+pub(crate) struct InvalidCallee<'tcx> {
     #[primary_span]
     pub span: Span,
-    pub ty: String,
+    pub ty: Ty<'tcx>,
+    pub found: String,
 }
 
 #[derive(Diagnostic)]
@@ -469,7 +540,7 @@ pub(crate) struct IntToWide<'tcx> {
     #[label(hir_typeck_int_to_fat_label)]
     pub span: Span,
     pub metadata: &'tcx str,
-    pub expr_ty: String,
+    pub expr_ty: Ty<'tcx>,
     pub cast_ty: Ty<'tcx>,
     #[label(hir_typeck_int_to_fat_label_nightly)]
     pub expr_if_nightly: Option<Span>,
@@ -581,12 +652,12 @@ pub(crate) struct UnionPatDotDot {
     applicability = "maybe-incorrect",
     style = "verbose"
 )]
-pub(crate) struct UseIsEmpty {
+pub(crate) struct UseIsEmpty<'tcx> {
     #[suggestion_part(code = "!")]
     pub lo: Span,
     #[suggestion_part(code = ".is_empty()")]
     pub hi: Span,
-    pub expr_ty: String,
+    pub expr_ty: Ty<'tcx>,
 }
 
 #[derive(Diagnostic)]
@@ -745,10 +816,10 @@ pub(crate) struct CtorIsPrivate {
 
 #[derive(Subdiagnostic)]
 #[note(hir_typeck_deref_is_empty)]
-pub(crate) struct DerefImplsIsEmpty {
+pub(crate) struct DerefImplsIsEmpty<'tcx> {
     #[primary_span]
     pub span: Span,
-    pub deref_ty: String,
+    pub deref_ty: Ty<'tcx>,
 }
 
 #[derive(Subdiagnostic)]
@@ -826,7 +897,7 @@ pub(crate) struct CastThinPointerToWidePointer<'tcx> {
     #[primary_span]
     pub span: Span,
     pub expr_ty: Ty<'tcx>,
-    pub cast_ty: String,
+    pub cast_ty: Ty<'tcx>,
     #[note(hir_typeck_teach_help)]
     pub(crate) teach: bool,
 }
diff --git a/compiler/rustc_hir_typeck/src/expr.rs b/compiler/rustc_hir_typeck/src/expr.rs
index 0c71ef4655c5..dec1779d92ca 100644
--- a/compiler/rustc_hir_typeck/src/expr.rs
+++ b/compiler/rustc_hir_typeck/src/expr.rs
@@ -45,9 +45,10 @@ use crate::coercion::{CoerceMany, DynamicCoerceMany};
 use crate::errors::{
     AddressOfTemporaryTaken, BaseExpressionDoubleDot, BaseExpressionDoubleDotAddExpr,
     BaseExpressionDoubleDotEnableDefaultFieldValues, BaseExpressionDoubleDotRemove,
-    FieldMultiplySpecifiedInInitializer, FunctionalRecordUpdateOnNonStruct, HelpUseLatestEdition,
-    ReturnLikeStatementKind, ReturnStmtOutsideOfFnBody, StructExprNonExhaustive,
-    TypeMismatchFruTypo, YieldExprOutsideOfCoroutine,
+    CantDereference, FieldMultiplySpecifiedInInitializer, FunctionalRecordUpdateOnNonStruct,
+    HelpUseLatestEdition, NoFieldOnType, NoFieldOnVariant, ReturnLikeStatementKind,
+    ReturnStmtOutsideOfFnBody, StructExprNonExhaustive, TypeMismatchFruTypo,
+    YieldExprOutsideOfCoroutine,
 };
 use crate::{
     BreakableCtxt, CoroutineTypes, Diverges, FnCtxt, Needs, cast, fatally_break_rust,
@@ -607,13 +608,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     if let Some(ty) = self.lookup_derefing(expr, oprnd, oprnd_t) {
                         oprnd_t = ty;
                     } else {
-                        let mut err = type_error_struct!(
-                            self.dcx(),
-                            expr.span,
-                            oprnd_t,
-                            E0614,
-                            "type `{oprnd_t}` cannot be dereferenced",
-                        );
+                        let mut err =
+                            self.dcx().create_err(CantDereference { span: expr.span, ty: oprnd_t });
                         let sp = tcx.sess.source_map().start_point(expr.span).with_parent(None);
                         if let Some(sp) =
                             tcx.sess.psess.ambiguous_block_expr_parse.borrow().get(&sp)
@@ -1656,13 +1652,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     fn check_expr_unsafe_binder_cast(
         &self,
         span: Span,
-        kind: hir::UnsafeBinderCastKind,
+        kind: ast::UnsafeBinderCastKind,
         inner_expr: &'tcx hir::Expr<'tcx>,
         hir_ty: Option<&'tcx hir::Ty<'tcx>>,
         expected: Expectation<'tcx>,
     ) -> Ty<'tcx> {
         match kind {
-            hir::UnsafeBinderCastKind::Wrap => {
+            ast::UnsafeBinderCastKind::Wrap => {
                 let ascribed_ty =
                     hir_ty.map(|hir_ty| self.lower_ty_saving_user_provided_ty(hir_ty));
                 let expected_ty = expected.only_has_type(self);
@@ -1706,7 +1702,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
                 binder_ty
             }
-            hir::UnsafeBinderCastKind::Unwrap => {
+            ast::UnsafeBinderCastKind::Unwrap => {
                 let ascribed_ty =
                     hir_ty.map(|hir_ty| self.lower_ty_saving_user_provided_ty(hir_ty));
                 let hint_ty = ascribed_ty.unwrap_or_else(|| self.next_ty_var(inner_expr.span));
@@ -1857,12 +1853,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             return Ty::new_error(tcx, guar);
         }
 
+        // We defer checking whether the element type is `Copy` as it is possible to have
+        // an inference variable as a repeat count and it seems unlikely that `Copy` would
+        // have inference side effects required for type checking to succeed.
+        if tcx.features().generic_arg_infer() {
+            self.deferred_repeat_expr_checks.borrow_mut().push((element, element_ty, count));
         // If the length is 0, we don't create any elements, so we don't copy any.
         // If the length is 1, we don't copy that one element, we move it. Only check
         // for `Copy` if the length is larger, or unevaluated.
-        // FIXME(min_const_generic_exprs): We could perhaps defer this check so that
-        // we don't require `<?0t as Tr>::CONST` doesn't unnecessarily require `Copy`.
-        if count.try_to_target_usize(tcx).is_none_or(|x| x > 1) {
+        } else if count.try_to_target_usize(self.tcx).is_none_or(|x| x > 1) {
             self.enforce_repeat_element_needs_copy_bound(element, element_ty);
         }
 
@@ -1872,7 +1871,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     }
 
     /// Requires that `element_ty` is `Copy` (unless it's a const expression itself).
-    fn enforce_repeat_element_needs_copy_bound(
+    pub(super) fn enforce_repeat_element_needs_copy_bound(
         &self,
         element: &hir::Expr<'_>,
         element_ty: Ty<'tcx>,
@@ -3287,13 +3286,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let span = field.span;
         debug!("no_such_field_err(span: {:?}, field: {:?}, expr_t: {:?})", span, field, expr_t);
 
-        let mut err = type_error_struct!(
-            self.dcx(),
-            span,
-            expr_t,
-            E0609,
-            "no field `{field}` on type `{expr_t}`",
-        );
+        let mut err = self.dcx().create_err(NoFieldOnType { span, ty: expr_t, field });
+        if expr_t.references_error() {
+            err.downgrade_to_delayed_bug();
+        }
 
         // try to add a suggestion in case the field is a nested field of a field of the Adt
         let mod_id = self.tcx.parent_module(id).to_def_id();
@@ -3778,13 +3774,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         self.check_expr_asm_operand(out_expr, false);
                     }
                 }
+                hir::InlineAsmOperand::Const { ref anon_const } => {
+                    self.check_expr_const_block(anon_const, Expectation::NoExpectation);
+                }
                 hir::InlineAsmOperand::SymFn { expr } => {
                     self.check_expr(expr);
                 }
-                // `AnonConst`s have their own body and is type-checked separately.
-                // As they don't flow into the type system we don't need them to
-                // be well-formed.
-                hir::InlineAsmOperand::Const { .. } => {}
                 hir::InlineAsmOperand::SymStatic { .. } => {}
                 hir::InlineAsmOperand::Label { block } => {
                     let previous_diverges = self.diverges.get();
@@ -3867,16 +3862,16 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         .iter_enumerated()
                         .find(|(_, f)| f.ident(self.tcx).normalize_to_macros_2_0() == subident)
                     else {
-                        type_error_struct!(
-                            self.dcx(),
-                            ident.span,
-                            container,
-                            E0609,
-                            "no field named `{subfield}` on enum variant `{container}::{ident}`",
-                        )
-                        .with_span_label(field.span, "this enum variant...")
-                        .with_span_label(subident.span, "...does not have this field")
-                        .emit();
+                        self.dcx()
+                            .create_err(NoFieldOnVariant {
+                                span: ident.span,
+                                container,
+                                ident,
+                                field: subfield,
+                                enum_span: field.span,
+                                field_span: subident.span,
+                            })
+                            .emit_unless(container.references_error());
                         break;
                     };
 
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index 9b85b2aeec6e..c0617119d67c 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -895,48 +895,44 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
             match pat.kind {
                 PatKind::Binding(_, canonical_id, ..) => {
                     debug!("walk_pat: binding place={:?} pat={:?}", place, pat);
-                    if let Some(bm) = self
+                    let bm = self
                         .cx
                         .typeck_results()
-                        .extract_binding_mode(tcx.sess, pat.hir_id, pat.span)
-                    {
-                        debug!("walk_pat: pat.hir_id={:?} bm={:?}", pat.hir_id, bm);
+                        .extract_binding_mode(tcx.sess, pat.hir_id, pat.span);
+                    debug!("walk_pat: pat.hir_id={:?} bm={:?}", pat.hir_id, bm);
 
-                        // pat_ty: the type of the binding being produced.
-                        let pat_ty = self.node_ty(pat.hir_id)?;
-                        debug!("walk_pat: pat_ty={:?}", pat_ty);
+                    // pat_ty: the type of the binding being produced.
+                    let pat_ty = self.node_ty(pat.hir_id)?;
+                    debug!("walk_pat: pat_ty={:?}", pat_ty);
 
-                        let def = Res::Local(canonical_id);
-                        if let Ok(ref binding_place) =
-                            self.cat_res(pat.hir_id, pat.span, pat_ty, def)
-                        {
-                            self.delegate.borrow_mut().bind(binding_place, binding_place.hir_id);
+                    let def = Res::Local(canonical_id);
+                    if let Ok(ref binding_place) = self.cat_res(pat.hir_id, pat.span, pat_ty, def) {
+                        self.delegate.borrow_mut().bind(binding_place, binding_place.hir_id);
+                    }
+
+                    // Subtle: MIR desugaring introduces immutable borrows for each pattern
+                    // binding when lowering pattern guards to ensure that the guard does not
+                    // modify the scrutinee.
+                    if has_guard {
+                        self.delegate.borrow_mut().borrow(
+                            place,
+                            discr_place.hir_id,
+                            BorrowKind::Immutable,
+                        );
+                    }
+
+                    // It is also a borrow or copy/move of the value being matched.
+                    // In a cases of pattern like `let pat = upvar`, don't use the span
+                    // of the pattern, as this just looks confusing, instead use the span
+                    // of the discriminant.
+                    match bm.0 {
+                        hir::ByRef::Yes(m) => {
+                            let bk = ty::BorrowKind::from_mutbl(m);
+                            self.delegate.borrow_mut().borrow(place, discr_place.hir_id, bk);
                         }
-
-                        // Subtle: MIR desugaring introduces immutable borrows for each pattern
-                        // binding when lowering pattern guards to ensure that the guard does not
-                        // modify the scrutinee.
-                        if has_guard {
-                            self.delegate.borrow_mut().borrow(
-                                place,
-                                discr_place.hir_id,
-                                BorrowKind::Immutable,
-                            );
-                        }
-
-                        // It is also a borrow or copy/move of the value being matched.
-                        // In a cases of pattern like `let pat = upvar`, don't use the span
-                        // of the pattern, as this just looks confusing, instead use the span
-                        // of the discriminant.
-                        match bm.0 {
-                            hir::ByRef::Yes(m) => {
-                                let bk = ty::BorrowKind::from_mutbl(m);
-                                self.delegate.borrow_mut().borrow(place, discr_place.hir_id, bk);
-                            }
-                            hir::ByRef::No => {
-                                debug!("walk_pat binding consuming pat");
-                                self.consume_or_copy(place, discr_place.hir_id);
-                            }
+                        hir::ByRef::No => {
+                            debug!("walk_pat binding consuming pat");
+                            self.consume_or_copy(place, discr_place.hir_id);
                         }
                     }
                 }
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 2d7d80e39bc3..054e3bcb67c3 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -85,25 +85,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         })
     }
 
-    /// Resolves type and const variables in `ty` if possible. Unlike the infcx
+    /// Resolves type and const variables in `t` if possible. Unlike the infcx
     /// version (resolve_vars_if_possible), this version will
     /// also select obligations if it seems useful, in an effort
     /// to get more type information.
     // FIXME(-Znext-solver): A lot of the calls to this method should
     // probably be `try_structurally_resolve_type` or `structurally_resolve_type` instead.
     #[instrument(skip(self), level = "debug", ret)]
-    pub(crate) fn resolve_vars_with_obligations(&self, mut ty: Ty<'tcx>) -> Ty<'tcx> {
+    pub(crate) fn resolve_vars_with_obligations<T: TypeFoldable<TyCtxt<'tcx>>>(
+        &self,
+        mut t: T,
+    ) -> T {
         // No Infer()? Nothing needs doing.
-        if !ty.has_non_region_infer() {
+        if !t.has_non_region_infer() {
             debug!("no inference var, nothing needs doing");
-            return ty;
+            return t;
         }
 
-        // If `ty` is a type variable, see whether we already know what it is.
-        ty = self.resolve_vars_if_possible(ty);
-        if !ty.has_non_region_infer() {
-            debug!(?ty);
-            return ty;
+        // If `t` is a type variable, see whether we already know what it is.
+        t = self.resolve_vars_if_possible(t);
+        if !t.has_non_region_infer() {
+            debug!(?t);
+            return t;
         }
 
         // If not, try resolving pending obligations as much as
@@ -111,7 +114,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // indirect dependencies that don't seem worth tracking
         // precisely.
         self.select_obligations_where_possible(|_| {});
-        self.resolve_vars_if_possible(ty)
+        self.resolve_vars_if_possible(t)
     }
 
     pub(crate) fn record_deferred_call_resolution(
@@ -519,7 +522,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     pub(crate) fn lower_const_arg(
         &self,
         const_arg: &'tcx hir::ConstArg<'tcx>,
-        feed: FeedConstTy,
+        feed: FeedConstTy<'_, 'tcx>,
     ) -> ty::Const<'tcx> {
         let ct = self.lowerer().lower_const_arg(const_arg, feed);
         self.register_wf_obligation(
@@ -1135,7 +1138,18 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             .last()
             .is_some_and(|GenericPathSegment(def_id, _)| tcx.generics_of(*def_id).has_self);
 
-        let (res, self_ctor_args) = if let Res::SelfCtor(impl_def_id) = res {
+        let (res, implicit_args) = if let Res::Def(DefKind::ConstParam, def) = res {
+            // types of const parameters are somewhat special as they are part of
+            // the same environment as the const parameter itself. this means that
+            // unlike most paths `type-of(N)` can return a type naming parameters
+            // introduced by the containing item, rather than provided through `N`.
+            //
+            // for example given `<T, const M: usize, const N: [T; M]>` and some
+            // `let a = N;` expression. The path to `N` would wind up with no args
+            // (as it has no args), but instantiating the early binder on `typeof(N)`
+            // requires providing generic arguments for `[T, M, N]`.
+            (res, Some(ty::GenericArgs::identity_for_item(tcx, tcx.parent(def))))
+        } else if let Res::SelfCtor(impl_def_id) = res {
             let ty = LoweredTy::from_raw(
                 self,
                 span,
@@ -1261,6 +1275,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
             fn provided_kind(
                 &mut self,
+                preceding_args: &[ty::GenericArg<'tcx>],
                 param: &ty::GenericParamDef,
                 arg: &GenericArg<'tcx>,
             ) -> ty::GenericArg<'tcx> {
@@ -1280,7 +1295,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => self
                         .fcx
                         // Ambiguous parts of `ConstArg` are handled in the match arms below
-                        .lower_const_arg(ct.as_unambig_ct(), FeedConstTy::Param(param.def_id))
+                        .lower_const_arg(
+                            ct.as_unambig_ct(),
+                            FeedConstTy::Param(param.def_id, preceding_args),
+                        )
                         .into(),
                     (&GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
                         self.fcx.ct_infer(Some(param), inf.span).into()
@@ -1320,7 +1338,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         }
 
-        let args_raw = self_ctor_args.unwrap_or_else(|| {
+        let args_raw = implicit_args.unwrap_or_else(|| {
             lower_generic_args(
                 self,
                 def_id,
@@ -1454,7 +1472,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         sp: Span,
         ct: ty::Const<'tcx>,
     ) -> ty::Const<'tcx> {
-        // FIXME(min_const_generic_exprs): We could process obligations here if `ct` is a var.
+        let ct = self.resolve_vars_with_obligations(ct);
 
         if self.next_trait_solver()
             && let ty::ConstKind::Unevaluated(..) = ct.kind()
@@ -1510,6 +1528,32 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    pub(crate) fn structurally_resolve_const(
+        &self,
+        sp: Span,
+        ct: ty::Const<'tcx>,
+    ) -> ty::Const<'tcx> {
+        let ct = self.try_structurally_resolve_const(sp, ct);
+
+        if !ct.is_ct_infer() {
+            ct
+        } else {
+            let e = self.tainted_by_errors().unwrap_or_else(|| {
+                self.err_ctxt()
+                    .emit_inference_failure_err(
+                        self.body_id,
+                        sp,
+                        ct.into(),
+                        TypeAnnotationNeeded::E0282,
+                        true,
+                    )
+                    .emit()
+            });
+            // FIXME: Infer `?ct = {const error}`?
+            ty::Const::new_error(self.tcx, e)
+        }
+    }
+
     pub(crate) fn with_breakable_ctxt<F: FnOnce() -> R, R>(
         &self,
         id: HirId,
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
index 358bc389bd13..f6298adf2ebb 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/arg_matrix.rs
@@ -22,6 +22,12 @@ impl ExpectedIdx {
     }
 }
 
+impl ProvidedIdx {
+    pub(crate) fn to_expected_idx(self) -> ExpectedIdx {
+        ExpectedIdx::from_u32(self.as_u32())
+    }
+}
+
 // An issue that might be found in the compatibility matrix
 #[derive(Debug)]
 enum Issue {
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
index 120a43576e81..e60a4bb47b57 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/checks.rs
@@ -110,7 +110,40 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     self.tcx.erase_regions(ty)
                 }
             };
-            InlineAsmCtxt::new(self.tcx, enclosing_id, expr_ty).check_asm(asm);
+            let node_ty = |hir_id: HirId| self.typeck_results.borrow().node_type(hir_id);
+            InlineAsmCtxt::new(
+                self.tcx,
+                enclosing_id,
+                self.typing_env(self.param_env),
+                expr_ty,
+                node_ty,
+            )
+            .check_asm(asm);
+        }
+    }
+
+    pub(in super::super) fn check_repeat_exprs(&self) {
+        let mut deferred_repeat_expr_checks = self.deferred_repeat_expr_checks.borrow_mut();
+        debug!("FnCtxt::check_repeat_exprs: {} deferred checks", deferred_repeat_expr_checks.len());
+        for (element, element_ty, count) in deferred_repeat_expr_checks.drain(..) {
+            // We want to emit an error if the const is not structurally resolveable as otherwise
+            // we can find up conservatively proving `Copy` which may infer the repeat expr count
+            // to something that never required `Copy` in the first place.
+            let count =
+                self.structurally_resolve_const(element.span, self.normalize(element.span, count));
+
+            // Avoid run on "`NotCopy: Copy` is not implemented" errors when the repeat expr count
+            // is erroneous/unknown. The user might wind up specifying a repeat count of 0/1.
+            if count.references_error() {
+                continue;
+            }
+
+            // If the length is 0, we don't create any elements, so we don't copy any.
+            // If the length is 1, we don't copy that one element, we move it. Only check
+            // for `Copy` if the length is larger.
+            if count.try_to_target_usize(self.tcx).is_none_or(|x| x > 1) {
+                self.enforce_repeat_element_needs_copy_bound(element, element_ty);
+            }
         }
     }
 
@@ -775,7 +808,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // First, check if we just need to wrap some arguments in a tuple.
         if let Some((mismatch_idx, terr)) =
-            compatibility_diagonal.iter().enumerate().find_map(|(i, c)| {
+            compatibility_diagonal.iter_enumerated().find_map(|(i, c)| {
                 if let Compatibility::Incompatible(Some(terr)) = c {
                     Some((i, *terr))
                 } else {
@@ -787,24 +820,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Do we have as many extra provided arguments as the tuple's length?
             // If so, we might have just forgotten to wrap some args in a tuple.
             if let Some(ty::Tuple(tys)) =
-                formal_and_expected_inputs.get(mismatch_idx.into()).map(|tys| tys.1.kind())
+                formal_and_expected_inputs.get(mismatch_idx.to_expected_idx()).map(|tys| tys.1.kind())
                 // If the tuple is unit, we're not actually wrapping any arguments.
                 && !tys.is_empty()
                 && provided_arg_tys.len() == formal_and_expected_inputs.len() - 1 + tys.len()
             {
                 // Wrap up the N provided arguments starting at this position in a tuple.
-                let provided_as_tuple = Ty::new_tup_from_iter(
-                    tcx,
-                    provided_arg_tys.iter().map(|(ty, _)| *ty).skip(mismatch_idx).take(tys.len()),
-                );
+                let provided_args_to_tuple = &provided_arg_tys[mismatch_idx..];
+                let (provided_args_to_tuple, provided_args_after_tuple) =
+                    provided_args_to_tuple.split_at(tys.len());
+                let provided_as_tuple =
+                    Ty::new_tup_from_iter(tcx, provided_args_to_tuple.iter().map(|&(ty, _)| ty));
 
                 let mut satisfied = true;
                 // Check if the newly wrapped tuple + rest of the arguments are compatible.
                 for ((_, expected_ty), provided_ty) in std::iter::zip(
-                    formal_and_expected_inputs.iter().skip(mismatch_idx),
-                    [provided_as_tuple].into_iter().chain(
-                        provided_arg_tys.iter().map(|(ty, _)| *ty).skip(mismatch_idx + tys.len()),
-                    ),
+                    formal_and_expected_inputs[mismatch_idx.to_expected_idx()..].iter(),
+                    [provided_as_tuple]
+                        .into_iter()
+                        .chain(provided_args_after_tuple.iter().map(|&(ty, _)| ty)),
                 ) {
                     if !self.may_coerce(provided_ty, *expected_ty) {
                         satisfied = false;
@@ -816,10 +850,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Take some care with spans, so we don't suggest wrapping a macro's
                 // innards in parenthesis, for example.
                 if satisfied
-                    && let Some((_, lo)) =
-                        provided_arg_tys.get(ProvidedIdx::from_usize(mismatch_idx))
-                    && let Some((_, hi)) =
-                        provided_arg_tys.get(ProvidedIdx::from_usize(mismatch_idx + tys.len() - 1))
+                    && let &[(_, hi @ lo)] | &[(_, lo), .., (_, hi)] = provided_args_to_tuple
                 {
                     let mut err;
                     if tys.len() == 1 {
@@ -827,9 +858,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         // so don't do anything special here.
                         err = self.err_ctxt().report_and_explain_type_error(
                             mk_trace(
-                                *lo,
-                                formal_and_expected_inputs[mismatch_idx.into()],
-                                provided_arg_tys[mismatch_idx.into()].0,
+                                lo,
+                                formal_and_expected_inputs[mismatch_idx.to_expected_idx()],
+                                provided_arg_tys[mismatch_idx].0,
                             ),
                             self.param_env,
                             terr,
@@ -868,7 +899,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         callee_ty,
                         call_expr,
                         None,
-                        Some(mismatch_idx),
+                        Some(mismatch_idx.as_usize()),
                         &matched_inputs,
                         &formal_and_expected_inputs,
                         is_method,
@@ -2615,7 +2646,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
 
                 let expected_display_type = self
-                    .resolve_vars_if_possible(formal_and_expected_inputs[idx.into()].1)
+                    .resolve_vars_if_possible(formal_and_expected_inputs[idx].1)
                     .sort_string(self.tcx);
                 let label = if idxs_matched == params_with_generics.len() - 1 {
                     format!(
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
index f9fc12159363..35a3491f7c08 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/suggestions.rs
@@ -23,7 +23,7 @@ use rustc_middle::ty::{
 };
 use rustc_session::errors::ExprParenthesesNeeded;
 use rustc_span::source_map::Spanned;
-use rustc_span::{Ident, Span, Symbol, sym};
+use rustc_span::{ExpnKind, Ident, MacroKind, Span, Symbol, sym};
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt;
 use rustc_trait_selection::error_reporting::traits::DefIdOrName;
 use rustc_trait_selection::infer::InferCtxtExt;
@@ -1365,6 +1365,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 self.param_env,
                 ty::TraitRef::new(self.tcx, into_def_id, [expr_ty, expected_ty]),
             ))
+            && !expr
+                .span
+                .macro_backtrace()
+                .any(|x| matches!(x.kind, ExpnKind::Macro(MacroKind::Attr | MacroKind::Derive, ..)))
         {
             let span = expr.span.find_oldest_ancestor_in_same_ctxt();
 
@@ -1380,10 +1384,10 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 sugg.insert(0, (expr.span.shrink_to_lo(), format!("{}: ", name)));
             }
             diag.multipart_suggestion(
-                format!("call `Into::into` on this expression to convert `{expr_ty}` into `{expected_ty}`"),
-                sugg,
-                Applicability::MaybeIncorrect
-            );
+                    format!("call `Into::into` on this expression to convert `{expr_ty}` into `{expected_ty}`"),
+                    sugg,
+                    Applicability::MaybeIncorrect
+                );
             return true;
         }
 
diff --git a/compiler/rustc_hir_typeck/src/lib.rs b/compiler/rustc_hir_typeck/src/lib.rs
index 0130ad775d9e..8b9c2b4a6ca0 100644
--- a/compiler/rustc_hir_typeck/src/lib.rs
+++ b/compiler/rustc_hir_typeck/src/lib.rs
@@ -199,6 +199,15 @@ fn typeck_with_inspect<'tcx>(
         fcx.write_ty(id, expected_type);
     };
 
+    // Whether to check repeat exprs before/after inference fallback is somewhat arbitrary of a decision
+    // as neither option is strictly more permissive than the other. However, we opt to check repeat exprs
+    // first as errors from not having inferred array lengths yet seem less confusing than errors from inference
+    // fallback arbitrarily inferring something incompatible with `Copy` inference side effects.
+    //
+    // This should also be forwards compatible with moving repeat expr checks to a custom goal kind or using
+    // marker traits in the future.
+    fcx.check_repeat_exprs();
+
     fcx.type_inference_fallback();
 
     // Even though coercion casts provide type hints, we check casts after fallback for
diff --git a/compiler/rustc_hir_typeck/src/method/confirm.rs b/compiler/rustc_hir_typeck/src/method/confirm.rs
index 3b107fbf1739..0483164ca030 100644
--- a/compiler/rustc_hir_typeck/src/method/confirm.rs
+++ b/compiler/rustc_hir_typeck/src/method/confirm.rs
@@ -426,6 +426,7 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
 
             fn provided_kind(
                 &mut self,
+                preceding_args: &[ty::GenericArg<'tcx>],
                 param: &ty::GenericParamDef,
                 arg: &GenericArg<'tcx>,
             ) -> ty::GenericArg<'tcx> {
@@ -446,7 +447,10 @@ impl<'a, 'tcx> ConfirmContext<'a, 'tcx> {
                     (GenericParamDefKind::Const { .. }, GenericArg::Const(ct)) => self
                         .cfcx
                         // We handle the ambig portions of `ConstArg` in the match arms below
-                        .lower_const_arg(ct.as_unambig_ct(), FeedConstTy::Param(param.def_id))
+                        .lower_const_arg(
+                            ct.as_unambig_ct(),
+                            FeedConstTy::Param(param.def_id, preceding_args),
+                        )
                         .into(),
                     (GenericParamDefKind::Const { .. }, GenericArg::Infer(inf)) => {
                         self.cfcx.ct_infer(Some(param), inf.span).into()
diff --git a/compiler/rustc_hir_typeck/src/method/suggest.rs b/compiler/rustc_hir_typeck/src/method/suggest.rs
index 8438a92219ea..18218a7a0a64 100644
--- a/compiler/rustc_hir_typeck/src/method/suggest.rs
+++ b/compiler/rustc_hir_typeck/src/method/suggest.rs
@@ -9,7 +9,7 @@ use std::path::PathBuf;
 
 use hir::Expr;
 use rustc_ast::ast::Mutability;
-use rustc_attr_parsing::parse_confusables;
+use rustc_attr_parsing::{AttributeKind, find_attr};
 use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::sorted_map::SortedMap;
 use rustc_data_structures::unord::UnordSet;
@@ -1884,9 +1884,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 for inherent_method in
                     self.tcx.associated_items(inherent_impl_did).in_definition_order()
                 {
-                    if let Some(attr) =
-                        self.tcx.get_attr(inherent_method.def_id, sym::rustc_confusables)
-                        && let Some(candidates) = parse_confusables(attr)
+                    if let Some(candidates) = find_attr!(self.tcx.get_all_attrs(inherent_method.def_id), AttributeKind::Confusables{symbols, ..} => symbols)
                         && candidates.contains(&item_name.name)
                         && let ty::AssocKind::Fn = inherent_method.kind
                     {
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index bd0848b99166..19ae3e3899c9 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -2771,16 +2771,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
     ) -> ErrorGuaranteed {
         let PatInfo { top_info: ti, current_depth, .. } = pat_info;
 
-        let mut err = struct_span_code_err!(
-            self.dcx(),
-            span,
-            E0529,
-            "expected an array or slice, found `{expected_ty}`"
-        );
+        let mut slice_pat_semantics = false;
+        let mut as_deref = None;
+        let mut slicing = None;
         if let ty::Ref(_, ty, _) = expected_ty.kind()
             && let ty::Array(..) | ty::Slice(..) = ty.kind()
         {
-            err.help("the semantics of slice patterns changed recently; see issue #62254");
+            slice_pat_semantics = true;
         } else if self
             .autoderef(span, expected_ty)
             .silence_errors()
@@ -2797,28 +2794,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         || self.tcx.is_diagnostic_item(sym::Result, adt_def.did()) =>
                 {
                     // Slicing won't work here, but `.as_deref()` might (issue #91328).
-                    err.span_suggestion_verbose(
-                        span.shrink_to_hi(),
-                        "consider using `as_deref` here",
-                        ".as_deref()",
-                        Applicability::MaybeIncorrect,
-                    );
+                    as_deref = Some(errors::AsDerefSuggestion { span: span.shrink_to_hi() });
                 }
                 _ => (),
             }
 
             let is_top_level = current_depth <= 1;
             if is_slice_or_array_or_vector && is_top_level {
-                err.span_suggestion_verbose(
-                    span.shrink_to_hi(),
-                    "consider slicing here",
-                    "[..]",
-                    Applicability::MachineApplicable,
-                );
+                slicing = Some(errors::SlicingSuggestion { span: span.shrink_to_hi() });
             }
         }
-        err.span_label(span, format!("pattern cannot match with input type `{expected_ty}`"));
-        err.emit()
+        self.dcx().emit_err(errors::ExpectedArrayOrSlice {
+            span,
+            ty: expected_ty,
+            slice_pat_semantics,
+            as_deref,
+            slicing,
+        })
     }
 
     fn is_slice_or_array_or_vector(&self, ty: Ty<'tcx>) -> (bool, Ty<'tcx>) {
diff --git a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
index 903be7e732af..381606a9fb02 100644
--- a/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
+++ b/compiler/rustc_hir_typeck/src/typeck_root_ctxt.rs
@@ -62,6 +62,9 @@ pub(crate) struct TypeckRootCtxt<'tcx> {
 
     pub(super) deferred_coroutine_interiors: RefCell<Vec<(LocalDefId, hir::BodyId, Ty<'tcx>)>>,
 
+    pub(super) deferred_repeat_expr_checks:
+        RefCell<Vec<(&'tcx hir::Expr<'tcx>, Ty<'tcx>, ty::Const<'tcx>)>>,
+
     /// Whenever we introduce an adjustment from `!` into a type variable,
     /// we record that type variable here. This is later used to inform
     /// fallback. See the `fallback` module for details.
@@ -96,6 +99,7 @@ impl<'tcx> TypeckRootCtxt<'tcx> {
             deferred_transmute_checks: RefCell::new(Vec::new()),
             deferred_asm_checks: RefCell::new(Vec::new()),
             deferred_coroutine_interiors: RefCell::new(Vec::new()),
+            deferred_repeat_expr_checks: RefCell::new(Vec::new()),
             diverging_type_vars: RefCell::new(Default::default()),
             infer_var_info: RefCell::new(Default::default()),
         }
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index 3e9ce0e11e40..d7d7d6a20aca 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -248,13 +248,6 @@ impl<'cx, 'tcx> WritebackCx<'cx, 'tcx> {
             }
         }
     }
-
-    fn visit_const_block(&mut self, span: Span, anon_const: &hir::ConstBlock) {
-        self.visit_node_id(span, anon_const.hir_id);
-
-        let body = self.tcx().hir_body(anon_const.body);
-        self.visit_body(body);
-    }
 }
 
 ///////////////////////////////////////////////////////////////////////////
@@ -284,9 +277,6 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
             hir::ExprKind::Field(..) | hir::ExprKind::OffsetOf(..) => {
                 self.visit_field_id(e.hir_id);
             }
-            hir::ExprKind::ConstBlock(ref anon_const) => {
-                self.visit_const_block(e.span, anon_const);
-            }
             _ => {}
         }
 
@@ -297,6 +287,14 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
         self.fix_index_builtin_expr(e);
     }
 
+    fn visit_inline_const(&mut self, anon_const: &hir::ConstBlock) {
+        let span = self.tcx().def_span(anon_const.def_id);
+        self.visit_node_id(span, anon_const.hir_id);
+
+        let body = self.tcx().hir_body(anon_const.body);
+        self.visit_body(body);
+    }
+
     fn visit_generic_param(&mut self, p: &'tcx hir::GenericParam<'tcx>) {
         match &p.kind {
             hir::GenericParamKind::Lifetime { .. } => {
@@ -319,11 +317,8 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
         match p.kind {
             hir::PatKind::Binding(..) => {
                 let typeck_results = self.fcx.typeck_results.borrow();
-                if let Some(bm) =
-                    typeck_results.extract_binding_mode(self.tcx().sess, p.hir_id, p.span)
-                {
-                    self.typeck_results.pat_binding_modes_mut().insert(p.hir_id, bm);
-                }
+                let bm = typeck_results.extract_binding_mode(self.tcx().sess, p.hir_id, p.span);
+                self.typeck_results.pat_binding_modes_mut().insert(p.hir_id, bm);
             }
             hir::PatKind::Struct(_, fields, _) => {
                 for field in fields {
@@ -343,9 +338,6 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
 
     fn visit_pat_expr(&mut self, expr: &'tcx hir::PatExpr<'tcx>) {
         self.visit_node_id(expr.span, expr.hir_id);
-        if let hir::PatExprKind::ConstBlock(c) = &expr.kind {
-            self.visit_const_block(expr.span, c);
-        }
         intravisit::walk_pat_expr(self, expr);
     }
 
diff --git a/compiler/rustc_incremental/src/assert_dep_graph.rs b/compiler/rustc_incremental/src/assert_dep_graph.rs
index d4407559202f..8f2ca6babea8 100644
--- a/compiler/rustc_incremental/src/assert_dep_graph.rs
+++ b/compiler/rustc_incremental/src/assert_dep_graph.rs
@@ -137,13 +137,13 @@ impl<'tcx> IfThisChanged<'tcx> {
                         match DepNode::from_label_string(self.tcx, n.as_str(), def_path_hash) {
                             Ok(n) => n,
                             Err(()) => self.tcx.dcx().emit_fatal(errors::UnrecognizedDepNode {
-                                span: attr.span,
+                                span: attr.span(),
                                 name: n,
                             }),
                         }
                     }
                 };
-                self.if_this_changed.push((attr.span, def_id.to_def_id(), dep_node));
+                self.if_this_changed.push((attr.span(), def_id.to_def_id(), dep_node));
             } else if attr.has_name(sym::rustc_then_this_would_need) {
                 let dep_node_interned = self.argument(attr);
                 let dep_node = match dep_node_interned {
@@ -151,17 +151,17 @@ impl<'tcx> IfThisChanged<'tcx> {
                         match DepNode::from_label_string(self.tcx, n.as_str(), def_path_hash) {
                             Ok(n) => n,
                             Err(()) => self.tcx.dcx().emit_fatal(errors::UnrecognizedDepNode {
-                                span: attr.span,
+                                span: attr.span(),
                                 name: n,
                             }),
                         }
                     }
                     None => {
-                        self.tcx.dcx().emit_fatal(errors::MissingDepNode { span: attr.span });
+                        self.tcx.dcx().emit_fatal(errors::MissingDepNode { span: attr.span() });
                     }
                 };
                 self.then_this_would_need.push((
-                    attr.span,
+                    attr.span(),
                     dep_node_interned.unwrap(),
                     hir_id,
                     dep_node,
diff --git a/compiler/rustc_incremental/src/persist/dirty_clean.rs b/compiler/rustc_incremental/src/persist/dirty_clean.rs
index 56858679af66..d40a0d514f6f 100644
--- a/compiler/rustc_incremental/src/persist/dirty_clean.rs
+++ b/compiler/rustc_incremental/src/persist/dirty_clean.rs
@@ -199,7 +199,7 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
         let loaded_from_disk = self.loaded_from_disk(attr);
         for e in except.items().into_sorted_stable_ord() {
             if !auto.remove(e) {
-                self.tcx.dcx().emit_fatal(errors::AssertionAuto { span: attr.span, name, e });
+                self.tcx.dcx().emit_fatal(errors::AssertionAuto { span: attr.span(), name, e });
             }
         }
         Assertion { clean: auto, dirty: except, loaded_from_disk }
@@ -282,7 +282,7 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
                     HirItem::Impl { .. } => ("ItemKind::Impl", LABELS_IMPL),
 
                     _ => self.tcx.dcx().emit_fatal(errors::UndefinedCleanDirtyItem {
-                        span: attr.span,
+                        span: attr.span(),
                         kind: format!("{:?}", item.kind),
                     }),
                 }
@@ -298,7 +298,7 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
                 ImplItemKind::Type(..) => ("NodeImplType", LABELS_CONST_IN_IMPL),
             },
             _ => self.tcx.dcx().emit_fatal(errors::UndefinedCleanDirty {
-                span: attr.span,
+                span: attr.span(),
                 kind: format!("{node:?}"),
             }),
         };
@@ -375,7 +375,7 @@ impl<'tcx> DirtyCleanVisitor<'tcx> {
             let Some(assertion) = self.assertion_maybe(item_id, attr) else {
                 continue;
             };
-            self.checked_attrs.insert(attr.id);
+            self.checked_attrs.insert(attr.id());
             for label in assertion.clean.items().into_sorted_stable_ord() {
                 let dep_node = DepNode::from_label_string(self.tcx, label, def_path_hash).unwrap();
                 self.assert_clean(item_span, dep_node);
@@ -405,12 +405,13 @@ fn check_config(tcx: TyCtxt<'_>, attr: &Attribute) -> bool {
             debug!("check_config: searching for cfg {:?}", value);
             cfg = Some(config.contains(&(value, None)));
         } else if !(item.has_name(EXCEPT) || item.has_name(LOADED_FROM_DISK)) {
-            tcx.dcx().emit_err(errors::UnknownItem { span: attr.span, name: item.name_or_empty() });
+            tcx.dcx()
+                .emit_err(errors::UnknownItem { span: attr.span(), name: item.name_or_empty() });
         }
     }
 
     match cfg {
-        None => tcx.dcx().emit_fatal(errors::NoCfg { span: attr.span }),
+        None => tcx.dcx().emit_fatal(errors::NoCfg { span: attr.span() }),
         Some(c) => c,
     }
 }
@@ -444,9 +445,9 @@ impl<'tcx> FindAllAttrs<'tcx> {
 
     fn report_unchecked_attrs(&self, mut checked_attrs: FxHashSet<ast::AttrId>) {
         for attr in &self.found_attrs {
-            if !checked_attrs.contains(&attr.id) {
-                self.tcx.dcx().emit_err(errors::UncheckedClean { span: attr.span });
-                checked_attrs.insert(attr.id);
+            if !checked_attrs.contains(&attr.id()) {
+                self.tcx.dcx().emit_err(errors::UncheckedClean { span: attr.span() });
+                checked_attrs.insert(attr.id());
             }
         }
     }
diff --git a/compiler/rustc_index/src/idx.rs b/compiler/rustc_index/src/idx.rs
index b85160540d87..33f406e21137 100644
--- a/compiler/rustc_index/src/idx.rs
+++ b/compiler/rustc_index/src/idx.rs
@@ -1,5 +1,7 @@
 use std::fmt::Debug;
 use std::hash::Hash;
+use std::ops;
+use std::slice::SliceIndex;
 
 /// Represents some newtyped `usize` wrapper.
 ///
@@ -43,3 +45,92 @@ impl Idx for u32 {
         self as usize
     }
 }
+
+/// Helper trait for indexing operations with a custom index type.
+pub trait IntoSliceIdx<I, T: ?Sized> {
+    type Output: SliceIndex<T>;
+    fn into_slice_idx(self) -> Self::Output;
+}
+
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for I {
+    type Output = usize;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        self.index()
+    }
+}
+
+impl<I, T> IntoSliceIdx<I, [T]> for ops::RangeFull {
+    type Output = ops::RangeFull;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        self
+    }
+}
+
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for ops::Range<I> {
+    type Output = ops::Range<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        ops::Range { start: self.start.index(), end: self.end.index() }
+    }
+}
+
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for ops::RangeFrom<I> {
+    type Output = ops::RangeFrom<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        ops::RangeFrom { start: self.start.index() }
+    }
+}
+
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for ops::RangeTo<I> {
+    type Output = ops::RangeTo<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        ..self.end.index()
+    }
+}
+
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for ops::RangeInclusive<I> {
+    type Output = ops::RangeInclusive<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        ops::RangeInclusive::new(self.start().index(), self.end().index())
+    }
+}
+
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for ops::RangeToInclusive<I> {
+    type Output = ops::RangeToInclusive<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        ..=self.end.index()
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::Range<I> {
+    type Output = core::range::Range<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        core::range::Range { start: self.start.index(), end: self.end.index() }
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeFrom<I> {
+    type Output = core::range::RangeFrom<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        core::range::RangeFrom { start: self.start.index() }
+    }
+}
+
+#[cfg(feature = "nightly")]
+impl<I: Idx, T> IntoSliceIdx<I, [T]> for core::range::RangeInclusive<I> {
+    type Output = core::range::RangeInclusive<usize>;
+    #[inline]
+    fn into_slice_idx(self) -> Self::Output {
+        core::range::RangeInclusive { start: self.start.index(), end: self.end.index() }
+    }
+}
diff --git a/compiler/rustc_index/src/lib.rs b/compiler/rustc_index/src/lib.rs
index cae55230b067..3441a5f65c78 100644
--- a/compiler/rustc_index/src/lib.rs
+++ b/compiler/rustc_index/src/lib.rs
@@ -2,6 +2,7 @@
 #![cfg_attr(all(feature = "nightly", test), feature(stmt_expr_attributes))]
 #![cfg_attr(feature = "nightly", allow(internal_features))]
 #![cfg_attr(feature = "nightly", feature(extend_one, step_trait, test))]
+#![cfg_attr(feature = "nightly", feature(new_range_api))]
 #![cfg_attr(feature = "nightly", feature(new_zeroed_alloc))]
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
@@ -14,7 +15,7 @@ mod idx;
 mod slice;
 mod vec;
 
-pub use idx::Idx;
+pub use idx::{Idx, IntoSliceIdx};
 pub use rustc_index_macros::newtype_index;
 pub use slice::IndexSlice;
 #[doc(no_inline)]
diff --git a/compiler/rustc_index/src/slice.rs b/compiler/rustc_index/src/slice.rs
index 4636f294f13b..f17ea9e4b59a 100644
--- a/compiler/rustc_index/src/slice.rs
+++ b/compiler/rustc_index/src/slice.rs
@@ -1,8 +1,9 @@
+use std::fmt;
 use std::marker::PhantomData;
 use std::ops::{Index, IndexMut};
-use std::{fmt, slice};
+use std::slice::{self, SliceIndex};
 
-use crate::{Idx, IndexVec};
+use crate::{Idx, IndexVec, IntoSliceIdx};
 
 /// A view into contiguous `T`s, indexed by `I` rather than by `usize`.
 ///
@@ -97,13 +98,19 @@ impl<I: Idx, T> IndexSlice<I, T> {
     }
 
     #[inline]
-    pub fn get(&self, index: I) -> Option<&T> {
-        self.raw.get(index.index())
+    pub fn get<R: IntoSliceIdx<I, [T]>>(
+        &self,
+        index: R,
+    ) -> Option<&<R::Output as SliceIndex<[T]>>::Output> {
+        self.raw.get(index.into_slice_idx())
     }
 
     #[inline]
-    pub fn get_mut(&mut self, index: I) -> Option<&mut T> {
-        self.raw.get_mut(index.index())
+    pub fn get_mut<R: IntoSliceIdx<I, [T]>>(
+        &mut self,
+        index: R,
+    ) -> Option<&mut <R::Output as SliceIndex<[T]>>::Output> {
+        self.raw.get_mut(index.into_slice_idx())
     }
 
     /// Returns mutable references to two distinct elements, `a` and `b`.
@@ -184,19 +191,19 @@ impl<I: Idx, T: fmt::Debug> fmt::Debug for IndexSlice<I, T> {
     }
 }
 
-impl<I: Idx, T> Index<I> for IndexSlice<I, T> {
-    type Output = T;
+impl<I: Idx, T, R: IntoSliceIdx<I, [T]>> Index<R> for IndexSlice<I, T> {
+    type Output = <R::Output as SliceIndex<[T]>>::Output;
 
     #[inline]
-    fn index(&self, index: I) -> &T {
-        &self.raw[index.index()]
+    fn index(&self, index: R) -> &Self::Output {
+        &self.raw[index.into_slice_idx()]
     }
 }
 
-impl<I: Idx, T> IndexMut<I> for IndexSlice<I, T> {
+impl<I: Idx, T, R: IntoSliceIdx<I, [T]>> IndexMut<R> for IndexSlice<I, T> {
     #[inline]
-    fn index_mut(&mut self, index: I) -> &mut T {
-        &mut self.raw[index.index()]
+    fn index_mut(&mut self, index: R) -> &mut Self::Output {
+        &mut self.raw[index.into_slice_idx()]
     }
 }
 
diff --git a/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs b/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
index e454a88e847f..03c4614af139 100644
--- a/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
+++ b/compiler/rustc_infer/src/infer/lexical_region_resolve/mod.rs
@@ -160,7 +160,7 @@ impl<'cx, 'tcx> LexicalResolver<'cx, 'tcx> {
     /// empty region. The `expansion` phase will grow this larger.
     fn construct_var_data(&self) -> LexicalRegionResolutions<'tcx> {
         LexicalRegionResolutions {
-            values: IndexVec::from_fn_n(
+            values: IndexVec::<RegionVid, _>::from_fn_n(
                 |vid| {
                     let vid_universe = self.var_infos[vid].universe;
                     VarValue::Empty(vid_universe)
diff --git a/compiler/rustc_infer/src/infer/relate/higher_ranked.rs b/compiler/rustc_infer/src/infer/relate/higher_ranked.rs
index 0998f3c47902..a12d83db91f2 100644
--- a/compiler/rustc_infer/src/infer/relate/higher_ranked.rs
+++ b/compiler/rustc_infer/src/infer/relate/higher_ranked.rs
@@ -2,6 +2,7 @@
 //! the end of the file for details.
 
 use rustc_middle::ty::fold::FnMutDelegate;
+use rustc_middle::ty::visit::TypeVisitableExt;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeFoldable};
 use tracing::{debug, instrument};
 
@@ -26,8 +27,9 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: TypeFoldable<TyCtxt<'tcx>>,
     {
-        if let Some(inner) = binder.clone().no_bound_vars() {
-            return inner;
+        // Inlined `no_bound_vars`.
+        if !binder.as_ref().skip_binder().has_escaping_bound_vars() {
+            return binder.skip_binder();
         }
 
         let next_universe = self.create_next_universe();
diff --git a/compiler/rustc_lint/Cargo.toml b/compiler/rustc_lint/Cargo.toml
index 24e7b40c8a2d..d6014f5006ad 100644
--- a/compiler/rustc_lint/Cargo.toml
+++ b/compiler/rustc_lint/Cargo.toml
@@ -24,6 +24,7 @@ rustc_span = { path = "../rustc_span" }
 rustc_target = { path = "../rustc_target" }
 rustc_trait_selection = { path = "../rustc_trait_selection" }
 rustc_type_ir = { path = "../rustc_type_ir" }
+smallvec = { version = "1.8.1", features = ["union", "may_dangle"] }
 tracing = "0.1"
 unicode-security = "0.1.0"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_lint/messages.ftl b/compiler/rustc_lint/messages.ftl
index 679367634276..d51865810b9a 100644
--- a/compiler/rustc_lint/messages.ftl
+++ b/compiler/rustc_lint/messages.ftl
@@ -333,6 +333,11 @@ lint_identifier_uncommon_codepoints = identifier contains {$codepoints_len ->
         *[other] {" "}{$identifier_type}
     } Unicode general security profile
 
+lint_if_let_dtor = {$dtor_kind ->
+    [dyn] value may invoke a custom destructor because it contains a trait object
+    *[concrete] value invokes this custom destructor
+    }
+
 lint_if_let_rescope = `if let` assigns a shorter lifetime since Edition 2024
     .label = this value has a significant drop implementation which may observe a major change in drop order and requires your discretion
     .help = the value is now dropped here in Edition 2024
diff --git a/compiler/rustc_lint/src/builtin.rs b/compiler/rustc_lint/src/builtin.rs
index 5e44583b2976..f7be37dc4a2c 100644
--- a/compiler/rustc_lint/src/builtin.rs
+++ b/compiler/rustc_lint/src/builtin.rs
@@ -1011,7 +1011,7 @@ impl<'tcx> LateLintPass<'tcx> for InvalidNoMangleItems {
                         cx.emit_span_lint(
                             NO_MANGLE_GENERIC_ITEMS,
                             span,
-                            BuiltinNoMangleGeneric { suggestion: no_mangle_attr.span },
+                            BuiltinNoMangleGeneric { suggestion: no_mangle_attr.span() },
                         );
                         break;
                     }
@@ -1226,7 +1226,7 @@ impl<'tcx> LateLintPass<'tcx> for UngatedAsyncFnTrackCaller {
         {
             cx.emit_span_lint(
                 UNGATED_ASYNC_FN_TRACK_CALLER,
-                attr.span,
+                attr.span(),
                 BuiltinUngatedAsyncFnTrackCaller { label: span, session: &cx.tcx.sess },
             );
         }
diff --git a/compiler/rustc_lint/src/expect.rs b/compiler/rustc_lint/src/expect.rs
index ef79f1301e5f..9ca148e1f254 100644
--- a/compiler/rustc_lint/src/expect.rs
+++ b/compiler/rustc_lint/src/expect.rs
@@ -38,7 +38,8 @@ fn check_expectations(tcx: TyCtxt<'_>, tool_filter: Option<Symbol>) {
             }
             LintExpectationId::Stable { hir_id, attr_index, lint_index: Some(lint_index) } => {
                 // We are an `eval_always` query, so looking at the attribute's `AttrId` is ok.
-                let attr_id = tcx.hir().attrs(hir_id)[attr_index as usize].id;
+                let attr_id = tcx.hir().attrs(hir_id)[attr_index as usize].id();
+
                 (attr_id, lint_index)
             }
             _ => panic!("fulfilled expectations must have a lint index"),
diff --git a/compiler/rustc_lint/src/foreign_modules.rs b/compiler/rustc_lint/src/foreign_modules.rs
index 49c34d0edcc2..6175415c31f9 100644
--- a/compiler/rustc_lint/src/foreign_modules.rs
+++ b/compiler/rustc_lint/src/foreign_modules.rs
@@ -182,7 +182,7 @@ fn name_of_extern_decl(tcx: TyCtxt<'_>, fi: hir::OwnerId) -> SymbolName {
             // information, we could have codegen_fn_attrs also give span information back for
             // where the attribute was defined. However, until this is found to be a
             // bottleneck, this does just fine.
-            (overridden_link_name, tcx.get_attr(fi, sym::link_name).unwrap().span)
+            (overridden_link_name, tcx.get_attr(fi, sym::link_name).unwrap().span())
         })
     {
         SymbolName::Link(overridden_link_name, overridden_link_name_span)
diff --git a/compiler/rustc_lint/src/if_let_rescope.rs b/compiler/rustc_lint/src/if_let_rescope.rs
index c1aa95667da6..39ea8d8e3246 100644
--- a/compiler/rustc_lint/src/if_let_rescope.rs
+++ b/compiler/rustc_lint/src/if_let_rescope.rs
@@ -1,18 +1,23 @@
 use std::iter::repeat;
 use std::ops::ControlFlow;
 
-use hir::intravisit::Visitor;
+use hir::intravisit::{self, Visitor};
 use rustc_ast::Recovered;
 use rustc_errors::{
     Applicability, Diag, EmissionGuarantee, SubdiagMessageOp, Subdiagnostic, SuggestionStyle,
 };
 use rustc_hir::{self as hir, HirIdSet};
-use rustc_macros::LintDiagnostic;
-use rustc_middle::ty::TyCtxt;
+use rustc_macros::{LintDiagnostic, Subdiagnostic};
+use rustc_middle::ty::adjustment::Adjust;
+use rustc_middle::ty::significant_drop_order::{
+    extract_component_with_significant_dtor, ty_dtor_span,
+};
+use rustc_middle::ty::{self, Ty, TyCtxt};
 use rustc_session::lint::{FutureIncompatibilityReason, LintId};
 use rustc_session::{declare_lint, impl_lint_pass};
-use rustc_span::Span;
 use rustc_span::edition::Edition;
+use rustc_span::{DUMMY_SP, Span};
+use smallvec::SmallVec;
 
 use crate::{LateContext, LateLintPass};
 
@@ -129,6 +134,7 @@ impl IfLetRescope {
             hir::ExprKind::If(_cond, _conseq, Some(alt)) => alt.span.shrink_to_hi(),
             _ => return,
         };
+        let mut seen_dyn = false;
         let mut add_bracket_to_match_head = match_head_needs_bracket(tcx, expr);
         let mut significant_droppers = vec![];
         let mut lifetime_ends = vec![];
@@ -136,6 +142,7 @@ impl IfLetRescope {
         let mut alt_heads = vec![];
         let mut match_heads = vec![];
         let mut consequent_heads = vec![];
+        let mut destructors = vec![];
         let mut first_if_to_lint = None;
         let mut first_if_to_rewrite = false;
         let mut empty_alt = false;
@@ -159,11 +166,25 @@ impl IfLetRescope {
                 let before_conseq = conseq.span.shrink_to_lo();
                 let lifetime_end = source_map.end_point(conseq.span);
 
-                if let ControlFlow::Break(significant_dropper) =
-                    (FindSignificantDropper { cx }).visit_expr(init)
+                if let ControlFlow::Break((drop_span, drop_tys)) =
+                    (FindSignificantDropper { cx }).check_if_let_scrutinee(init)
                 {
+                    destructors.extend(drop_tys.into_iter().filter_map(|ty| {
+                        if let Some(span) = ty_dtor_span(tcx, ty) {
+                            Some(DestructorLabel { span, dtor_kind: "concrete" })
+                        } else if matches!(ty.kind(), ty::Dynamic(..)) {
+                            if seen_dyn {
+                                None
+                            } else {
+                                seen_dyn = true;
+                                Some(DestructorLabel { span: DUMMY_SP, dtor_kind: "dyn" })
+                            }
+                        } else {
+                            None
+                        }
+                    }));
                     first_if_to_lint = first_if_to_lint.or_else(|| Some((span, expr.hir_id)));
-                    significant_droppers.push(significant_dropper);
+                    significant_droppers.push(drop_span);
                     lifetime_ends.push(lifetime_end);
                     if ty_ascription.is_some()
                         || !expr.span.can_be_used_for_suggestions()
@@ -226,6 +247,7 @@ impl IfLetRescope {
                 hir_id,
                 span,
                 IfLetRescopeLint {
+                    destructors,
                     significant_droppers,
                     lifetime_ends,
                     rewrite: first_if_to_rewrite.then_some(IfLetRescopeRewrite {
@@ -287,6 +309,8 @@ impl<'tcx> LateLintPass<'tcx> for IfLetRescope {
 #[derive(LintDiagnostic)]
 #[diag(lint_if_let_rescope)]
 struct IfLetRescopeLint {
+    #[subdiagnostic]
+    destructors: Vec<DestructorLabel>,
     #[label]
     significant_droppers: Vec<Span>,
     #[help]
@@ -346,6 +370,14 @@ impl Subdiagnostic for IfLetRescopeRewrite {
     }
 }
 
+#[derive(Subdiagnostic)]
+#[note(lint_if_let_dtor)]
+struct DestructorLabel {
+    #[primary_span]
+    span: Span,
+    dtor_kind: &'static str,
+}
+
 struct AltHead(Span);
 
 struct ConsequentRewrite {
@@ -363,96 +395,107 @@ enum SingleArmMatchBegin {
     WithoutOpenBracket(Span),
 }
 
-struct FindSignificantDropper<'tcx, 'a> {
+struct FindSignificantDropper<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
 }
 
-impl<'tcx, 'a> Visitor<'tcx> for FindSignificantDropper<'tcx, 'a> {
-    type Result = ControlFlow<Span>;
+impl<'tcx> FindSignificantDropper<'_, 'tcx> {
+    /// Check the scrutinee of an `if let` to see if it promotes any temporary values
+    /// that would change drop order in edition 2024. Specifically, it checks the value
+    /// of the scrutinee itself, and also recurses into the expression to find any ref
+    /// exprs (or autoref) which would promote temporaries that would be scoped to the
+    /// end of this `if`.
+    fn check_if_let_scrutinee(
+        &mut self,
+        init: &'tcx hir::Expr<'tcx>,
+    ) -> ControlFlow<(Span, SmallVec<[Ty<'tcx>; 4]>)> {
+        self.check_promoted_temp_with_drop(init)?;
+        self.visit_expr(init)
+    }
+
+    /// Check that an expression is not a promoted temporary with a significant
+    /// drop impl.
+    ///
+    /// An expression is a promoted temporary if it has an addr taken (i.e. `&expr` or autoref)
+    /// or is the scrutinee of the `if let`, *and* the expression is not a place
+    /// expr, and it has a significant drop.
+    fn check_promoted_temp_with_drop(
+        &self,
+        expr: &'tcx hir::Expr<'tcx>,
+    ) -> ControlFlow<(Span, SmallVec<[Ty<'tcx>; 4]>)> {
+        if expr.is_place_expr(|base| {
+            self.cx
+                .typeck_results()
+                .adjustments()
+                .get(base.hir_id)
+                .is_some_and(|x| x.iter().any(|adj| matches!(adj.kind, Adjust::Deref(_))))
+        }) {
+            return ControlFlow::Continue(());
+        }
+
+        let drop_tys = extract_component_with_significant_dtor(
+            self.cx.tcx,
+            self.cx.typing_env(),
+            self.cx.typeck_results().expr_ty(expr),
+        );
+        if drop_tys.is_empty() {
+            return ControlFlow::Continue(());
+        }
+
+        ControlFlow::Break((expr.span, drop_tys))
+    }
+}
+
+impl<'tcx> Visitor<'tcx> for FindSignificantDropper<'_, 'tcx> {
+    type Result = ControlFlow<(Span, SmallVec<[Ty<'tcx>; 4]>)>;
+
+    fn visit_block(&mut self, b: &'tcx hir::Block<'tcx>) -> Self::Result {
+        // Blocks introduce temporary terminating scope for all of its
+        // statements, so just visit the tail expr, skipping over any
+        // statements. This prevents false positives like `{ let x = &Drop; }`.
+        if let Some(expr) = b.expr { self.visit_expr(expr) } else { ControlFlow::Continue(()) }
+    }
 
     fn visit_expr(&mut self, expr: &'tcx hir::Expr<'tcx>) -> Self::Result {
-        if self
-            .cx
-            .typeck_results()
-            .expr_ty(expr)
-            .has_significant_drop(self.cx.tcx, self.cx.typing_env())
-        {
-            return ControlFlow::Break(expr.span);
+        // Check for promoted temporaries from autoref, e.g.
+        // `if let None = TypeWithDrop.as_ref() {} else {}`
+        // where `fn as_ref(&self) -> Option<...>`.
+        for adj in self.cx.typeck_results().expr_adjustments(expr) {
+            match adj.kind {
+                // Skip when we hit the first deref expr.
+                Adjust::Deref(_) => break,
+                Adjust::Borrow(_) => {
+                    self.check_promoted_temp_with_drop(expr)?;
+                }
+                _ => {}
+            }
         }
+
         match expr.kind {
-            hir::ExprKind::ConstBlock(_)
-            | hir::ExprKind::Lit(_)
-            | hir::ExprKind::Path(_)
-            | hir::ExprKind::Assign(_, _, _)
-            | hir::ExprKind::AssignOp(_, _, _)
-            | hir::ExprKind::Break(_, _)
-            | hir::ExprKind::Continue(_)
-            | hir::ExprKind::Ret(_)
-            | hir::ExprKind::Become(_)
-            | hir::ExprKind::InlineAsm(_)
-            | hir::ExprKind::OffsetOf(_, _)
-            | hir::ExprKind::Repeat(_, _)
-            | hir::ExprKind::Err(_)
-            | hir::ExprKind::Struct(_, _, _)
-            | hir::ExprKind::Closure(_)
-            | hir::ExprKind::Block(_, _)
-            | hir::ExprKind::DropTemps(_)
-            | hir::ExprKind::Loop(_, _, _, _) => ControlFlow::Continue(()),
-
-            hir::ExprKind::Tup(exprs) | hir::ExprKind::Array(exprs) => {
-                for expr in exprs {
-                    self.visit_expr(expr)?;
-                }
-                ControlFlow::Continue(())
+            // Account for cases like `if let None = Some(&Drop) {} else {}`.
+            hir::ExprKind::AddrOf(_, _, expr) => {
+                self.check_promoted_temp_with_drop(expr)?;
+                intravisit::walk_expr(self, expr)
             }
-            hir::ExprKind::Call(callee, args) => {
-                self.visit_expr(callee)?;
-                for expr in args {
-                    self.visit_expr(expr)?;
-                }
-                ControlFlow::Continue(())
-            }
-            hir::ExprKind::MethodCall(_, receiver, args, _) => {
-                self.visit_expr(receiver)?;
-                for expr in args {
-                    self.visit_expr(expr)?;
-                }
-                ControlFlow::Continue(())
-            }
-            hir::ExprKind::Index(left, right, _) | hir::ExprKind::Binary(_, left, right) => {
-                self.visit_expr(left)?;
-                self.visit_expr(right)
-            }
-            hir::ExprKind::Unary(_, expr)
-            | hir::ExprKind::Cast(expr, _)
-            | hir::ExprKind::Type(expr, _)
-            | hir::ExprKind::UnsafeBinderCast(_, expr, _)
-            | hir::ExprKind::Yield(expr, _)
-            | hir::ExprKind::AddrOf(_, _, expr)
-            | hir::ExprKind::Match(expr, _, _)
-            | hir::ExprKind::Field(expr, _)
-            | hir::ExprKind::Let(&hir::LetExpr {
-                init: expr,
-                span: _,
-                pat: _,
-                ty: _,
-                recovered: Recovered::No,
-            }) => self.visit_expr(expr),
-            hir::ExprKind::Let(_) => ControlFlow::Continue(()),
-
-            hir::ExprKind::If(cond, _, _) => {
-                if let hir::ExprKind::Let(hir::LetExpr {
-                    init,
-                    span: _,
-                    pat: _,
-                    ty: _,
-                    recovered: Recovered::No,
-                }) = cond.kind
-                {
-                    self.visit_expr(init)?;
-                }
-                ControlFlow::Continue(())
+            // `(Drop, ()).1` introduces a temporary and then moves out of
+            // part of it, therefore we should check it for temporaries.
+            // FIXME: This may have false positives if we move the part
+            // that actually has drop, but oh well.
+            hir::ExprKind::Index(expr, _, _) | hir::ExprKind::Field(expr, _) => {
+                self.check_promoted_temp_with_drop(expr)?;
+                intravisit::walk_expr(self, expr)
             }
+            // If always introduces a temporary terminating scope for its cond and arms,
+            // so don't visit them.
+            hir::ExprKind::If(..) => ControlFlow::Continue(()),
+            // Match introduces temporary terminating scopes for arms, so don't visit
+            // them, and only visit the scrutinee to account for cases like:
+            // `if let None = match &Drop { _ => Some(1) } {} else {}`.
+            hir::ExprKind::Match(scrut, _, _) => self.visit_expr(scrut),
+            // Self explanatory.
+            hir::ExprKind::DropTemps(_) => ControlFlow::Continue(()),
+            // Otherwise, walk into the expr's parts.
+            _ => intravisit::walk_expr(self, expr),
         }
     }
 }
diff --git a/compiler/rustc_lint/src/lib.rs b/compiler/rustc_lint/src/lib.rs
index ded50d98db5e..5c5b3b350dd4 100644
--- a/compiler/rustc_lint/src/lib.rs
+++ b/compiler/rustc_lint/src/lib.rs
@@ -26,7 +26,6 @@
 #![feature(array_windows)]
 #![feature(assert_matches)]
 #![feature(box_patterns)]
-#![feature(extract_if)]
 #![feature(if_let_guard)]
 #![feature(iter_order_by)]
 #![feature(let_chains)]
diff --git a/compiler/rustc_lint/src/nonstandard_style.rs b/compiler/rustc_lint/src/nonstandard_style.rs
index bc35e2f0538d..49f9ad39780a 100644
--- a/compiler/rustc_lint/src/nonstandard_style.rs
+++ b/compiler/rustc_lint/src/nonstandard_style.rs
@@ -1,13 +1,14 @@
 use rustc_abi::ExternAbi;
+use rustc_attr_parsing::{AttributeKind, AttributeParser, ReprAttr};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::intravisit::FnKind;
-use rustc_hir::{AttrArgs, AttrItem, AttrKind, GenericParamKind, PatExprKind, PatKind};
+use rustc_hir::{AttrArgs, AttrItem, Attribute, GenericParamKind, PatExprKind, PatKind};
 use rustc_middle::ty;
 use rustc_session::config::CrateType;
 use rustc_session::{declare_lint, declare_lint_pass};
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{BytePos, Ident, Span, sym};
-use {rustc_ast as ast, rustc_attr_parsing as attr, rustc_hir as hir};
+use {rustc_ast as ast, rustc_hir as hir};
 
 use crate::lints::{
     NonCamelCaseType, NonCamelCaseTypeSub, NonSnakeCaseDiag, NonSnakeCaseDiagSub,
@@ -161,10 +162,10 @@ impl NonCamelCaseTypes {
 
 impl EarlyLintPass for NonCamelCaseTypes {
     fn check_item(&mut self, cx: &EarlyContext<'_>, it: &ast::Item) {
-        let has_repr_c = it
-            .attrs
-            .iter()
-            .any(|attr| attr::find_repr_attrs(cx.sess(), attr).contains(&attr::ReprC));
+        let has_repr_c = matches!(
+            AttributeParser::parse_limited(cx.sess(), &it.attrs, sym::repr, it.span, true),
+            Some(Attribute::Parsed(AttributeKind::Repr(r))) if r.iter().any(|(r, _)| r == &ReprAttr::ReprC)
+        );
 
         if has_repr_c {
             return;
@@ -343,7 +344,7 @@ impl<'tcx> LateLintPass<'tcx> for NonSnakeCase {
         } else {
             ast::attr::find_by_name(cx.tcx.hir().attrs(hir::CRATE_HIR_ID), sym::crate_name)
                 .and_then(|attr| {
-                    if let AttrKind::Normal(n) = &attr.kind
+                    if let Attribute::Unparsed(n) = attr
                         && let AttrItem { args: AttrArgs::Eq { eq_span: _, expr: lit }, .. } =
                             n.as_ref()
                         && let ast::LitKind::Str(name, ..) = lit.kind
diff --git a/compiler/rustc_lint/src/types/literal.rs b/compiler/rustc_lint/src/types/literal.rs
index 3e4532a6dbee..7cb00262b6ff 100644
--- a/compiler/rustc_lint/src/types/literal.rs
+++ b/compiler/rustc_lint/src/types/literal.rs
@@ -186,7 +186,7 @@ fn report_bin_hex_error(
                 lit_no_suffix,
                 negative_val: actually.clone(),
                 int_ty: int_ty.name_str(),
-                uint_ty: int_ty.to_unsigned().name_str(),
+                uint_ty: Integer::fit_unsigned(val).uint_ty_str(),
             })
         })
         .flatten();
diff --git a/compiler/rustc_lint_defs/src/lib.rs b/compiler/rustc_lint_defs/src/lib.rs
index ff3dae08ffc9..e564235c41a5 100644
--- a/compiler/rustc_lint_defs/src/lib.rs
+++ b/compiler/rustc_lint_defs/src/lib.rs
@@ -251,19 +251,23 @@ impl Level {
 
     /// Converts an `Attribute` to a level.
     pub fn from_attr(attr: &impl AttributeExt) -> Option<Self> {
-        Self::from_symbol(attr.name_or_empty(), Some(attr.id()))
+        Self::from_symbol(attr.name_or_empty(), || Some(attr.id()))
     }
 
     /// Converts a `Symbol` to a level.
-    pub fn from_symbol(s: Symbol, id: Option<AttrId>) -> Option<Self> {
-        match (s, id) {
-            (sym::allow, _) => Some(Level::Allow),
-            (sym::expect, Some(attr_id)) => {
-                Some(Level::Expect(LintExpectationId::Unstable { attr_id, lint_index: None }))
+    pub fn from_symbol(s: Symbol, id: impl FnOnce() -> Option<AttrId>) -> Option<Self> {
+        match s {
+            sym::allow => Some(Level::Allow),
+            sym::expect => {
+                if let Some(attr_id) = id() {
+                    Some(Level::Expect(LintExpectationId::Unstable { attr_id, lint_index: None }))
+                } else {
+                    None
+                }
             }
-            (sym::warn, _) => Some(Level::Warn),
-            (sym::deny, _) => Some(Level::Deny),
-            (sym::forbid, _) => Some(Level::Forbid),
+            sym::warn => Some(Level::Warn),
+            sym::deny => Some(Level::Deny),
+            sym::forbid => Some(Level::Forbid),
             _ => None,
         }
     }
diff --git a/compiler/rustc_llvm/Cargo.toml b/compiler/rustc_llvm/Cargo.toml
index 4f3ce77efc44..061562b2ec5e 100644
--- a/compiler/rustc_llvm/Cargo.toml
+++ b/compiler/rustc_llvm/Cargo.toml
@@ -12,5 +12,5 @@ libc = "0.2.73"
 # tidy-alphabetical-start
 # Pinned so `cargo update` bumps don't cause breakage. Please also update the
 # pinned `cc` in `rustc_codegen_ssa` if you update `cc` here.
-cc = "=1.2.13"
+cc = "=1.2.16"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
index 9ce4abdb432e..6e607baebb5c 100644
--- a/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
+++ b/compiler/rustc_llvm/llvm-wrapper/PassWrapper.cpp
@@ -7,6 +7,7 @@
 #include "llvm/Analysis/Lint.h"
 #include "llvm/Analysis/TargetLibraryInfo.h"
 #include "llvm/Bitcode/BitcodeWriter.h"
+#include "llvm/Bitcode/BitcodeWriterPass.h"
 #include "llvm/CodeGen/CommandFlags.h"
 #include "llvm/IR/AssemblyAnnotationWriter.h"
 #include "llvm/IR/AutoUpgrade.h"
@@ -37,6 +38,7 @@
 #include "llvm/Transforms/Instrumentation/InstrProfiling.h"
 #include "llvm/Transforms/Instrumentation/MemorySanitizer.h"
 #include "llvm/Transforms/Instrumentation/ThreadSanitizer.h"
+#include "llvm/Transforms/Scalar/AnnotationRemarks.h"
 #include "llvm/Transforms/Utils/CanonicalizeAliases.h"
 #include "llvm/Transforms/Utils/FunctionImportUtils.h"
 #include "llvm/Transforms/Utils/NameAnonGlobals.h"
@@ -195,6 +197,19 @@ extern "C" void LLVMRustTimeTraceProfilerFinish(const char *FileName) {
 GEN_SUBTARGETS
 #undef SUBTARGET
 
+// This struct and various functions are sort of a hack right now, but the
+// problem is that we've got in-memory LLVM modules after we generate and
+// optimize all codegen-units for one compilation in rustc. To be compatible
+// with the LTO support above we need to serialize the modules plus their
+// ThinLTO summary into memory.
+//
+// This structure is basically an owned version of a serialize module, with
+// a ThinLTO summary attached.
+struct LLVMRustThinLTOBuffer {
+  std::string data;
+  std::string thin_link_data;
+};
+
 extern "C" bool LLVMRustHasFeature(LLVMTargetMachineRef TM,
                                    const char *Feature) {
   TargetMachine *Target = unwrap(TM);
@@ -704,7 +719,8 @@ extern "C" LLVMRustResult LLVMRustOptimize(
     LLVMModuleRef ModuleRef, LLVMTargetMachineRef TMRef,
     LLVMRustPassBuilderOptLevel OptLevelRust, LLVMRustOptStage OptStage,
     bool IsLinkerPluginLTO, bool NoPrepopulatePasses, bool VerifyIR,
-    bool LintIR, bool UseThinLTOBuffers, bool MergeFunctions, bool UnrollLoops,
+    bool LintIR, LLVMRustThinLTOBuffer **ThinLTOBufferRef, bool EmitThinLTO,
+    bool EmitThinLTOSummary, bool MergeFunctions, bool UnrollLoops,
     bool SLPVectorize, bool LoopVectorize, bool DisableSimplifyLibCalls,
     bool EmitLifetimeMarkers, bool RunEnzyme,
     LLVMRustSanitizerOptions *SanitizerOptions, const char *PGOGenPath,
@@ -952,7 +968,10 @@ extern "C" LLVMRustResult LLVMRustOptimize(
   }
 
   ModulePassManager MPM;
-  bool NeedThinLTOBufferPasses = UseThinLTOBuffers;
+  bool NeedThinLTOBufferPasses = EmitThinLTO;
+  auto ThinLTOBuffer = std::make_unique<LLVMRustThinLTOBuffer>();
+  raw_string_ostream ThinLTODataOS(ThinLTOBuffer->data);
+  raw_string_ostream ThinLinkDataOS(ThinLTOBuffer->thin_link_data);
   if (!NoPrepopulatePasses) {
     // The pre-link pipelines don't support O0 and require using
     // buildO0DefaultPipeline() instead. At the same time, the LTO pipelines do
@@ -976,7 +995,25 @@ extern "C" LLVMRustResult LLVMRustOptimize(
 
       switch (OptStage) {
       case LLVMRustOptStage::PreLinkNoLTO:
-        MPM = PB.buildPerModuleDefaultPipeline(OptLevel);
+        if (ThinLTOBufferRef) {
+          // This is similar to LLVM's `buildFatLTODefaultPipeline`, where the
+          // bitcode for embedding is obtained after performing
+          // `ThinLTOPreLinkDefaultPipeline`.
+          MPM.addPass(PB.buildThinLTOPreLinkDefaultPipeline(OptLevel));
+          if (EmitThinLTO) {
+            MPM.addPass(ThinLTOBitcodeWriterPass(
+                ThinLTODataOS, EmitThinLTOSummary ? &ThinLinkDataOS : nullptr));
+          } else {
+            MPM.addPass(BitcodeWriterPass(ThinLTODataOS));
+          }
+          *ThinLTOBufferRef = ThinLTOBuffer.release();
+          MPM.addPass(PB.buildModuleOptimizationPipeline(
+              OptLevel, ThinOrFullLTOPhase::None));
+          MPM.addPass(
+              createModuleToFunctionPassAdaptor(AnnotationRemarksPass()));
+        } else {
+          MPM = PB.buildPerModuleDefaultPipeline(OptLevel);
+        }
         break;
       case LLVMRustOptStage::PreLinkThinLTO:
         MPM = PB.buildThinLTOPreLinkDefaultPipeline(OptLevel);
@@ -1022,6 +1059,16 @@ extern "C" LLVMRustResult LLVMRustOptimize(
     MPM.addPass(CanonicalizeAliasesPass());
     MPM.addPass(NameAnonGlobalPass());
   }
+  // For `-Copt-level=0`, ThinLTO, or LTO.
+  if (ThinLTOBufferRef && *ThinLTOBufferRef == nullptr) {
+    if (EmitThinLTO) {
+      MPM.addPass(ThinLTOBitcodeWriterPass(
+          ThinLTODataOS, EmitThinLTOSummary ? &ThinLinkDataOS : nullptr));
+    } else {
+      MPM.addPass(BitcodeWriterPass(ThinLTODataOS));
+    }
+    *ThinLTOBufferRef = ThinLTOBuffer.release();
+  }
 
   // now load "-enzyme" pass:
 #ifdef ENZYME
@@ -1500,19 +1547,6 @@ extern "C" bool LLVMRustPrepareThinLTOImport(const LLVMRustThinLTOData *Data,
   return true;
 }
 
-// This struct and various functions are sort of a hack right now, but the
-// problem is that we've got in-memory LLVM modules after we generate and
-// optimize all codegen-units for one compilation in rustc. To be compatible
-// with the LTO support above we need to serialize the modules plus their
-// ThinLTO summary into memory.
-//
-// This structure is basically an owned version of a serialize module, with
-// a ThinLTO summary attached.
-struct LLVMRustThinLTOBuffer {
-  std::string data;
-  std::string thin_link_data;
-};
-
 extern "C" LLVMRustThinLTOBuffer *
 LLVMRustThinLTOBufferCreate(LLVMModuleRef M, bool is_thin, bool emit_summary) {
   auto Ret = std::make_unique<LLVMRustThinLTOBuffer>();
diff --git a/compiler/rustc_macros/src/lib.rs b/compiler/rustc_macros/src/lib.rs
index 0df674eb4c90..34fc0f00320c 100644
--- a/compiler/rustc_macros/src/lib.rs
+++ b/compiler/rustc_macros/src/lib.rs
@@ -17,6 +17,7 @@ mod diagnostics;
 mod extension;
 mod hash_stable;
 mod lift;
+mod print_attribute;
 mod query;
 mod serialize;
 mod symbols;
@@ -175,3 +176,11 @@ decl_derive! {
     /// The error type is `u32`.
     try_from::try_from_u32
 }
+decl_derive! {
+    [PrintAttribute] =>
+    /// Derives `PrintAttribute` for `AttributeKind`.
+    /// This macro is pretty specific to `rustc_attr_data_structures` and likely not that useful in
+    /// other places. It's deriving something close to `Debug` without printing some extraenous
+    /// things like spans.
+    print_attribute::print_attribute
+}
diff --git a/compiler/rustc_macros/src/print_attribute.rs b/compiler/rustc_macros/src/print_attribute.rs
new file mode 100644
index 000000000000..3c6e30b851bf
--- /dev/null
+++ b/compiler/rustc_macros/src/print_attribute.rs
@@ -0,0 +1,145 @@
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote, quote_spanned};
+use syn::spanned::Spanned;
+use syn::{Data, Fields, Ident};
+use synstructure::Structure;
+
+fn print_fields(name: &Ident, fields: &Fields) -> (TokenStream, TokenStream, TokenStream) {
+    let string_name = name.to_string();
+    let mut disps = vec![quote! {let mut __printed_anything = false;}];
+
+    match fields {
+        Fields::Named(fields_named) => {
+            let mut field_names = Vec::new();
+
+            for field in &fields_named.named {
+                let name = field.ident.as_ref().unwrap();
+                let string_name = name.to_string();
+                disps.push(quote! {
+                    if __printed_anything && #name.print_something() {
+                        __p.word_space(",");
+                        __printed_anything = true;
+                    }
+                    __p.word(#string_name);
+                    __p.word_space(":");
+                    #name.print_attribute(__p);
+                });
+                field_names.push(name);
+            }
+
+            (
+                quote! { {#(#field_names),*} },
+                quote! {
+                    __p.word(#string_name);
+                    if true #(&& !#field_names.print_something())* {
+                        return;
+                    }
+
+                    __p.word("{");
+                    #(#disps)*
+                    __p.word("}");
+                },
+                quote! { true },
+            )
+        }
+        Fields::Unnamed(fields_unnamed) => {
+            let mut field_names = Vec::new();
+
+            for idx in 0..fields_unnamed.unnamed.len() {
+                let name = format_ident!("f{idx}");
+                disps.push(quote! {
+                    if __printed_anything && #name.print_something() {
+                        __p.word_space(",");
+                        __printed_anything = true;
+                    }
+                    #name.print_attribute(__p);
+                });
+                field_names.push(name);
+            }
+
+            (
+                quote! { (#(#field_names),*) },
+                quote! {
+                    __p.word(#string_name);
+
+                    if true #(&& !#field_names.print_something())* {
+                        return;
+                    }
+
+                    __p.word("(");
+                    #(#disps)*
+                    __p.word(")");
+                },
+                quote! { true },
+            )
+        }
+        Fields::Unit => (quote! {}, quote! { __p.word(#string_name) }, quote! { true }),
+    }
+}
+
+pub(crate) fn print_attribute(input: Structure<'_>) -> TokenStream {
+    let span_error = |span, message: &str| {
+        quote_spanned! { span => const _: () = ::core::compile_error!(#message); }
+    };
+
+    // Must be applied to an enum type.
+    let (code, printed) = match &input.ast().data {
+        Data::Enum(e) => {
+            let (arms, printed) = e
+                .variants
+                .iter()
+                .map(|x| {
+                    let ident = &x.ident;
+                    let (pat, code, printed) = print_fields(ident, &x.fields);
+
+                    (
+                        quote! {
+                            Self::#ident #pat => {#code}
+                        },
+                        quote! {
+                            Self::#ident #pat => {#printed}
+                        },
+                    )
+                })
+                .unzip::<_, _, Vec<_>, Vec<_>>();
+
+            (
+                quote! {
+                    match self {
+                        #(#arms)*
+                    }
+                },
+                quote! {
+                    match self {
+                        #(#printed)*
+                    }
+                },
+            )
+        }
+        Data::Struct(s) => {
+            let (pat, code, printed) = print_fields(&input.ast().ident, &s.fields);
+            (
+                quote! {
+                    let Self #pat = self;
+                    #code
+                },
+                quote! {
+                    let Self #pat = self;
+                    #printed
+                },
+            )
+        }
+        Data::Union(u) => {
+            return span_error(u.union_token.span(), "can't derive PrintAttribute on unions");
+        }
+    };
+
+    #[allow(keyword_idents_2024)]
+    input.gen_impl(quote! {
+        #[allow(unused)]
+        gen impl PrintAttribute for @Self {
+            fn print_something(&self) -> bool { #printed }
+            fn print_attribute(&self, __p: &mut rustc_ast_pretty::pp::Printer) { #code }
+        }
+    })
+}
diff --git a/compiler/rustc_metadata/src/lib.rs b/compiler/rustc_metadata/src/lib.rs
index b817b4cb7b83..ebcc0efd5a67 100644
--- a/compiler/rustc_metadata/src/lib.rs
+++ b/compiler/rustc_metadata/src/lib.rs
@@ -5,7 +5,6 @@
 #![feature(coroutines)]
 #![feature(decl_macro)]
 #![feature(error_iter)]
-#![feature(extract_if)]
 #![feature(file_buffered)]
 #![feature(if_let_guard)]
 #![feature(iter_from_coroutine)]
diff --git a/compiler/rustc_metadata/src/locator.rs b/compiler/rustc_metadata/src/locator.rs
index 3f3e58384cbf..d5dd5059aacc 100644
--- a/compiler/rustc_metadata/src/locator.rs
+++ b/compiler/rustc_metadata/src/locator.rs
@@ -290,7 +290,7 @@ impl fmt::Display for CrateFlavor {
 }
 
 impl IntoDiagArg for CrateFlavor {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         match self {
             CrateFlavor::Rlib => DiagArgValue::Str(Cow::Borrowed("rlib")),
             CrateFlavor::Rmeta => DiagArgValue::Str(Cow::Borrowed("rmeta")),
diff --git a/compiler/rustc_metadata/src/native_libs.rs b/compiler/rustc_metadata/src/native_libs.rs
index 2a1e4b261e73..e2d043f47c0e 100644
--- a/compiler/rustc_metadata/src/native_libs.rs
+++ b/compiler/rustc_metadata/src/native_libs.rs
@@ -450,7 +450,7 @@ impl<'tcx> Collector<'tcx> {
                 (name, kind) = (wasm_import_module, Some(NativeLibKind::WasmImportModule));
             }
             let Some((name, name_span)) = name else {
-                sess.dcx().emit_err(errors::LinkRequiresName { span: m.span });
+                sess.dcx().emit_err(errors::LinkRequiresName { span: m.span() });
                 continue;
             };
 
@@ -485,7 +485,7 @@ impl<'tcx> Collector<'tcx> {
                             let link_ordinal_attr =
                                 self.tcx.get_attr(child_item, sym::link_ordinal).unwrap();
                             sess.dcx().emit_err(errors::LinkOrdinalRawDylib {
-                                span: link_ordinal_attr.span,
+                                span: link_ordinal_attr.span(),
                             });
                         }
                     }
diff --git a/compiler/rustc_metadata/src/rmeta/decoder.rs b/compiler/rustc_metadata/src/rmeta/decoder.rs
index 591c8ed50d57..e8d9d17872f7 100644
--- a/compiler/rustc_metadata/src/rmeta/decoder.rs
+++ b/compiler/rustc_metadata/src/rmeta/decoder.rs
@@ -1071,7 +1071,6 @@ impl<'a> CrateMetadataRef<'a> {
         let attrs: Vec<_> = self.get_item_attrs(id, sess).collect();
         SyntaxExtension::new(
             sess,
-            tcx.features(),
             kind,
             self.get_span(id, sess),
             helper_attrs,
@@ -1117,7 +1116,6 @@ impl<'a> CrateMetadataRef<'a> {
                         value: self.get_default_field(did.index),
                     })
                     .collect(),
-                adt_kind,
                 parent_did,
                 None,
                 data.is_non_exhaustive,
diff --git a/compiler/rustc_middle/src/error.rs b/compiler/rustc_middle/src/error.rs
index be8a3403ba95..bd315577efb5 100644
--- a/compiler/rustc_middle/src/error.rs
+++ b/compiler/rustc_middle/src/error.rs
@@ -47,10 +47,10 @@ pub struct UnsupportedUnion {
 // FIXME(autodiff): I should get used somewhere
 #[derive(Diagnostic)]
 #[diag(middle_autodiff_unsafe_inner_const_ref)]
-pub struct AutodiffUnsafeInnerConstRef {
+pub struct AutodiffUnsafeInnerConstRef<'tcx> {
     #[primary_span]
     pub span: Span,
-    pub ty: String,
+    pub ty: Ty<'tcx>,
 }
 
 #[derive(Subdiagnostic)]
diff --git a/compiler/rustc_middle/src/lib.rs b/compiler/rustc_middle/src/lib.rs
index 93a7227d65ee..48ea7df5c23f 100644
--- a/compiler/rustc_middle/src/lib.rs
+++ b/compiler/rustc_middle/src/lib.rs
@@ -44,7 +44,6 @@
 #![feature(decl_macro)]
 #![feature(discriminant_kind)]
 #![feature(extern_types)]
-#![feature(extract_if)]
 #![feature(file_buffered)]
 #![feature(if_let_guard)]
 #![feature(intra_doc_pointers)]
diff --git a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
index 2f13f9635785..82fb5f33b4c8 100644
--- a/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
+++ b/compiler/rustc_middle/src/mir/interpret/allocation/provenance_map.rs
@@ -2,6 +2,7 @@
 //! representation for the common case where PTR_SIZE consecutive bytes have the same provenance.
 
 use std::cmp;
+use std::ops::Range;
 
 use rustc_abi::{HasDataLayout, Size};
 use rustc_data_structures::sorted_map::SortedMap;
@@ -66,6 +67,15 @@ impl ProvenanceMap {
 }
 
 impl<Prov: Provenance> ProvenanceMap<Prov> {
+    fn adjusted_range(range: AllocRange, cx: &impl HasDataLayout) -> Range<Size> {
+        // We have to go back `pointer_size - 1` bytes, as that one would still overlap with
+        // the beginning of this range.
+        let adjusted_start = Size::from_bytes(
+            range.start.bytes().saturating_sub(cx.data_layout().pointer_size.bytes() - 1),
+        );
+        adjusted_start..range.end()
+    }
+
     /// Returns all ptr-sized provenance in the given range.
     /// If the range has length 0, returns provenance that crosses the edge between `start-1` and
     /// `start`.
@@ -74,12 +84,17 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
         range: AllocRange,
         cx: &impl HasDataLayout,
     ) -> &[(Size, Prov)] {
-        // We have to go back `pointer_size - 1` bytes, as that one would still overlap with
-        // the beginning of this range.
-        let adjusted_start = Size::from_bytes(
-            range.start.bytes().saturating_sub(cx.data_layout().pointer_size.bytes() - 1),
-        );
-        self.ptrs.range(adjusted_start..range.end())
+        self.ptrs.range(Self::adjusted_range(range, cx))
+    }
+
+    /// `pm.range_get_ptrs_is_empty(r, cx)` == `pm.range_get_ptrs(r, cx).is_empty()`, but is
+    /// faster.
+    pub(super) fn range_get_ptrs_is_empty(
+        &self,
+        range: AllocRange,
+        cx: &impl HasDataLayout,
+    ) -> bool {
+        self.ptrs.range_is_empty(Self::adjusted_range(range, cx))
     }
 
     /// Returns all byte-wise provenance in the given range.
@@ -117,7 +132,7 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
     /// limit access to provenance outside of the `Allocation` abstraction.
     ///
     pub fn range_empty(&self, range: AllocRange, cx: &impl HasDataLayout) -> bool {
-        self.range_get_ptrs(range, cx).is_empty() && self.range_get_bytes(range).is_empty()
+        self.range_get_ptrs_is_empty(range, cx) && self.range_get_bytes(range).is_empty()
     }
 
     /// Yields all the provenances stored in this map.
@@ -149,12 +164,14 @@ impl<Prov: Provenance> ProvenanceMap<Prov> {
         // provenance that overlaps with the given range.
         let (first, last) = {
             // Find all provenance overlapping the given range.
-            let provenance = self.range_get_ptrs(range, cx);
-            if provenance.is_empty() {
-                // No provenance in this range, we are done.
+            if self.range_get_ptrs_is_empty(range, cx) {
+                // No provenance in this range, we are done. This is the common case.
                 return Ok(());
             }
 
+            // This redoes some of the work of `range_get_ptrs_is_empty`, but this path is much
+            // colder than the early return above, so it's worth it.
+            let provenance = self.range_get_ptrs(range, cx);
             (
                 provenance.first().unwrap().0,
                 provenance.last().unwrap().0 + cx.data_layout().pointer_size,
diff --git a/compiler/rustc_middle/src/mir/interpret/error.rs b/compiler/rustc_middle/src/mir/interpret/error.rs
index 743812e3a20a..890756a17cae 100644
--- a/compiler/rustc_middle/src/mir/interpret/error.rs
+++ b/compiler/rustc_middle/src/mir/interpret/error.rs
@@ -248,7 +248,7 @@ pub enum InvalidMetaKind {
 }
 
 impl IntoDiagArg for InvalidMetaKind {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(match self {
             InvalidMetaKind::SliceTooBig => "slice_too_big",
             InvalidMetaKind::TooBig => "too_big",
@@ -282,7 +282,7 @@ pub struct Misalignment {
 macro_rules! impl_into_diag_arg_through_debug {
     ($($ty:ty),*$(,)?) => {$(
         impl IntoDiagArg for $ty {
-            fn into_diag_arg(self) -> DiagArgValue {
+            fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
                 DiagArgValue::Str(Cow::Owned(format!("{self:?}")))
             }
         }
@@ -401,7 +401,7 @@ pub enum PointerKind {
 }
 
 impl IntoDiagArg for PointerKind {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(
             match self {
                 Self::Ref(_) => "ref",
@@ -666,7 +666,7 @@ macro_rules! err_ub_custom {
                 msg: || $msg,
                 add_args: Box::new(move |mut set_arg| {
                     $($(
-                        set_arg(stringify!($name).into(), rustc_errors::IntoDiagArg::into_diag_arg($name));
+                        set_arg(stringify!($name).into(), rustc_errors::IntoDiagArg::into_diag_arg($name, &mut None));
                     )*)?
                 })
             }
diff --git a/compiler/rustc_middle/src/mir/mod.rs b/compiler/rustc_middle/src/mir/mod.rs
index cf90df1b198b..ea0bb5feb122 100644
--- a/compiler/rustc_middle/src/mir/mod.rs
+++ b/compiler/rustc_middle/src/mir/mod.rs
@@ -96,6 +96,17 @@ impl<'tcx> HasLocalDecls<'tcx> for Body<'tcx> {
 }
 
 impl MirPhase {
+    pub fn name(&self) -> &'static str {
+        match *self {
+            MirPhase::Built => "built",
+            MirPhase::Analysis(AnalysisPhase::Initial) => "analysis",
+            MirPhase::Analysis(AnalysisPhase::PostCleanup) => "analysis-post-cleanup",
+            MirPhase::Runtime(RuntimePhase::Initial) => "runtime",
+            MirPhase::Runtime(RuntimePhase::PostCleanup) => "runtime-post-cleanup",
+            MirPhase::Runtime(RuntimePhase::Optimized) => "runtime-optimized",
+        }
+    }
+
     /// Gets the (dialect, phase) index of the current `MirPhase`. Both numbers
     /// are 1-indexed.
     pub fn index(&self) -> (usize, usize) {
diff --git a/compiler/rustc_middle/src/mir/pretty.rs b/compiler/rustc_middle/src/mir/pretty.rs
index 875f5282bf29..f880b1364c2c 100644
--- a/compiler/rustc_middle/src/mir/pretty.rs
+++ b/compiler/rustc_middle/src/mir/pretty.rs
@@ -319,6 +319,7 @@ pub fn write_mir_pretty<'tcx>(
 
     writeln!(w, "// WARNING: This output format is intended for human consumers only")?;
     writeln!(w, "// and is subject to change without notice. Knock yourself out.")?;
+    writeln!(w, "// HINT: See also -Z dump-mir for MIR at specific points during compilation.")?;
 
     let mut first = true;
     for def_id in dump_mir_def_ids(tcx, single) {
diff --git a/compiler/rustc_middle/src/mir/statement.rs b/compiler/rustc_middle/src/mir/statement.rs
index 595a5e548b01..f05a798949b7 100644
--- a/compiler/rustc_middle/src/mir/statement.rs
+++ b/compiler/rustc_middle/src/mir/statement.rs
@@ -25,6 +25,26 @@ impl Statement<'_> {
 }
 
 impl<'tcx> StatementKind<'tcx> {
+    /// Returns a simple string representation of a `StatementKind` variant, independent of any
+    /// values it might hold (e.g. `StatementKind::Assign` always returns `"Assign"`).
+    pub const fn name(&self) -> &'static str {
+        match self {
+            StatementKind::Assign(..) => "Assign",
+            StatementKind::FakeRead(..) => "FakeRead",
+            StatementKind::SetDiscriminant { .. } => "SetDiscriminant",
+            StatementKind::Deinit(..) => "Deinit",
+            StatementKind::StorageLive(..) => "StorageLive",
+            StatementKind::StorageDead(..) => "StorageDead",
+            StatementKind::Retag(..) => "Retag",
+            StatementKind::PlaceMention(..) => "PlaceMention",
+            StatementKind::AscribeUserType(..) => "AscribeUserType",
+            StatementKind::Coverage(..) => "Coverage",
+            StatementKind::Intrinsic(..) => "Intrinsic",
+            StatementKind::ConstEvalCounter => "ConstEvalCounter",
+            StatementKind::Nop => "Nop",
+            StatementKind::BackwardIncompatibleDropHint { .. } => "BackwardIncompatibleDropHint",
+        }
+    }
     pub fn as_assign_mut(&mut self) -> Option<&mut (Place<'tcx>, Rvalue<'tcx>)> {
         match self {
             StatementKind::Assign(x) => Some(x),
@@ -862,3 +882,40 @@ impl<'tcx> BinOp {
         })
     }
 }
+
+impl From<Mutability> for RawPtrKind {
+    fn from(other: Mutability) -> Self {
+        match other {
+            Mutability::Mut => RawPtrKind::Mut,
+            Mutability::Not => RawPtrKind::Const,
+        }
+    }
+}
+
+impl RawPtrKind {
+    pub fn is_fake(self) -> bool {
+        match self {
+            RawPtrKind::Mut | RawPtrKind::Const => false,
+            RawPtrKind::FakeForPtrMetadata => true,
+        }
+    }
+
+    pub fn to_mutbl_lossy(self) -> Mutability {
+        match self {
+            RawPtrKind::Mut => Mutability::Mut,
+            RawPtrKind::Const => Mutability::Not,
+
+            // We have no type corresponding to a fake borrow, so use
+            // `*const` as an approximation.
+            RawPtrKind::FakeForPtrMetadata => Mutability::Not,
+        }
+    }
+
+    pub fn ptr_str(self) -> &'static str {
+        match self {
+            RawPtrKind::Mut => "mut",
+            RawPtrKind::Const => "const",
+            RawPtrKind::FakeForPtrMetadata => "const (fake)",
+        }
+    }
+}
diff --git a/compiler/rustc_middle/src/mir/syntax.rs b/compiler/rustc_middle/src/mir/syntax.rs
index af6f0e4c5518..4f86703e9537 100644
--- a/compiler/rustc_middle/src/mir/syntax.rs
+++ b/compiler/rustc_middle/src/mir/syntax.rs
@@ -97,19 +97,6 @@ pub enum MirPhase {
     Runtime(RuntimePhase),
 }
 
-impl MirPhase {
-    pub fn name(&self) -> &'static str {
-        match *self {
-            MirPhase::Built => "built",
-            MirPhase::Analysis(AnalysisPhase::Initial) => "analysis",
-            MirPhase::Analysis(AnalysisPhase::PostCleanup) => "analysis-post-cleanup",
-            MirPhase::Runtime(RuntimePhase::Initial) => "runtime",
-            MirPhase::Runtime(RuntimePhase::PostCleanup) => "runtime-post-cleanup",
-            MirPhase::Runtime(RuntimePhase::Optimized) => "runtime-optimized",
-        }
-    }
-}
-
 /// See [`MirPhase::Analysis`].
 #[derive(Copy, Clone, TyEncodable, TyDecodable, Debug, PartialEq, Eq, PartialOrd, Ord)]
 #[derive(HashStable)]
@@ -206,43 +193,6 @@ pub enum RawPtrKind {
     FakeForPtrMetadata,
 }
 
-impl From<Mutability> for RawPtrKind {
-    fn from(other: Mutability) -> Self {
-        match other {
-            Mutability::Mut => RawPtrKind::Mut,
-            Mutability::Not => RawPtrKind::Const,
-        }
-    }
-}
-
-impl RawPtrKind {
-    pub fn is_fake(self) -> bool {
-        match self {
-            RawPtrKind::Mut | RawPtrKind::Const => false,
-            RawPtrKind::FakeForPtrMetadata => true,
-        }
-    }
-
-    pub fn to_mutbl_lossy(self) -> Mutability {
-        match self {
-            RawPtrKind::Mut => Mutability::Mut,
-            RawPtrKind::Const => Mutability::Not,
-
-            // We have no type corresponding to a fake borrow, so use
-            // `*const` as an approximation.
-            RawPtrKind::FakeForPtrMetadata => Mutability::Not,
-        }
-    }
-
-    pub fn ptr_str(self) -> &'static str {
-        match self {
-            RawPtrKind::Mut => "mut",
-            RawPtrKind::Const => "const",
-            RawPtrKind::FakeForPtrMetadata => "const (fake)",
-        }
-    }
-}
-
 #[derive(Copy, Clone, Debug, PartialEq, Eq, PartialOrd, Ord, TyEncodable, TyDecodable)]
 #[derive(Hash, HashStable)]
 pub enum MutBorrowKind {
@@ -515,29 +465,6 @@ pub enum StatementKind<'tcx> {
     },
 }
 
-impl StatementKind<'_> {
-    /// Returns a simple string representation of a `StatementKind` variant, independent of any
-    /// values it might hold (e.g. `StatementKind::Assign` always returns `"Assign"`).
-    pub const fn name(&self) -> &'static str {
-        match self {
-            StatementKind::Assign(..) => "Assign",
-            StatementKind::FakeRead(..) => "FakeRead",
-            StatementKind::SetDiscriminant { .. } => "SetDiscriminant",
-            StatementKind::Deinit(..) => "Deinit",
-            StatementKind::StorageLive(..) => "StorageLive",
-            StatementKind::StorageDead(..) => "StorageDead",
-            StatementKind::Retag(..) => "Retag",
-            StatementKind::PlaceMention(..) => "PlaceMention",
-            StatementKind::AscribeUserType(..) => "AscribeUserType",
-            StatementKind::Coverage(..) => "Coverage",
-            StatementKind::Intrinsic(..) => "Intrinsic",
-            StatementKind::ConstEvalCounter => "ConstEvalCounter",
-            StatementKind::Nop => "Nop",
-            StatementKind::BackwardIncompatibleDropHint { .. } => "BackwardIncompatibleDropHint",
-        }
-    }
-}
-
 #[derive(
     Clone,
     TyEncodable,
@@ -673,12 +600,6 @@ pub enum CallSource {
     Normal,
 }
 
-impl CallSource {
-    pub fn from_hir_call(self) -> bool {
-        matches!(self, CallSource::Normal)
-    }
-}
-
 #[derive(Clone, Copy, Debug, TyEncodable, TyDecodable, Hash, HashStable, PartialEq)]
 #[derive(TypeFoldable, TypeVisitable)]
 /// The macro that an inline assembly block was created by
@@ -689,15 +610,6 @@ pub enum InlineAsmMacro {
     NakedAsm,
 }
 
-impl InlineAsmMacro {
-    pub const fn diverges(self, options: InlineAsmOptions) -> bool {
-        match self {
-            InlineAsmMacro::Asm => options.contains(InlineAsmOptions::NORETURN),
-            InlineAsmMacro::NakedAsm => true,
-        }
-    }
-}
-
 ///////////////////////////////////////////////////////////////////////////
 // Terminators
 
@@ -999,30 +911,6 @@ pub enum BackwardIncompatibleDropReason {
     Edition2024,
 }
 
-impl TerminatorKind<'_> {
-    /// Returns a simple string representation of a `TerminatorKind` variant, independent of any
-    /// values it might hold (e.g. `TerminatorKind::Call` always returns `"Call"`).
-    pub const fn name(&self) -> &'static str {
-        match self {
-            TerminatorKind::Goto { .. } => "Goto",
-            TerminatorKind::SwitchInt { .. } => "SwitchInt",
-            TerminatorKind::UnwindResume => "UnwindResume",
-            TerminatorKind::UnwindTerminate(_) => "UnwindTerminate",
-            TerminatorKind::Return => "Return",
-            TerminatorKind::Unreachable => "Unreachable",
-            TerminatorKind::Drop { .. } => "Drop",
-            TerminatorKind::Call { .. } => "Call",
-            TerminatorKind::TailCall { .. } => "TailCall",
-            TerminatorKind::Assert { .. } => "Assert",
-            TerminatorKind::Yield { .. } => "Yield",
-            TerminatorKind::CoroutineDrop => "CoroutineDrop",
-            TerminatorKind::FalseEdge { .. } => "FalseEdge",
-            TerminatorKind::FalseUnwind { .. } => "FalseUnwind",
-            TerminatorKind::InlineAsm { .. } => "InlineAsm",
-        }
-    }
-}
-
 #[derive(Debug, Clone, TyEncodable, TyDecodable, Hash, HashStable, PartialEq)]
 pub struct SwitchTargets {
     /// Possible values. For each value, the location to branch to is found in
diff --git a/compiler/rustc_middle/src/mir/terminator.rs b/compiler/rustc_middle/src/mir/terminator.rs
index fdfcb128778a..bc77f22af67b 100644
--- a/compiler/rustc_middle/src/mir/terminator.rs
+++ b/compiler/rustc_middle/src/mir/terminator.rs
@@ -2,12 +2,13 @@
 
 use std::slice;
 
+use rustc_ast::InlineAsmOptions;
 use rustc_data_structures::packed::Pu128;
 use rustc_hir::LangItem;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
 use smallvec::{SmallVec, smallvec};
 
-use super::{TerminatorKind, *};
+use super::*;
 
 impl SwitchTargets {
     /// Creates switch targets from an iterator of values and target blocks.
@@ -356,7 +357,7 @@ impl<O> AssertKind<O> {
 
         macro_rules! add {
             ($name: expr, $value: expr) => {
-                adder($name.into(), $value.into_diag_arg());
+                adder($name.into(), $value.into_diag_arg(&mut None));
             };
         }
 
@@ -414,6 +415,28 @@ impl<'tcx> Terminator<'tcx> {
 }
 
 impl<'tcx> TerminatorKind<'tcx> {
+    /// Returns a simple string representation of a `TerminatorKind` variant, independent of any
+    /// values it might hold (e.g. `TerminatorKind::Call` always returns `"Call"`).
+    pub const fn name(&self) -> &'static str {
+        match self {
+            TerminatorKind::Goto { .. } => "Goto",
+            TerminatorKind::SwitchInt { .. } => "SwitchInt",
+            TerminatorKind::UnwindResume => "UnwindResume",
+            TerminatorKind::UnwindTerminate(_) => "UnwindTerminate",
+            TerminatorKind::Return => "Return",
+            TerminatorKind::Unreachable => "Unreachable",
+            TerminatorKind::Drop { .. } => "Drop",
+            TerminatorKind::Call { .. } => "Call",
+            TerminatorKind::TailCall { .. } => "TailCall",
+            TerminatorKind::Assert { .. } => "Assert",
+            TerminatorKind::Yield { .. } => "Yield",
+            TerminatorKind::CoroutineDrop => "CoroutineDrop",
+            TerminatorKind::FalseEdge { .. } => "FalseEdge",
+            TerminatorKind::FalseUnwind { .. } => "FalseUnwind",
+            TerminatorKind::InlineAsm { .. } => "InlineAsm",
+        }
+    }
+
     #[inline]
     pub fn if_(cond: Operand<'tcx>, t: BasicBlock, f: BasicBlock) -> TerminatorKind<'tcx> {
         TerminatorKind::SwitchInt { discr: cond, targets: SwitchTargets::static_if(0, f, t) }
@@ -698,3 +721,18 @@ impl<'tcx> TerminatorKind<'tcx> {
         }
     }
 }
+
+impl CallSource {
+    pub fn from_hir_call(self) -> bool {
+        matches!(self, CallSource::Normal)
+    }
+}
+
+impl InlineAsmMacro {
+    pub const fn diverges(self, options: InlineAsmOptions) -> bool {
+        match self {
+            InlineAsmMacro::Asm => options.contains(InlineAsmOptions::NORETURN),
+            InlineAsmMacro::NakedAsm => true,
+        }
+    }
+}
diff --git a/compiler/rustc_middle/src/query/mod.rs b/compiler/rustc_middle/src/query/mod.rs
index 7c4ea06a7461..1302027aabb3 100644
--- a/compiler/rustc_middle/src/query/mod.rs
+++ b/compiler/rustc_middle/src/query/mod.rs
@@ -143,11 +143,11 @@ rustc_queries! {
 
     /// Represents crate as a whole (as distinct from the top-level crate module).
     ///
-    /// If you call `hir_crate` (e.g., indirectly by calling `tcx.hir().krate()`),
+    /// If you call `hir_crate` (e.g., indirectly by calling `tcx.hir_crate()`),
     /// we will have to assume that any change means that you need to be recompiled.
     /// This is because the `hir_crate` query gives you access to all other items.
-    /// To avoid this fate, do not call `tcx.hir().krate()`; instead,
-    /// prefer wrappers like `tcx.visit_all_items_in_krate()`.
+    /// To avoid this fate, do not call `tcx.hir_crate()`; instead,
+    /// prefer wrappers like [`TyCtxt::hir_visit_all_item_likes_in_crate`].
     query hir_crate(key: ()) -> &'tcx Crate<'tcx> {
         arena_cache
         eval_always
@@ -748,6 +748,15 @@ rustc_queries! {
         }
     }
 
+    /// Compute the conditions that need to hold for a conditionally-const item to be const.
+    /// That is, compute the set of `~const` where clauses for a given item.
+    ///
+    /// This can be thought of as the `~const` equivalent of `predicates_of`. These are the
+    /// predicates that need to be proven at usage sites, and can be assumed at definition.
+    ///
+    /// This query also computes the `~const` where clauses for associated types, which are
+    /// not "const", but which have item bounds which may be `~const`. These must hold for
+    /// the `~const` item bound to hold.
     query const_conditions(
         key: DefId
     ) -> ty::ConstConditions<'tcx> {
@@ -757,6 +766,11 @@ rustc_queries! {
         separate_provide_extern
     }
 
+    /// Compute the const bounds that are implied for a conditionally-const item.
+    ///
+    /// This can be though of as the `~const` equivalent of `explicit_item_bounds`. These
+    /// are the predicates that need to proven at definition sites, and can be assumed at
+    /// usage sites.
     query explicit_implied_const_bounds(
         key: DefId
     ) -> ty::EarlyBinder<'tcx, &'tcx [(ty::PolyTraitRef<'tcx>, Span)]> {
diff --git a/compiler/rustc_middle/src/query/plumbing.rs b/compiler/rustc_middle/src/query/plumbing.rs
index 690b8128b1ae..66a9e5fed4c3 100644
--- a/compiler/rustc_middle/src/query/plumbing.rs
+++ b/compiler/rustc_middle/src/query/plumbing.rs
@@ -258,7 +258,7 @@ macro_rules! query_if_arena {
     };
 }
 
-/// If `separate_provide_if_extern`, then the key can be projected to its
+/// If `separate_provide_extern`, then the key can be projected to its
 /// local key via `<$K as AsLocalKey>::LocalKey`.
 macro_rules! local_key_if_separate_extern {
     ([] $($K:tt)*) => {
diff --git a/compiler/rustc_middle/src/traits/specialization_graph.rs b/compiler/rustc_middle/src/traits/specialization_graph.rs
index ed7c98ee0e01..9ce5373b0311 100644
--- a/compiler/rustc_middle/src/traits/specialization_graph.rs
+++ b/compiler/rustc_middle/src/traits/specialization_graph.rs
@@ -75,7 +75,7 @@ impl OverlapMode {
                         tcx.hir().attrs(tcx.local_def_id_to_hir_id(local_def_id))
                     })
                     .find(|attr| attr.has_name(sym::rustc_strict_coherence))
-                    .map(|attr| attr.span);
+                    .map(|attr| attr.span());
                 tcx.dcx().emit_err(StrictCoherenceNeedsNegativeCoherence {
                     span: tcx.def_span(trait_id),
                     attr_span,
diff --git a/compiler/rustc_middle/src/ty/codec.rs b/compiler/rustc_middle/src/ty/codec.rs
index 41958949836a..fe42a224d9f2 100644
--- a/compiler/rustc_middle/src/ty/codec.rs
+++ b/compiler/rustc_middle/src/ty/codec.rs
@@ -224,7 +224,7 @@ impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for Ty<'tcx> {
             })
         } else {
             let tcx = decoder.interner();
-            tcx.mk_ty_from_kind(rustc_type_ir::TyKind::decode(decoder))
+            tcx.mk_ty_from_kind(ty::TyKind::decode(decoder))
         }
     }
 }
diff --git a/compiler/rustc_middle/src/ty/consts/int.rs b/compiler/rustc_middle/src/ty/consts/int.rs
index b72edc1c5325..7c9280fae16d 100644
--- a/compiler/rustc_middle/src/ty/consts/int.rs
+++ b/compiler/rustc_middle/src/ty/consts/int.rs
@@ -118,7 +118,7 @@ impl std::fmt::Debug for ConstInt {
 impl IntoDiagArg for ConstInt {
     // FIXME this simply uses the Debug impl, but we could probably do better by converting both
     // to an inherent method that returns `Cow`.
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(format!("{self:?}").into())
     }
 }
diff --git a/compiler/rustc_middle/src/ty/context.rs b/compiler/rustc_middle/src/ty/context.rs
index 238ba127e2ec..d0aa2b8cbdad 100644
--- a/compiler/rustc_middle/src/ty/context.rs
+++ b/compiler/rustc_middle/src/ty/context.rs
@@ -324,11 +324,11 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.features()
     }
 
-    fn bound_coroutine_hidden_types(
+    fn coroutine_hidden_types(
         self,
         def_id: DefId,
-    ) -> impl IntoIterator<Item = ty::EarlyBinder<'tcx, ty::Binder<'tcx, Ty<'tcx>>>> {
-        self.bound_coroutine_hidden_types(def_id)
+    ) -> ty::EarlyBinder<'tcx, ty::Binder<'tcx, &'tcx ty::List<Ty<'tcx>>>> {
+        self.coroutine_hidden_types(def_id)
     }
 
     fn fn_sig(self, def_id: DefId) -> ty::EarlyBinder<'tcx, ty::PolyFnSig<'tcx>> {
@@ -594,6 +594,10 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
         self.trait_is_auto(trait_def_id)
     }
 
+    fn trait_is_coinductive(self, trait_def_id: DefId) -> bool {
+        self.trait_is_coinductive(trait_def_id)
+    }
+
     fn trait_is_alias(self, trait_def_id: DefId) -> bool {
         self.trait_is_alias(trait_def_id)
     }
@@ -812,32 +816,38 @@ pub struct CtxtInterners<'tcx> {
 
 impl<'tcx> CtxtInterners<'tcx> {
     fn new(arena: &'tcx WorkerLocal<Arena<'tcx>>) -> CtxtInterners<'tcx> {
+        // Default interner size - this value has been chosen empirically, and may need to be adjusted
+        // as the compiler evolves.
+        const N: usize = 2048;
         CtxtInterners {
             arena,
-            type_: Default::default(),
-            const_lists: Default::default(),
-            args: Default::default(),
-            type_lists: Default::default(),
-            region: Default::default(),
-            poly_existential_predicates: Default::default(),
-            canonical_var_infos: Default::default(),
-            predicate: Default::default(),
-            clauses: Default::default(),
-            projs: Default::default(),
-            place_elems: Default::default(),
-            const_: Default::default(),
-            pat: Default::default(),
-            const_allocation: Default::default(),
-            bound_variable_kinds: Default::default(),
-            layout: Default::default(),
-            adt_def: Default::default(),
-            external_constraints: Default::default(),
-            predefined_opaques_in_body: Default::default(),
-            fields: Default::default(),
-            local_def_ids: Default::default(),
-            captures: Default::default(),
-            offset_of: Default::default(),
-            valtree: Default::default(),
+            // The factors have been chosen by @FractalFir based on observed interner sizes, and local perf runs.
+            // To get the interner sizes, insert `eprintln` printing the size of the interner in functions like `intern_ty`.
+            // Bigger benchmarks tend to give more accurate ratios, so use something like `x perf eprintln --includes cargo`.
+            type_: InternedSet::with_capacity(N * 16),
+            const_lists: InternedSet::with_capacity(N * 4),
+            args: InternedSet::with_capacity(N * 4),
+            type_lists: InternedSet::with_capacity(N * 4),
+            region: InternedSet::with_capacity(N * 4),
+            poly_existential_predicates: InternedSet::with_capacity(N / 4),
+            canonical_var_infos: InternedSet::with_capacity(N / 2),
+            predicate: InternedSet::with_capacity(N),
+            clauses: InternedSet::with_capacity(N),
+            projs: InternedSet::with_capacity(N * 4),
+            place_elems: InternedSet::with_capacity(N * 2),
+            const_: InternedSet::with_capacity(N * 2),
+            pat: InternedSet::with_capacity(N),
+            const_allocation: InternedSet::with_capacity(N),
+            bound_variable_kinds: InternedSet::with_capacity(N * 2),
+            layout: InternedSet::with_capacity(N),
+            adt_def: InternedSet::with_capacity(N),
+            external_constraints: InternedSet::with_capacity(N),
+            predefined_opaques_in_body: InternedSet::with_capacity(N),
+            fields: InternedSet::with_capacity(N * 4),
+            local_def_ids: InternedSet::with_capacity(N),
+            captures: InternedSet::with_capacity(N),
+            offset_of: InternedSet::with_capacity(N),
+            valtree: InternedSet::with_capacity(N),
         }
     }
 
@@ -1542,7 +1552,7 @@ impl<'tcx> TyCtxt<'tcx> {
                 Bound::Included(a.get())
             } else {
                 self.dcx().span_delayed_bug(
-                    attr.span,
+                    attr.span(),
                     "invalid rustc_layout_scalar_valid_range attribute",
                 );
                 Bound::Unbounded
diff --git a/compiler/rustc_middle/src/ty/diagnostics.rs b/compiler/rustc_middle/src/ty/diagnostics.rs
index cb218a27e623..881381a5ee61 100644
--- a/compiler/rustc_middle/src/ty/diagnostics.rs
+++ b/compiler/rustc_middle/src/ty/diagnostics.rs
@@ -19,8 +19,16 @@ use crate::ty::{
     TypeSuperVisitable, TypeVisitable, TypeVisitor,
 };
 
+impl IntoDiagArg for Ty<'_> {
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
+        ty::tls::with(|tcx| {
+            let ty = tcx.short_string(self, path);
+            rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(ty))
+        })
+    }
+}
+
 into_diag_arg_using_display! {
-    Ty<'_>,
     ty::Region<'_>,
 }
 
diff --git a/compiler/rustc_middle/src/ty/error.rs b/compiler/rustc_middle/src/ty/error.rs
index 8c1991ddb36e..a0e67929c528 100644
--- a/compiler/rustc_middle/src/ty/error.rs
+++ b/compiler/rustc_middle/src/ty/error.rs
@@ -213,10 +213,9 @@ impl<'tcx> Ty<'tcx> {
 }
 
 impl<'tcx> TyCtxt<'tcx> {
-    pub fn string_with_limit<'a, T>(self, p: T, length_limit: usize) -> String
+    pub fn string_with_limit<T>(self, p: T, length_limit: usize) -> String
     where
-        T: Print<'tcx, FmtPrinter<'a, 'tcx>> + Lift<TyCtxt<'tcx>> + Copy,
-        <T as Lift<TyCtxt<'tcx>>>::Lifted: Print<'tcx, FmtPrinter<'a, 'tcx>>,
+        T: Copy + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
     {
         let mut type_limit = 50;
         let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |cx| {
@@ -253,10 +252,9 @@ impl<'tcx> TyCtxt<'tcx> {
     /// `tcx.short_string(ty, diag.long_ty_path())`. The diagnostic itself is the one that keeps
     /// the existence of a "long type" anywhere in the diagnostic, so the note telling the user
     /// where we wrote the file to is only printed once.
-    pub fn short_string<'a, T>(self, p: T, path: &mut Option<PathBuf>) -> String
+    pub fn short_string<T>(self, p: T, path: &mut Option<PathBuf>) -> String
     where
-        T: Print<'tcx, FmtPrinter<'a, 'tcx>> + Lift<TyCtxt<'tcx>> + Copy + Hash,
-        <T as Lift<TyCtxt<'tcx>>>::Lifted: Print<'tcx, FmtPrinter<'a, 'tcx>>,
+        T: Copy + Hash + for<'a, 'b> Lift<TyCtxt<'b>, Lifted: Print<'b, FmtPrinter<'a, 'b>>>,
     {
         let regular = FmtPrinter::print_string(self, hir::def::Namespace::TypeNS, |cx| {
             self.lift(p).expect("could not lift for printing").print(cx)
diff --git a/compiler/rustc_middle/src/ty/generic_args.rs b/compiler/rustc_middle/src/ty/generic_args.rs
index ed0b3059d752..27576a2ec4a2 100644
--- a/compiler/rustc_middle/src/ty/generic_args.rs
+++ b/compiler/rustc_middle/src/ty/generic_args.rs
@@ -159,8 +159,8 @@ unsafe impl<'tcx> Sync for GenericArg<'tcx> where
 }
 
 impl<'tcx> IntoDiagArg for GenericArg<'tcx> {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_string().into_diag_arg(&mut None)
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/instance.rs b/compiler/rustc_middle/src/ty/instance.rs
index e9c19331e4a0..98ca71b86be0 100644
--- a/compiler/rustc_middle/src/ty/instance.rs
+++ b/compiler/rustc_middle/src/ty/instance.rs
@@ -111,8 +111,9 @@ pub enum InstanceKind<'tcx> {
 
     /// Dynamic dispatch to `<dyn Trait as Trait>::fn`.
     ///
-    /// This `InstanceKind` does not have callable MIR. Calls to `Virtual` instances must be
-    /// codegen'd as virtual calls through the vtable.
+    /// This `InstanceKind` may have a callable MIR as the default implementation.
+    /// Calls to `Virtual` instances must be codegen'd as virtual calls through the vtable.
+    /// *This means we might not know exactly what is being called.*
     ///
     /// If this is reified to a `fn` pointer, a `ReifyShim` is used (see `ReifyShim` above for more
     /// details on that).
diff --git a/compiler/rustc_middle/src/ty/layout.rs b/compiler/rustc_middle/src/ty/layout.rs
index eb14ed20fbac..272bb0cc915f 100644
--- a/compiler/rustc_middle/src/ty/layout.rs
+++ b/compiler/rustc_middle/src/ty/layout.rs
@@ -315,8 +315,8 @@ impl<'tcx> fmt::Display for LayoutError<'tcx> {
 }
 
 impl<'tcx> IntoDiagArg for LayoutError<'tcx> {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_string().into_diag_arg(&mut None)
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/mod.rs b/compiler/rustc_middle/src/ty/mod.rs
index 8ed5a118093f..527509af05fc 100644
--- a/compiler/rustc_middle/src/ty/mod.rs
+++ b/compiler/rustc_middle/src/ty/mod.rs
@@ -27,6 +27,7 @@ pub use intrinsic::IntrinsicDef;
 use rustc_abi::{Align, FieldIdx, Integer, IntegerType, ReprFlags, ReprOptions, VariantIdx};
 use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::node_id::NodeMap;
+use rustc_attr_parsing::AttributeKind;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_data_structures::intern::Interned;
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
@@ -47,7 +48,7 @@ pub use rustc_session::lint::RegisteredTools;
 use rustc_span::hygiene::MacroKind;
 use rustc_span::{ExpnId, ExpnKind, Ident, Span, Symbol, kw, sym};
 pub use rustc_type_ir::relate::VarianceDiagInfo;
-pub use rustc_type_ir::{Movability, Mutability, *};
+pub use rustc_type_ir::*;
 use tracing::{debug, instrument};
 pub use vtable::*;
 use {rustc_ast as ast, rustc_attr_parsing as attr, rustc_hir as hir};
@@ -121,6 +122,7 @@ pub mod normalize_erasing_regions;
 pub mod pattern;
 pub mod print;
 pub mod relate;
+pub mod significant_drop_order;
 pub mod trait_def;
 pub mod util;
 pub mod visit;
@@ -990,12 +992,6 @@ impl<'tcx> ParamEnv<'tcx> {
         ParamEnv { caller_bounds }
     }
 
-    /// Returns this same environment but with no caller bounds.
-    #[inline]
-    pub fn without_caller_bounds(self) -> Self {
-        Self::new(ListWithCachedTypeInfo::empty())
-    }
-
     /// Creates a pair of param-env and value for use in queries.
     pub fn and<T: TypeVisitable<TyCtxt<'tcx>>>(self, value: T) -> ParamEnvAnd<'tcx, T> {
         ParamEnvAnd { param_env: self, value }
@@ -1183,23 +1179,17 @@ impl VariantDef {
     ///
     /// If someone speeds up attribute loading to not be a performance concern, they can
     /// remove this hack and use the constructor `DefId` everywhere.
+    #[instrument(level = "debug")]
     pub fn new(
         name: Symbol,
         variant_did: Option<DefId>,
         ctor: Option<(CtorKind, DefId)>,
         discr: VariantDiscr,
         fields: IndexVec<FieldIdx, FieldDef>,
-        adt_kind: AdtKind,
         parent_did: DefId,
         recover_tainted: Option<ErrorGuaranteed>,
         is_field_list_non_exhaustive: bool,
     ) -> Self {
-        debug!(
-            "VariantDef::new(name = {:?}, variant_did = {:?}, ctor = {:?}, discr = {:?},
-             fields = {:?}, adt_kind = {:?}, parent_did = {:?})",
-            name, variant_did, ctor, discr, fields, adt_kind, parent_did,
-        );
-
         let mut flags = VariantFlags::NO_VARIANT_FLAGS;
         if is_field_list_non_exhaustive {
             flags |= VariantFlags::IS_FIELD_LIST_NON_EXHAUSTIVE;
@@ -1495,9 +1485,10 @@ impl<'tcx> TyCtxt<'tcx> {
             field_shuffle_seed ^= user_seed;
         }
 
-        for attr in self.get_attrs(did, sym::repr) {
-            for r in attr::parse_repr_attr(self.sess, attr) {
-                flags.insert(match r {
+        if let Some(reprs) = attr::find_attr!(self.get_all_attrs(did), AttributeKind::Repr(r) => r)
+        {
+            for (r, _) in reprs {
+                flags.insert(match *r {
                     attr::ReprRust => ReprFlags::empty(),
                     attr::ReprC => ReprFlags::IS_C,
                     attr::ReprPacked(pack) => {
@@ -1535,6 +1526,10 @@ impl<'tcx> TyCtxt<'tcx> {
                         max_align = max_align.max(Some(align));
                         ReprFlags::empty()
                     }
+                    attr::ReprEmpty => {
+                        /* skip these, they're just for diagnostics */
+                        ReprFlags::empty()
+                    }
                 });
             }
         }
@@ -1756,14 +1751,22 @@ impl<'tcx> TyCtxt<'tcx> {
         self,
         did: impl Into<DefId>,
         attr: Symbol,
+    ) -> impl Iterator<Item = &'tcx hir::Attribute> {
+        self.get_all_attrs(did).filter(move |a: &&hir::Attribute| a.has_name(attr))
+    }
+
+    /// Gets all attributes.
+    ///
+    /// To see if an item has a specific attribute, you should use [`rustc_attr_parsing::find_attr!`] so you can use matching.
+    pub fn get_all_attrs(
+        self,
+        did: impl Into<DefId>,
     ) -> impl Iterator<Item = &'tcx hir::Attribute> {
         let did: DefId = did.into();
-        let filter_fn = move |a: &&hir::Attribute| a.has_name(attr);
         if let Some(did) = did.as_local() {
-            self.hir().attrs(self.local_def_id_to_hir_id(did)).iter().filter(filter_fn)
+            self.hir().attrs(self.local_def_id_to_hir_id(did)).iter()
         } else {
-            debug_assert!(rustc_feature::encode_cross_crate(attr));
-            self.attrs_for_def(did).iter().filter(filter_fn)
+            self.attrs_for_def(did).iter()
         }
     }
 
diff --git a/compiler/rustc_middle/src/ty/predicate.rs b/compiler/rustc_middle/src/ty/predicate.rs
index 553de83dfcb4..1674ca4cfc56 100644
--- a/compiler/rustc_middle/src/ty/predicate.rs
+++ b/compiler/rustc_middle/src/ty/predicate.rs
@@ -4,7 +4,6 @@ use rustc_data_structures::intern::Interned;
 use rustc_hir::def_id::DefId;
 use rustc_macros::{HashStable, extension};
 use rustc_type_ir as ir;
-use tracing::instrument;
 
 use crate::ty::{
     self, DebruijnIndex, EarlyBinder, PredicatePolarity, Ty, TyCtxt, TypeFlags, Upcast, UpcastFrom,
@@ -51,10 +50,6 @@ impl<'tcx> rustc_type_ir::inherent::Predicate<TyCtxt<'tcx>> for Predicate<'tcx>
         self.as_clause()
     }
 
-    fn is_coinductive(self, interner: TyCtxt<'tcx>) -> bool {
-        self.is_coinductive(interner)
-    }
-
     fn allow_normalization(self) -> bool {
         self.allow_normalization()
     }
@@ -119,17 +114,6 @@ impl<'tcx> Predicate<'tcx> {
         Some(tcx.mk_predicate(kind))
     }
 
-    #[instrument(level = "debug", skip(tcx), ret)]
-    pub fn is_coinductive(self, tcx: TyCtxt<'tcx>) -> bool {
-        match self.kind().skip_binder() {
-            ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
-                tcx.trait_is_coinductive(data.def_id())
-            }
-            ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => true,
-            _ => false,
-        }
-    }
-
     /// Whether this projection can be soundly normalized.
     ///
     /// Wf predicates must not be normalized, as normalization
@@ -158,15 +142,21 @@ impl<'tcx> Predicate<'tcx> {
     }
 }
 
-impl rustc_errors::IntoDiagArg for Predicate<'_> {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
-        rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(self.to_string()))
+impl<'tcx> rustc_errors::IntoDiagArg for Predicate<'tcx> {
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
+        ty::tls::with(|tcx| {
+            let pred = tcx.short_string(self, path);
+            rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(pred))
+        })
     }
 }
 
-impl rustc_errors::IntoDiagArg for Clause<'_> {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
-        rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(self.to_string()))
+impl<'tcx> rustc_errors::IntoDiagArg for Clause<'tcx> {
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
+        ty::tls::with(|tcx| {
+            let clause = tcx.short_string(self, path);
+            rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(clause))
+        })
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/print/pretty.rs b/compiler/rustc_middle/src/ty/print/pretty.rs
index ed0839f47e69..c77b37a302bc 100644
--- a/compiler/rustc_middle/src/ty/print/pretty.rs
+++ b/compiler/rustc_middle/src/ty/print/pretty.rs
@@ -1516,10 +1516,7 @@ pub trait PrettyPrinter<'tcx>: Printer<'tcx> + fmt::Write {
             ty::ExprKind::Binop(op) => {
                 let (_, _, c1, c2) = expr.binop_args();
 
-                let precedence = |binop: crate::mir::BinOp| {
-                    use rustc_ast::util::parser::AssocOp;
-                    AssocOp::from_ast_binop(binop.to_hir_binop()).precedence()
-                };
+                let precedence = |binop: crate::mir::BinOp| binop.to_hir_binop().precedence();
                 let op_precedence = precedence(op);
                 let formatted_op = op.to_hir_binop().as_str();
                 let (lhs_parenthesized, rhs_parenthesized) = match (c1.kind(), c2.kind()) {
@@ -2898,12 +2895,15 @@ where
 /// Wrapper type for `ty::TraitRef` which opts-in to pretty printing only
 /// the trait path. That is, it will print `Trait<U>` instead of
 /// `<T as Trait<U>>`.
-#[derive(Copy, Clone, TypeFoldable, TypeVisitable, Lift)]
+#[derive(Copy, Clone, TypeFoldable, TypeVisitable, Lift, Hash)]
 pub struct TraitRefPrintOnlyTraitPath<'tcx>(ty::TraitRef<'tcx>);
 
 impl<'tcx> rustc_errors::IntoDiagArg for TraitRefPrintOnlyTraitPath<'tcx> {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
+        ty::tls::with(|tcx| {
+            let trait_ref = tcx.short_string(self, path);
+            rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(trait_ref))
+        })
     }
 }
 
@@ -2915,12 +2915,15 @@ impl<'tcx> fmt::Debug for TraitRefPrintOnlyTraitPath<'tcx> {
 
 /// Wrapper type for `ty::TraitRef` which opts-in to pretty printing only
 /// the trait path, and additionally tries to "sugar" `Fn(...)` trait bounds.
-#[derive(Copy, Clone, TypeFoldable, TypeVisitable, Lift)]
+#[derive(Copy, Clone, TypeFoldable, TypeVisitable, Lift, Hash)]
 pub struct TraitRefPrintSugared<'tcx>(ty::TraitRef<'tcx>);
 
 impl<'tcx> rustc_errors::IntoDiagArg for TraitRefPrintSugared<'tcx> {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
+        ty::tls::with(|tcx| {
+            let trait_ref = tcx.short_string(self, path);
+            rustc_errors::DiagArgValue::Str(std::borrow::Cow::Owned(trait_ref))
+        })
     }
 }
 
diff --git a/compiler/rustc_middle/src/ty/significant_drop_order.rs b/compiler/rustc_middle/src/ty/significant_drop_order.rs
new file mode 100644
index 000000000000..7f0d82d89fed
--- /dev/null
+++ b/compiler/rustc_middle/src/ty/significant_drop_order.rs
@@ -0,0 +1,172 @@
+use rustc_data_structures::fx::FxHashSet;
+use rustc_data_structures::unord::UnordSet;
+use rustc_hir::def_id::DefId;
+use rustc_span::Span;
+use smallvec::{SmallVec, smallvec};
+use tracing::{debug, instrument};
+
+use crate::ty::{self, Ty, TyCtxt};
+
+/// An additional filter to exclude well-known types from the ecosystem
+/// because their drops are trivial.
+/// This returns additional types to check if the drops are delegated to those.
+/// A typical example is `hashbrown::HashMap<K, V>`, whose drop is delegated to `K` and `V`.
+fn true_significant_drop_ty<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    ty: Ty<'tcx>,
+) -> Option<SmallVec<[Ty<'tcx>; 2]>> {
+    if let ty::Adt(def, args) = ty.kind() {
+        let mut did = def.did();
+        let mut name_rev = vec![];
+        loop {
+            let key = tcx.def_key(did);
+
+            match key.disambiguated_data.data {
+                rustc_hir::definitions::DefPathData::CrateRoot => {
+                    name_rev.push(tcx.crate_name(did.krate))
+                }
+                rustc_hir::definitions::DefPathData::TypeNs(symbol) => name_rev.push(symbol),
+                _ => return None,
+            }
+            if let Some(parent) = key.parent {
+                did = DefId { krate: did.krate, index: parent };
+            } else {
+                break;
+            }
+        }
+        let name_str: Vec<_> = name_rev.iter().rev().map(|x| x.as_str()).collect();
+        debug!(?name_str);
+        match name_str[..] {
+            // These are the types from Rust core ecosystem
+            ["syn" | "proc_macro2", ..]
+            | ["core" | "std", "task", "LocalWaker" | "Waker"]
+            | ["core" | "std", "task", "wake", "LocalWaker" | "Waker"] => Some(smallvec![]),
+            // These are important types from Rust ecosystem
+            ["tracing", "instrument", "Instrumented"] | ["bytes", "Bytes"] => Some(smallvec![]),
+            ["hashbrown", "raw", "RawTable" | "RawIntoIter"] => {
+                if let [ty, ..] = &***args
+                    && let Some(ty) = ty.as_type()
+                {
+                    Some(smallvec![ty])
+                } else {
+                    None
+                }
+            }
+            ["hashbrown", "raw", "RawDrain"] => {
+                if let [_, ty, ..] = &***args
+                    && let Some(ty) = ty.as_type()
+                {
+                    Some(smallvec![ty])
+                } else {
+                    None
+                }
+            }
+            _ => None,
+        }
+    } else {
+        None
+    }
+}
+
+/// Returns the list of types with a "potentially sigificant" that may be dropped
+/// by dropping a value of type `ty`.
+#[instrument(level = "trace", skip(tcx, typing_env))]
+pub fn extract_component_raw<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    typing_env: ty::TypingEnv<'tcx>,
+    ty: Ty<'tcx>,
+    ty_seen: &mut UnordSet<Ty<'tcx>>,
+) -> SmallVec<[Ty<'tcx>; 4]> {
+    // Droppiness does not depend on regions, so let us erase them.
+    let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
+
+    let tys = tcx.list_significant_drop_tys(typing_env.as_query_input(ty));
+    debug!(?ty, "components");
+    let mut out_tys = smallvec![];
+    for ty in tys {
+        if let Some(tys) = true_significant_drop_ty(tcx, ty) {
+            // Some types can be further opened up because the drop is simply delegated
+            for ty in tys {
+                if ty_seen.insert(ty) {
+                    out_tys.extend(extract_component_raw(tcx, typing_env, ty, ty_seen));
+                }
+            }
+        } else {
+            if ty_seen.insert(ty) {
+                out_tys.push(ty);
+            }
+        }
+    }
+    out_tys
+}
+
+#[instrument(level = "trace", skip(tcx, typing_env))]
+pub fn extract_component_with_significant_dtor<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    typing_env: ty::TypingEnv<'tcx>,
+    ty: Ty<'tcx>,
+) -> SmallVec<[Ty<'tcx>; 4]> {
+    let mut tys = extract_component_raw(tcx, typing_env, ty, &mut Default::default());
+    let mut deduplicate = FxHashSet::default();
+    tys.retain(|oty| deduplicate.insert(*oty));
+    tys.into_iter().collect()
+}
+
+/// Extract the span of the custom destructor of a type
+/// especially the span of the `impl Drop` header or its entire block
+/// when we are working with current local crate.
+#[instrument(level = "trace", skip(tcx))]
+pub fn ty_dtor_span<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Span> {
+    match ty.kind() {
+        ty::Bool
+        | ty::Char
+        | ty::Int(_)
+        | ty::Uint(_)
+        | ty::Float(_)
+        | ty::Error(_)
+        | ty::Str
+        | ty::Never
+        | ty::RawPtr(_, _)
+        | ty::Ref(_, _, _)
+        | ty::FnPtr(_, _)
+        | ty::Tuple(_)
+        | ty::Dynamic(_, _, _)
+        | ty::Alias(_, _)
+        | ty::Bound(_, _)
+        | ty::Pat(_, _)
+        | ty::Placeholder(_)
+        | ty::Infer(_)
+        | ty::Slice(_)
+        | ty::Array(_, _)
+        | ty::UnsafeBinder(_) => None,
+
+        ty::Adt(adt_def, _) => {
+            let did = adt_def.did();
+            let try_local_did_span = |did: DefId| {
+                if let Some(local) = did.as_local() {
+                    tcx.source_span(local)
+                } else {
+                    tcx.def_span(did)
+                }
+            };
+            let dtor = if let Some(dtor) = tcx.adt_destructor(did) {
+                dtor.did
+            } else if let Some(dtor) = tcx.adt_async_destructor(did) {
+                dtor.future
+            } else {
+                return Some(try_local_did_span(did));
+            };
+            let def_key = tcx.def_key(dtor);
+            let Some(parent_index) = def_key.parent else { return Some(try_local_did_span(dtor)) };
+            let parent_did = DefId { index: parent_index, krate: dtor.krate };
+            Some(try_local_did_span(parent_did))
+        }
+        ty::Coroutine(did, _)
+        | ty::CoroutineWitness(did, _)
+        | ty::CoroutineClosure(did, _)
+        | ty::Closure(did, _)
+        | ty::FnDef(did, _)
+        | ty::Foreign(did) => Some(tcx.def_span(did)),
+        ty::Param(_) => None,
+    }
+}
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index d5617adf26b4..ce563c592516 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -342,6 +342,7 @@ impl ParamConst {
         ParamConst::new(def.index, def.name)
     }
 
+    #[instrument(level = "debug")]
     pub fn find_ty_from_env<'tcx>(self, env: ParamEnv<'tcx>) -> Ty<'tcx> {
         let mut candidates = env.caller_bounds().iter().filter_map(|clause| {
             // `ConstArgHasType` are never desugared to be higher ranked.
@@ -461,7 +462,7 @@ impl<'tcx> Ty<'tcx> {
 
     #[inline]
     pub fn new_param(tcx: TyCtxt<'tcx>, index: u32, name: Symbol) -> Ty<'tcx> {
-        tcx.mk_ty_from_kind(Param(ParamTy { index, name }))
+        Ty::new(tcx, Param(ParamTy { index, name }))
     }
 
     #[inline]
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index d4484a16fea4..7d9c23c05f95 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -394,8 +394,10 @@ impl<'tcx> TypeckResults<'tcx> {
         matches!(self.type_dependent_defs().get(expr.hir_id), Some(Ok((DefKind::AssocFn, _))))
     }
 
-    pub fn extract_binding_mode(&self, s: &Session, id: HirId, sp: Span) -> Option<BindingMode> {
-        self.pat_binding_modes().get(id).copied().or_else(|| {
+    /// Returns the computed binding mode for a `PatKind::Binding` pattern
+    /// (after match ergonomics adjustments).
+    pub fn extract_binding_mode(&self, s: &Session, id: HirId, sp: Span) -> BindingMode {
+        self.pat_binding_modes().get(id).copied().unwrap_or_else(|| {
             s.dcx().span_bug(sp, "missing binding mode");
         })
     }
diff --git a/compiler/rustc_middle/src/ty/util.rs b/compiler/rustc_middle/src/ty/util.rs
index 88d574985423..237aa66f486f 100644
--- a/compiler/rustc_middle/src/ty/util.rs
+++ b/compiler/rustc_middle/src/ty/util.rs
@@ -208,6 +208,20 @@ impl<'tcx> TyCtxt<'tcx> {
         tcx.struct_tail_raw(ty, |ty| tcx.normalize_erasing_regions(typing_env, ty), || {})
     }
 
+    /// Returns true if a type has metadata.
+    pub fn type_has_metadata(self, ty: Ty<'tcx>, typing_env: ty::TypingEnv<'tcx>) -> bool {
+        if ty.is_sized(self, typing_env) {
+            return false;
+        }
+
+        let tail = self.struct_tail_for_codegen(ty, typing_env);
+        match tail.kind() {
+            ty::Foreign(..) => false,
+            ty::Str | ty::Slice(..) | ty::Dynamic(..) => true,
+            _ => bug!("unexpected unsized tail: {:?}", tail),
+        }
+    }
+
     /// Returns the deeply last field of nested structures, or the same type if
     /// not a structure at all. Corresponds to the only possible unsized field,
     /// and its type can be used to determine unsizing strategy.
@@ -726,51 +740,37 @@ impl<'tcx> TyCtxt<'tcx> {
     }
 
     /// Return the set of types that should be taken into account when checking
-    /// trait bounds on a coroutine's internal state.
-    // FIXME(compiler-errors): We should remove this when the old solver goes away;
-    // and all other usages of this function should go through `bound_coroutine_hidden_types`
-    // instead.
+    /// trait bounds on a coroutine's internal state. This properly replaces
+    /// `ReErased` with new existential bound lifetimes.
     pub fn coroutine_hidden_types(
         self,
         def_id: DefId,
-    ) -> impl Iterator<Item = ty::EarlyBinder<'tcx, Ty<'tcx>>> {
+    ) -> ty::EarlyBinder<'tcx, ty::Binder<'tcx, &'tcx ty::List<Ty<'tcx>>>> {
         let coroutine_layout = self.mir_coroutine_witnesses(def_id);
-        coroutine_layout
-            .as_ref()
-            .map_or_else(|| [].iter(), |l| l.field_tys.iter())
-            .filter(|decl| !decl.ignore_for_traits)
-            .map(|decl| ty::EarlyBinder::bind(decl.ty))
-    }
-
-    /// Return the set of types that should be taken into account when checking
-    /// trait bounds on a coroutine's internal state. This properly replaces
-    /// `ReErased` with new existential bound lifetimes.
-    pub fn bound_coroutine_hidden_types(
-        self,
-        def_id: DefId,
-    ) -> impl Iterator<Item = ty::EarlyBinder<'tcx, ty::Binder<'tcx, Ty<'tcx>>>> {
-        let coroutine_layout = self.mir_coroutine_witnesses(def_id);
-        coroutine_layout
-            .as_ref()
-            .map_or_else(|| [].iter(), |l| l.field_tys.iter())
-            .filter(|decl| !decl.ignore_for_traits)
-            .map(move |decl| {
-                let mut vars = vec![];
-                let ty = fold_regions(self, decl.ty, |re, debruijn| {
-                    assert_eq!(re, self.lifetimes.re_erased);
-                    let var = ty::BoundVar::from_usize(vars.len());
-                    vars.push(ty::BoundVariableKind::Region(ty::BoundRegionKind::Anon));
-                    ty::Region::new_bound(
-                        self,
-                        debruijn,
-                        ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon },
-                    )
-                });
-                ty::EarlyBinder::bind(ty::Binder::bind_with_vars(
-                    ty,
-                    self.mk_bound_variable_kinds(&vars),
-                ))
-            })
+        let mut vars = vec![];
+        let bound_tys = self.mk_type_list_from_iter(
+            coroutine_layout
+                .as_ref()
+                .map_or_else(|| [].iter(), |l| l.field_tys.iter())
+                .filter(|decl| !decl.ignore_for_traits)
+                .map(|decl| {
+                    let ty = fold_regions(self, decl.ty, |re, debruijn| {
+                        assert_eq!(re, self.lifetimes.re_erased);
+                        let var = ty::BoundVar::from_usize(vars.len());
+                        vars.push(ty::BoundVariableKind::Region(ty::BoundRegionKind::Anon));
+                        ty::Region::new_bound(
+                            self,
+                            debruijn,
+                            ty::BoundRegion { var, kind: ty::BoundRegionKind::Anon },
+                        )
+                    });
+                    ty
+                }),
+        );
+        ty::EarlyBinder::bind(ty::Binder::bind_with_vars(
+            bound_tys,
+            self.mk_bound_variable_kinds(&vars),
+        ))
     }
 
     /// Expands the given impl trait type, stopping if the type is recursive.
@@ -1755,13 +1755,12 @@ pub fn intrinsic_raw(tcx: TyCtxt<'_>, def_id: LocalDefId) -> Option<ty::Intrinsi
         && (matches!(tcx.fn_sig(def_id).skip_binder().abi(), ExternAbi::RustIntrinsic)
             || tcx.has_attr(def_id, sym::rustc_intrinsic))
     {
-        let must_be_overridden = tcx.has_attr(def_id, sym::rustc_intrinsic_must_be_overridden)
-            || match tcx.hir_node_by_def_id(def_id) {
-                hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn { has_body, .. }, .. }) => {
-                    !has_body
-                }
-                _ => true,
-            };
+        let must_be_overridden = match tcx.hir_node_by_def_id(def_id) {
+            hir::Node::Item(hir::Item { kind: hir::ItemKind::Fn { has_body, .. }, .. }) => {
+                !has_body
+            }
+            _ => true,
+        };
         Some(ty::IntrinsicDef {
             name: tcx.item_name(def_id.into()),
             must_be_overridden,
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index ee331713736e..10b43390eb28 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -1,7 +1,7 @@
 use std::sync::Arc;
 
 use rustc_middle::mir::*;
-use rustc_middle::thir::{self, *};
+use rustc_middle::thir::*;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
 
 use crate::builder::Builder;
@@ -134,7 +134,7 @@ impl<'tcx> MatchPairTree<'tcx> {
             PatKind::Constant { value } => TestCase::Constant { value },
 
             PatKind::AscribeUserType {
-                ascription: thir::Ascription { ref annotation, variance },
+                ascription: Ascription { ref annotation, variance },
                 ref subpattern,
                 ..
             } => {
diff --git a/compiler/rustc_mir_build/src/errors.rs b/compiler/rustc_mir_build/src/errors.rs
index f1753be845d4..17b22f25dbb0 100644
--- a/compiler/rustc_mir_build/src/errors.rs
+++ b/compiler/rustc_mir_build/src/errors.rs
@@ -828,7 +828,7 @@ pub(crate) struct IrrefutableLetPatternsWhileLet {
 
 #[derive(Diagnostic)]
 #[diag(mir_build_borrow_of_moved_value)]
-pub(crate) struct BorrowOfMovedValue {
+pub(crate) struct BorrowOfMovedValue<'tcx> {
     #[primary_span]
     #[label]
     #[label(mir_build_occurs_because_label)]
@@ -836,7 +836,7 @@ pub(crate) struct BorrowOfMovedValue {
     #[label(mir_build_value_borrowed_label)]
     pub(crate) conflicts_ref: Vec<Span>,
     pub(crate) name: Ident,
-    pub(crate) ty: String,
+    pub(crate) ty: Ty<'tcx>,
     #[suggestion(code = "ref ", applicability = "machine-applicable")]
     pub(crate) suggest_borrowing: Option<Span>,
 }
diff --git a/compiler/rustc_mir_build/src/thir/cx/expr.rs b/compiler/rustc_mir_build/src/thir/cx/expr.rs
index 88877d05ffad..7139516702e9 100644
--- a/compiler/rustc_mir_build/src/thir/cx/expr.rs
+++ b/compiler/rustc_mir_build/src/thir/cx/expr.rs
@@ -730,12 +730,20 @@ impl<'tcx> ThirBuildCx<'tcx> {
                             }
                         }
                         hir::InlineAsmOperand::Const { ref anon_const } => {
-                            let value =
-                                mir::Const::from_unevaluated(tcx, anon_const.def_id.to_def_id())
-                                    .instantiate_identity();
-                            let span = tcx.def_span(anon_const.def_id);
+                            let ty = self.typeck_results.node_type(anon_const.hir_id);
+                            let did = anon_const.def_id.to_def_id();
+                            let typeck_root_def_id = tcx.typeck_root_def_id(did);
+                            let parent_args = tcx.erase_regions(GenericArgs::identity_for_item(
+                                tcx,
+                                typeck_root_def_id,
+                            ));
+                            let args =
+                                InlineConstArgs::new(tcx, InlineConstArgsParts { parent_args, ty })
+                                    .args;
 
-                            InlineAsmOperand::Const { value, span }
+                            let uneval = mir::UnevaluatedConst::new(did, args);
+                            let value = mir::Const::Unevaluated(uneval, ty);
+                            InlineAsmOperand::Const { value, span: tcx.def_span(did) }
                         }
                         hir::InlineAsmOperand::SymFn { expr } => {
                             InlineAsmOperand::SymFn { value: self.mirror_expr(expr) }
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index d60ae6484afb..954d0cf97abe 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -786,17 +786,13 @@ fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat:
                 }
             });
             if !conflicts_ref.is_empty() {
-                let mut path = None;
-                let ty = cx.tcx.short_string(ty, &mut path);
-                let mut err = sess.dcx().create_err(BorrowOfMovedValue {
+                sess.dcx().emit_err(BorrowOfMovedValue {
                     binding_span: pat.span,
                     conflicts_ref,
                     name: Ident::new(name, pat.span),
                     ty,
                     suggest_borrowing: Some(pat.span.shrink_to_lo()),
                 });
-                *err.long_ty_path() = path;
-                err.emit();
             }
             return;
         }
diff --git a/compiler/rustc_mir_transform/src/check_pointers.rs b/compiler/rustc_mir_transform/src/check_pointers.rs
index d693f739180f..2d04b6219358 100644
--- a/compiler/rustc_mir_transform/src/check_pointers.rs
+++ b/compiler/rustc_mir_transform/src/check_pointers.rs
@@ -71,8 +71,7 @@ pub(crate) fn check_pointers<'tcx, F>(
     // statements/blocks after. Iterating or visiting the MIR in order would require updating
     // our current location after every insertion. By iterating backwards, we dodge this issue:
     // The only Locations that an insertion changes have already been handled.
-    for block in (0..basic_blocks.len()).rev() {
-        let block = block.into();
+    for block in basic_blocks.indices().rev() {
         for statement_index in (0..basic_blocks[block].statements.len()).rev() {
             let location = Location { block, statement_index };
             let statement = &basic_blocks[block].statements[statement_index];
diff --git a/compiler/rustc_mir_transform/src/coverage/counters.rs b/compiler/rustc_mir_transform/src/coverage/counters.rs
index 039f346495be..5568d42ab8f3 100644
--- a/compiler/rustc_mir_transform/src/coverage/counters.rs
+++ b/compiler/rustc_mir_transform/src/coverage/counters.rs
@@ -50,7 +50,7 @@ fn make_node_flow_priority_list(
     // A "reloop" node has exactly one out-edge, which jumps back to the top
     // of an enclosing loop. Reloop nodes are typically visited more times
     // than loop-exit nodes, so try to avoid giving them physical counters.
-    let is_reloop_node = IndexVec::from_fn_n(
+    let is_reloop_node = IndexVec::<BasicCoverageBlock, _>::from_fn_n(
         |node| match graph.successors[node].as_slice() {
             &[succ] => graph.dominates(succ, node),
             _ => false,
diff --git a/compiler/rustc_mir_transform/src/coverage/graph.rs b/compiler/rustc_mir_transform/src/coverage/graph.rs
index 09384defea86..dcc7c5b91d76 100644
--- a/compiler/rustc_mir_transform/src/coverage/graph.rs
+++ b/compiler/rustc_mir_transform/src/coverage/graph.rs
@@ -42,7 +42,7 @@ impl CoverageGraph {
         // `SwitchInt` to have multiple targets to the same destination `BasicBlock`, so
         // de-duplication is required. This is done without reordering the successors.
 
-        let successors = IndexVec::from_fn_n(
+        let successors = IndexVec::<BasicCoverageBlock, _>::from_fn_n(
             |bcb| {
                 let mut seen_bcbs = FxHashSet::default();
                 let terminator = mir_body[bcbs[bcb].last_bb()].terminator();
diff --git a/compiler/rustc_mir_transform/src/coverage/query.rs b/compiler/rustc_mir_transform/src/coverage/query.rs
index 58461be01f17..ccf76dc71087 100644
--- a/compiler/rustc_mir_transform/src/coverage/query.rs
+++ b/compiler/rustc_mir_transform/src/coverage/query.rs
@@ -65,7 +65,7 @@ fn coverage_attr_on(tcx: TyCtxt<'_>, def_id: LocalDefId) -> bool {
             Some(_) | None => {
                 // Other possibilities should have been rejected by `rustc_parse::validate_attr`.
                 // Use `span_delayed_bug` to avoid an ICE in failing builds (#127880).
-                tcx.dcx().span_delayed_bug(attr.span, "unexpected value of coverage attribute");
+                tcx.dcx().span_delayed_bug(attr.span(), "unexpected value of coverage attribute");
             }
         }
     }
diff --git a/compiler/rustc_mir_transform/src/gvn.rs b/compiler/rustc_mir_transform/src/gvn.rs
index 2f8a30501999..981dedd5b5c7 100644
--- a/compiler/rustc_mir_transform/src/gvn.rs
+++ b/compiler/rustc_mir_transform/src/gvn.rs
@@ -1259,7 +1259,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
 
         let layout = self.ecx.layout_of(lhs_ty).ok()?;
 
-        let as_bits = |value| {
+        let as_bits = |value: VnIndex| {
             let constant = self.evaluated[value].as_ref()?;
             if layout.backend_repr.is_scalar() {
                 let scalar = self.ecx.read_scalar(constant).discard_err()?;
@@ -1567,7 +1567,7 @@ impl<'body, 'tcx> VnState<'body, 'tcx> {
             BackendRepr::ScalarPair(a, b) => {
                 !a.is_always_valid(&self.ecx) || !b.is_always_valid(&self.ecx)
             }
-            BackendRepr::Vector { .. } | BackendRepr::Memory { .. } => false,
+            BackendRepr::SimdVector { .. } | BackendRepr::Memory { .. } => false,
         }
     }
 
diff --git a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
index e3260e45bc52..7d77fffa83fd 100644
--- a/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
+++ b/compiler/rustc_mir_transform/src/lint_tail_expr_drop_order.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::unord::{UnordMap, UnordSet};
 use rustc_errors::Subdiagnostic;
 use rustc_hir::CRATE_HIR_ID;
-use rustc_hir::def_id::{DefId, LocalDefId};
+use rustc_hir::def_id::LocalDefId;
 use rustc_index::bit_set::MixedBitSet;
 use rustc_index::{IndexSlice, IndexVec};
 use rustc_macros::{LintDiagnostic, Subdiagnostic};
@@ -15,7 +15,10 @@ use rustc_middle::mir::{
     self, BasicBlock, Body, ClearCrossCrate, Local, Location, Place, StatementKind, TerminatorKind,
     dump_mir,
 };
-use rustc_middle::ty::{self, Ty, TyCtxt};
+use rustc_middle::ty::significant_drop_order::{
+    extract_component_with_significant_dtor, ty_dtor_span,
+};
+use rustc_middle::ty::{self, TyCtxt};
 use rustc_mir_dataflow::impls::MaybeInitializedPlaces;
 use rustc_mir_dataflow::move_paths::{LookupResult, MoveData, MovePathIndex};
 use rustc_mir_dataflow::{Analysis, MaybeReachable, ResultsCursor};
@@ -23,8 +26,7 @@ use rustc_session::lint::builtin::TAIL_EXPR_DROP_ORDER;
 use rustc_session::lint::{self};
 use rustc_span::{DUMMY_SP, Span, Symbol};
 use rustc_type_ir::data_structures::IndexMap;
-use smallvec::{SmallVec, smallvec};
-use tracing::{debug, instrument};
+use tracing::debug;
 
 fn place_has_common_prefix<'tcx>(left: &Place<'tcx>, right: &Place<'tcx>) -> bool {
     left.local == right.local
@@ -155,170 +157,6 @@ impl<'a, 'mir, 'tcx> DropsReachable<'a, 'mir, 'tcx> {
     }
 }
 
-/// An additional filter to exclude well-known types from the ecosystem
-/// because their drops are trivial.
-/// This returns additional types to check if the drops are delegated to those.
-/// A typical example is `hashbrown::HashMap<K, V>`, whose drop is delegated to `K` and `V`.
-fn true_significant_drop_ty<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    ty: Ty<'tcx>,
-) -> Option<SmallVec<[Ty<'tcx>; 2]>> {
-    if let ty::Adt(def, args) = ty.kind() {
-        let mut did = def.did();
-        let mut name_rev = vec![];
-        loop {
-            let key = tcx.def_key(did);
-
-            match key.disambiguated_data.data {
-                rustc_hir::definitions::DefPathData::CrateRoot => {
-                    name_rev.push(tcx.crate_name(did.krate))
-                }
-                rustc_hir::definitions::DefPathData::TypeNs(symbol) => name_rev.push(symbol),
-                _ => return None,
-            }
-            if let Some(parent) = key.parent {
-                did = DefId { krate: did.krate, index: parent };
-            } else {
-                break;
-            }
-        }
-        let name_str: Vec<_> = name_rev.iter().rev().map(|x| x.as_str()).collect();
-        debug!(?name_str);
-        match name_str[..] {
-            // These are the types from Rust core ecosystem
-            ["syn" | "proc_macro2", ..]
-            | ["core" | "std", "task", "LocalWaker" | "Waker"]
-            | ["core" | "std", "task", "wake", "LocalWaker" | "Waker"] => Some(smallvec![]),
-            // These are important types from Rust ecosystem
-            ["tracing", "instrument", "Instrumented"] | ["bytes", "Bytes"] => Some(smallvec![]),
-            ["hashbrown", "raw", "RawTable" | "RawIntoIter"] => {
-                if let [ty, ..] = &***args
-                    && let Some(ty) = ty.as_type()
-                {
-                    Some(smallvec![ty])
-                } else {
-                    None
-                }
-            }
-            ["hashbrown", "raw", "RawDrain"] => {
-                if let [_, ty, ..] = &***args
-                    && let Some(ty) = ty.as_type()
-                {
-                    Some(smallvec![ty])
-                } else {
-                    None
-                }
-            }
-            _ => None,
-        }
-    } else {
-        None
-    }
-}
-
-/// Returns the list of types with a "potentially sigificant" that may be dropped
-/// by dropping a value of type `ty`.
-#[instrument(level = "debug", skip(tcx, typing_env))]
-fn extract_component_raw<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    typing_env: ty::TypingEnv<'tcx>,
-    ty: Ty<'tcx>,
-    ty_seen: &mut UnordSet<Ty<'tcx>>,
-) -> SmallVec<[Ty<'tcx>; 4]> {
-    // Droppiness does not depend on regions, so let us erase them.
-    let ty = tcx.try_normalize_erasing_regions(typing_env, ty).unwrap_or(ty);
-
-    let tys = tcx.list_significant_drop_tys(typing_env.as_query_input(ty));
-    debug!(?ty, "components");
-    let mut out_tys = smallvec![];
-    for ty in tys {
-        if let Some(tys) = true_significant_drop_ty(tcx, ty) {
-            // Some types can be further opened up because the drop is simply delegated
-            for ty in tys {
-                if ty_seen.insert(ty) {
-                    out_tys.extend(extract_component_raw(tcx, typing_env, ty, ty_seen));
-                }
-            }
-        } else {
-            if ty_seen.insert(ty) {
-                out_tys.push(ty);
-            }
-        }
-    }
-    out_tys
-}
-
-#[instrument(level = "debug", skip(tcx, typing_env))]
-fn extract_component_with_significant_dtor<'tcx>(
-    tcx: TyCtxt<'tcx>,
-    typing_env: ty::TypingEnv<'tcx>,
-    ty: Ty<'tcx>,
-) -> SmallVec<[Ty<'tcx>; 4]> {
-    let mut tys = extract_component_raw(tcx, typing_env, ty, &mut Default::default());
-    let mut deduplicate = FxHashSet::default();
-    tys.retain(|oty| deduplicate.insert(*oty));
-    tys.into_iter().collect()
-}
-
-/// Extract the span of the custom destructor of a type
-/// especially the span of the `impl Drop` header or its entire block
-/// when we are working with current local crate.
-#[instrument(level = "debug", skip(tcx))]
-fn ty_dtor_span<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Span> {
-    match ty.kind() {
-        ty::Bool
-        | ty::Char
-        | ty::Int(_)
-        | ty::Uint(_)
-        | ty::Float(_)
-        | ty::Error(_)
-        | ty::Str
-        | ty::Never
-        | ty::RawPtr(_, _)
-        | ty::Ref(_, _, _)
-        | ty::FnPtr(_, _)
-        | ty::Tuple(_)
-        | ty::Dynamic(_, _, _)
-        | ty::Alias(_, _)
-        | ty::Bound(_, _)
-        | ty::Pat(_, _)
-        | ty::Placeholder(_)
-        | ty::Infer(_)
-        | ty::Slice(_)
-        | ty::Array(_, _)
-        | ty::UnsafeBinder(_) => None,
-
-        ty::Adt(adt_def, _) => {
-            let did = adt_def.did();
-            let try_local_did_span = |did: DefId| {
-                if let Some(local) = did.as_local() {
-                    tcx.source_span(local)
-                } else {
-                    tcx.def_span(did)
-                }
-            };
-            let dtor = if let Some(dtor) = tcx.adt_destructor(did) {
-                dtor.did
-            } else if let Some(dtor) = tcx.adt_async_destructor(did) {
-                dtor.future
-            } else {
-                return Some(try_local_did_span(did));
-            };
-            let def_key = tcx.def_key(dtor);
-            let Some(parent_index) = def_key.parent else { return Some(try_local_did_span(dtor)) };
-            let parent_did = DefId { index: parent_index, krate: dtor.krate };
-            Some(try_local_did_span(parent_did))
-        }
-        ty::Coroutine(did, _)
-        | ty::CoroutineWitness(did, _)
-        | ty::CoroutineClosure(did, _)
-        | ty::Closure(did, _)
-        | ty::FnDef(did, _)
-        | ty::Foreign(did) => Some(tcx.def_span(did)),
-        ty::Param(_) => None,
-    }
-}
-
 /// Check if a moved place at `idx` is a part of a BID.
 /// The use of this check is that we will consider drops on these
 /// as a drop of the overall BID and, thus, we can exclude it from the diagnosis.
diff --git a/compiler/rustc_monomorphize/src/collector.rs b/compiler/rustc_monomorphize/src/collector.rs
index d7cb8f18f826..08df0dedc6b0 100644
--- a/compiler/rustc_monomorphize/src/collector.rs
+++ b/compiler/rustc_monomorphize/src/collector.rs
@@ -751,7 +751,7 @@ impl<'a, 'tcx> MirVisitor<'tcx> for MirUsedCollector<'a, 'tcx> {
     /// This does not walk the MIR of the constant as that is not needed for codegen, all we need is
     /// to ensure that the constant evaluates successfully and walk the result.
     #[instrument(skip(self), level = "debug")]
-    fn visit_const_operand(&mut self, constant: &mir::ConstOperand<'tcx>, location: Location) {
+    fn visit_const_operand(&mut self, constant: &mir::ConstOperand<'tcx>, _location: Location) {
         // No `super_constant` as we don't care about `visit_ty`/`visit_ty_const`.
         let Some(val) = self.eval_constant(constant) else { return };
         collect_const_value(self.tcx, val, self.used_items);
@@ -1043,18 +1043,7 @@ fn find_vtable_types_for_unsizing<'tcx>(
 ) -> (Ty<'tcx>, Ty<'tcx>) {
     let ptr_vtable = |inner_source: Ty<'tcx>, inner_target: Ty<'tcx>| {
         let typing_env = ty::TypingEnv::fully_monomorphized();
-        let type_has_metadata = |ty: Ty<'tcx>| -> bool {
-            if ty.is_sized(tcx.tcx, typing_env) {
-                return false;
-            }
-            let tail = tcx.struct_tail_for_codegen(ty, typing_env);
-            match tail.kind() {
-                ty::Foreign(..) => false,
-                ty::Str | ty::Slice(..) | ty::Dynamic(..) => true,
-                _ => bug!("unexpected unsized tail: {:?}", tail),
-            }
-        };
-        if type_has_metadata(inner_source) {
+        if tcx.type_has_metadata(inner_source, typing_env) {
             (inner_source, inner_target)
         } else {
             tcx.struct_lockstep_tails_for_codegen(inner_source, inner_target, typing_env)
diff --git a/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs b/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
index 4c8dd933317e..9f26da7d5c64 100644
--- a/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
+++ b/compiler/rustc_monomorphize/src/mono_checks/abi_check.rs
@@ -18,7 +18,7 @@ fn uses_vector_registers(mode: &PassMode, repr: &BackendRepr) -> bool {
             cast.prefix.iter().any(|r| r.is_some_and(|x| x.kind == RegKind::Vector))
                 || cast.rest.unit.kind == RegKind::Vector
         }
-        PassMode::Direct(..) | PassMode::Pair(..) => matches!(repr, BackendRepr::Vector { .. }),
+        PassMode::Direct(..) | PassMode::Pair(..) => matches!(repr, BackendRepr::SimdVector { .. }),
     }
 }
 
diff --git a/compiler/rustc_next_trait_solver/src/delegate.rs b/compiler/rustc_next_trait_solver/src/delegate.rs
index a64941cce3af..850d86d91e88 100644
--- a/compiler/rustc_next_trait_solver/src/delegate.rs
+++ b/compiler/rustc_next_trait_solver/src/delegate.rs
@@ -102,7 +102,6 @@ pub trait SolverDelegate: Deref<Target = Self::Infcx> + Sized {
 
     fn is_transmutable(
         &self,
-        param_env: <Self::Interner as Interner>::ParamEnv,
         dst: <Self::Interner as Interner>::Ty,
         src: <Self::Interner as Interner>::Ty,
         assume: <Self::Interner as Interner>::Const,
diff --git a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
index dc0f4c4483e6..93804b14125d 100644
--- a/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/assembly/structural_traits.rs
@@ -18,7 +18,7 @@ use crate::solve::{AdtDestructorKind, EvalCtxt, Goal, NoSolution};
 pub(in crate::solve) fn instantiate_constituent_tys_for_auto_trait<D, I>(
     ecx: &EvalCtxt<'_, D>,
     ty: I::Ty,
-) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>
+) -> Result<ty::Binder<I, Vec<I::Ty>>, NoSolution>
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
@@ -33,10 +33,10 @@ where
         | ty::FnPtr(..)
         | ty::Error(_)
         | ty::Never
-        | ty::Char => Ok(vec![]),
+        | ty::Char => Ok(ty::Binder::dummy(vec![])),
 
         // Treat `str` like it's defined as `struct str([u8]);`
-        ty::Str => Ok(vec![ty::Binder::dummy(Ty::new_slice(cx, Ty::new_u8(cx)))]),
+        ty::Str => Ok(ty::Binder::dummy(vec![Ty::new_slice(cx, Ty::new_u8(cx))])),
 
         ty::Dynamic(..)
         | ty::Param(..)
@@ -49,53 +49,49 @@ where
         }
 
         ty::RawPtr(element_ty, _) | ty::Ref(_, element_ty, _) => {
-            Ok(vec![ty::Binder::dummy(element_ty)])
+            Ok(ty::Binder::dummy(vec![element_ty]))
         }
 
         ty::Pat(element_ty, _) | ty::Array(element_ty, _) | ty::Slice(element_ty) => {
-            Ok(vec![ty::Binder::dummy(element_ty)])
+            Ok(ty::Binder::dummy(vec![element_ty]))
         }
 
         ty::Tuple(tys) => {
             // (T1, ..., Tn) -- meets any bound that all of T1...Tn meet
-            Ok(tys.iter().map(ty::Binder::dummy).collect())
+            Ok(ty::Binder::dummy(tys.to_vec()))
         }
 
-        ty::Closure(_, args) => Ok(vec![ty::Binder::dummy(args.as_closure().tupled_upvars_ty())]),
+        ty::Closure(_, args) => Ok(ty::Binder::dummy(vec![args.as_closure().tupled_upvars_ty()])),
 
         ty::CoroutineClosure(_, args) => {
-            Ok(vec![ty::Binder::dummy(args.as_coroutine_closure().tupled_upvars_ty())])
+            Ok(ty::Binder::dummy(vec![args.as_coroutine_closure().tupled_upvars_ty()]))
         }
 
         ty::Coroutine(_, args) => {
             let coroutine_args = args.as_coroutine();
-            Ok(vec![
-                ty::Binder::dummy(coroutine_args.tupled_upvars_ty()),
-                ty::Binder::dummy(coroutine_args.witness()),
-            ])
+            Ok(ty::Binder::dummy(vec![coroutine_args.tupled_upvars_ty(), coroutine_args.witness()]))
         }
 
         ty::CoroutineWitness(def_id, args) => Ok(ecx
             .cx()
-            .bound_coroutine_hidden_types(def_id)
-            .into_iter()
-            .map(|bty| bty.instantiate(cx, args))
-            .collect()),
+            .coroutine_hidden_types(def_id)
+            .instantiate(cx, args)
+            .map_bound(|tys| tys.to_vec())),
 
-        ty::UnsafeBinder(bound_ty) => Ok(vec![bound_ty.into()]),
+        ty::UnsafeBinder(bound_ty) => Ok(bound_ty.map_bound(|ty| vec![ty])),
 
         // For `PhantomData<T>`, we pass `T`.
-        ty::Adt(def, args) if def.is_phantom_data() => Ok(vec![ty::Binder::dummy(args.type_at(0))]),
+        ty::Adt(def, args) if def.is_phantom_data() => Ok(ty::Binder::dummy(vec![args.type_at(0)])),
 
         ty::Adt(def, args) => {
-            Ok(def.all_field_tys(cx).iter_instantiated(cx, args).map(ty::Binder::dummy).collect())
+            Ok(ty::Binder::dummy(def.all_field_tys(cx).iter_instantiated(cx, args).collect()))
         }
 
         ty::Alias(ty::Opaque, ty::AliasTy { def_id, args, .. }) => {
             // We can resolve the `impl Trait` to its concrete type,
             // which enforces a DAG between the functions requiring
             // the auto trait bounds in question.
-            Ok(vec![ty::Binder::dummy(cx.type_of(def_id).instantiate(cx, args))])
+            Ok(ty::Binder::dummy(vec![cx.type_of(def_id).instantiate(cx, args)]))
         }
     }
 }
@@ -104,7 +100,7 @@ where
 pub(in crate::solve) fn instantiate_constituent_tys_for_sized_trait<D, I>(
     ecx: &EvalCtxt<'_, D>,
     ty: I::Ty,
-) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>
+) -> Result<ty::Binder<I, Vec<I::Ty>>, NoSolution>
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
@@ -130,7 +126,7 @@ where
         | ty::CoroutineClosure(..)
         | ty::Never
         | ty::Dynamic(_, _, ty::DynStar)
-        | ty::Error(_) => Ok(vec![]),
+        | ty::Error(_) => Ok(ty::Binder::dummy(vec![])),
 
         ty::Str
         | ty::Slice(_)
@@ -145,11 +141,11 @@ where
             panic!("unexpected type `{ty:?}`")
         }
 
-        ty::UnsafeBinder(bound_ty) => Ok(vec![bound_ty.into()]),
+        ty::UnsafeBinder(bound_ty) => Ok(bound_ty.map_bound(|ty| vec![ty])),
 
         // impl Sized for ()
         // impl Sized for (T1, T2, .., Tn) where Tn: Sized if n >= 1
-        ty::Tuple(tys) => Ok(tys.last().map_or_else(Vec::new, |ty| vec![ty::Binder::dummy(ty)])),
+        ty::Tuple(tys) => Ok(ty::Binder::dummy(tys.last().map_or_else(Vec::new, |ty| vec![ty]))),
 
         // impl Sized for Adt<Args...> where sized_constraint(Adt)<Args...>: Sized
         //   `sized_constraint(Adt)` is the deepest struct trail that can be determined
@@ -162,9 +158,9 @@ where
         //   if the ADT is sized for all possible args.
         ty::Adt(def, args) => {
             if let Some(sized_crit) = def.sized_constraint(ecx.cx()) {
-                Ok(vec![ty::Binder::dummy(sized_crit.instantiate(ecx.cx(), args))])
+                Ok(ty::Binder::dummy(vec![sized_crit.instantiate(ecx.cx(), args)]))
             } else {
-                Ok(vec![])
+                Ok(ty::Binder::dummy(vec![]))
             }
         }
     }
@@ -174,14 +170,14 @@ where
 pub(in crate::solve) fn instantiate_constituent_tys_for_copy_clone_trait<D, I>(
     ecx: &EvalCtxt<'_, D>,
     ty: I::Ty,
-) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>
+) -> Result<ty::Binder<I, Vec<I::Ty>>, NoSolution>
 where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
     match ty.kind() {
         // impl Copy/Clone for FnDef, FnPtr
-        ty::FnDef(..) | ty::FnPtr(..) | ty::Error(_) => Ok(vec![]),
+        ty::FnDef(..) | ty::FnPtr(..) | ty::Error(_) => Ok(ty::Binder::dummy(vec![])),
 
         // Implementations are provided in core
         ty::Uint(_)
@@ -197,7 +193,7 @@ where
 
         // Cannot implement in core, as we can't be generic over patterns yet,
         // so we'd have to list all patterns and type combinations.
-        ty::Pat(ty, ..) => Ok(vec![ty::Binder::dummy(ty)]),
+        ty::Pat(ty, ..) => Ok(ty::Binder::dummy(vec![ty])),
 
         ty::Dynamic(..)
         | ty::Str
@@ -215,14 +211,14 @@ where
         }
 
         // impl Copy/Clone for (T1, T2, .., Tn) where T1: Copy/Clone, T2: Copy/Clone, .. Tn: Copy/Clone
-        ty::Tuple(tys) => Ok(tys.iter().map(ty::Binder::dummy).collect()),
+        ty::Tuple(tys) => Ok(ty::Binder::dummy(tys.to_vec())),
 
         // impl Copy/Clone for Closure where Self::TupledUpvars: Copy/Clone
-        ty::Closure(_, args) => Ok(vec![ty::Binder::dummy(args.as_closure().tupled_upvars_ty())]),
+        ty::Closure(_, args) => Ok(ty::Binder::dummy(vec![args.as_closure().tupled_upvars_ty()])),
 
         // impl Copy/Clone for CoroutineClosure where Self::TupledUpvars: Copy/Clone
         ty::CoroutineClosure(_, args) => {
-            Ok(vec![ty::Binder::dummy(args.as_coroutine_closure().tupled_upvars_ty())])
+            Ok(ty::Binder::dummy(vec![args.as_coroutine_closure().tupled_upvars_ty()]))
         }
 
         // only when `coroutine_clone` is enabled and the coroutine is movable
@@ -232,10 +228,7 @@ where
             Movability::Movable => {
                 if ecx.cx().features().coroutine_clone() {
                     let coroutine = args.as_coroutine();
-                    Ok(vec![
-                        ty::Binder::dummy(coroutine.tupled_upvars_ty()),
-                        ty::Binder::dummy(coroutine.witness()),
-                    ])
+                    Ok(ty::Binder::dummy(vec![coroutine.tupled_upvars_ty(), coroutine.witness()]))
                 } else {
                     Err(NoSolution)
                 }
@@ -247,10 +240,9 @@ where
         // impl Copy/Clone for CoroutineWitness where T: Copy/Clone forall T in coroutine_hidden_types
         ty::CoroutineWitness(def_id, args) => Ok(ecx
             .cx()
-            .bound_coroutine_hidden_types(def_id)
-            .into_iter()
-            .map(|bty| bty.instantiate(ecx.cx(), args))
-            .collect()),
+            .coroutine_hidden_types(def_id)
+            .instantiate(ecx.cx(), args)
+            .map_bound(|tys| tys.to_vec())),
     }
 }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
index 2491f09a0e28..ce53a3968c7a 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/canonical.rs
@@ -21,7 +21,7 @@ use tracing::{debug, instrument, trace};
 use crate::canonicalizer::Canonicalizer;
 use crate::delegate::SolverDelegate;
 use crate::resolve::EagerResolver;
-use crate::solve::eval_ctxt::NestedGoals;
+use crate::solve::eval_ctxt::{CurrentGoalKind, NestedGoals};
 use crate::solve::{
     CanonicalInput, CanonicalResponse, Certainty, EvalCtxt, ExternalConstraintsData, Goal,
     MaybeCause, NestedNormalizationGoals, NoSolution, PredefinedOpaquesData, QueryInput,
@@ -109,18 +109,22 @@ where
         //
         // As we return all ambiguous nested goals, we can ignore the certainty returned
         // by `try_evaluate_added_goals()`.
-        let (certainty, normalization_nested_goals) = if self.is_normalizes_to_goal {
-            let NestedGoals { normalizes_to_goals, goals } = std::mem::take(&mut self.nested_goals);
-            if cfg!(debug_assertions) {
-                assert!(normalizes_to_goals.is_empty());
-                if goals.is_empty() {
-                    assert!(matches!(goals_certainty, Certainty::Yes));
+        let (certainty, normalization_nested_goals) = match self.current_goal_kind {
+            CurrentGoalKind::NormalizesTo => {
+                let NestedGoals { normalizes_to_goals, goals } =
+                    std::mem::take(&mut self.nested_goals);
+                if cfg!(debug_assertions) {
+                    assert!(normalizes_to_goals.is_empty());
+                    if goals.is_empty() {
+                        assert!(matches!(goals_certainty, Certainty::Yes));
+                    }
                 }
+                (certainty, NestedNormalizationGoals(goals))
+            }
+            CurrentGoalKind::Misc | CurrentGoalKind::CoinductiveTrait => {
+                let certainty = certainty.unify_with(goals_certainty);
+                (certainty, NestedNormalizationGoals::empty())
             }
-            (certainty, NestedNormalizationGoals(goals))
-        } else {
-            let certainty = certainty.unify_with(goals_certainty);
-            (certainty, NestedNormalizationGoals::empty())
         };
 
         if let Certainty::Maybe(cause @ MaybeCause::Overflow { .. }) = certainty {
@@ -163,19 +167,24 @@ where
         // ambiguous alias types which get replaced with fresh inference variables
         // during generalization. This prevents hangs caused by an exponential blowup,
         // see tests/ui/traits/next-solver/coherence-alias-hang.rs.
-        //
-        // We don't do so for `NormalizesTo` goals as we erased the expected term and
-        // bailing with overflow here would prevent us from detecting a type-mismatch,
-        // causing a coherence error in diesel, see #131969. We still bail with overflow
-        // when later returning from the parent AliasRelate goal.
-        if !self.is_normalizes_to_goal {
-            let num_non_region_vars =
-                canonical.variables.iter().filter(|c| !c.is_region() && c.is_existential()).count();
-            if num_non_region_vars > self.cx().recursion_limit() {
-                debug!(?num_non_region_vars, "too many inference variables -> overflow");
-                return Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Overflow {
-                    suggest_increasing_limit: true,
-                }));
+        match self.current_goal_kind {
+            // We don't do so for `NormalizesTo` goals as we erased the expected term and
+            // bailing with overflow here would prevent us from detecting a type-mismatch,
+            // causing a coherence error in diesel, see #131969. We still bail with overflow
+            // when later returning from the parent AliasRelate goal.
+            CurrentGoalKind::NormalizesTo => {}
+            CurrentGoalKind::Misc | CurrentGoalKind::CoinductiveTrait => {
+                let num_non_region_vars = canonical
+                    .variables
+                    .iter()
+                    .filter(|c| !c.is_region() && c.is_existential())
+                    .count();
+                if num_non_region_vars > self.cx().recursion_limit() {
+                    debug!(?num_non_region_vars, "too many inference variables -> overflow");
+                    return Ok(self.make_ambiguous_response_no_constraints(MaybeCause::Overflow {
+                        suggest_increasing_limit: true,
+                    }));
+                }
             }
         }
 
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
index b0a34b9ce756..b0bbec489471 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs
@@ -9,6 +9,7 @@ use rustc_type_ir::fold::{TypeFoldable, TypeFolder, TypeSuperFoldable};
 use rustc_type_ir::inherent::*;
 use rustc_type_ir::relate::Relate;
 use rustc_type_ir::relate::solver_relating::RelateExt;
+use rustc_type_ir::search_graph::PathKind;
 use rustc_type_ir::visit::{TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor};
 use rustc_type_ir::{self as ty, CanonicalVarValues, InferCtxtLike, Interner, TypingMode};
 use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
@@ -20,12 +21,51 @@ use crate::solve::inspect::{self, ProofTreeBuilder};
 use crate::solve::search_graph::SearchGraph;
 use crate::solve::{
     CanonicalInput, Certainty, FIXPOINT_STEP_LIMIT, Goal, GoalEvaluationKind, GoalSource,
-    HasChanged, NestedNormalizationGoals, NoSolution, PredefinedOpaquesData, QueryResult,
+    HasChanged, NestedNormalizationGoals, NoSolution, PredefinedOpaquesData, QueryInput,
+    QueryResult,
 };
 
 pub(super) mod canonical;
 mod probe;
 
+/// The kind of goal we're currently proving.
+///
+/// This has effects on cycle handling handling and on how we compute
+/// query responses, see the variant descriptions for more info.
+#[derive(Debug, Copy, Clone)]
+enum CurrentGoalKind {
+    Misc,
+    /// We're proving an trait goal for a coinductive trait, either an auto trait or `Sized`.
+    ///
+    /// These are currently the only goals whose impl where-clauses are considered to be
+    /// productive steps.
+    CoinductiveTrait,
+    /// Unlike other goals, `NormalizesTo` goals act like functions with the expected term
+    /// always being fully unconstrained. This would weaken inference however, as the nested
+    /// goals never get the inference constraints from the actual normalized-to type.
+    ///
+    /// Because of this we return any ambiguous nested goals from `NormalizesTo` to the
+    /// caller when then adds these to its own context. The caller is always an `AliasRelate`
+    /// goal so this never leaks out of the solver.
+    NormalizesTo,
+}
+
+impl CurrentGoalKind {
+    fn from_query_input<I: Interner>(cx: I, input: QueryInput<I, I::Predicate>) -> CurrentGoalKind {
+        match input.goal.predicate.kind().skip_binder() {
+            ty::PredicateKind::Clause(ty::ClauseKind::Trait(pred)) => {
+                if cx.trait_is_coinductive(pred.trait_ref.def_id) {
+                    CurrentGoalKind::CoinductiveTrait
+                } else {
+                    CurrentGoalKind::Misc
+                }
+            }
+            ty::PredicateKind::NormalizesTo(_) => CurrentGoalKind::NormalizesTo,
+            _ => CurrentGoalKind::Misc,
+        }
+    }
+}
+
 pub struct EvalCtxt<'a, D, I = <D as SolverDelegate>::Interner>
 where
     D: SolverDelegate<Interner = I>,
@@ -51,14 +91,10 @@ where
     /// The variable info for the `var_values`, only used to make an ambiguous response
     /// with no constraints.
     variables: I::CanonicalVars,
-    /// Whether we're currently computing a `NormalizesTo` goal. Unlike other goals,
-    /// `NormalizesTo` goals act like functions with the expected term always being
-    /// fully unconstrained. This would weaken inference however, as the nested goals
-    /// never get the inference constraints from the actual normalized-to type. Because
-    /// of this we return any ambiguous nested goals from `NormalizesTo` to the caller
-    /// when then adds these to its own context. The caller is always an `AliasRelate`
-    /// goal so this never leaks out of the solver.
-    is_normalizes_to_goal: bool,
+
+    /// What kind of goal we're currently computing, see the enum definition
+    /// for more info.
+    current_goal_kind: CurrentGoalKind,
     pub(super) var_values: CanonicalVarValues<I>,
 
     predefined_opaques_in_body: I::PredefinedOpaques,
@@ -226,8 +262,22 @@ where
         self.delegate.typing_mode()
     }
 
-    pub(super) fn set_is_normalizes_to_goal(&mut self) {
-        self.is_normalizes_to_goal = true;
+    /// Computes the `PathKind` for the step from the current goal to the
+    /// nested goal required due to `source`.
+    ///
+    /// See #136824 for a more detailed reasoning for this behavior. We
+    /// consider cycles to be coinductive if they 'step into' a where-clause
+    /// of a coinductive trait. We will likely extend this function in the future
+    /// and will need to clearly document it in the rustc-dev-guide before
+    /// stabilization.
+    pub(super) fn step_kind_for_source(&self, source: GoalSource) -> PathKind {
+        match (self.current_goal_kind, source) {
+            (_, GoalSource::NormalizeGoal(step_kind)) => step_kind,
+            (CurrentGoalKind::CoinductiveTrait, GoalSource::ImplWhereBound) => {
+                PathKind::Coinductive
+            }
+            _ => PathKind::Inductive,
+        }
     }
 
     /// Creates a root evaluation context and search graph. This should only be
@@ -256,7 +306,7 @@ where
             max_input_universe: ty::UniverseIndex::ROOT,
             variables: Default::default(),
             var_values: CanonicalVarValues::dummy(),
-            is_normalizes_to_goal: false,
+            current_goal_kind: CurrentGoalKind::Misc,
             origin_span,
             tainted: Ok(()),
         };
@@ -294,7 +344,7 @@ where
             delegate,
             variables: canonical_input.canonical.variables,
             var_values,
-            is_normalizes_to_goal: false,
+            current_goal_kind: CurrentGoalKind::from_query_input(cx, input),
             predefined_opaques_in_body: input.predefined_opaques_in_body,
             max_input_universe: canonical_input.canonical.max_universe,
             search_graph,
@@ -340,6 +390,7 @@ where
         cx: I,
         search_graph: &'a mut SearchGraph<D>,
         canonical_input: CanonicalInput<I>,
+        step_kind_from_parent: PathKind,
         goal_evaluation: &mut ProofTreeBuilder<D>,
     ) -> QueryResult<I> {
         let mut canonical_goal_evaluation =
@@ -352,6 +403,7 @@ where
             search_graph.with_new_goal(
                 cx,
                 canonical_input,
+                step_kind_from_parent,
                 &mut canonical_goal_evaluation,
                 |search_graph, canonical_goal_evaluation| {
                     EvalCtxt::enter_canonical(
@@ -395,12 +447,10 @@ where
     /// `NormalizesTo` is only used by `AliasRelate`, all other callsites
     /// should use [`EvalCtxt::evaluate_goal`] which discards that empty
     /// storage.
-    // FIXME(-Znext-solver=coinduction): `_source` is currently unused but will
-    // be necessary once we implement the new coinduction approach.
     pub(super) fn evaluate_goal_raw(
         &mut self,
         goal_evaluation_kind: GoalEvaluationKind,
-        _source: GoalSource,
+        source: GoalSource,
         goal: Goal<I, I::Predicate>,
     ) -> Result<(NestedNormalizationGoals<I>, HasChanged, Certainty), NoSolution> {
         let (orig_values, canonical_goal) = self.canonicalize_goal(goal);
@@ -410,6 +460,7 @@ where
             self.cx(),
             self.search_graph,
             canonical_goal,
+            self.step_kind_for_source(source),
             &mut goal_evaluation,
         );
         let response = match canonical_response {
@@ -630,8 +681,11 @@ where
 
     #[instrument(level = "trace", skip(self))]
     pub(super) fn add_normalizes_to_goal(&mut self, mut goal: Goal<I, ty::NormalizesTo<I>>) {
-        goal.predicate =
-            goal.predicate.fold_with(&mut ReplaceAliasWithInfer::new(self, goal.param_env));
+        goal.predicate = goal.predicate.fold_with(&mut ReplaceAliasWithInfer::new(
+            self,
+            GoalSource::Misc,
+            goal.param_env,
+        ));
         self.inspect.add_normalizes_to_goal(self.delegate, self.max_input_universe, goal);
         self.nested_goals.normalizes_to_goals.push(goal);
     }
@@ -639,7 +693,7 @@ where
     #[instrument(level = "debug", skip(self))]
     pub(super) fn add_goal(&mut self, source: GoalSource, mut goal: Goal<I, I::Predicate>) {
         goal.predicate =
-            goal.predicate.fold_with(&mut ReplaceAliasWithInfer::new(self, goal.param_env));
+            goal.predicate.fold_with(&mut ReplaceAliasWithInfer::new(self, source, goal.param_env));
         self.inspect.add_goal(self.delegate, self.max_input_universe, source, goal);
         self.nested_goals.goals.push((source, goal));
     }
@@ -913,7 +967,7 @@ where
 
     /// `enter_forall`, but takes `&mut self` and passes it back through the
     /// callback since it can't be aliased during the call.
-    pub(super) fn enter_forall<T: TypeFoldable<I> + Copy, U>(
+    pub(super) fn enter_forall<T: TypeFoldable<I>, U>(
         &mut self,
         value: ty::Binder<I, T>,
         f: impl FnOnce(&mut Self, T) -> U,
@@ -1037,12 +1091,11 @@ where
 
     pub(super) fn is_transmutable(
         &mut self,
-        param_env: I::ParamEnv,
         dst: I::Ty,
         src: I::Ty,
         assume: I::Const,
     ) -> Result<Certainty, NoSolution> {
-        self.delegate.is_transmutable(param_env, dst, src, assume)
+        self.delegate.is_transmutable(dst, src, assume)
     }
 }
 
@@ -1053,6 +1106,13 @@ where
 ///
 /// This is a performance optimization to more eagerly detect cycles during trait
 /// solving. See tests/ui/traits/next-solver/cycles/cycle-modulo-ambig-aliases.rs.
+///
+/// The emitted goals get evaluated in the context of the parent goal; by
+/// replacing aliases in nested goals we essentially pull the normalization out of
+/// the nested goal. We want to treat the goal as if the normalization still happens
+/// inside of the nested goal by inheriting the `step_kind` of the nested goal and
+/// storing it in the `GoalSource` of the emitted `AliasRelate` goals.
+/// This is necessary for tests/ui/sized/coinductive-1.rs to compile.
 struct ReplaceAliasWithInfer<'me, 'a, D, I>
 where
     D: SolverDelegate<Interner = I>,
@@ -1060,6 +1120,7 @@ where
 {
     ecx: &'me mut EvalCtxt<'a, D>,
     param_env: I::ParamEnv,
+    normalization_goal_source: GoalSource,
     cache: HashMap<I::Ty, I::Ty>,
 }
 
@@ -1068,8 +1129,18 @@ where
     D: SolverDelegate<Interner = I>,
     I: Interner,
 {
-    fn new(ecx: &'me mut EvalCtxt<'a, D>, param_env: I::ParamEnv) -> Self {
-        ReplaceAliasWithInfer { ecx, param_env, cache: Default::default() }
+    fn new(
+        ecx: &'me mut EvalCtxt<'a, D>,
+        for_goal_source: GoalSource,
+        param_env: I::ParamEnv,
+    ) -> Self {
+        let step_kind = ecx.step_kind_for_source(for_goal_source);
+        ReplaceAliasWithInfer {
+            ecx,
+            param_env,
+            normalization_goal_source: GoalSource::NormalizeGoal(step_kind),
+            cache: Default::default(),
+        }
     }
 }
 
@@ -1092,7 +1163,7 @@ where
                     ty::AliasRelationDirection::Equate,
                 );
                 self.ecx.add_goal(
-                    GoalSource::Misc,
+                    self.normalization_goal_source,
                     Goal::new(self.cx(), self.param_env, normalizes_to),
                 );
                 infer_ty
@@ -1121,7 +1192,7 @@ where
                     ty::AliasRelationDirection::Equate,
                 );
                 self.ecx.add_goal(
-                    GoalSource::Misc,
+                    self.normalization_goal_source,
                     Goal::new(self.cx(), self.param_env, normalizes_to),
                 );
                 infer_ct
diff --git a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs
index add96a1fdf7a..0a9e7fafaea6 100644
--- a/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/eval_ctxt/probe.rs
@@ -34,7 +34,7 @@ where
             delegate,
             variables: outer_ecx.variables,
             var_values: outer_ecx.var_values,
-            is_normalizes_to_goal: outer_ecx.is_normalizes_to_goal,
+            current_goal_kind: outer_ecx.current_goal_kind,
             predefined_opaques_in_body: outer_ecx.predefined_opaques_in_body,
             max_input_universe,
             search_graph: outer_ecx.search_graph,
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs
index 25e8708a3322..1d1ff09ee410 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/inherent.rs
@@ -39,7 +39,7 @@ where
         //
         // FIXME(-Znext-solver=coinductive): I think this should be split
         // and we tag the impl bounds with `GoalSource::ImplWhereBound`?
-        // Right not this includes both the impl and the assoc item where bounds,
+        // Right now this includes both the impl and the assoc item where bounds,
         // and I don't think the assoc item where-bounds are allowed to be coinductive.
         self.add_goals(
             GoalSource::Misc,
diff --git a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
index 88002e1a88a8..de6d21da0f59 100644
--- a/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs
@@ -28,7 +28,6 @@ where
         &mut self,
         goal: Goal<I, NormalizesTo<I>>,
     ) -> QueryResult<I> {
-        self.set_is_normalizes_to_goal();
         debug_assert!(self.term_is_fully_unconstrained(goal));
         let cx = self.cx();
         match goal.predicate.alias.kind(cx) {
diff --git a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
index 843200ca184e..67eb442d2cce 100644
--- a/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/search_graph.rs
@@ -2,7 +2,6 @@ use std::convert::Infallible;
 use std::marker::PhantomData;
 
 use rustc_type_ir::Interner;
-use rustc_type_ir::inherent::*;
 use rustc_type_ir::search_graph::{self, PathKind};
 use rustc_type_ir::solve::{CanonicalInput, Certainty, QueryResult};
 
@@ -94,10 +93,6 @@ where
         let certainty = from_result.unwrap().value.certainty;
         response_no_constraints(cx, for_input, certainty)
     }
-
-    fn step_is_coinductive(cx: I, input: CanonicalInput<I>) -> bool {
-        input.canonical.value.goal.predicate.is_coinductive(cx)
-    }
 }
 
 fn response_no_constraints<I: Interner>(
diff --git a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
index 1665dbb30189..1b18142c2427 100644
--- a/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
+++ b/compiler/rustc_next_trait_solver/src/solve/trait_goals.rs
@@ -617,7 +617,6 @@ where
             )?;
 
             let certainty = ecx.is_transmutable(
-                goal.param_env,
                 goal.predicate.trait_ref.args.type_at(0),
                 goal.predicate.trait_ref.args.type_at(1),
                 assume,
@@ -1239,17 +1238,15 @@ where
         constituent_tys: impl Fn(
             &EvalCtxt<'_, D>,
             I::Ty,
-        ) -> Result<Vec<ty::Binder<I, I::Ty>>, NoSolution>,
+        ) -> Result<ty::Binder<I, Vec<I::Ty>>, NoSolution>,
     ) -> Result<Candidate<I>, NoSolution> {
         self.probe_trait_candidate(source).enter(|ecx| {
-            let goals = constituent_tys(ecx, goal.predicate.self_ty())?
-                .into_iter()
-                .map(|ty| {
-                    ecx.enter_forall(ty, |ecx, ty| {
-                        goal.with(ecx.cx(), goal.predicate.with_self_ty(ecx.cx(), ty))
-                    })
-                })
-                .collect::<Vec<_>>();
+            let goals =
+                ecx.enter_forall(constituent_tys(ecx, goal.predicate.self_ty())?, |ecx, tys| {
+                    tys.into_iter()
+                        .map(|ty| goal.with(ecx.cx(), goal.predicate.with_self_ty(ecx.cx(), ty)))
+                        .collect::<Vec<_>>()
+                });
             ecx.add_goals(GoalSource::ImplWhereBound, goals);
             ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         })
diff --git a/compiler/rustc_parse/messages.ftl b/compiler/rustc_parse/messages.ftl
index 563081c7240c..1d5b59421706 100644
--- a/compiler/rustc_parse/messages.ftl
+++ b/compiler/rustc_parse/messages.ftl
@@ -424,7 +424,7 @@ parse_invalid_logical_operator = `{$incorrect}` is not a logical operator
     .use_amp_amp_for_conjunction = use `&&` to perform logical conjunction
     .use_pipe_pipe_for_disjunction = use `||` to perform logical disjunction
 
-parse_invalid_meta_item = expected unsuffixed literal, found `{$token}`
+parse_invalid_meta_item = expected unsuffixed literal, found {$descr}
     .quote_ident_sugg = surround the identifier with quotation marks to make it into a string literal
 
 parse_invalid_offset_of = offset_of expects dot-separated field and variant names
diff --git a/compiler/rustc_parse/src/errors.rs b/compiler/rustc_parse/src/errors.rs
index dc03d6f9521d..8d2fd595942c 100644
--- a/compiler/rustc_parse/src/errors.rs
+++ b/compiler/rustc_parse/src/errors.rs
@@ -772,7 +772,6 @@ pub(crate) struct LabeledLoopInBreak {
 }
 
 #[derive(Subdiagnostic)]
-
 pub(crate) enum WrapInParentheses {
     #[multipart_suggestion(
         parse_sugg_wrap_expression_in_parentheses,
@@ -1025,7 +1024,7 @@ pub(crate) struct SuffixedLiteralInAttribute {
 pub(crate) struct InvalidMetaItem {
     #[primary_span]
     pub span: Span,
-    pub token: Token,
+    pub descr: String,
     #[subdiagnostic]
     pub quote_ident_sugg: Option<InvalidMetaItemQuoteIdentSugg>,
 }
@@ -2923,8 +2922,9 @@ pub(crate) struct AddBoxNew {
 #[diag(parse_bad_return_type_notation_output)]
 pub(crate) struct BadReturnTypeNotationOutput {
     #[primary_span]
-    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
     pub span: Span,
+    #[suggestion(code = "", applicability = "maybe-incorrect", style = "verbose")]
+    pub suggestion: Span,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_parse/src/parser/attr.rs b/compiler/rustc_parse/src/parser/attr.rs
index 2691e6f56d68..98fdd35190d8 100644
--- a/compiler/rustc_parse/src/parser/attr.rs
+++ b/compiler/rustc_parse/src/parser/attr.rs
@@ -1,4 +1,6 @@
-use rustc_ast::{self as ast, Attribute, attr, token};
+use rustc_ast as ast;
+use rustc_ast::token::{self, MetaVarKind};
+use rustc_ast::{Attribute, attr};
 use rustc_errors::codes::*;
 use rustc_errors::{Diag, PResult};
 use rustc_span::{BytePos, Span};
@@ -9,7 +11,7 @@ use super::{
     AttrWrapper, Capturing, FnParseMode, ForceCollect, Parser, ParserRange, PathStyle, Trailing,
     UsePreAttrPos,
 };
-use crate::{errors, exp, fluent_generated as fluent, maybe_whole};
+use crate::{errors, exp, fluent_generated as fluent};
 
 // Public for rustfmt usage
 #[derive(Debug)]
@@ -269,7 +271,12 @@ impl<'a> Parser<'a> {
     ///     PATH `=` UNSUFFIXED_LIT
     /// The delimiters or `=` are still put into the resulting token stream.
     pub fn parse_attr_item(&mut self, force_collect: ForceCollect) -> PResult<'a, ast::AttrItem> {
-        maybe_whole!(self, NtMeta, |attr| attr.into_inner());
+        if let Some(item) = self.eat_metavar_seq_with_matcher(
+            |mv_kind| matches!(mv_kind, MetaVarKind::Meta { .. }),
+            |this| this.parse_attr_item(force_collect),
+        ) {
+            return Ok(item);
+        }
 
         // Attr items don't have attributes.
         self.collect_tokens(None, AttrWrapper::empty(), force_collect, |this, _empty_attrs| {
@@ -396,18 +403,17 @@ impl<'a> Parser<'a> {
         &mut self,
         unsafe_allowed: AllowLeadingUnsafe,
     ) -> PResult<'a, ast::MetaItem> {
-        // We can't use `maybe_whole` here because it would bump in the `None`
-        // case, which we don't want.
-        if let token::Interpolated(nt) = &self.token.kind
-            && let token::NtMeta(attr_item) = &**nt
-        {
-            match attr_item.meta(attr_item.path.span) {
-                Some(meta) => {
-                    self.bump();
-                    return Ok(meta);
-                }
-                None => self.unexpected()?,
-            }
+        if let Some(MetaVarKind::Meta { has_meta_form }) = self.token.is_metavar_seq() {
+            return if has_meta_form {
+                let attr_item = self
+                    .eat_metavar_seq(MetaVarKind::Meta { has_meta_form: true }, |this| {
+                        this.parse_attr_item(ForceCollect::No)
+                    })
+                    .unwrap();
+                Ok(attr_item.meta(attr_item.path.span).unwrap())
+            } else {
+                self.unexpected_any()
+            };
         }
 
         let lo = self.token.span;
@@ -464,7 +470,7 @@ impl<'a> Parser<'a> {
 
         let mut err = errors::InvalidMetaItem {
             span: self.token.span,
-            token: self.token.clone(),
+            descr: super::token_descr(&self.token),
             quote_ident_sugg: None,
         };
 
diff --git a/compiler/rustc_parse/src/parser/diagnostics.rs b/compiler/rustc_parse/src/parser/diagnostics.rs
index 67abc2d53940..02bcb1fbf702 100644
--- a/compiler/rustc_parse/src/parser/diagnostics.rs
+++ b/compiler/rustc_parse/src/parser/diagnostics.rs
@@ -1,17 +1,15 @@
 use std::mem::take;
 use std::ops::{Deref, DerefMut};
-use std::sync::Arc;
 
 use ast::token::IdentIsRaw;
 use rustc_ast as ast;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter, Lit, LitKind, Token, TokenKind};
-use rustc_ast::tokenstream::AttrTokenTree;
 use rustc_ast::util::parser::AssocOp;
 use rustc_ast::{
     AngleBracketedArg, AngleBracketedArgs, AnonConst, AttrVec, BinOpKind, BindingMode, Block,
-    BlockCheckMode, Expr, ExprKind, GenericArg, Generics, HasTokens, Item, ItemKind, Param, Pat,
-    PatKind, Path, PathSegment, QSelf, Recovered, Ty, TyKind,
+    BlockCheckMode, Expr, ExprKind, GenericArg, Generics, Item, ItemKind, Param, Pat, PatKind,
+    Path, PathSegment, QSelf, Recovered, Ty, TyKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashSet;
@@ -1350,13 +1348,13 @@ impl<'a> Parser<'a> {
             }
             return match (op.node, &outer_op.node) {
                 // `x == y == z`
-                (BinOpKind::Eq, AssocOp::Equal) |
+                (BinOpKind::Eq, AssocOp::Binary(BinOpKind::Eq)) |
                 // `x < y < z` and friends.
-                (BinOpKind::Lt, AssocOp::Less | AssocOp::LessEqual) |
-                (BinOpKind::Le, AssocOp::LessEqual | AssocOp::Less) |
+                (BinOpKind::Lt, AssocOp::Binary(BinOpKind::Lt | BinOpKind::Le)) |
+                (BinOpKind::Le, AssocOp::Binary(BinOpKind::Lt | BinOpKind::Le)) |
                 // `x > y > z` and friends.
-                (BinOpKind::Gt, AssocOp::Greater | AssocOp::GreaterEqual) |
-                (BinOpKind::Ge, AssocOp::GreaterEqual | AssocOp::Greater) => {
+                (BinOpKind::Gt, AssocOp::Binary(BinOpKind::Gt | BinOpKind::Ge)) |
+                (BinOpKind::Ge, AssocOp::Binary(BinOpKind::Gt | BinOpKind::Ge)) => {
                     let expr_to_str = |e: &Expr| {
                         self.span_to_snippet(e.span)
                             .unwrap_or_else(|_| pprust::expr_to_string(e))
@@ -1368,7 +1366,10 @@ impl<'a> Parser<'a> {
                     false // Keep the current parse behavior, where the AST is `(x < y) < z`.
                 }
                 // `x == y < z`
-                (BinOpKind::Eq, AssocOp::Less | AssocOp::LessEqual | AssocOp::Greater | AssocOp::GreaterEqual) => {
+                (
+                    BinOpKind::Eq,
+                    AssocOp::Binary(BinOpKind::Lt | BinOpKind::Le | BinOpKind::Gt | BinOpKind::Ge)
+                ) => {
                     // Consume `z`/outer-op-rhs.
                     let snapshot = self.create_snapshot_for_diagnostic();
                     match self.parse_expr() {
@@ -1389,7 +1390,10 @@ impl<'a> Parser<'a> {
                     }
                 }
                 // `x > y == z`
-                (BinOpKind::Lt | BinOpKind::Le | BinOpKind::Gt | BinOpKind::Ge, AssocOp::Equal) => {
+                (
+                    BinOpKind::Lt | BinOpKind::Le | BinOpKind::Gt | BinOpKind::Ge,
+                    AssocOp::Binary(BinOpKind::Eq)
+                ) => {
                     let snapshot = self.create_snapshot_for_diagnostic();
                     // At this point it is always valid to enclose the lhs in parentheses, no
                     // further checks are necessary.
@@ -1457,10 +1461,10 @@ impl<'a> Parser<'a> {
 
                 // Include `<` to provide this recommendation even in a case like
                 // `Foo<Bar<Baz<Qux, ()>>>`
-                if op.node == BinOpKind::Lt && outer_op.node == AssocOp::Less
-                    || outer_op.node == AssocOp::Greater
+                if op.node == BinOpKind::Lt && outer_op.node == AssocOp::Binary(BinOpKind::Lt)
+                    || outer_op.node == AssocOp::Binary(BinOpKind::Gt)
                 {
-                    if outer_op.node == AssocOp::Less {
+                    if outer_op.node == AssocOp::Binary(BinOpKind::Lt) {
                         let snapshot = self.create_snapshot_for_diagnostic();
                         self.bump();
                         // So far we have parsed `foo<bar<`, consume the rest of the type args.
@@ -2400,52 +2404,6 @@ impl<'a> Parser<'a> {
             err.subdiagnostic(ExprParenthesesNeeded::surrounding(*sp));
         }
         err.span_label(span, "expected expression");
-
-        // Walk the chain of macro expansions for the current token to point at how the original
-        // code was interpreted. This helps the user realize when a macro argument of one type is
-        // later reinterpreted as a different type, like `$x:expr` being reinterpreted as `$x:pat`
-        // in a subsequent macro invocation (#71039).
-        let mut tok = self.token.clone();
-        let mut labels = vec![];
-        while let TokenKind::Interpolated(nt) = &tok.kind {
-            let tokens = nt.tokens();
-            labels.push(Arc::clone(nt));
-            if let Some(tokens) = tokens
-                && let tokens = tokens.to_attr_token_stream()
-                && let tokens = tokens.0.deref()
-                && let [AttrTokenTree::Token(token, _)] = &tokens[..]
-            {
-                tok = token.clone();
-            } else {
-                break;
-            }
-        }
-        let mut iter = labels.into_iter().peekable();
-        let mut show_link = false;
-        while let Some(nt) = iter.next() {
-            let descr = nt.descr();
-            if let Some(next) = iter.peek() {
-                let next_descr = next.descr();
-                if next_descr != descr {
-                    err.span_label(next.use_span(), format!("this is expected to be {next_descr}"));
-                    err.span_label(
-                        nt.use_span(),
-                        format!(
-                            "this is interpreted as {}, but it is expected to be {}",
-                            next_descr, descr,
-                        ),
-                    );
-                    show_link = true;
-                }
-            }
-        }
-        if show_link {
-            err.note(
-                "when forwarding a matched fragment to another macro-by-example, matchers in the \
-                 second macro will see an opaque AST of the fragment type, not the underlying \
-                 tokens",
-            );
-        }
         err
     }
 
@@ -2635,10 +2593,12 @@ impl<'a> Parser<'a> {
     ) -> PResult<'a, GenericArg> {
         let is_op_or_dot = AssocOp::from_token(&self.token)
             .and_then(|op| {
-                if let AssocOp::Greater
-                | AssocOp::Less
-                | AssocOp::ShiftRight
-                | AssocOp::GreaterEqual
+                if let AssocOp::Binary(
+                    BinOpKind::Gt
+                    | BinOpKind::Lt
+                    | BinOpKind::Shr
+                    | BinOpKind::Ge
+                )
                 // Don't recover from `foo::<bar = baz>`, because this could be an attempt to
                 // assign a value to a defaulted generic parameter.
                 | AssocOp::Assign
diff --git a/compiler/rustc_parse/src/parser/expr.rs b/compiler/rustc_parse/src/parser/expr.rs
index b2e58c942806..ef29ac2719d9 100644
--- a/compiler/rustc_parse/src/parser/expr.rs
+++ b/compiler/rustc_parse/src/parser/expr.rs
@@ -4,7 +4,7 @@ use core::mem;
 use core::ops::{Bound, ControlFlow};
 
 use ast::mut_visit::{self, MutVisitor};
-use ast::token::IdentIsRaw;
+use ast::token::{IdentIsRaw, MetaVarKind};
 use ast::{CoroutineKind, ForLoopKind, GenBlockKind, MatchKind, Pat, Path, PathSegment, Recovered};
 use rustc_ast::ptr::P;
 use rustc_ast::token::{self, Delimiter, Token, TokenKind};
@@ -171,7 +171,7 @@ impl<'a> Parser<'a> {
                 break;
             }
             // Check for deprecated `...` syntax
-            if self.token == token::DotDotDot && op.node == AssocOp::DotDotEq {
+            if self.token == token::DotDotDot && op.node == AssocOp::Range(RangeLimits::Closed) {
                 self.err_dotdotdot_syntax(self.token.span);
             }
 
@@ -188,17 +188,12 @@ impl<'a> Parser<'a> {
             }
 
             // Look for JS' `===` and `!==` and recover
-            if (op.node == AssocOp::Equal || op.node == AssocOp::NotEqual)
+            if let AssocOp::Binary(bop @ BinOpKind::Eq | bop @ BinOpKind::Ne) = op.node
                 && self.token == token::Eq
                 && self.prev_token.span.hi() == self.token.span.lo()
             {
                 let sp = op.span.to(self.token.span);
-                let sugg = match op.node {
-                    AssocOp::Equal => "==",
-                    AssocOp::NotEqual => "!=",
-                    _ => unreachable!(),
-                }
-                .into();
+                let sugg = bop.as_str().into();
                 let invalid = format!("{sugg}=");
                 self.dcx().emit_err(errors::InvalidComparisonOperator {
                     span: sp,
@@ -213,7 +208,7 @@ impl<'a> Parser<'a> {
             }
 
             // Look for PHP's `<>` and recover
-            if op.node == AssocOp::Less
+            if op.node == AssocOp::Binary(BinOpKind::Lt)
                 && self.token == token::Gt
                 && self.prev_token.span.hi() == self.token.span.lo()
             {
@@ -231,7 +226,7 @@ impl<'a> Parser<'a> {
             }
 
             // Look for C++'s `<=>` and recover
-            if op.node == AssocOp::LessEqual
+            if op.node == AssocOp::Binary(BinOpKind::Le)
                 && self.token == token::Gt
                 && self.prev_token.span.hi() == self.token.span.lo()
             {
@@ -269,13 +264,13 @@ impl<'a> Parser<'a> {
 
             let op = op.node;
             // Special cases:
-            if op == AssocOp::As {
+            if op == AssocOp::Cast {
                 lhs = self.parse_assoc_op_cast(lhs, lhs_span, ExprKind::Cast)?;
                 continue;
-            } else if op == AssocOp::DotDot || op == AssocOp::DotDotEq {
+            } else if let AssocOp::Range(limits) = op {
                 // If we didn't have to handle `x..`/`x..=`, it would be pretty easy to
                 // generalise it to the Fixity::None code.
-                lhs = self.parse_expr_range(prec, lhs, op, cur_op_span)?;
+                lhs = self.parse_expr_range(prec, lhs, limits, cur_op_span)?;
                 break;
             }
 
@@ -290,46 +285,16 @@ impl<'a> Parser<'a> {
 
             let span = self.mk_expr_sp(&lhs, lhs_span, rhs.span);
             lhs = match op {
-                AssocOp::Add
-                | AssocOp::Subtract
-                | AssocOp::Multiply
-                | AssocOp::Divide
-                | AssocOp::Modulus
-                | AssocOp::LAnd
-                | AssocOp::LOr
-                | AssocOp::BitXor
-                | AssocOp::BitAnd
-                | AssocOp::BitOr
-                | AssocOp::ShiftLeft
-                | AssocOp::ShiftRight
-                | AssocOp::Equal
-                | AssocOp::Less
-                | AssocOp::LessEqual
-                | AssocOp::NotEqual
-                | AssocOp::Greater
-                | AssocOp::GreaterEqual => {
-                    let ast_op = op.to_ast_binop().unwrap();
+                AssocOp::Binary(ast_op) => {
                     let binary = self.mk_binary(source_map::respan(cur_op_span, ast_op), lhs, rhs);
                     self.mk_expr(span, binary)
                 }
                 AssocOp::Assign => self.mk_expr(span, ExprKind::Assign(lhs, rhs, cur_op_span)),
-                AssocOp::AssignOp(k) => {
-                    let aop = match k {
-                        token::Plus => BinOpKind::Add,
-                        token::Minus => BinOpKind::Sub,
-                        token::Star => BinOpKind::Mul,
-                        token::Slash => BinOpKind::Div,
-                        token::Percent => BinOpKind::Rem,
-                        token::Caret => BinOpKind::BitXor,
-                        token::And => BinOpKind::BitAnd,
-                        token::Or => BinOpKind::BitOr,
-                        token::Shl => BinOpKind::Shl,
-                        token::Shr => BinOpKind::Shr,
-                    };
+                AssocOp::AssignOp(aop) => {
                     let aopexpr = self.mk_assign_op(source_map::respan(cur_op_span, aop), lhs, rhs);
                     self.mk_expr(span, aopexpr)
                 }
-                AssocOp::As | AssocOp::DotDot | AssocOp::DotDotEq => {
+                AssocOp::Cast | AssocOp::Range(_) => {
                     self.dcx().span_bug(span, "AssocOp should have been handled by special case")
                 }
             };
@@ -347,13 +312,14 @@ impl<'a> Parser<'a> {
             // An exhaustive check is done in the following block, but these are checked first
             // because they *are* ambiguous but also reasonable looking incorrect syntax, so we
             // want to keep their span info to improve diagnostics in these cases in a later stage.
-            (true, Some(AssocOp::Multiply)) | // `{ 42 } *foo = bar;` or `{ 42 } * 3`
-            (true, Some(AssocOp::Subtract)) | // `{ 42 } -5`
-            (true, Some(AssocOp::Add)) | // `{ 42 } + 42` (unary plus)
-            (true, Some(AssocOp::LAnd)) | // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`
-            (true, Some(AssocOp::LOr)) | // `{ 42 } || 42` ("logical or" or closure)
-            (true, Some(AssocOp::BitOr)) // `{ 42 } | 42` or `{ 42 } |x| 42`
-            => {
+            (true, Some(AssocOp::Binary(
+                BinOpKind::Mul | // `{ 42 } *foo = bar;` or `{ 42 } * 3`
+                BinOpKind::Sub | // `{ 42 } -5`
+                BinOpKind::Add | // `{ 42 } + 42` (unary plus)
+                BinOpKind::And | // `{ 42 } &&x` (#61475) or `{ 42 } && if x { 1 } else { 0 }`
+                BinOpKind::Or | // `{ 42 } || 42` ("logical or" or closure)
+                BinOpKind::BitOr // `{ 42 } | 42` or `{ 42 } |x| 42`
+            ))) => {
                 // These cases are ambiguous and can't be identified in the parser alone.
                 //
                 // Bitwise AND is left out because guessing intent is hard. We can make
@@ -392,23 +358,21 @@ impl<'a> Parser<'a> {
             // When parsing const expressions, stop parsing when encountering `>`.
             (
                 Some(
-                    AssocOp::ShiftRight
-                    | AssocOp::Greater
-                    | AssocOp::GreaterEqual
-                    | AssocOp::AssignOp(token::BinOpToken::Shr),
+                    AssocOp::Binary(BinOpKind::Shr | BinOpKind::Gt | BinOpKind::Ge)
+                    | AssocOp::AssignOp(BinOpKind::Shr),
                 ),
                 _,
             ) if self.restrictions.contains(Restrictions::CONST_EXPR) => {
                 return None;
             }
-            // When recovering patterns as expressions, stop parsing when encountering an assignment `=`, an alternative `|`, or a range `..`.
+            // When recovering patterns as expressions, stop parsing when encountering an
+            // assignment `=`, an alternative `|`, or a range `..`.
             (
                 Some(
                     AssocOp::Assign
                     | AssocOp::AssignOp(_)
-                    | AssocOp::BitOr
-                    | AssocOp::DotDot
-                    | AssocOp::DotDotEq,
+                    | AssocOp::Binary(BinOpKind::BitOr)
+                    | AssocOp::Range(_),
                 ),
                 _,
             ) if self.restrictions.contains(Restrictions::IS_PAT) => {
@@ -423,7 +387,7 @@ impl<'a> Parser<'a> {
                     incorrect: "and".into(),
                     sub: errors::InvalidLogicalOperatorSub::Conjunction(self.token.span),
                 });
-                (AssocOp::LAnd, span)
+                (AssocOp::Binary(BinOpKind::And), span)
             }
             (None, Some((Ident { name: sym::or, span }, IdentIsRaw::No))) if self.may_recover() => {
                 self.dcx().emit_err(errors::InvalidLogicalOperator {
@@ -431,7 +395,7 @@ impl<'a> Parser<'a> {
                     incorrect: "or".into(),
                     sub: errors::InvalidLogicalOperatorSub::Disjunction(self.token.span),
                 });
-                (AssocOp::LOr, span)
+                (AssocOp::Binary(BinOpKind::Or), span)
             }
             _ => return None,
         };
@@ -449,7 +413,7 @@ impl<'a> Parser<'a> {
         &mut self,
         prec: ExprPrecedence,
         lhs: P<Expr>,
-        op: AssocOp,
+        limits: RangeLimits,
         cur_op_span: Span,
     ) -> PResult<'a, P<Expr>> {
         let rhs = if self.is_at_start_of_range_notation_rhs() {
@@ -465,8 +429,6 @@ impl<'a> Parser<'a> {
         };
         let rhs_span = rhs.as_ref().map_or(cur_op_span, |x| x.span);
         let span = self.mk_expr_sp(&lhs, lhs.span, rhs_span);
-        let limits =
-            if op == AssocOp::DotDot { RangeLimits::HalfOpen } else { RangeLimits::Closed };
         let range = self.mk_range(Some(lhs), rhs, limits);
         Ok(self.mk_expr(span, range))
     }
@@ -1382,6 +1344,7 @@ impl<'a> Parser<'a> {
     fn parse_expr_bottom(&mut self) -> PResult<'a, P<Expr>> {
         maybe_recover_from_interpolated_ty_qpath!(self, true);
 
+        let span = self.token.span;
         if let token::Interpolated(nt) = &self.token.kind {
             match &**nt {
                 token::NtExpr(e) | token::NtLiteral(e) => {
@@ -1389,11 +1352,6 @@ impl<'a> Parser<'a> {
                     self.bump();
                     return Ok(e);
                 }
-                token::NtPath(path) => {
-                    let path = (**path).clone();
-                    self.bump();
-                    return Ok(self.mk_expr(self.prev_token.span, ExprKind::Path(None, path)));
-                }
                 token::NtBlock(block) => {
                     let block = block.clone();
                     self.bump();
@@ -1401,6 +1359,10 @@ impl<'a> Parser<'a> {
                 }
                 _ => {}
             };
+        } else if let Some(path) = self.eat_metavar_seq(MetaVarKind::Path, |this| {
+            this.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))
+        }) {
+            return Ok(self.mk_expr(span, ExprKind::Path(None, path)));
         }
 
         // Outer attributes are already parsed and will be
diff --git a/compiler/rustc_parse/src/parser/item.rs b/compiler/rustc_parse/src/parser/item.rs
index c923717ecaf2..5765a5b5315b 100644
--- a/compiler/rustc_parse/src/parser/item.rs
+++ b/compiler/rustc_parse/src/parser/item.rs
@@ -4,7 +4,7 @@ use std::mem;
 use ast::token::IdentIsRaw;
 use rustc_ast::ast::*;
 use rustc_ast::ptr::P;
-use rustc_ast::token::{self, Delimiter, TokenKind};
+use rustc_ast::token::{self, Delimiter, InvisibleOrigin, MetaVarKind, TokenKind};
 use rustc_ast::tokenstream::{DelimSpan, TokenStream, TokenTree};
 use rustc_ast::util::case::Case;
 use rustc_ast::{self as ast};
@@ -3071,8 +3071,10 @@ impl<'a> Parser<'a> {
 
     fn is_named_param(&self) -> bool {
         let offset = match &self.token.kind {
-            token::Interpolated(nt) => match &**nt {
-                token::NtPat(..) => return self.look_ahead(1, |t| t == &token::Colon),
+            token::OpenDelim(Delimiter::Invisible(origin)) => match origin {
+                InvisibleOrigin::MetaVar(MetaVarKind::Pat(_)) => {
+                    return self.check_noexpect_past_close_delim(&token::Colon);
+                }
                 _ => 0,
             },
             token::BinOp(token::And) | token::AndAnd => 1,
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 80a33a760059..00282ef86799 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -24,7 +24,8 @@ pub use pat::{CommaRecoveryMode, RecoverColon, RecoverComma};
 use path::PathStyle;
 use rustc_ast::ptr::P;
 use rustc_ast::token::{
-    self, Delimiter, IdentIsRaw, InvisibleOrigin, MetaVarKind, Nonterminal, Token, TokenKind,
+    self, Delimiter, IdentIsRaw, InvisibleOrigin, MetaVarKind, Nonterminal, NtPatKind, Token,
+    TokenKind,
 };
 use rustc_ast::tokenstream::{AttrsTarget, Spacing, TokenStream, TokenTree};
 use rustc_ast::util::case::Case;
@@ -1745,7 +1746,10 @@ pub enum ParseNtResult {
     Tt(TokenTree),
     Ident(Ident, IdentIsRaw),
     Lifetime(Ident, IdentIsRaw),
+    Pat(P<ast::Pat>, NtPatKind),
     Ty(P<ast::Ty>),
+    Meta(P<ast::AttrItem>),
+    Path(P<ast::Path>),
     Vis(P<ast::Visibility>),
 
     /// This variant will eventually be removed, along with `Token::Interpolate`.
diff --git a/compiler/rustc_parse/src/parser/nonterminal.rs b/compiler/rustc_parse/src/parser/nonterminal.rs
index f202f85752e1..d537bc17ce37 100644
--- a/compiler/rustc_parse/src/parser/nonterminal.rs
+++ b/compiler/rustc_parse/src/parser/nonterminal.rs
@@ -32,7 +32,7 @@ impl<'a> Parser<'a> {
                 | MetaVarKind::Expr { .. }
                 | MetaVarKind::Ty { .. }
                 | MetaVarKind::Literal // `true`, `false`
-                | MetaVarKind::Meta
+                | MetaVarKind::Meta { .. }
                 | MetaVarKind::Path => true,
 
                 MetaVarKind::Item
@@ -49,11 +49,9 @@ impl<'a> Parser<'a> {
         fn nt_may_be_ident(nt: &Nonterminal) -> bool {
             match nt {
                 NtStmt(_)
-                | NtPat(_)
                 | NtExpr(_)
                 | NtLiteral(_) // `true`, `false`
-                | NtMeta(_)
-                | NtPath(_) => true,
+                => true,
 
                 NtItem(_) | NtBlock(_) => false,
             }
@@ -99,7 +97,7 @@ impl<'a> Parser<'a> {
                 token::NtLifetime(..) => true,
                 token::Interpolated(nt) => match &**nt {
                     NtBlock(_) | NtStmt(_) | NtExpr(_) | NtLiteral(_) => true,
-                    NtItem(_) | NtPat(_) | NtMeta(_) | NtPath(_) => false,
+                    NtItem(_) => false,
                 },
                 token::OpenDelim(Delimiter::Invisible(InvisibleOrigin::MetaVar(k))) => match k {
                     MetaVarKind::Block
@@ -109,7 +107,7 @@ impl<'a> Parser<'a> {
                     MetaVarKind::Item
                     | MetaVarKind::Pat(_)
                     | MetaVarKind::Ty { .. }
-                    | MetaVarKind::Meta
+                    | MetaVarKind::Meta { .. }
                     | MetaVarKind::Path
                     | MetaVarKind::Vis => false,
                     MetaVarKind::Lifetime | MetaVarKind::Ident | MetaVarKind::TT => {
@@ -170,15 +168,18 @@ impl<'a> Parser<'a> {
                 }
             },
             NonterminalKind::Pat(pat_kind) => {
-                NtPat(self.collect_tokens_no_attrs(|this| match pat_kind {
-                    PatParam { .. } => this.parse_pat_no_top_alt(None, None),
-                    PatWithOr => this.parse_pat_no_top_guard(
-                        None,
-                        RecoverComma::No,
-                        RecoverColon::No,
-                        CommaRecoveryMode::EitherTupleOrPipe,
-                    ),
-                })?)
+                return Ok(ParseNtResult::Pat(
+                    self.collect_tokens_no_attrs(|this| match pat_kind {
+                        PatParam { .. } => this.parse_pat_no_top_alt(None, None),
+                        PatWithOr => this.parse_pat_no_top_guard(
+                            None,
+                            RecoverComma::No,
+                            RecoverColon::No,
+                            CommaRecoveryMode::EitherTupleOrPipe,
+                        ),
+                    })?,
+                    pat_kind,
+                ));
             }
             NonterminalKind::Expr(_) => NtExpr(self.parse_expr_force_collect()?),
             NonterminalKind::Literal => {
@@ -203,9 +204,13 @@ impl<'a> Parser<'a> {
                 };
             }
             NonterminalKind::Path => {
-                NtPath(P(self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?))
+                return Ok(ParseNtResult::Path(P(
+                    self.collect_tokens_no_attrs(|this| this.parse_path(PathStyle::Type))?
+                )));
+            }
+            NonterminalKind::Meta => {
+                return Ok(ParseNtResult::Meta(P(self.parse_attr_item(ForceCollect::Yes)?)));
             }
-            NonterminalKind::Meta => NtMeta(P(self.parse_attr_item(ForceCollect::Yes)?)),
             NonterminalKind::Vis => {
                 return Ok(ParseNtResult::Vis(P(self.collect_tokens_no_attrs(|this| {
                     this.parse_visibility(FollowedByType::Yes)
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index 8ce749ec8141..40f2e228b24e 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -2,7 +2,8 @@ use std::ops::Bound;
 
 use rustc_ast::mut_visit::{self, MutVisitor};
 use rustc_ast::ptr::P;
-use rustc_ast::token::{self, BinOpToken, Delimiter, IdentIsRaw, Token};
+use rustc_ast::token::NtPatKind::*;
+use rustc_ast::token::{self, BinOpToken, Delimiter, IdentIsRaw, MetaVarKind, Token};
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast::visit::{self, Visitor};
 use rustc_ast::{
@@ -30,7 +31,7 @@ use crate::errors::{
     UnexpectedVertVertInPattern, WrapInParens,
 };
 use crate::parser::expr::{DestructuredFloat, could_be_unclosed_char_literal};
-use crate::{exp, maybe_recover_from_interpolated_ty_qpath, maybe_whole};
+use crate::{exp, maybe_recover_from_interpolated_ty_qpath};
 
 #[derive(PartialEq, Copy, Clone)]
 pub enum Expected {
@@ -689,6 +690,27 @@ impl<'a> Parser<'a> {
         PatVisitor { parser: self, stmt, arm: None, field: None }.visit_stmt(stmt);
     }
 
+    fn eat_metavar_pat(&mut self) -> Option<P<Pat>> {
+        // Must try both kinds of pattern nonterminals.
+        if let Some(pat) = self.eat_metavar_seq_with_matcher(
+            |mv_kind| matches!(mv_kind, MetaVarKind::Pat(PatParam { .. })),
+            |this| this.parse_pat_no_top_alt(None, None),
+        ) {
+            Some(pat)
+        } else if let Some(pat) = self.eat_metavar_seq(MetaVarKind::Pat(PatWithOr), |this| {
+            this.parse_pat_no_top_guard(
+                None,
+                RecoverComma::No,
+                RecoverColon::No,
+                CommaRecoveryMode::EitherTupleOrPipe,
+            )
+        }) {
+            Some(pat)
+        } else {
+            None
+        }
+    }
+
     /// Parses a pattern, with a setting whether modern range patterns (e.g., `a..=b`, `a..b` are
     /// allowed).
     fn parse_pat_with_range_pat(
@@ -698,7 +720,10 @@ impl<'a> Parser<'a> {
         syntax_loc: Option<PatternLocation>,
     ) -> PResult<'a, P<Pat>> {
         maybe_recover_from_interpolated_ty_qpath!(self, true);
-        maybe_whole!(self, NtPat, |pat| pat);
+
+        if let Some(pat) = self.eat_metavar_pat() {
+            return Ok(pat);
+        }
 
         let mut lo = self.token.span;
 
@@ -1043,10 +1068,8 @@ impl<'a> Parser<'a> {
         self.recover_additional_muts();
 
         // Make sure we don't allow e.g. `let mut $p;` where `$p:pat`.
-        if let token::Interpolated(nt) = &self.token.kind {
-            if let token::NtPat(..) = &**nt {
-                self.expected_ident_found_err().emit();
-            }
+        if let Some(MetaVarKind::Pat(_)) = self.token.is_metavar_seq() {
+            self.expected_ident_found_err().emit();
         }
 
         // Parse the pattern we hope to be an identifier.
diff --git a/compiler/rustc_parse/src/parser/path.rs b/compiler/rustc_parse/src/parser/path.rs
index c24305ea9a86..8091dfa2a4a4 100644
--- a/compiler/rustc_parse/src/parser/path.rs
+++ b/compiler/rustc_parse/src/parser/path.rs
@@ -15,9 +15,9 @@ use tracing::debug;
 
 use super::ty::{AllowPlus, RecoverQPath, RecoverReturnSign};
 use super::{Parser, Restrictions, TokenType};
-use crate::errors::{PathSingleColon, PathTripleColon};
+use crate::errors::{self, PathSingleColon, PathTripleColon};
+use crate::exp;
 use crate::parser::{CommaRecoveryMode, RecoverColon, RecoverComma};
-use crate::{errors, exp, maybe_whole};
 
 /// Specifies how to parse a path.
 #[derive(Copy, Clone, PartialEq)]
@@ -194,7 +194,11 @@ impl<'a> Parser<'a> {
             }
         };
 
-        maybe_whole!(self, NtPath, |path| reject_generics_if_mod_style(self, path.into_inner()));
+        if let Some(path) =
+            self.eat_metavar_seq(MetaVarKind::Path, |this| this.parse_path(PathStyle::Type))
+        {
+            return Ok(reject_generics_if_mod_style(self, path));
+        }
 
         // If we have a `ty` metavar in the form of a path, reparse it directly as a path, instead
         // of reparsing it as a `ty` and then extracting the path.
@@ -378,11 +382,14 @@ impl<'a> Parser<'a> {
 
                     self.psess.gated_spans.gate(sym::return_type_notation, span);
 
+                    let prev_lo = self.prev_token.span.shrink_to_hi();
                     if self.eat_noexpect(&token::RArrow) {
                         let lo = self.prev_token.span;
                         let ty = self.parse_ty()?;
+                        let span = lo.to(ty.span);
+                        let suggestion = prev_lo.to(ty.span);
                         self.dcx()
-                            .emit_err(errors::BadReturnTypeNotationOutput { span: lo.to(ty.span) });
+                            .emit_err(errors::BadReturnTypeNotationOutput { span, suggestion });
                     }
 
                     P(ast::GenericArgs::ParenthesizedElided(span))
diff --git a/compiler/rustc_passes/messages.ftl b/compiler/rustc_passes/messages.ftl
index 978cb7af2427..b65430c34802 100644
--- a/compiler/rustc_passes/messages.ftl
+++ b/compiler/rustc_passes/messages.ftl
@@ -311,9 +311,6 @@ passes_duplicate_lang_item_crate_depends =
     .first_definition_path = first definition in `{$orig_crate_name}` loaded from {$orig_path}
     .second_definition_path = second definition in `{$crate_name}` loaded from {$path}
 
-passes_empty_confusables =
-    expected at least one confusable name
-
 passes_export_name =
     attribute should be applied to a free function, impl method or static
     .label = not a free function, impl method or static
@@ -365,9 +362,6 @@ passes_incorrect_do_not_recommend_args =
 passes_incorrect_do_not_recommend_location =
     `#[diagnostic::do_not_recommend]` can only be placed on trait implementations
 
-passes_incorrect_meta_item = expected a quoted string literal
-passes_incorrect_meta_item_suggestion = consider surrounding this with quotes
-
 passes_incorrect_target =
     `{$name}` lang item must be applied to a {$kind} with {$at_least ->
         [true] at least {$num}
@@ -641,13 +635,12 @@ passes_repr_align_greater_than_target_max =
 passes_repr_conflicting =
     conflicting representation hints
 
-passes_repr_ident =
-    meta item in `repr` must be an identifier
-
 passes_rustc_allow_const_fn_unstable =
     attribute should be applied to `const fn`
     .label = not a `const fn`
 
+passes_rustc_const_stable_indirect_pairing =
+    `const_stable_indirect` attribute does not make sense on `rustc_const_stable` function, its behavior is already implied
 passes_rustc_dirty_clean =
     attribute requires -Z query-dep-graph to be enabled
 
@@ -732,6 +725,12 @@ passes_target_feature_on_statement =
     .warn = {-passes_previously_accepted}
     .label = {passes_should_be_applied_to_fn.label}
 
+passes_trait_impl_const_stability_mismatch = const stability on the impl does not match the const stability on the trait
+passes_trait_impl_const_stability_mismatch_impl_stable = this impl is (implicitly) stable...
+passes_trait_impl_const_stability_mismatch_impl_unstable = this impl is unstable...
+passes_trait_impl_const_stability_mismatch_trait_stable = ...but the trait is stable
+passes_trait_impl_const_stability_mismatch_trait_unstable = ...but the trait is unstable
+
 passes_trait_impl_const_stable =
     trait implementations cannot be const stable yet
     .note = see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
@@ -774,10 +773,6 @@ passes_unreachable_due_to_uninhabited = unreachable {$descr}
 passes_unrecognized_field =
     unrecognized field name `{$name}`
 
-passes_unrecognized_repr_hint =
-    unrecognized representation hint
-    .help = valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
-
 passes_unstable_attr_for_already_stable_feature =
     can't mark as unstable using an already stable feature
     .label = this feature is already stable
diff --git a/compiler/rustc_passes/src/check_attr.rs b/compiler/rustc_passes/src/check_attr.rs
index 9a4db612cfed..5ada289cc209 100644
--- a/compiler/rustc_passes/src/check_attr.rs
+++ b/compiler/rustc_passes/src/check_attr.rs
@@ -1,3 +1,4 @@
+// FIXME(jdonszelmann): should become rustc_attr_validation
 //! This module implements some validity checks for attributes.
 //! In particular it verifies that `#[inline]` and `#[repr]` attributes are
 //! attached to items that actually support them and if there are
@@ -7,16 +8,17 @@
 use std::cell::Cell;
 use std::collections::hash_map::Entry;
 
-use rustc_abi::{ExternAbi, Size};
+use rustc_abi::{Align, ExternAbi, Size};
 use rustc_ast::{AttrStyle, LitKind, MetaItemInner, MetaItemKind, MetaItemLit, ast};
+use rustc_attr_parsing::{AttributeKind, ReprAttr, find_attr};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::{Applicability, DiagCtxtHandle, IntoDiagArg, MultiSpan, StashKey};
 use rustc_feature::{AttributeDuplicates, AttributeType, BUILTIN_ATTRIBUTE_MAP, BuiltinAttribute};
 use rustc_hir::def_id::LocalModDefId;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{
-    self as hir, self, AssocItemKind, AttrKind, Attribute, CRATE_HIR_ID, CRATE_OWNER_ID, FnSig,
-    ForeignItem, HirId, Item, ItemKind, MethodKind, Safety, Target, TraitItem,
+    self as hir, self, AssocItemKind, Attribute, CRATE_HIR_ID, CRATE_OWNER_ID, FnSig, ForeignItem,
+    HirId, Item, ItemKind, MethodKind, Safety, Target, TraitItem,
 };
 use rustc_macros::LintDiagnostic;
 use rustc_middle::hir::nested_filter;
@@ -78,13 +80,13 @@ pub(crate) enum ProcMacroKind {
 }
 
 impl IntoDiagArg for ProcMacroKind {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         match self {
             ProcMacroKind::Attribute => "attribute proc macro",
             ProcMacroKind::Derive => "derive proc macro",
             ProcMacroKind::FunctionLike => "function-like proc macro",
         }
-        .into_diag_arg()
+        .into_diag_arg(&mut None)
     }
 }
 
@@ -113,190 +115,201 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let mut seen = FxHashMap::default();
         let attrs = self.tcx.hir().attrs(hir_id);
         for attr in attrs {
-            match attr.path().as_slice() {
-                [sym::diagnostic, sym::do_not_recommend, ..] => {
-                    self.check_do_not_recommend(attr.span, hir_id, target, attr, item)
+            match attr {
+                Attribute::Parsed(AttributeKind::Confusables { first_span, .. }) => {
+                    self.check_confusables(*first_span, target);
                 }
-                [sym::diagnostic, sym::on_unimplemented, ..] => {
-                    self.check_diagnostic_on_unimplemented(attr.span, hir_id, target)
-                }
-                [sym::inline, ..] => self.check_inline(hir_id, attr, span, target),
-                [sym::coverage, ..] => self.check_coverage(attr, span, target),
-                [sym::optimize, ..] => self.check_optimize(hir_id, attr, span, target),
-                [sym::no_sanitize, ..] => self.check_no_sanitize(attr, span, target),
-                [sym::non_exhaustive, ..] => self.check_non_exhaustive(hir_id, attr, span, target, item),
-                [sym::marker, ..] => self.check_marker(hir_id, attr, span, target),
-                [sym::target_feature, ..] => {
-                    self.check_target_feature(hir_id, attr, span, target, attrs)
-                }
-                [sym::thread_local, ..] => self.check_thread_local(attr, span, target),
-                [sym::track_caller, ..] => {
-                    self.check_track_caller(hir_id, attr.span, attrs, span, target)
-                }
-                [sym::doc, ..] => self.check_doc_attrs(
-                    attr,
-                    hir_id,
-                    target,
-                    &mut specified_inline,
-                    &mut doc_aliases,
-                ),
-                [sym::no_link, ..] => self.check_no_link(hir_id, attr, span, target),
-                [sym::export_name, ..] => self.check_export_name(hir_id, attr, span, target),
-                [sym::rustc_layout_scalar_valid_range_start, ..]
-                | [sym::rustc_layout_scalar_valid_range_end, ..] => {
-                    self.check_rustc_layout_scalar_valid_range(attr, span, target)
-                }
-                [sym::allow_internal_unstable, ..] => {
-                    self.check_allow_internal_unstable(hir_id, attr, span, target, attrs)
-                }
-                [sym::debugger_visualizer, ..] => self.check_debugger_visualizer(attr, target),
-                [sym::rustc_allow_const_fn_unstable, ..] => {
-                    self.check_rustc_allow_const_fn_unstable(hir_id, attr, span, target)
-                }
-                [sym::rustc_std_internal_symbol, ..] => {
-                    self.check_rustc_std_internal_symbol(attr, span, target)
-                }
-                [sym::naked, ..] => self.check_naked(hir_id, attr, span, target, attrs),
-                [sym::rustc_as_ptr, ..] => {
-                    self.check_applied_to_fn_or_method(hir_id, attr, span, target)
-                }
-                [sym::rustc_never_returns_null_ptr, ..] => {
-                    self.check_applied_to_fn_or_method(hir_id, attr, span, target)
-                }
-                [sym::rustc_legacy_const_generics, ..] => {
-                    self.check_rustc_legacy_const_generics(hir_id, attr, span, target, item)
-                }
-                [sym::rustc_lint_query_instability, ..] => {
-                    self.check_applied_to_fn_or_method(hir_id, attr, span, target)
-                }
-                [sym::rustc_lint_untracked_query_information, ..] => {
-                    self.check_applied_to_fn_or_method(hir_id, attr, span, target)
-                }
-                [sym::rustc_lint_diagnostics, ..] => {
-                    self.check_applied_to_fn_or_method(hir_id, attr, span, target)
-                }
-                [sym::rustc_lint_opt_ty, ..] => self.check_rustc_lint_opt_ty(attr, span, target),
-                [sym::rustc_lint_opt_deny_field_access, ..] => {
-                    self.check_rustc_lint_opt_deny_field_access(attr, span, target)
-                }
-                [sym::rustc_clean, ..]
-                | [sym::rustc_dirty, ..]
-                | [sym::rustc_if_this_changed, ..]
-                | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr),
-                [sym::rustc_coinductive, ..]
-                | [sym::rustc_must_implement_one_of, ..]
-                | [sym::rustc_deny_explicit_impl, ..]
-                | [sym::rustc_do_not_implement_via_object, ..]
-                | [sym::const_trait, ..] => self.check_must_be_applied_to_trait(attr, span, target),
-                [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
-                [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
-                [sym::must_use, ..] => self.check_must_use(hir_id, attr, target),
-                [sym::may_dangle, ..] => self.check_may_dangle(hir_id, attr),
-                [sym::rustc_pass_by_value, ..] => self.check_pass_by_value(attr, span, target),
-                [sym::rustc_allow_incoherent_impl, ..] => {
-                    self.check_allow_incoherent_impl(attr, span, target)
-                }
-                [sym::rustc_has_incoherent_inherent_impls, ..] => {
-                    self.check_has_incoherent_inherent_impls(attr, span, target)
-                }
-                [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span, attrs, target),
-                [sym::ffi_const, ..] => self.check_ffi_const(attr.span, target),
-                [sym::rustc_const_unstable, ..]
-                | [sym::rustc_const_stable, ..]
-                | [sym::unstable, ..]
-                | [sym::stable, ..]
-                | [sym::rustc_allowed_through_unstable_modules, ..]
-                | [sym::rustc_promotable, ..] => self.check_stability_promotable(attr, target),
-                [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
-                [sym::rustc_confusables, ..] => self.check_confusables(attr, target),
-                [sym::cold, ..] => self.check_cold(hir_id, attr, span, target),
-                [sym::link, ..] => self.check_link(hir_id, attr, span, target),
-                [sym::link_name, ..] => self.check_link_name(hir_id, attr, span, target),
-                [sym::link_section, ..] => self.check_link_section(hir_id, attr, span, target),
-                [sym::no_mangle, ..] => self.check_no_mangle(hir_id, attr, span, target),
-                [sym::deprecated, ..] => self.check_deprecated(hir_id, attr, span, target),
-                [sym::macro_use, ..] | [sym::macro_escape, ..] => {
-                    self.check_macro_use(hir_id, attr, target)
-                }
-                [sym::path, ..] => self.check_generic_attr(hir_id, attr, target, Target::Mod),
-                [sym::macro_export, ..] => self.check_macro_export(hir_id, attr, target),
-                [sym::ignore, ..] | [sym::should_panic, ..] => {
-                    self.check_generic_attr(hir_id, attr, target, Target::Fn)
-                }
-                [sym::automatically_derived, ..] => {
-                    self.check_generic_attr(hir_id, attr, target, Target::Impl)
-                }
-                [sym::no_implicit_prelude, ..] => {
-                    self.check_generic_attr(hir_id, attr, target, Target::Mod)
-                }
-                [sym::rustc_object_lifetime_default, ..] => self.check_object_lifetime_default(hir_id),
-                [sym::proc_macro, ..] => {
-                    self.check_proc_macro(hir_id, target, ProcMacroKind::FunctionLike)
-                }
-                [sym::proc_macro_attribute, ..] => {
-                    self.check_proc_macro(hir_id, target, ProcMacroKind::Attribute);
-                }
-                [sym::proc_macro_derive, ..] => {
-                    self.check_generic_attr(hir_id, attr, target, Target::Fn);
-                    self.check_proc_macro(hir_id, target, ProcMacroKind::Derive)
-                }
-                [sym::autodiff, ..] => {
-                    self.check_autodiff(hir_id, attr, span, target)
-                }
-                [sym::coroutine, ..] => {
-                    self.check_coroutine(attr, target);
-                }
-                [sym::linkage, ..] => self.check_linkage(attr, span, target),
-                [sym::rustc_pub_transparent, ..] => self.check_rustc_pub_transparent(attr.span, span, attrs),
-                [
-                    // ok
-                    sym::allow
-                    | sym::expect
-                    | sym::warn
-                    | sym::deny
-                    | sym::forbid
-                    | sym::cfg
-                    | sym::cfg_attr
-                    // need to be fixed
-                    | sym::cfi_encoding // FIXME(cfi_encoding)
-                    | sym::pointee // FIXME(derive_coerce_pointee)
-                    | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section)
-                    | sym::used // handled elsewhere to restrict to static items
-                    | sym::repr // handled elsewhere to restrict to type decls items
-                    | sym::instruction_set // broken on stable!!!
-                    | sym::windows_subsystem // broken on stable!!!
-                    | sym::patchable_function_entry // FIXME(patchable_function_entry)
-                    | sym::deprecated_safe // FIXME(deprecated_safe)
-                    // internal
-                    | sym::prelude_import
-                    | sym::panic_handler
-                    | sym::allow_internal_unsafe
-                    | sym::fundamental
-                    | sym::lang
-                    | sym::needs_allocator
-                    | sym::default_lib_allocator
-                    | sym::custom_mir,
-                    ..
-                ] => {}
-                [name, ..] => {
-                    match BUILTIN_ATTRIBUTE_MAP.get(name) {
-                        // checked below
-                        Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) => {}
-                        Some(_) => {
-                            // FIXME: differentiate between unstable and internal attributes just
-                            // like we do with features instead of just accepting `rustc_`
-                            // attributes by name. That should allow trimming the above list, too.
-                            if !name.as_str().starts_with("rustc_") {
-                                span_bug!(
-                                    attr.span,
-                                    "builtin attribute {name:?} not handled by `CheckAttrVisitor`"
-                                )
+                Attribute::Parsed(
+                    AttributeKind::Stability { span, .. }
+                    | AttributeKind::ConstStability { span, .. },
+                ) => self.check_stability_promotable(*span, target),
+                Attribute::Parsed(AttributeKind::AllowInternalUnstable(syms)) => self
+                    .check_allow_internal_unstable(
+                        hir_id,
+                        syms.first().unwrap().1,
+                        span,
+                        target,
+                        attrs,
+                    ),
+                _ => {
+                    match attr.path().as_slice() {
+                        [sym::diagnostic, sym::do_not_recommend, ..] => {
+                            self.check_do_not_recommend(attr.span(), hir_id, target, attr, item)
+                        }
+                        [sym::diagnostic, sym::on_unimplemented, ..] => {
+                            self.check_diagnostic_on_unimplemented(attr.span(), hir_id, target)
+                        }
+                        [sym::inline, ..] => self.check_inline(hir_id, attr, span, target),
+                        [sym::coverage, ..] => self.check_coverage(attr, span, target),
+                        [sym::optimize, ..] => self.check_optimize(hir_id, attr, span, target),
+                        [sym::no_sanitize, ..] => {
+                            self.check_no_sanitize(attr, span, target)
+                        }
+                        [sym::non_exhaustive, ..] => self.check_non_exhaustive(hir_id, attr, span, target, item),
+                        [sym::marker, ..] => self.check_marker(hir_id, attr, span, target),
+                        [sym::target_feature, ..] => {
+                            self.check_target_feature(hir_id, attr, span, target, attrs)
+                        }
+                        [sym::thread_local, ..] => self.check_thread_local(attr, span, target),
+                        [sym::track_caller, ..] => {
+                            self.check_track_caller(hir_id, attr.span(), attrs, span, target)
+                        }
+                        [sym::doc, ..] => self.check_doc_attrs(
+                            attr,
+                            hir_id,
+                            target,
+                            &mut specified_inline,
+                            &mut doc_aliases,
+                        ),
+                        [sym::no_link, ..] => self.check_no_link(hir_id, attr, span, target),
+                        [sym::export_name, ..] => self.check_export_name(hir_id, attr, span, target),
+                        [sym::rustc_layout_scalar_valid_range_start, ..]
+                        | [sym::rustc_layout_scalar_valid_range_end, ..] => {
+                            self.check_rustc_layout_scalar_valid_range(attr, span, target)
+                        }
+                        [sym::debugger_visualizer, ..] => self.check_debugger_visualizer(attr, target),
+                        [sym::rustc_allow_const_fn_unstable, ..] => {
+                            self.check_rustc_allow_const_fn_unstable(hir_id, attr, span, target)
+                        }
+                        [sym::rustc_std_internal_symbol, ..] => {
+                            self.check_rustc_std_internal_symbol(attr, span, target)
+                        }
+                        [sym::naked, ..] => self.check_naked(hir_id, attr, span, target, attrs),
+                        [sym::rustc_as_ptr, ..] => {
+                            self.check_applied_to_fn_or_method(hir_id, attr, span, target)
+                        }
+                        [sym::rustc_never_returns_null_ptr, ..] => {
+                            self.check_applied_to_fn_or_method(hir_id, attr, span, target)
+                        }
+                        [sym::rustc_legacy_const_generics, ..] => {
+                            self.check_rustc_legacy_const_generics(hir_id, attr, span, target, item)
+                        }
+                        [sym::rustc_lint_query_instability, ..] => {
+                            self.check_applied_to_fn_or_method(hir_id, attr, span, target)
+                        }
+                        [sym::rustc_lint_untracked_query_information, ..] => {
+                            self.check_applied_to_fn_or_method(hir_id, attr, span, target)
+                        }
+                        [sym::rustc_lint_diagnostics, ..] => {
+                            self.check_applied_to_fn_or_method(hir_id, attr, span, target)
+                        }
+                        [sym::rustc_lint_opt_ty, ..] => self.check_rustc_lint_opt_ty(attr, span, target),
+                        [sym::rustc_lint_opt_deny_field_access, ..] => {
+                            self.check_rustc_lint_opt_deny_field_access(attr, span, target)
+                        }
+                        [sym::rustc_clean, ..]
+                        | [sym::rustc_dirty, ..]
+                        | [sym::rustc_if_this_changed, ..]
+                        | [sym::rustc_then_this_would_need, ..] => self.check_rustc_dirty_clean(attr),
+                        [sym::rustc_coinductive, ..]
+                        | [sym::rustc_must_implement_one_of, ..]
+                        | [sym::rustc_deny_explicit_impl, ..]
+                        | [sym::rustc_do_not_implement_via_object, ..]
+                        | [sym::const_trait, ..] => self.check_must_be_applied_to_trait(attr, span, target),
+                        [sym::collapse_debuginfo, ..] => self.check_collapse_debuginfo(attr, span, target),
+                        [sym::must_not_suspend, ..] => self.check_must_not_suspend(attr, span, target),
+                        [sym::must_use, ..] => self.check_must_use(hir_id, attr, target),
+                        [sym::may_dangle, ..] => self.check_may_dangle(hir_id, attr),
+                        [sym::rustc_pass_by_value, ..] => self.check_pass_by_value(attr, span, target),
+                        [sym::rustc_allow_incoherent_impl, ..] => {
+                            self.check_allow_incoherent_impl(attr, span, target)
+                        }
+                        [sym::rustc_has_incoherent_inherent_impls, ..] => {
+                            self.check_has_incoherent_inherent_impls(attr, span, target)
+                        }
+                        [sym::ffi_pure, ..] => self.check_ffi_pure(attr.span(), attrs, target),
+                        [sym::ffi_const, ..] => self.check_ffi_const(attr.span(), target),
+                        [sym::link_ordinal, ..] => self.check_link_ordinal(attr, span, target),
+                        [sym::cold, ..] => self.check_cold(hir_id, attr, span, target),
+                        [sym::link, ..] => self.check_link(hir_id, attr, span, target),
+                        [sym::link_name, ..] => self.check_link_name(hir_id, attr, span, target),
+                        [sym::link_section, ..] => self.check_link_section(hir_id, attr, span, target),
+                        [sym::no_mangle, ..] => self.check_no_mangle(hir_id, attr, span, target),
+                        [sym::deprecated, ..] => self.check_deprecated(hir_id, attr, span, target),
+                        [sym::macro_use, ..] | [sym::macro_escape, ..] => {
+                            self.check_macro_use(hir_id, attr, target)
+                        }
+                        [sym::path, ..] => self.check_generic_attr(hir_id, attr, target, Target::Mod),
+                        [sym::macro_export, ..] => self.check_macro_export(hir_id, attr, target),
+                        [sym::ignore, ..] | [sym::should_panic, ..] => {
+                            self.check_generic_attr(hir_id, attr, target, Target::Fn)
+                        }
+                        [sym::automatically_derived, ..] => {
+                            self.check_generic_attr(hir_id, attr, target, Target::Impl)
+                        }
+                        [sym::no_implicit_prelude, ..] => {
+                            self.check_generic_attr(hir_id, attr, target, Target::Mod)
+                        }
+                        [sym::rustc_object_lifetime_default, ..] => self.check_object_lifetime_default(hir_id),
+                        [sym::proc_macro, ..] => {
+                            self.check_proc_macro(hir_id, target, ProcMacroKind::FunctionLike)
+                        }
+                        [sym::proc_macro_attribute, ..] => {
+                            self.check_proc_macro(hir_id, target, ProcMacroKind::Attribute);
+                        }
+                        [sym::proc_macro_derive, ..] => {
+                            self.check_generic_attr(hir_id, attr, target, Target::Fn);
+                            self.check_proc_macro(hir_id, target, ProcMacroKind::Derive)
+                        }
+                        [sym::autodiff, ..] => {
+                            self.check_autodiff(hir_id, attr, span, target)
+                        }
+                        [sym::coroutine, ..] => {
+                            self.check_coroutine(attr, target);
+                        }
+                        [sym::linkage, ..] => self.check_linkage(attr, span, target),
+                        [sym::rustc_pub_transparent, ..] => self.check_rustc_pub_transparent(attr.span(), span, attrs),
+                        [
+                            // ok
+                            sym::allow
+                            | sym::expect
+                            | sym::warn
+                            | sym::deny
+                            | sym::forbid
+                            | sym::cfg
+                            | sym::cfg_attr
+                            // need to be fixed
+                            | sym::cfi_encoding // FIXME(cfi_encoding)
+                            | sym::pointee // FIXME(derive_coerce_pointee)
+                            | sym::omit_gdb_pretty_printer_section // FIXME(omit_gdb_pretty_printer_section)
+                            | sym::used // handled elsewhere to restrict to static items
+                            | sym::repr // handled elsewhere to restrict to type decls items
+                            | sym::instruction_set // broken on stable!!!
+                            | sym::windows_subsystem // broken on stable!!!
+                            | sym::patchable_function_entry // FIXME(patchable_function_entry)
+                            | sym::deprecated_safe // FIXME(deprecated_safe)
+                            // internal
+                            | sym::prelude_import
+                            | sym::panic_handler
+                            | sym::allow_internal_unsafe
+                            | sym::fundamental
+                            | sym::lang
+                            | sym::needs_allocator
+                            | sym::default_lib_allocator
+                            | sym::custom_mir,
+                            ..
+                        ] => {}
+                        [name, ..] => {
+                            match BUILTIN_ATTRIBUTE_MAP.get(name) {
+                                // checked below
+                                Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) => {}
+                                Some(_) => {
+                                    // FIXME: differentiate between unstable and internal attributes just
+                                    // like we do with features instead of just accepting `rustc_`
+                                    // attributes by name. That should allow trimming the above list, too.
+                                    if !name.as_str().starts_with("rustc_") {
+                                        span_bug!(
+                                            attr.span(),
+                                            "builtin attribute {name:?} not handled by `CheckAttrVisitor`"
+                                        )
+                                    }
+                                }
+                                None => (),
                             }
                         }
-                        None => (),
+                        [] => unreachable!(),
                     }
                 }
-                [] => unreachable!(),
             }
 
             let builtin = attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name));
@@ -305,17 +318,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 if let Some(BuiltinAttribute { type_: AttributeType::CrateLevel, .. }) =
                     attr.ident().and_then(|ident| BUILTIN_ATTRIBUTE_MAP.get(&ident.name))
                 {
-                    match attr.style {
+                    match attr.style() {
                         ast::AttrStyle::Outer => self.tcx.emit_node_span_lint(
                             UNUSED_ATTRIBUTES,
                             hir_id,
-                            attr.span,
+                            attr.span(),
                             errors::OuterCrateLevelAttr,
                         ),
                         ast::AttrStyle::Inner => self.tcx.emit_node_span_lint(
                             UNUSED_ATTRIBUTES,
                             hir_id,
-                            attr.span,
+                            attr.span(),
                             errors::InnerCrateLevelAttr,
                         ),
                     }
@@ -338,16 +351,16 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         self.tcx.emit_node_span_lint(
             UNUSED_ATTRIBUTES,
             hir_id,
-            attr.span,
+            attr.span(),
             errors::IgnoredAttrWithMacro { sym },
         );
     }
 
-    fn inline_attr_str_error_without_macro_def(&self, hir_id: HirId, attr: &Attribute, sym: &str) {
+    fn inline_attr_str_error_without_macro_def(&self, hir_id: HirId, attr_span: Span, sym: &str) {
         self.tcx.emit_node_span_lint(
             UNUSED_ATTRIBUTES,
             hir_id,
-            attr.span,
+            attr_span,
             errors::IgnoredAttr { sym },
         );
     }
@@ -407,7 +420,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::IgnoredInlineAttrFnProto,
                 )
             }
@@ -418,7 +431,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             Target::AssocConst => self.tcx.emit_node_span_lint(
                 UNUSED_ATTRIBUTES,
                 hir_id,
-                attr.span,
+                attr.span(),
                 errors::IgnoredInlineAttrConstants,
             ),
             // FIXME(#80564): Same for fields, arms, and macro defs
@@ -427,7 +440,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             _ => {
                 self.dcx().emit_err(errors::InlineNotFnOrClosure {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     defn_span: span,
                 });
             }
@@ -459,7 +472,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
 
         self.dcx().emit_err(errors::CoverageAttributeNotAllowed {
-            attr_span: attr.span,
+            attr_span: attr.span(),
             not_fn_impl_mod,
             no_body,
             help: (),
@@ -477,7 +490,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         );
         if !is_valid {
             self.dcx().emit_err(errors::OptimizeInvalidTarget {
-                attr_span: attr.span,
+                attr_span: attr.span(),
                 defn_span: span,
                 on_crate: hir_id == CRATE_HIR_ID,
             });
@@ -528,7 +541,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             self.tcx.emit_node_span_lint(
                 UNUSED_ATTRIBUTES,
                 hir_id,
-                attr.span,
+                attr.span(),
                 errors::OnlyHasEffectOn {
                     attr_name: attr.name_or_empty(),
                     target_name: allowed_target.name().replace(' ', "_"),
@@ -568,6 +581,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             sym::warn,
             sym::deny,
             sym::forbid,
+            // FIXME(jdonszelmann): not used, because already a new-style attr (ugh)
             sym::deprecated,
             sym::must_use,
             // abi, linking and FFI
@@ -595,10 +609,21 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         continue;
                     }
 
+                    // FIXME(jdonszelmann): once naked uses new-style parsing,
+                    // this check can be part of the parser and be removed here
+                    match other_attr {
+                        Attribute::Parsed(
+                            AttributeKind::Deprecation { .. } | AttributeKind::Repr { .. },
+                        ) => {
+                            continue;
+                        }
+                        _ => {}
+                    }
+
                     if !ALLOW_LIST.iter().any(|name| other_attr.has_name(*name)) {
                         self.dcx().emit_err(errors::NakedFunctionIncompatibleAttribute {
-                            span: other_attr.span,
-                            naked_span: attr.span,
+                            span: other_attr.span(),
+                            naked_span: attr.span(),
                             attr: other_attr.name_or_empty(),
                         });
 
@@ -615,7 +640,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             _ => {
                 self.dcx().emit_err(errors::AttrShouldBeAppliedToFn {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     defn_span: span,
                     on_crate: hir_id == CRATE_HIR_ID,
                 });
@@ -648,9 +673,10 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::MacroDef => {}
             _ => {
-                self.tcx
-                    .dcx()
-                    .emit_err(errors::CollapseDebuginfo { attr_span: attr.span, defn_span: span });
+                self.tcx.dcx().emit_err(errors::CollapseDebuginfo {
+                    attr_span: attr.span(),
+                    defn_span: span,
+                });
             }
         }
     }
@@ -720,7 +746,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     && fields.iter().any(|f| f.default.is_some())
                 {
                     self.dcx().emit_err(errors::NonExhaustiveWithDefaultFieldValues {
-                        attr_span: attr.span,
+                        attr_span: attr.span(),
                         defn_span: span,
                     });
                 }
@@ -735,7 +761,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             _ => {
                 self.dcx().emit_err(errors::NonExhaustiveWrongLocation {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     defn_span: span,
                 });
             }
@@ -755,7 +781,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             _ => {
                 self.dcx().emit_err(errors::AttrShouldBeAppliedToTrait {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     defn_span: span,
                 });
             }
@@ -784,7 +810,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     let sig = self.tcx.hir_node(hir_id).fn_sig().unwrap();
 
                     self.dcx().emit_err(errors::LangItemWithTargetFeature {
-                        attr_span: attr.span,
+                        attr_span: attr.span(),
                         name: lang_item,
                         sig_span: sig.span,
                     });
@@ -796,7 +822,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::TargetFeatureOnStatement,
                 );
             }
@@ -809,7 +835,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             }
             _ => {
                 self.dcx().emit_err(errors::AttrShouldBeAppliedToFn {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     defn_span: span,
                     on_crate: hir_id == CRATE_HIR_ID,
                 });
@@ -823,7 +849,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             Target::ForeignStatic | Target::Static => {}
             _ => {
                 self.dcx().emit_err(errors::AttrShouldBeAppliedToStatic {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     defn_span: span,
                 });
             }
@@ -1093,7 +1119,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     meta.span(),
                     errors::DocInlineOnlyUse {
                         attr_span: meta.span(),
-                        item_span: (attr.style == AttrStyle::Outer)
+                        item_span: (attr.style() == AttrStyle::Outer)
                             .then(|| self.tcx.hir().span(hir_id)),
                     },
                 );
@@ -1115,7 +1141,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 meta.span(),
                 errors::DocMaskedOnlyExternCrate {
                     attr_span: meta.span(),
-                    item_span: (attr.style == AttrStyle::Outer)
+                    item_span: (attr.style() == AttrStyle::Outer)
                         .then(|| self.tcx.hir().span(hir_id)),
                 },
             );
@@ -1129,7 +1155,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 meta.span(),
                 errors::DocMaskedNotExternCrateSelf {
                     attr_span: meta.span(),
-                    item_span: (attr.style == AttrStyle::Outer)
+                    item_span: (attr.style() == AttrStyle::Outer)
                         .then(|| self.tcx.hir().span(hir_id)),
                 },
             );
@@ -1159,11 +1185,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     ) -> bool {
         if hir_id != CRATE_HIR_ID {
             // insert a bang between `#` and `[...`
-            let bang_span = attr.span.lo() + BytePos(1);
-            let sugg = (attr.style == AttrStyle::Outer
+            let bang_span = attr.span().lo() + BytePos(1);
+            let sugg = (attr.style() == AttrStyle::Outer
                 && self.tcx.hir_get_parent_item(hir_id) == CRATE_OWNER_ID)
                 .then_some(errors::AttrCrateLevelOnlySugg {
-                    attr: attr.span.with_lo(bang_span).with_hi(bang_span),
+                    attr: attr.span().with_lo(bang_span).with_hi(bang_span),
                 });
             self.tcx.emit_node_span_lint(
                 INVALID_DOC_ATTRIBUTES,
@@ -1337,11 +1363,11 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                                     errors::DocTestUnknownInclude {
                                         path,
                                         value: value.to_string(),
-                                        inner: match attr.style {
+                                        inner: match attr.style() {
                                             AttrStyle::Inner => "!",
                                             AttrStyle::Outer => "",
                                         },
-                                        sugg: (attr.span, applicability),
+                                        sugg: (attr.span(), applicability),
                                     },
                                 );
                             } else if i_meta.has_name(sym::passes)
@@ -1387,7 +1413,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::Struct | Target::Enum | Target::TyAlias => {}
             _ => {
-                self.dcx().emit_err(errors::PassByValue { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::PassByValue { attr_span: attr.span(), span });
             }
         }
     }
@@ -1396,7 +1422,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::Method(MethodKind::Inherent) => {}
             _ => {
-                self.dcx().emit_err(errors::AllowIncoherentImpl { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::AllowIncoherentImpl { attr_span: attr.span(), span });
             }
         }
     }
@@ -1407,7 +1433,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             _ => {
                 self.tcx
                     .dcx()
-                    .emit_err(errors::HasIncoherentInherentImpl { attr_span: attr.span, span });
+                    .emit_err(errors::HasIncoherentInherentImpl { attr_span: attr.span(), span });
             }
         }
     }
@@ -1470,7 +1496,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         self.tcx.emit_node_span_lint(
             UNUSED_ATTRIBUTES,
             hir_id,
-            attr.span,
+            attr.span(),
             errors::MustUseNoEffect { article, target },
         );
     }
@@ -1480,7 +1506,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::Struct | Target::Enum | Target::Union | Target::Trait => {}
             _ => {
-                self.dcx().emit_err(errors::MustNotSuspend { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::MustNotSuspend { attr_span: attr.span(), span });
             }
         }
     }
@@ -1503,7 +1529,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             return;
         }
 
-        self.dcx().emit_err(errors::InvalidMayDangle { attr_span: attr.span });
+        self.dcx().emit_err(errors::InvalidMayDangle { attr_span: attr.span() });
     }
 
     /// Checks if `#[cold]` is applied to a non-function.
@@ -1523,7 +1549,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::Cold { span, on_crate: hir_id == CRATE_HIR_ID },
                 );
             }
@@ -1543,7 +1569,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         self.tcx.emit_node_span_lint(
             UNUSED_ATTRIBUTES,
             hir_id,
-            attr.span,
+            attr.span(),
             errors::Link { span: (target != Target::ForeignMod).then_some(span) },
         );
     }
@@ -1562,19 +1588,19 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             _ => {
                 // FIXME: #[cold] was previously allowed on non-functions/statics and some crates
                 // used this, so only emit a warning.
-                let attr_span = matches!(target, Target::ForeignMod).then_some(attr.span);
+                let attr_span = matches!(target, Target::ForeignMod).then_some(attr.span());
                 if let Some(s) = attr.value_str() {
                     self.tcx.emit_node_span_lint(
                         UNUSED_ATTRIBUTES,
                         hir_id,
-                        attr.span,
+                        attr.span(),
                         errors::LinkName { span, attr_span, value: s.as_str() },
                     );
                 } else {
                     self.tcx.emit_node_span_lint(
                         UNUSED_ATTRIBUTES,
                         hir_id,
-                        attr.span,
+                        attr.span(),
                         errors::LinkName { span, attr_span, value: "..." },
                     );
                 };
@@ -1594,7 +1620,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "no_link");
             }
             _ => {
-                self.dcx().emit_err(errors::NoLink { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::NoLink { attr_span: attr.span(), span });
             }
         }
     }
@@ -1616,7 +1642,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.inline_attr_str_error_with_macro_def(hir_id, attr, "export_name");
             }
             _ => {
-                self.dcx().emit_err(errors::ExportName { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::ExportName { attr_span: attr.span(), span });
             }
         }
     }
@@ -1624,7 +1650,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     fn check_rustc_layout_scalar_valid_range(&self, attr: &Attribute, span: Span, target: Target) {
         if target != Target::Struct {
             self.dcx().emit_err(errors::RustcLayoutScalarValidRangeNotStruct {
-                attr_span: attr.span,
+                attr_span: attr.span(),
                 span,
             });
             return;
@@ -1637,7 +1663,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         if !matches!(&list[..], &[MetaItemInner::Lit(MetaItemLit { kind: LitKind::Int(..), .. })]) {
             self.tcx
                 .dcx()
-                .emit_err(errors::RustcLayoutScalarValidRangeArg { attr_span: attr.span });
+                .emit_err(errors::RustcLayoutScalarValidRangeArg { attr_span: attr.span() });
         }
     }
 
@@ -1653,7 +1679,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let is_function = matches!(target, Target::Fn);
         if !is_function {
             self.dcx().emit_err(errors::AttrShouldBeAppliedToFn {
-                attr_span: attr.span,
+                attr_span: attr.span(),
                 defn_span: span,
                 on_crate: hir_id == CRATE_HIR_ID,
             });
@@ -1678,7 +1704,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 hir::GenericParamKind::Const { .. } => {}
                 _ => {
                     self.dcx().emit_err(errors::RustcLegacyConstGenericsOnly {
-                        attr_span: attr.span,
+                        attr_span: attr.span(),
                         param_span: param.span,
                     });
                     return;
@@ -1688,7 +1714,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
         if list.len() != generics.params.len() {
             self.dcx().emit_err(errors::RustcLegacyConstGenericsIndex {
-                attr_span: attr.span,
+                attr_span: attr.span(),
                 generics_span: generics.span,
             });
             return;
@@ -1728,7 +1754,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let is_function = matches!(target, Target::Fn | Target::Method(..));
         if !is_function {
             self.dcx().emit_err(errors::AttrShouldBeAppliedToFn {
-                attr_span: attr.span,
+                attr_span: attr.span(),
                 defn_span: span,
                 on_crate: hir_id == CRATE_HIR_ID,
             });
@@ -1740,7 +1766,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::Struct => {}
             _ => {
-                self.dcx().emit_err(errors::RustcLintOptTy { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::RustcLintOptTy { attr_span: attr.span(), span });
             }
         }
     }
@@ -1752,7 +1778,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             _ => {
                 self.tcx
                     .dcx()
-                    .emit_err(errors::RustcLintOptDenyFieldAccess { attr_span: attr.span, span });
+                    .emit_err(errors::RustcLintOptDenyFieldAccess { attr_span: attr.span(), span });
             }
         }
     }
@@ -1761,7 +1787,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     /// option is passed to the compiler.
     fn check_rustc_dirty_clean(&self, attr: &Attribute) {
         if !self.tcx.sess.opts.unstable_opts.query_dep_graph {
-            self.dcx().emit_err(errors::RustcDirtyClean { span: attr.span });
+            self.dcx().emit_err(errors::RustcDirtyClean { span: attr.span() });
         }
     }
 
@@ -1771,7 +1797,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             Target::Trait => {}
             _ => {
                 self.dcx().emit_err(errors::AttrShouldBeAppliedToTrait {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     defn_span: span,
                 });
             }
@@ -1795,7 +1821,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::LinkSection { span },
                 );
             }
@@ -1826,8 +1852,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
-                    errors::NoMangleForeign { span, attr_span: attr.span, foreign_item_kind },
+                    attr.span(),
+                    errors::NoMangleForeign { span, attr_span: attr.span(), foreign_item_kind },
                 );
             }
             _ => {
@@ -1836,7 +1862,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::NoMangle { span },
                 );
             }
@@ -1857,12 +1883,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         // #[repr(foo)]
         // #[repr(bar, align(8))]
         // ```
-        let hints: Vec<_> = attrs
-            .iter()
-            .filter(|attr| attr.has_name(sym::repr))
-            .filter_map(|attr| attr.meta_item_list())
-            .flatten()
-            .collect();
+        let reprs = find_attr!(attrs, AttributeKind::Repr(r) => r.as_slice()).unwrap_or(&[]);
 
         let mut int_reprs = 0;
         let mut is_explicit_rust = false;
@@ -1870,66 +1891,33 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         let mut is_simd = false;
         let mut is_transparent = false;
 
-        // catch `repr()` with no arguments, applied to an item (i.e. not `#![repr()]`)
-        if hints.is_empty() && item.is_some() {
-            for attr in attrs.iter().filter(|attr| attr.has_name(sym::repr)) {
-                match target {
-                    Target::Struct | Target::Union | Target::Enum => {}
-                    Target::Fn | Target::Method(_) => {
-                        feature_err(
-                            &self.tcx.sess,
-                            sym::fn_align,
-                            attr.span,
-                            fluent::passes_repr_align_function,
-                        )
-                        .emit();
-                    }
-                    _ => {
-                        self.dcx().emit_err(
-                            errors::AttrApplication::StructEnumFunctionMethodUnion {
-                                hint_span: attr.span,
-                                span,
-                            },
-                        );
-                    }
-                }
-            }
-
-            return;
-        }
-
-        for hint in &hints {
-            if !hint.is_meta_item() {
-                self.dcx().emit_err(errors::ReprIdent { span: hint.span() });
-                continue;
-            }
-
-            match hint.name_or_empty() {
-                sym::Rust => {
+        for (repr, repr_span) in reprs {
+            match repr {
+                ReprAttr::ReprRust => {
                     is_explicit_rust = true;
                     match target {
                         Target::Struct | Target::Union | Target::Enum => continue,
                         _ => {
                             self.dcx().emit_err(errors::AttrApplication::StructEnumUnion {
-                                hint_span: hint.span(),
+                                hint_span: *repr_span,
                                 span,
                             });
                         }
                     }
                 }
-                sym::C => {
+                ReprAttr::ReprC => {
                     is_c = true;
                     match target {
                         Target::Struct | Target::Union | Target::Enum => continue,
                         _ => {
                             self.dcx().emit_err(errors::AttrApplication::StructEnumUnion {
-                                hint_span: hint.span(),
+                                hint_span: *repr_span,
                                 span,
                             });
                         }
                     }
                 }
-                sym::align => {
+                ReprAttr::ReprAlign(align) => {
                     match target {
                         Target::Struct | Target::Union | Target::Enum => {}
                         Target::Fn | Target::Method(_) => {
@@ -1937,7 +1925,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                                 feature_err(
                                     &self.tcx.sess,
                                     sym::fn_align,
-                                    hint.span(),
+                                    *repr_span,
                                     fluent::passes_repr_align_function,
                                 )
                                 .emit();
@@ -1946,83 +1934,97 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                         _ => {
                             self.dcx().emit_err(
                                 errors::AttrApplication::StructEnumFunctionMethodUnion {
-                                    hint_span: hint.span(),
+                                    hint_span: *repr_span,
                                     span,
                                 },
                             );
                         }
                     }
 
-                    self.check_align_value(hint);
+                    self.check_align_value(*align, *repr_span);
                 }
-                sym::packed => {
+                ReprAttr::ReprPacked(_) => {
                     if target != Target::Struct && target != Target::Union {
                         self.dcx().emit_err(errors::AttrApplication::StructUnion {
-                            hint_span: hint.span(),
+                            hint_span: *repr_span,
                             span,
                         });
                     } else {
                         continue;
                     }
                 }
-                sym::simd => {
+                ReprAttr::ReprSimd => {
                     is_simd = true;
                     if target != Target::Struct {
                         self.dcx().emit_err(errors::AttrApplication::Struct {
-                            hint_span: hint.span(),
+                            hint_span: *repr_span,
                             span,
                         });
                     } else {
                         continue;
                     }
                 }
-                sym::transparent => {
+                ReprAttr::ReprTransparent => {
                     is_transparent = true;
                     match target {
                         Target::Struct | Target::Union | Target::Enum => continue,
                         _ => {
                             self.dcx().emit_err(errors::AttrApplication::StructEnumUnion {
-                                hint_span: hint.span(),
+                                hint_span: *repr_span,
                                 span,
                             });
                         }
                     }
                 }
-                sym::i8
-                | sym::u8
-                | sym::i16
-                | sym::u16
-                | sym::i32
-                | sym::u32
-                | sym::i64
-                | sym::u64
-                | sym::i128
-                | sym::u128
-                | sym::isize
-                | sym::usize => {
+                ReprAttr::ReprInt(_) => {
                     int_reprs += 1;
                     if target != Target::Enum {
                         self.dcx().emit_err(errors::AttrApplication::Enum {
-                            hint_span: hint.span(),
+                            hint_span: *repr_span,
                             span,
                         });
                     } else {
                         continue;
                     }
                 }
-                _ => {
-                    self.dcx().emit_err(errors::UnrecognizedReprHint { span: hint.span() });
-                    continue;
+                // FIXME(jdonszelmann): move the diagnostic for unused repr attrs here, I think
+                // it's a better place for it.
+                ReprAttr::ReprEmpty => {
+                    // catch `repr()` with no arguments, applied to an item (i.e. not `#![repr()]`)
+                    if item.is_some() {
+                        match target {
+                            Target::Struct | Target::Union | Target::Enum => {}
+                            Target::Fn | Target::Method(_) => {
+                                feature_err(
+                                    &self.tcx.sess,
+                                    sym::fn_align,
+                                    *repr_span,
+                                    fluent::passes_repr_align_function,
+                                )
+                                .emit();
+                            }
+                            _ => {
+                                self.dcx().emit_err(
+                                    errors::AttrApplication::StructEnumFunctionMethodUnion {
+                                        hint_span: *repr_span,
+                                        span,
+                                    },
+                                );
+                            }
+                        }
+                    }
+
+                    return;
                 }
             };
         }
 
         // Just point at all repr hints if there are any incompatibilities.
         // This is not ideal, but tracking precisely which ones are at fault is a huge hassle.
-        let hint_spans = hints.iter().map(|hint| hint.span());
+        let hint_spans = reprs.iter().map(|(_, span)| *span);
 
         // Error on repr(transparent, <anything else>).
-        if is_transparent && hints.len() > 1 {
+        if is_transparent && reprs.len() > 1 {
             let hint_spans = hint_spans.clone().collect();
             self.dcx().emit_err(errors::TransparentIncompatible {
                 hint_spans,
@@ -2051,41 +2053,21 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         }
     }
 
-    fn check_align_value(&self, item: &MetaItemInner) {
-        match item.singleton_lit_list() {
-            Some((
-                _,
-                MetaItemLit {
-                    kind: ast::LitKind::Int(literal, ast::LitIntType::Unsuffixed), ..
-                },
-            )) => {
-                let val = literal.get() as u64;
-                if val > 2_u64.pow(29) {
-                    // for values greater than 2^29, a different error will be emitted, make sure that happens
-                    self.dcx().span_delayed_bug(
-                        item.span(),
-                        "alignment greater than 2^29 should be errored on elsewhere",
-                    );
-                } else {
-                    // only do this check when <= 2^29 to prevent duplicate errors:
-                    // alignment greater than 2^29 not supported
-                    // alignment is too large for the current target
+    fn check_align_value(&self, align: Align, span: Span) {
+        if align.bytes() > 2_u64.pow(29) {
+            // for values greater than 2^29, a different error will be emitted, make sure that happens
+            self.dcx().span_delayed_bug(
+                span,
+                "alignment greater than 2^29 should be errored on elsewhere",
+            );
+        } else {
+            // only do this check when <= 2^29 to prevent duplicate errors:
+            // alignment greater than 2^29 not supported
+            // alignment is too large for the current target
 
-                    let max =
-                        Size::from_bits(self.tcx.sess.target.pointer_width).signed_int_max() as u64;
-                    if val > max {
-                        self.dcx().emit_err(errors::InvalidReprAlignForTarget {
-                            span: item.span(),
-                            size: max,
-                        });
-                    }
-                }
-            }
-
-            // if the attribute is malformed, singleton_lit_list may not be of the expected type or may be None
-            // but an error will have already been emitted, so this code should just skip such attributes
-            Some((_, _)) | None => {
-                self.dcx().span_delayed_bug(item.span(), "malformed repr(align(N))");
+            let max = Size::from_bits(self.tcx.sess.target.pointer_width).signed_int_max() as u64;
+            if align.bytes() > max {
+                self.dcx().emit_err(errors::InvalidReprAlignForTarget { span, size: max });
             }
         }
     }
@@ -2096,7 +2078,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         for attr in attrs.iter().filter(|attr| attr.has_name(sym::used)) {
             if target != Target::Static {
                 self.dcx().emit_err(errors::UsedStatic {
-                    attr_span: attr.span,
+                    attr_span: attr.span(),
                     span: target_span,
                     target: target.name(),
                 });
@@ -2105,12 +2087,12 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             match inner.as_deref() {
                 Some([item]) if item.has_name(sym::linker) => {
                     if used_linker_span.is_none() {
-                        used_linker_span = Some(attr.span);
+                        used_linker_span = Some(attr.span());
                     }
                 }
                 Some([item]) if item.has_name(sym::compiler) => {
                     if used_compiler_span.is_none() {
-                        used_compiler_span = Some(attr.span);
+                        used_compiler_span = Some(attr.span());
                     }
                 }
                 Some(_) => {
@@ -2119,7 +2101,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 None => {
                     // Default case (compiler) when arg isn't defined.
                     if used_compiler_span.is_none() {
-                        used_compiler_span = Some(attr.span);
+                        used_compiler_span = Some(attr.span());
                     }
                 }
             }
@@ -2133,41 +2115,44 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
 
     /// Outputs an error for `#[allow_internal_unstable]` which can only be applied to macros.
     /// (Allows proc_macro functions)
+    // FIXME(jdonszelmann): if possible, move to attr parsing
     fn check_allow_internal_unstable(
         &self,
         hir_id: HirId,
-        attr: &Attribute,
+        attr_span: Span,
         span: Span,
         target: Target,
         attrs: &[Attribute],
     ) {
-        debug!("Checking target: {:?}", target);
         match target {
             Target::Fn => {
                 for attr in attrs {
                     if attr.is_proc_macro_attr() {
-                        debug!("Is proc macro attr");
+                        // return on proc macros
                         return;
                     }
                 }
-                debug!("Is not proc macro attr");
+                // continue out of the match
             }
-            Target::MacroDef => {}
+            // return on decl macros
+            Target::MacroDef => return,
             // FIXME(#80564): We permit struct fields and match arms to have an
             // `#[allow_internal_unstable]` attribute with just a lint, because we previously
             // erroneously allowed it and some crates used it accidentally, to be compatible
             // with crates depending on them, we can't throw an error here.
-            Target::Field | Target::Arm => self.inline_attr_str_error_without_macro_def(
-                hir_id,
-                attr,
-                "allow_internal_unstable",
-            ),
-            _ => {
-                self.tcx
-                    .dcx()
-                    .emit_err(errors::AllowInternalUnstable { attr_span: attr.span, span });
+            Target::Field | Target::Arm => {
+                self.inline_attr_str_error_without_macro_def(
+                    hir_id,
+                    attr_span,
+                    "allow_internal_unstable",
+                );
+                return;
             }
+            // otherwise continue out of the match
+            _ => {}
         }
+
+        self.tcx.dcx().emit_err(errors::AllowInternalUnstable { attr_span, span });
     }
 
     /// Checks if the items on the `#[debugger_visualizer]` attribute are valid.
@@ -2179,7 +2164,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::Mod => {}
             _ => {
-                self.dcx().emit_err(errors::DebugVisualizerPlacement { span: attr.span });
+                self.dcx().emit_err(errors::DebugVisualizerPlacement { span: attr.span() });
             }
         }
     }
@@ -2206,7 +2191,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             _ => {
                 self.tcx
                     .dcx()
-                    .emit_err(errors::RustcAllowConstFnUnstable { attr_span: attr.span, span });
+                    .emit_err(errors::RustcAllowConstFnUnstable { attr_span: attr.span(), span });
             }
         }
     }
@@ -2217,15 +2202,15 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             _ => {
                 self.tcx
                     .dcx()
-                    .emit_err(errors::RustcStdInternalSymbol { attr_span: attr.span, span });
+                    .emit_err(errors::RustcStdInternalSymbol { attr_span: attr.span(), span });
             }
         }
     }
 
-    fn check_stability_promotable(&self, attr: &Attribute, target: Target) {
+    fn check_stability_promotable(&self, span: Span, target: Target) {
         match target {
             Target::Expression => {
-                self.dcx().emit_err(errors::StabilityPromotable { attr_span: attr.span });
+                self.dcx().emit_err(errors::StabilityPromotable { attr_span: span });
             }
             _ => {}
         }
@@ -2235,41 +2220,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::ForeignFn | Target::ForeignStatic => {}
             _ => {
-                self.dcx().emit_err(errors::LinkOrdinal { attr_span: attr.span });
+                self.dcx().emit_err(errors::LinkOrdinal { attr_span: attr.span() });
             }
         }
     }
 
-    fn check_confusables(&self, attr: &Attribute, target: Target) {
-        match target {
-            Target::Method(MethodKind::Inherent) => {
-                let Some(metas) = attr.meta_item_list() else {
-                    return;
-                };
-
-                let mut candidates = Vec::new();
-
-                for meta in metas {
-                    let MetaItemInner::Lit(meta_lit) = meta else {
-                        self.dcx().emit_err(errors::IncorrectMetaItem {
-                            span: meta.span(),
-                            suggestion: errors::IncorrectMetaItemSuggestion {
-                                lo: meta.span().shrink_to_lo(),
-                                hi: meta.span().shrink_to_hi(),
-                            },
-                        });
-                        return;
-                    };
-                    candidates.push(meta_lit.symbol);
-                }
-
-                if candidates.is_empty() {
-                    self.dcx().emit_err(errors::EmptyConfusables { span: attr.span });
-                }
-            }
-            _ => {
-                self.dcx().emit_err(errors::Confusables { attr_span: attr.span });
-            }
+    fn check_confusables(&self, span: Span, target: Target) {
+        if !matches!(target, Target::Method(MethodKind::Inherent)) {
+            self.dcx().emit_err(errors::Confusables { attr_span: span });
         }
     }
 
@@ -2279,7 +2237,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::Deprecated,
                 );
             }
@@ -2295,7 +2253,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::MacroUse { name },
                 );
             }
@@ -2307,7 +2265,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             self.tcx.emit_node_span_lint(
                 UNUSED_ATTRIBUTES,
                 hir_id,
-                attr.span,
+                attr.span(),
                 errors::MacroExport::Normal,
             );
         } else if let Some(meta_item_list) = attr.meta_item_list()
@@ -2317,7 +2275,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     INVALID_MACRO_EXPORT_ARGUMENTS,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::MacroExport::TooManyItems,
                 );
             } else if meta_item_list[0].name_or_empty() != sym::local_inner_macros {
@@ -2337,7 +2295,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 self.tcx.emit_node_span_lint(
                     UNUSED_ATTRIBUTES,
                     hir_id,
-                    attr.span,
+                    attr.span(),
                     errors::MacroExport::OnDeclMacro,
                 );
             }
@@ -2345,8 +2303,32 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
     }
 
     fn check_unused_attribute(&self, hir_id: HirId, attr: &Attribute) {
+        // FIXME(jdonszelmann): deduplicate these checks after more attrs are parsed. This is very
+        // ugly now but can 100% be removed later.
+        if let Attribute::Parsed(p) = attr {
+            match p {
+                AttributeKind::Repr(reprs) => {
+                    for (r, span) in reprs {
+                        if let ReprAttr::ReprEmpty = r {
+                            self.tcx.emit_node_span_lint(
+                                UNUSED_ATTRIBUTES,
+                                hir_id,
+                                *span,
+                                errors::Unused {
+                                    attr_span: *span,
+                                    note: errors::UnusedNote::EmptyList { name: sym::repr },
+                                },
+                            );
+                        }
+                    }
+                    return;
+                }
+                _ => {}
+            }
+        }
+
         // Warn on useless empty attributes.
-        let note = if matches!(
+        let note = if (matches!(
             attr.name_or_empty(),
             sym::macro_use
                 | sym::allow
@@ -2355,9 +2337,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                 | sym::deny
                 | sym::forbid
                 | sym::feature
-                | sym::repr
                 | sym::target_feature
-        ) && attr.meta_item_list().is_some_and(|list| list.is_empty())
+        ) && attr.meta_item_list().is_some_and(|list| list.is_empty()))
         {
             errors::UnusedNote::EmptyList { name: attr.name_or_empty() }
         } else if matches!(
@@ -2379,17 +2360,17 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             })
         {
             if hir_id != CRATE_HIR_ID {
-                match attr.style {
+                match attr.style() {
                     ast::AttrStyle::Outer => self.tcx.emit_node_span_lint(
                         UNUSED_ATTRIBUTES,
                         hir_id,
-                        attr.span,
+                        attr.span(),
                         errors::OuterCrateLevelAttr,
                     ),
                     ast::AttrStyle::Inner => self.tcx.emit_node_span_lint(
                         UNUSED_ATTRIBUTES,
                         hir_id,
-                        attr.span,
+                        attr.span(),
                         errors::InnerCrateLevelAttr,
                     ),
                 };
@@ -2415,8 +2396,8 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         self.tcx.emit_node_span_lint(
             UNUSED_ATTRIBUTES,
             hir_id,
-            attr.span,
-            errors::Unused { attr_span: attr.span, note },
+            attr.span(),
+            errors::Unused { attr_span: attr.span(), note },
         );
     }
 
@@ -2532,7 +2513,7 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
         match target {
             Target::Closure => return,
             _ => {
-                self.dcx().emit_err(errors::CoroutineOnNonClosure { span: attr.span });
+                self.dcx().emit_err(errors::CoroutineOnNonClosure { span: attr.span() });
             }
         }
     }
@@ -2545,18 +2526,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
             | Target::ForeignStatic
             | Target::ForeignFn => {}
             _ => {
-                self.dcx().emit_err(errors::Linkage { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::Linkage { attr_span: attr.span(), span });
             }
         }
     }
 
     fn check_rustc_pub_transparent(&self, attr_span: Span, span: Span, attrs: &[Attribute]) {
-        if !attrs
-            .iter()
-            .filter(|attr| attr.has_name(sym::repr))
-            .filter_map(|attr| attr.meta_item_list())
-            .flatten()
-            .any(|nmi| nmi.has_name(sym::transparent))
+        if !find_attr!(attrs, AttributeKind::Repr(r) => r.iter().any(|(r, _)| r == &ReprAttr::ReprTransparent))
+            .unwrap_or(false)
         {
             self.dcx().emit_err(errors::RustcPubTransparent { span, attr_span });
         }
@@ -2588,14 +2565,14 @@ impl<'tcx> CheckAttrVisitor<'tcx> {
                     && is_coro
                 {
                     self.dcx().emit_err(errors::RustcForceInlineCoro {
-                        attr_span: attr.span,
+                        attr_span: attr.span(),
                         span: parent_span,
                     });
                 }
             }
             (Target::Fn, _) => (),
             (_, Some(attr)) => {
-                self.dcx().emit_err(errors::RustcForceInline { attr_span: attr.span, span });
+                self.dcx().emit_err(errors::RustcForceInline { attr_span: attr.span(), span });
             }
             (_, None) => (),
         }
@@ -2733,7 +2710,6 @@ fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
     // resolution for the attribute macro error.
     const ATTRS_TO_CHECK: &[Symbol] = &[
         sym::macro_export,
-        sym::repr,
         sym::path,
         sym::automatically_derived,
         sym::rustc_main,
@@ -2745,47 +2721,46 @@ fn check_invalid_crate_level_attr(tcx: TyCtxt<'_>, attrs: &[Attribute]) {
     ];
 
     for attr in attrs {
-        // This function should only be called with crate attributes
-        // which are inner attributes always but lets check to make sure
-        if attr.style == AttrStyle::Inner {
-            for attr_to_check in ATTRS_TO_CHECK {
-                if attr.has_name(*attr_to_check) {
-                    let item = tcx
-                        .hir_free_items()
-                        .map(|id| tcx.hir_item(id))
-                        .find(|item| !item.span.is_dummy()) // Skip prelude `use`s
-                        .map(|item| errors::ItemFollowingInnerAttr {
-                            span: item.ident.span,
-                            kind: item.kind.descr(),
-                        });
-                    let err = tcx.dcx().create_err(errors::InvalidAttrAtCrateLevel {
-                        span: attr.span,
-                        sugg_span: tcx
-                            .sess
-                            .source_map()
-                            .span_to_snippet(attr.span)
-                            .ok()
-                            .filter(|src| src.starts_with("#!["))
-                            .map(|_| {
-                                attr.span
-                                    .with_lo(attr.span.lo() + BytePos(1))
-                                    .with_hi(attr.span.lo() + BytePos(2))
-                            }),
-                        name: *attr_to_check,
-                        item,
-                    });
+        // FIXME(jdonszelmann): all attrs should be combined here cleaning this up some day.
+        let (span, name) = if let Some(a) =
+            ATTRS_TO_CHECK.iter().find(|attr_to_check| attr.has_name(**attr_to_check))
+        {
+            (attr.span(), *a)
+        } else if let Attribute::Parsed(AttributeKind::Repr(r)) = attr {
+            (r.first().unwrap().1, sym::repr)
+        } else {
+            continue;
+        };
 
-                    if let AttrKind::Normal(ref p) = attr.kind {
-                        tcx.dcx().try_steal_replace_and_emit_err(
-                            p.path.span,
-                            StashKey::UndeterminedMacroResolution,
-                            err,
-                        );
-                    } else {
-                        err.emit();
-                    }
-                }
-            }
+        let item = tcx
+            .hir_free_items()
+            .map(|id| tcx.hir_item(id))
+            .find(|item| !item.span.is_dummy()) // Skip prelude `use`s
+            .map(|item| errors::ItemFollowingInnerAttr {
+                span: item.ident.span,
+                kind: item.kind.descr(),
+            });
+        let err = tcx.dcx().create_err(errors::InvalidAttrAtCrateLevel {
+            span,
+            sugg_span: tcx
+                .sess
+                .source_map()
+                .span_to_snippet(span)
+                .ok()
+                .filter(|src| src.starts_with("#!["))
+                .map(|_| span.with_lo(span.lo() + BytePos(1)).with_hi(span.lo() + BytePos(2))),
+            name,
+            item,
+        });
+
+        if let Attribute::Unparsed(p) = attr {
+            tcx.dcx().try_steal_replace_and_emit_err(
+                p.path.span,
+                StashKey::UndeterminedMacroResolution,
+                err,
+            );
+        } else {
+            err.emit();
         }
     }
 }
@@ -2795,7 +2770,7 @@ fn check_non_exported_macro_for_invalid_attrs(tcx: TyCtxt<'_>, item: &Item<'_>)
 
     for attr in attrs {
         if attr.has_name(sym::inline) {
-            tcx.dcx().emit_err(errors::NonExportedMacroInvalidAttrs { attr_span: attr.span });
+            tcx.dcx().emit_err(errors::NonExportedMacroInvalidAttrs { attr_span: attr.span() });
         }
     }
 }
@@ -2833,10 +2808,10 @@ fn check_duplicates(
             match seen.entry(attr.name_or_empty()) {
                 Entry::Occupied(mut entry) => {
                     let (this, other) = if matches!(duplicates, FutureWarnPreceding) {
-                        let to_remove = entry.insert(attr.span);
-                        (to_remove, attr.span)
+                        let to_remove = entry.insert(attr.span());
+                        (to_remove, attr.span())
                     } else {
-                        (attr.span, *entry.get())
+                        (attr.span(), *entry.get())
                     };
                     tcx.emit_node_span_lint(
                         UNUSED_ATTRIBUTES,
@@ -2853,17 +2828,17 @@ fn check_duplicates(
                     );
                 }
                 Entry::Vacant(entry) => {
-                    entry.insert(attr.span);
+                    entry.insert(attr.span());
                 }
             }
         }
         ErrorFollowing | ErrorPreceding => match seen.entry(attr.name_or_empty()) {
             Entry::Occupied(mut entry) => {
                 let (this, other) = if matches!(duplicates, ErrorPreceding) {
-                    let to_remove = entry.insert(attr.span);
-                    (to_remove, attr.span)
+                    let to_remove = entry.insert(attr.span());
+                    (to_remove, attr.span())
                 } else {
-                    (attr.span, *entry.get())
+                    (attr.span(), *entry.get())
                 };
                 tcx.dcx().emit_err(errors::UnusedMultiple {
                     this,
@@ -2872,7 +2847,7 @@ fn check_duplicates(
                 });
             }
             Entry::Vacant(entry) => {
-                entry.insert(attr.span);
+                entry.insert(attr.span());
             }
         },
     }
diff --git a/compiler/rustc_passes/src/entry.rs b/compiler/rustc_passes/src/entry.rs
index c2225ea1e642..25e679a84601 100644
--- a/compiler/rustc_passes/src/entry.rs
+++ b/compiler/rustc_passes/src/entry.rs
@@ -46,7 +46,7 @@ fn entry_fn(tcx: TyCtxt<'_>, (): ()) -> Option<(DefId, EntryFnType)> {
 
 fn attr_span_by_symbol(ctxt: &EntryContext<'_>, id: ItemId, sym: Symbol) -> Option<Span> {
     let attrs = ctxt.tcx.hir().attrs(id.hir_id());
-    attr::find_by_name(attrs, sym).map(|attr| attr.span)
+    attr::find_by_name(attrs, sym).map(|attr| attr.span())
 }
 
 fn check_and_search_item(id: ItemId, ctxt: &mut EntryContext<'_>) {
diff --git a/compiler/rustc_passes/src/errors.rs b/compiler/rustc_passes/src/errors.rs
index 9bcdd2385470..9bb9b2353dc8 100644
--- a/compiler/rustc_passes/src/errors.rs
+++ b/compiler/rustc_passes/src/errors.rs
@@ -582,13 +582,6 @@ pub(crate) struct NoMangle {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_repr_ident, code = E0565)]
-pub(crate) struct ReprIdent {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(passes_repr_conflicting, code = E0566)]
 pub(crate) struct ReprConflicting {
@@ -736,31 +729,6 @@ pub(crate) struct Linkage {
     pub span: Span,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_empty_confusables)]
-pub(crate) struct EmptyConfusables {
-    #[primary_span]
-    pub span: Span,
-}
-
-#[derive(Diagnostic)]
-#[diag(passes_incorrect_meta_item, code = E0539)]
-pub(crate) struct IncorrectMetaItem {
-    #[primary_span]
-    pub span: Span,
-    #[subdiagnostic]
-    pub suggestion: IncorrectMetaItemSuggestion,
-}
-
-#[derive(Subdiagnostic)]
-#[multipart_suggestion(passes_incorrect_meta_item_suggestion, applicability = "maybe-incorrect")]
-pub(crate) struct IncorrectMetaItemSuggestion {
-    #[suggestion_part(code = "\"")]
-    pub lo: Span,
-    #[suggestion_part(code = "\"")]
-    pub hi: Span,
-}
-
 #[derive(Diagnostic)]
 #[diag(passes_stability_promotable)]
 pub(crate) struct StabilityPromotable {
@@ -1037,10 +1005,10 @@ pub(crate) struct LayoutHomogeneousAggregate {
 
 #[derive(Diagnostic)]
 #[diag(passes_layout_of)]
-pub(crate) struct LayoutOf {
+pub(crate) struct LayoutOf<'tcx> {
     #[primary_span]
     pub span: Span,
-    pub normalized_ty: String,
+    pub normalized_ty: Ty<'tcx>,
     pub ty_layout: String,
 }
 
@@ -1475,14 +1443,6 @@ pub(crate) struct ObjectLifetimeErr {
     pub repr: String,
 }
 
-#[derive(Diagnostic)]
-#[diag(passes_unrecognized_repr_hint, code = E0552)]
-#[help]
-pub(crate) struct UnrecognizedReprHint {
-    #[primary_span]
-    pub span: Span,
-}
-
 #[derive(Diagnostic)]
 pub(crate) enum AttrApplication {
     #[diag(passes_attr_application_enum, code = E0517)]
@@ -1592,6 +1552,45 @@ pub(crate) struct TraitImplConstStable {
     pub span: Span,
 }
 
+#[derive(Diagnostic)]
+#[diag(passes_trait_impl_const_stability_mismatch)]
+pub(crate) struct TraitImplConstStabilityMismatch {
+    #[primary_span]
+    pub span: Span,
+    #[subdiagnostic]
+    pub impl_stability: ImplConstStability,
+    #[subdiagnostic]
+    pub trait_stability: TraitConstStability,
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum TraitConstStability {
+    #[note(passes_trait_impl_const_stability_mismatch_trait_stable)]
+    Stable {
+        #[primary_span]
+        span: Span,
+    },
+    #[note(passes_trait_impl_const_stability_mismatch_trait_unstable)]
+    Unstable {
+        #[primary_span]
+        span: Span,
+    },
+}
+
+#[derive(Subdiagnostic)]
+pub(crate) enum ImplConstStability {
+    #[note(passes_trait_impl_const_stability_mismatch_impl_stable)]
+    Stable {
+        #[primary_span]
+        span: Span,
+    },
+    #[note(passes_trait_impl_const_stability_mismatch_impl_unstable)]
+    Unstable {
+        #[primary_span]
+        span: Span,
+    },
+}
+
 #[derive(Diagnostic)]
 #[diag(passes_unknown_feature, code = E0635)]
 pub(crate) struct UnknownFeature {
@@ -1902,3 +1901,11 @@ pub(crate) struct NoSanitize<'a> {
     pub accepted_kind: &'a str,
     pub attr_str: &'a str,
 }
+
+// FIXME(jdonszelmann): move back to rustc_attr
+#[derive(Diagnostic)]
+#[diag(passes_rustc_const_stable_indirect_pairing)]
+pub(crate) struct RustcConstStableIndirectPairing {
+    #[primary_span]
+    pub span: Span,
+}
diff --git a/compiler/rustc_passes/src/layout_test.rs b/compiler/rustc_passes/src/layout_test.rs
index 1133cf93304d..d4512c9417eb 100644
--- a/compiler/rustc_passes/src/layout_test.rs
+++ b/compiler/rustc_passes/src/layout_test.rs
@@ -112,8 +112,7 @@ fn dump_layout_of(tcx: TyCtxt<'_>, item_def_id: LocalDefId, attr: &Attribute) {
                     }
 
                     sym::debug => {
-                        let normalized_ty =
-                            format!("{}", tcx.normalize_erasing_regions(typing_env, ty));
+                        let normalized_ty = tcx.normalize_erasing_regions(typing_env, ty);
                         // FIXME: using the `Debug` impl here isn't ideal.
                         let ty_layout = format!("{:#?}", *ty_layout);
                         tcx.dcx().emit_err(LayoutOf { span, normalized_ty, ty_layout });
diff --git a/compiler/rustc_passes/src/lib_features.rs b/compiler/rustc_passes/src/lib_features.rs
index e123fbac1bee..7353c1ead5a7 100644
--- a/compiler/rustc_passes/src/lib_features.rs
+++ b/compiler/rustc_passes/src/lib_features.rs
@@ -4,7 +4,7 @@
 //! but are not declared in one single location (unlike lang features), which means we need to
 //! collect them instead.
 
-use rustc_attr_parsing::VERSION_PLACEHOLDER;
+use rustc_attr_parsing::{AttributeKind, StabilityLevel, StableSince};
 use rustc_hir::Attribute;
 use rustc_hir::intravisit::Visitor;
 use rustc_middle::hir::nested_filter;
@@ -26,62 +26,29 @@ impl<'tcx> LibFeatureCollector<'tcx> {
     }
 
     fn extract(&self, attr: &Attribute) -> Option<(Symbol, FeatureStability, Span)> {
-        let stab_attrs = [
-            sym::stable,
-            sym::unstable,
-            sym::rustc_const_stable,
-            sym::rustc_const_unstable,
-            sym::rustc_default_body_unstable,
-        ];
-
-        // Find a stability attribute: one of #[stable(…)], #[unstable(…)],
-        // #[rustc_const_stable(…)], #[rustc_const_unstable(…)] or #[rustc_default_body_unstable].
-        if let Some(stab_attr) = stab_attrs.iter().find(|stab_attr| attr.has_name(**stab_attr)) {
-            if let Some(metas) = attr.meta_item_list() {
-                let mut feature = None;
-                let mut since = None;
-                for meta in metas {
-                    if let Some(mi) = meta.meta_item() {
-                        // Find the `feature = ".."` meta-item.
-                        match (mi.name_or_empty(), mi.value_str()) {
-                            (sym::feature, val) => feature = val,
-                            (sym::since, val) => since = val,
-                            _ => {}
-                        }
-                    }
-                }
-
-                if let Some(s) = since
-                    && s.as_str() == VERSION_PLACEHOLDER
-                {
-                    since = Some(sym::env_CFG_RELEASE);
-                }
-
-                if let Some(feature) = feature {
-                    // This additional check for stability is to make sure we
-                    // don't emit additional, irrelevant errors for malformed
-                    // attributes.
-                    let is_unstable = matches!(
-                        *stab_attr,
-                        sym::unstable
-                            | sym::rustc_const_unstable
-                            | sym::rustc_default_body_unstable
-                    );
-                    if is_unstable {
-                        return Some((feature, FeatureStability::Unstable, attr.span));
-                    }
-                    if let Some(since) = since {
-                        return Some((feature, FeatureStability::AcceptedSince(since), attr.span));
-                    }
-                }
-                // We need to iterate over the other attributes, because
-                // `rustc_const_unstable` is not mutually exclusive with
-                // the other stability attributes, so we can't just `break`
-                // here.
+        let (feature, level, span) = match attr {
+            Attribute::Parsed(AttributeKind::Stability { stability, span }) => {
+                (stability.feature, stability.level, *span)
             }
-        }
+            Attribute::Parsed(AttributeKind::ConstStability { stability, span }) => {
+                (stability.feature, stability.level, *span)
+            }
+            Attribute::Parsed(AttributeKind::BodyStability { stability, span }) => {
+                (stability.feature, stability.level, *span)
+            }
+            _ => return None,
+        };
 
-        None
+        let feature_stability = match level {
+            StabilityLevel::Unstable { .. } => FeatureStability::Unstable,
+            StabilityLevel::Stable { since, .. } => FeatureStability::AcceptedSince(match since {
+                StableSince::Version(v) => Symbol::intern(&v.to_string()),
+                StableSince::Current => sym::env_CFG_RELEASE,
+                StableSince::Err => return None,
+            }),
+        };
+
+        Some((feature, feature_stability, span))
     }
 
     fn collect_feature(&mut self, feature: Symbol, stability: FeatureStability, span: Span) {
diff --git a/compiler/rustc_passes/src/stability.rs b/compiler/rustc_passes/src/stability.rs
index d92edf959aff..0fcf6a80ec4d 100644
--- a/compiler/rustc_passes/src/stability.rs
+++ b/compiler/rustc_passes/src/stability.rs
@@ -6,8 +6,8 @@ use std::num::NonZero;
 
 use rustc_ast_lowering::stability::extern_abi_stability;
 use rustc_attr_parsing::{
-    self as attr, ConstStability, DeprecatedSince, Stability, StabilityLevel, StableSince,
-    UnstableReason, VERSION_PLACEHOLDER,
+    self as attr, AttributeKind, ConstStability, DeprecatedSince, PartialConstStability, Stability,
+    StabilityLevel, StableSince, UnstableReason, VERSION_PLACEHOLDER, find_attr,
 };
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::unord::{ExtendUnord, UnordMap, UnordSet};
@@ -121,7 +121,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         let attrs = self.tcx.hir().attrs(self.tcx.local_def_id_to_hir_id(def_id));
         debug!("annotate(id = {:?}, attrs = {:?})", def_id, attrs);
 
-        let depr = attr::find_deprecation(self.tcx.sess, self.tcx.features(), attrs);
+        let depr = attr::find_attr!(attrs, AttributeKind::Deprecation{deprecation, span} => (*deprecation, *span));
+        let const_stability_indirect = find_attr!(attrs, AttributeKind::ConstStabilityIndirect);
+
         let mut is_deprecated = false;
         if let Some((depr, span)) = &depr {
             is_deprecated = true;
@@ -154,9 +156,10 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
                 if inherit_deprecation.yes() && stab.is_unstable() {
                     self.index.stab_map.insert(def_id, stab);
                     if fn_sig.is_some_and(|s| s.header.is_const()) {
-                        let const_stab =
-                            attr::unmarked_crate_const_stab(self.tcx.sess, attrs, stab);
-                        self.index.const_stab_map.insert(def_id, const_stab);
+                        self.index.const_stab_map.insert(
+                            def_id,
+                            ConstStability::unmarked(const_stability_indirect, stab),
+                        );
                     }
                 }
             }
@@ -171,9 +174,9 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         }
 
         // # Regular and body stability
-
-        let stab = attr::find_stability(self.tcx.sess, attrs, item_sp);
-        let body_stab = attr::find_body_stability(self.tcx.sess, attrs);
+        let stab = attr::find_attr!(attrs, AttributeKind::Stability { stability, span } => (*stability, *span));
+        let body_stab =
+            attr::find_attr!(attrs, AttributeKind::BodyStability { stability, .. } => *stability);
 
         if let Some((depr, span)) = &depr
             && depr.is_since_rustc_version()
@@ -182,7 +185,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             self.tcx.dcx().emit_err(errors::DeprecatedAttribute { span: *span });
         }
 
-        if let Some((body_stab, _span)) = body_stab {
+        if let Some(body_stab) = body_stab {
             // FIXME: check that this item can have body stability
 
             self.index.default_body_stab_map.insert(def_id, body_stab);
@@ -260,10 +263,10 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
 
         // # Const stability
 
-        let const_stab = attr::find_const_stability(self.tcx.sess, attrs, item_sp);
+        let const_stab = attr::find_attr!(attrs, AttributeKind::ConstStability { stability, span } => (*stability, *span));
 
         // If the current node is a function with const stability attributes (directly given or
-        // implied), check if the function/method is const.
+        // implied), check if the function/method is const or the parent impl block is const.
         if let Some(fn_sig) = fn_sig
             && !fn_sig.header.is_const()
             && const_stab.is_some()
@@ -285,7 +288,7 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
         // Stable *language* features shouldn't be used as unstable library features.
         // (Not doing this for stable library features is checked by tidy.)
         if let Some((
-            ConstStability { level: StabilityLevel::Unstable { .. }, feature, .. },
+            PartialConstStability { level: StabilityLevel::Unstable { .. }, feature, .. },
             const_span,
         )) = const_stab
         {
@@ -297,12 +300,20 @@ impl<'a, 'tcx> Annotator<'a, 'tcx> {
             }
         }
 
+        if let Some((stab, span)) = &const_stab
+            && stab.is_const_stable()
+            && const_stability_indirect
+        {
+            self.tcx.dcx().emit_err(errors::RustcConstStableIndirectPairing { span: *span });
+        }
+
         // After checking the immediate attributes, get rid of the span and compute implied
         // const stability: inherit feature gate from regular stability.
-        let mut const_stab = const_stab.map(|(stab, _span)| stab);
+        let mut const_stab = const_stab
+            .map(|(stab, _span)| ConstStability::from_partial(stab, const_stability_indirect));
 
         // If this is a const fn but not annotated with stability markers, see if we can inherit regular stability.
-        if fn_sig.is_some_and(|s| s.header.is_const())  && const_stab.is_none() &&
+        if fn_sig.is_some_and(|s| s.header.is_const()) && const_stab.is_none() &&
             // We only ever inherit unstable features.
             let Some(inherit_regular_stab) =
                 final_stab.filter(|s| s.is_unstable())
@@ -785,8 +796,10 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                 let features = self.tcx.features();
                 if features.staged_api() {
                     let attrs = self.tcx.hir().attrs(item.hir_id());
-                    let stab = attr::find_stability(self.tcx.sess, attrs, item.span);
-                    let const_stab = attr::find_const_stability(self.tcx.sess, attrs, item.span);
+                    let stab = attr::find_attr!(attrs, AttributeKind::Stability{stability, span} => (*stability, *span));
+
+                    // FIXME(jdonszelmann): make it impossible to miss the or_else in the typesystem
+                    let const_stab = attr::find_attr!(attrs, AttributeKind::ConstStability{stability, ..} => *stability);
 
                     // If this impl block has an #[unstable] attribute, give an
                     // error if all involved types and traits are stable, because
@@ -813,24 +826,56 @@ impl<'tcx> Visitor<'tcx> for Checker<'tcx> {
                         }
                     }
 
-                    // `#![feature(const_trait_impl)]` is unstable, so any impl declared stable
-                    // needs to have an error emitted.
                     if features.const_trait_impl()
-                        && self.tcx.is_const_trait_impl(item.owner_id.to_def_id())
-                        && const_stab.is_some_and(|(stab, _)| stab.is_const_stable())
+                        && let hir::Constness::Const = constness
                     {
-                        self.tcx.dcx().emit_err(errors::TraitImplConstStable { span: item.span });
+                        let stable_or_implied_stable = match const_stab {
+                            None => true,
+                            Some(stab) if stab.is_const_stable() => {
+                                // `#![feature(const_trait_impl)]` is unstable, so any impl declared stable
+                                // needs to have an error emitted.
+                                // Note: Remove this error once `const_trait_impl` is stabilized
+                                self.tcx
+                                    .dcx()
+                                    .emit_err(errors::TraitImplConstStable { span: item.span });
+                                true
+                            }
+                            Some(_) => false,
+                        };
+
+                        if let Some(trait_id) = t.trait_def_id()
+                            && let Some(const_stab) = self.tcx.lookup_const_stability(trait_id)
+                        {
+                            // the const stability of a trait impl must match the const stability on the trait.
+                            if const_stab.is_const_stable() != stable_or_implied_stable {
+                                let trait_span = self.tcx.def_ident_span(trait_id).unwrap();
+
+                                let impl_stability = if stable_or_implied_stable {
+                                    errors::ImplConstStability::Stable { span: item.span }
+                                } else {
+                                    errors::ImplConstStability::Unstable { span: item.span }
+                                };
+                                let trait_stability = if const_stab.is_const_stable() {
+                                    errors::TraitConstStability::Stable { span: trait_span }
+                                } else {
+                                    errors::TraitConstStability::Unstable { span: trait_span }
+                                };
+
+                                self.tcx.dcx().emit_err(errors::TraitImplConstStabilityMismatch {
+                                    span: item.span,
+                                    impl_stability,
+                                    trait_stability,
+                                });
+                            }
+                        }
                     }
                 }
 
-                match constness {
-                    rustc_hir::Constness::Const => {
-                        if let Some(def_id) = t.trait_def_id() {
-                            // FIXME(const_trait_impl): Improve the span here.
-                            self.tcx.check_const_stability(def_id, t.path.span, t.path.span);
-                        }
-                    }
-                    rustc_hir::Constness::NotConst => {}
+                if let hir::Constness::Const = constness
+                    && let Some(def_id) = t.trait_def_id()
+                {
+                    // FIXME(const_trait_impl): Improve the span here.
+                    self.tcx.check_const_stability(def_id, t.path.span, t.path.span);
                 }
 
                 for impl_item_ref in *items {
diff --git a/compiler/rustc_privacy/src/lib.rs b/compiler/rustc_privacy/src/lib.rs
index 41725d0c6a4f..5271d03a6f61 100644
--- a/compiler/rustc_privacy/src/lib.rs
+++ b/compiler/rustc_privacy/src/lib.rs
@@ -22,6 +22,7 @@ use errors::{
 };
 use rustc_ast::MacroDef;
 use rustc_ast::visit::{VisitorResult, try_visit};
+use rustc_attr_parsing::AttributeKind;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_data_structures::intern::Interned;
 use rustc_errors::{MultiSpan, listify};
@@ -493,7 +494,11 @@ impl<'tcx> EmbargoVisitor<'tcx> {
         // Non-opaque macros cannot make other items more accessible than they already are.
         let hir_id = self.tcx.local_def_id_to_hir_id(local_def_id);
         let attrs = self.tcx.hir().attrs(hir_id);
-        if attr::find_transparency(attrs, md.macro_rules).0 != Transparency::Opaque {
+
+        if attr::find_attr!(attrs, AttributeKind::MacroTransparency(x) => *x)
+            .unwrap_or(Transparency::fallback(md.macro_rules))
+            != Transparency::Opaque
+        {
             return;
         }
 
diff --git a/compiler/rustc_query_impl/Cargo.toml b/compiler/rustc_query_impl/Cargo.toml
index d89e1355ca67..c85156e059e5 100644
--- a/compiler/rustc_query_impl/Cargo.toml
+++ b/compiler/rustc_query_impl/Cargo.toml
@@ -6,6 +6,7 @@ edition = "2024"
 [dependencies]
 # tidy-alphabetical-start
 measureme = "11"
+rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_hashes = { path = "../rustc_hashes" }
diff --git a/compiler/rustc_query_system/Cargo.toml b/compiler/rustc_query_system/Cargo.toml
index 839465f9273b..3e8ccb51021e 100644
--- a/compiler/rustc_query_system/Cargo.toml
+++ b/compiler/rustc_query_system/Cargo.toml
@@ -9,6 +9,7 @@ parking_lot = "0.12"
 rustc-rayon-core = { version = "0.5.0" }
 rustc_abi = { path = "../rustc_abi" }
 rustc_ast = { path = "../rustc_ast" }
+rustc_attr_data_structures = { path = "../rustc_attr_data_structures" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_feature = { path = "../rustc_feature" }
diff --git a/compiler/rustc_query_system/src/ich/hcx.rs b/compiler/rustc_query_system/src/ich/hcx.rs
index cf50e61e72ba..e1b6adc6cc17 100644
--- a/compiler/rustc_query_system/src/ich/hcx.rs
+++ b/compiler/rustc_query_system/src/ich/hcx.rs
@@ -129,3 +129,4 @@ impl<'a> rustc_span::HashStableContext for StableHashingContext<'a> {
 }
 
 impl<'a> rustc_session::HashStableContext for StableHashingContext<'a> {}
+impl<'a> rustc_attr_data_structures::HashStableContext for StableHashingContext<'a> {}
diff --git a/compiler/rustc_query_system/src/ich/impls_syntax.rs b/compiler/rustc_query_system/src/ich/impls_syntax.rs
index 7d508b8201bd..1dcd5d9058f4 100644
--- a/compiler/rustc_query_system/src/ich/impls_syntax.rs
+++ b/compiler/rustc_query_system/src/ich/impls_syntax.rs
@@ -2,7 +2,7 @@
 //! from various crates in no particular order.
 
 use rustc_data_structures::stable_hasher::{HashStable, StableHasher};
-use rustc_hir as hir;
+use rustc_hir::{self as hir, HashIgnoredAttrId};
 use rustc_span::SourceFile;
 use smallvec::SmallVec;
 
@@ -23,6 +23,7 @@ impl<'a> HashStable<StableHashingContext<'a>> for [hir::Attribute] {
             .iter()
             .filter(|attr| {
                 !attr.is_doc_comment()
+                    // FIXME(jdonszelmann) have a better way to handle ignored attrs
                     && !attr.ident().is_some_and(|ident| hcx.is_ignored_attr(ident.name))
             })
             .collect();
@@ -35,19 +36,8 @@ impl<'a> HashStable<StableHashingContext<'a>> for [hir::Attribute] {
 }
 
 impl<'ctx> rustc_hir::HashStableContext for StableHashingContext<'ctx> {
-    fn hash_attr(&mut self, attr: &hir::Attribute, hasher: &mut StableHasher) {
-        // Make sure that these have been filtered out.
-        debug_assert!(!attr.ident().is_some_and(|ident| self.is_ignored_attr(ident.name)));
-        debug_assert!(!attr.is_doc_comment());
-
-        let hir::Attribute { kind, id: _, style, span } = attr;
-        if let hir::AttrKind::Normal(item) = kind {
-            item.hash_stable(self, hasher);
-            style.hash_stable(self, hasher);
-            span.hash_stable(self, hasher);
-        } else {
-            unreachable!();
-        }
+    fn hash_attr_id(&mut self, _id: &HashIgnoredAttrId, _hasher: &mut StableHasher) {
+        /* we don't hash HashIgnoredAttrId, we ignore them */
     }
 }
 
diff --git a/compiler/rustc_resolve/messages.ftl b/compiler/rustc_resolve/messages.ftl
index b13de2875bc2..9f062b3935fd 100644
--- a/compiler/rustc_resolve/messages.ftl
+++ b/compiler/rustc_resolve/messages.ftl
@@ -125,9 +125,6 @@ resolve_const_param_in_enum_discriminant =
 resolve_const_param_in_non_trivial_anon_const =
     const parameters may only be used as standalone arguments, i.e. `{$name}`
 
-resolve_const_param_in_ty_of_const_param =
-    const parameters may not be used in the type of const parameters
-
 resolve_constructor_private_if_any_field_private =
     a constructor is private if any of the fields is private
 
@@ -250,9 +247,6 @@ resolve_lifetime_param_in_enum_discriminant =
 resolve_lifetime_param_in_non_trivial_anon_const =
     lifetime parameters may not be used in const expressions
 
-resolve_lifetime_param_in_ty_of_const_param =
-    lifetime parameters may not be used in the type of const parameters
-
 resolve_lowercase_self =
     attempt to use a non-constant value in a constant
     .suggestion = try using `Self`
@@ -437,9 +431,6 @@ resolve_type_param_in_enum_discriminant =
 resolve_type_param_in_non_trivial_anon_const =
     type parameters may not be used in const expressions
 
-resolve_type_param_in_ty_of_const_param =
-    type parameters may not be used in the type of const parameters
-
 resolve_undeclared_label =
     use of undeclared label `{$name}`
     .label = undeclared label `{$name}`
diff --git a/compiler/rustc_resolve/src/def_collector.rs b/compiler/rustc_resolve/src/def_collector.rs
index 5eb8e420fa4e..9d78c71b76aa 100644
--- a/compiler/rustc_resolve/src/def_collector.rs
+++ b/compiler/rustc_resolve/src/def_collector.rs
@@ -3,6 +3,7 @@ use std::mem;
 use rustc_ast::visit::FnKind;
 use rustc_ast::*;
 use rustc_ast_pretty::pprust;
+use rustc_attr_parsing::{AttributeParser, OmitDoc};
 use rustc_expand::expand::AstFragment;
 use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind};
@@ -132,8 +133,24 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
             ItemKind::Fn(..) | ItemKind::Delegation(..) => DefKind::Fn,
             ItemKind::MacroDef(def) => {
                 let edition = i.span.edition();
+
+                // FIXME(jdonszelmann) make one of these in the resolver?
+                // FIXME(jdonszelmann) don't care about tools here maybe? Just parse what we can.
+                // Does that prevents errors from happening? maybe
+                let parser = AttributeParser::new(
+                    &self.resolver.tcx.sess,
+                    self.resolver.tcx.features(),
+                    Vec::new(),
+                );
+                let attrs = parser.parse_attribute_list(
+                    &i.attrs,
+                    i.span,
+                    OmitDoc::Skip,
+                    std::convert::identity,
+                );
+
                 let macro_data =
-                    self.resolver.compile_macro(def, i.ident, &i.attrs, i.span, i.id, edition);
+                    self.resolver.compile_macro(def, i.ident, &attrs, i.span, i.id, edition);
                 let macro_kind = macro_data.ext.macro_kind();
                 opt_macro_data = Some(macro_data);
                 DefKind::Macro(macro_kind)
@@ -442,4 +459,43 @@ impl<'a, 'ra, 'tcx> visit::Visitor<'a> for DefCollector<'a, 'ra, 'tcx> {
         visit::walk_attribute(self, attr);
         self.in_attr = orig_in_attr;
     }
+
+    fn visit_inline_asm(&mut self, asm: &'a InlineAsm) {
+        let InlineAsm {
+            asm_macro: _,
+            template: _,
+            template_strs: _,
+            operands,
+            clobber_abis: _,
+            options: _,
+            line_spans: _,
+        } = asm;
+        for (op, _span) in operands {
+            match op {
+                InlineAsmOperand::In { expr, reg: _ }
+                | InlineAsmOperand::Out { expr: Some(expr), reg: _, late: _ }
+                | InlineAsmOperand::InOut { expr, reg: _, late: _ } => {
+                    self.visit_expr(expr);
+                }
+                InlineAsmOperand::Out { expr: None, reg: _, late: _ } => {}
+                InlineAsmOperand::SplitInOut { in_expr, out_expr, reg: _, late: _ } => {
+                    self.visit_expr(in_expr);
+                    if let Some(expr) = out_expr {
+                        self.visit_expr(expr);
+                    }
+                }
+                InlineAsmOperand::Const { anon_const } => {
+                    let def = self.create_def(
+                        anon_const.id,
+                        kw::Empty,
+                        DefKind::InlineConst,
+                        anon_const.value.span,
+                    );
+                    self.with_parent(def, |this| visit::walk_anon_const(this, anon_const));
+                }
+                InlineAsmOperand::Sym { sym } => self.visit_inline_asm_sym(sym),
+                InlineAsmOperand::Label { block } => self.visit_block(block),
+            }
+        }
+    }
 }
diff --git a/compiler/rustc_resolve/src/diagnostics.rs b/compiler/rustc_resolve/src/diagnostics.rs
index 5db6f83f3ee5..e3405c89b79a 100644
--- a/compiler/rustc_resolve/src/diagnostics.rs
+++ b/compiler/rustc_resolve/src/diagnostics.rs
@@ -890,9 +890,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             ResolutionError::ForwardDeclaredGenericParam => {
                 self.dcx().create_err(errs::ForwardDeclaredGenericParam { span })
             }
-            ResolutionError::ParamInTyOfConstParam { name, param_kind: is_type } => self
-                .dcx()
-                .create_err(errs::ParamInTyOfConstParam { span, name, param_kind: is_type }),
+            ResolutionError::ParamInTyOfConstParam { name } => {
+                self.dcx().create_err(errs::ParamInTyOfConstParam { span, name })
+            }
             ResolutionError::ParamInNonTrivialAnonConst { name, param_kind: is_type } => {
                 self.dcx().create_err(errs::ParamInNonTrivialAnonConst {
                     span,
@@ -1806,7 +1806,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             && !def_id.is_local()
             && let Some(attr) = self.tcx.get_attr(def_id, sym::non_exhaustive)
         {
-            non_exhaustive = Some(attr.span);
+            non_exhaustive = Some(attr.span());
         } else if let Some(span) = ctor_fields_span {
             let label = errors::ConstructorPrivateIfAnyFieldPrivate { span };
             err.subdiagnostic(label);
@@ -2252,7 +2252,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
     #[instrument(level = "debug", skip(self, parent_scope))]
     pub(crate) fn make_path_suggestion(
         &mut self,
-        span: Span,
         mut path: Vec<Segment>,
         parent_scope: &ParentScope<'ra>,
     ) -> Option<(Vec<Segment>, Option<String>)> {
@@ -2480,7 +2479,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             //   or  `use a::{b, c, d}};`
             //               ^^^^^^^^^^^
             let (has_nested, after_crate_name) =
-                find_span_immediately_after_crate_name(self.tcx.sess, module_name, import.use_span);
+                find_span_immediately_after_crate_name(self.tcx.sess, import.use_span);
             debug!(has_nested, ?after_crate_name);
 
             let source_map = self.tcx.sess.source_map();
@@ -2687,11 +2686,7 @@ fn extend_span_to_previous_binding(sess: &Session, binding_span: Span) -> Option
 /// //       ^^^^^^^^^^^^^^^ -- true
 /// ```
 #[instrument(level = "debug", skip(sess))]
-fn find_span_immediately_after_crate_name(
-    sess: &Session,
-    module_name: Symbol,
-    use_span: Span,
-) -> (bool, Span) {
+fn find_span_immediately_after_crate_name(sess: &Session, use_span: Span) -> (bool, Span) {
     let source_map = sess.source_map();
 
     // Using `use issue_59764::foo::{baz, makro};` as an example throughout..
diff --git a/compiler/rustc_resolve/src/errors.rs b/compiler/rustc_resolve/src/errors.rs
index 7eb795034b03..b5d3e5ea7767 100644
--- a/compiler/rustc_resolve/src/errors.rs
+++ b/compiler/rustc_resolve/src/errors.rs
@@ -347,19 +347,6 @@ pub(crate) struct ParamInTyOfConstParam {
     #[label]
     pub(crate) span: Span,
     pub(crate) name: Symbol,
-    #[subdiagnostic]
-    pub(crate) param_kind: Option<ParamKindInTyOfConstParam>,
-}
-
-#[derive(Debug)]
-#[derive(Subdiagnostic)]
-pub(crate) enum ParamKindInTyOfConstParam {
-    #[note(resolve_type_param_in_ty_of_const_param)]
-    Type,
-    #[note(resolve_const_param_in_ty_of_const_param)]
-    Const,
-    #[note(resolve_lifetime_param_in_ty_of_const_param)]
-    Lifetime,
 }
 
 #[derive(Diagnostic)]
diff --git a/compiler/rustc_resolve/src/ident.rs b/compiler/rustc_resolve/src/ident.rs
index 499b9bca4d2a..d9776be4dd0a 100644
--- a/compiler/rustc_resolve/src/ident.rs
+++ b/compiler/rustc_resolve/src/ident.rs
@@ -1131,6 +1131,17 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
             return Res::Err;
         }
 
+        if let RibKind::ConstParamTy = all_ribs[rib_index].kind {
+            if let Some(span) = finalize {
+                self.report_error(
+                    span,
+                    ResolutionError::ParamInTyOfConstParam { name: rib_ident.name },
+                );
+            }
+            assert_eq!(res, Res::Err);
+            return Res::Err;
+        }
+
         match res {
             Res::Local(_) => {
                 use ResolutionError::*;
@@ -1209,10 +1220,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                             if let Some(span) = finalize {
                                 self.report_error(
                                     span,
-                                    ParamInTyOfConstParam {
-                                        name: rib_ident.name,
-                                        param_kind: None,
-                                    },
+                                    ParamInTyOfConstParam { name: rib_ident.name },
                                 );
                             }
                             return Res::Err;
@@ -1239,6 +1247,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         | RibKind::MacroDefinition(..)
                         | RibKind::InlineAsmSym
                         | RibKind::AssocItem
+                        | RibKind::ConstParamTy
                         | RibKind::ForwardGenericParamBan => {
                             // Nothing to do. Continue.
                             continue;
@@ -1292,18 +1301,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         RibKind::Item(has_generic_params, def_kind) => {
                             (has_generic_params, def_kind)
                         }
-                        RibKind::ConstParamTy => {
-                            if let Some(span) = finalize {
-                                self.report_error(
-                                    span,
-                                    ResolutionError::ParamInTyOfConstParam {
-                                        name: rib_ident.name,
-                                        param_kind: Some(errors::ParamKindInTyOfConstParam::Type),
-                                    },
-                                );
-                            }
-                            return Res::Err;
-                        }
                     };
 
                     if let Some(span) = finalize {
@@ -1328,6 +1325,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         | RibKind::MacroDefinition(..)
                         | RibKind::InlineAsmSym
                         | RibKind::AssocItem
+                        | RibKind::ConstParamTy
                         | RibKind::ForwardGenericParamBan => continue,
 
                         RibKind::ConstantItem(trivial, _) => {
@@ -1361,18 +1359,6 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                         RibKind::Item(has_generic_params, def_kind) => {
                             (has_generic_params, def_kind)
                         }
-                        RibKind::ConstParamTy => {
-                            if let Some(span) = finalize {
-                                self.report_error(
-                                    span,
-                                    ResolutionError::ParamInTyOfConstParam {
-                                        name: rib_ident.name,
-                                        param_kind: Some(errors::ParamKindInTyOfConstParam::Const),
-                                    },
-                                );
-                            }
-                            return Res::Err;
-                        }
                     };
 
                     // This was an attempt to use a const parameter outside its scope.
diff --git a/compiler/rustc_resolve/src/imports.rs b/compiler/rustc_resolve/src/imports.rs
index 6b8a7493cd42..89b9a0743518 100644
--- a/compiler/rustc_resolve/src/imports.rs
+++ b/compiler/rustc_resolve/src/imports.rs
@@ -955,11 +955,9 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
                     } else {
                         None
                     };
-                    let err = match self.make_path_suggestion(
-                        span,
-                        import.module_path.clone(),
-                        &import.parent_scope,
-                    ) {
+                    let err = match self
+                        .make_path_suggestion(import.module_path.clone(), &import.parent_scope)
+                    {
                         Some((suggestion, note)) => UnresolvedImportError {
                             span,
                             label: None,
diff --git a/compiler/rustc_resolve/src/late.rs b/compiler/rustc_resolve/src/late.rs
index ad9c3465f0cc..f119ed55e7d1 100644
--- a/compiler/rustc_resolve/src/late.rs
+++ b/compiler/rustc_resolve/src/late.rs
@@ -94,7 +94,7 @@ impl PatternSource {
 }
 
 impl IntoDiagArg for PatternSource {
-    fn into_diag_arg(self) -> DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
         DiagArgValue::Str(Cow::Borrowed(self.descr()))
     }
 }
@@ -227,9 +227,11 @@ impl RibKind<'_> {
             | RibKind::ConstantItem(..)
             | RibKind::Module(_)
             | RibKind::MacroDefinition(_)
-            | RibKind::ConstParamTy
             | RibKind::InlineAsmSym => false,
-            RibKind::AssocItem | RibKind::Item(..) | RibKind::ForwardGenericParamBan => true,
+            RibKind::ConstParamTy
+            | RibKind::AssocItem
+            | RibKind::Item(..)
+            | RibKind::ForwardGenericParamBan => true,
         }
     }
 
@@ -1570,6 +1572,17 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
             forward_ty_ban_rib.bindings.insert(Ident::with_dummy_span(kw::SelfUpper), Res::Err);
         }
 
+        let mut forward_ty_ban_rib_const_param_ty = Rib {
+            bindings: forward_ty_ban_rib.bindings.clone(),
+            patterns_with_skipped_bindings: FxHashMap::default(),
+            kind: RibKind::ConstParamTy,
+        };
+        let mut forward_const_ban_rib_const_param_ty = Rib {
+            bindings: forward_const_ban_rib.bindings.clone(),
+            patterns_with_skipped_bindings: FxHashMap::default(),
+            kind: RibKind::ConstParamTy,
+        };
+
         self.with_lifetime_rib(LifetimeRibKind::AnonymousReportError, |this| {
             for param in params {
                 match param.kind {
@@ -1592,21 +1605,27 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         }
 
                         // Allow all following defaults to refer to this type parameter.
-                        forward_ty_ban_rib
-                            .bindings
-                            .remove(&Ident::with_dummy_span(param.ident.name));
+                        let i = &Ident::with_dummy_span(param.ident.name);
+                        forward_ty_ban_rib.bindings.remove(i);
+                        if this.r.tcx.features().generic_const_parameter_types() {
+                            forward_ty_ban_rib_const_param_ty.bindings.remove(i);
+                        }
                     }
                     GenericParamKind::Const { ref ty, kw_span: _, ref default } => {
                         // Const parameters can't have param bounds.
                         assert!(param.bounds.is_empty());
 
-                        this.ribs[TypeNS].push(Rib::new(RibKind::ConstParamTy));
-                        this.ribs[ValueNS].push(Rib::new(RibKind::ConstParamTy));
-                        this.with_lifetime_rib(LifetimeRibKind::ConstParamTy, |this| {
+                        this.ribs[TypeNS].push(forward_ty_ban_rib_const_param_ty);
+                        this.ribs[ValueNS].push(forward_const_ban_rib_const_param_ty);
+                        if this.r.tcx.features().generic_const_parameter_types() {
                             this.visit_ty(ty)
-                        });
-                        this.ribs[TypeNS].pop().unwrap();
-                        this.ribs[ValueNS].pop().unwrap();
+                        } else {
+                            this.with_lifetime_rib(LifetimeRibKind::ConstParamTy, |this| {
+                                this.visit_ty(ty)
+                            });
+                        }
+                        forward_const_ban_rib_const_param_ty = this.ribs[ValueNS].pop().unwrap();
+                        forward_ty_ban_rib_const_param_ty = this.ribs[TypeNS].pop().unwrap();
 
                         if let Some(expr) = default {
                             this.ribs[TypeNS].push(forward_ty_ban_rib);
@@ -1620,9 +1639,11 @@ impl<'a, 'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'a, 'ast, 'ra, 'tcx> {
                         }
 
                         // Allow all following defaults to refer to this const parameter.
-                        forward_const_ban_rib
-                            .bindings
-                            .remove(&Ident::with_dummy_span(param.ident.name));
+                        let i = &Ident::with_dummy_span(param.ident.name);
+                        forward_const_ban_rib.bindings.remove(i);
+                        if this.r.tcx.features().generic_const_parameter_types() {
+                            forward_const_ban_rib_const_param_ty.bindings.remove(i);
+                        }
                     }
                 }
             }
diff --git a/compiler/rustc_resolve/src/late/diagnostics.rs b/compiler/rustc_resolve/src/late/diagnostics.rs
index fa9c42e35933..0e14e7671b17 100644
--- a/compiler/rustc_resolve/src/late/diagnostics.rs
+++ b/compiler/rustc_resolve/src/late/diagnostics.rs
@@ -3052,7 +3052,6 @@ impl<'ast, 'ra: 'ast, 'tcx> LateResolutionVisitor<'_, 'ast, 'ra, 'tcx> {
             .create_err(errors::ParamInTyOfConstParam {
                 span: lifetime_ref.ident.span,
                 name: lifetime_ref.ident.name,
-                param_kind: Some(errors::ParamKindInTyOfConstParam::Lifetime),
             })
             .emit();
     }
diff --git a/compiler/rustc_resolve/src/lib.rs b/compiler/rustc_resolve/src/lib.rs
index eb4ac6ce77c9..4c5d4041022a 100644
--- a/compiler/rustc_resolve/src/lib.rs
+++ b/compiler/rustc_resolve/src/lib.rs
@@ -15,7 +15,6 @@
 #![doc(rust_logo)]
 #![feature(assert_matches)]
 #![feature(box_patterns)]
-#![feature(extract_if)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(let_chains)]
@@ -31,9 +30,7 @@ use std::sync::Arc;
 
 use diagnostics::{ImportSuggestion, LabelSuggestion, Suggestion};
 use effective_visibilities::EffectiveVisibilitiesVisitor;
-use errors::{
-    ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst, ParamKindInTyOfConstParam,
-};
+use errors::{ParamKindInEnumDiscriminant, ParamKindInNonTrivialAnonConst};
 use imports::{Import, ImportData, ImportKind, NameResolution};
 use late::{HasGenericParams, PathSource, PatternSource, UnnecessaryQualification};
 use macros::{MacroRulesBinding, MacroRulesScope, MacroRulesScopeRef};
@@ -277,8 +274,10 @@ enum ResolutionError<'ra> {
     },
     /// Error E0128: generic parameters with a default cannot use forward-declared identifiers.
     ForwardDeclaredGenericParam,
+    // FIXME(generic_const_parameter_types): This should give custom output specifying it's only
+    // problematic to use *forward declared* parameters when the feature is enabled.
     /// ERROR E0770: the type of const parameters must not depend on other generic parameters.
-    ParamInTyOfConstParam { name: Symbol, param_kind: Option<ParamKindInTyOfConstParam> },
+    ParamInTyOfConstParam { name: Symbol },
     /// generic parameters must not be used inside const evaluations.
     ///
     /// This error is only emitted when using `min_const_generics`.
diff --git a/compiler/rustc_resolve/src/macros.rs b/compiler/rustc_resolve/src/macros.rs
index a70def2f6c93..984dfff3ea56 100644
--- a/compiler/rustc_resolve/src/macros.rs
+++ b/compiler/rustc_resolve/src/macros.rs
@@ -5,7 +5,6 @@ use std::cell::Cell;
 use std::mem;
 use std::sync::Arc;
 
-use rustc_ast::attr::AttributeExt;
 use rustc_ast::expand::StrippedCfgItem;
 use rustc_ast::{self as ast, Crate, NodeId, attr};
 use rustc_ast_pretty::pprust;
@@ -1112,7 +1111,7 @@ impl<'ra, 'tcx> Resolver<'ra, 'tcx> {
         &mut self,
         macro_def: &ast::MacroDef,
         ident: Ident,
-        attrs: &[impl AttributeExt],
+        attrs: &[rustc_hir::Attribute],
         span: Span,
         node_id: NodeId,
         edition: Edition,
diff --git a/compiler/rustc_sanitizers/Cargo.toml b/compiler/rustc_sanitizers/Cargo.toml
index 66488bc96259..900cd4243b13 100644
--- a/compiler/rustc_sanitizers/Cargo.toml
+++ b/compiler/rustc_sanitizers/Cargo.toml
@@ -8,6 +8,7 @@ bitflags = "2.5.0"
 tracing = "0.1"
 twox-hash = "1.6.3"
 rustc_abi = { path = "../rustc_abi" }
+rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hir = { path = "../rustc_hir" }
 rustc_middle = { path = "../rustc_middle" }
diff --git a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
index 5f0c1afdf642..e088417d72e3 100644
--- a/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
+++ b/compiler/rustc_sanitizers/src/cfi/typeid/itanium_cxx_abi/encode.rs
@@ -468,7 +468,7 @@ pub(crate) fn encode_ty<'tcx>(
                         )]
                         tcx.dcx()
                             .struct_span_err(
-                                cfi_encoding.span,
+                                cfi_encoding.span(),
                                 format!("invalid `cfi_encoding` for `{:?}`", ty.kind()),
                             )
                             .emit();
@@ -519,7 +519,7 @@ pub(crate) fn encode_ty<'tcx>(
                         )]
                         tcx.dcx()
                             .struct_span_err(
-                                cfi_encoding.span,
+                                cfi_encoding.span(),
                                 format!("invalid `cfi_encoding` for `{:?}`", ty.kind()),
                             )
                             .emit();
diff --git a/compiler/rustc_session/src/config.rs b/compiler/rustc_session/src/config.rs
index 8f0b17b5e887..7586c5766b58 100644
--- a/compiler/rustc_session/src/config.rs
+++ b/compiler/rustc_session/src/config.rs
@@ -539,7 +539,10 @@ impl FromStr for SplitDwarfKind {
 #[derive(Clone, Copy, PartialEq, Eq, Hash, Debug, PartialOrd, Ord, HashStable_Generic)]
 #[derive(Encodable, Decodable)]
 pub enum OutputType {
+    /// This is the optimized bitcode, which could be either pre-LTO or non-LTO bitcode,
+    /// depending on the specific request type.
     Bitcode,
+    /// This is the summary or index data part of the ThinLTO bitcode.
     ThinLinkBitcode,
     Assembly,
     LlvmAssembly,
@@ -2807,8 +2810,8 @@ impl fmt::Display for CrateType {
 }
 
 impl IntoDiagArg for CrateType {
-    fn into_diag_arg(self) -> DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> DiagArgValue {
+        self.to_string().into_diag_arg(&mut None)
     }
 }
 
diff --git a/compiler/rustc_session/src/session.rs b/compiler/rustc_session/src/session.rs
index 8e5ff1d3bc48..ecdf76d22fb2 100644
--- a/compiler/rustc_session/src/session.rs
+++ b/compiler/rustc_session/src/session.rs
@@ -109,8 +109,8 @@ impl Mul<usize> for Limit {
 }
 
 impl rustc_errors::IntoDiagArg for Limit {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
-        self.to_string().into_diag_arg()
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
+        self.to_string().into_diag_arg(&mut None)
     }
 }
 
diff --git a/compiler/rustc_smir/src/rustc_smir/context.rs b/compiler/rustc_smir/src/rustc_smir/context.rs
index 71e7b9c04ca1..acd3b7583510 100644
--- a/compiler/rustc_smir/src/rustc_smir/context.rs
+++ b/compiler/rustc_smir/src/rustc_smir/context.rs
@@ -9,7 +9,7 @@ use std::cell::RefCell;
 use std::iter;
 
 use rustc_abi::HasDataLayout;
-use rustc_hir::LangItem;
+use rustc_hir::{Attribute, LangItem};
 use rustc_middle::ty::layout::{
     FnAbiOf, FnAbiOfHelpers, HasTyCtxt, HasTypingEnv, LayoutOf, LayoutOfHelpers,
 };
@@ -243,7 +243,7 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
         }
     }
 
-    fn get_attrs_by_path(
+    fn tool_attrs(
         &self,
         def_id: stable_mir::DefId,
         attr: &[stable_mir::Symbol],
@@ -253,30 +253,40 @@ impl<'tcx> Context for TablesWrapper<'tcx> {
         let did = tables[def_id];
         let attr_name: Vec<_> = attr.iter().map(|seg| rustc_span::Symbol::intern(&seg)).collect();
         tcx.get_attrs_by_path(did, &attr_name)
-            .map(|attribute| {
-                let attr_str = rustc_hir_pretty::attribute_to_string(&tcx, attribute);
-                let span = attribute.span;
-                stable_mir::crate_def::Attribute::new(attr_str, span.stable(&mut *tables))
+            .filter_map(|attribute| {
+                if let Attribute::Unparsed(u) = attribute {
+                    let attr_str = rustc_hir_pretty::attribute_to_string(&tcx, attribute);
+                    Some(stable_mir::crate_def::Attribute::new(
+                        attr_str,
+                        u.span.stable(&mut *tables),
+                    ))
+                } else {
+                    None
+                }
             })
             .collect()
     }
 
-    fn get_all_attrs(&self, def_id: stable_mir::DefId) -> Vec<stable_mir::crate_def::Attribute> {
+    fn all_tool_attrs(&self, def_id: stable_mir::DefId) -> Vec<stable_mir::crate_def::Attribute> {
         let mut tables = self.0.borrow_mut();
         let tcx = tables.tcx;
         let did = tables[def_id];
-        let filter_fn =
-            move |a: &&rustc_hir::Attribute| matches!(a.kind, rustc_hir::AttrKind::Normal(_));
         let attrs_iter = if let Some(did) = did.as_local() {
-            tcx.hir().attrs(tcx.local_def_id_to_hir_id(did)).iter().filter(filter_fn)
+            tcx.hir().attrs(tcx.local_def_id_to_hir_id(did)).iter()
         } else {
-            tcx.attrs_for_def(did).iter().filter(filter_fn)
+            tcx.attrs_for_def(did).iter()
         };
         attrs_iter
-            .map(|attribute| {
-                let attr_str = rustc_hir_pretty::attribute_to_string(&tcx, attribute);
-                let span = attribute.span;
-                stable_mir::crate_def::Attribute::new(attr_str, span.stable(&mut *tables))
+            .filter_map(|attribute| {
+                if let Attribute::Unparsed(u) = attribute {
+                    let attr_str = rustc_hir_pretty::attribute_to_string(&tcx, attribute);
+                    Some(stable_mir::crate_def::Attribute::new(
+                        attr_str,
+                        u.span.stable(&mut *tables),
+                    ))
+                } else {
+                    None
+                }
             })
             .collect()
     }
diff --git a/compiler/rustc_smir/src/rustc_smir/convert/abi.rs b/compiler/rustc_smir/src/rustc_smir/convert/abi.rs
index a627e0e69b62..62cbab9b723c 100644
--- a/compiler/rustc_smir/src/rustc_smir/convert/abi.rs
+++ b/compiler/rustc_smir/src/rustc_smir/convert/abi.rs
@@ -206,7 +206,7 @@ impl<'tcx> Stable<'tcx> for rustc_abi::BackendRepr {
             rustc_abi::BackendRepr::ScalarPair(first, second) => {
                 ValueAbi::ScalarPair(first.stable(tables), second.stable(tables))
             }
-            rustc_abi::BackendRepr::Vector { element, count } => {
+            rustc_abi::BackendRepr::SimdVector { element, count } => {
                 ValueAbi::Vector { element: element.stable(tables), count }
             }
             rustc_abi::BackendRepr::Memory { sized } => ValueAbi::Aggregate { sized },
diff --git a/compiler/rustc_span/src/analyze_source_file.rs b/compiler/rustc_span/src/analyze_source_file.rs
index a39bb884faad..141d261b5f01 100644
--- a/compiler/rustc_span/src/analyze_source_file.rs
+++ b/compiler/rustc_span/src/analyze_source_file.rs
@@ -68,9 +68,7 @@ cfg_match! {
 
             const CHUNK_SIZE: usize = 16;
 
-            let src_bytes = src.as_bytes();
-
-            let chunk_count = src.len() / CHUNK_SIZE;
+            let (chunks, tail) = src.as_bytes().as_chunks::<CHUNK_SIZE>();
 
             // This variable keeps track of where we should start decoding a
             // chunk. If a multi-byte character spans across chunk boundaries,
@@ -78,11 +76,10 @@ cfg_match! {
             // handled it.
             let mut intra_chunk_offset = 0;
 
-            for chunk_index in 0..chunk_count {
-                let ptr = src_bytes.as_ptr() as *const __m128i;
+            for (chunk_index, chunk) in chunks.iter().enumerate() {
                 // We don't know if the pointer is aligned to 16 bytes, so we
                 // use `loadu`, which supports unaligned loading.
-                let chunk = unsafe { _mm_loadu_si128(ptr.add(chunk_index)) };
+                let chunk = unsafe { _mm_loadu_si128(chunk.as_ptr() as *const __m128i) };
 
                 // For character in the chunk, see if its byte value is < 0, which
                 // indicates that it's part of a UTF-8 char.
@@ -123,7 +120,7 @@ cfg_match! {
             }
 
             // There might still be a tail left to analyze
-            let tail_start = chunk_count * CHUNK_SIZE + intra_chunk_offset;
+            let tail_start = src.len() - tail.len() + intra_chunk_offset;
             if tail_start < src.len() {
                 analyze_source_file_generic(
                     &src[tail_start..],
diff --git a/compiler/rustc_span/src/hygiene.rs b/compiler/rustc_span/src/hygiene.rs
index 9bf1d305e541..84e89ff4b7da 100644
--- a/compiler/rustc_span/src/hygiene.rs
+++ b/compiler/rustc_span/src/hygiene.rs
@@ -175,6 +175,12 @@ pub enum Transparency {
     Opaque,
 }
 
+impl Transparency {
+    pub fn fallback(macro_rules: bool) -> Self {
+        if macro_rules { Transparency::SemiTransparent } else { Transparency::Opaque }
+    }
+}
+
 impl LocalExpnId {
     /// The ID of the theoretical expansion that generates freshly parsed, unexpanded AST.
     pub const ROOT: LocalExpnId = LocalExpnId::ZERO;
diff --git a/compiler/rustc_span/src/lib.rs b/compiler/rustc_span/src/lib.rs
index c09669d959c9..bca9323a50d4 100644
--- a/compiler/rustc_span/src/lib.rs
+++ b/compiler/rustc_span/src/lib.rs
@@ -31,6 +31,7 @@
 #![feature(round_char_boundary)]
 #![feature(rustc_attrs)]
 #![feature(rustdoc_internals)]
+#![feature(slice_as_chunks)]
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
 
diff --git a/compiler/rustc_span/src/symbol.rs b/compiler/rustc_span/src/symbol.rs
index 10c79b1be82d..2a709b072557 100644
--- a/compiler/rustc_span/src/symbol.rs
+++ b/compiler/rustc_span/src/symbol.rs
@@ -1037,6 +1037,7 @@ symbols! {
         generic_associated_types_extended,
         generic_const_exprs,
         generic_const_items,
+        generic_const_parameter_types,
         generic_param_attrs,
         generic_pattern_types,
         get_context,
@@ -1764,7 +1765,6 @@ symbols! {
         rustc_insignificant_dtor,
         rustc_intrinsic,
         rustc_intrinsic_const_stable_indirect,
-        rustc_intrinsic_must_be_overridden,
         rustc_layout,
         rustc_layout_scalar_valid_range_end,
         rustc_layout_scalar_valid_range_start,
@@ -1878,8 +1878,6 @@ symbols! {
         simd_fma,
         simd_fmax,
         simd_fmin,
-        simd_fpow,
-        simd_fpowi,
         simd_fsin,
         simd_fsqrt,
         simd_gather,
@@ -1916,7 +1914,7 @@ symbols! {
         simd_shl,
         simd_shr,
         simd_shuffle,
-        simd_shuffle_generic,
+        simd_shuffle_const_generic,
         simd_sub,
         simd_trunc,
         simd_with_exposed_provenance,
diff --git a/compiler/rustc_symbol_mangling/Cargo.toml b/compiler/rustc_symbol_mangling/Cargo.toml
index 12fe6b719f9b..90ddf4c8a040 100644
--- a/compiler/rustc_symbol_mangling/Cargo.toml
+++ b/compiler/rustc_symbol_mangling/Cargo.toml
@@ -9,6 +9,7 @@ punycode = "0.4.0"
 rustc-demangle = "0.1.21"
 
 rustc_abi = { path = "../rustc_abi" }
+rustc_ast = { path = "../rustc_ast" }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_errors = { path = "../rustc_errors" }
 rustc_hashes = { path = "../rustc_hashes" }
diff --git a/compiler/rustc_symbol_mangling/src/test.rs b/compiler/rustc_symbol_mangling/src/test.rs
index 7fda81126c44..ddeeadff13d1 100644
--- a/compiler/rustc_symbol_mangling/src/test.rs
+++ b/compiler/rustc_symbol_mangling/src/test.rs
@@ -62,18 +62,18 @@ impl SymbolNamesTest<'_> {
             );
             let mangled = tcx.symbol_name(instance);
             tcx.dcx().emit_err(TestOutput {
-                span: attr.span,
+                span: attr.span(),
                 kind: Kind::SymbolName,
                 content: format!("{mangled}"),
             });
             if let Ok(demangling) = rustc_demangle::try_demangle(mangled.name) {
                 tcx.dcx().emit_err(TestOutput {
-                    span: attr.span,
+                    span: attr.span(),
                     kind: Kind::Demangling,
                     content: format!("{demangling}"),
                 });
                 tcx.dcx().emit_err(TestOutput {
-                    span: attr.span,
+                    span: attr.span(),
                     kind: Kind::DemanglingAlt,
                     content: format!("{demangling:#}"),
                 });
@@ -82,7 +82,7 @@ impl SymbolNamesTest<'_> {
 
         for attr in tcx.get_attrs(def_id, DEF_PATH) {
             tcx.dcx().emit_err(TestOutput {
-                span: attr.span,
+                span: attr.span(),
                 kind: Kind::DefPath,
                 content: with_no_trimmed_paths!(tcx.def_path_str(def_id)),
             });
diff --git a/compiler/rustc_target/src/callconv/loongarch.rs b/compiler/rustc_target/src/callconv/loongarch.rs
index 3fa67c624a7b..209d7483e612 100644
--- a/compiler/rustc_target/src/callconv/loongarch.rs
+++ b/compiler/rustc_target/src/callconv/loongarch.rs
@@ -25,7 +25,7 @@ struct CannotUseFpConv;
 
 fn is_loongarch_aggregate<Ty>(arg: &ArgAbi<'_, Ty>) -> bool {
     match arg.layout.backend_repr {
-        BackendRepr::Vector { .. } => true,
+        BackendRepr::SimdVector { .. } => true,
         _ => arg.layout.is_aggregate(),
     }
 }
@@ -80,7 +80,7 @@ where
                 }
             }
         },
-        BackendRepr::Vector { .. } => return Err(CannotUseFpConv),
+        BackendRepr::SimdVector { .. } => return Err(CannotUseFpConv),
         BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => match arg_layout.fields {
             FieldsShape::Primitive => {
                 unreachable!("aggregates can't have `FieldsShape::Primitive`")
diff --git a/compiler/rustc_target/src/callconv/mod.rs b/compiler/rustc_target/src/callconv/mod.rs
index 1c044fe98b3e..198d08864bec 100644
--- a/compiler/rustc_target/src/callconv/mod.rs
+++ b/compiler/rustc_target/src/callconv/mod.rs
@@ -357,7 +357,7 @@ impl<'a, Ty> ArgAbi<'a, Ty> {
                 scalar_attrs(&layout, a, Size::ZERO),
                 scalar_attrs(&layout, b, a.size(cx).align_to(b.align(cx).abi)),
             ),
-            BackendRepr::Vector { .. } => PassMode::Direct(ArgAttributes::new()),
+            BackendRepr::SimdVector { .. } => PassMode::Direct(ArgAttributes::new()),
             BackendRepr::Memory { .. } => Self::indirect_pass_mode(&layout),
         };
         ArgAbi { layout, mode }
@@ -759,7 +759,7 @@ impl<'a, Ty> FnAbi<'a, Ty> {
 
             if arg_idx.is_none()
                 && arg.layout.size > Primitive::Pointer(AddressSpace::DATA).size(cx) * 2
-                && !matches!(arg.layout.backend_repr, BackendRepr::Vector { .. })
+                && !matches!(arg.layout.backend_repr, BackendRepr::SimdVector { .. })
             {
                 // Return values larger than 2 registers using a return area
                 // pointer. LLVM and Cranelift disagree about how to return
@@ -826,7 +826,7 @@ impl<'a, Ty> FnAbi<'a, Ty> {
                     }
                 }
 
-                BackendRepr::Vector { .. } => {
+                BackendRepr::SimdVector { .. } => {
                     // This is a fun case! The gist of what this is doing is
                     // that we want callers and callees to always agree on the
                     // ABI of how they pass SIMD arguments. If we were to *not*
diff --git a/compiler/rustc_target/src/callconv/riscv.rs b/compiler/rustc_target/src/callconv/riscv.rs
index 785175229b03..7368e225efa7 100644
--- a/compiler/rustc_target/src/callconv/riscv.rs
+++ b/compiler/rustc_target/src/callconv/riscv.rs
@@ -31,7 +31,7 @@ struct CannotUseFpConv;
 
 fn is_riscv_aggregate<Ty>(arg: &ArgAbi<'_, Ty>) -> bool {
     match arg.layout.backend_repr {
-        BackendRepr::Vector { .. } => true,
+        BackendRepr::SimdVector { .. } => true,
         _ => arg.layout.is_aggregate(),
     }
 }
@@ -86,7 +86,7 @@ where
                 }
             }
         },
-        BackendRepr::Vector { .. } => return Err(CannotUseFpConv),
+        BackendRepr::SimdVector { .. } => return Err(CannotUseFpConv),
         BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => match arg_layout.fields {
             FieldsShape::Primitive => {
                 unreachable!("aggregates can't have `FieldsShape::Primitive`")
diff --git a/compiler/rustc_target/src/callconv/s390x.rs b/compiler/rustc_target/src/callconv/s390x.rs
index 4f69e32b2e3d..1ba792c5acc5 100644
--- a/compiler/rustc_target/src/callconv/s390x.rs
+++ b/compiler/rustc_target/src/callconv/s390x.rs
@@ -8,7 +8,7 @@ use crate::spec::HasTargetSpec;
 
 fn classify_ret<Ty>(ret: &mut ArgAbi<'_, Ty>) {
     let size = ret.layout.size;
-    if size.bits() <= 128 && matches!(ret.layout.backend_repr, BackendRepr::Vector { .. }) {
+    if size.bits() <= 128 && matches!(ret.layout.backend_repr, BackendRepr::SimdVector { .. }) {
         return;
     }
     if !ret.layout.is_aggregate() && size.bits() <= 64 {
@@ -40,7 +40,7 @@ where
 
     let size = arg.layout.size;
     if size.bits() <= 128 {
-        if let BackendRepr::Vector { .. } = arg.layout.backend_repr {
+        if let BackendRepr::SimdVector { .. } = arg.layout.backend_repr {
             // pass non-wrapped vector types using `PassMode::Direct`
             return;
         }
diff --git a/compiler/rustc_target/src/callconv/x86.rs b/compiler/rustc_target/src/callconv/x86.rs
index 7e5aab0201b6..73aff85a0ad8 100644
--- a/compiler/rustc_target/src/callconv/x86.rs
+++ b/compiler/rustc_target/src/callconv/x86.rs
@@ -109,7 +109,7 @@ where
             {
                 match layout.backend_repr {
                     BackendRepr::Scalar(_) | BackendRepr::ScalarPair(..) => false,
-                    BackendRepr::Vector { .. } => true,
+                    BackendRepr::SimdVector { .. } => true,
                     BackendRepr::Memory { .. } => {
                         for i in 0..layout.fields.count() {
                             if contains_vector(cx, layout.field(cx, i)) {
diff --git a/compiler/rustc_target/src/callconv/x86_64.rs b/compiler/rustc_target/src/callconv/x86_64.rs
index ab306e202396..300b19f62e72 100644
--- a/compiler/rustc_target/src/callconv/x86_64.rs
+++ b/compiler/rustc_target/src/callconv/x86_64.rs
@@ -56,7 +56,7 @@ where
                 Primitive::Float(_) => Class::Sse,
             },
 
-            BackendRepr::Vector { .. } => Class::Sse,
+            BackendRepr::SimdVector { .. } => Class::Sse,
 
             BackendRepr::ScalarPair(..) | BackendRepr::Memory { .. } => {
                 for i in 0..layout.fields.count() {
diff --git a/compiler/rustc_target/src/callconv/x86_win64.rs b/compiler/rustc_target/src/callconv/x86_win64.rs
index 4d99a9f9ba06..8f8597ea662a 100644
--- a/compiler/rustc_target/src/callconv/x86_win64.rs
+++ b/compiler/rustc_target/src/callconv/x86_win64.rs
@@ -18,7 +18,7 @@ pub(crate) fn compute_abi_info<Ty>(cx: &impl HasTargetSpec, fn_abi: &mut FnAbi<'
                     _ => a.make_indirect(),
                 }
             }
-            BackendRepr::Vector { .. } => {
+            BackendRepr::SimdVector { .. } => {
                 // FIXME(eddyb) there should be a size cap here
                 // (probably what clang calls "illegal vectors").
             }
diff --git a/compiler/rustc_target/src/callconv/xtensa.rs b/compiler/rustc_target/src/callconv/xtensa.rs
index 6c030cb3bf77..b687f0e20c66 100644
--- a/compiler/rustc_target/src/callconv/xtensa.rs
+++ b/compiler/rustc_target/src/callconv/xtensa.rs
@@ -116,7 +116,7 @@ where
 
 fn is_xtensa_aggregate<'a, Ty>(arg: &ArgAbi<'a, Ty>) -> bool {
     match arg.layout.backend_repr {
-        BackendRepr::Vector { .. } => true,
+        BackendRepr::SimdVector { .. } => true,
         _ => arg.layout.is_aggregate(),
     }
 }
diff --git a/compiler/rustc_target/src/spec/mod.rs b/compiler/rustc_target/src/spec/mod.rs
index 761d2848a059..cc8162a2f27e 100644
--- a/compiler/rustc_target/src/spec/mod.rs
+++ b/compiler/rustc_target/src/spec/mod.rs
@@ -2914,20 +2914,35 @@ impl Target {
             // On Windows, `extern "system"` behaves like msvc's `__stdcall`.
             // `__stdcall` only applies on x86 and on non-variadic functions:
             // https://learn.microsoft.com/en-us/cpp/cpp/stdcall?view=msvc-170
-            System { unwind } if self.is_like_windows && self.arch == "x86" && !c_variadic => {
-                Stdcall { unwind }
+            System { unwind } => {
+                if self.is_like_windows && self.arch == "x86" && !c_variadic {
+                    Stdcall { unwind }
+                } else {
+                    C { unwind }
+                }
+            }
+
+            EfiApi => {
+                if self.arch == "arm" {
+                    Aapcs { unwind: false }
+                } else if self.arch == "x86_64" {
+                    Win64 { unwind: false }
+                } else {
+                    C { unwind: false }
+                }
             }
-            System { unwind } => C { unwind },
-            EfiApi if self.arch == "arm" => Aapcs { unwind: false },
-            EfiApi if self.arch == "x86_64" => Win64 { unwind: false },
-            EfiApi => C { unwind: false },
 
             // See commentary in `is_abi_supported`.
-            Stdcall { .. } | Thiscall { .. } if self.arch == "x86" => abi,
-            Stdcall { unwind } | Thiscall { unwind } => C { unwind },
-            Fastcall { .. } if self.arch == "x86" => abi,
-            Vectorcall { .. } if ["x86", "x86_64"].contains(&&self.arch[..]) => abi,
-            Fastcall { unwind } | Vectorcall { unwind } => C { unwind },
+            Stdcall { unwind } | Thiscall { unwind } | Fastcall { unwind } => {
+                if self.arch == "x86" { abi } else { C { unwind } }
+            }
+            Vectorcall { unwind } => {
+                if ["x86", "x86_64"].contains(&&*self.arch) {
+                    abi
+                } else {
+                    C { unwind }
+                }
+            }
 
             // The Windows x64 calling convention we use for `extern "Rust"`
             // <https://learn.microsoft.com/en-us/cpp/build/x64-software-conventions#register-volatility-and-preservation>
diff --git a/compiler/rustc_target/src/target_features.rs b/compiler/rustc_target/src/target_features.rs
index b98bca60c9de..65a85151befa 100644
--- a/compiler/rustc_target/src/target_features.rs
+++ b/compiler/rustc_target/src/target_features.rs
@@ -497,9 +497,14 @@ static RISCV_FEATURES: &[(&str, Stability, ImpliedFeatures)] = &[
     ("relax", Unstable(sym::riscv_target_feature), &[]),
     ("unaligned-scalar-mem", Unstable(sym::riscv_target_feature), &[]),
     ("v", Unstable(sym::riscv_target_feature), &[]),
+    ("za128rs", Unstable(sym::riscv_target_feature), &[]),
+    ("za64rs", Unstable(sym::riscv_target_feature), &[]),
     ("zaamo", Unstable(sym::riscv_target_feature), &[]),
     ("zabha", Unstable(sym::riscv_target_feature), &["zaamo"]),
+    ("zacas", Unstable(sym::riscv_target_feature), &["zaamo"]),
     ("zalrsc", Unstable(sym::riscv_target_feature), &[]),
+    ("zama16b", Unstable(sym::riscv_target_feature), &[]),
+    ("zawrs", Unstable(sym::riscv_target_feature), &[]),
     ("zba", Stable, &[]),
     ("zbb", Stable, &[]),
     ("zbc", Stable, &[]),
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
index a618bae269fa..847bd06bb017 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/mod.rs
@@ -2418,7 +2418,7 @@ impl<'tcx> ObligationCause<'tcx> {
 pub struct ObligationCauseAsDiagArg<'tcx>(pub ObligationCause<'tcx>);
 
 impl IntoDiagArg for ObligationCauseAsDiagArg<'_> {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         let kind = match self.0.code() {
             ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Fn, .. } => "method_compat",
             ObligationCauseCode::CompareImplItem { kind: ty::AssocKind::Type, .. } => "type_compat",
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
index bed9734f389c..a6d8eb6add7d 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/need_type_info.rs
@@ -137,7 +137,7 @@ impl InferenceDiagnosticsParentData {
 }
 
 impl IntoDiagArg for UnderspecifiedArgKind {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         let kind = match self {
             Self::Type { .. } => "type",
             Self::Const { is_parameter: true } => "const_with_param",
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs
index aaaefd81d19b..5056161e117e 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/nice_region_error/placeholder_error.rs
@@ -31,7 +31,7 @@ impl<'tcx, T> IntoDiagArg for Highlighted<'tcx, T>
 where
     T: for<'a> Print<'tcx, FmtPrinter<'a, 'tcx>>,
 {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         rustc_errors::DiagArgValue::Str(self.to_string().into())
     }
 }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
index 36726cc6cae0..514615735a50 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/infer/note_and_explain.rs
@@ -522,7 +522,8 @@ impl<T> Trait<T> for X {
                 }
             }
             TypeError::TargetFeatureCast(def_id) => {
-                let target_spans = tcx.get_attrs(def_id, sym::target_feature).map(|attr| attr.span);
+                let target_spans =
+                    tcx.get_attrs(def_id, sym::target_feature).map(|attr| attr.span());
                 diag.note(
                     "functions with `#[target_feature]` can only be coerced to `unsafe` function pointers"
                 );
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
index 596f794568c5..d270b4cf96ba 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/fulfillment_errors.rs
@@ -1189,9 +1189,6 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         let span = obligation.cause.span;
 
         let mut diag = match ty.kind() {
-            _ if ty.has_param() => {
-                span_bug!(span, "const param tys cannot mention other generic parameters");
-            }
             ty::Float(_) => {
                 struct_span_code_err!(
                     self.dcx(),
@@ -2419,6 +2416,12 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 &mut vec![],
                 &mut Default::default(),
             );
+            self.suggest_swapping_lhs_and_rhs(
+                err,
+                obligation.predicate,
+                obligation.param_env,
+                obligation.cause.code(),
+            );
             self.suggest_unsized_bound_if_applicable(err, obligation);
             if let Some(span) = err.span.primary_span()
                 && let Some(mut diag) =
@@ -2530,9 +2533,7 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
                 return GetSafeTransmuteErrorAndReason::Silent;
             };
 
-            let Some(assume) =
-                rustc_transmute::Assume::from_const(self.infcx.tcx, obligation.param_env, assume)
-            else {
+            let Some(assume) = rustc_transmute::Assume::from_const(self.infcx.tcx, assume) else {
                 self.dcx().span_delayed_bug(
                     span,
                     "Unable to construct rustc_transmute::Assume where it was previously possible",
@@ -2544,11 +2545,9 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
             let src = trait_pred.trait_ref.args.type_at(1);
             let err_msg = format!("`{src}` cannot be safely transmuted into `{dst}`");
 
-            match rustc_transmute::TransmuteTypeEnv::new(self.infcx).is_transmutable(
-                obligation.cause,
-                src_and_dst,
-                assume,
-            ) {
+            match rustc_transmute::TransmuteTypeEnv::new(self.infcx.tcx)
+                .is_transmutable(src_and_dst, assume)
+            {
                 Answer::No(reason) => {
                     let safe_transmute_explanation = match reason {
                         rustc_transmute::Reason::SrcIsNotYetSupported => {
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
index 518323f6526a..f0c6e51f2a4c 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/on_unimplemented.rs
@@ -6,7 +6,7 @@ use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::codes::*;
 use rustc_errors::{ErrorGuaranteed, struct_span_code_err};
 use rustc_hir::def_id::{DefId, LocalDefId};
-use rustc_hir::{AttrArgs, AttrKind, Attribute};
+use rustc_hir::{AttrArgs, Attribute};
 use rustc_macros::LintDiagnostic;
 use rustc_middle::bug;
 use rustc_middle::ty::print::PrintTraitRefExt as _;
@@ -622,7 +622,14 @@ impl<'tcx> OnUnimplementedDirective {
         item_def_id: DefId,
     ) -> Result<Option<Self>, ErrorGuaranteed> {
         let result = if let Some(items) = attr.meta_item_list() {
-            Self::parse(tcx, item_def_id, &items, attr.span, true, is_diagnostic_namespace_variant)
+            Self::parse(
+                tcx,
+                item_def_id,
+                &items,
+                attr.span(),
+                true,
+                is_diagnostic_namespace_variant,
+            )
         } else if let Some(value) = attr.value_str() {
             if !is_diagnostic_namespace_variant {
                 Ok(Some(OnUnimplementedDirective {
@@ -633,7 +640,7 @@ impl<'tcx> OnUnimplementedDirective {
                         tcx,
                         item_def_id,
                         value,
-                        attr.span,
+                        attr.span(),
                         is_diagnostic_namespace_variant,
                     )?),
                     notes: Vec::new(),
@@ -659,14 +666,14 @@ impl<'tcx> OnUnimplementedDirective {
                 Ok(None)
             }
         } else if is_diagnostic_namespace_variant {
-            match &attr.kind {
-                AttrKind::Normal(p) if !matches!(p.args, AttrArgs::Empty) => {
+            match attr {
+                Attribute::Unparsed(p) if !matches!(p.args, AttrArgs::Empty) => {
                     if let Some(item_def_id) = item_def_id.as_local() {
                         tcx.emit_node_span_lint(
                             UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                             tcx.local_def_id_to_hir_id(item_def_id),
-                            attr.span,
-                            MalformedOnUnimplementedAttrLint::new(attr.span),
+                            attr.span(),
+                            MalformedOnUnimplementedAttrLint::new(attr.span()),
                         );
                     }
                 }
@@ -675,7 +682,7 @@ impl<'tcx> OnUnimplementedDirective {
                         tcx.emit_node_span_lint(
                             UNKNOWN_OR_MALFORMED_DIAGNOSTIC_ATTRIBUTES,
                             tcx.local_def_id_to_hir_id(item_def_id),
-                            attr.span,
+                            attr.span(),
                             MissingOptionsForOnUnimplementedAttr,
                         )
                     }
diff --git a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
index c7e71a626dc5..b85c18c53121 100644
--- a/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
+++ b/compiler/rustc_trait_selection/src/error_reporting/traits/suggestions.rs
@@ -136,7 +136,10 @@ pub fn suggest_restriction<'tcx, G: EmissionGuarantee>(
 ) {
     if hir_generics.where_clause_span.from_expansion()
         || hir_generics.where_clause_span.desugaring_kind().is_some()
-        || projection.is_some_and(|projection| tcx.is_impl_trait_in_trait(projection.def_id))
+        || projection.is_some_and(|projection| {
+            tcx.is_impl_trait_in_trait(projection.def_id)
+                || tcx.lookup_stability(projection.def_id).is_some_and(|stab| stab.is_unstable())
+        })
     {
         return;
     }
@@ -4911,6 +4914,53 @@ impl<'a, 'tcx> TypeErrCtxt<'a, 'tcx> {
         );
         true
     }
+    pub(crate) fn suggest_swapping_lhs_and_rhs<T>(
+        &self,
+        err: &mut Diag<'_>,
+        predicate: T,
+        param_env: ty::ParamEnv<'tcx>,
+        cause_code: &ObligationCauseCode<'tcx>,
+    ) where
+        T: Upcast<TyCtxt<'tcx>, ty::Predicate<'tcx>>,
+    {
+        let tcx = self.tcx;
+        let predicate = predicate.upcast(tcx);
+        match *cause_code {
+            ObligationCauseCode::BinOp {
+                lhs_hir_id,
+                rhs_hir_id: Some(rhs_hir_id),
+                rhs_span: Some(rhs_span),
+                ..
+            } if let Some(typeck_results) = &self.typeck_results
+                && let hir::Node::Expr(lhs) = tcx.hir_node(lhs_hir_id)
+                && let hir::Node::Expr(rhs) = tcx.hir_node(rhs_hir_id)
+                && let Some(lhs_ty) = typeck_results.expr_ty_opt(lhs)
+                && let Some(rhs_ty) = typeck_results.expr_ty_opt(rhs) =>
+            {
+                if let Some(pred) = predicate.as_trait_clause()
+                    && tcx.is_lang_item(pred.def_id(), LangItem::PartialEq)
+                    && self
+                        .infcx
+                        .type_implements_trait(pred.def_id(), [rhs_ty, lhs_ty], param_env)
+                        .must_apply_modulo_regions()
+                {
+                    let lhs_span = tcx.hir().span(lhs_hir_id);
+                    let sm = tcx.sess.source_map();
+                    if let Ok(rhs_snippet) = sm.span_to_snippet(rhs_span)
+                        && let Ok(lhs_snippet) = sm.span_to_snippet(lhs_span)
+                    {
+                        err.note(format!("`{rhs_ty}` implements `PartialEq<{lhs_ty}>`"));
+                        err.multipart_suggestion(
+                            "consider swapping the equality",
+                            vec![(lhs_span, rhs_snippet), (rhs_span, lhs_snippet)],
+                            Applicability::MaybeIncorrect,
+                        );
+                    }
+                }
+            }
+            _ => {}
+        }
+    }
 }
 
 /// Add a hint to add a missing borrow or remove an unnecessary one.
diff --git a/compiler/rustc_trait_selection/src/errors.rs b/compiler/rustc_trait_selection/src/errors.rs
index 23aa38006604..fe859eb53cd7 100644
--- a/compiler/rustc_trait_selection/src/errors.rs
+++ b/compiler/rustc_trait_selection/src/errors.rs
@@ -784,10 +784,10 @@ pub enum TyOrSig<'tcx> {
 }
 
 impl IntoDiagArg for TyOrSig<'_> {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, path: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         match self {
-            TyOrSig::Ty(ty) => ty.into_diag_arg(),
-            TyOrSig::ClosureSig(sig) => sig.into_diag_arg(),
+            TyOrSig::Ty(ty) => ty.into_diag_arg(path),
+            TyOrSig::ClosureSig(sig) => sig.into_diag_arg(path),
         }
     }
 }
diff --git a/compiler/rustc_trait_selection/src/errors/note_and_explain.rs b/compiler/rustc_trait_selection/src/errors/note_and_explain.rs
index 4601ddf678a0..46622246a178 100644
--- a/compiler/rustc_trait_selection/src/errors/note_and_explain.rs
+++ b/compiler/rustc_trait_selection/src/errors/note_and_explain.rs
@@ -105,7 +105,7 @@ pub enum SuffixKind {
 }
 
 impl IntoDiagArg for PrefixKind {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         let kind = match self {
             Self::Empty => "empty",
             Self::RefValidFor => "ref_valid_for",
@@ -127,7 +127,7 @@ impl IntoDiagArg for PrefixKind {
 }
 
 impl IntoDiagArg for SuffixKind {
-    fn into_diag_arg(self) -> rustc_errors::DiagArgValue {
+    fn into_diag_arg(self, _: &mut Option<std::path::PathBuf>) -> rustc_errors::DiagArgValue {
         let kind = match self {
             Self::Empty => "empty",
             Self::Continues => "continues",
diff --git a/compiler/rustc_trait_selection/src/lib.rs b/compiler/rustc_trait_selection/src/lib.rs
index 1af383e9200d..b235d0da83cc 100644
--- a/compiler/rustc_trait_selection/src/lib.rs
+++ b/compiler/rustc_trait_selection/src/lib.rs
@@ -20,7 +20,6 @@
 #![feature(associated_type_defaults)]
 #![feature(box_patterns)]
 #![feature(cfg_version)]
-#![feature(extract_if)]
 #![feature(if_let_guard)]
 #![feature(iter_intersperse)]
 #![feature(iterator_try_reduce)]
diff --git a/compiler/rustc_trait_selection/src/solve/delegate.rs b/compiler/rustc_trait_selection/src/solve/delegate.rs
index 58d8a3a62547..e69bad095e33 100644
--- a/compiler/rustc_trait_selection/src/solve/delegate.rs
+++ b/compiler/rustc_trait_selection/src/solve/delegate.rs
@@ -7,7 +7,6 @@ use rustc_infer::infer::canonical::{
     Canonical, CanonicalExt as _, CanonicalQueryInput, CanonicalVarInfo, CanonicalVarValues,
 };
 use rustc_infer::infer::{InferCtxt, RegionVariableOrigin, TyCtxtInferExt};
-use rustc_infer::traits::ObligationCause;
 use rustc_infer::traits::solve::Goal;
 use rustc_middle::ty::fold::TypeFoldable;
 use rustc_middle::ty::{self, Ty, TyCtxt, TypeVisitableExt as _};
@@ -222,7 +221,6 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
     // register candidates. We probably need to register >1 since we may have an OR of ANDs.
     fn is_transmutable(
         &self,
-        param_env: ty::ParamEnv<'tcx>,
         dst: Ty<'tcx>,
         src: Ty<'tcx>,
         assume: ty::Const<'tcx>,
@@ -231,16 +229,14 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         // which will ICE for region vars.
         let (dst, src) = self.tcx.erase_regions((dst, src));
 
-        let Some(assume) = rustc_transmute::Assume::from_const(self.tcx, param_env, assume) else {
+        let Some(assume) = rustc_transmute::Assume::from_const(self.tcx, assume) else {
             return Err(NoSolution);
         };
 
         // FIXME(transmutability): This really should be returning nested goals for `Answer::If*`
-        match rustc_transmute::TransmuteTypeEnv::new(&self.0).is_transmutable(
-            ObligationCause::dummy(),
-            rustc_transmute::Types { src, dst },
-            assume,
-        ) {
+        match rustc_transmute::TransmuteTypeEnv::new(self.0.tcx)
+            .is_transmutable(rustc_transmute::Types { src, dst }, assume)
+        {
             rustc_transmute::Answer::Yes => Ok(Certainty::Yes),
             rustc_transmute::Answer::No(_) | rustc_transmute::Answer::If(_) => Err(NoSolution),
         }
diff --git a/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs b/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
index 982782bc57c1..4f177df89e23 100644
--- a/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
+++ b/compiler/rustc_trait_selection/src/solve/fulfill/derive_errors.rs
@@ -438,7 +438,10 @@ impl<'tcx> ProofTreeVisitor<'tcx> for BestObligation<'tcx> {
 
             let obligation;
             match (child_mode, nested_goal.source()) {
-                (ChildMode::Trait(_) | ChildMode::Host(_), GoalSource::Misc) => {
+                (
+                    ChildMode::Trait(_) | ChildMode::Host(_),
+                    GoalSource::Misc | GoalSource::NormalizeGoal(_),
+                ) => {
                     continue;
                 }
                 (ChildMode::Trait(parent_trait_pred), GoalSource::ImplWhereBound) => {
diff --git a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
index 740f44ebcade..d4502be6ccfe 100644
--- a/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
+++ b/compiler/rustc_trait_selection/src/traits/dyn_compatibility.rs
@@ -538,10 +538,10 @@ fn receiver_for_self_ty<'tcx>(
 /// a pointer.
 ///
 /// In practice, we cannot use `dyn Trait` explicitly in the obligation because it would result in
-/// a new check that `Trait` is dyn-compatible, creating a cycle (until dyn_compatible_for_dispatch
-/// is stabilized, see tracking issue <https://github.com/rust-lang/rust/issues/43561>).
-/// Instead, we fudge a little by introducing a new type parameter `U` such that
+/// a new check that `Trait` is dyn-compatible, creating a cycle.
+/// Instead, we emulate a placeholder by introducing a new type parameter `U` such that
 /// `Self: Unsize<U>` and `U: Trait + ?Sized`, and use `U` in place of `dyn Trait`.
+///
 /// Written as a chalk-style query:
 /// ```ignore (not-rust)
 /// forall (U: Trait + ?Sized) {
@@ -572,8 +572,6 @@ fn receiver_is_dispatchable<'tcx>(
 
     // the type `U` in the query
     // use a bogus type parameter to mimic a forall(U) query using u32::MAX for now.
-    // FIXME(mikeyhew) this is a total hack. Once dyn_compatible_for_dispatch is stabilized, we can
-    // replace this with `dyn Trait`
     let unsized_self_ty: Ty<'tcx> =
         Ty::new_param(tcx, u32::MAX, rustc_span::sym::RustaceansAreAwesome);
 
diff --git a/compiler/rustc_trait_selection/src/traits/effects.rs b/compiler/rustc_trait_selection/src/traits/effects.rs
index b32909efe0be..3c127416cbf7 100644
--- a/compiler/rustc_trait_selection/src/traits/effects.rs
+++ b/compiler/rustc_trait_selection/src/traits/effects.rs
@@ -31,6 +31,8 @@ pub fn evaluate_host_effect_obligation<'tcx>(
         );
     }
 
+    let ref obligation = selcx.infcx.resolve_vars_if_possible(obligation.clone());
+
     // Force ambiguity for infer self ty.
     if obligation.predicate.self_ty().is_ty_var() {
         return Err(EvaluationFailure::Ambiguous);
diff --git a/compiler/rustc_trait_selection/src/traits/query/normalize.rs b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
index 2ef9d5421ba6..6bf76eaee5c6 100644
--- a/compiler/rustc_trait_selection/src/traits/query/normalize.rs
+++ b/compiler/rustc_trait_selection/src/traits/query/normalize.rs
@@ -31,20 +31,19 @@ impl<'a, 'tcx> At<'a, 'tcx> {
     /// normalized. If you don't care about regions, you should prefer
     /// `normalize_erasing_regions`, which is more efficient.
     ///
-    /// If the normalization succeeds and is unambiguous, returns back
-    /// the normalized value along with various outlives relations (in
-    /// the form of obligations that must be discharged).
+    /// If the normalization succeeds, returns back the normalized
+    /// value along with various outlives relations (in the form of
+    /// obligations that must be discharged).
     ///
-    /// N.B., this will *eventually* be the main means of
-    /// normalizing, but for now should be used only when we actually
-    /// know that normalization will succeed, since error reporting
-    /// and other details are still "under development".
-    ///
-    /// This normalization should *only* be used when the projection does not
-    /// have possible ambiguity or may not be well-formed.
+    /// This normalization should *only* be used when the projection is well-formed and
+    /// does not have possible ambiguity (contains inference variables).
     ///
     /// After codegen, when lifetimes do not matter, it is preferable to instead
     /// use [`TyCtxt::normalize_erasing_regions`], which wraps this procedure.
+    ///
+    /// N.B. Once the new solver is stabilized this method of normalization will
+    /// likely be removed as trait solver operations are already cached by the query
+    /// system making this redundant.
     fn query_normalize<T>(self, value: T) -> Result<Normalized<'tcx, T>, NoSolution>
     where
         T: TypeFoldable<TyCtxt<'tcx>>,
@@ -210,8 +209,6 @@ impl<'a, 'tcx> FallibleTypeFolder<TyCtxt<'tcx>> for QueryNormalizer<'a, 'tcx> {
 
         // See note in `rustc_trait_selection::traits::project` about why we
         // wait to fold the args.
-
-        // Wrap this in a closure so we don't accidentally return from the outer function
         let res = match kind {
             ty::Opaque => {
                 // Only normalize `impl Trait` outside of type inference, usually in codegen.
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 5b362b2356e8..11b6b826efe5 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -859,13 +859,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                         }
 
                         if let Some(principal) = data.principal() {
-                            if !self.infcx.tcx.features().dyn_compatible_for_dispatch() {
-                                principal.with_self_ty(self.tcx(), self_ty)
-                            } else if self.tcx().is_dyn_compatible(principal.def_id()) {
-                                principal.with_self_ty(self.tcx(), self_ty)
-                            } else {
-                                return;
-                            }
+                            principal.with_self_ty(self.tcx(), self_ty)
                         } else {
                             // Only auto trait bounds exist.
                             return;
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 32cbb97e314d..a58317dd56d2 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -414,9 +414,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         if self.tcx().features().generic_const_exprs() {
             assume = crate::traits::evaluate_const(self.infcx, assume, obligation.param_env)
         }
-        let Some(assume) =
-            rustc_transmute::Assume::from_const(self.infcx.tcx, obligation.param_env, assume)
-        else {
+        let Some(assume) = rustc_transmute::Assume::from_const(self.infcx.tcx, assume) else {
             return Err(Unimplemented);
         };
 
@@ -424,12 +422,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         let src = predicate.trait_ref.args.type_at(1);
 
         debug!(?src, ?dst);
-        let mut transmute_env = rustc_transmute::TransmuteTypeEnv::new(self.infcx);
-        let maybe_transmutable = transmute_env.is_transmutable(
-            obligation.cause.clone(),
-            rustc_transmute::Types { dst, src },
-            assume,
-        );
+        let mut transmute_env = rustc_transmute::TransmuteTypeEnv::new(self.infcx.tcx);
+        let maybe_transmutable =
+            transmute_env.is_transmutable(rustc_transmute::Types { dst, src }, assume);
 
         let fully_flattened = match maybe_transmutable {
             Answer::No(_) => Err(Unimplemented)?,
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 436ce3dddd9f..77dbb43465e9 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -9,7 +9,7 @@ use std::ops::ControlFlow;
 use std::{cmp, iter};
 
 use hir::def::DefKind;
-use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
+use rustc_data_structures::fx::{FxIndexMap, FxIndexSet};
 use rustc_data_structures::stack::ensure_sufficient_stack;
 use rustc_errors::{Diag, EmissionGuarantee};
 use rustc_hir as hir;
@@ -25,7 +25,6 @@ use rustc_middle::dep_graph::{DepNodeIndex, dep_kinds};
 pub use rustc_middle::traits::select::*;
 use rustc_middle::ty::abstract_const::NotConstEvaluatable;
 use rustc_middle::ty::error::TypeErrorToStringExt;
-use rustc_middle::ty::fold::fold_regions;
 use rustc_middle::ty::print::{PrintTraitRefExt as _, with_no_trimmed_paths};
 use rustc_middle::ty::{
     self, GenericArgsRef, PolyProjectionPredicate, Ty, TyCtxt, TypeFoldable, TypeVisitableExt,
@@ -1008,7 +1007,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             // depend on its particular value in order to work, so we can clear
             // out the param env and get better caching.
             debug!("in global");
-            obligation.param_env = obligation.param_env.without_caller_bounds();
+            obligation.param_env = ty::ParamEnv::empty();
         }
 
         let stack = self.push_stack(previous_stack, &obligation);
@@ -1225,15 +1224,21 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
     /// that recursion is ok. This routine returns `true` if the top of the
     /// stack (`cycle[0]`):
     ///
-    /// - is a defaulted trait,
+    /// - is a coinductive trait: an auto-trait or `Sized`,
     /// - it also appears in the backtrace at some position `X`,
     /// - all the predicates at positions `X..` between `X` and the top are
-    ///   also defaulted traits.
+    ///   also coinductive traits.
     pub(crate) fn coinductive_match<I>(&mut self, mut cycle: I) -> bool
     where
         I: Iterator<Item = ty::Predicate<'tcx>>,
     {
-        cycle.all(|predicate| predicate.is_coinductive(self.tcx()))
+        cycle.all(|p| match p.kind().skip_binder() {
+            ty::PredicateKind::Clause(ty::ClauseKind::Trait(data)) => {
+                self.infcx.tcx.trait_is_coinductive(data.def_id())
+            }
+            ty::PredicateKind::Clause(ty::ClauseKind::WellFormed(_)) => true,
+            _ => false,
+        })
     }
 
     /// Further evaluates `candidate` to decide whether all type parameters match and whether nested
@@ -2199,8 +2204,8 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             }
 
             ty::CoroutineWitness(def_id, args) => {
-                let hidden_types = bind_coroutine_hidden_types_above(
-                    self.infcx,
+                let hidden_types = rebind_coroutine_witness_types(
+                    self.infcx.tcx,
                     def_id,
                     args,
                     obligation.predicate.bound_vars(),
@@ -2348,7 +2353,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
             }
 
             ty::CoroutineWitness(def_id, args) => {
-                bind_coroutine_hidden_types_above(self.infcx, def_id, args, t.bound_vars())
+                rebind_coroutine_witness_types(self.infcx.tcx, def_id, args, t.bound_vars())
             }
 
             // For `PhantomData<T>`, we pass `T`.
@@ -2843,6 +2848,23 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
     }
 }
 
+fn rebind_coroutine_witness_types<'tcx>(
+    tcx: TyCtxt<'tcx>,
+    def_id: DefId,
+    args: ty::GenericArgsRef<'tcx>,
+    bound_vars: &'tcx ty::List<ty::BoundVariableKind>,
+) -> ty::Binder<'tcx, Vec<Ty<'tcx>>> {
+    let bound_coroutine_types = tcx.coroutine_hidden_types(def_id).skip_binder();
+    let shifted_coroutine_types =
+        tcx.shift_bound_var_indices(bound_vars.len(), bound_coroutine_types.skip_binder());
+    ty::Binder::bind_with_vars(
+        ty::EarlyBinder::bind(shifted_coroutine_types.to_vec()).instantiate(tcx, args),
+        tcx.mk_bound_variable_kinds_from_iter(
+            bound_vars.iter().chain(bound_coroutine_types.bound_vars()),
+        ),
+    )
+}
+
 impl<'o, 'tcx> TraitObligationStack<'o, 'tcx> {
     fn list(&'o self) -> TraitObligationStackList<'o, 'tcx> {
         TraitObligationStackList::with(self)
@@ -3151,56 +3173,3 @@ pub(crate) enum ProjectionMatchesProjection {
     Ambiguous,
     No,
 }
-
-/// Replace all regions inside the coroutine interior with late bound regions.
-/// Note that each region slot in the types gets a new fresh late bound region, which means that
-/// none of the regions inside relate to any other, even if typeck had previously found constraints
-/// that would cause them to be related.
-#[instrument(level = "trace", skip(infcx), ret)]
-fn bind_coroutine_hidden_types_above<'tcx>(
-    infcx: &InferCtxt<'tcx>,
-    def_id: DefId,
-    args: ty::GenericArgsRef<'tcx>,
-    bound_vars: &ty::List<ty::BoundVariableKind>,
-) -> ty::Binder<'tcx, Vec<Ty<'tcx>>> {
-    let tcx = infcx.tcx;
-    let mut seen_tys = FxHashSet::default();
-
-    let considering_regions = infcx.considering_regions;
-
-    let num_bound_variables = bound_vars.len() as u32;
-    let mut counter = num_bound_variables;
-
-    let hidden_types: Vec<_> = tcx
-        .coroutine_hidden_types(def_id)
-        // Deduplicate tys to avoid repeated work.
-        .filter(|bty| seen_tys.insert(*bty))
-        .map(|mut bty| {
-            // Only remap erased regions if we use them.
-            if considering_regions {
-                bty = bty.map_bound(|ty| {
-                    fold_regions(tcx, ty, |r, current_depth| match r.kind() {
-                        ty::ReErased => {
-                            let br = ty::BoundRegion {
-                                var: ty::BoundVar::from_u32(counter),
-                                kind: ty::BoundRegionKind::Anon,
-                            };
-                            counter += 1;
-                            ty::Region::new_bound(tcx, current_depth, br)
-                        }
-                        r => bug!("unexpected region: {r:?}"),
-                    })
-                })
-            }
-
-            bty.instantiate(tcx, args)
-        })
-        .collect();
-    let bound_vars = tcx.mk_bound_variable_kinds_from_iter(
-        bound_vars.iter().chain(
-            (num_bound_variables..counter)
-                .map(|_| ty::BoundVariableKind::Region(ty::BoundRegionKind::Anon)),
-        ),
-    );
-    ty::Binder::bind_with_vars(hidden_types, bound_vars)
-}
diff --git a/compiler/rustc_trait_selection/src/traits/wf.rs b/compiler/rustc_trait_selection/src/traits/wf.rs
index 7f3e3ce47816..18906a6a8ce0 100644
--- a/compiler/rustc_trait_selection/src/traits/wf.rs
+++ b/compiler/rustc_trait_selection/src/traits/wf.rs
@@ -904,19 +904,14 @@ impl<'a, 'tcx> TypeVisitor<TyCtxt<'tcx>> for WfPredicates<'a, 'tcx> {
                 // FIXME(#27579) RFC also considers adding trait
                 // obligations that don't refer to Self and
                 // checking those
-
-                let defer_to_coercion = tcx.features().dyn_compatible_for_dispatch();
-
-                if !defer_to_coercion {
-                    if let Some(principal) = data.principal_def_id() {
-                        self.out.push(traits::Obligation::with_depth(
-                            tcx,
-                            self.cause(ObligationCauseCode::WellFormed(None)),
-                            self.recursion_depth,
-                            self.param_env,
-                            ty::Binder::dummy(ty::PredicateKind::DynCompatible(principal)),
-                        ));
-                    }
+                if let Some(principal) = data.principal_def_id() {
+                    self.out.push(traits::Obligation::with_depth(
+                        tcx,
+                        self.cause(ObligationCauseCode::WellFormed(None)),
+                        self.recursion_depth,
+                        self.param_env,
+                        ty::Binder::dummy(ty::PredicateKind::DynCompatible(principal)),
+                    ));
                 }
             }
 
diff --git a/compiler/rustc_transmute/Cargo.toml b/compiler/rustc_transmute/Cargo.toml
index e9daf6b0c384..f0c783b30020 100644
--- a/compiler/rustc_transmute/Cargo.toml
+++ b/compiler/rustc_transmute/Cargo.toml
@@ -8,8 +8,6 @@ edition = "2024"
 rustc_abi = { path = "../rustc_abi", optional = true }
 rustc_data_structures = { path = "../rustc_data_structures" }
 rustc_hir = { path = "../rustc_hir", optional = true }
-rustc_infer = { path = "../rustc_infer", optional = true }
-rustc_macros = { path = "../rustc_macros", optional = true }
 rustc_middle = { path = "../rustc_middle", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
 tracing = "0.1"
@@ -19,8 +17,6 @@ tracing = "0.1"
 rustc = [
     "dep:rustc_abi",
     "dep:rustc_hir",
-    "dep:rustc_infer",
-    "dep:rustc_macros",
     "dep:rustc_middle",
     "dep:rustc_span",
 ]
diff --git a/compiler/rustc_transmute/src/layout/dfa.rs b/compiler/rustc_transmute/src/layout/dfa.rs
index a70dc034e63d..a29baade42fb 100644
--- a/compiler/rustc_transmute/src/layout/dfa.rs
+++ b/compiler/rustc_transmute/src/layout/dfa.rs
@@ -38,7 +38,7 @@ impl<R> Transitions<R>
 where
     R: Ref,
 {
-    #[allow(dead_code)]
+    #[cfg(test)]
     fn insert(&mut self, transition: Transition<R>, state: State) {
         match transition {
             Transition::Byte(b) => {
@@ -86,15 +86,6 @@ impl<R> Dfa<R>
 where
     R: Ref,
 {
-    #[allow(dead_code)]
-    pub(crate) fn unit() -> Self {
-        let transitions: Map<State, Transitions<R>> = Map::default();
-        let start = State::new();
-        let accepting = start;
-
-        Self { transitions, start, accepting }
-    }
-
     #[cfg(test)]
     pub(crate) fn bool() -> Self {
         let mut transitions: Map<State, Transitions<R>> = Map::default();
diff --git a/compiler/rustc_transmute/src/layout/nfa.rs b/compiler/rustc_transmute/src/layout/nfa.rs
index 3b49c59fa686..9c21fd94f03e 100644
--- a/compiler/rustc_transmute/src/layout/nfa.rs
+++ b/compiler/rustc_transmute/src/layout/nfa.rs
@@ -159,11 +159,6 @@ where
         }
         Self { transitions, start, accepting }
     }
-
-    #[allow(dead_code)]
-    pub(crate) fn edges_from(&self, start: State) -> Option<&Map<Transition<R>, Set<State>>> {
-        self.transitions.get(&start)
-    }
 }
 
 impl State {
diff --git a/compiler/rustc_transmute/src/layout/tree.rs b/compiler/rustc_transmute/src/layout/tree.rs
index b00585d29221..a21be5dda4ee 100644
--- a/compiler/rustc_transmute/src/layout/tree.rs
+++ b/compiler/rustc_transmute/src/layout/tree.rs
@@ -237,7 +237,7 @@ pub(crate) mod rustc {
 
                 ty::Tuple(members) => Self::from_tuple((ty, layout), members, cx),
 
-                ty::Array(inner_ty, len) => {
+                ty::Array(inner_ty, _len) => {
                     let FieldsShape::Array { stride, count } = &layout.fields else {
                         return Err(Err::NotYetSupported);
                     };
@@ -282,7 +282,6 @@ pub(crate) mod rustc {
                 FieldsShape::Primitive => {
                     assert_eq!(members.len(), 1);
                     let inner_ty = members[0];
-                    let inner_layout = layout_of(cx, inner_ty)?;
                     Self::from_ty(inner_ty, cx)
                 }
                 FieldsShape::Arbitrary { offsets, .. } => {
@@ -345,7 +344,7 @@ pub(crate) mod rustc {
                     // the enum delegates its layout to the variant at `index`.
                     layout_of_variant(*index, None)
                 }
-                Variants::Multiple { tag, tag_encoding, tag_field, .. } => {
+                Variants::Multiple { tag: _, tag_encoding, tag_field, .. } => {
                     // `Variants::Multiple` denotes an enum with multiple
                     // variants. The layout of such an enum is the disjunction
                     // of the layouts of its tagged variants.
@@ -356,7 +355,7 @@ pub(crate) mod rustc {
 
                     let variants = def.discriminants(cx.tcx()).try_fold(
                         Self::uninhabited(),
-                        |variants, (idx, ref discriminant)| {
+                        |variants, (idx, _discriminant)| {
                             let variant = layout_of_variant(idx, Some(tag_encoding.clone()))?;
                             Result::<Self, Err>::Ok(variants.or(variant))
                         },
@@ -414,7 +413,7 @@ pub(crate) mod rustc {
 
             // Append the fields, in memory order, to the layout.
             let inverse_memory_index = memory_index.invert_bijective_mapping();
-            for (memory_idx, &field_idx) in inverse_memory_index.iter_enumerated() {
+            for &field_idx in inverse_memory_index.iter() {
                 // Add interfield padding.
                 let padding_needed = offsets[field_idx] - size;
                 let padding = Self::padding(padding_needed.bytes_usize());
@@ -468,15 +467,14 @@ pub(crate) mod rustc {
 
             // This constructor does not support non-`FieldsShape::Union`
             // layouts. Fields of this shape are all placed at offset 0.
-            let FieldsShape::Union(fields) = layout.fields() else {
+            let FieldsShape::Union(_fields) = layout.fields() else {
                 return Err(Err::NotYetSupported);
             };
 
             let fields = &def.non_enum_variant().fields;
             let fields = fields.iter_enumerated().try_fold(
                 Self::uninhabited(),
-                |fields, (idx, field_def)| {
-                    let field_def = Def::Field(field_def);
+                |fields, (idx, _field_def)| {
                     let field_ty = ty_field(cx, (ty, layout), idx);
                     let field_layout = layout_of(cx, field_ty)?;
                     let field = Self::from_ty(field_ty, cx)?;
diff --git a/compiler/rustc_transmute/src/lib.rs b/compiler/rustc_transmute/src/lib.rs
index f9537f708ef8..81a11f7cfb26 100644
--- a/compiler/rustc_transmute/src/lib.rs
+++ b/compiler/rustc_transmute/src/lib.rs
@@ -1,6 +1,4 @@
 // tidy-alphabetical-start
-#![allow(unused_variables)]
-#![feature(alloc_layout_extra)]
 #![feature(never_type)]
 #![warn(unreachable_pub)]
 // tidy-alphabetical-end
@@ -81,15 +79,12 @@ pub enum Reason<T> {
 #[cfg(feature = "rustc")]
 mod rustc {
     use rustc_hir::lang_items::LangItem;
-    use rustc_infer::infer::InferCtxt;
-    use rustc_macros::TypeVisitable;
-    use rustc_middle::traits::ObligationCause;
-    use rustc_middle::ty::{Const, ParamEnv, Ty, TyCtxt};
+    use rustc_middle::ty::{Const, Ty, TyCtxt};
 
     use super::*;
 
     /// The source and destination types of a transmutation.
-    #[derive(TypeVisitable, Debug, Clone, Copy)]
+    #[derive(Debug, Clone, Copy)]
     pub struct Types<'tcx> {
         /// The source type.
         pub src: Ty<'tcx>,
@@ -97,27 +92,22 @@ mod rustc {
         pub dst: Ty<'tcx>,
     }
 
-    pub struct TransmuteTypeEnv<'cx, 'tcx> {
-        infcx: &'cx InferCtxt<'tcx>,
+    pub struct TransmuteTypeEnv<'tcx> {
+        tcx: TyCtxt<'tcx>,
     }
 
-    impl<'cx, 'tcx> TransmuteTypeEnv<'cx, 'tcx> {
-        pub fn new(infcx: &'cx InferCtxt<'tcx>) -> Self {
-            Self { infcx }
+    impl<'tcx> TransmuteTypeEnv<'tcx> {
+        pub fn new(tcx: TyCtxt<'tcx>) -> Self {
+            Self { tcx }
         }
 
-        #[allow(unused)]
         pub fn is_transmutable(
             &mut self,
-            cause: ObligationCause<'tcx>,
             types: Types<'tcx>,
             assume: crate::Assume,
         ) -> crate::Answer<crate::layout::rustc::Ref<'tcx>> {
             crate::maybe_transmutable::MaybeTransmutableQuery::new(
-                types.src,
-                types.dst,
-                assume,
-                self.infcx.tcx,
+                types.src, types.dst, assume, self.tcx,
             )
             .answer()
         }
@@ -125,11 +115,7 @@ mod rustc {
 
     impl Assume {
         /// Constructs an `Assume` from a given const-`Assume`.
-        pub fn from_const<'tcx>(
-            tcx: TyCtxt<'tcx>,
-            param_env: ParamEnv<'tcx>,
-            ct: Const<'tcx>,
-        ) -> Option<Self> {
+        pub fn from_const<'tcx>(tcx: TyCtxt<'tcx>, ct: Const<'tcx>) -> Option<Self> {
             use rustc_middle::ty::ScalarInt;
             use rustc_span::sym;
 
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
index 023c8fad781d..63fabc9c83d9 100644
--- a/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
+++ b/compiler/rustc_transmute/src/maybe_transmutable/mod.rs
@@ -79,12 +79,12 @@ where
     pub(crate) fn answer(self) -> Answer<<C as QueryContext>::Ref> {
         let Self { src, dst, assume, context } = self;
 
-        // Unconditionally all `Def` nodes from `src`, without pruning away the
+        // Unconditionally remove all `Def` nodes from `src`, without pruning away the
         // branches they appear in. This is valid to do for value-to-value
         // transmutations, but not for `&mut T` to `&mut U`; we will need to be
         // more sophisticated to handle transmutations between mutable
         // references.
-        let src = src.prune(&|def| false);
+        let src = src.prune(&|_def| false);
 
         if src.is_inhabited() && !dst.is_inhabited() {
             return Answer::No(Reason::DstUninhabited);
@@ -96,7 +96,7 @@ where
         let dst = if assume.safety {
             // ...if safety is assumed, don't check if they carry safety
             // invariants; retain all paths.
-            dst.prune(&|def| false)
+            dst.prune(&|_def| false)
         } else {
             // ...otherwise, prune away all paths with safety invariants from
             // the `Dst` layout.
diff --git a/compiler/rustc_transmute/src/maybe_transmutable/tests.rs b/compiler/rustc_transmute/src/maybe_transmutable/tests.rs
index 84af20c773e0..4d81382eba02 100644
--- a/compiler/rustc_transmute/src/maybe_transmutable/tests.rs
+++ b/compiler/rustc_transmute/src/maybe_transmutable/tests.rs
@@ -92,7 +92,6 @@ mod bool {
 
     #[test]
     fn should_permit_validity_expansion_and_reject_contraction() {
-        let un = layout::Tree::<Def, !>::uninhabited();
         let b0 = layout::Tree::<Def, !>::from_bits(0);
         let b1 = layout::Tree::<Def, !>::from_bits(1);
         let b2 = layout::Tree::<Def, !>::from_bits(2);
diff --git a/compiler/rustc_ty_utils/src/abi.rs b/compiler/rustc_ty_utils/src/abi.rs
index 0ff82f0c256d..e317768ff602 100644
--- a/compiler/rustc_ty_utils/src/abi.rs
+++ b/compiler/rustc_ty_utils/src/abi.rs
@@ -309,15 +309,11 @@ fn fn_abi_of_fn_ptr<'tcx>(
     query: ty::PseudoCanonicalInput<'tcx, (ty::PolyFnSig<'tcx>, &'tcx ty::List<Ty<'tcx>>)>,
 ) -> Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, &'tcx FnAbiError<'tcx>> {
     let ty::PseudoCanonicalInput { typing_env, value: (sig, extra_args) } = query;
-
-    let cx = LayoutCx::new(tcx, typing_env);
     fn_abi_new_uncached(
-        &cx,
+        &LayoutCx::new(tcx, typing_env),
         tcx.instantiate_bound_regions_with_erased(sig),
         extra_args,
         None,
-        None,
-        false,
     )
 }
 
@@ -326,19 +322,11 @@ fn fn_abi_of_instance<'tcx>(
     query: ty::PseudoCanonicalInput<'tcx, (ty::Instance<'tcx>, &'tcx ty::List<Ty<'tcx>>)>,
 ) -> Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, &'tcx FnAbiError<'tcx>> {
     let ty::PseudoCanonicalInput { typing_env, value: (instance, extra_args) } = query;
-
-    let sig = fn_sig_for_fn_abi(tcx, instance, typing_env);
-
-    let caller_location =
-        instance.def.requires_caller_location(tcx).then(|| tcx.caller_location_ty());
-
     fn_abi_new_uncached(
         &LayoutCx::new(tcx, typing_env),
-        sig,
+        fn_sig_for_fn_abi(tcx, instance, typing_env),
         extra_args,
-        caller_location,
-        Some(instance.def_id()),
-        matches!(instance.def, ty::InstanceKind::Virtual(..)),
+        Some(instance),
     )
 }
 
@@ -472,7 +460,7 @@ fn fn_abi_sanity_check<'tcx>(
                 // `layout.backend_repr` and ignore everything else. We should just reject
                 //`Aggregate` entirely here, but some targets need to be fixed first.
                 match arg.layout.backend_repr {
-                    BackendRepr::Scalar(_) | BackendRepr::Vector { .. } => {}
+                    BackendRepr::Scalar(_) | BackendRepr::SimdVector { .. } => {}
                     BackendRepr::ScalarPair(..) => {
                         panic!("`PassMode::Direct` used for ScalarPair type {}", arg.layout.ty)
                     }
@@ -547,19 +535,25 @@ fn fn_abi_sanity_check<'tcx>(
     fn_arg_sanity_check(cx, fn_abi, spec_abi, &fn_abi.ret);
 }
 
-// FIXME(eddyb) perhaps group the signature/type-containing (or all of them?)
-// arguments of this method, into a separate `struct`.
-#[tracing::instrument(level = "debug", skip(cx, caller_location, fn_def_id, force_thin_self_ptr))]
+#[tracing::instrument(level = "debug", skip(cx, instance))]
 fn fn_abi_new_uncached<'tcx>(
     cx: &LayoutCx<'tcx>,
     sig: ty::FnSig<'tcx>,
     extra_args: &[Ty<'tcx>],
-    caller_location: Option<Ty<'tcx>>,
-    fn_def_id: Option<DefId>,
-    // FIXME(eddyb) replace this with something typed, like an `enum`.
-    force_thin_self_ptr: bool,
+    instance: Option<ty::Instance<'tcx>>,
 ) -> Result<&'tcx FnAbi<'tcx, Ty<'tcx>>, &'tcx FnAbiError<'tcx>> {
     let tcx = cx.tcx();
+    let (caller_location, determined_fn_def_id, is_virtual_call) = if let Some(instance) = instance
+    {
+        let is_virtual_call = matches!(instance.def, ty::InstanceKind::Virtual(..));
+        (
+            instance.def.requires_caller_location(tcx).then(|| tcx.caller_location_ty()),
+            if is_virtual_call { None } else { Some(instance.def_id()) },
+            is_virtual_call,
+        )
+    } else {
+        (None, None, false)
+    };
     let sig = tcx.normalize_erasing_regions(cx.typing_env, sig);
 
     let conv = conv_from_spec_abi(cx.tcx(), sig.abi, sig.c_variadic);
@@ -568,16 +562,11 @@ fn fn_abi_new_uncached<'tcx>(
     let extra_args = if sig.abi == ExternAbi::RustCall {
         assert!(!sig.c_variadic && extra_args.is_empty());
 
-        if let Some(input) = sig.inputs().last() {
-            if let ty::Tuple(tupled_arguments) = input.kind() {
-                inputs = &sig.inputs()[0..sig.inputs().len() - 1];
-                tupled_arguments
-            } else {
-                bug!(
-                    "argument to function with \"rust-call\" ABI \
-                        is not a tuple"
-                );
-            }
+        if let Some(input) = sig.inputs().last()
+            && let ty::Tuple(tupled_arguments) = input.kind()
+        {
+            inputs = &sig.inputs()[0..sig.inputs().len() - 1];
+            tupled_arguments
         } else {
             bug!(
                 "argument to function with \"rust-call\" ABI \
@@ -590,7 +579,7 @@ fn fn_abi_new_uncached<'tcx>(
     };
 
     let is_drop_in_place =
-        fn_def_id.is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::DropInPlace));
+        determined_fn_def_id.is_some_and(|def_id| tcx.is_lang_item(def_id, LangItem::DropInPlace));
 
     let arg_of = |ty: Ty<'tcx>, arg_idx: Option<usize>| -> Result<_, &'tcx FnAbiError<'tcx>> {
         let span = tracing::debug_span!("arg_of");
@@ -603,7 +592,7 @@ fn fn_abi_new_uncached<'tcx>(
         });
 
         let layout = cx.layout_of(ty).map_err(|err| &*tcx.arena.alloc(FnAbiError::Layout(*err)))?;
-        let layout = if force_thin_self_ptr && arg_idx == Some(0) {
+        let layout = if is_virtual_call && arg_idx == Some(0) {
             // Don't pass the vtable, it's not an argument of the virtual fn.
             // Instead, pass just the data pointer, but give it the type `*const/mut dyn Trait`
             // or `&/&mut dyn Trait` because this is special-cased elsewhere in codegen
@@ -646,9 +635,22 @@ fn fn_abi_new_uncached<'tcx>(
         c_variadic: sig.c_variadic,
         fixed_count: inputs.len() as u32,
         conv,
-        can_unwind: fn_can_unwind(cx.tcx(), fn_def_id, sig.abi),
+        can_unwind: fn_can_unwind(
+            tcx,
+            // Since `#[rustc_nounwind]` can change unwinding, we cannot infer unwinding by `fn_def_id` for a virtual call.
+            determined_fn_def_id,
+            sig.abi,
+        ),
     };
-    fn_abi_adjust_for_abi(cx, &mut fn_abi, sig.abi, fn_def_id);
+    fn_abi_adjust_for_abi(
+        cx,
+        &mut fn_abi,
+        sig.abi,
+        // If this is a virtual call, we cannot pass the `fn_def_id`, as it might call other
+        // functions from vtable. Internally, `deduced_param_attrs` attempts to infer attributes by
+        // visit the function body.
+        determined_fn_def_id,
+    );
     debug!("fn_abi_new_uncached = {:?}", fn_abi);
     fn_abi_sanity_check(cx, &fn_abi, sig.abi);
     Ok(tcx.arena.alloc(fn_abi))
diff --git a/compiler/rustc_ty_utils/src/layout.rs b/compiler/rustc_ty_utils/src/layout.rs
index 2ab6b8e17c4c..1a82d1713075 100644
--- a/compiler/rustc_ty_utils/src/layout.rs
+++ b/compiler/rustc_ty_utils/src/layout.rs
@@ -553,7 +553,7 @@ fn layout_of_uncached<'tcx>(
                 )
             } else {
                 (
-                    BackendRepr::Vector { element: e_abi, count: e_len },
+                    BackendRepr::SimdVector { element: e_abi, count: e_len },
                     dl.llvmlike_vector_align(size),
                 )
             };
diff --git a/compiler/rustc_ty_utils/src/layout/invariant.rs b/compiler/rustc_ty_utils/src/layout/invariant.rs
index c695e2887fd6..7423a156a217 100644
--- a/compiler/rustc_ty_utils/src/layout/invariant.rs
+++ b/compiler/rustc_ty_utils/src/layout/invariant.rs
@@ -234,7 +234,7 @@ pub(super) fn layout_sanity_check<'tcx>(cx: &LayoutCx<'tcx>, layout: &TyAndLayou
                     "`ScalarPair` second field with bad ABI in {inner:#?}",
                 );
             }
-            BackendRepr::Vector { element, count } => {
+            BackendRepr::SimdVector { element, count } => {
                 let align = layout.align.abi;
                 let size = layout.size;
                 let element_align = element.align(cx).abi;
diff --git a/compiler/rustc_ty_utils/src/ty.rs b/compiler/rustc_ty_utils/src/ty.rs
index 8ed45b4e5415..8610c30ab703 100644
--- a/compiler/rustc_ty_utils/src/ty.rs
+++ b/compiler/rustc_ty_utils/src/ty.rs
@@ -37,8 +37,6 @@ fn sized_constraint_for_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'
         | Never
         | Dynamic(_, _, ty::DynStar) => None,
 
-        UnsafeBinder(_) => todo!(),
-
         // these are never sized
         Str | Slice(..) | Dynamic(_, _, ty::Dyn) | Foreign(..) => Some(ty),
 
@@ -52,9 +50,14 @@ fn sized_constraint_for_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>) -> Option<Ty<'
             sized_constraint_for_ty(tcx, ty)
         }),
 
-        // these can be sized or unsized
+        // these can be sized or unsized.
         Param(..) | Alias(..) | Error(_) => Some(ty),
 
+        // We cannot instantiate the binder, so just return the *original* type back,
+        // but only if the inner type has a sized constraint. Thus we skip the binder,
+        // but don't actually use the result from `sized_constraint_for_ty`.
+        UnsafeBinder(inner_ty) => sized_constraint_for_ty(tcx, inner_ty.skip_binder()).map(|_| ty),
+
         Placeholder(..) | Bound(..) | Infer(..) => {
             bug!("unexpected type `{ty:?}` in sized_constraint_for_ty")
         }
diff --git a/compiler/rustc_type_ir/Cargo.toml b/compiler/rustc_type_ir/Cargo.toml
index d8184da927c3..7b2593b96e37 100644
--- a/compiler/rustc_type_ir/Cargo.toml
+++ b/compiler/rustc_type_ir/Cargo.toml
@@ -16,7 +16,7 @@ rustc_macros = { path = "../rustc_macros", optional = true }
 rustc_serialize = { path = "../rustc_serialize", optional = true }
 rustc_span = { path = "../rustc_span", optional = true }
 rustc_type_ir_macros = { path = "../rustc_type_ir_macros" }
-smallvec = { version = "1.8.1", default-features = false }
+smallvec = { version = "1.8.1", default-features = false, features = ["const_generics"] }
 thin-vec = "0.2.12"
 tracing = "0.1"
 # tidy-alphabetical-end
diff --git a/compiler/rustc_type_ir/src/infer_ctxt.rs b/compiler/rustc_type_ir/src/infer_ctxt.rs
index c9b636132f80..d5edc9610a4a 100644
--- a/compiler/rustc_type_ir/src/infer_ctxt.rs
+++ b/compiler/rustc_type_ir/src/infer_ctxt.rs
@@ -151,7 +151,7 @@ pub trait InferCtxtLike: Sized {
         value: ty::Binder<Self::Interner, T>,
     ) -> T;
 
-    fn enter_forall<T: TypeFoldable<Self::Interner> + Copy, U>(
+    fn enter_forall<T: TypeFoldable<Self::Interner>, U>(
         &self,
         value: ty::Binder<Self::Interner, T>,
         f: impl FnOnce(T) -> U,
diff --git a/compiler/rustc_type_ir/src/inherent.rs b/compiler/rustc_type_ir/src/inherent.rs
index 9277226b718b..d4134bdf3a78 100644
--- a/compiler/rustc_type_ir/src/inherent.rs
+++ b/compiler/rustc_type_ir/src/inherent.rs
@@ -462,8 +462,6 @@ pub trait Predicate<I: Interner<Predicate = Self>>:
 {
     fn as_clause(self) -> Option<I::Clause>;
 
-    fn is_coinductive(self, interner: I) -> bool;
-
     // FIXME: Eventually uplift the impl out of rustc and make this defaulted.
     fn allow_normalization(self) -> bool;
 }
diff --git a/compiler/rustc_type_ir/src/interner.rs b/compiler/rustc_type_ir/src/interner.rs
index aae2d2e96b96..e765cb66d00a 100644
--- a/compiler/rustc_type_ir/src/interner.rs
+++ b/compiler/rustc_type_ir/src/interner.rs
@@ -189,10 +189,10 @@ pub trait Interner:
     type Features: Features<Self>;
     fn features(self) -> Self::Features;
 
-    fn bound_coroutine_hidden_types(
+    fn coroutine_hidden_types(
         self,
         def_id: Self::DefId,
-    ) -> impl IntoIterator<Item = ty::EarlyBinder<Self, ty::Binder<Self, Self::Ty>>>;
+    ) -> ty::EarlyBinder<Self, ty::Binder<Self, Self::Tys>>;
 
     fn fn_sig(
         self,
@@ -279,6 +279,8 @@ pub trait Interner:
 
     fn trait_is_auto(self, trait_def_id: Self::DefId) -> bool;
 
+    fn trait_is_coinductive(self, trait_def_id: Self::DefId) -> bool;
+
     fn trait_is_alias(self, trait_def_id: Self::DefId) -> bool;
 
     fn trait_is_dyn_compatible(self, trait_def_id: Self::DefId) -> bool;
diff --git a/compiler/rustc_type_ir/src/predicate.rs b/compiler/rustc_type_ir/src/predicate.rs
index 51790b13ec77..46385ca3a6fd 100644
--- a/compiler/rustc_type_ir/src/predicate.rs
+++ b/compiler/rustc_type_ir/src/predicate.rs
@@ -131,8 +131,6 @@ pub struct TraitPredicate<I: Interner> {
     /// If polarity is Negative: we are proving that a negative impl of this trait
     /// exists. (Note that coherence also checks whether negative impls of supertraits
     /// exist via a series of predicates.)
-    ///
-    /// If polarity is Reserved: that's a bug.
     pub polarity: PredicatePolarity,
 }
 
diff --git a/compiler/rustc_type_ir/src/search_graph/mod.rs b/compiler/rustc_type_ir/src/search_graph/mod.rs
index 082cfff72e20..18e84db5d686 100644
--- a/compiler/rustc_type_ir/src/search_graph/mod.rs
+++ b/compiler/rustc_type_ir/src/search_graph/mod.rs
@@ -12,13 +12,15 @@
 /// The global cache has to be completely unobservable, while the per-cycle cache may impact
 /// behavior as long as the resulting behavior is still correct.
 use std::cmp::Ordering;
-use std::collections::BTreeSet;
+use std::collections::BTreeMap;
 use std::fmt::Debug;
 use std::hash::Hash;
 use std::marker::PhantomData;
 
 use derive_where::derive_where;
 use rustc_index::{Idx, IndexVec};
+#[cfg(feature = "nightly")]
+use rustc_macros::HashStable_NoContext;
 use tracing::debug;
 
 use crate::data_structures::HashMap;
@@ -104,27 +106,49 @@ pub trait Delegate {
         for_input: <Self::Cx as Cx>::Input,
         from_result: <Self::Cx as Cx>::Result,
     ) -> <Self::Cx as Cx>::Result;
-
-    fn step_is_coinductive(cx: Self::Cx, input: <Self::Cx as Cx>::Input) -> bool;
 }
 
 /// In the initial iteration of a cycle, we do not yet have a provisional
 /// result. In the case we return an initial provisional result depending
 /// on the kind of cycle.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[derive(Copy, Clone, Debug, PartialEq, Eq, Hash)]
+#[cfg_attr(feature = "nightly", derive(HashStable_NoContext))]
 pub enum PathKind {
     Coinductive,
     Inductive,
 }
+impl PathKind {
+    /// Returns the path kind when merging `self` with `rest`.
+    ///
+    /// Given an inductive path `self` and a coinductive path `rest`,
+    /// the path `self -> rest` would be coinductive.
+    fn extend(self, rest: PathKind) -> PathKind {
+        match self {
+            PathKind::Coinductive => PathKind::Coinductive,
+            PathKind::Inductive => rest,
+        }
+    }
+}
 
+/// The kinds of cycles a cycle head was involved in.
+///
+/// This is used to avoid rerunning a cycle if there's
+/// just a single usage kind and the final result matches
+/// its provisional result.
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum UsageKind {
     Single(PathKind),
     Mixed,
 }
+impl From<PathKind> for UsageKind {
+    fn from(path: PathKind) -> UsageKind {
+        UsageKind::Single(path)
+    }
+}
 impl UsageKind {
-    fn merge(self, other: Self) -> Self {
-        match (self, other) {
+    #[must_use]
+    fn merge(self, other: impl Into<Self>) -> Self {
+        match (self, other.into()) {
             (UsageKind::Mixed, _) | (_, UsageKind::Mixed) => UsageKind::Mixed,
             (UsageKind::Single(lhs), UsageKind::Single(rhs)) => {
                 if lhs == rhs {
@@ -135,7 +159,42 @@ impl UsageKind {
             }
         }
     }
-    fn and_merge(&mut self, other: Self) {
+    fn and_merge(&mut self, other: impl Into<Self>) {
+        *self = self.merge(other);
+    }
+}
+
+/// For each goal we track whether the paths from this goal
+/// to its cycle heads are coinductive.
+///
+/// This is a necessary condition to rebase provisional cache
+/// entries.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum AllPathsToHeadCoinductive {
+    Yes,
+    No,
+}
+impl From<PathKind> for AllPathsToHeadCoinductive {
+    fn from(path: PathKind) -> AllPathsToHeadCoinductive {
+        match path {
+            PathKind::Coinductive => AllPathsToHeadCoinductive::Yes,
+            _ => AllPathsToHeadCoinductive::No,
+        }
+    }
+}
+impl AllPathsToHeadCoinductive {
+    #[must_use]
+    fn merge(self, other: impl Into<Self>) -> Self {
+        match (self, other.into()) {
+            (AllPathsToHeadCoinductive::Yes, AllPathsToHeadCoinductive::Yes) => {
+                AllPathsToHeadCoinductive::Yes
+            }
+            (AllPathsToHeadCoinductive::No, _) | (_, AllPathsToHeadCoinductive::No) => {
+                AllPathsToHeadCoinductive::No
+            }
+        }
+    }
+    fn and_merge(&mut self, other: impl Into<Self>) {
         *self = self.merge(other);
     }
 }
@@ -177,10 +236,11 @@ impl AvailableDepth {
 
 /// All cycle heads a given goal depends on, ordered by their stack depth.
 ///
-/// We therefore pop the cycle heads from highest to lowest.
+/// We also track all paths from this goal to that head. This is necessary
+/// when rebasing provisional cache results.
 #[derive(Clone, Debug, PartialEq, Eq, Default)]
 struct CycleHeads {
-    heads: BTreeSet<StackDepth>,
+    heads: BTreeMap<StackDepth, AllPathsToHeadCoinductive>,
 }
 
 impl CycleHeads {
@@ -189,15 +249,15 @@ impl CycleHeads {
     }
 
     fn highest_cycle_head(&self) -> StackDepth {
-        *self.heads.last().unwrap()
+        self.opt_highest_cycle_head().unwrap()
     }
 
     fn opt_highest_cycle_head(&self) -> Option<StackDepth> {
-        self.heads.last().copied()
+        self.heads.last_key_value().map(|(k, _)| *k)
     }
 
     fn opt_lowest_cycle_head(&self) -> Option<StackDepth> {
-        self.heads.first().copied()
+        self.heads.first_key_value().map(|(k, _)| *k)
     }
 
     fn remove_highest_cycle_head(&mut self) {
@@ -205,28 +265,42 @@ impl CycleHeads {
         debug_assert_ne!(last, None);
     }
 
-    fn insert(&mut self, head: StackDepth) {
-        self.heads.insert(head);
+    fn insert(
+        &mut self,
+        head: StackDepth,
+        path_from_entry: impl Into<AllPathsToHeadCoinductive> + Copy,
+    ) {
+        self.heads.entry(head).or_insert(path_from_entry.into()).and_merge(path_from_entry);
     }
 
     fn merge(&mut self, heads: &CycleHeads) {
-        for &head in heads.heads.iter() {
-            self.insert(head);
+        for (&head, &path_from_entry) in heads.heads.iter() {
+            self.insert(head, path_from_entry);
+            debug_assert!(matches!(self.heads[&head], AllPathsToHeadCoinductive::Yes));
         }
     }
 
+    fn iter(&self) -> impl Iterator<Item = (StackDepth, AllPathsToHeadCoinductive)> + '_ {
+        self.heads.iter().map(|(k, v)| (*k, *v))
+    }
+
     /// Update the cycle heads of a goal at depth `this` given the cycle heads
     /// of a nested goal. This merges the heads after filtering the parent goal
     /// itself.
-    fn extend_from_child(&mut self, this: StackDepth, child: &CycleHeads) {
-        for &head in child.heads.iter() {
+    fn extend_from_child(&mut self, this: StackDepth, step_kind: PathKind, child: &CycleHeads) {
+        for (&head, &path_from_entry) in child.heads.iter() {
             match head.cmp(&this) {
                 Ordering::Less => {}
                 Ordering::Equal => continue,
                 Ordering::Greater => unreachable!(),
             }
 
-            self.insert(head);
+            let path_from_entry = match step_kind {
+                PathKind::Coinductive => AllPathsToHeadCoinductive::Yes,
+                PathKind::Inductive => path_from_entry,
+            };
+
+            self.insert(head, path_from_entry);
         }
     }
 }
@@ -246,7 +320,7 @@ impl CycleHeads {
 /// We need to disable the global cache if using it would hide a cycle, as
 /// cycles can impact behavior. The cycle ABA may have different final
 /// results from a the cycle BAB depending on the cycle root.
-#[derive_where(Debug, Default; X: Cx)]
+#[derive_where(Debug, Default, Clone; X: Cx)]
 struct NestedGoals<X: Cx> {
     nested_goals: HashMap<X::Input, UsageKind>,
 }
@@ -259,13 +333,6 @@ impl<X: Cx> NestedGoals<X> {
         self.nested_goals.entry(input).or_insert(path_from_entry).and_merge(path_from_entry);
     }
 
-    fn merge(&mut self, nested_goals: &NestedGoals<X>) {
-        #[allow(rustc::potential_query_instability)]
-        for (input, path_from_entry) in nested_goals.iter() {
-            self.insert(input, path_from_entry);
-        }
-    }
-
     /// Adds the nested goals of a nested goal, given that the path `step_kind` from this goal
     /// to the parent goal.
     ///
@@ -276,8 +343,8 @@ impl<X: Cx> NestedGoals<X> {
         #[allow(rustc::potential_query_instability)]
         for (input, path_from_entry) in nested_goals.iter() {
             let path_from_entry = match step_kind {
-                PathKind::Coinductive => path_from_entry,
-                PathKind::Inductive => UsageKind::Single(PathKind::Inductive),
+                PathKind::Coinductive => UsageKind::Single(PathKind::Coinductive),
+                PathKind::Inductive => path_from_entry,
             };
             self.insert(input, path_from_entry);
         }
@@ -289,10 +356,6 @@ impl<X: Cx> NestedGoals<X> {
         self.nested_goals.iter().map(|(i, p)| (*i, *p))
     }
 
-    fn get(&self, input: X::Input) -> Option<UsageKind> {
-        self.nested_goals.get(&input).copied()
-    }
-
     fn contains(&self, input: X::Input) -> bool {
         self.nested_goals.contains_key(&input)
     }
@@ -310,6 +373,12 @@ rustc_index::newtype_index! {
 struct StackEntry<X: Cx> {
     input: X::Input,
 
+    /// Whether proving this goal is a coinductive step.
+    ///
+    /// This is used when encountering a trait solver cycle to
+    /// decide whether the initial provisional result of the cycle.
+    step_kind_from_parent: PathKind,
+
     /// The available depth of a given goal, immutable.
     available_depth: AvailableDepth,
 
@@ -346,9 +415,9 @@ struct ProvisionalCacheEntry<X: Cx> {
     encountered_overflow: bool,
     /// All cycle heads this cache entry depends on.
     heads: CycleHeads,
-    /// The path from the highest cycle head to this goal.
+    /// The path from the highest cycle head to this goal. This differs from
+    /// `heads` which tracks the path to the cycle head *from* this goal.
     path_from_head: PathKind,
-    nested_goals: NestedGoals<X>,
     result: X::Result,
 }
 
@@ -367,6 +436,20 @@ pub struct SearchGraph<D: Delegate<Cx = X>, X: Cx = <D as Delegate>::Cx> {
     _marker: PhantomData<D>,
 }
 
+/// While [`SearchGraph::update_parent_goal`] can be mostly shared between
+/// ordinary nested goals/global cache hits and provisional cache hits,
+/// using the provisional cache should not add any nested goals.
+///
+/// `nested_goals` are only used when checking whether global cache entries
+/// are applicable. This only cares about whether a goal is actually accessed.
+/// Given that the usage of the provisional cache is fully determinstic, we
+/// don't need to track the nested goals used while computing a provisional
+/// cache entry.
+enum UpdateParentGoalCtxt<'a, X: Cx> {
+    Ordinary(&'a NestedGoals<X>),
+    ProvisionalCacheHit,
+}
+
 impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     pub fn new(root_depth: usize) -> SearchGraph<D> {
         Self {
@@ -382,27 +465,32 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// and using existing global cache entries to make sure they
     /// have the same impact on the remaining evaluation.
     fn update_parent_goal(
-        cx: X,
         stack: &mut IndexVec<StackDepth, StackEntry<X>>,
+        step_kind_from_parent: PathKind,
         reached_depth: StackDepth,
         heads: &CycleHeads,
         encountered_overflow: bool,
-        nested_goals: &NestedGoals<X>,
+        context: UpdateParentGoalCtxt<'_, X>,
     ) {
         if let Some(parent_index) = stack.last_index() {
             let parent = &mut stack[parent_index];
             parent.reached_depth = parent.reached_depth.max(reached_depth);
             parent.encountered_overflow |= encountered_overflow;
 
-            parent.heads.extend_from_child(parent_index, heads);
-            let step_kind = Self::step_kind(cx, parent.input);
-            parent.nested_goals.extend_from_child(step_kind, nested_goals);
+            parent.heads.extend_from_child(parent_index, step_kind_from_parent, heads);
+            let parent_depends_on_cycle = match context {
+                UpdateParentGoalCtxt::Ordinary(nested_goals) => {
+                    parent.nested_goals.extend_from_child(step_kind_from_parent, nested_goals);
+                    !nested_goals.is_empty()
+                }
+                UpdateParentGoalCtxt::ProvisionalCacheHit => true,
+            };
             // Once we've got goals which encountered overflow or a cycle,
             // we track all goals whose behavior may depend depend on these
             // goals as this change may cause them to now depend on additional
             // goals, resulting in new cycles. See the dev-guide for examples.
-            if !nested_goals.is_empty() {
-                parent.nested_goals.insert(parent.input, UsageKind::Single(PathKind::Coinductive))
+            if parent_depends_on_cycle {
+                parent.nested_goals.insert(parent.input, UsageKind::Single(PathKind::Inductive))
             }
         }
     }
@@ -422,21 +510,19 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         self.stack.len()
     }
 
-    fn step_kind(cx: X, input: X::Input) -> PathKind {
-        if D::step_is_coinductive(cx, input) { PathKind::Coinductive } else { PathKind::Inductive }
-    }
-
     /// Whether the path from `head` to the current stack entry is inductive or coinductive.
-    fn stack_path_kind(
-        cx: X,
+    ///
+    /// The `step_kind_to_head` is used to add a single additional path segment to the path on
+    /// the stack which completes the cycle. This given an inductive step AB which then cycles
+    /// coinductively with A, we need to treat this cycle as coinductive.
+    fn cycle_path_kind(
         stack: &IndexVec<StackDepth, StackEntry<X>>,
+        step_kind_to_head: PathKind,
         head: StackDepth,
     ) -> PathKind {
-        if stack.raw[head.index()..].iter().all(|entry| D::step_is_coinductive(cx, entry.input)) {
-            PathKind::Coinductive
-        } else {
-            PathKind::Inductive
-        }
+        stack.raw[head.index() + 1..]
+            .iter()
+            .fold(step_kind_to_head, |curr, entry| curr.extend(entry.step_kind_from_parent))
     }
 
     /// Probably the most involved method of the whole solver.
@@ -447,6 +533,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         &mut self,
         cx: X,
         input: X::Input,
+        step_kind_from_parent: PathKind,
         inspect: &mut D::ProofTreeBuilder,
         mut evaluate_goal: impl FnMut(&mut Self, &mut D::ProofTreeBuilder) -> X::Result,
     ) -> X::Result {
@@ -464,7 +551,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         // - A
         //     - BA cycle
         //     - CB :x:
-        if let Some(result) = self.lookup_provisional_cache(cx, input) {
+        if let Some(result) = self.lookup_provisional_cache(input, step_kind_from_parent) {
             return result;
         }
 
@@ -477,10 +564,12 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // global cache has been disabled as it may otherwise change the result for
             // cyclic goals. We don't care about goals which are not on the current stack
             // so it's fine to drop their scope eagerly.
-            self.lookup_global_cache_untracked(cx, input, available_depth)
+            self.lookup_global_cache_untracked(cx, input, step_kind_from_parent, available_depth)
                 .inspect(|expected| debug!(?expected, "validate cache entry"))
                 .map(|r| (scope, r))
-        } else if let Some(result) = self.lookup_global_cache(cx, input, available_depth) {
+        } else if let Some(result) =
+            self.lookup_global_cache(cx, input, step_kind_from_parent, available_depth)
+        {
             return result;
         } else {
             None
@@ -490,8 +579,8 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         // avoid iterating over the stack in case a goal has already been computed.
         // This may not have an actual performance impact and we could reorder them
         // as it may reduce the number of `nested_goals` we need to track.
-        if let Some(result) = self.check_cycle_on_stack(cx, input) {
-            debug_assert!(validate_cache.is_none(), "global cache and cycle on stack");
+        if let Some(result) = self.check_cycle_on_stack(cx, input, step_kind_from_parent) {
+            debug_assert!(validate_cache.is_none(), "global cache and cycle on stack: {input:?}");
             return result;
         }
 
@@ -499,6 +588,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         let depth = self.stack.next_index();
         let entry = StackEntry {
             input,
+            step_kind_from_parent,
             available_depth,
             reached_depth: depth,
             heads: Default::default(),
@@ -522,12 +612,12 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         // We've finished computing the goal and have popped it from the stack,
         // lazily update its parent goal.
         Self::update_parent_goal(
-            cx,
             &mut self.stack,
+            final_entry.step_kind_from_parent,
             final_entry.reached_depth,
             &final_entry.heads,
             final_entry.encountered_overflow,
-            &final_entry.nested_goals,
+            UpdateParentGoalCtxt::Ordinary(&final_entry.nested_goals),
         );
 
         // We're now done with this goal. We only add the root of cycles to the global cache.
@@ -541,19 +631,20 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 self.insert_global_cache(cx, input, final_entry, result, dep_node)
             }
         } else if D::ENABLE_PROVISIONAL_CACHE {
-            debug_assert!(validate_cache.is_none());
+            debug_assert!(validate_cache.is_none(), "unexpected non-root: {input:?}");
             let entry = self.provisional_cache.entry(input).or_default();
-            let StackEntry { heads, nested_goals, encountered_overflow, .. } = final_entry;
-            let path_from_head = Self::stack_path_kind(cx, &self.stack, heads.highest_cycle_head());
-            entry.push(ProvisionalCacheEntry {
-                encountered_overflow,
-                heads,
-                path_from_head,
-                nested_goals,
-                result,
-            });
+            let StackEntry { heads, encountered_overflow, .. } = final_entry;
+            let path_from_head = Self::cycle_path_kind(
+                &self.stack,
+                step_kind_from_parent,
+                heads.highest_cycle_head(),
+            );
+            let provisional_cache_entry =
+                ProvisionalCacheEntry { encountered_overflow, heads, path_from_head, result };
+            debug!(?provisional_cache_entry);
+            entry.push(provisional_cache_entry);
         } else {
-            debug_assert!(validate_cache.is_none());
+            debug_assert!(validate_cache.is_none(), "unexpected non-root: {input:?}");
         }
 
         result
@@ -575,7 +666,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             //
             // We must therefore not use the global cache entry for `B` in that case.
             // See tests/ui/traits/next-solver/cycles/hidden-by-overflow.rs
-            last.nested_goals.insert(last.input, UsageKind::Single(PathKind::Coinductive));
+            last.nested_goals.insert(last.input, UsageKind::Single(PathKind::Inductive));
         }
 
         debug!("encountered stack overflow");
@@ -607,7 +698,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// This can be thought of rotating the sub-tree of this provisional result and changing
     /// its entry point while making sure that all paths through this sub-tree stay the same.
     ///
-    ///
     /// In case the popped cycle head failed to reach a fixpoint anything which depends on
     /// its provisional result is invalid. Actually discarding provisional cache entries in
     /// this case would cause hangs, so we instead change the result of dependant provisional
@@ -616,7 +706,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// to me.
     fn rebase_provisional_cache_entries(
         &mut self,
-        cx: X,
         stack_entry: &StackEntry<X>,
         mut mutate_result: impl FnMut(X::Input, X::Result) -> X::Result,
     ) {
@@ -628,25 +717,24 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                     encountered_overflow: _,
                     heads,
                     path_from_head,
-                    nested_goals,
                     result,
                 } = entry;
-                if heads.highest_cycle_head() != head {
+                if heads.highest_cycle_head() == head {
+                    heads.remove_highest_cycle_head()
+                } else {
                     return true;
                 }
 
-                // We don't try rebasing if the path from the current head
-                // to the cache entry is not coinductive or if the path from
-                // the cache entry to the current head is not coinductive.
-                //
-                // Both of these constraints could be weakened, but by only
-                // accepting coinductive paths we don't have to worry about
-                // changing the cycle kind of the remaining cycles. We can
-                // extend this in the future once there's a known issue
-                // caused by it.
-                if *path_from_head != PathKind::Coinductive
-                    || nested_goals.get(stack_entry.input).unwrap()
-                        != UsageKind::Single(PathKind::Coinductive)
+                // We only try to rebase if all paths from the cache entry
+                // to its heads are coinductive. In this case these cycle
+                // kinds won't change, no matter the goals between these
+                // heads and the provisional cache entry.
+                if heads.iter().any(|(_, p)| matches!(p, AllPathsToHeadCoinductive::No)) {
+                    return false;
+                }
+
+                // The same for nested goals of the cycle head.
+                if stack_entry.heads.iter().any(|(_, p)| matches!(p, AllPathsToHeadCoinductive::No))
                 {
                     return false;
                 }
@@ -654,20 +742,23 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 // Merge the cycle heads of the provisional cache entry and the
                 // popped head. If the popped cycle head was a root, discard all
                 // provisional cache entries which depend on it.
-                heads.remove_highest_cycle_head();
                 heads.merge(&stack_entry.heads);
                 let Some(head) = heads.opt_highest_cycle_head() else {
                     return false;
                 };
 
-                // As we've made sure that the path from the new highest cycle
-                // head to the uses of the popped cycle head are fully coinductive,
-                // we can be sure that the paths to all nested goals of the popped
-                // cycle head remain the same. We can simply merge them.
-                nested_goals.merge(&stack_entry.nested_goals);
                 // We now care about the path from the next highest cycle head to the
                 // provisional cache entry.
-                *path_from_head = Self::stack_path_kind(cx, &self.stack, head);
+                match path_from_head {
+                    PathKind::Coinductive => {}
+                    PathKind::Inductive => {
+                        *path_from_head = Self::cycle_path_kind(
+                            &self.stack,
+                            stack_entry.step_kind_from_parent,
+                            head,
+                        )
+                    }
+                }
                 // Mutate the result of the provisional cache entry in case we did
                 // not reach a fixpoint.
                 *result = mutate_result(input, *result);
@@ -677,19 +768,18 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         });
     }
 
-    fn lookup_provisional_cache(&mut self, cx: X, input: X::Input) -> Option<X::Result> {
+    fn lookup_provisional_cache(
+        &mut self,
+        input: X::Input,
+        step_kind_from_parent: PathKind,
+    ) -> Option<X::Result> {
         if !D::ENABLE_PROVISIONAL_CACHE {
             return None;
         }
 
         let entries = self.provisional_cache.get(&input)?;
-        for &ProvisionalCacheEntry {
-            encountered_overflow,
-            ref heads,
-            path_from_head,
-            ref nested_goals,
-            result,
-        } in entries
+        for &ProvisionalCacheEntry { encountered_overflow, ref heads, path_from_head, result } in
+            entries
         {
             let head = heads.highest_cycle_head();
             if encountered_overflow {
@@ -710,22 +800,18 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
 
             // A provisional cache entry is only valid if the current path from its
             // highest cycle head to the goal is the same.
-            if path_from_head == Self::stack_path_kind(cx, &self.stack, head) {
+            if path_from_head == Self::cycle_path_kind(&self.stack, step_kind_from_parent, head) {
                 // While we don't have to track the full depth of the provisional cache entry,
                 // we do have to increment the required depth by one as we'd have already failed
                 // with overflow otherwise
                 let next_index = self.stack.next_index();
-                let last = &mut self.stack.raw.last_mut().unwrap();
-                let path_from_entry = Self::step_kind(cx, last.input);
-                last.nested_goals.insert(input, UsageKind::Single(path_from_entry));
-
                 Self::update_parent_goal(
-                    cx,
                     &mut self.stack,
+                    step_kind_from_parent,
                     next_index,
                     heads,
-                    false,
-                    nested_goals,
+                    encountered_overflow,
+                    UpdateParentGoalCtxt::ProvisionalCacheHit,
                 );
                 debug_assert!(self.stack[head].has_been_used.is_some());
                 debug!(?head, ?path_from_head, "provisional cache hit");
@@ -740,8 +826,8 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
     /// evaluating this entry would not have ended up depending on either a goal
     /// already on the stack or a provisional cache entry.
     fn candidate_is_applicable(
-        cx: X,
         stack: &IndexVec<StackDepth, StackEntry<X>>,
+        step_kind_from_parent: PathKind,
         provisional_cache: &HashMap<X::Input, Vec<ProvisionalCacheEntry<X>>>,
         nested_goals: &NestedGoals<X>,
     ) -> bool {
@@ -773,7 +859,6 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 encountered_overflow,
                 ref heads,
                 path_from_head,
-                nested_goals: _,
                 result: _,
             } in entries.iter()
             {
@@ -786,9 +871,9 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
                 // A provisional cache entry only applies if the path from its highest head
                 // matches the path when encountering the goal.
                 let head = heads.highest_cycle_head();
-                let full_path = match Self::stack_path_kind(cx, stack, head) {
-                    PathKind::Coinductive => path_from_global_entry,
-                    PathKind::Inductive => UsageKind::Single(PathKind::Inductive),
+                let full_path = match Self::cycle_path_kind(stack, step_kind_from_parent, head) {
+                    PathKind::Coinductive => UsageKind::Single(PathKind::Coinductive),
+                    PathKind::Inductive => path_from_global_entry,
                 };
 
                 match (full_path, path_from_head) {
@@ -816,14 +901,15 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         &self,
         cx: X,
         input: X::Input,
+        step_kind_from_parent: PathKind,
         available_depth: AvailableDepth,
     ) -> Option<X::Result> {
         cx.with_global_cache(|cache| {
             cache
                 .get(cx, input, available_depth, |nested_goals| {
                     Self::candidate_is_applicable(
-                        cx,
                         &self.stack,
+                        step_kind_from_parent,
                         &self.provisional_cache,
                         nested_goals,
                     )
@@ -839,14 +925,15 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         &mut self,
         cx: X,
         input: X::Input,
+        step_kind_from_parent: PathKind,
         available_depth: AvailableDepth,
     ) -> Option<X::Result> {
         cx.with_global_cache(|cache| {
             let CacheData { result, additional_depth, encountered_overflow, nested_goals } = cache
                 .get(cx, input, available_depth, |nested_goals| {
                     Self::candidate_is_applicable(
-                        cx,
                         &self.stack,
+                        step_kind_from_parent,
                         &self.provisional_cache,
                         nested_goals,
                     )
@@ -860,12 +947,12 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // cycle heads are always empty.
             let heads = Default::default();
             Self::update_parent_goal(
-                cx,
                 &mut self.stack,
+                step_kind_from_parent,
                 reached_depth,
                 &heads,
                 encountered_overflow,
-                nested_goals,
+                UpdateParentGoalCtxt::Ordinary(nested_goals),
             );
 
             debug!(?additional_depth, "global cache hit");
@@ -873,16 +960,21 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         })
     }
 
-    fn check_cycle_on_stack(&mut self, cx: X, input: X::Input) -> Option<X::Result> {
+    fn check_cycle_on_stack(
+        &mut self,
+        cx: X,
+        input: X::Input,
+        step_kind_from_parent: PathKind,
+    ) -> Option<X::Result> {
         let (head, _stack_entry) = self.stack.iter_enumerated().find(|(_, e)| e.input == input)?;
-        debug!("encountered cycle with depth {head:?}");
         // We have a nested goal which directly relies on a goal deeper in the stack.
         //
         // We start by tagging all cycle participants, as that's necessary for caching.
         //
         // Finally we can return either the provisional response or the initial response
         // in case we're in the first fixpoint iteration for this goal.
-        let path_kind = Self::stack_path_kind(cx, &self.stack, head);
+        let path_kind = Self::cycle_path_kind(&self.stack, step_kind_from_parent, head);
+        debug!(?path_kind, "encountered cycle with depth {head:?}");
         let usage_kind = UsageKind::Single(path_kind);
         self.stack[head].has_been_used =
             Some(self.stack[head].has_been_used.map_or(usage_kind, |prev| prev.merge(usage_kind)));
@@ -894,11 +986,10 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
         let last = &mut self.stack[last_index];
         last.reached_depth = last.reached_depth.max(next_index);
 
-        let path_from_entry = Self::step_kind(cx, last.input);
-        last.nested_goals.insert(input, UsageKind::Single(path_from_entry));
-        last.nested_goals.insert(last.input, UsageKind::Single(PathKind::Coinductive));
+        last.nested_goals.insert(input, UsageKind::Single(step_kind_from_parent));
+        last.nested_goals.insert(last.input, UsageKind::Single(PathKind::Inductive));
         if last_index != head {
-            last.heads.insert(head);
+            last.heads.insert(head, step_kind_from_parent);
         }
 
         // Return the provisional result or, if we're in the first iteration,
@@ -964,7 +1055,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // this was only the root of either coinductive or inductive cycles, and the
             // final result is equal to the initial response for that case.
             if self.reached_fixpoint(cx, &stack_entry, usage_kind, result) {
-                self.rebase_provisional_cache_entries(cx, &stack_entry, |_, result| result);
+                self.rebase_provisional_cache_entries(&stack_entry, |_, result| result);
                 return (stack_entry, result);
             }
 
@@ -981,7 +1072,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             // we also taint all provisional cache entries which depend on the
             // current goal.
             if D::is_ambiguous_result(result) {
-                self.rebase_provisional_cache_entries(cx, &stack_entry, |input, _| {
+                self.rebase_provisional_cache_entries(&stack_entry, |input, _| {
                     D::propagate_ambiguity(cx, input, result)
                 });
                 return (stack_entry, result);
@@ -993,7 +1084,7 @@ impl<D: Delegate<Cx = X>, X: Cx> SearchGraph<D> {
             if i >= D::FIXPOINT_STEP_LIMIT {
                 debug!("canonical cycle overflow");
                 let result = D::on_fixpoint_overflow(cx, input);
-                self.rebase_provisional_cache_entries(cx, &stack_entry, |input, _| {
+                self.rebase_provisional_cache_entries(&stack_entry, |input, _| {
                     D::on_fixpoint_overflow(cx, input)
                 });
                 return (stack_entry, result);
diff --git a/compiler/rustc_type_ir/src/solve/mod.rs b/compiler/rustc_type_ir/src/solve/mod.rs
index a562b751d8a9..b93668b5111b 100644
--- a/compiler/rustc_type_ir/src/solve/mod.rs
+++ b/compiler/rustc_type_ir/src/solve/mod.rs
@@ -8,6 +8,7 @@ use derive_where::derive_where;
 use rustc_macros::{HashStable_NoContext, TyDecodable, TyEncodable};
 use rustc_type_ir_macros::{Lift_Generic, TypeFoldable_Generic, TypeVisitable_Generic};
 
+use crate::search_graph::PathKind;
 use crate::{self as ty, Canonical, CanonicalVarValues, Interner, Upcast};
 
 pub type CanonicalInput<I, T = <I as Interner>::Predicate> =
@@ -78,6 +79,13 @@ pub enum GoalSource {
     /// This is used in two places: projecting to an opaque whose hidden type
     /// is already registered in the opaque type storage, and for rigid projections.
     AliasWellFormed,
+
+    /// In case normalizing aliases in nested goals cycles, eagerly normalizing these
+    /// aliases in the context of the parent may incorrectly change the cycle kind.
+    /// Normalizing aliases in goals therefore tracks the original path kind for this
+    /// nested goal. See the comment of the `ReplaceAliasWithInfer` visitor for more
+    /// details.
+    NormalizeGoal(PathKind),
 }
 
 #[derive_where(Clone; I: Interner, Goal<I, P>: Clone)]
diff --git a/compiler/stable_mir/src/compiler_interface.rs b/compiler/stable_mir/src/compiler_interface.rs
index a6f7c254583e..e82c957c34ea 100644
--- a/compiler/stable_mir/src/compiler_interface.rs
+++ b/compiler/stable_mir/src/compiler_interface.rs
@@ -62,14 +62,17 @@ pub trait Context {
     /// Returns the name of given `DefId`
     fn def_name(&self, def_id: DefId, trimmed: bool) -> Symbol;
 
-    /// Return attributes with the given attribute name.
+    /// Return registered tool attributes with the given attribute name.
     ///
-    /// Single segmented name like `#[inline]` is specified as `&["inline".to_string()]`.
+    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
+    /// attributes will simply return an empty list.
+    ///
+    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
     /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
-    fn get_attrs_by_path(&self, def_id: DefId, attr: &[Symbol]) -> Vec<Attribute>;
+    fn tool_attrs(&self, def_id: DefId, attr: &[Symbol]) -> Vec<Attribute>;
 
-    /// Get all attributes of a definition.
-    fn get_all_attrs(&self, def_id: DefId) -> Vec<Attribute>;
+    /// Get all tool attributes of a definition.
+    fn all_tool_attrs(&self, def_id: DefId) -> Vec<Attribute>;
 
     /// Returns printable, human readable form of `Span`
     fn span_to_string(&self, span: Span) -> String;
diff --git a/compiler/stable_mir/src/crate_def.rs b/compiler/stable_mir/src/crate_def.rs
index cf29176dbbdd..8c6fd99f98a1 100644
--- a/compiler/stable_mir/src/crate_def.rs
+++ b/compiler/stable_mir/src/crate_def.rs
@@ -53,19 +53,22 @@ pub trait CrateDef {
         with(|cx| cx.span_of_an_item(def_id))
     }
 
-    /// Return attributes with the given attribute name.
+    /// Return registered tool attributes with the given attribute name.
     ///
-    /// Single segmented name like `#[inline]` is specified as `&["inline".to_string()]`.
+    /// FIXME(jdonszelmann): may panic on non-tool attributes. After more attribute work, non-tool
+    /// attributes will simply return an empty list.
+    ///
+    /// Single segmented name like `#[clippy]` is specified as `&["clippy".to_string()]`.
     /// Multi-segmented name like `#[rustfmt::skip]` is specified as `&["rustfmt".to_string(), "skip".to_string()]`.
-    fn attrs_by_path(&self, attr: &[Symbol]) -> Vec<Attribute> {
+    fn tool_attrs(&self, attr: &[Symbol]) -> Vec<Attribute> {
         let def_id = self.def_id();
-        with(|cx| cx.get_attrs_by_path(def_id, attr))
+        with(|cx| cx.tool_attrs(def_id, attr))
     }
 
-    /// Return all attributes of this definition.
-    fn all_attrs(&self) -> Vec<Attribute> {
+    /// Return all tool attributes of this definition.
+    fn all_tool_attrs(&self) -> Vec<Attribute> {
         let def_id = self.def_id();
-        with(|cx| cx.get_all_attrs(def_id))
+        with(|cx| cx.all_tool_attrs(def_id))
     }
 }
 
diff --git a/config.example.toml b/config.example.toml
index a17d3ec9f884..2e26c024865d 100644
--- a/config.example.toml
+++ b/config.example.toml
@@ -608,11 +608,12 @@
 
 # The "channel" for the Rust build to produce. The stable/beta channels only
 # allow using stable features, whereas the nightly and dev channels allow using
-# nightly features
+# nightly features.
 #
-# If using tarball sources, default value for `channel` is taken from the `src/ci/channel` file;
-# otherwise, it's "dev".
-#channel = if "is a tarball source" { content of `src/ci/channel` file } else { "dev" }
+# You can set the channel to "auto-detect" to load the channel name from `src/ci/channel`.
+#
+# If using tarball sources, default value is "auto-detect", otherwise, it's "dev".
+#channel = if "is a tarball source" { "auto-detect" } else { "dev" }
 
 # A descriptive string to be appended to `rustc --version` output, which is
 # also used in places like debuginfo `DW_AT_producer`. This may be useful for
diff --git a/library/Cargo.lock b/library/Cargo.lock
index 0ad56f3ce47a..de9685742f59 100644
--- a/library/Cargo.lock
+++ b/library/Cargo.lock
@@ -61,9 +61,9 @@ dependencies = [
 
 [[package]]
 name = "compiler_builtins"
-version = "0.1.147"
+version = "0.1.148"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "7170335a76fbcba350c3ea795c15df3b2c02934e35e502e82c4dd7837d4d0161"
+checksum = "26137996631d90d2727b905b480fdcf8c4479fdbce7afd7f8e3796d689b33cc2"
 dependencies = [
  "cc",
  "rustc-std-workspace-core",
diff --git a/library/alloc/Cargo.toml b/library/alloc/Cargo.toml
index 6f9074d91b01..9e80f3579e80 100644
--- a/library/alloc/Cargo.toml
+++ b/library/alloc/Cargo.toml
@@ -12,7 +12,7 @@ edition = "2021"
 
 [dependencies]
 core = { path = "../core", public = true }
-compiler_builtins = { version = "=0.1.147", features = ['rustc-dep-of-std'] }
+compiler_builtins = { version = "=0.1.148", features = ['rustc-dep-of-std'] }
 
 [dev-dependencies]
 rand = { version = "0.9.0", default-features = false, features = ["alloc"] }
diff --git a/library/alloc/src/boxed.rs b/library/alloc/src/boxed.rs
index e2a55d313953..c3f5806e1aa9 100644
--- a/library/alloc/src/boxed.rs
+++ b/library/alloc/src/boxed.rs
@@ -238,11 +238,8 @@ pub struct Box<
 ///
 /// This is the surface syntax for `box <expr>` expressions.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[unstable(feature = "liballoc_internals", issue = "none")]
-pub fn box_new<T>(_x: T) -> Box<T> {
-    unreachable!()
-}
+pub fn box_new<T>(_x: T) -> Box<T>;
 
 impl<T> Box<T> {
     /// Allocates memory on the heap and then places `x` into it.
diff --git a/library/alloc/src/collections/btree/map.rs b/library/alloc/src/collections/btree/map.rs
index 6d305386dbfa..78b7da9d6b3e 100644
--- a/library/alloc/src/collections/btree/map.rs
+++ b/library/alloc/src/collections/btree/map.rs
@@ -289,7 +289,7 @@ impl<K: Clone, V: Clone, A: Allocator + Clone> Clone for BTreeMap<K, V, A> {
     }
 }
 
-/// Internal functionality for `BTreeSet`.
+// Internal functionality for `BTreeSet`.
 impl<K, A: Allocator + Clone> BTreeMap<K, SetValZST, A> {
     pub(super) fn replace(&mut self, key: K) -> Option<K>
     where
diff --git a/library/alloc/src/collections/linked_list.rs b/library/alloc/src/collections/linked_list.rs
index 13168b7a39fe..3183268b4b32 100644
--- a/library/alloc/src/collections/linked_list.rs
+++ b/library/alloc/src/collections/linked_list.rs
@@ -1140,7 +1140,6 @@ impl<T, A: Allocator> LinkedList<T, A> {
     /// Splitting a list into evens and odds, reusing the original list:
     ///
     /// ```
-    /// #![feature(extract_if)]
     /// use std::collections::LinkedList;
     ///
     /// let mut numbers: LinkedList<u32> = LinkedList::new();
@@ -1152,7 +1151,7 @@ impl<T, A: Allocator> LinkedList<T, A> {
     /// assert_eq!(evens.into_iter().collect::<Vec<_>>(), vec![2, 4, 6, 8, 14]);
     /// assert_eq!(odds.into_iter().collect::<Vec<_>>(), vec![1, 3, 5, 9, 11, 13, 15]);
     /// ```
-    #[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+    #[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
     pub fn extract_if<F>(&mut self, filter: F) -> ExtractIf<'_, T, F, A>
     where
         F: FnMut(&mut T) -> bool,
@@ -1932,7 +1931,7 @@ impl<'a, T, A: Allocator> CursorMut<'a, T, A> {
 }
 
 /// An iterator produced by calling `extract_if` on LinkedList.
-#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<
     'a,
@@ -1947,7 +1946,7 @@ pub struct ExtractIf<
     old_len: usize,
 }
 
-#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
 where
     F: FnMut(&mut T) -> bool,
@@ -1976,7 +1975,7 @@ where
     }
 }
 
-#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<T: fmt::Debug, F> fmt::Debug for ExtractIf<'_, T, F> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("ExtractIf").field(&self.list).finish()
diff --git a/library/alloc/src/string.rs b/library/alloc/src/string.rs
index 9446afd4b24b..f10ef1fca137 100644
--- a/library/alloc/src/string.rs
+++ b/library/alloc/src/string.rs
@@ -966,11 +966,8 @@ impl String {
     /// This is highly unsafe, due to the number of invariants that aren't
     /// checked:
     ///
-    /// * The memory at `buf` needs to have been previously allocated by the
-    ///   same allocator the standard library uses, with a required alignment of exactly 1.
-    /// * `length` needs to be less than or equal to `capacity`.
-    /// * `capacity` needs to be the correct value.
-    /// * The first `length` bytes at `buf` need to be valid UTF-8.
+    /// * all safety requirements for [`Vec::<u8>::from_raw_parts`].
+    /// * all safety requirements for [`String::from_utf8_unchecked`].
     ///
     /// Violating these may cause problems like corrupting the allocator's
     /// internal data structures. For example, it is normally **not** safe to
diff --git a/library/alloc/src/vec/extract_if.rs b/library/alloc/src/vec/extract_if.rs
index 4db13981596b..be869553ef4e 100644
--- a/library/alloc/src/vec/extract_if.rs
+++ b/library/alloc/src/vec/extract_if.rs
@@ -12,12 +12,10 @@ use crate::alloc::{Allocator, Global};
 /// # Example
 ///
 /// ```
-/// #![feature(extract_if)]
-///
 /// let mut v = vec![0, 1, 2];
 /// let iter: std::vec::ExtractIf<'_, _, _> = v.extract_if(.., |x| *x % 2 == 0);
 /// ```
-#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
 #[derive(Debug)]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<
@@ -59,7 +57,7 @@ impl<'a, T, F, A: Allocator> ExtractIf<'a, T, F, A> {
     }
 }
 
-#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<T, F, A: Allocator> Iterator for ExtractIf<'_, T, F, A>
 where
     F: FnMut(&mut T) -> bool,
@@ -95,7 +93,7 @@ where
     }
 }
 
-#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<T, F, A: Allocator> Drop for ExtractIf<'_, T, F, A> {
     fn drop(&mut self) {
         unsafe {
diff --git a/library/alloc/src/vec/mod.rs b/library/alloc/src/vec/mod.rs
index a84bb724473a..701144cc3af2 100644
--- a/library/alloc/src/vec/mod.rs
+++ b/library/alloc/src/vec/mod.rs
@@ -66,7 +66,7 @@ use core::ptr::{self, NonNull};
 use core::slice::{self, SliceIndex};
 use core::{fmt, intrinsics};
 
-#[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+#[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
 pub use self::extract_if::ExtractIf;
 use crate::alloc::{Allocator, Global};
 use crate::borrow::{Cow, ToOwned};
@@ -355,11 +355,20 @@ mod spec_extend;
 /// and it may prove desirable to use a non-constant growth factor. Whatever
 /// strategy is used will of course guarantee *O*(1) amortized [`push`].
 ///
-/// `vec![x; n]`, `vec![a, b, c, d]`, and
-/// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec`
-/// with at least the requested capacity. If <code>[len] == [capacity]</code>,
-/// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to
-/// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements.
+/// It is guaranteed, in order to respect the intentions of the programmer, that
+/// all of `vec![e_1, e_2, ..., e_n]`, `vec![x; n]`, and [`Vec::with_capacity(n)`] produce a `Vec`
+/// that requests an allocation of the exact size needed for precisely `n` elements from the allocator,
+/// and no other size (such as, for example: a size rounded up to the nearest power of 2).
+/// The allocator will return an allocation that is at least as large as requested, but it may be larger.
+///
+/// It is guaranteed that the [`Vec::capacity`] method returns a value that is at least the requested capacity
+/// and not more than the allocated capacity.
+///
+/// The method [`Vec::shrink_to_fit`] will attempt to discard excess capacity an allocator has given to a `Vec`.
+/// If <code>[len] == [capacity]</code>, then a `Vec<T>` can be converted
+/// to and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements.
+/// `Vec` exploits this fact as much as reasonable when implementing common conversions
+/// such as [`into_boxed_slice`].
 ///
 /// `Vec` will not specifically overwrite any data that is removed from it,
 /// but also won't specifically preserve it. Its uninitialized memory is
@@ -383,14 +392,17 @@ mod spec_extend;
 /// [`shrink_to`]: Vec::shrink_to
 /// [capacity]: Vec::capacity
 /// [`capacity`]: Vec::capacity
+/// [`Vec::capacity`]: Vec::capacity
 /// [mem::size_of::\<T>]: core::mem::size_of
 /// [len]: Vec::len
 /// [`len`]: Vec::len
 /// [`push`]: Vec::push
 /// [`insert`]: Vec::insert
 /// [`reserve`]: Vec::reserve
+/// [`Vec::with_capacity(n)`]: Vec::with_capacity
 /// [`MaybeUninit`]: core::mem::MaybeUninit
 /// [owned slice]: Box
+/// [`into_boxed_slice`]: Vec::into_boxed_slice
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "Vec")]
 #[rustc_insignificant_dtor]
@@ -3684,7 +3696,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// Splitting an array into evens and odds, reusing the original allocation:
     ///
     /// ```
-    /// #![feature(extract_if)]
     /// let mut numbers = vec![1, 2, 3, 4, 5, 6, 8, 9, 11, 13, 14, 15];
     ///
     /// let evens = numbers.extract_if(.., |x| *x % 2 == 0).collect::<Vec<_>>();
@@ -3697,13 +3708,12 @@ impl<T, A: Allocator> Vec<T, A> {
     /// Using the range argument to only process a part of the vector:
     ///
     /// ```
-    /// #![feature(extract_if)]
     /// let mut items = vec![0, 0, 0, 0, 0, 0, 0, 1, 2, 1, 2, 1, 2];
     /// let ones = items.extract_if(7.., |x| *x == 1).collect::<Vec<_>>();
     /// assert_eq!(items, vec![0, 0, 0, 0, 0, 0, 0, 2, 2, 2]);
     /// assert_eq!(ones.len(), 3);
     /// ```
-    #[unstable(feature = "extract_if", reason = "recently added", issue = "43244")]
+    #[stable(feature = "extract_if", since = "CURRENT_RUSTC_VERSION")]
     pub fn extract_if<F, R>(&mut self, range: R, filter: F) -> ExtractIf<'_, T, F, A>
     where
         F: FnMut(&mut T) -> bool,
diff --git a/library/alloc/tests/lib.rs b/library/alloc/tests/lib.rs
index f95be6a6df0b..785070fb2bbc 100644
--- a/library/alloc/tests/lib.rs
+++ b/library/alloc/tests/lib.rs
@@ -7,7 +7,6 @@
 #![feature(cow_is_borrowed)]
 #![feature(core_intrinsics)]
 #![feature(downcast_unchecked)]
-#![feature(extract_if)]
 #![feature(exact_size_is_empty)]
 #![feature(hashmap_internals)]
 #![feature(linked_list_cursors)]
@@ -29,7 +28,6 @@
 #![feature(string_remove_matches)]
 #![feature(const_btree_len)]
 #![feature(const_trait_impl)]
-#![feature(const_str_from_utf8)]
 #![feature(panic_update_hook)]
 #![feature(pointer_is_aligned_to)]
 #![feature(test)]
diff --git a/library/core/src/cmp.rs b/library/core/src/cmp.rs
index 594236cf1d96..c8ced78c4d79 100644
--- a/library/core/src/cmp.rs
+++ b/library/core/src/cmp.rs
@@ -1369,7 +1369,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_lt"]
     fn lt(&self, other: &Rhs) -> bool {
-        matches!(self.partial_cmp(other), Some(Less))
+        self.partial_cmp(other).is_some_and(Ordering::is_lt)
     }
 
     /// Tests less than or equal to (for `self` and `other`) and is used by the
@@ -1387,7 +1387,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_le"]
     fn le(&self, other: &Rhs) -> bool {
-        matches!(self.partial_cmp(other), Some(Less | Equal))
+        self.partial_cmp(other).is_some_and(Ordering::is_le)
     }
 
     /// Tests greater than (for `self` and `other`) and is used by the `>`
@@ -1405,7 +1405,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_gt"]
     fn gt(&self, other: &Rhs) -> bool {
-        matches!(self.partial_cmp(other), Some(Greater))
+        self.partial_cmp(other).is_some_and(Ordering::is_gt)
     }
 
     /// Tests greater than or equal to (for `self` and `other`) and is used by
@@ -1423,7 +1423,7 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_diagnostic_item = "cmp_partialord_ge"]
     fn ge(&self, other: &Rhs) -> bool {
-        matches!(self.partial_cmp(other), Some(Greater | Equal))
+        self.partial_cmp(other).is_some_and(Ordering::is_ge)
     }
 }
 
diff --git a/library/core/src/ffi/c_str.rs b/library/core/src/ffi/c_str.rs
index 75338e492ee0..080c0cef5330 100644
--- a/library/core/src/ffi/c_str.rs
+++ b/library/core/src/ffi/c_str.rs
@@ -55,18 +55,15 @@ use crate::{fmt, ops, slice, str};
 /// Passing a Rust-originating C string:
 ///
 /// ```
-/// use std::ffi::{CString, CStr};
+/// use std::ffi::CStr;
 /// use std::os::raw::c_char;
 ///
 /// fn work(data: &CStr) {
-/// #   /* Extern functions are awkward in doc comments - fake it instead
-///     extern "C" { fn work_with(data: *const c_char); }
-/// #   */ unsafe extern "C" fn work_with(s: *const c_char) {}
-///
+///     unsafe extern "C" fn work_with(s: *const c_char) {}
 ///     unsafe { work_with(data.as_ptr()) }
 /// }
 ///
-/// let s = CString::new("data data data data").expect("CString::new failed");
+/// let s = c"Hello world!";
 /// work(&s);
 /// ```
 ///
@@ -384,13 +381,12 @@ impl CStr {
     /// # Examples
     ///
     /// ```
-    /// use std::ffi::{CStr, CString};
+    /// use std::ffi::CStr;
     ///
-    /// unsafe {
-    ///     let cstring = CString::new("hello").expect("CString::new failed");
-    ///     let cstr = CStr::from_bytes_with_nul_unchecked(cstring.to_bytes_with_nul());
-    ///     assert_eq!(cstr, &*cstring);
-    /// }
+    /// let bytes = b"Hello world!\0";
+    ///
+    /// let cstr = unsafe { CStr::from_bytes_with_nul_unchecked(bytes) };
+    /// assert_eq!(cstr.to_bytes_with_nul(), bytes);
     /// ```
     #[inline]
     #[must_use]
@@ -449,38 +445,43 @@ impl CStr {
     /// behavior when `ptr` is used inside the `unsafe` block:
     ///
     /// ```no_run
-    /// # #![allow(unused_must_use)]
     /// # #![expect(dangling_pointers_from_temporaries)]
-    /// use std::ffi::CString;
+    /// use std::ffi::{CStr, CString};
     ///
-    /// // Do not do this:
-    /// let ptr = CString::new("Hello").expect("CString::new failed").as_ptr();
-    /// unsafe {
-    ///     // `ptr` is dangling
-    ///     *ptr;
-    /// }
+    /// // 💀 The meaning of this entire program is undefined,
+    /// // 💀 and nothing about its behavior is guaranteed,
+    /// // 💀 not even that its behavior resembles the code as written,
+    /// // 💀 just because it contains a single instance of undefined behavior!
+    ///
+    /// // 🚨 creates a dangling pointer to a temporary `CString`
+    /// // 🚨 that is deallocated at the end of the statement
+    /// let ptr = CString::new("Hi!".to_uppercase()).unwrap().as_ptr();
+    ///
+    /// // without undefined behavior, you would expect that `ptr` equals:
+    /// dbg!(CStr::from_bytes_with_nul(b"HI!\0").unwrap());
+    ///
+    /// // 🙏 Possibly the program behaved as expected so far,
+    /// // 🙏 and this just shows `ptr` is now garbage..., but
+    /// // 💀 this violates `CStr::from_ptr`'s safety contract
+    /// // 💀 leading to a dereference of a dangling pointer,
+    /// // 💀 which is immediate undefined behavior.
+    /// // 💀 *BOOM*, you're dead, you're entire program has no meaning.
+    /// dbg!(unsafe { CStr::from_ptr(ptr) });
     /// ```
     ///
-    /// This happens because the pointer returned by `as_ptr` does not carry any
-    /// lifetime information and the `CString` is deallocated immediately after
-    /// the `CString::new("Hello").expect("CString::new failed").as_ptr()`
-    /// expression is evaluated.
+    /// This happens because, the pointer returned by `as_ptr` does not carry any
+    /// lifetime information, and the `CString` is deallocated immediately after
+    /// the expression that it is part of has been evaluated.
     /// To fix the problem, bind the `CString` to a local variable:
     ///
-    /// ```no_run
-    /// # #![allow(unused_must_use)]
-    /// use std::ffi::CString;
-    ///
-    /// let hello = CString::new("Hello").expect("CString::new failed");
-    /// let ptr = hello.as_ptr();
-    /// unsafe {
-    ///     // `ptr` is valid because `hello` is in scope
-    ///     *ptr;
-    /// }
     /// ```
+    /// use std::ffi::{CStr, CString};
     ///
-    /// This way, the lifetime of the `CString` in `hello` encompasses
-    /// the lifetime of `ptr` and the `unsafe` block.
+    /// let c_str = CString::new("Hi!".to_uppercase()).unwrap();
+    /// let ptr = c_str.as_ptr();
+    ///
+    /// assert_eq!(unsafe { CStr::from_ptr(ptr) }, c"HI!");
+    /// ```
     #[inline]
     #[must_use]
     #[stable(feature = "rust1", since = "1.0.0")]
diff --git a/library/core/src/ffi/va_list.rs b/library/core/src/ffi/va_list.rs
index cceb186b31e7..cefa0e3950ca 100644
--- a/library/core/src/ffi/va_list.rs
+++ b/library/core/src/ffi/va_list.rs
@@ -305,25 +305,16 @@ impl<'f> Drop for VaListImpl<'f> {
 /// Destroy the arglist `ap` after initialization with `va_start` or
 /// `va_copy`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-unsafe fn va_end(_ap: &mut VaListImpl<'_>) {
-    unreachable!()
-}
+unsafe fn va_end(_ap: &mut VaListImpl<'_>);
 
 /// Copies the current location of arglist `src` to the arglist `dst`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-unsafe fn va_copy<'f>(_dest: *mut VaListImpl<'f>, _src: &VaListImpl<'f>) {
-    unreachable!()
-}
+unsafe fn va_copy<'f>(_dest: *mut VaListImpl<'f>, _src: &VaListImpl<'f>);
 
 /// Loads an argument of type `T` from the `va_list` `ap` and increment the
 /// argument `ap` points to.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-unsafe fn va_arg<T: sealed_trait::VaArgSafe>(_ap: &mut VaListImpl<'_>) -> T {
-    unreachable!()
-}
+unsafe fn va_arg<T: sealed_trait::VaArgSafe>(_ap: &mut VaListImpl<'_>) -> T;
diff --git a/library/core/src/future/mod.rs b/library/core/src/future/mod.rs
index e5a368796ec9..65c0171c88d5 100644
--- a/library/core/src/future/mod.rs
+++ b/library/core/src/future/mod.rs
@@ -46,19 +46,19 @@ pub use self::join::join;
 /// It also simplifies the HIR lowering of `.await`.
 #[lang = "ResumeTy"]
 #[doc(hidden)]
-#[unstable(feature = "gen_future", issue = "50547")]
+#[unstable(feature = "gen_future", issue = "none")]
 #[derive(Debug, Copy, Clone)]
 pub struct ResumeTy(NonNull<Context<'static>>);
 
-#[unstable(feature = "gen_future", issue = "50547")]
+#[unstable(feature = "gen_future", issue = "none")]
 unsafe impl Send for ResumeTy {}
 
-#[unstable(feature = "gen_future", issue = "50547")]
+#[unstable(feature = "gen_future", issue = "none")]
 unsafe impl Sync for ResumeTy {}
 
 #[lang = "get_context"]
 #[doc(hidden)]
-#[unstable(feature = "gen_future", issue = "50547")]
+#[unstable(feature = "gen_future", issue = "none")]
 #[must_use]
 #[inline]
 pub unsafe fn get_context<'a, 'b>(cx: ResumeTy) -> &'a mut Context<'b> {
diff --git a/library/core/src/intrinsics/mod.rs b/library/core/src/intrinsics/mod.rs
index ae2b3b92b823..38a60338e74e 100644
--- a/library/core/src/intrinsics/mod.rs
+++ b/library/core/src/intrinsics/mod.rs
@@ -96,11 +96,8 @@ pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
 /// [`Ordering::Relaxed`] as both the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_relaxed_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_relaxed_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -108,11 +105,8 @@ pub unsafe fn atomic_cxchg_relaxed_relaxed<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Relaxed`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_relaxed_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_relaxed_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -120,11 +114,8 @@ pub unsafe fn atomic_cxchg_relaxed_acquire<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Relaxed`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_relaxed_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_relaxed_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -132,11 +123,8 @@ pub unsafe fn atomic_cxchg_relaxed_seqcst<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Acquire`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_acquire_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_acquire_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -144,11 +132,8 @@ pub unsafe fn atomic_cxchg_acquire_relaxed<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Acquire`] as both the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_acquire_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_acquire_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -156,11 +141,8 @@ pub unsafe fn atomic_cxchg_acquire_acquire<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Acquire`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_acquire_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_acquire_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -168,11 +150,8 @@ pub unsafe fn atomic_cxchg_acquire_seqcst<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Release`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_release_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_release_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -180,11 +159,8 @@ pub unsafe fn atomic_cxchg_release_relaxed<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Release`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_release_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_release_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -192,11 +168,8 @@ pub unsafe fn atomic_cxchg_release_acquire<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::Release`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_release_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_release_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -204,11 +177,8 @@ pub unsafe fn atomic_cxchg_release_seqcst<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::AcqRel`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_acqrel_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_acqrel_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -216,11 +186,8 @@ pub unsafe fn atomic_cxchg_acqrel_relaxed<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::AcqRel`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_acqrel_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_acqrel_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -228,11 +195,8 @@ pub unsafe fn atomic_cxchg_acqrel_acquire<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::AcqRel`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_acqrel_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_acqrel_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -240,11 +204,8 @@ pub unsafe fn atomic_cxchg_acqrel_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T
 /// [`Ordering::SeqCst`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_seqcst_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_seqcst_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -252,11 +213,8 @@ pub unsafe fn atomic_cxchg_seqcst_relaxed<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::SeqCst`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_seqcst_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_seqcst_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -264,11 +222,8 @@ pub unsafe fn atomic_cxchg_seqcst_acquire<T: Copy>(_dst: *mut T, _old: T, _src:
 /// [`Ordering::SeqCst`] as both the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchg_seqcst_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchg_seqcst_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 
 /// Stores a value if the current value is the same as the `old` value.
 ///
@@ -277,15 +232,12 @@ pub unsafe fn atomic_cxchg_seqcst_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T
 /// [`Ordering::Relaxed`] as both the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 pub unsafe fn atomic_cxchgweak_relaxed_relaxed<T: Copy>(
     _dst: *mut T,
     _old: T,
     _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -293,15 +245,12 @@ pub unsafe fn atomic_cxchgweak_relaxed_relaxed<T: Copy>(
 /// [`Ordering::Relaxed`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 pub unsafe fn atomic_cxchgweak_relaxed_acquire<T: Copy>(
     _dst: *mut T,
     _old: T,
     _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -309,15 +258,9 @@ pub unsafe fn atomic_cxchgweak_relaxed_acquire<T: Copy>(
 /// [`Ordering::Relaxed`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_relaxed_seqcst<T: Copy>(
-    _dst: *mut T,
-    _old: T,
-    _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_relaxed_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T)
+-> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -325,15 +268,12 @@ pub unsafe fn atomic_cxchgweak_relaxed_seqcst<T: Copy>(
 /// [`Ordering::Acquire`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 pub unsafe fn atomic_cxchgweak_acquire_relaxed<T: Copy>(
     _dst: *mut T,
     _old: T,
     _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -341,15 +281,12 @@ pub unsafe fn atomic_cxchgweak_acquire_relaxed<T: Copy>(
 /// [`Ordering::Acquire`] as both the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 pub unsafe fn atomic_cxchgweak_acquire_acquire<T: Copy>(
     _dst: *mut T,
     _old: T,
     _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -357,15 +294,9 @@ pub unsafe fn atomic_cxchgweak_acquire_acquire<T: Copy>(
 /// [`Ordering::Acquire`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_acquire_seqcst<T: Copy>(
-    _dst: *mut T,
-    _old: T,
-    _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_acquire_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T)
+-> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -373,15 +304,12 @@ pub unsafe fn atomic_cxchgweak_acquire_seqcst<T: Copy>(
 /// [`Ordering::Release`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 pub unsafe fn atomic_cxchgweak_release_relaxed<T: Copy>(
     _dst: *mut T,
     _old: T,
     _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -389,15 +317,12 @@ pub unsafe fn atomic_cxchgweak_release_relaxed<T: Copy>(
 /// [`Ordering::Release`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 pub unsafe fn atomic_cxchgweak_release_acquire<T: Copy>(
     _dst: *mut T,
     _old: T,
     _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -405,15 +330,9 @@ pub unsafe fn atomic_cxchgweak_release_acquire<T: Copy>(
 /// [`Ordering::Release`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_release_seqcst<T: Copy>(
-    _dst: *mut T,
-    _old: T,
-    _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_release_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T)
+-> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -421,15 +340,9 @@ pub unsafe fn atomic_cxchgweak_release_seqcst<T: Copy>(
 /// [`Ordering::AcqRel`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_acqrel_relaxed<T: Copy>(
-    _dst: *mut T,
-    _old: T,
-    _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_acqrel_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T)
+-> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -437,15 +350,9 @@ pub unsafe fn atomic_cxchgweak_acqrel_relaxed<T: Copy>(
 /// [`Ordering::AcqRel`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_acqrel_acquire<T: Copy>(
-    _dst: *mut T,
-    _old: T,
-    _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_acqrel_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T)
+-> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -453,11 +360,8 @@ pub unsafe fn atomic_cxchgweak_acqrel_acquire<T: Copy>(
 /// [`Ordering::AcqRel`] and [`Ordering::SeqCst`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_acqrel_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_acqrel_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -465,15 +369,9 @@ pub unsafe fn atomic_cxchgweak_acqrel_seqcst<T: Copy>(_dst: *mut T, _old: T, _sr
 /// [`Ordering::SeqCst`] and [`Ordering::Relaxed`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_seqcst_relaxed<T: Copy>(
-    _dst: *mut T,
-    _old: T,
-    _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_seqcst_relaxed<T: Copy>(_dst: *mut T, _old: T, _src: T)
+-> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -481,15 +379,9 @@ pub unsafe fn atomic_cxchgweak_seqcst_relaxed<T: Copy>(
 /// [`Ordering::SeqCst`] and [`Ordering::Acquire`] as the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_seqcst_acquire<T: Copy>(
-    _dst: *mut T,
-    _old: T,
-    _src: T,
-) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_seqcst_acquire<T: Copy>(_dst: *mut T, _old: T, _src: T)
+-> (T, bool);
 /// Stores a value if the current value is the same as the `old` value.
 ///
 /// The stabilized version of this intrinsic is available on the
@@ -497,11 +389,8 @@ pub unsafe fn atomic_cxchgweak_seqcst_acquire<T: Copy>(
 /// [`Ordering::SeqCst`] as both the success and failure parameters.
 /// For example, [`AtomicBool::compare_exchange_weak`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_cxchgweak_seqcst_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool) {
-    unreachable!()
-}
+pub unsafe fn atomic_cxchgweak_seqcst_seqcst<T: Copy>(_dst: *mut T, _old: T, _src: T) -> (T, bool);
 
 /// Loads the current value of the pointer.
 ///
@@ -509,42 +398,30 @@ pub unsafe fn atomic_cxchgweak_seqcst_seqcst<T: Copy>(_dst: *mut T, _old: T, _sr
 /// [`atomic`] types via the `load` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicBool::load`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_load_seqcst<T: Copy>(_src: *const T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_load_seqcst<T: Copy>(_src: *const T) -> T;
 /// Loads the current value of the pointer.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `load` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicBool::load`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_load_acquire<T: Copy>(_src: *const T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_load_acquire<T: Copy>(_src: *const T) -> T;
 /// Loads the current value of the pointer.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `load` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicBool::load`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_load_relaxed<T: Copy>(_src: *const T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_load_relaxed<T: Copy>(_src: *const T) -> T;
 /// Do NOT use this intrinsic; "unordered" operations do not exist in our memory model!
 /// In terms of the Rust Abstract Machine, this operation is equivalent to `src.read()`,
 /// i.e., it performs a non-atomic read.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_load_unordered<T: Copy>(_src: *const T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_load_unordered<T: Copy>(_src: *const T) -> T;
 
 /// Stores the value at the specified memory location.
 ///
@@ -552,42 +429,30 @@ pub unsafe fn atomic_load_unordered<T: Copy>(_src: *const T) -> T {
 /// [`atomic`] types via the `store` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicBool::store`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_store_seqcst<T: Copy>(_dst: *mut T, _val: T) {
-    unreachable!()
-}
+pub unsafe fn atomic_store_seqcst<T: Copy>(_dst: *mut T, _val: T);
 /// Stores the value at the specified memory location.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `store` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicBool::store`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_store_release<T: Copy>(_dst: *mut T, _val: T) {
-    unreachable!()
-}
+pub unsafe fn atomic_store_release<T: Copy>(_dst: *mut T, _val: T);
 /// Stores the value at the specified memory location.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `store` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicBool::store`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_store_relaxed<T: Copy>(_dst: *mut T, _val: T) {
-    unreachable!()
-}
+pub unsafe fn atomic_store_relaxed<T: Copy>(_dst: *mut T, _val: T);
 /// Do NOT use this intrinsic; "unordered" operations do not exist in our memory model!
 /// In terms of the Rust Abstract Machine, this operation is equivalent to `dst.write(val)`,
 /// i.e., it performs a non-atomic write.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_store_unordered<T: Copy>(_dst: *mut T, _val: T) {
-    unreachable!()
-}
+pub unsafe fn atomic_store_unordered<T: Copy>(_dst: *mut T, _val: T);
 
 /// Stores the value at the specified memory location, returning the old value.
 ///
@@ -595,55 +460,40 @@ pub unsafe fn atomic_store_unordered<T: Copy>(_dst: *mut T, _val: T) {
 /// [`atomic`] types via the `swap` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicBool::swap`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xchg_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xchg_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Stores the value at the specified memory location, returning the old value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `swap` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicBool::swap`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xchg_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xchg_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Stores the value at the specified memory location, returning the old value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `swap` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicBool::swap`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xchg_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xchg_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Stores the value at the specified memory location, returning the old value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `swap` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicBool::swap`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xchg_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xchg_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Stores the value at the specified memory location, returning the old value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `swap` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicBool::swap`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xchg_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xchg_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Adds to the current value, returning the previous value.
 ///
@@ -651,55 +501,40 @@ pub unsafe fn atomic_xchg_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] types via the `fetch_add` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicIsize::fetch_add`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xadd_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xadd_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Adds to the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_add` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicIsize::fetch_add`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xadd_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xadd_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Adds to the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_add` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicIsize::fetch_add`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xadd_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xadd_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Adds to the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_add` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicIsize::fetch_add`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xadd_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xadd_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Adds to the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_add` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicIsize::fetch_add`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xadd_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xadd_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Subtract from the current value, returning the previous value.
 ///
@@ -707,55 +542,40 @@ pub unsafe fn atomic_xadd_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] types via the `fetch_sub` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicIsize::fetch_sub`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xsub_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xsub_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Subtract from the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_sub` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicIsize::fetch_sub`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xsub_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xsub_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Subtract from the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_sub` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicIsize::fetch_sub`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xsub_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xsub_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Subtract from the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_sub` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicIsize::fetch_sub`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xsub_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xsub_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Subtract from the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_sub` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicIsize::fetch_sub`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xsub_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xsub_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Bitwise and with the current value, returning the previous value.
 ///
@@ -763,55 +583,40 @@ pub unsafe fn atomic_xsub_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] types via the `fetch_and` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicBool::fetch_and`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_and_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_and_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise and with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_and` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicBool::fetch_and`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_and_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_and_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise and with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_and` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicBool::fetch_and`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_and_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_and_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise and with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_and` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicBool::fetch_and`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_and_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_and_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise and with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_and` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicBool::fetch_and`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_and_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_and_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Bitwise nand with the current value, returning the previous value.
 ///
@@ -819,55 +624,40 @@ pub unsafe fn atomic_and_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`AtomicBool`] type via the `fetch_nand` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicBool::fetch_nand`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_nand_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_nand_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise nand with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`AtomicBool`] type via the `fetch_nand` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicBool::fetch_nand`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_nand_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_nand_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise nand with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`AtomicBool`] type via the `fetch_nand` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicBool::fetch_nand`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_nand_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_nand_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise nand with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`AtomicBool`] type via the `fetch_nand` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicBool::fetch_nand`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_nand_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_nand_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise nand with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`AtomicBool`] type via the `fetch_nand` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicBool::fetch_nand`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_nand_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_nand_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Bitwise or with the current value, returning the previous value.
 ///
@@ -875,55 +665,40 @@ pub unsafe fn atomic_nand_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] types via the `fetch_or` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicBool::fetch_or`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_or_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_or_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise or with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_or` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicBool::fetch_or`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_or_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_or_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise or with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_or` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicBool::fetch_or`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_or_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_or_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise or with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_or` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicBool::fetch_or`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_or_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_or_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise or with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_or` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicBool::fetch_or`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_or_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_or_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Bitwise xor with the current value, returning the previous value.
 ///
@@ -931,55 +706,40 @@ pub unsafe fn atomic_or_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] types via the `fetch_xor` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicBool::fetch_xor`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xor_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xor_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise xor with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_xor` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicBool::fetch_xor`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xor_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xor_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise xor with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_xor` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicBool::fetch_xor`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xor_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xor_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise xor with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_xor` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicBool::fetch_xor`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xor_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xor_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Bitwise xor with the current value, returning the previous value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] types via the `fetch_xor` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicBool::fetch_xor`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_xor_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_xor_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Maximum with the current value using a signed comparison.
 ///
@@ -987,55 +747,40 @@ pub unsafe fn atomic_xor_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] signed integer types via the `fetch_max` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicI32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_max_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_max_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value using a signed comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_max` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicI32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_max_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_max_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value using a signed comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_max` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicI32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_max_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_max_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value using a signed comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_max` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicI32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_max_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_max_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_max` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicI32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_max_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_max_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Minimum with the current value using a signed comparison.
 ///
@@ -1043,55 +788,40 @@ pub unsafe fn atomic_max_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] signed integer types via the `fetch_min` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicI32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_min_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_min_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using a signed comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_min` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicI32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_min_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_min_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using a signed comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_min` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicI32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_min_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_min_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using a signed comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_min` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicI32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_min_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_min_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using a signed comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] signed integer types via the `fetch_min` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicI32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_min_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_min_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Minimum with the current value using an unsigned comparison.
 ///
@@ -1099,55 +829,40 @@ pub unsafe fn atomic_min_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] unsigned integer types via the `fetch_min` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicU32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umin_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umin_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_min` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicU32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umin_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umin_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_min` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicU32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umin_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umin_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_min` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicU32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umin_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umin_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Minimum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_min` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicU32::fetch_min`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umin_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umin_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// Maximum with the current value using an unsigned comparison.
 ///
@@ -1155,55 +870,40 @@ pub unsafe fn atomic_umin_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic`] unsigned integer types via the `fetch_max` method by passing
 /// [`Ordering::SeqCst`] as the `order`. For example, [`AtomicU32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umax_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umax_seqcst<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_max` method by passing
 /// [`Ordering::Acquire`] as the `order`. For example, [`AtomicU32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umax_acquire<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umax_acquire<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_max` method by passing
 /// [`Ordering::Release`] as the `order`. For example, [`AtomicU32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umax_release<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umax_release<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_max` method by passing
 /// [`Ordering::AcqRel`] as the `order`. For example, [`AtomicU32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umax_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umax_acqrel<T: Copy>(_dst: *mut T, _src: T) -> T;
 /// Maximum with the current value using an unsigned comparison.
 ///
 /// The stabilized version of this intrinsic is available on the
 /// [`atomic`] unsigned integer types via the `fetch_max` method by passing
 /// [`Ordering::Relaxed`] as the `order`. For example, [`AtomicU32::fetch_max`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_umax_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
-    unreachable!()
-}
+pub unsafe fn atomic_umax_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T;
 
 /// An atomic fence.
 ///
@@ -1211,44 +911,32 @@ pub unsafe fn atomic_umax_relaxed<T: Copy>(_dst: *mut T, _src: T) -> T {
 /// [`atomic::fence`] by passing [`Ordering::SeqCst`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_fence_seqcst() {
-    unreachable!()
-}
+pub unsafe fn atomic_fence_seqcst();
 /// An atomic fence.
 ///
 /// The stabilized version of this intrinsic is available in
 /// [`atomic::fence`] by passing [`Ordering::Acquire`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_fence_acquire() {
-    unreachable!()
-}
+pub unsafe fn atomic_fence_acquire();
 /// An atomic fence.
 ///
 /// The stabilized version of this intrinsic is available in
 /// [`atomic::fence`] by passing [`Ordering::Release`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_fence_release() {
-    unreachable!()
-}
+pub unsafe fn atomic_fence_release();
 /// An atomic fence.
 ///
 /// The stabilized version of this intrinsic is available in
 /// [`atomic::fence`] by passing [`Ordering::AcqRel`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_fence_acqrel() {
-    unreachable!()
-}
+pub unsafe fn atomic_fence_acqrel();
 
 /// A compiler-only memory barrier.
 ///
@@ -1261,11 +949,8 @@ pub unsafe fn atomic_fence_acqrel() {
 /// [`atomic::compiler_fence`] by passing [`Ordering::SeqCst`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_singlethreadfence_seqcst() {
-    unreachable!()
-}
+pub unsafe fn atomic_singlethreadfence_seqcst();
 /// A compiler-only memory barrier.
 ///
 /// Memory accesses will never be reordered across this barrier by the
@@ -1277,11 +962,8 @@ pub unsafe fn atomic_singlethreadfence_seqcst() {
 /// [`atomic::compiler_fence`] by passing [`Ordering::Acquire`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_singlethreadfence_acquire() {
-    unreachable!()
-}
+pub unsafe fn atomic_singlethreadfence_acquire();
 /// A compiler-only memory barrier.
 ///
 /// Memory accesses will never be reordered across this barrier by the
@@ -1293,11 +975,8 @@ pub unsafe fn atomic_singlethreadfence_acquire() {
 /// [`atomic::compiler_fence`] by passing [`Ordering::Release`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_singlethreadfence_release() {
-    unreachable!()
-}
+pub unsafe fn atomic_singlethreadfence_release();
 /// A compiler-only memory barrier.
 ///
 /// Memory accesses will never be reordered across this barrier by the
@@ -1309,11 +988,8 @@ pub unsafe fn atomic_singlethreadfence_release() {
 /// [`atomic::compiler_fence`] by passing [`Ordering::AcqRel`]
 /// as the `order`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn atomic_singlethreadfence_acqrel() {
-    unreachable!()
-}
+pub unsafe fn atomic_singlethreadfence_acqrel();
 
 /// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
 /// if supported; otherwise, it is a no-op.
@@ -1325,11 +1001,8 @@ pub unsafe fn atomic_singlethreadfence_acqrel() {
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn prefetch_read_data<T>(_data: *const T, _locality: i32) {
-    unreachable!()
-}
+pub unsafe fn prefetch_read_data<T>(_data: *const T, _locality: i32);
 /// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
 /// if supported; otherwise, it is a no-op.
 /// Prefetches have no effect on the behavior of the program but can change its performance
@@ -1340,11 +1013,8 @@ pub unsafe fn prefetch_read_data<T>(_data: *const T, _locality: i32) {
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn prefetch_write_data<T>(_data: *const T, _locality: i32) {
-    unreachable!()
-}
+pub unsafe fn prefetch_write_data<T>(_data: *const T, _locality: i32);
 /// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
 /// if supported; otherwise, it is a no-op.
 /// Prefetches have no effect on the behavior of the program but can change its performance
@@ -1355,11 +1025,8 @@ pub unsafe fn prefetch_write_data<T>(_data: *const T, _locality: i32) {
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn prefetch_read_instruction<T>(_data: *const T, _locality: i32) {
-    unreachable!()
-}
+pub unsafe fn prefetch_read_instruction<T>(_data: *const T, _locality: i32);
 /// The `prefetch` intrinsic is a hint to the code generator to insert a prefetch instruction
 /// if supported; otherwise, it is a no-op.
 /// Prefetches have no effect on the behavior of the program but can change its performance
@@ -1370,21 +1037,15 @@ pub unsafe fn prefetch_read_instruction<T>(_data: *const T, _locality: i32) {
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn prefetch_write_instruction<T>(_data: *const T, _locality: i32) {
-    unreachable!()
-}
+pub unsafe fn prefetch_write_instruction<T>(_data: *const T, _locality: i32);
 
 /// Executes a breakpoint trap, for inspection by a debugger.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub fn breakpoint() {
-    unreachable!()
-}
+pub fn breakpoint();
 
 /// Magic intrinsic that derives its meaning from attributes
 /// attached to the function.
@@ -1397,10 +1058,7 @@ pub fn breakpoint() {
 /// This intrinsic should not be used outside of the compiler.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn rustc_peek<T>(_: T) -> T {
-    unreachable!()
-}
+pub fn rustc_peek<T>(_: T) -> T;
 
 /// Aborts the execution of the process.
 ///
@@ -1419,10 +1077,7 @@ pub fn rustc_peek<T>(_: T) -> T {
 /// `SIGBUS`.  The precise behavior is not guaranteed and not stable.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn abort() -> ! {
-    unreachable!()
-}
+pub fn abort() -> !;
 
 /// Informs the optimizer that this point in the code is not reachable,
 /// enabling further optimizations.
@@ -1435,10 +1090,7 @@ pub fn abort() -> ! {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unreachable() -> ! {
-    unreachable!()
-}
+pub const unsafe fn unreachable() -> !;
 
 /// Informs the optimizer that a condition is always true.
 /// If the condition is false, the behavior is undefined.
@@ -1550,10 +1202,7 @@ pub fn select_unpredictable<T>(b: bool, true_val: T, false_val: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn assert_inhabited<T>() {
-    unreachable!()
-}
+pub const fn assert_inhabited<T>();
 
 /// A guard for unsafe functions that cannot ever be executed if `T` does not permit
 /// zero-initialization: This will statically either panic, or do nothing.
@@ -1562,10 +1211,7 @@ pub const fn assert_inhabited<T>() {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn assert_zero_valid<T>() {
-    unreachable!()
-}
+pub const fn assert_zero_valid<T>();
 
 /// A guard for `std::mem::uninitialized`. This will statically either panic, or do nothing.
 ///
@@ -1573,10 +1219,7 @@ pub const fn assert_zero_valid<T>() {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn assert_mem_uninitialized_valid<T>() {
-    unreachable!()
-}
+pub const fn assert_mem_uninitialized_valid<T>();
 
 /// Gets a reference to a static `Location` indicating where it was called.
 ///
@@ -1589,10 +1232,7 @@ pub const fn assert_mem_uninitialized_valid<T>() {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn caller_location() -> &'static crate::panic::Location<'static> {
-    unreachable!()
-}
+pub const fn caller_location() -> &'static crate::panic::Location<'static>;
 
 /// Moves a value out of scope without running drop glue.
 ///
@@ -1606,10 +1246,7 @@ pub const fn caller_location() -> &'static crate::panic::Location<'static> {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn forget<T: ?Sized>(_: T) {
-    unreachable!()
-}
+pub const fn forget<T: ?Sized>(_: T);
 
 /// Reinterprets the bits of a value of one type as another type.
 ///
@@ -1902,10 +1539,7 @@ pub const fn forget<T: ?Sized>(_: T) {
 #[rustc_diagnostic_item = "transmute"]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn transmute<Src, Dst>(_src: Src) -> Dst {
-    unreachable!()
-}
+pub const unsafe fn transmute<Src, Dst>(_src: Src) -> Dst;
 
 /// Like [`transmute`], but even less checked at compile-time: rather than
 /// giving an error for `size_of::<Src>() != size_of::<Dst>()`, it's
@@ -1919,10 +1553,7 @@ pub const unsafe fn transmute<Src, Dst>(_src: Src) -> Dst {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn transmute_unchecked<Src, Dst>(_src: Src) -> Dst {
-    unreachable!()
-}
+pub const unsafe fn transmute_unchecked<Src, Dst>(_src: Src) -> Dst;
 
 /// Returns `true` if the actual type given as `T` requires drop
 /// glue; returns `false` if the actual type provided for `T`
@@ -1940,10 +1571,7 @@ pub const unsafe fn transmute_unchecked<Src, Dst>(_src: Src) -> Dst {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn needs_drop<T: ?Sized>() -> bool {
-    unreachable!()
-}
+pub const fn needs_drop<T: ?Sized>() -> bool;
 
 /// Calculates the offset from a pointer.
 ///
@@ -1965,10 +1593,7 @@ pub const fn needs_drop<T: ?Sized>() -> bool {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn offset<Ptr, Delta>(_dst: Ptr, _offset: Delta) -> Ptr {
-    unreachable!()
-}
+pub const unsafe fn offset<Ptr, Delta>(_dst: Ptr, _offset: Delta) -> Ptr;
 
 /// Calculates the offset from a pointer, potentially wrapping.
 ///
@@ -1987,10 +1612,7 @@ pub const unsafe fn offset<Ptr, Delta>(_dst: Ptr, _offset: Delta) -> Ptr {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn arith_offset<T>(_dst: *const T, _offset: isize) -> *const T {
-    unreachable!()
-}
+pub const unsafe fn arith_offset<T>(_dst: *const T, _offset: isize) -> *const T;
 
 /// Masks out bits of the pointer according to a mask.
 ///
@@ -2002,10 +1624,7 @@ pub const unsafe fn arith_offset<T>(_dst: *const T, _offset: isize) -> *const T
 /// Consider using [`pointer::mask`] instead.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn ptr_mask<T>(_ptr: *const T, _mask: usize) -> *const T {
-    unreachable!()
-}
+pub fn ptr_mask<T>(_ptr: *const T, _mask: usize) -> *const T;
 
 /// Equivalent to the appropriate `llvm.memcpy.p0i8.0i8.*` intrinsic, with
 /// a size of `count` * `size_of::<T>()` and an alignment of
@@ -2016,11 +1635,8 @@ pub fn ptr_mask<T>(_ptr: *const T, _mask: usize) -> *const T {
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn volatile_copy_nonoverlapping_memory<T>(_dst: *mut T, _src: *const T, _count: usize) {
-    unreachable!()
-}
+pub unsafe fn volatile_copy_nonoverlapping_memory<T>(_dst: *mut T, _src: *const T, _count: usize);
 /// Equivalent to the appropriate `llvm.memmove.p0i8.0i8.*` intrinsic, with
 /// a size of `count * size_of::<T>()` and an alignment of
 /// `min_align_of::<T>()`
@@ -2030,11 +1646,8 @@ pub unsafe fn volatile_copy_nonoverlapping_memory<T>(_dst: *mut T, _src: *const
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn volatile_copy_memory<T>(_dst: *mut T, _src: *const T, _count: usize) {
-    unreachable!()
-}
+pub unsafe fn volatile_copy_memory<T>(_dst: *mut T, _src: *const T, _count: usize);
 /// Equivalent to the appropriate `llvm.memset.p0i8.*` intrinsic, with a
 /// size of `count * size_of::<T>()` and an alignment of
 /// `min_align_of::<T>()`.
@@ -2044,504 +1657,357 @@ pub unsafe fn volatile_copy_memory<T>(_dst: *mut T, _src: *const T, _count: usiz
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn volatile_set_memory<T>(_dst: *mut T, _val: u8, _count: usize) {
-    unreachable!()
-}
+pub unsafe fn volatile_set_memory<T>(_dst: *mut T, _val: u8, _count: usize);
 
 /// Performs a volatile load from the `src` pointer.
 ///
 /// The stabilized version of this intrinsic is [`core::ptr::read_volatile`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn volatile_load<T>(_src: *const T) -> T {
-    unreachable!()
-}
+pub unsafe fn volatile_load<T>(_src: *const T) -> T;
 /// Performs a volatile store to the `dst` pointer.
 ///
 /// The stabilized version of this intrinsic is [`core::ptr::write_volatile`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn volatile_store<T>(_dst: *mut T, _val: T) {
-    unreachable!()
-}
+pub unsafe fn volatile_store<T>(_dst: *mut T, _val: T);
 
 /// Performs a volatile load from the `src` pointer
 /// The pointer is not required to be aligned.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 #[rustc_diagnostic_item = "intrinsics_unaligned_volatile_load"]
-pub unsafe fn unaligned_volatile_load<T>(_src: *const T) -> T {
-    unreachable!()
-}
+pub unsafe fn unaligned_volatile_load<T>(_src: *const T) -> T;
 /// Performs a volatile store to the `dst` pointer.
 /// The pointer is not required to be aligned.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 #[rustc_diagnostic_item = "intrinsics_unaligned_volatile_store"]
-pub unsafe fn unaligned_volatile_store<T>(_dst: *mut T, _val: T) {
-    unreachable!()
-}
+pub unsafe fn unaligned_volatile_store<T>(_dst: *mut T, _val: T);
 
 /// Returns the square root of an `f16`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::sqrt`](../../std/primitive.f16.html#method.sqrt)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sqrtf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn sqrtf16(_x: f16) -> f16;
 /// Returns the square root of an `f32`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::sqrt`](../../std/primitive.f32.html#method.sqrt)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sqrtf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn sqrtf32(_x: f32) -> f32;
 /// Returns the square root of an `f64`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::sqrt`](../../std/primitive.f64.html#method.sqrt)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sqrtf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn sqrtf64(_x: f64) -> f64;
 /// Returns the square root of an `f128`
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::sqrt`](../../std/primitive.f128.html#method.sqrt)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sqrtf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn sqrtf128(_x: f128) -> f128;
 
 /// Raises an `f16` to an integer power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::powi`](../../std/primitive.f16.html#method.powi)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powif16(_a: f16, _x: i32) -> f16 {
-    unreachable!()
-}
+pub unsafe fn powif16(_a: f16, _x: i32) -> f16;
 /// Raises an `f32` to an integer power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::powi`](../../std/primitive.f32.html#method.powi)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powif32(_a: f32, _x: i32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn powif32(_a: f32, _x: i32) -> f32;
 /// Raises an `f64` to an integer power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::powi`](../../std/primitive.f64.html#method.powi)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powif64(_a: f64, _x: i32) -> f64 {
-    unreachable!()
-}
+pub unsafe fn powif64(_a: f64, _x: i32) -> f64;
 /// Raises an `f128` to an integer power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::powi`](../../std/primitive.f128.html#method.powi)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powif128(_a: f128, _x: i32) -> f128 {
-    unreachable!()
-}
+pub unsafe fn powif128(_a: f128, _x: i32) -> f128;
 
 /// Returns the sine of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::sin`](../../std/primitive.f16.html#method.sin)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sinf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn sinf16(_x: f16) -> f16;
 /// Returns the sine of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::sin`](../../std/primitive.f32.html#method.sin)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sinf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn sinf32(_x: f32) -> f32;
 /// Returns the sine of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::sin`](../../std/primitive.f64.html#method.sin)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sinf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn sinf64(_x: f64) -> f64;
 /// Returns the sine of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::sin`](../../std/primitive.f128.html#method.sin)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn sinf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn sinf128(_x: f128) -> f128;
 
 /// Returns the cosine of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::cos`](../../std/primitive.f16.html#method.cos)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn cosf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn cosf16(_x: f16) -> f16;
 /// Returns the cosine of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::cos`](../../std/primitive.f32.html#method.cos)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn cosf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn cosf32(_x: f32) -> f32;
 /// Returns the cosine of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::cos`](../../std/primitive.f64.html#method.cos)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn cosf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn cosf64(_x: f64) -> f64;
 /// Returns the cosine of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::cos`](../../std/primitive.f128.html#method.cos)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn cosf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn cosf128(_x: f128) -> f128;
 
 /// Raises an `f16` to an `f16` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::powf`](../../std/primitive.f16.html#method.powf)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powf16(_a: f16, _x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn powf16(_a: f16, _x: f16) -> f16;
 /// Raises an `f32` to an `f32` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::powf`](../../std/primitive.f32.html#method.powf)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powf32(_a: f32, _x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn powf32(_a: f32, _x: f32) -> f32;
 /// Raises an `f64` to an `f64` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::powf`](../../std/primitive.f64.html#method.powf)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powf64(_a: f64, _x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn powf64(_a: f64, _x: f64) -> f64;
 /// Raises an `f128` to an `f128` power.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::powf`](../../std/primitive.f128.html#method.powf)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn powf128(_a: f128, _x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn powf128(_a: f128, _x: f128) -> f128;
 
 /// Returns the exponential of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::exp`](../../std/primitive.f16.html#method.exp)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn expf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn expf16(_x: f16) -> f16;
 /// Returns the exponential of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::exp`](../../std/primitive.f32.html#method.exp)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn expf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn expf32(_x: f32) -> f32;
 /// Returns the exponential of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::exp`](../../std/primitive.f64.html#method.exp)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn expf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn expf64(_x: f64) -> f64;
 /// Returns the exponential of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::exp`](../../std/primitive.f128.html#method.exp)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn expf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn expf128(_x: f128) -> f128;
 
 /// Returns 2 raised to the power of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::exp2`](../../std/primitive.f16.html#method.exp2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn exp2f16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn exp2f16(_x: f16) -> f16;
 /// Returns 2 raised to the power of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::exp2`](../../std/primitive.f32.html#method.exp2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn exp2f32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn exp2f32(_x: f32) -> f32;
 /// Returns 2 raised to the power of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::exp2`](../../std/primitive.f64.html#method.exp2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn exp2f64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn exp2f64(_x: f64) -> f64;
 /// Returns 2 raised to the power of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::exp2`](../../std/primitive.f128.html#method.exp2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn exp2f128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn exp2f128(_x: f128) -> f128;
 
 /// Returns the natural logarithm of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::ln`](../../std/primitive.f16.html#method.ln)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn logf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn logf16(_x: f16) -> f16;
 /// Returns the natural logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::ln`](../../std/primitive.f32.html#method.ln)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn logf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn logf32(_x: f32) -> f32;
 /// Returns the natural logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::ln`](../../std/primitive.f64.html#method.ln)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn logf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn logf64(_x: f64) -> f64;
 /// Returns the natural logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::ln`](../../std/primitive.f128.html#method.ln)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn logf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn logf128(_x: f128) -> f128;
 
 /// Returns the base 10 logarithm of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::log10`](../../std/primitive.f16.html#method.log10)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log10f16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn log10f16(_x: f16) -> f16;
 /// Returns the base 10 logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::log10`](../../std/primitive.f32.html#method.log10)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log10f32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn log10f32(_x: f32) -> f32;
 /// Returns the base 10 logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::log10`](../../std/primitive.f64.html#method.log10)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log10f64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn log10f64(_x: f64) -> f64;
 /// Returns the base 10 logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::log10`](../../std/primitive.f128.html#method.log10)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log10f128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn log10f128(_x: f128) -> f128;
 
 /// Returns the base 2 logarithm of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::log2`](../../std/primitive.f16.html#method.log2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log2f16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn log2f16(_x: f16) -> f16;
 /// Returns the base 2 logarithm of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::log2`](../../std/primitive.f32.html#method.log2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log2f32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn log2f32(_x: f32) -> f32;
 /// Returns the base 2 logarithm of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::log2`](../../std/primitive.f64.html#method.log2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log2f64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn log2f64(_x: f64) -> f64;
 /// Returns the base 2 logarithm of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::log2`](../../std/primitive.f128.html#method.log2)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn log2f128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn log2f128(_x: f128) -> f128;
 
 /// Returns `a * b + c` for `f16` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::mul_add`](../../std/primitive.f16.html#method.mul_add)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmaf16(_a: f16, _b: f16, _c: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn fmaf16(_a: f16, _b: f16, _c: f16) -> f16;
 /// Returns `a * b + c` for `f32` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::mul_add`](../../std/primitive.f32.html#method.mul_add)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmaf32(_a: f32, _b: f32, _c: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn fmaf32(_a: f32, _b: f32, _c: f32) -> f32;
 /// Returns `a * b + c` for `f64` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::mul_add`](../../std/primitive.f64.html#method.mul_add)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmaf64(_a: f64, _b: f64, _c: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn fmaf64(_a: f64, _b: f64, _c: f64) -> f64;
 /// Returns `a * b + c` for `f128` values.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::mul_add`](../../std/primitive.f128.html#method.mul_add)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmaf128(_a: f128, _b: f128, _c: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn fmaf128(_a: f128, _b: f128, _c: f128) -> f128;
 
 /// Returns `a * b + c` for `f16` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
@@ -2554,11 +2020,8 @@ pub unsafe fn fmaf128(_a: f128, _b: f128, _c: f128) -> f128 {
 /// is selected, and that may depend on optimization level and context, for
 /// example.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf16(_a: f16, _b: f16, _c: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn fmuladdf16(_a: f16, _b: f16, _c: f16) -> f16;
 /// Returns `a * b + c` for `f32` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -2570,11 +2033,8 @@ pub unsafe fn fmuladdf16(_a: f16, _b: f16, _c: f16) -> f16 {
 /// is selected, and that may depend on optimization level and context, for
 /// example.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf32(_a: f32, _b: f32, _c: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn fmuladdf32(_a: f32, _b: f32, _c: f32) -> f32;
 /// Returns `a * b + c` for `f64` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -2586,11 +2046,8 @@ pub unsafe fn fmuladdf32(_a: f32, _b: f32, _c: f32) -> f32 {
 /// is selected, and that may depend on optimization level and context, for
 /// example.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf64(_a: f64, _b: f64, _c: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn fmuladdf64(_a: f64, _b: f64, _c: f64) -> f64;
 /// Returns `a * b + c` for `f128` values, non-deterministically executing
 /// either a fused multiply-add or two operations with rounding of the
 /// intermediate result.
@@ -2602,134 +2059,95 @@ pub unsafe fn fmuladdf64(_a: f64, _b: f64, _c: f64) -> f64 {
 /// is selected, and that may depend on optimization level and context, for
 /// example.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmuladdf128(_a: f128, _b: f128, _c: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn fmuladdf128(_a: f128, _b: f128, _c: f128) -> f128;
 
 /// Returns the largest integer less than or equal to an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::floor`](../../std/primitive.f16.html#method.floor)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn floorf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn floorf16(_x: f16) -> f16;
 /// Returns the largest integer less than or equal to an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::floor`](../../std/primitive.f32.html#method.floor)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn floorf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn floorf32(_x: f32) -> f32;
 /// Returns the largest integer less than or equal to an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::floor`](../../std/primitive.f64.html#method.floor)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn floorf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn floorf64(_x: f64) -> f64;
 /// Returns the largest integer less than or equal to an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::floor`](../../std/primitive.f128.html#method.floor)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn floorf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn floorf128(_x: f128) -> f128;
 
 /// Returns the smallest integer greater than or equal to an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::ceil`](../../std/primitive.f16.html#method.ceil)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn ceilf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn ceilf16(_x: f16) -> f16;
 /// Returns the smallest integer greater than or equal to an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::ceil`](../../std/primitive.f32.html#method.ceil)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn ceilf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn ceilf32(_x: f32) -> f32;
 /// Returns the smallest integer greater than or equal to an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::ceil`](../../std/primitive.f64.html#method.ceil)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn ceilf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn ceilf64(_x: f64) -> f64;
 /// Returns the smallest integer greater than or equal to an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::ceil`](../../std/primitive.f128.html#method.ceil)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn ceilf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn ceilf128(_x: f128) -> f128;
 
 /// Returns the integer part of an `f16`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f16::trunc`](../../std/primitive.f16.html#method.trunc)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn truncf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn truncf16(_x: f16) -> f16;
 /// Returns the integer part of an `f32`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::trunc`](../../std/primitive.f32.html#method.trunc)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn truncf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn truncf32(_x: f32) -> f32;
 /// Returns the integer part of an `f64`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::trunc`](../../std/primitive.f64.html#method.trunc)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn truncf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn truncf64(_x: f64) -> f64;
 /// Returns the integer part of an `f128`.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::trunc`](../../std/primitive.f128.html#method.trunc)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn truncf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn truncf128(_x: f128) -> f128;
 
 /// Returns the nearest integer to an `f16`. Rounds half-way cases to the number with an even
 /// least significant digit.
@@ -2737,22 +2155,16 @@ pub unsafe fn truncf128(_x: f128) -> f128 {
 /// The stabilized version of this intrinsic is
 /// [`f16::round_ties_even`](../../std/primitive.f16.html#method.round_ties_even)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 #[cfg(not(bootstrap))]
-pub fn round_ties_even_f16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub fn round_ties_even_f16(_x: f16) -> f16;
 
 /// To be removed on next bootstrap bump.
 #[cfg(bootstrap)]
 pub fn round_ties_even_f16(x: f16) -> f16 {
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
     #[rustc_nounwind]
-    unsafe fn rintf16(_x: f16) -> f16 {
-        unreachable!()
-    }
+    unsafe fn rintf16(_x: f16) -> f16;
 
     // SAFETY: this intrinsic isn't actually unsafe
     unsafe { rintf16(x) }
@@ -2764,22 +2176,16 @@ pub fn round_ties_even_f16(x: f16) -> f16 {
 /// The stabilized version of this intrinsic is
 /// [`f32::round_ties_even`](../../std/primitive.f32.html#method.round_ties_even)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 #[cfg(not(bootstrap))]
-pub fn round_ties_even_f32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub fn round_ties_even_f32(_x: f32) -> f32;
 
 /// To be removed on next bootstrap bump.
 #[cfg(bootstrap)]
 pub fn round_ties_even_f32(x: f32) -> f32 {
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
     #[rustc_nounwind]
-    unsafe fn rintf32(_x: f32) -> f32 {
-        unreachable!()
-    }
+    unsafe fn rintf32(_x: f32) -> f32;
 
     // SAFETY: this intrinsic isn't actually unsafe
     unsafe { rintf32(x) }
@@ -2797,22 +2203,16 @@ pub unsafe fn rintf32(x: f32) -> f32 {
 /// The stabilized version of this intrinsic is
 /// [`f64::round_ties_even`](../../std/primitive.f64.html#method.round_ties_even)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 #[cfg(not(bootstrap))]
-pub fn round_ties_even_f64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub fn round_ties_even_f64(_x: f64) -> f64;
 
 /// To be removed on next bootstrap bump.
 #[cfg(bootstrap)]
 pub fn round_ties_even_f64(x: f64) -> f64 {
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
     #[rustc_nounwind]
-    unsafe fn rintf64(_x: f64) -> f64 {
-        unreachable!()
-    }
+    unsafe fn rintf64(_x: f64) -> f64;
 
     // SAFETY: this intrinsic isn't actually unsafe
     unsafe { rintf64(x) }
@@ -2830,22 +2230,16 @@ pub unsafe fn rintf64(x: f64) -> f64 {
 /// The stabilized version of this intrinsic is
 /// [`f128::round_ties_even`](../../std/primitive.f128.html#method.round_ties_even)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 #[cfg(not(bootstrap))]
-pub fn round_ties_even_f128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub fn round_ties_even_f128(_x: f128) -> f128;
 
 /// To be removed on next bootstrap bump.
 #[cfg(bootstrap)]
 pub fn round_ties_even_f128(x: f128) -> f128 {
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
     #[rustc_nounwind]
-    unsafe fn rintf128(_x: f128) -> f128 {
-        unreachable!()
-    }
+    unsafe fn rintf128(_x: f128) -> f128;
 
     // SAFETY: this intrinsic isn't actually unsafe
     unsafe { rintf128(x) }
@@ -2856,157 +2250,112 @@ pub fn round_ties_even_f128(x: f128) -> f128 {
 /// The stabilized version of this intrinsic is
 /// [`f16::round`](../../std/primitive.f16.html#method.round)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn roundf16(_x: f16) -> f16 {
-    unreachable!()
-}
+pub unsafe fn roundf16(_x: f16) -> f16;
 /// Returns the nearest integer to an `f32`. Rounds half-way cases away from zero.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f32::round`](../../std/primitive.f32.html#method.round)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn roundf32(_x: f32) -> f32 {
-    unreachable!()
-}
+pub unsafe fn roundf32(_x: f32) -> f32;
 /// Returns the nearest integer to an `f64`. Rounds half-way cases away from zero.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f64::round`](../../std/primitive.f64.html#method.round)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn roundf64(_x: f64) -> f64 {
-    unreachable!()
-}
+pub unsafe fn roundf64(_x: f64) -> f64;
 /// Returns the nearest integer to an `f128`. Rounds half-way cases away from zero.
 ///
 /// The stabilized version of this intrinsic is
 /// [`f128::round`](../../std/primitive.f128.html#method.round)
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn roundf128(_x: f128) -> f128 {
-    unreachable!()
-}
+pub unsafe fn roundf128(_x: f128) -> f128;
 
 /// Float addition that allows optimizations based on algebraic rules.
 /// May assume inputs are finite.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fadd_fast<T: Copy>(_a: T, _b: T) -> T {
-    unreachable!()
-}
+pub unsafe fn fadd_fast<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float subtraction that allows optimizations based on algebraic rules.
 /// May assume inputs are finite.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fsub_fast<T: Copy>(_a: T, _b: T) -> T {
-    unreachable!()
-}
+pub unsafe fn fsub_fast<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float multiplication that allows optimizations based on algebraic rules.
 /// May assume inputs are finite.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fmul_fast<T: Copy>(_a: T, _b: T) -> T {
-    unreachable!()
-}
+pub unsafe fn fmul_fast<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float division that allows optimizations based on algebraic rules.
 /// May assume inputs are finite.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn fdiv_fast<T: Copy>(_a: T, _b: T) -> T {
-    unreachable!()
-}
+pub unsafe fn fdiv_fast<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float remainder that allows optimizations based on algebraic rules.
 /// May assume inputs are finite.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn frem_fast<T: Copy>(_a: T, _b: T) -> T {
-    unreachable!()
-}
+pub unsafe fn frem_fast<T: Copy>(_a: T, _b: T) -> T;
 
 /// Converts with LLVM’s fptoui/fptosi, which may return undef for values out of range
 /// (<https://github.com/rust-lang/rust/issues/10184>)
 ///
 /// Stabilized as [`f32::to_int_unchecked`] and [`f64::to_int_unchecked`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int {
-    unreachable!()
-}
+pub unsafe fn float_to_int_unchecked<Float: Copy, Int: Copy>(_value: Float) -> Int;
 
 /// Float addition that allows optimizations based on algebraic rules.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn fadd_algebraic<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub fn fadd_algebraic<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float subtraction that allows optimizations based on algebraic rules.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn fsub_algebraic<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub fn fsub_algebraic<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float multiplication that allows optimizations based on algebraic rules.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn fmul_algebraic<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub fn fmul_algebraic<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float division that allows optimizations based on algebraic rules.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn fdiv_algebraic<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub fn fdiv_algebraic<T: Copy>(_a: T, _b: T) -> T;
 
 /// Float remainder that allows optimizations based on algebraic rules.
 ///
 /// This intrinsic does not have a stable counterpart.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn frem_algebraic<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub fn frem_algebraic<T: Copy>(_a: T, _b: T) -> T;
 
 /// Returns the number of bits set in an integer type `T`
 ///
@@ -3021,10 +2370,7 @@ pub fn frem_algebraic<T: Copy>(_a: T, _b: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn ctpop<T: Copy>(_x: T) -> u32 {
-    unimplemented!()
-}
+pub const fn ctpop<T: Copy>(_x: T) -> u32;
 
 /// Returns the number of leading unset bits (zeroes) in an integer type `T`.
 ///
@@ -3065,10 +2411,7 @@ pub const fn ctpop<T: Copy>(_x: T) -> u32 {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn ctlz<T: Copy>(_x: T) -> u32 {
-    unimplemented!()
-}
+pub const fn ctlz<T: Copy>(_x: T) -> u32;
 
 /// Like `ctlz`, but extra-unsafe as it returns `undef` when
 /// given an `x` with value `0`.
@@ -3090,10 +2433,7 @@ pub const fn ctlz<T: Copy>(_x: T) -> u32 {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn ctlz_nonzero<T: Copy>(_x: T) -> u32 {
-    unimplemented!()
-}
+pub const unsafe fn ctlz_nonzero<T: Copy>(_x: T) -> u32;
 
 /// Returns the number of trailing unset bits (zeroes) in an integer type `T`.
 ///
@@ -3134,10 +2474,7 @@ pub const unsafe fn ctlz_nonzero<T: Copy>(_x: T) -> u32 {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn cttz<T: Copy>(_x: T) -> u32 {
-    unimplemented!()
-}
+pub const fn cttz<T: Copy>(_x: T) -> u32;
 
 /// Like `cttz`, but extra-unsafe as it returns `undef` when
 /// given an `x` with value `0`.
@@ -3159,10 +2496,7 @@ pub const fn cttz<T: Copy>(_x: T) -> u32 {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn cttz_nonzero<T: Copy>(_x: T) -> u32 {
-    unimplemented!()
-}
+pub const unsafe fn cttz_nonzero<T: Copy>(_x: T) -> u32;
 
 /// Reverses the bytes in an integer type `T`.
 ///
@@ -3177,10 +2511,7 @@ pub const unsafe fn cttz_nonzero<T: Copy>(_x: T) -> u32 {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn bswap<T: Copy>(_x: T) -> T {
-    unimplemented!()
-}
+pub const fn bswap<T: Copy>(_x: T) -> T;
 
 /// Reverses the bits in an integer type `T`.
 ///
@@ -3195,10 +2526,7 @@ pub const fn bswap<T: Copy>(_x: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn bitreverse<T: Copy>(_x: T) -> T {
-    unimplemented!()
-}
+pub const fn bitreverse<T: Copy>(_x: T) -> T;
 
 /// Does a three-way comparison between the two integer arguments.
 ///
@@ -3208,10 +2536,7 @@ pub const fn bitreverse<T: Copy>(_x: T) -> T {
 ///
 /// The stabilized version of this intrinsic is [`Ord::cmp`].
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn three_way_compare<T: Copy>(_lhs: T, _rhss: T) -> crate::cmp::Ordering {
-    unimplemented!()
-}
+pub const fn three_way_compare<T: Copy>(_lhs: T, _rhss: T) -> crate::cmp::Ordering;
 
 /// Combine two values which have no bits in common.
 ///
@@ -3246,10 +2571,7 @@ pub const unsafe fn disjoint_bitor<T: ~const fallback::DisjointBitOr>(a: T, b: T
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn add_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool) {
-    unimplemented!()
-}
+pub const fn add_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool);
 
 /// Performs checked integer subtraction
 ///
@@ -3264,10 +2586,7 @@ pub const fn add_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool) {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn sub_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool) {
-    unimplemented!()
-}
+pub const fn sub_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool);
 
 /// Performs checked integer multiplication
 ///
@@ -3282,10 +2601,7 @@ pub const fn sub_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool) {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn mul_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool) {
-    unimplemented!()
-}
+pub const fn mul_with_overflow<T: Copy>(_x: T, _y: T) -> (T, bool);
 
 /// Performs full-width multiplication and addition with a carry:
 /// `multiplier * multiplicand + addend + carry`.
@@ -3321,10 +2637,7 @@ pub const fn carrying_mul_add<T: ~const fallback::CarryingMulAdd<Unsigned = U>,
 /// This intrinsic does not have a stable counterpart.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn exact_div<T: Copy>(_x: T, _y: T) -> T {
-    unimplemented!()
-}
+pub const unsafe fn exact_div<T: Copy>(_x: T, _y: T) -> T;
 
 /// Performs an unchecked division, resulting in undefined behavior
 /// where `y == 0` or `x == T::MIN && y == -1`
@@ -3335,10 +2648,7 @@ pub const unsafe fn exact_div<T: Copy>(_x: T, _y: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unchecked_div<T: Copy>(_x: T, _y: T) -> T {
-    unimplemented!()
-}
+pub const unsafe fn unchecked_div<T: Copy>(_x: T, _y: T) -> T;
 /// Returns the remainder of an unchecked division, resulting in
 /// undefined behavior when `y == 0` or `x == T::MIN && y == -1`
 ///
@@ -3348,10 +2658,7 @@ pub const unsafe fn unchecked_div<T: Copy>(_x: T, _y: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unchecked_rem<T: Copy>(_x: T, _y: T) -> T {
-    unimplemented!()
-}
+pub const unsafe fn unchecked_rem<T: Copy>(_x: T, _y: T) -> T;
 
 /// Performs an unchecked left shift, resulting in undefined behavior when
 /// `y < 0` or `y >= N`, where N is the width of T in bits.
@@ -3362,10 +2669,7 @@ pub const unsafe fn unchecked_rem<T: Copy>(_x: T, _y: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unchecked_shl<T: Copy, U: Copy>(_x: T, _y: U) -> T {
-    unimplemented!()
-}
+pub const unsafe fn unchecked_shl<T: Copy, U: Copy>(_x: T, _y: U) -> T;
 /// Performs an unchecked right shift, resulting in undefined behavior when
 /// `y < 0` or `y >= N`, where N is the width of T in bits.
 ///
@@ -3375,10 +2679,7 @@ pub const unsafe fn unchecked_shl<T: Copy, U: Copy>(_x: T, _y: U) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unchecked_shr<T: Copy, U: Copy>(_x: T, _y: U) -> T {
-    unimplemented!()
-}
+pub const unsafe fn unchecked_shr<T: Copy, U: Copy>(_x: T, _y: U) -> T;
 
 /// Returns the result of an unchecked addition, resulting in
 /// undefined behavior when `x + y > T::MAX` or `x + y < T::MIN`.
@@ -3388,10 +2689,7 @@ pub const unsafe fn unchecked_shr<T: Copy, U: Copy>(_x: T, _y: U) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unchecked_add<T: Copy>(_x: T, _y: T) -> T {
-    unimplemented!()
-}
+pub const unsafe fn unchecked_add<T: Copy>(_x: T, _y: T) -> T;
 
 /// Returns the result of an unchecked subtraction, resulting in
 /// undefined behavior when `x - y > T::MAX` or `x - y < T::MIN`.
@@ -3401,10 +2699,7 @@ pub const unsafe fn unchecked_add<T: Copy>(_x: T, _y: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unchecked_sub<T: Copy>(_x: T, _y: T) -> T {
-    unimplemented!()
-}
+pub const unsafe fn unchecked_sub<T: Copy>(_x: T, _y: T) -> T;
 
 /// Returns the result of an unchecked multiplication, resulting in
 /// undefined behavior when `x * y > T::MAX` or `x * y < T::MIN`.
@@ -3414,10 +2709,7 @@ pub const unsafe fn unchecked_sub<T: Copy>(_x: T, _y: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn unchecked_mul<T: Copy>(_x: T, _y: T) -> T {
-    unimplemented!()
-}
+pub const unsafe fn unchecked_mul<T: Copy>(_x: T, _y: T) -> T;
 
 /// Performs rotate left.
 ///
@@ -3432,10 +2724,7 @@ pub const unsafe fn unchecked_mul<T: Copy>(_x: T, _y: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn rotate_left<T: Copy>(_x: T, _shift: u32) -> T {
-    unimplemented!()
-}
+pub const fn rotate_left<T: Copy>(_x: T, _shift: u32) -> T;
 
 /// Performs rotate right.
 ///
@@ -3450,10 +2739,7 @@ pub const fn rotate_left<T: Copy>(_x: T, _shift: u32) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn rotate_right<T: Copy>(_x: T, _shift: u32) -> T {
-    unimplemented!()
-}
+pub const fn rotate_right<T: Copy>(_x: T, _shift: u32) -> T;
 
 /// Returns (a + b) mod 2<sup>N</sup>, where N is the width of T in bits.
 ///
@@ -3468,10 +2754,7 @@ pub const fn rotate_right<T: Copy>(_x: T, _shift: u32) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn wrapping_add<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub const fn wrapping_add<T: Copy>(_a: T, _b: T) -> T;
 /// Returns (a - b) mod 2<sup>N</sup>, where N is the width of T in bits.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -3485,10 +2768,7 @@ pub const fn wrapping_add<T: Copy>(_a: T, _b: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn wrapping_sub<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub const fn wrapping_sub<T: Copy>(_a: T, _b: T) -> T;
 /// Returns (a * b) mod 2<sup>N</sup>, where N is the width of T in bits.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -3502,10 +2782,7 @@ pub const fn wrapping_sub<T: Copy>(_a: T, _b: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn wrapping_mul<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub const fn wrapping_mul<T: Copy>(_a: T, _b: T) -> T;
 
 /// Computes `a + b`, saturating at numeric bounds.
 ///
@@ -3520,10 +2797,7 @@ pub const fn wrapping_mul<T: Copy>(_a: T, _b: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn saturating_add<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub const fn saturating_add<T: Copy>(_a: T, _b: T) -> T;
 /// Computes `a - b`, saturating at numeric bounds.
 ///
 /// Note that, unlike most intrinsics, this is safe to call;
@@ -3537,10 +2811,7 @@ pub const fn saturating_add<T: Copy>(_a: T, _b: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn saturating_sub<T: Copy>(_a: T, _b: T) -> T {
-    unimplemented!()
-}
+pub const fn saturating_sub<T: Copy>(_a: T, _b: T) -> T;
 
 /// This is an implementation detail of [`crate::ptr::read`] and should
 /// not be used anywhere else.  See its comments for why this exists.
@@ -3551,10 +2822,7 @@ pub const fn saturating_sub<T: Copy>(_a: T, _b: T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn read_via_copy<T>(_ptr: *const T) -> T {
-    unimplemented!()
-}
+pub const unsafe fn read_via_copy<T>(_ptr: *const T) -> T;
 
 /// This is an implementation detail of [`crate::ptr::write`] and should
 /// not be used anywhere else.  See its comments for why this exists.
@@ -3565,10 +2833,7 @@ pub const unsafe fn read_via_copy<T>(_ptr: *const T) -> T {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn write_via_move<T>(_ptr: *mut T, _value: T) {
-    unimplemented!()
-}
+pub const unsafe fn write_via_move<T>(_ptr: *mut T, _value: T);
 
 /// Returns the value of the discriminant for the variant in 'v';
 /// if `T` has no discriminant, returns `0`.
@@ -3582,10 +2847,7 @@ pub const unsafe fn write_via_move<T>(_ptr: *mut T, _value: T) {
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn discriminant_value<T>(_v: &T) -> <T as DiscriminantKind>::Discriminant {
-    unimplemented!()
-}
+pub const fn discriminant_value<T>(_v: &T) -> <T as DiscriminantKind>::Discriminant;
 
 /// Rust's "try catch" construct for unwinding. Invokes the function pointer `try_fn` with the
 /// data pointer `data`, and calls `catch_fn` if unwinding occurs while `try_fn` runs.
@@ -3604,15 +2866,12 @@ pub const fn discriminant_value<T>(_v: &T) -> <T as DiscriminantKind>::Discrimin
 /// For more information, see the compiler's source, as well as the documentation for the stable
 /// version of this intrinsic, `std::panic::catch_unwind`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
 pub unsafe fn catch_unwind(
     _try_fn: fn(*mut u8),
     _data: *mut u8,
     _catch_fn: fn(*mut u8, *mut u8),
-) -> i32 {
-    unreachable!()
-}
+) -> i32;
 
 /// Emits a `nontemporal` store, which gives a hint to the CPU that the data should not be held
 /// in cache. Except for performance, this is fully equivalent to `ptr.write(val)`.
@@ -3621,29 +2880,20 @@ pub unsafe fn catch_unwind(
 /// exists, that operation is *not* equivalent to `ptr.write(val)` (`MOVNT` writes can be reordered
 /// in ways that are not allowed for regular writes).
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn nontemporal_store<T>(_ptr: *mut T, _val: T) {
-    unreachable!()
-}
+pub unsafe fn nontemporal_store<T>(_ptr: *mut T, _val: T);
 
 /// See documentation of `<*const T>::offset_from` for details.
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn ptr_offset_from<T>(_ptr: *const T, _base: *const T) -> isize {
-    unimplemented!()
-}
+pub const unsafe fn ptr_offset_from<T>(_ptr: *const T, _base: *const T) -> isize;
 
 /// See documentation of `<*const T>::sub_ptr` for details.
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_intrinsic_const_stable_indirect]
-pub const unsafe fn ptr_offset_from_unsigned<T>(_ptr: *const T, _base: *const T) -> usize {
-    unimplemented!()
-}
+pub const unsafe fn ptr_offset_from_unsigned<T>(_ptr: *const T, _base: *const T) -> usize;
 
 /// See documentation of `<*const T>::guaranteed_eq` for details.
 /// Returns `2` if the result is unknown.
@@ -3683,10 +2933,7 @@ pub const fn ptr_guaranteed_cmp<T>(ptr: *const T, other: *const T) -> u8 {
 /// which is UB if any of their inputs are `undef`.)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn raw_eq<T>(_a: &T, _b: &T) -> bool {
-    unimplemented!()
-}
+pub const unsafe fn raw_eq<T>(_a: &T, _b: &T) -> bool;
 
 /// Lexicographically compare `[left, left + bytes)` and `[right, right + bytes)`
 /// as unsigned bytes, returning negative if `left` is less, zero if all the
@@ -3704,21 +2951,15 @@ pub const unsafe fn raw_eq<T>(_a: &T, _b: &T) -> bool {
 /// [valid]: crate::ptr#safety
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn compare_bytes(_left: *const u8, _right: *const u8, _bytes: usize) -> i32 {
-    unimplemented!()
-}
+pub const unsafe fn compare_bytes(_left: *const u8, _right: *const u8, _bytes: usize) -> i32;
 
 /// See documentation of [`std::hint::black_box`] for details.
 ///
 /// [`std::hint::black_box`]: crate::hint::black_box
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_intrinsic_const_stable_indirect]
-pub const fn black_box<T>(_dummy: T) -> T {
-    unimplemented!()
-}
+pub const fn black_box<T>(_dummy: T) -> T;
 
 /// Selects which function to call depending on the context.
 ///
@@ -3774,7 +3015,6 @@ pub const fn black_box<T>(_dummy: T) -> T {
 /// otherwise, that principle should not be violated.
 #[rustc_const_unstable(feature = "const_eval_select", issue = "124625")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 pub const fn const_eval_select<ARG: Tuple, F, G, RET>(
     _arg: ARG,
     _called_in_const: F,
@@ -3782,10 +3022,7 @@ pub const fn const_eval_select<ARG: Tuple, F, G, RET>(
 ) -> RET
 where
     G: FnOnce<ARG, Output = RET>,
-    F: FnOnce<ARG, Output = RET>,
-{
-    unreachable!()
-}
+    F: FnOnce<ARG, Output = RET>;
 
 /// A macro to make it easier to invoke const_eval_select. Use as follows:
 /// ```rust,ignore (just a macro example)
@@ -4081,10 +3318,7 @@ pub fn contract_check_ensures<'a, Ret, C: Fn(&'a Ret) -> bool>(ret: &'a Ret, con
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub unsafe fn vtable_size(_ptr: *const ()) -> usize {
-    unreachable!()
-}
+pub unsafe fn vtable_size(_ptr: *const ()) -> usize;
 
 /// The intrinsic will return the alignment stored in that vtable.
 ///
@@ -4094,10 +3328,7 @@ pub unsafe fn vtable_size(_ptr: *const ()) -> usize {
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub unsafe fn vtable_align(_ptr: *const ()) -> usize {
-    unreachable!()
-}
+pub unsafe fn vtable_align(_ptr: *const ()) -> usize;
 
 /// The size of a type in bytes.
 ///
@@ -4114,10 +3345,7 @@ pub unsafe fn vtable_align(_ptr: *const ()) -> usize {
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn size_of<T>() -> usize {
-    unreachable!()
-}
+pub const fn size_of<T>() -> usize;
 
 /// The minimum alignment of a type.
 ///
@@ -4131,10 +3359,7 @@ pub const fn size_of<T>() -> usize {
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn min_align_of<T>() -> usize {
-    unreachable!()
-}
+pub const fn min_align_of<T>() -> usize;
 
 /// The preferred alignment of a type.
 ///
@@ -4143,10 +3368,7 @@ pub const fn min_align_of<T>() -> usize {
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn pref_align_of<T>() -> usize {
-    unreachable!()
-}
+pub const unsafe fn pref_align_of<T>() -> usize;
 
 /// Returns the number of variants of the type `T` cast to a `usize`;
 /// if `T` has no variants, returns `0`. Uninhabited variants will be counted.
@@ -4160,10 +3382,7 @@ pub const unsafe fn pref_align_of<T>() -> usize {
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn variant_count<T>() -> usize {
-    unreachable!()
-}
+pub const fn variant_count<T>() -> usize;
 
 /// The size of the referenced value in bytes.
 ///
@@ -4175,11 +3394,8 @@ pub const fn variant_count<T>() -> usize {
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_intrinsic_const_stable_indirect]
-pub const unsafe fn size_of_val<T: ?Sized>(_ptr: *const T) -> usize {
-    unreachable!()
-}
+pub const unsafe fn size_of_val<T: ?Sized>(_ptr: *const T) -> usize;
 
 /// The required alignment of the referenced value.
 ///
@@ -4191,11 +3407,8 @@ pub const unsafe fn size_of_val<T: ?Sized>(_ptr: *const T) -> usize {
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_intrinsic_const_stable_indirect]
-pub const unsafe fn min_align_of_val<T: ?Sized>(_ptr: *const T) -> usize {
-    unreachable!()
-}
+pub const unsafe fn min_align_of_val<T: ?Sized>(_ptr: *const T) -> usize;
 
 /// Gets a static string slice containing the name of a type.
 ///
@@ -4208,10 +3421,7 @@ pub const unsafe fn min_align_of_val<T: ?Sized>(_ptr: *const T) -> usize {
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn type_name<T: ?Sized>() -> &'static str {
-    unreachable!()
-}
+pub const fn type_name<T: ?Sized>() -> &'static str;
 
 /// Gets an identifier which is globally unique to the specified type. This
 /// function will return the same value for a type regardless of whichever
@@ -4226,10 +3436,7 @@ pub const fn type_name<T: ?Sized>() -> &'static str {
 #[rustc_nounwind]
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn type_id<T: ?Sized + 'static>() -> u128 {
-    unreachable!()
-}
+pub const fn type_id<T: ?Sized + 'static>() -> u128;
 
 /// Lowers in MIR to `Rvalue::Aggregate` with `AggregateKind::RawPtr`.
 ///
@@ -4240,12 +3447,7 @@ pub const fn type_id<T: ?Sized + 'static>() -> u128 {
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn aggregate_raw_ptr<P: AggregateRawPtr<D, Metadata = M>, D, M>(_data: D, _meta: M) -> P {
-    // To implement a fallback we'd have to assume the layout of the pointer,
-    // but the whole point of this intrinsic is that we shouldn't do that.
-    unreachable!()
-}
+pub const fn aggregate_raw_ptr<P: AggregateRawPtr<D, Metadata = M>, D, M>(_data: D, _meta: M) -> P;
 
 #[unstable(feature = "core_intrinsics", issue = "none")]
 pub trait AggregateRawPtr<D> {
@@ -4265,12 +3467,7 @@ impl<P: ?Sized, T: ptr::Thin> AggregateRawPtr<*mut T> for *mut P {
 #[unstable(feature = "core_intrinsics", issue = "none")]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn ptr_metadata<P: ptr::Pointee<Metadata = M> + ?Sized, M>(_ptr: *const P) -> M {
-    // To implement a fallback we'd have to assume the layout of the pointer,
-    // but the whole point of this intrinsic is that we shouldn't do that.
-    unreachable!()
-}
+pub const fn ptr_metadata<P: ptr::Pointee<Metadata = M> + ?Sized, M>(_ptr: *const P) -> M;
 
 // Some functions are defined here because they accidentally got made
 // available in this module on stable. See <https://github.com/rust-lang/rust/issues/15702>.
@@ -4372,10 +3569,7 @@ pub const unsafe fn copy_nonoverlapping<T>(src: *const T, dst: *mut T, count: us
     #[rustc_intrinsic_const_stable_indirect]
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    const unsafe fn copy_nonoverlapping<T>(_src: *const T, _dst: *mut T, _count: usize) {
-        unreachable!()
-    }
+    const unsafe fn copy_nonoverlapping<T>(_src: *const T, _dst: *mut T, _count: usize);
 
     ub_checks::assert_unsafe_precondition!(
         check_language_ub,
@@ -4476,10 +3670,7 @@ pub const unsafe fn copy<T>(src: *const T, dst: *mut T, count: usize) {
     #[rustc_intrinsic_const_stable_indirect]
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    const unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize) {
-        unreachable!()
-    }
+    const unsafe fn copy<T>(_src: *const T, _dst: *mut T, _count: usize);
 
     // SAFETY: the safety contract for `copy` must be upheld by the caller.
     unsafe {
@@ -4559,10 +3750,7 @@ pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize) {
     #[rustc_intrinsic_const_stable_indirect]
     #[rustc_nounwind]
     #[rustc_intrinsic]
-    #[rustc_intrinsic_must_be_overridden]
-    const unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize) {
-        unreachable!()
-    }
+    const unsafe fn write_bytes<T>(_dst: *mut T, _val: u8, _count: usize);
 
     // SAFETY: the safety contract for `write_bytes` must be upheld by the caller.
     unsafe {
@@ -4590,10 +3778,7 @@ pub const unsafe fn write_bytes<T>(dst: *mut T, val: u8, count: usize) {
 /// [`f16::min`]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn minnumf16(_x: f16, _y: f16) -> f16 {
-    unimplemented!();
-}
+pub const fn minnumf16(_x: f16, _y: f16) -> f16;
 
 /// Returns the minimum of two `f32` values.
 ///
@@ -4607,10 +3792,7 @@ pub const fn minnumf16(_x: f16, _y: f16) -> f16 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn minnumf32(_x: f32, _y: f32) -> f32 {
-    unimplemented!();
-}
+pub const fn minnumf32(_x: f32, _y: f32) -> f32;
 
 /// Returns the minimum of two `f64` values.
 ///
@@ -4624,10 +3806,7 @@ pub const fn minnumf32(_x: f32, _y: f32) -> f32 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn minnumf64(_x: f64, _y: f64) -> f64 {
-    unimplemented!();
-}
+pub const fn minnumf64(_x: f64, _y: f64) -> f64;
 
 /// Returns the minimum of two `f128` values.
 ///
@@ -4640,10 +3819,7 @@ pub const fn minnumf64(_x: f64, _y: f64) -> f64 {
 /// [`f128::min`]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn minnumf128(_x: f128, _y: f128) -> f128 {
-    unimplemented!();
-}
+pub const fn minnumf128(_x: f128, _y: f128) -> f128;
 
 /// Returns the maximum of two `f16` values.
 ///
@@ -4656,10 +3832,7 @@ pub const fn minnumf128(_x: f128, _y: f128) -> f128 {
 /// [`f16::max`]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn maxnumf16(_x: f16, _y: f16) -> f16 {
-    unimplemented!();
-}
+pub const fn maxnumf16(_x: f16, _y: f16) -> f16;
 
 /// Returns the maximum of two `f32` values.
 ///
@@ -4673,10 +3846,7 @@ pub const fn maxnumf16(_x: f16, _y: f16) -> f16 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn maxnumf32(_x: f32, _y: f32) -> f32 {
-    unimplemented!();
-}
+pub const fn maxnumf32(_x: f32, _y: f32) -> f32;
 
 /// Returns the maximum of two `f64` values.
 ///
@@ -4690,10 +3860,7 @@ pub const fn maxnumf32(_x: f32, _y: f32) -> f32 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn maxnumf64(_x: f64, _y: f64) -> f64 {
-    unimplemented!();
-}
+pub const fn maxnumf64(_x: f64, _y: f64) -> f64;
 
 /// Returns the maximum of two `f128` values.
 ///
@@ -4706,10 +3873,7 @@ pub const fn maxnumf64(_x: f64, _y: f64) -> f64 {
 /// [`f128::max`]
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const fn maxnumf128(_x: f128, _y: f128) -> f128 {
-    unimplemented!();
-}
+pub const fn maxnumf128(_x: f128, _y: f128) -> f128;
 
 /// Returns the absolute value of an `f16`.
 ///
@@ -4717,10 +3881,7 @@ pub const fn maxnumf128(_x: f128, _y: f128) -> f128 {
 /// [`f16::abs`](../../std/primitive.f16.html#method.abs)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn fabsf16(_x: f16) -> f16 {
-    unimplemented!();
-}
+pub const unsafe fn fabsf16(_x: f16) -> f16;
 
 /// Returns the absolute value of an `f32`.
 ///
@@ -4729,10 +3890,7 @@ pub const unsafe fn fabsf16(_x: f16) -> f16 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn fabsf32(_x: f32) -> f32 {
-    unimplemented!();
-}
+pub const unsafe fn fabsf32(_x: f32) -> f32;
 
 /// Returns the absolute value of an `f64`.
 ///
@@ -4741,10 +3899,7 @@ pub const unsafe fn fabsf32(_x: f32) -> f32 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn fabsf64(_x: f64) -> f64 {
-    unimplemented!();
-}
+pub const unsafe fn fabsf64(_x: f64) -> f64;
 
 /// Returns the absolute value of an `f128`.
 ///
@@ -4752,10 +3907,7 @@ pub const unsafe fn fabsf64(_x: f64) -> f64 {
 /// [`f128::abs`](../../std/primitive.f128.html#method.abs)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn fabsf128(_x: f128) -> f128 {
-    unimplemented!();
-}
+pub const unsafe fn fabsf128(_x: f128) -> f128;
 
 /// Copies the sign from `y` to `x` for `f16` values.
 ///
@@ -4763,10 +3915,7 @@ pub const unsafe fn fabsf128(_x: f128) -> f128 {
 /// [`f16::copysign`](../../std/primitive.f16.html#method.copysign)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn copysignf16(_x: f16, _y: f16) -> f16 {
-    unimplemented!();
-}
+pub const unsafe fn copysignf16(_x: f16, _y: f16) -> f16;
 
 /// Copies the sign from `y` to `x` for `f32` values.
 ///
@@ -4775,10 +3924,7 @@ pub const unsafe fn copysignf16(_x: f16, _y: f16) -> f16 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn copysignf32(_x: f32, _y: f32) -> f32 {
-    unimplemented!();
-}
+pub const unsafe fn copysignf32(_x: f32, _y: f32) -> f32;
 /// Copies the sign from `y` to `x` for `f64` values.
 ///
 /// The stabilized version of this intrinsic is
@@ -4786,10 +3932,7 @@ pub const unsafe fn copysignf32(_x: f32, _y: f32) -> f32 {
 #[rustc_nounwind]
 #[rustc_intrinsic_const_stable_indirect]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn copysignf64(_x: f64, _y: f64) -> f64 {
-    unimplemented!();
-}
+pub const unsafe fn copysignf64(_x: f64, _y: f64) -> f64;
 
 /// Copies the sign from `y` to `x` for `f128` values.
 ///
@@ -4797,10 +3940,7 @@ pub const unsafe fn copysignf64(_x: f64, _y: f64) -> f64 {
 /// [`f128::copysign`](../../std/primitive.f128.html#method.copysign)
 #[rustc_nounwind]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn copysignf128(_x: f128, _y: f128) -> f128 {
-    unimplemented!();
-}
+pub const unsafe fn copysignf128(_x: f128, _y: f128) -> f128;
 
 /// Inform Miri that a given pointer definitely has a certain alignment.
 #[cfg(miri)]
diff --git a/library/core/src/intrinsics/simd.rs b/library/core/src/intrinsics/simd.rs
index e59d3aff3799..935dd2e56731 100644
--- a/library/core/src/intrinsics/simd.rs
+++ b/library/core/src/intrinsics/simd.rs
@@ -10,11 +10,8 @@
 ///
 /// `idx` must be in-bounds of the vector.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_insert<T, U>(_x: T, _idx: u32, _val: U) -> T {
-    unreachable!()
-}
+pub const unsafe fn simd_insert<T, U>(_x: T, _idx: u32, _val: U) -> T;
 
 /// Extracts an element from a vector.
 ///
@@ -24,89 +21,68 @@ pub unsafe fn simd_insert<T, U>(_x: T, _idx: u32, _val: U) -> T {
 ///
 /// `idx` must be in-bounds of the vector.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_extract<T, U>(_x: T, _idx: u32) -> U {
-    unreachable!()
-}
+pub const unsafe fn simd_extract<T, U>(_x: T, _idx: u32) -> U;
 
 /// Adds two simd vectors elementwise.
 ///
-/// `T` must be a vector of integer or floating point primitive types.
+/// `T` must be a vector of integers or floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_add<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_add<T>(_x: T, _y: T) -> T;
 
 /// Subtracts `rhs` from `lhs` elementwise.
 ///
-/// `T` must be a vector of integer or floating point primitive types.
+/// `T` must be a vector of integers or floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_sub<T>(_lhs: T, _rhs: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_sub<T>(_lhs: T, _rhs: T) -> T;
 
 /// Multiplies two simd vectors elementwise.
 ///
-/// `T` must be a vector of integer or floating point primitive types.
+/// `T` must be a vector of integers or floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_mul<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_mul<T>(_x: T, _y: T) -> T;
 
 /// Divides `lhs` by `rhs` elementwise.
 ///
-/// `T` must be a vector of integer or floating point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// # Safety
 /// For integers, `rhs` must not contain any zero elements.
 /// Additionally for signed integers, `<int>::MIN / -1` is undefined behavior.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_div<T>(_lhs: T, _rhs: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_div<T>(_lhs: T, _rhs: T) -> T;
 
 /// Returns remainder of two vectors elementwise.
 ///
-/// `T` must be a vector of integer or floating point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// # Safety
 /// For integers, `rhs` must not contain any zero elements.
 /// Additionally for signed integers, `<int>::MIN / -1` is undefined behavior.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_rem<T>(_lhs: T, _rhs: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_rem<T>(_lhs: T, _rhs: T) -> T;
 
 /// Shifts vector left elementwise, with UB on overflow.
 ///
 /// Shifts `lhs` left by `rhs`, shifting in sign bits for signed types.
 ///
-/// `T` must be a vector of integer primitive types.
+/// `T` must be a vector of integers.
 ///
 /// # Safety
 ///
 /// Each element of `rhs` must be less than `<int>::BITS`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_shl<T>(_lhs: T, _rhs: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_shl<T>(_lhs: T, _rhs: T) -> T;
 
 /// Shifts vector right elementwise, with UB on overflow.
 ///
-/// `T` must be a vector of integer primitive types.
+/// `T` must be a vector of integers.
 ///
 /// Shifts `lhs` right by `rhs`, shifting in sign bits for signed types.
 ///
@@ -114,46 +90,33 @@ pub unsafe fn simd_shl<T>(_lhs: T, _rhs: T) -> T {
 ///
 /// Each element of `rhs` must be less than `<int>::BITS`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_shr<T>(_lhs: T, _rhs: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_shr<T>(_lhs: T, _rhs: T) -> T;
 
 /// "Ands" vectors elementwise.
 ///
-/// `T` must be a vector of integer primitive types.
+/// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_and<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_and<T>(_x: T, _y: T) -> T;
 
 /// "Ors" vectors elementwise.
 ///
-/// `T` must be a vector of integer primitive types.
+/// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_or<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_or<T>(_x: T, _y: T) -> T;
 
 /// "Exclusive ors" vectors elementwise.
 ///
-/// `T` must be a vector of integer primitive types.
+/// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_xor<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_xor<T>(_x: T, _y: T) -> T;
 
 /// Numerically casts a vector, elementwise.
 ///
-/// `T` and `U` must be vectors of integer or floating point primitive types, and must have the
-/// same length.
+/// `T` and `U` must be vectors of integers or floats, and must have the same length.
 ///
 /// When casting floats to integers, the result is truncated. Out-of-bounds result lead to UB.
 /// When casting integers to floats, the result is rounded.
@@ -169,16 +132,12 @@ pub unsafe fn simd_xor<T>(_x: T, _y: T) -> T {
 /// * Not be infinite
 /// * Be representable in the return type, after truncating off its fractional part
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_cast<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_cast<T, U>(_x: T) -> U;
 
 /// Numerically casts a vector, elementwise.
 ///
-/// `T` and `U` be a vectors of integer or floating point primitive types, and must have the
-/// same length.
+/// `T` and `U` be a vectors of integers or floats, and must have the same length.
 ///
 /// Like `simd_cast`, but saturates float-to-integer conversions (NaN becomes 0).
 /// This matches regular `as` and is always safe.
@@ -187,33 +146,24 @@ pub unsafe fn simd_cast<T, U>(_x: T) -> U {
 /// When casting integers to floats, the result is rounded.
 /// Otherwise, truncates or extends the value, maintaining the sign for signed integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_as<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_as<T, U>(_x: T) -> U;
 
 /// Negates a vector elementwise.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// Rust panics for `-<int>::Min` due to overflow, but it is not UB with this intrinsic.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_neg<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_neg<T>(_x: T) -> T;
 
 /// Returns absolute value of a vector, elementwise.
 ///
 /// `T` must be a vector of floating-point primitive types.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fabs<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fabs<T>(_x: T) -> T;
 
 /// Returns the minimum of two vectors, elementwise.
 ///
@@ -221,11 +171,8 @@ pub unsafe fn simd_fabs<T>(_x: T) -> T {
 ///
 /// Follows IEEE-754 `minNum` semantics.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fmin<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fmin<T>(_x: T, _y: T) -> T;
 
 /// Returns the maximum of two vectors, elementwise.
 ///
@@ -233,95 +180,74 @@ pub unsafe fn simd_fmin<T>(_x: T, _y: T) -> T {
 ///
 /// Follows IEEE-754 `maxNum` semantics.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fmax<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fmax<T>(_x: T, _y: T) -> T;
 
 /// Tests elementwise equality of two vectors.
 ///
-/// `T` must be a vector of floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be a vector of integers with the same number of elements and element size as `T`.
 ///
 /// Returns `0` for false and `!0` for true.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_eq<T, U>(_x: T, _y: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_eq<T, U>(_x: T, _y: T) -> U;
 
 /// Tests elementwise inequality equality of two vectors.
 ///
-/// `T` must be a vector of floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be a vector of integers with the same number of elements and element size as `T`.
 ///
 /// Returns `0` for false and `!0` for true.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_ne<T, U>(_x: T, _y: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_ne<T, U>(_x: T, _y: T) -> U;
 
 /// Tests if `x` is less than `y`, elementwise.
 ///
-/// `T` must be a vector of floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be a vector of integers with the same number of elements and element size as `T`.
 ///
 /// Returns `0` for false and `!0` for true.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_lt<T, U>(_x: T, _y: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_lt<T, U>(_x: T, _y: T) -> U;
 
 /// Tests if `x` is less than or equal to `y`, elementwise.
 ///
-/// `T` must be a vector of floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be a vector of integers with the same number of elements and element size as `T`.
 ///
 /// Returns `0` for false and `!0` for true.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_le<T, U>(_x: T, _y: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_le<T, U>(_x: T, _y: T) -> U;
 
 /// Tests if `x` is greater than `y`, elementwise.
 ///
-/// `T` must be a vector of floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be a vector of integers with the same number of elements and element size as `T`.
 ///
 /// Returns `0` for false and `!0` for true.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_gt<T, U>(_x: T, _y: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_gt<T, U>(_x: T, _y: T) -> U;
 
 /// Tests if `x` is greater than or equal to `y`, elementwise.
 ///
-/// `T` must be a vector of floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be a vector of integers with the same number of elements and element size as `T`.
 ///
 /// Returns `0` for false and `!0` for true.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_ge<T, U>(_x: T, _y: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_ge<T, U>(_x: T, _y: T) -> U;
 
 /// Shuffles two vectors by const indices.
 ///
@@ -336,11 +262,8 @@ pub unsafe fn simd_ge<T, U>(_x: T, _y: T) -> U {
 /// is the concatenation of `x` and `y`. It is a compile-time error if `idx[i]` is out-of-bounds
 /// of `xy`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_shuffle<T, U, V>(_x: T, _y: T, _idx: U) -> V {
-    unreachable!()
-}
+pub unsafe fn simd_shuffle<T, U, V>(_x: T, _y: T, _idx: U) -> V;
 
 /// Reads a vector of pointers.
 ///
@@ -348,7 +271,7 @@ pub unsafe fn simd_shuffle<T, U, V>(_x: T, _y: T, _idx: U) -> V {
 ///
 /// `U` must be a vector of pointers to the element type of `T`, with the same length as `T`.
 ///
-/// `V` must be a vector of integers with the same length as `T` (but any element size).
+/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
 ///
 /// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, read the pointer.
 /// Otherwise if the corresponding value in `mask` is `0`, return the corresponding value from
@@ -360,11 +283,8 @@ pub unsafe fn simd_shuffle<T, U, V>(_x: T, _y: T, _idx: U) -> V {
 ///
 /// `mask` must only contain `0` or `!0` values.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_gather<T, U, V>(_val: T, _ptr: U, _mask: V) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_gather<T, U, V>(_val: T, _ptr: U, _mask: V) -> T;
 
 /// Writes to a vector of pointers.
 ///
@@ -372,7 +292,7 @@ pub unsafe fn simd_gather<T, U, V>(_val: T, _ptr: U, _mask: V) -> T {
 ///
 /// `U` must be a vector of pointers to the element type of `T`, with the same length as `T`.
 ///
-/// `V` must be a vector of integers with the same length as `T` (but any element size).
+/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
 ///
 /// For each pointer in `ptr`, if the corresponding value in `mask` is `!0`, write the
 /// corresponding value in `val` to the pointer.
@@ -387,11 +307,8 @@ pub unsafe fn simd_gather<T, U, V>(_val: T, _ptr: U, _mask: V) -> T {
 ///
 /// `mask` must only contain `0` or `!0` values.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_scatter<T, U, V>(_val: T, _ptr: U, _mask: V) {
-    unreachable!()
-}
+pub unsafe fn simd_scatter<T, U, V>(_val: T, _ptr: U, _mask: V);
 
 /// Reads a vector of pointers.
 ///
@@ -399,7 +316,7 @@ pub unsafe fn simd_scatter<T, U, V>(_val: T, _ptr: U, _mask: V) {
 ///
 /// `U` must be a pointer to the element type of `T`
 ///
-/// `V` must be a vector of integers with the same length as `T` (but any element size).
+/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
 ///
 /// For each element, if the corresponding value in `mask` is `!0`, read the corresponding
 /// pointer offset from `ptr`.
@@ -413,11 +330,8 @@ pub unsafe fn simd_scatter<T, U, V>(_val: T, _ptr: U, _mask: V) {
 ///
 /// `mask` must only contain `0` or `!0` values.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_masked_load<V, U, T>(_mask: V, _ptr: U, _val: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_masked_load<V, U, T>(_mask: V, _ptr: U, _val: T) -> T;
 
 /// Writes to a vector of pointers.
 ///
@@ -425,7 +339,7 @@ pub unsafe fn simd_masked_load<V, U, T>(_mask: V, _ptr: U, _val: T) -> T {
 ///
 /// `U` must be a pointer to the element type of `T`
 ///
-/// `V` must be a vector of integers with the same length as `T` (but any element size).
+/// `V` must be a vector of signed integers with the same length as `T` (but any element size).
 ///
 /// For each element, if the corresponding value in `mask` is `!0`, write the corresponding
 /// value in `val` to the pointer offset from `ptr`.
@@ -438,21 +352,15 @@ pub unsafe fn simd_masked_load<V, U, T>(_mask: V, _ptr: U, _val: T) -> T {
 ///
 /// `mask` must only contain `0` or `!0` values.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_masked_store<V, U, T>(_mask: V, _ptr: U, _val: T) {
-    unreachable!()
-}
+pub unsafe fn simd_masked_store<V, U, T>(_mask: V, _ptr: U, _val: T);
 
 /// Adds two simd vectors elementwise, with saturation.
 ///
 /// `T` must be a vector of integer primitive types.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_saturating_add<T>(_x: T, _y: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_saturating_add<T>(_x: T, _y: T) -> T;
 
 /// Subtracts two simd vectors elementwise, with saturation.
 ///
@@ -460,65 +368,50 @@ pub unsafe fn simd_saturating_add<T>(_x: T, _y: T) -> T {
 ///
 /// Subtract `rhs` from `lhs`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_saturating_sub<T>(_lhs: T, _rhs: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_saturating_sub<T>(_lhs: T, _rhs: T) -> T;
 
 /// Adds elements within a vector from left to right.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 ///
 /// Starting with the value `y`, add the elements of `x` and accumulate.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_add_ordered<T, U>(_x: T, _y: U) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_add_ordered<T, U>(_x: T, _y: U) -> U;
 
 /// Adds elements within a vector in arbitrary order. May also be re-associated with
 /// unordered additions on the inputs/outputs.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_add_unordered<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_add_unordered<T, U>(_x: T) -> U;
 
 /// Multiplies elements within a vector from left to right.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 ///
 /// Starting with the value `y`, multiply the elements of `x` and accumulate.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_mul_ordered<T, U>(_x: T, _y: U) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_mul_ordered<T, U>(_x: T, _y: U) -> U;
 
 /// Multiplies elements within a vector in arbitrary order. May also be re-associated with
 /// unordered additions on the inputs/outputs.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_mul_unordered<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_mul_unordered<T, U>(_x: T) -> U;
 
 /// Checks if all mask values are true.
 ///
@@ -527,11 +420,8 @@ pub unsafe fn simd_reduce_mul_unordered<T, U>(_x: T) -> U {
 /// # Safety
 /// `x` must contain only `0` or `!0`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_all<T>(_x: T) -> bool {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_all<T>(_x: T) -> bool;
 
 /// Checks if any mask value is true.
 ///
@@ -540,75 +430,57 @@ pub unsafe fn simd_reduce_all<T>(_x: T) -> bool {
 /// # Safety
 /// `x` must contain only `0` or `!0`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_any<T>(_x: T) -> bool {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_any<T>(_x: T) -> bool;
 
 /// Returns the maximum element of a vector.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 ///
 /// For floating-point values, uses IEEE-754 `maxNum`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_max<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_max<T, U>(_x: T) -> U;
 
 /// Returns the minimum element of a vector.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 ///
 /// For floating-point values, uses IEEE-754 `minNum`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_min<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_min<T, U>(_x: T) -> U;
 
 /// Logical "ands" all elements together.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_and<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_and<T, U>(_x: T) -> U;
 
 /// Logical "ors" all elements together.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_or<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_or<T, U>(_x: T) -> U;
 
 /// Logical "exclusive ors" all elements together.
 ///
-/// `T` must be a vector of integer or floating-point primitive types.
+/// `T` must be a vector of integers or floats.
 ///
 /// `U` must be the element type of `T`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_reduce_xor<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_reduce_xor<T, U>(_x: T) -> U;
 
 /// Truncates an integer vector to a bitmask.
 ///
@@ -644,17 +516,14 @@ pub unsafe fn simd_reduce_xor<T, U>(_x: T) -> U {
 /// # Safety
 /// `x` must contain only `0` and `!0`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_bitmask<T, U>(_x: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_bitmask<T, U>(_x: T) -> U;
 
 /// Selects elements from a mask.
 ///
-/// `M` must be an integer vector.
+/// `T` must be a vector.
 ///
-/// `T` must be a vector with the same number of elements as `M`.
+/// `M` must be a signed integer vector with the same length as `T` (but any element size).
 ///
 /// For each element, if the corresponding value in `mask` is `!0`, select the element from
 /// `if_true`.  If the corresponding value in `mask` is `0`, select the element from
@@ -663,11 +532,8 @@ pub unsafe fn simd_bitmask<T, U>(_x: T) -> U {
 /// # Safety
 /// `mask` must only contain `0` and `!0`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_select<M, T>(_mask: M, _if_true: T, _if_false: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_select<M, T>(_mask: M, _if_true: T, _if_false: T) -> T;
 
 /// Selects elements from a bitmask.
 ///
@@ -684,11 +550,8 @@ pub unsafe fn simd_select<M, T>(_mask: M, _if_true: T, _if_false: T) -> T {
 /// # Safety
 /// Padding bits must be all zero.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_select_bitmask<M, T>(_m: M, _yes: T, _no: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_select_bitmask<M, T>(_m: M, _yes: T, _no: T) -> T;
 
 /// Calculates the offset from a pointer vector elementwise, potentially
 /// wrapping.
@@ -699,21 +562,15 @@ pub unsafe fn simd_select_bitmask<M, T>(_m: M, _yes: T, _no: T) -> T {
 ///
 /// Operates as if by `<ptr>::wrapping_offset`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_arith_offset<T, U>(_ptr: T, _offset: U) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_arith_offset<T, U>(_ptr: T, _offset: U) -> T;
 
 /// Casts a vector of pointers.
 ///
 /// `T` and `U` must be vectors of pointers with the same number of elements.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_cast_ptr<T, U>(_ptr: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_cast_ptr<T, U>(_ptr: T) -> U;
 
 /// Exposes a vector of pointers as a vector of addresses.
 ///
@@ -721,11 +578,8 @@ pub unsafe fn simd_cast_ptr<T, U>(_ptr: T) -> U {
 ///
 /// `U` must be a vector of `usize` with the same length as `T`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_expose_provenance<T, U>(_ptr: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_expose_provenance<T, U>(_ptr: T) -> U;
 
 /// Creates a vector of pointers from a vector of addresses.
 ///
@@ -733,123 +587,87 @@ pub unsafe fn simd_expose_provenance<T, U>(_ptr: T) -> U {
 ///
 /// `U` must be a vector of pointers, with the same length as `T`.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_with_exposed_provenance<T, U>(_addr: T) -> U {
-    unreachable!()
-}
+pub unsafe fn simd_with_exposed_provenance<T, U>(_addr: T) -> U;
 
 /// Swaps bytes of each element.
 ///
 /// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_bswap<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_bswap<T>(_x: T) -> T;
 
 /// Reverses bits of each element.
 ///
 /// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_bitreverse<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_bitreverse<T>(_x: T) -> T;
 
 /// Counts the leading zeros of each element.
 ///
 /// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_ctlz<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_ctlz<T>(_x: T) -> T;
 
 /// Counts the number of ones in each element.
 ///
 /// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_ctpop<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_ctpop<T>(_x: T) -> T;
 
 /// Counts the trailing zeros of each element.
 ///
 /// `T` must be a vector of integers.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_cttz<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_cttz<T>(_x: T) -> T;
 
 /// Rounds up each element to the next highest integer-valued float.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_ceil<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_ceil<T>(_x: T) -> T;
 
 /// Rounds down each element to the next lowest integer-valued float.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_floor<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_floor<T>(_x: T) -> T;
 
 /// Rounds each element to the closest integer-valued float.
 /// Ties are resolved by rounding away from 0.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_round<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_round<T>(_x: T) -> T;
 
 /// Returns the integer part of each element as an integer-valued float.
 /// In other words, non-integer values are truncated towards zero.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_trunc<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_trunc<T>(_x: T) -> T;
 
 /// Takes the square root of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fsqrt<T>(_x: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fsqrt<T>(_x: T) -> T;
 
 /// Computes `(x*y) + z` for each element, but without any intermediate rounding.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fma<T>(_x: T, _y: T, _z: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fma<T>(_x: T, _y: T, _z: T) -> T;
 
 /// Computes `(x*y) + z` for each element, non-deterministically executing either
 /// a fused multiply-add or two operations with rounding of the intermediate result.
@@ -863,78 +681,54 @@ pub unsafe fn simd_fma<T>(_x: T, _y: T, _z: T) -> T {
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_relaxed_fma<T>(_x: T, _y: T, _z: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_relaxed_fma<T>(_x: T, _y: T, _z: T) -> T;
 
 // Computes the sine of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fsin<T>(_a: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fsin<T>(_a: T) -> T;
 
 // Computes the cosine of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fcos<T>(_a: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fcos<T>(_a: T) -> T;
 
 // Computes the exponential function of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fexp<T>(_a: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fexp<T>(_a: T) -> T;
 
 // Computes 2 raised to the power of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_fexp2<T>(_a: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_fexp2<T>(_a: T) -> T;
 
 // Computes the base 10 logarithm of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_flog10<T>(_a: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_flog10<T>(_a: T) -> T;
 
 // Computes the base 2 logarithm of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_flog2<T>(_a: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_flog2<T>(_a: T) -> T;
 
 // Computes the natural logarithm of each element.
 ///
 /// `T` must be a vector of floats.
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
 #[rustc_nounwind]
-pub unsafe fn simd_flog<T>(_a: T) -> T {
-    unreachable!()
-}
+pub unsafe fn simd_flog<T>(_a: T) -> T;
diff --git a/library/core/src/marker.rs b/library/core/src/marker.rs
index 842a48e1606d..b0571bf7247a 100644
--- a/library/core/src/marker.rs
+++ b/library/core/src/marker.rs
@@ -1302,6 +1302,7 @@ pub trait FnPtr: Copy + Clone {
 /// ```
 #[rustc_builtin_macro(CoercePointee, attributes(pointee))]
 #[allow_internal_unstable(dispatch_from_dyn, coerce_unsized, unsize, coerce_pointee_validated)]
+#[cfg_attr(not(test), rustc_diagnostic_item = "CoercePointee")]
 #[unstable(feature = "derive_coerce_pointee", issue = "123430")]
 pub macro CoercePointee($item:item) {
     /* compiler built-in */
diff --git a/library/core/src/mem/maybe_uninit.rs b/library/core/src/mem/maybe_uninit.rs
index edc39f8f28cf..067371c1b58a 100644
--- a/library/core/src/mem/maybe_uninit.rs
+++ b/library/core/src/mem/maybe_uninit.rs
@@ -331,42 +331,6 @@ impl<T> MaybeUninit<T> {
         MaybeUninit { uninit: () }
     }
 
-    /// Creates a new array of `MaybeUninit<T>` items, in an uninitialized state.
-    ///
-    /// Note: in a future Rust version this method may become unnecessary
-    /// when Rust allows
-    /// [inline const expressions](https://github.com/rust-lang/rust/issues/76001).
-    /// The example below could then use `let mut buf = [const { MaybeUninit::<u8>::uninit() }; 32];`.
-    ///
-    /// # Examples
-    ///
-    /// ```no_run
-    /// #![feature(maybe_uninit_uninit_array, maybe_uninit_slice)]
-    ///
-    /// use std::mem::MaybeUninit;
-    ///
-    /// unsafe extern "C" {
-    ///     fn read_into_buffer(ptr: *mut u8, max_len: usize) -> usize;
-    /// }
-    ///
-    /// /// Returns a (possibly smaller) slice of data that was actually read
-    /// fn read(buf: &mut [MaybeUninit<u8>]) -> &[u8] {
-    ///     unsafe {
-    ///         let len = read_into_buffer(buf.as_mut_ptr() as *mut u8, buf.len());
-    ///         buf[..len].assume_init_ref()
-    ///     }
-    /// }
-    ///
-    /// let mut buf: [MaybeUninit<u8>; 32] = MaybeUninit::uninit_array();
-    /// let data = read(&mut buf);
-    /// ```
-    #[unstable(feature = "maybe_uninit_uninit_array", issue = "96097")]
-    #[must_use]
-    #[inline(always)]
-    pub const fn uninit_array<const N: usize>() -> [Self; N] {
-        [const { MaybeUninit::uninit() }; N]
-    }
-
     /// Creates a new `MaybeUninit<T>` in an uninitialized state, with the memory being
     /// filled with `0` bytes. It depends on `T` whether that already makes for
     /// proper initialization. For example, `MaybeUninit<usize>::zeroed()` is initialized,
@@ -1041,7 +1005,6 @@ impl<T> MaybeUninit<T> {
 
     /// Deprecated version of [`slice::assume_init_ref`].
     #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
-    #[rustc_const_unstable(feature = "maybe_uninit_slice", issue = "63569")]
     #[deprecated(
         note = "replaced by inherent assume_init_ref method; will eventually be removed",
         since = "1.83.0"
@@ -1053,7 +1016,6 @@ impl<T> MaybeUninit<T> {
 
     /// Deprecated version of [`slice::assume_init_mut`].
     #[unstable(feature = "maybe_uninit_slice", issue = "63569")]
-    #[rustc_const_unstable(feature = "maybe_uninit_slice", issue = "63569")]
     #[deprecated(
         note = "replaced by inherent assume_init_mut method; will eventually be removed",
         since = "1.83.0"
@@ -1326,7 +1288,6 @@ impl<T> [MaybeUninit<T>] {
     ///
     /// [`write_clone_of_slice`]: slice::write_clone_of_slice
     #[unstable(feature = "maybe_uninit_write_slice", issue = "79995")]
-    #[rustc_const_unstable(feature = "maybe_uninit_write_slice", issue = "79995")]
     pub const fn write_copy_of_slice(&mut self, src: &[T]) -> &mut [T]
     where
         T: Copy,
diff --git a/library/core/src/num/int_macros.rs b/library/core/src/num/int_macros.rs
index 74221e216875..7d99aaa17314 100644
--- a/library/core/src/num/int_macros.rs
+++ b/library/core/src/num/int_macros.rs
@@ -1352,11 +1352,11 @@ macro_rules! int_impl {
         ///
         /// Basic usage:
         /// ```
-        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
         /// ```
-        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1474,12 +1474,12 @@ macro_rules! int_impl {
         ///
         /// Basic usage:
         /// ```
-        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x1);")]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         #[doc = concat!("assert_eq!(", stringify!($SelfT), "::MIN.unbounded_shr(129), -1);")]
         /// ```
-        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
diff --git a/library/core/src/num/uint_macros.rs b/library/core/src/num/uint_macros.rs
index 2682273b7f18..405c71121caa 100644
--- a/library/core/src/num/uint_macros.rs
+++ b/library/core/src/num/uint_macros.rs
@@ -1613,11 +1613,11 @@ macro_rules! uint_impl {
         ///
         /// Basic usage:
         /// ```
-        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(4), 0x10);")]
         #[doc = concat!("assert_eq!(0x1", stringify!($SelfT), ".unbounded_shl(129), 0);")]
         /// ```
-        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
@@ -1734,11 +1734,11 @@ macro_rules! uint_impl {
         ///
         /// Basic usage:
         /// ```
-        /// #![feature(unbounded_shifts)]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(4), 0x1);")]
         #[doc = concat!("assert_eq!(0x10", stringify!($SelfT), ".unbounded_shr(129), 0);")]
         /// ```
-        #[unstable(feature = "unbounded_shifts", issue = "129375")]
+        #[stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
+        #[rustc_const_stable(feature = "unbounded_shifts", since = "CURRENT_RUSTC_VERSION")]
         #[must_use = "this returns the result of the operation, \
                       without modifying the original"]
         #[inline]
diff --git a/library/core/src/ops/arith.rs b/library/core/src/ops/arith.rs
index fe7ff2d9ede6..54d79beca95a 100644
--- a/library/core/src/ops/arith.rs
+++ b/library/core/src/ops/arith.rs
@@ -96,6 +96,7 @@ pub trait Add<Rhs = Self> {
 macro_rules! add_impl {
     ($($t:ty)*) => ($(
         #[stable(feature = "rust1", since = "1.0.0")]
+        #[rustc_const_unstable(feature = "const_ops", issue = "90080")]
         impl const Add for $t {
             type Output = $t;
 
diff --git a/library/core/src/ops/control_flow.rs b/library/core/src/ops/control_flow.rs
index c8fcee5c140f..8993e14fcd37 100644
--- a/library/core/src/ops/control_flow.rs
+++ b/library/core/src/ops/control_flow.rs
@@ -229,6 +229,27 @@ impl<B, C> ControlFlow<B, C> {
     }
 }
 
+impl<T> ControlFlow<T, T> {
+    /// Extracts the value `T` that is wrapped by `ControlFlow<T, T>`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(control_flow_into_value)]
+    /// use std::ops::ControlFlow;
+    ///
+    /// assert_eq!(ControlFlow::<i32, i32>::Break(1024).into_value(), 1024);
+    /// assert_eq!(ControlFlow::<i32, i32>::Continue(512).into_value(), 512);
+    /// ```
+    #[unstable(feature = "control_flow_into_value", issue = "137461")]
+    #[rustc_allow_const_fn_unstable(const_precise_live_drops)]
+    pub const fn into_value(self) -> T {
+        match self {
+            ControlFlow::Continue(x) | ControlFlow::Break(x) => x,
+        }
+    }
+}
+
 /// These are used only as part of implementing the iterator adapters.
 /// They have mediocre names and non-obvious semantics, so aren't
 /// currently on a path to potential stabilization.
diff --git a/library/core/src/ops/deref.rs b/library/core/src/ops/deref.rs
index 11490ea2bfcb..e74f5443ac2d 100644
--- a/library/core/src/ops/deref.rs
+++ b/library/core/src/ops/deref.rs
@@ -150,6 +150,7 @@ pub trait Deref {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
 impl<T: ?Sized> const Deref for &T {
     type Target = T;
 
@@ -163,6 +164,7 @@ impl<T: ?Sized> const Deref for &T {
 impl<T: ?Sized> !DerefMut for &T {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
 impl<T: ?Sized> const Deref for &mut T {
     type Target = T;
 
@@ -273,6 +275,7 @@ pub trait DerefMut: ~const Deref {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
+#[rustc_const_unstable(feature = "const_deref", issue = "88955")]
 impl<T: ?Sized> const DerefMut for &mut T {
     fn deref_mut(&mut self) -> &mut T {
         *self
diff --git a/library/core/src/ops/range.rs b/library/core/src/ops/range.rs
index 5580faefacc0..e0c442e52921 100644
--- a/library/core/src/ops/range.rs
+++ b/library/core/src/ops/range.rs
@@ -771,13 +771,11 @@ pub trait RangeBounds<T: ?Sized> {
     /// # Examples
     ///
     /// ```
-    /// # fn main() {
     /// use std::ops::Bound::*;
     /// use std::ops::RangeBounds;
     ///
     /// assert_eq!((..10).start_bound(), Unbounded);
     /// assert_eq!((3..10).start_bound(), Included(&3));
-    /// # }
     /// ```
     #[stable(feature = "collections_range", since = "1.28.0")]
     fn start_bound(&self) -> Bound<&T>;
@@ -789,13 +787,11 @@ pub trait RangeBounds<T: ?Sized> {
     /// # Examples
     ///
     /// ```
-    /// # fn main() {
     /// use std::ops::Bound::*;
     /// use std::ops::RangeBounds;
     ///
     /// assert_eq!((3..).end_bound(), Unbounded);
     /// assert_eq!((3..10).end_bound(), Excluded(&10));
-    /// # }
     /// ```
     #[stable(feature = "collections_range", since = "1.28.0")]
     fn end_bound(&self) -> Bound<&T>;
@@ -829,6 +825,71 @@ pub trait RangeBounds<T: ?Sized> {
             Unbounded => true,
         })
     }
+
+    /// Returns `true` if the range contains no items.
+    /// One-sided ranges (`RangeFrom`, etc) always return `true`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(range_bounds_is_empty)]
+    /// use std::ops::RangeBounds;
+    ///
+    /// assert!(!(3..).is_empty());
+    /// assert!(!(..2).is_empty());
+    /// assert!(!RangeBounds::is_empty(&(3..5)));
+    /// assert!( RangeBounds::is_empty(&(3..3)));
+    /// assert!( RangeBounds::is_empty(&(3..2)));
+    /// ```
+    ///
+    /// The range is empty if either side is incomparable:
+    ///
+    /// ```
+    /// #![feature(range_bounds_is_empty)]
+    /// use std::ops::RangeBounds;
+    ///
+    /// assert!(!RangeBounds::is_empty(&(3.0..5.0)));
+    /// assert!( RangeBounds::is_empty(&(3.0..f32::NAN)));
+    /// assert!( RangeBounds::is_empty(&(f32::NAN..5.0)));
+    /// ```
+    ///
+    /// But never empty is either side is unbounded:
+    ///
+    /// ```
+    /// #![feature(range_bounds_is_empty)]
+    /// use std::ops::RangeBounds;
+    ///
+    /// assert!(!(..0).is_empty());
+    /// assert!(!(i32::MAX..).is_empty());
+    /// assert!(!RangeBounds::<u8>::is_empty(&(..)));
+    /// ```
+    ///
+    /// `(Excluded(a), Excluded(b))` is only empty if `a >= b`:
+    ///
+    /// ```
+    /// #![feature(range_bounds_is_empty)]
+    /// use std::ops::Bound::*;
+    /// use std::ops::RangeBounds;
+    ///
+    /// assert!(!(Excluded(1), Excluded(3)).is_empty());
+    /// assert!(!(Excluded(1), Excluded(2)).is_empty());
+    /// assert!( (Excluded(1), Excluded(1)).is_empty());
+    /// assert!( (Excluded(2), Excluded(1)).is_empty());
+    /// assert!( (Excluded(3), Excluded(1)).is_empty());
+    /// ```
+    #[unstable(feature = "range_bounds_is_empty", issue = "137300")]
+    fn is_empty(&self) -> bool
+    where
+        T: PartialOrd,
+    {
+        !match (self.start_bound(), self.end_bound()) {
+            (Unbounded, _) | (_, Unbounded) => true,
+            (Included(start), Excluded(end))
+            | (Excluded(start), Included(end))
+            | (Excluded(start), Excluded(end)) => start < end,
+            (Included(start), Included(end)) => start <= end,
+        }
+    }
 }
 
 /// Used to convert a range into start and end bounds, consuming the
@@ -845,7 +906,6 @@ pub trait IntoBounds<T>: RangeBounds<T> {
     ///
     /// ```
     /// #![feature(range_into_bounds)]
-    ///
     /// use std::ops::Bound::*;
     /// use std::ops::IntoBounds;
     ///
@@ -853,6 +913,76 @@ pub trait IntoBounds<T>: RangeBounds<T> {
     /// assert_eq!((..=7).into_bounds(), (Unbounded, Included(7)));
     /// ```
     fn into_bounds(self) -> (Bound<T>, Bound<T>);
+
+    /// Compute the intersection of  `self` and `other`.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// #![feature(range_into_bounds)]
+    /// use std::ops::Bound::*;
+    /// use std::ops::IntoBounds;
+    ///
+    /// assert_eq!((3..).intersect(..5), (Included(3), Excluded(5)));
+    /// assert_eq!((-12..387).intersect(0..256), (Included(0), Excluded(256)));
+    /// assert_eq!((1..5).intersect(..), (Included(1), Excluded(5)));
+    /// assert_eq!((1..=9).intersect(0..10), (Included(1), Included(9)));
+    /// assert_eq!((7..=13).intersect(8..13), (Included(8), Excluded(13)));
+    /// ```
+    ///
+    /// Combine with `is_empty` to determine if two ranges overlap.
+    ///
+    /// ```
+    /// #![feature(range_into_bounds)]
+    /// #![feature(range_bounds_is_empty)]
+    /// use std::ops::{RangeBounds, IntoBounds};
+    ///
+    /// assert!(!(3..).intersect(..5).is_empty());
+    /// assert!(!(-12..387).intersect(0..256).is_empty());
+    /// assert!((1..5).intersect(6..).is_empty());
+    /// ```
+    fn intersect<R>(self, other: R) -> (Bound<T>, Bound<T>)
+    where
+        Self: Sized,
+        T: Ord,
+        R: Sized + IntoBounds<T>,
+    {
+        let (self_start, self_end) = IntoBounds::into_bounds(self);
+        let (other_start, other_end) = IntoBounds::into_bounds(other);
+
+        let start = match (self_start, other_start) {
+            (Included(a), Included(b)) => Included(Ord::max(a, b)),
+            (Excluded(a), Excluded(b)) => Excluded(Ord::max(a, b)),
+            (Unbounded, Unbounded) => Unbounded,
+
+            (x, Unbounded) | (Unbounded, x) => x,
+
+            (Included(i), Excluded(e)) | (Excluded(e), Included(i)) => {
+                if i > e {
+                    Included(i)
+                } else {
+                    Excluded(e)
+                }
+            }
+        };
+        let end = match (self_end, other_end) {
+            (Included(a), Included(b)) => Included(Ord::min(a, b)),
+            (Excluded(a), Excluded(b)) => Excluded(Ord::min(a, b)),
+            (Unbounded, Unbounded) => Unbounded,
+
+            (x, Unbounded) | (Unbounded, x) => x,
+
+            (Included(i), Excluded(e)) | (Excluded(e), Included(i)) => {
+                if i < e {
+                    Included(i)
+                } else {
+                    Excluded(e)
+                }
+            }
+        };
+
+        (start, end)
+    }
 }
 
 use self::Bound::{Excluded, Included, Unbounded};
diff --git a/library/core/src/pin.rs b/library/core/src/pin.rs
index 2a0bf89fcf7a..7fcd19f67ee2 100644
--- a/library/core/src/pin.rs
+++ b/library/core/src/pin.rs
@@ -1240,8 +1240,8 @@ impl<Ptr: Deref> Pin<Ptr> {
     /// points to is pinned, that is a violation of the API contract and may lead to undefined
     /// behavior in later (even safe) operations.
     ///
-    /// By using this method, you are also making a promise about the [`Deref`] and
-    /// [`DerefMut`] implementations of `Ptr`, if they exist. Most importantly, they
+    /// By using this method, you are also making a promise about the [`Deref`],
+    /// [`DerefMut`], and [`Drop`] implementations of `Ptr`, if they exist. Most importantly, they
     /// must not move out of their `self` arguments: `Pin::as_mut` and `Pin::as_ref`
     /// will call `DerefMut::deref_mut` and `Deref::deref` *on the pointer type `Ptr`*
     /// and expect these methods to uphold the pinning invariants.
diff --git a/library/core/src/slice/mod.rs b/library/core/src/slice/mod.rs
index 471150cfd967..7a2764206e8d 100644
--- a/library/core/src/slice/mod.rs
+++ b/library/core/src/slice/mod.rs
@@ -956,7 +956,6 @@ impl<T> [T] {
     /// [`swap`]: slice::swap
     /// [undefined behavior]: https://doc.rust-lang.org/reference/behavior-considered-undefined.html
     #[unstable(feature = "slice_swap_unchecked", issue = "88539")]
-    #[rustc_const_unstable(feature = "slice_swap_unchecked", issue = "88539")]
     pub const unsafe fn swap_unchecked(&mut self, a: usize, b: usize) {
         assert_unsafe_precondition!(
             check_library_ub,
@@ -2928,10 +2927,17 @@ impl<T> [T] {
     /// This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not
     /// allocate), and *O*(*n* \* log(*n*)) worst-case.
     ///
-    /// If the implementation of [`Ord`] for `T` does not implement a [total order] the resulting
-    /// order of elements in the slice is unspecified. All original elements will remain in the
-    /// slice and any possible modifications via interior mutability are observed in the input. Same
-    /// is true if the implementation of [`Ord`] for `T` panics.
+    /// If the implementation of [`Ord`] for `T` does not implement a [total order], the function
+    /// may panic; even if the function exits normally, the resulting order of elements in the slice
+    /// is unspecified. See also the note on panicking below.
+    ///
+    /// For example `|a, b| (a - b).cmp(a)` is a comparison function that is neither transitive nor
+    /// reflexive nor total, `a < b < c < a` with `a = 1, b = 2, c = 3`. For more information and
+    /// examples see the [`Ord`] documentation.
+    ///
+    ///
+    /// All original elements will remain in the slice and any possible modifications via interior
+    /// mutability are observed in the input. Same is true if the implementation of [`Ord`] for `T` panics.
     ///
     /// Sorting types that only implement [`PartialOrd`] such as [`f32`] and [`f64`] require
     /// additional precautions. For example, `f32::NAN != f32::NAN`, which doesn't fulfill the
@@ -2954,7 +2960,8 @@ impl<T> [T] {
     ///
     /// # Panics
     ///
-    /// May panic if the implementation of [`Ord`] for `T` does not implement a [total order].
+    /// May panic if the implementation of [`Ord`] for `T` does not implement a [total order], or if
+    /// the [`Ord`] implementation panics.
     ///
     /// # Examples
     ///
@@ -2982,15 +2989,17 @@ impl<T> [T] {
     /// This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not
     /// allocate), and *O*(*n* \* log(*n*)) worst-case.
     ///
-    /// If the comparison function `compare` does not implement a [total order] the resulting order
-    /// of elements in the slice is unspecified. All original elements will remain in the slice and
-    /// any possible modifications via interior mutability are observed in the input. Same is true
-    /// if `compare` panics.
+    /// If the comparison function `compare` does not implement a [total order], the function
+    /// may panic; even if the function exits normally, the resulting order of elements in the slice
+    /// is unspecified. See also the note on panicking below.
     ///
     /// For example `|a, b| (a - b).cmp(a)` is a comparison function that is neither transitive nor
     /// reflexive nor total, `a < b < c < a` with `a = 1, b = 2, c = 3`. For more information and
     /// examples see the [`Ord`] documentation.
     ///
+    /// All original elements will remain in the slice and any possible modifications via interior
+    /// mutability are observed in the input. Same is true if `compare` panics.
+    ///
     /// # Current implementation
     ///
     /// The current implementation is based on [ipnsort] by Lukas Bergdoll and Orson Peters, which
@@ -3003,7 +3012,8 @@ impl<T> [T] {
     ///
     /// # Panics
     ///
-    /// May panic if `compare` does not implement a [total order].
+    /// May panic if the `compare` does not implement a [total order], or if
+    /// the `compare` itself panics.
     ///
     /// # Examples
     ///
@@ -3034,10 +3044,16 @@ impl<T> [T] {
     /// This sort is unstable (i.e., may reorder equal elements), in-place (i.e., does not
     /// allocate), and *O*(*n* \* log(*n*)) worst-case.
     ///
-    /// If the implementation of [`Ord`] for `K` does not implement a [total order] the resulting
-    /// order of elements in the slice is unspecified. All original elements will remain in the
-    /// slice and any possible modifications via interior mutability are observed in the input. Same
-    /// is true if the implementation of [`Ord`] for `K` panics.
+    /// If the implementation of [`Ord`] for `K` does not implement a [total order], the function
+    /// may panic; even if the function exits normally, the resulting order of elements in the slice
+    /// is unspecified. See also the note on panicking below.
+    ///
+    /// For example `|a, b| (a - b).cmp(a)` is a comparison function that is neither transitive nor
+    /// reflexive nor total, `a < b < c < a` with `a = 1, b = 2, c = 3`. For more information and
+    /// examples see the [`Ord`] documentation.
+    ///
+    /// All original elements will remain in the slice and any possible modifications via interior
+    /// mutability are observed in the input. Same is true if the implementation of [`Ord`] for `K` panics.
     ///
     /// # Current implementation
     ///
@@ -3051,7 +3067,8 @@ impl<T> [T] {
     ///
     /// # Panics
     ///
-    /// May panic if the implementation of [`Ord`] for `K` does not implement a [total order].
+    /// May panic if the implementation of [`Ord`] for `K` does not implement a [total order], or if
+    /// the [`Ord`] implementation panics.
     ///
     /// # Examples
     ///
@@ -3716,6 +3733,7 @@ impl<T> [T] {
     #[inline]
     #[stable(feature = "copy_from_slice", since = "1.9.0")]
     #[rustc_const_unstable(feature = "const_copy_from_slice", issue = "131415")]
+    #[rustc_const_stable_indirect]
     #[track_caller]
     pub const fn copy_from_slice(&mut self, src: &[T])
     where
diff --git a/library/core/src/str/converts.rs b/library/core/src/str/converts.rs
index de68f80aa0c8..1276d9014f0e 100644
--- a/library/core/src/str/converts.rs
+++ b/library/core/src/str/converts.rs
@@ -126,7 +126,7 @@ pub const fn from_utf8(v: &[u8]) -> Result<&str, Utf8Error> {
 /// See the docs for [`Utf8Error`] for more details on the kinds of
 /// errors that can be returned.
 #[stable(feature = "str_mut_extras", since = "1.20.0")]
-#[rustc_const_unstable(feature = "const_str_from_utf8", issue = "91006")]
+#[rustc_const_stable(feature = "const_str_from_utf8", since = "CURRENT_RUSTC_VERSION")]
 #[rustc_diagnostic_item = "str_from_utf8_mut"]
 pub const fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> {
     // FIXME(const-hack): This should use `?` again, once it's `const`
diff --git a/library/core/src/str/mod.rs b/library/core/src/str/mod.rs
index 064923edb41f..83ad10db2da4 100644
--- a/library/core/src/str/mod.rs
+++ b/library/core/src/str/mod.rs
@@ -265,7 +265,7 @@ impl str {
     /// See the docs for [`Utf8Error`] for more details on the kinds of
     /// errors that can be returned.
     #[stable(feature = "inherent_str_constructors", since = "CURRENT_RUSTC_VERSION")]
-    #[rustc_const_unstable(feature = "const_str_from_utf8", issue = "91006")]
+    #[rustc_const_stable(feature = "const_str_from_utf8", since = "CURRENT_RUSTC_VERSION")]
     #[rustc_diagnostic_item = "str_inherent_from_utf8_mut"]
     pub const fn from_utf8_mut(v: &mut [u8]) -> Result<&mut str, Utf8Error> {
         converts::from_utf8_mut(v)
diff --git a/library/coretests/tests/num/int_log.rs b/library/coretests/tests/num/int_log.rs
index 60902752dab6..e8d35fc21ce6 100644
--- a/library/coretests/tests/num/int_log.rs
+++ b/library/coretests/tests/num/int_log.rs
@@ -1,5 +1,13 @@
 //! Tests for the `Integer::{ilog,log2,log10}` methods.
 
+/// Rounds the argument down to the next integer, except that we account for potential imprecision
+/// in the input, so if `f` is very close to an integer, it will round to that.
+fn round_down_imprecise(f: f32) -> u32 {
+    // Rounds up for values less than 16*EPSILON below an integer,
+    // and rounds down for everything else.
+    (f + 16.0 * f32::EPSILON) as u32
+}
+
 #[test]
 fn checked_ilog() {
     assert_eq!(999u32.checked_ilog(10), Some(2));
@@ -25,15 +33,24 @@ fn checked_ilog() {
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=i16::MAX {
-        assert_eq!(i.checked_ilog(13), Some((i as f32).log(13.0) as u32), "checking {i}");
+        assert_eq!(
+            i.checked_ilog(13),
+            Some(round_down_imprecise((i as f32).log(13.0))),
+            "checking {i}"
+        );
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=u16::MAX {
-        assert_eq!(i.checked_ilog(13), Some((i as f32).log(13.0) as u32), "checking {i}");
+        assert_eq!(
+            i.checked_ilog(13),
+            Some(round_down_imprecise((i as f32).log(13.0))),
+            "checking {i}"
+        );
     }
 }
 
 #[test]
+#[cfg_attr(miri, ignore)] // FIXME test is broken on Miri: https://github.com/rust-lang/rust/issues/137591
 fn checked_ilog2() {
     assert_eq!(5u32.checked_ilog2(), Some(2));
     assert_eq!(0u64.checked_ilog2(), None);
@@ -45,25 +62,34 @@ fn checked_ilog2() {
     assert_eq!(0i8.checked_ilog2(), None);
     assert_eq!(0i16.checked_ilog2(), None);
 
-    assert_eq!(8192u16.checked_ilog2(), Some((8192f32).log2() as u32));
-    assert_eq!(32768u16.checked_ilog2(), Some((32768f32).log2() as u32));
-    assert_eq!(8192i16.checked_ilog2(), Some((8192f32).log2() as u32));
+    assert_eq!(8192u16.checked_ilog2(), Some(round_down_imprecise((8192f32).log2())));
+    assert_eq!(32768u16.checked_ilog2(), Some(round_down_imprecise((32768f32).log2())));
+    assert_eq!(8192i16.checked_ilog2(), Some(round_down_imprecise((8192f32).log2())));
 
     for i in 1..=u8::MAX {
-        assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32), "checking {i}");
+        assert_eq!(
+            i.checked_ilog2(),
+            Some(round_down_imprecise((i as f32).log2())),
+            "checking {i}"
+        );
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=u16::MAX {
-        // Guard against Android's imprecise f32::ilog2 implementation.
-        if i != 8192 && i != 32768 {
-            assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32), "checking {i}");
-        }
+        assert_eq!(
+            i.checked_ilog2(),
+            Some(round_down_imprecise((i as f32).log2())),
+            "checking {i}"
+        );
     }
     for i in i8::MIN..=0 {
         assert_eq!(i.checked_ilog2(), None, "checking {i}");
     }
     for i in 1..=i8::MAX {
-        assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32), "checking {i}");
+        assert_eq!(
+            i.checked_ilog2(),
+            Some(round_down_imprecise((i as f32).log2())),
+            "checking {i}"
+        );
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in i16::MIN..=0 {
@@ -71,10 +97,11 @@ fn checked_ilog2() {
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=i16::MAX {
-        // Guard against Android's imprecise f32::ilog2 implementation.
-        if i != 8192 {
-            assert_eq!(i.checked_ilog2(), Some((i as f32).log2() as u32), "checking {i}");
-        }
+        assert_eq!(
+            i.checked_ilog2(),
+            Some(round_down_imprecise((i as f32).log2())),
+            "checking {i}"
+        );
     }
 }
 
@@ -91,15 +118,27 @@ fn checked_ilog10() {
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=i16::MAX {
-        assert_eq!(i.checked_ilog10(), Some((i as f32).log10() as u32), "checking {i}");
+        assert_eq!(
+            i.checked_ilog10(),
+            Some(round_down_imprecise((i as f32).log10())),
+            "checking {i}"
+        );
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=u16::MAX {
-        assert_eq!(i.checked_ilog10(), Some((i as f32).log10() as u32), "checking {i}");
+        assert_eq!(
+            i.checked_ilog10(),
+            Some(round_down_imprecise((i as f32).log10())),
+            "checking {i}"
+        );
     }
     #[cfg(not(miri))] // Miri is too slow
     for i in 1..=100_000u32 {
-        assert_eq!(i.checked_ilog10(), Some((i as f32).log10() as u32), "checking {i}");
+        assert_eq!(
+            i.checked_ilog10(),
+            Some(round_down_imprecise((i as f32).log10())),
+            "checking {i}"
+        );
     }
 }
 
diff --git a/library/coretests/tests/num/int_macros.rs b/library/coretests/tests/num/int_macros.rs
index 392704e7509a..bbf19d2b444f 100644
--- a/library/coretests/tests/num/int_macros.rs
+++ b/library/coretests/tests/num/int_macros.rs
@@ -512,5 +512,169 @@ macro_rules! int_module {
                 assert_eq_const_safe!(<$T>::midpoint(6, <$T>::MAX), <$T>::MAX / 2 + 3);
             }
         }
+
+        // test_unbounded_sh* constants
+        const SHIFT_AMOUNT_OVERFLOW: u32 = <$T>::BITS;
+        const SHIFT_AMOUNT_OVERFLOW2: u32 = <$T>::BITS + 3;
+        const SHIFT_AMOUNT_OVERFLOW3: u32 = <$T>::BITS << 2;
+
+        const SHIFT_AMOUNT_TEST_ONE: u32 = <$T>::BITS >> 1;
+        const SHIFT_AMOUNT_TEST_TWO: u32 = <$T>::BITS >> 3;
+        const SHIFT_AMOUNT_TEST_THREE: u32 = (<$T>::BITS >> 1) - 1;
+        const SHIFT_AMOUNT_TEST_FOUR: u32 = <$T>::BITS - 1;
+
+        test_runtime_and_compiletime! {
+            fn test_unbounded_shl() {
+                // <$T>::MIN
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_ONE), (<$T>::MIN << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_TWO), (<$T>::MIN << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_THREE), (<$T>::MIN << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MIN << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, 1), (<$T>::MIN << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, 3), (<$T>::MIN << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, 5), (<$T>::MIN << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // <$T>::MAX
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_ONE), (<$T>::MAX << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_TWO), (<$T>::MAX << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_THREE), (<$T>::MAX << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MAX << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, 1), (<$T>::MAX << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, 3), (<$T>::MAX << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, 5), (<$T>::MAX << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 1
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_ONE), (1 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_TWO), (1 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_THREE), (1 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_FOUR), (1 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, 1), (1 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, 3), (1 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, 5), (1 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // -1
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_TEST_ONE), (-1 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_TEST_TWO), (-1 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_TEST_THREE), (-1 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_TEST_FOUR), (-1 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, 1), (-1 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, 3), (-1 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, 5), (-1 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(-1, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 8
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_ONE), (8 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_TWO), (8 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_THREE), (8 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_FOUR), (8 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, 1), (8 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, 3), (8 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, 5), (8 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 17
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_ONE), (17 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_TWO), (17 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_THREE), (17 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_FOUR), (17 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, 1), (17 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, 3), (17 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, 5), (17 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_OVERFLOW3), 0);
+            }
+
+            fn test_unbounded_shr() {
+                // <$T>::MIN
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_ONE), (<$T>::MIN >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_TWO), (<$T>::MIN >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_THREE), (<$T>::MIN >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MIN >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, 1), (<$T>::MIN >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, 3), (<$T>::MIN >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, 5), (<$T>::MIN >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW), -1);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW2), -1);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW3), -1);
+
+                // <$T>::MAX
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_ONE), (<$T>::MAX >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_TWO), (<$T>::MAX >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_THREE), (<$T>::MAX >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MAX >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, 1), (<$T>::MAX >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, 3), (<$T>::MAX >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, 5), (<$T>::MAX >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 1
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_ONE), (1 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_TWO), (1 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_THREE), (1 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_FOUR), (1 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, 1), (1 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, 3), (1 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, 5), (1 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // -1
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_TEST_ONE), (-1 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_TEST_TWO), (-1 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_TEST_THREE), (-1 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_TEST_FOUR), (-1 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, 1), (-1 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, 3), (-1 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, 5), (-1 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_OVERFLOW), -1);
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_OVERFLOW), -1);
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_OVERFLOW2), -1);
+                assert_eq_const_safe!(<$T>::unbounded_shr(-1, SHIFT_AMOUNT_OVERFLOW3), -1);
+
+                // 8
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_ONE), (8 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_TWO), (8 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_THREE), (8 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_FOUR), (8 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, 1), (8 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, 3), (8 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, 5), (8 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 17
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_ONE), (17 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_TWO), (17 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_THREE), (17 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_FOUR), (17 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, 1), (17 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, 3), (17 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, 5), (17 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_OVERFLOW3), 0);
+            }
+        }
     };
 }
diff --git a/library/coretests/tests/num/uint_macros.rs b/library/coretests/tests/num/uint_macros.rs
index c085ba5a249a..d09eb97b17e0 100644
--- a/library/coretests/tests/num/uint_macros.rs
+++ b/library/coretests/tests/num/uint_macros.rs
@@ -351,5 +351,169 @@ macro_rules! uint_module {
                 assert_eq_const_safe!(<$T>::midpoint(6, <$T>::MAX), (<$T>::MAX - <$T>::MIN) / 2 + 3);
             }
         }
+
+        // test_unbounded_sh* constants
+        const SHIFT_AMOUNT_OVERFLOW: u32 = <$T>::BITS;
+        const SHIFT_AMOUNT_OVERFLOW2: u32 = <$T>::BITS + 3;
+        const SHIFT_AMOUNT_OVERFLOW3: u32 = <$T>::BITS << 2;
+
+        const SHIFT_AMOUNT_TEST_ONE: u32 = <$T>::BITS >> 1;
+        const SHIFT_AMOUNT_TEST_TWO: u32 = <$T>::BITS >> 3;
+        const SHIFT_AMOUNT_TEST_THREE: u32 = (<$T>::BITS >> 1) - 1;
+        const SHIFT_AMOUNT_TEST_FOUR: u32 = <$T>::BITS - 1;
+
+        test_runtime_and_compiletime! {
+            fn test_unbounded_shl() {
+                // <$T>::MIN
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_ONE), (<$T>::MIN << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_TWO), (<$T>::MIN << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_THREE), (<$T>::MIN << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MIN << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, 1), (<$T>::MIN << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, 3), (<$T>::MIN << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, 5), (<$T>::MIN << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // <$T>::MAX
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_ONE), (<$T>::MAX << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_TWO), (<$T>::MAX << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_THREE), (<$T>::MAX << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MAX << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, 1), (<$T>::MAX << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, 3), (<$T>::MAX << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, 5), (<$T>::MAX << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 1
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_ONE), (1 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_TWO), (1 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_THREE), (1 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_TEST_FOUR), (1 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, 1), (1 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, 3), (1 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, 5), (1 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(1, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // !0
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_TEST_ONE), (!0 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_TEST_TWO), (!0 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_TEST_THREE), (!0 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_TEST_FOUR), (!0 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, 1), (!0 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, 3), (!0 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, 5), (!0 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(!0, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 8
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_ONE), (8 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_TWO), (8 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_THREE), (8 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_TEST_FOUR), (8 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, 1), (8 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, 3), (8 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, 5), (8 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(8, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 17
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_ONE), (17 << SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_TWO), (17 << SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_THREE), (17 << SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_TEST_FOUR), (17 << SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, 1), (17 << 1));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, 3), (17 << 3));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, 5), (17 << 5));
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shl(17, SHIFT_AMOUNT_OVERFLOW3), 0);
+            }
+
+            fn test_unbounded_shr() {
+                // <$T>::MIN
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_ONE), (<$T>::MIN >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_TWO), (<$T>::MIN >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_THREE), (<$T>::MIN >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MIN >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, 1), (<$T>::MIN >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, 3), (<$T>::MIN >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, 5), (<$T>::MIN >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MIN, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // <$T>::MAX
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_ONE), (<$T>::MAX >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_TWO), (<$T>::MAX >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_THREE), (<$T>::MAX >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_TEST_FOUR), (<$T>::MAX >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, 1), (<$T>::MAX >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, 3), (<$T>::MAX >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, 5), (<$T>::MAX >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(<$T>::MAX, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 1
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_ONE), (1 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_TWO), (1 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_THREE), (1 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_TEST_FOUR), (1 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, 1), (1 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, 3), (1 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, 5), (1 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(1, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // !0
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_TEST_ONE), (!0 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_TEST_TWO), (!0 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_TEST_THREE), (!0 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_TEST_FOUR), (!0 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, 1), (!0 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, 3), (!0 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, 5), (!0 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(!0, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 8
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_ONE), (8 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_TWO), (8 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_THREE), (8 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_TEST_FOUR), (8 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, 1), (8 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, 3), (8 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, 5), (8 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(8, SHIFT_AMOUNT_OVERFLOW3), 0);
+
+                // 17
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_ONE), (17 >> SHIFT_AMOUNT_TEST_ONE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_TWO), (17 >> SHIFT_AMOUNT_TEST_TWO));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_THREE), (17 >> SHIFT_AMOUNT_TEST_THREE));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_TEST_FOUR), (17 >> SHIFT_AMOUNT_TEST_FOUR));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, 1), (17 >> 1));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, 3), (17 >> 3));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, 5), (17 >> 5));
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_OVERFLOW), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_OVERFLOW2), 0);
+                assert_eq_const_safe!(<$T>::unbounded_shr(17, SHIFT_AMOUNT_OVERFLOW3), 0);
+            }
+        }
     };
 }
diff --git a/library/std/Cargo.toml b/library/std/Cargo.toml
index a0a28e807960..f4d4894c1bbd 100644
--- a/library/std/Cargo.toml
+++ b/library/std/Cargo.toml
@@ -18,7 +18,7 @@ cfg-if = { version = "1.0", features = ['rustc-dep-of-std'] }
 panic_unwind = { path = "../panic_unwind", optional = true }
 panic_abort = { path = "../panic_abort" }
 core = { path = "../core", public = true }
-compiler_builtins = { version = "=0.1.147" }
+compiler_builtins = { version = "=0.1.148" }
 unwind = { path = "../unwind" }
 hashbrown = { version = "0.15", default-features = false, features = [
     'rustc-dep-of-std',
diff --git a/library/std/build.rs b/library/std/build.rs
index 8dc326a3dde6..723d1eb02e07 100644
--- a/library/std/build.rs
+++ b/library/std/build.rs
@@ -107,7 +107,6 @@ fn main() {
         ("csky", _) => false,
         ("hexagon", _) => false,
         ("loongarch64", _) => false,
-        ("mips" | "mips64" | "mips32r6" | "mips64r6", _) => false,
         ("powerpc" | "powerpc64", _) => false,
         ("sparc" | "sparc64", _) => false,
         ("wasm32" | "wasm64", _) => false,
diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs
index 93d254e34f5e..ff4a4b35ce45 100644
--- a/library/std/src/collections/hash/map.rs
+++ b/library/std/src/collections/hash/map.rs
@@ -656,7 +656,6 @@ impl<K, V, S> HashMap<K, V, S> {
     /// Splitting a map into even and odd keys, reusing the original map:
     ///
     /// ```
-    /// #![feature(hash_extract_if)]
     /// use std::collections::HashMap;
     ///
     /// let mut map: HashMap<i32, i32> = (0..8).map(|x| (x, x)).collect();
@@ -672,7 +671,7 @@ impl<K, V, S> HashMap<K, V, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    #[unstable(feature = "hash_extract_if", issue = "59618")]
+    #[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
     pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F>
     where
         F: FnMut(&K, &mut V) -> bool,
@@ -1722,8 +1721,6 @@ impl<'a, K, V> Drain<'a, K, V> {
 /// # Example
 ///
 /// ```
-/// #![feature(hash_extract_if)]
-///
 /// use std::collections::HashMap;
 ///
 /// let mut map = HashMap::from([
@@ -1731,7 +1728,7 @@ impl<'a, K, V> Drain<'a, K, V> {
 /// ]);
 /// let iter = map.extract_if(|_k, v| *v % 2 == 0);
 /// ```
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 #[must_use = "iterators are lazy and do nothing unless consumed"]
 pub struct ExtractIf<'a, K, V, F>
 where
@@ -2746,7 +2743,7 @@ where
     }
 }
 
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<K, V, F> Iterator for ExtractIf<'_, K, V, F>
 where
     F: FnMut(&K, &mut V) -> bool,
@@ -2763,10 +2760,10 @@ where
     }
 }
 
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F> where F: FnMut(&K, &mut V) -> bool {}
 
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<'a, K, V, F> fmt::Debug for ExtractIf<'a, K, V, F>
 where
     F: FnMut(&K, &mut V) -> bool,
diff --git a/library/std/src/collections/hash/set.rs b/library/std/src/collections/hash/set.rs
index c265d42d06a9..a547a9943c1a 100644
--- a/library/std/src/collections/hash/set.rs
+++ b/library/std/src/collections/hash/set.rs
@@ -293,7 +293,6 @@ impl<T, S> HashSet<T, S> {
     /// Splitting a set into even and odd values, reusing the original set:
     ///
     /// ```
-    /// #![feature(hash_extract_if)]
     /// use std::collections::HashSet;
     ///
     /// let mut set: HashSet<i32> = (0..8).collect();
@@ -309,7 +308,7 @@ impl<T, S> HashSet<T, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    #[unstable(feature = "hash_extract_if", issue = "59618")]
+    #[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
     pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F>
     where
         F: FnMut(&T) -> bool,
@@ -1385,15 +1384,13 @@ pub struct Drain<'a, K: 'a> {
 /// # Examples
 ///
 /// ```
-/// #![feature(hash_extract_if)]
-///
 /// use std::collections::HashSet;
 ///
 /// let mut a = HashSet::from([1, 2, 3]);
 ///
 /// let mut extract_ifed = a.extract_if(|v| v % 2 == 0);
 /// ```
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 pub struct ExtractIf<'a, K, F>
 where
     F: FnMut(&K) -> bool,
@@ -1676,7 +1673,7 @@ impl<K: fmt::Debug> fmt::Debug for Drain<'_, K> {
     }
 }
 
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<K, F> Iterator for ExtractIf<'_, K, F>
 where
     F: FnMut(&K) -> bool,
@@ -1693,10 +1690,10 @@ where
     }
 }
 
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<K, F> FusedIterator for ExtractIf<'_, K, F> where F: FnMut(&K) -> bool {}
 
-#[unstable(feature = "hash_extract_if", issue = "59618")]
+#[stable(feature = "hash_extract_if", since = "CURRENT_RUSTC_VERSION")]
 impl<'a, K, F> fmt::Debug for ExtractIf<'a, K, F>
 where
     F: FnMut(&K) -> bool,
diff --git a/library/std/src/env.rs b/library/std/src/env.rs
index adbd68896241..4a071b4e1fae 100644
--- a/library/std/src/env.rs
+++ b/library/std/src/env.rs
@@ -668,7 +668,9 @@ pub fn home_dir() -> Option<PathBuf> {
 /// On Unix, returns the value of the `TMPDIR` environment variable if it is
 /// set, otherwise the value is OS-specific:
 /// - On Android, there is no global temporary folder (it is usually allocated
-///   per-app), it returns `/data/local/tmp`.
+///   per-app), it will return the application's cache dir if the program runs
+///   in application's namespace and system version is Android 13 (or above), or
+///   `/data/local/tmp` otherwise.
 /// - On Darwin-based OSes (macOS, iOS, etc) it returns the directory provided
 ///   by `confstr(_CS_DARWIN_USER_TEMP_DIR, ...)`, as recommended by [Apple's
 ///   security guidelines][appledoc].
diff --git a/library/std/src/fs/tests.rs b/library/std/src/fs/tests.rs
index c7833c7dc713..38dcd816d267 100644
--- a/library/std/src/fs/tests.rs
+++ b/library/std/src/fs/tests.rs
@@ -1962,6 +1962,10 @@ fn test_rename_directory_to_non_empty_directory() {
 #[test]
 fn test_rename_symlink() {
     let tmpdir = tmpdir();
+    if !got_symlink_permission(&tmpdir) {
+        return;
+    };
+
     let original = tmpdir.join("original");
     let dest = tmpdir.join("dest");
     let not_exist = Path::new("does not exist");
diff --git a/library/std/src/io/error.rs b/library/std/src/io/error.rs
index 30bc0e3b0883..5aa048c4cbc8 100644
--- a/library/std/src/io/error.rs
+++ b/library/std/src/io/error.rs
@@ -83,7 +83,7 @@ impl Error {
 
     pub(crate) const UNKNOWN_THREAD_COUNT: Self = const_error!(
         ErrorKind::NotFound,
-        "The number of hardware threads is not known for the target platform",
+        "the number of hardware threads is not known for the target platform",
     );
 
     pub(crate) const UNSUPPORTED_PLATFORM: Self =
diff --git a/library/std/src/os/windows/io/socket.rs b/library/std/src/os/windows/io/socket.rs
index 2bc6ce222ae5..1c228914de93 100644
--- a/library/std/src/os/windows/io/socket.rs
+++ b/library/std/src/os/windows/io/socket.rs
@@ -90,7 +90,7 @@ impl OwnedSocket {
 
     #[cfg(target_vendor = "uwp")]
     pub(crate) fn set_no_inherit(&self) -> io::Result<()> {
-        Err(io::const_error!(io::ErrorKind::Unsupported, "Unavailable on UWP"))
+        Err(io::const_error!(io::ErrorKind::Unsupported, "unavailable on UWP"))
     }
 }
 
diff --git a/library/std/src/sys/net/connection/xous/tcplistener.rs b/library/std/src/sys/net/connection/xous/tcplistener.rs
index 851d2eb8178d..7f13ca559204 100644
--- a/library/std/src/sys/net/connection/xous/tcplistener.rs
+++ b/library/std/src/sys/net/connection/xous/tcplistener.rs
@@ -11,7 +11,7 @@ macro_rules! unimpl {
     () => {
         return Err(io::const_error!(
             io::ErrorKind::Unsupported,
-            "This function is not yet implemented",
+            "this function is not yet implemented",
         ));
     };
 }
@@ -71,7 +71,7 @@ impl TcpListener {
             0,
             4096,
         ) else {
-            return Err(io::const_error!(io::ErrorKind::InvalidInput, "Invalid response"));
+            return Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid response"));
         };
 
         // The first four bytes should be zero upon success, and will be nonzero
@@ -80,15 +80,15 @@ impl TcpListener {
         if response[0] != 0 || valid == 0 {
             let errcode = response[1];
             if errcode == NetError::SocketInUse as u8 {
-                return Err(io::const_error!(io::ErrorKind::ResourceBusy, "Socket in use"));
+                return Err(io::const_error!(io::ErrorKind::ResourceBusy, "socket in use"));
             } else if errcode == NetError::Invalid as u8 {
-                return Err(io::const_error!(io::ErrorKind::AddrNotAvailable, "Invalid address"));
+                return Err(io::const_error!(io::ErrorKind::AddrNotAvailable, "invalid address"));
             } else if errcode == NetError::LibraryError as u8 {
-                return Err(io::const_error!(io::ErrorKind::Other, "Library error"));
+                return Err(io::const_error!(io::ErrorKind::Other, "library error"));
             } else {
                 return Err(io::const_error!(
                     io::ErrorKind::Other,
-                    "Unable to connect or internal error",
+                    "unable to connect or internal error",
                 ));
             }
         }
@@ -131,7 +131,7 @@ impl TcpListener {
                 } else if receive_request.raw[1] == NetError::WouldBlock as u8 {
                     return Err(io::const_error!(io::ErrorKind::WouldBlock, "accept would block"));
                 } else if receive_request.raw[1] == NetError::LibraryError as u8 {
-                    return Err(io::const_error!(io::ErrorKind::Other, "Library error"));
+                    return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                 } else {
                     return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                 }
@@ -169,7 +169,7 @@ impl TcpListener {
                 Ok((TcpStream::from_listener(stream_fd, self.local.port(), port, addr), addr))
             }
         } else {
-            Err(io::const_error!(io::ErrorKind::InvalidInput, "Unable to accept"))
+            Err(io::const_error!(io::ErrorKind::InvalidInput, "unable to accept"))
         }
     }
 
@@ -186,7 +186,7 @@ impl TcpListener {
             services::net_server(),
             services::NetBlockingScalar::StdSetTtlTcp(self.fd.load(Ordering::Relaxed), ttl).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|_| ())
     }
 
@@ -195,7 +195,7 @@ impl TcpListener {
             services::net_server(),
             services::NetBlockingScalar::StdGetTtlTcp(self.fd.load(Ordering::Relaxed)).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|res| res[0] as _)?)
     }
 
diff --git a/library/std/src/sys/net/connection/xous/tcpstream.rs b/library/std/src/sys/net/connection/xous/tcpstream.rs
index 7f7bbfb7fed3..283b1fe9a33b 100644
--- a/library/std/src/sys/net/connection/xous/tcpstream.rs
+++ b/library/std/src/sys/net/connection/xous/tcpstream.rs
@@ -12,7 +12,7 @@ macro_rules! unimpl {
     () => {
         return Err(io::const_error!(
             io::ErrorKind::Unsupported,
-            "This function is not yet implemented",
+            "this function is not yet implemented",
         ));
     };
 }
@@ -96,7 +96,7 @@ impl TcpStream {
             0,
             4096,
         ) else {
-            return Err(io::const_error!(io::ErrorKind::InvalidInput, "Invalid response"));
+            return Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid response"));
         };
 
         // The first four bytes should be zero upon success, and will be nonzero
@@ -106,13 +106,13 @@ impl TcpStream {
             // errcode is a u8 but stuck in a u16 where the upper byte is invalid. Mask & decode accordingly.
             let errcode = response[0];
             if errcode == NetError::SocketInUse as u8 {
-                return Err(io::const_error!(io::ErrorKind::ResourceBusy, "Socket in use"));
+                return Err(io::const_error!(io::ErrorKind::ResourceBusy, "socket in use"));
             } else if errcode == NetError::Unaddressable as u8 {
-                return Err(io::const_error!(io::ErrorKind::AddrNotAvailable, "Invalid address"));
+                return Err(io::const_error!(io::ErrorKind::AddrNotAvailable, "invalid address"));
             } else {
                 return Err(io::const_error!(
                     io::ErrorKind::InvalidInput,
-                    "Unable to connect or internal error",
+                    "unable to connect or internal error",
                 ));
             }
         }
@@ -198,7 +198,7 @@ impl TcpStream {
         ) else {
             return Err(io::const_error!(
                 io::ErrorKind::InvalidInput,
-                "Library failure: wrong message type or messaging error",
+                "library failure: wrong message type or messaging error",
             ));
         };
 
@@ -212,11 +212,11 @@ impl TcpStream {
             if result[0] != 0 {
                 if result[1] == 8 {
                     // timed out
-                    return Err(io::const_error!(io::ErrorKind::TimedOut, "Timeout"));
+                    return Err(io::const_error!(io::ErrorKind::TimedOut, "timeout"));
                 }
                 if result[1] == 9 {
                     // would block
-                    return Err(io::const_error!(io::ErrorKind::WouldBlock, "Would block"));
+                    return Err(io::const_error!(io::ErrorKind::WouldBlock, "would block"));
                 }
             }
             Err(io::const_error!(io::ErrorKind::Other, "recv_slice failure"))
@@ -258,20 +258,20 @@ impl TcpStream {
             self.write_timeout.load(Ordering::Relaxed) as usize,
             buf_len,
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Internal error")))?;
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "internal error")))?;
 
         if send_request.raw[0] != 0 {
             if send_request.raw[4] == 8 {
                 // timed out
                 return Err(io::const_error!(
                     io::ErrorKind::BrokenPipe,
-                    "Timeout or connection closed",
+                    "timeout or connection closed",
                 ));
             } else if send_request.raw[4] == 9 {
                 // would block
-                return Err(io::const_error!(io::ErrorKind::WouldBlock, "Would block"));
+                return Err(io::const_error!(io::ErrorKind::WouldBlock, "would block"));
             } else {
-                return Err(io::const_error!(io::ErrorKind::InvalidInput, "Error when sending"));
+                return Err(io::const_error!(io::ErrorKind::InvalidInput, "error when sending"));
             }
         }
         Ok(u32::from_le_bytes([
@@ -304,7 +304,7 @@ impl TcpStream {
             0,
             0,
         ) else {
-            return Err(io::const_error!(io::ErrorKind::InvalidInput, "Internal error"));
+            return Err(io::const_error!(io::ErrorKind::InvalidInput, "internal error"));
         };
         let mut i = get_addr.raw.iter();
         match *i.next().unwrap() {
@@ -324,7 +324,7 @@ impl TcpStream {
                 }
                 Ok(SocketAddr::V6(SocketAddrV6::new(new_addr.into(), self.local_port, 0, 0)))
             }
-            _ => Err(io::const_error!(io::ErrorKind::InvalidInput, "Internal error")),
+            _ => Err(io::const_error!(io::ErrorKind::InvalidInput, "tnternal error")),
         }
     }
 
@@ -333,7 +333,7 @@ impl TcpStream {
             services::net_server(),
             services::NetBlockingScalar::StdTcpStreamShutdown(self.fd, how).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|_| ())
     }
 
@@ -355,7 +355,7 @@ impl TcpStream {
             services::net_server(),
             services::NetBlockingScalar::StdSetNodelay(self.fd, enabled).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|_| ())
     }
 
@@ -364,7 +364,7 @@ impl TcpStream {
             services::net_server(),
             services::NetBlockingScalar::StdGetNodelay(self.fd).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|res| res[0] != 0)?)
     }
 
@@ -376,7 +376,7 @@ impl TcpStream {
             services::net_server(),
             services::NetBlockingScalar::StdSetTtlTcp(self.fd, ttl).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|_| ())
     }
 
@@ -385,7 +385,7 @@ impl TcpStream {
             services::net_server(),
             services::NetBlockingScalar::StdGetTtlTcp(self.fd).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|res| res[0] as _)?)
     }
 
diff --git a/library/std/src/sys/net/connection/xous/udp.rs b/library/std/src/sys/net/connection/xous/udp.rs
index ab5bd357b612..f35970bc3215 100644
--- a/library/std/src/sys/net/connection/xous/udp.rs
+++ b/library/std/src/sys/net/connection/xous/udp.rs
@@ -13,7 +13,7 @@ macro_rules! unimpl {
     () => {
         return Err(io::const_error!(
             io::ErrorKind::Unsupported,
-            "This function is not yet implemented",
+            "this function is not yet implemented",
         ));
     };
 }
@@ -72,18 +72,18 @@ impl UdpSocket {
             if response[0] != 0 || valid == 0 {
                 let errcode = response[1];
                 if errcode == NetError::SocketInUse as u8 {
-                    return Err(io::const_error!(io::ErrorKind::ResourceBusy, "Socket in use"));
+                    return Err(io::const_error!(io::ErrorKind::ResourceBusy, "socket in use"));
                 } else if errcode == NetError::Invalid as u8 {
                     return Err(io::const_error!(
                         io::ErrorKind::InvalidInput,
-                        "Port can't be 0 or invalid address",
+                        "port can't be 0 or invalid address",
                     ));
                 } else if errcode == NetError::LibraryError as u8 {
-                    return Err(io::const_error!(io::ErrorKind::Other, "Library error"));
+                    return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                 } else {
                     return Err(io::const_error!(
                         io::ErrorKind::Other,
-                        "Unable to connect or internal error",
+                        "unable to connect or internal error",
                     ));
                 }
             }
@@ -98,13 +98,13 @@ impl UdpSocket {
                 nonblocking: Cell::new(false),
             });
         }
-        Err(io::const_error!(io::ErrorKind::InvalidInput, "Invalid response"))
+        Err(io::const_error!(io::ErrorKind::InvalidInput, "invalid response"))
     }
 
     pub fn peer_addr(&self) -> io::Result<SocketAddr> {
         match self.remote.get() {
             Some(dest) => Ok(dest),
-            None => Err(io::const_error!(io::ErrorKind::NotConnected, "No peer specified")),
+            None => Err(io::const_error!(io::ErrorKind::NotConnected, "no peer specified")),
         }
     }
 
@@ -145,7 +145,7 @@ impl UdpSocket {
                 } else if receive_request.raw[1] == NetError::WouldBlock as u8 {
                     return Err(io::const_error!(io::ErrorKind::WouldBlock, "recv would block"));
                 } else if receive_request.raw[1] == NetError::LibraryError as u8 {
-                    return Err(io::const_error!(io::ErrorKind::Other, "Library error"));
+                    return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                 } else {
                     return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                 }
@@ -178,7 +178,7 @@ impl UdpSocket {
                 Ok((rxlen as usize, addr))
             }
         } else {
-            Err(io::const_error!(io::ErrorKind::InvalidInput, "Unable to recv"))
+            Err(io::const_error!(io::ErrorKind::InvalidInput, "unable to recv"))
         }
     }
 
@@ -281,19 +281,19 @@ impl UdpSocket {
                         if errcode == NetError::SocketInUse as u8 {
                             return Err(io::const_error!(
                                 io::ErrorKind::ResourceBusy,
-                                "Socket in use",
+                                "socket in use",
                             ));
                         } else if errcode == NetError::Invalid as u8 {
                             return Err(io::const_error!(
                                 io::ErrorKind::InvalidInput,
-                                "Socket not valid",
+                                "socket not valid",
                             ));
                         } else if errcode == NetError::LibraryError as u8 {
-                            return Err(io::const_error!(io::ErrorKind::Other, "Library error"));
+                            return Err(io::const_error!(io::ErrorKind::Other, "library error"));
                         } else {
                             return Err(io::const_error!(
                                 io::ErrorKind::Other,
-                                "Unable to connect",
+                                "unable to connect",
                             ));
                         }
                     } else {
@@ -303,13 +303,13 @@ impl UdpSocket {
                 }
                 Err(crate::os::xous::ffi::Error::ServerQueueFull) => {
                     if now.elapsed() >= write_timeout {
-                        return Err(io::const_error!(io::ErrorKind::WouldBlock, "Write timed out"));
+                        return Err(io::const_error!(io::ErrorKind::WouldBlock, "write timed out"));
                     } else {
                         // question: do we want to do something a bit more gentle than immediately retrying?
                         crate::thread::yield_now();
                     }
                 }
-                _ => return Err(io::const_error!(io::ErrorKind::Other, "Library error")),
+                _ => return Err(io::const_error!(io::ErrorKind::Other, "library error")),
             }
         }
     }
@@ -363,7 +363,7 @@ impl UdpSocket {
             services::net_server(),
             services::NetBlockingScalar::StdSetTtlUdp(self.fd, ttl).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|_| ())
     }
 
@@ -372,7 +372,7 @@ impl UdpSocket {
             services::net_server(),
             services::NetBlockingScalar::StdGetTtlUdp(self.fd).into(),
         )
-        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "Unexpected return value")))
+        .or(Err(io::const_error!(io::ErrorKind::InvalidInput, "unexpected return value")))
         .map(|res| res[0] as _)?)
     }
 
diff --git a/library/std/src/sys/os_str/wtf8.rs b/library/std/src/sys/os_str/wtf8.rs
index 19728d33990a..8acec6f949fc 100644
--- a/library/std/src/sys/os_str/wtf8.rs
+++ b/library/std/src/sys/os_str/wtf8.rs
@@ -41,13 +41,13 @@ impl AsInner<Wtf8> for Buf {
 
 impl fmt::Debug for Buf {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Debug::fmt(self.as_slice(), f)
+        fmt::Debug::fmt(&self.inner, f)
     }
 }
 
 impl fmt::Display for Buf {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        fmt::Display::fmt(self.as_slice(), f)
+        fmt::Display::fmt(&self.inner, f)
     }
 }
 
diff --git a/library/std/src/sys/pal/hermit/thread.rs b/library/std/src/sys/pal/hermit/thread.rs
index 4a7afddbec10..bb68a824fc31 100644
--- a/library/std/src/sys/pal/hermit/thread.rs
+++ b/library/std/src/sys/pal/hermit/thread.rs
@@ -41,7 +41,7 @@ impl Thread {
             unsafe {
                 drop(Box::from_raw(p));
             }
-            Err(io::const_error!(io::ErrorKind::Uncategorized, "Unable to create thread!"))
+            Err(io::const_error!(io::ErrorKind::Uncategorized, "unable to create thread!"))
         } else {
             Ok(Thread { tid })
         };
diff --git a/library/std/src/sys/pal/uefi/helpers.rs b/library/std/src/sys/pal/uefi/helpers.rs
index ec2da4e4ee7a..cb6aacd0063d 100644
--- a/library/std/src/sys/pal/uefi/helpers.rs
+++ b/library/std/src/sys/pal/uefi/helpers.rs
@@ -158,7 +158,7 @@ pub(crate) unsafe fn close_event(evt: NonNull<crate::ffi::c_void>) -> io::Result
 /// Note: Some protocols need to be manually freed. It is the caller's responsibility to do so.
 pub(crate) fn image_handle_protocol<T>(protocol_guid: Guid) -> io::Result<NonNull<T>> {
     let system_handle = uefi::env::try_image_handle()
-        .ok_or(io::const_error!(io::ErrorKind::NotFound, "Protocol not found in Image handle"))?;
+        .ok_or(io::const_error!(io::ErrorKind::NotFound, "protocol not found in Image handle"))?;
     open_protocol(system_handle, protocol_guid)
 }
 
@@ -178,7 +178,7 @@ pub(crate) fn device_path_to_text(path: NonNull<device_path::Protocol>) -> io::R
         };
 
         let path = os_string_from_raw(path_ptr)
-            .ok_or(io::const_error!(io::ErrorKind::InvalidData, "Invalid path"))?;
+            .ok_or(io::const_error!(io::ErrorKind::InvalidData, "invalid path"))?;
 
         if let Some(boot_services) = crate::os::uefi::env::boot_services() {
             let boot_services: NonNull<r_efi::efi::BootServices> = boot_services.cast();
@@ -213,7 +213,7 @@ pub(crate) fn device_path_to_text(path: NonNull<device_path::Protocol>) -> io::R
         }
     }
 
-    Err(io::const_error!(io::ErrorKind::NotFound, "No device path to text protocol found"))
+    Err(io::const_error!(io::ErrorKind::NotFound, "no device path to text protocol found"))
 }
 
 /// Gets RuntimeServices.
@@ -245,7 +245,7 @@ impl OwnedDevicePath {
 
             NonNull::new(path)
                 .map(OwnedDevicePath)
-                .ok_or_else(|| const_error!(io::ErrorKind::InvalidFilename, "Invalid Device Path"))
+                .ok_or_else(|| const_error!(io::ErrorKind::InvalidFilename, "invalid Device Path"))
         }
 
         static LAST_VALID_HANDLE: AtomicPtr<crate::ffi::c_void> =
@@ -490,7 +490,7 @@ pub(crate) fn get_device_path_from_map(map: &Path) -> io::Result<BorrowedDeviceP
     let shell =
         open_shell().ok_or(io::const_error!(io::ErrorKind::NotFound, "UEFI Shell not found"))?;
     let mut path = os_string_to_raw(map.as_os_str())
-        .ok_or(io::const_error!(io::ErrorKind::InvalidFilename, "Invalid UEFI shell mapping"))?;
+        .ok_or(io::const_error!(io::ErrorKind::InvalidFilename, "invalid UEFI shell mapping"))?;
 
     // The Device Path Protocol pointer returned by UEFI shell is owned by the shell and is not
     // freed throughout it's lifetime. So it has a 'static lifetime.
diff --git a/library/std/src/sys/pal/uefi/os.rs b/library/std/src/sys/pal/uefi/os.rs
index e305b8610c9f..d26d61890c19 100644
--- a/library/std/src/sys/pal/uefi/os.rs
+++ b/library/std/src/sys/pal/uefi/os.rs
@@ -70,7 +70,7 @@ pub fn getcwd() -> io::Result<PathBuf> {
             let path_ptr = unsafe { ((*shell.as_ptr()).get_cur_dir)(crate::ptr::null_mut()) };
             helpers::os_string_from_raw(path_ptr)
                 .map(PathBuf::from)
-                .ok_or(io::const_error!(io::ErrorKind::InvalidData, "Invalid path"))
+                .ok_or(io::const_error!(io::ErrorKind::InvalidData, "invalid path"))
         }
         None => {
             let mut t = current_exe()?;
@@ -86,7 +86,7 @@ pub fn chdir(p: &path::Path) -> io::Result<()> {
     let shell = helpers::open_shell().ok_or(unsupported_err())?;
 
     let mut p = helpers::os_string_to_raw(p.as_os_str())
-        .ok_or(io::const_error!(io::ErrorKind::InvalidData, "Invalid path"))?;
+        .ok_or(io::const_error!(io::ErrorKind::InvalidData, "invalid path"))?;
 
     let r = unsafe { ((*shell.as_ptr()).set_cur_dir)(crate::ptr::null_mut(), p.as_mut_ptr()) };
     if r.is_error() { Err(io::Error::from_raw_os_error(r.as_usize())) } else { Ok(()) }
@@ -229,15 +229,15 @@ mod uefi_env {
 
     pub(crate) fn set(key: &OsStr, val: &OsStr) -> io::Result<()> {
         let mut key_ptr = helpers::os_string_to_raw(key)
-            .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "Invalid Key"))?;
+            .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "invalid key"))?;
         let mut val_ptr = helpers::os_string_to_raw(val)
-            .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "Invalid Value"))?;
+            .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "invalid value"))?;
         unsafe { set_raw(key_ptr.as_mut_ptr(), val_ptr.as_mut_ptr()) }
     }
 
     pub(crate) fn unset(key: &OsStr) -> io::Result<()> {
         let mut key_ptr = helpers::os_string_to_raw(key)
-            .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "Invalid Key"))?;
+            .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "invalid key"))?;
         unsafe { set_raw(key_ptr.as_mut_ptr(), crate::ptr::null_mut()) }
     }
 
@@ -267,7 +267,7 @@ mod uefi_env {
                 });
                 // SAFETY: val.add(start) is always NULL terminated
                 let val = unsafe { get_raw(shell, val.add(start)) }
-                    .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "Invalid Value"))?;
+                    .ok_or(io::const_error!(io::ErrorKind::InvalidInput, "invalid value"))?;
 
                 vars.push((key, val));
                 start = i + 1;
diff --git a/library/std/src/sys/pal/uefi/process.rs b/library/std/src/sys/pal/uefi/process.rs
index c73a6350357a..a47c8dbcaaaf 100644
--- a/library/std/src/sys/pal/uefi/process.rs
+++ b/library/std/src/sys/pal/uefi/process.rs
@@ -613,7 +613,7 @@ mod uefi_command_internal {
             OsString::from_wide(&self._buffer)
                 .into_string()
                 .map(Into::into)
-                .map_err(|_| const_error!(io::ErrorKind::Other, "utf8 conversion failed"))
+                .map_err(|_| const_error!(io::ErrorKind::Other, "UTF-8 conversion failed"))
         }
 
         extern "efiapi" fn reset(
diff --git a/library/std/src/sys/pal/uefi/stdio.rs b/library/std/src/sys/pal/uefi/stdio.rs
index d049d19bc83e..257e321dd03d 100644
--- a/library/std/src/sys/pal/uefi/stdio.rs
+++ b/library/std/src/sys/pal/uefi/stdio.rs
@@ -71,7 +71,7 @@ impl io::Read for Stdin {
             };
 
         if ch.len() > 1 {
-            return Err(io::const_error!(io::ErrorKind::InvalidData, "invalid utf-16 sequence"));
+            return Err(io::const_error!(io::ErrorKind::InvalidData, "invalid UTF-16 sequence"));
         }
 
         match ch.pop().unwrap() {
diff --git a/library/std/src/sys/pal/unix/os.rs b/library/std/src/sys/pal/unix/os.rs
index 78404b4afa79..3a238d160cb5 100644
--- a/library/std/src/sys/pal/unix/os.rs
+++ b/library/std/src/sys/pal/unix/os.rs
@@ -475,7 +475,7 @@ pub fn current_exe() -> io::Result<PathBuf> {
         );
         if result != libc::B_OK {
             use crate::io::ErrorKind;
-            Err(io::const_error!(ErrorKind::Uncategorized, "Error getting executable path"))
+            Err(io::const_error!(ErrorKind::Uncategorized, "error getting executable path"))
         } else {
             // find_path adds the null terminator.
             let name = CStr::from_ptr(name.as_ptr()).to_bytes();
@@ -492,7 +492,7 @@ pub fn current_exe() -> io::Result<PathBuf> {
 #[cfg(target_os = "l4re")]
 pub fn current_exe() -> io::Result<PathBuf> {
     use crate::io::ErrorKind;
-    Err(io::const_error!(ErrorKind::Unsupported, "Not yet implemented!"))
+    Err(io::const_error!(ErrorKind::Unsupported, "not yet implemented!"))
 }
 
 #[cfg(target_os = "vxworks")]
diff --git a/library/std/src/sys/pal/unix/process/process_fuchsia.rs b/library/std/src/sys/pal/unix/process/process_fuchsia.rs
index b7a35718757a..4ddc96356b99 100644
--- a/library/std/src/sys/pal/unix/process/process_fuchsia.rs
+++ b/library/std/src/sys/pal/unix/process/process_fuchsia.rs
@@ -187,7 +187,7 @@ impl Process {
         if actual != 1 {
             return Err(io::const_error!(
                 io::ErrorKind::InvalidData,
-                "Failed to get exit status of process",
+                "failed to get exit status of process",
             ));
         }
         Ok(ExitStatus(proc_info.return_code))
@@ -224,7 +224,7 @@ impl Process {
         if actual != 1 {
             return Err(io::const_error!(
                 io::ErrorKind::InvalidData,
-                "Failed to get exit status of process",
+                "failed to get exit status of process",
             ));
         }
         Ok(Some(ExitStatus(proc_info.return_code)))
diff --git a/library/std/src/sys/pal/unix/process/process_unix.rs b/library/std/src/sys/pal/unix/process/process_unix.rs
index aa7406dd5487..1f3abd4cc128 100644
--- a/library/std/src/sys/pal/unix/process/process_unix.rs
+++ b/library/std/src/sys/pal/unix/process/process_unix.rs
@@ -1228,7 +1228,7 @@ mod linux_child_ext {
                 .as_ref()
                 // SAFETY: The os type is a transparent wrapper, therefore we can transmute references
                 .map(|fd| unsafe { mem::transmute::<&imp::PidFd, &os::PidFd>(fd) })
-                .ok_or_else(|| io::const_error!(ErrorKind::Uncategorized, "No pidfd was created."))
+                .ok_or_else(|| io::const_error!(ErrorKind::Uncategorized, "no pidfd was created."))
         }
 
         fn into_pidfd(mut self) -> Result<os::PidFd, Self> {
diff --git a/library/std/src/sys/pal/unix/thread.rs b/library/std/src/sys/pal/unix/thread.rs
index 37d5e01790a0..3dedc8d1257c 100644
--- a/library/std/src/sys/pal/unix/thread.rs
+++ b/library/std/src/sys/pal/unix/thread.rs
@@ -59,7 +59,7 @@ impl Thread {
             assert_eq!(
                 libc::pthread_attr_setstacksize(
                     attr.as_mut_ptr(),
-                    cmp::max(stack, min_stack_size(&attr))
+                    cmp::max(stack, min_stack_size(attr.as_ptr()))
                 ),
                 0
             );
@@ -480,7 +480,7 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
             unsafe {
                 use libc::_syspage_ptr;
                 if _syspage_ptr.is_null() {
-                    Err(io::const_error!(io::ErrorKind::NotFound, "No syspage available"))
+                    Err(io::const_error!(io::ErrorKind::NotFound, "no syspage available"))
                 } else {
                     let cpus = (*_syspage_ptr).num_cpu;
                     NonZero::new(cpus as usize)
@@ -520,7 +520,7 @@ pub fn available_parallelism() -> io::Result<NonZero<usize>> {
             }
         } else {
             // FIXME: implement on Redox, l4re
-            Err(io::const_error!(io::ErrorKind::Unsupported, "Getting the number of hardware threads is not supported on the target platform"))
+            Err(io::const_error!(io::ErrorKind::Unsupported, "getting the number of hardware threads is not supported on the target platform"))
         }
     }
 }
diff --git a/library/std/src/sys/pal/unix/time.rs b/library/std/src/sys/pal/unix/time.rs
index e224980e95f3..0271626380c5 100644
--- a/library/std/src/sys/pal/unix/time.rs
+++ b/library/std/src/sys/pal/unix/time.rs
@@ -92,7 +92,7 @@ impl Timespec {
         if tv_nsec >= 0 && tv_nsec < NSEC_PER_SEC as i64 {
             Ok(unsafe { Self::new_unchecked(tv_sec, tv_nsec) })
         } else {
-            Err(io::const_error!(io::ErrorKind::InvalidData, "Invalid timestamp"))
+            Err(io::const_error!(io::ErrorKind::InvalidData, "invalid timestamp"))
         }
     }
 
diff --git a/library/std/src/sys/pal/windows/fs.rs b/library/std/src/sys/pal/windows/fs.rs
index 0ddce30cf8e4..623a7d89ba5a 100644
--- a/library/std/src/sys/pal/windows/fs.rs
+++ b/library/std/src/sys/pal/windows/fs.rs
@@ -1,4 +1,4 @@
-use super::api::{self, WinError};
+use super::api::{self, WinError, set_file_information_by_handle};
 use super::{IoResult, to_u16s};
 use crate::alloc::{alloc, handle_alloc_error};
 use crate::borrow::Cow;
@@ -319,31 +319,17 @@ impl File {
                 && creation == c::OPEN_ALWAYS
                 && api::get_last_error() == WinError::ALREADY_EXISTS
             {
-                unsafe {
-                    // This first tries `FileAllocationInfo` but falls back to
-                    // `FileEndOfFileInfo` in order to support WINE.
-                    // If WINE gains support for FileAllocationInfo, we should
-                    // remove the fallback.
-                    let alloc = c::FILE_ALLOCATION_INFO { AllocationSize: 0 };
-                    let result = c::SetFileInformationByHandle(
-                        handle.as_raw_handle(),
-                        c::FileAllocationInfo,
-                        (&raw const alloc).cast::<c_void>(),
-                        mem::size_of::<c::FILE_ALLOCATION_INFO>() as u32,
-                    );
-                    if result == 0 {
+                // This first tries `FileAllocationInfo` but falls back to
+                // `FileEndOfFileInfo` in order to support WINE.
+                // If WINE gains support for FileAllocationInfo, we should
+                // remove the fallback.
+                let alloc = c::FILE_ALLOCATION_INFO { AllocationSize: 0 };
+                set_file_information_by_handle(handle.as_raw_handle(), &alloc)
+                    .or_else(|_| {
                         let eof = c::FILE_END_OF_FILE_INFO { EndOfFile: 0 };
-                        let result = c::SetFileInformationByHandle(
-                            handle.as_raw_handle(),
-                            c::FileEndOfFileInfo,
-                            (&raw const eof).cast::<c_void>(),
-                            mem::size_of::<c::FILE_END_OF_FILE_INFO>() as u32,
-                        );
-                        if result == 0 {
-                            return Err(io::Error::last_os_error());
-                        }
-                    }
-                }
+                        set_file_information_by_handle(handle.as_raw_handle(), &eof)
+                    })
+                    .io_result()?;
             }
             Ok(File { handle: Handle::from_inner(handle) })
         } else {
@@ -738,7 +724,7 @@ impl File {
         {
             return Err(io::const_error!(
                 io::ErrorKind::InvalidInput,
-                "Cannot set file timestamp to 0",
+                "cannot set file timestamp to 0",
             ));
         }
         let is_max = |t: c::FILETIME| t.dwLowDateTime == u32::MAX && t.dwHighDateTime == u32::MAX;
@@ -748,7 +734,7 @@ impl File {
         {
             return Err(io::const_error!(
                 io::ErrorKind::InvalidInput,
-                "Cannot set file timestamp to 0xFFFF_FFFF_FFFF_FFFF",
+                "cannot set file timestamp to 0xFFFF_FFFF_FFFF_FFFF",
             ));
         }
         cvt(unsafe {
diff --git a/library/std/src/sys/pal/windows/process.rs b/library/std/src/sys/pal/windows/process.rs
index a41dfbfe6014..6eff471f3867 100644
--- a/library/std/src/sys/pal/windows/process.rs
+++ b/library/std/src/sys/pal/windows/process.rs
@@ -260,9 +260,10 @@ impl Command {
         needs_stdin: bool,
         proc_thread_attribute_list: Option<&ProcThreadAttributeList<'_>>,
     ) -> io::Result<(Process, StdioPipes)> {
+        let env_saw_path = self.env.have_changed_path();
         let maybe_env = self.env.capture_if_changed();
 
-        let child_paths = if let Some(env) = maybe_env.as_ref() {
+        let child_paths = if env_saw_path && let Some(env) = maybe_env.as_ref() {
             env.get(&EnvKey::new("PATH")).map(|s| s.as_os_str())
         } else {
             None
diff --git a/library/std/src/sys/pal/zkvm/stdio.rs b/library/std/src/sys/pal/zkvm/stdio.rs
index 5f1d06dd1d78..0bcb54744b0b 100644
--- a/library/std/src/sys/pal/zkvm/stdio.rs
+++ b/library/std/src/sys/pal/zkvm/stdio.rs
@@ -1,6 +1,6 @@
 use super::abi;
 use super::abi::fileno;
-use crate::io;
+use crate::io::{self, BorrowedCursor};
 
 pub struct Stdin;
 pub struct Stdout;
@@ -16,6 +16,14 @@ impl io::Read for Stdin {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         Ok(unsafe { abi::sys_read(fileno::STDIN, buf.as_mut_ptr(), buf.len()) })
     }
+
+    fn read_buf(&mut self, mut buf: BorrowedCursor<'_>) -> io::Result<()> {
+        unsafe {
+            let n = abi::sys_read(fileno::STDIN, buf.as_mut().as_mut_ptr().cast(), buf.capacity());
+            buf.advance_unchecked(n);
+        }
+        Ok(())
+    }
 }
 
 impl Stdout {
diff --git a/library/std/src/sys_common/wtf8.rs b/library/std/src/sys_common/wtf8.rs
index 952c39132b05..f9ec112b1974 100644
--- a/library/std/src/sys_common/wtf8.rs
+++ b/library/std/src/sys_common/wtf8.rs
@@ -169,6 +169,18 @@ impl fmt::Debug for Wtf8Buf {
     }
 }
 
+/// Formats the string with unpaired surrogates substituted with the replacement
+/// character, U+FFFD.
+impl fmt::Display for Wtf8Buf {
+    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+        if let Some(s) = self.as_known_utf8() {
+            fmt::Display::fmt(s, formatter)
+        } else {
+            fmt::Display::fmt(&**self, formatter)
+        }
+    }
+}
+
 impl Wtf8Buf {
     /// Creates a new, empty WTF-8 string.
     #[inline]
@@ -262,6 +274,18 @@ impl Wtf8Buf {
         unsafe { Wtf8::from_mut_bytes_unchecked(&mut self.bytes) }
     }
 
+    /// Converts the string to UTF-8 without validation, if it was created from
+    /// valid UTF-8.
+    #[inline]
+    fn as_known_utf8(&self) -> Option<&str> {
+        if self.is_known_utf8 {
+            // SAFETY: The buffer is known to be valid UTF-8.
+            Some(unsafe { str::from_utf8_unchecked(self.as_bytes()) })
+        } else {
+            None
+        }
+    }
+
     /// Reserves capacity for at least `additional` more bytes to be inserted
     /// in the given `Wtf8Buf`.
     /// The collection may reserve more space to avoid frequent reallocations.
@@ -364,7 +388,7 @@ impl Wtf8Buf {
             _ => {
                 // If we'll be pushing a string containing a surrogate, we may
                 // no longer have UTF-8.
-                if other.next_surrogate(0).is_some() {
+                if self.is_known_utf8 && other.next_surrogate(0).is_some() {
                     self.is_known_utf8 = false;
                 }
 
diff --git a/library/std/src/thread/mod.rs b/library/std/src/thread/mod.rs
index 59b395336f2e..3f3ba02361cc 100644
--- a/library/std/src/thread/mod.rs
+++ b/library/std/src/thread/mod.rs
@@ -1739,7 +1739,16 @@ struct JoinInner<'scope, T> {
 impl<'scope, T> JoinInner<'scope, T> {
     fn join(mut self) -> Result<T> {
         self.native.join();
-        Arc::get_mut(&mut self.packet).unwrap().result.get_mut().take().unwrap()
+        Arc::get_mut(&mut self.packet)
+            // FIXME(fuzzypixelz): returning an error instead of panicking here
+            // would require updating the documentation of
+            // `std::thread::Result`; currently we can return `Err` if and only
+            // if the thread had panicked.
+            .expect("threads should not terminate unexpectedly")
+            .result
+            .get_mut()
+            .take()
+            .unwrap()
     }
 }
 
diff --git a/library/test/src/formatters/junit.rs b/library/test/src/formatters/junit.rs
index 36158b0258a6..84153a9d05b5 100644
--- a/library/test/src/formatters/junit.rs
+++ b/library/test/src/formatters/junit.rs
@@ -39,15 +39,15 @@ fn str_to_cdata(s: &str) -> String {
 
 impl<T: Write> OutputFormatter for JunitFormatter<T> {
     fn write_discovery_start(&mut self) -> io::Result<()> {
-        Err(io::const_error!(io::ErrorKind::NotFound, "Not yet implemented!"))
+        Err(io::const_error!(io::ErrorKind::NotFound, "not yet implemented!"))
     }
 
     fn write_test_discovered(&mut self, _desc: &TestDesc, _test_type: &str) -> io::Result<()> {
-        Err(io::const_error!(io::ErrorKind::NotFound, "Not yet implemented!"))
+        Err(io::const_error!(io::ErrorKind::NotFound, "not yet implemented!"))
     }
 
     fn write_discovery_finish(&mut self, _state: &ConsoleTestDiscoveryState) -> io::Result<()> {
-        Err(io::const_error!(io::ErrorKind::NotFound, "Not yet implemented!"))
+        Err(io::const_error!(io::ErrorKind::NotFound, "not yet implemented!"))
     }
 
     fn write_run_start(
diff --git a/license-metadata.json b/license-metadata.json
index 4cf9bea2861d..4fb59210854e 100644
--- a/license-metadata.json
+++ b/license-metadata.json
@@ -13,7 +13,8 @@
                         "directories": [],
                         "files": [
                           "analyzer-decls.h",
-                          "malloc-macro.h"
+                          "malloc-macro.h",
+                          "sarif-path-role.h"
                         ],
                         "license": {
                           "copyright": [
diff --git a/src/bootstrap/Cargo.lock b/src/bootstrap/Cargo.lock
index a47f3af60cbd..890e64e2babb 100644
--- a/src/bootstrap/Cargo.lock
+++ b/src/bootstrap/Cargo.lock
@@ -88,9 +88,9 @@ dependencies = [
 
 [[package]]
 name = "cc"
-version = "1.2.0"
+version = "1.1.22"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "1aeb932158bd710538c73702db6945cb68a8fb08c519e6e12706b94263b36db8"
+checksum = "9540e661f81799159abee814118cc139a2004b3a3aa3ea37724a1b66530b90e0"
 dependencies = [
  "shlex",
 ]
diff --git a/src/bootstrap/Cargo.toml b/src/bootstrap/Cargo.toml
index ed51862390d4..2c1d85b01e6a 100644
--- a/src/bootstrap/Cargo.toml
+++ b/src/bootstrap/Cargo.toml
@@ -37,7 +37,9 @@ test = false
 # Most of the time updating these dependencies requires modifications to the
 # bootstrap codebase(e.g., https://github.com/rust-lang/rust/issues/124565);
 # otherwise, some targets will fail. That's why these dependencies are explicitly pinned.
-cc = "=1.2.0"
+#
+# Do not upgrade this crate unless https://github.com/rust-lang/cc-rs/issues/1317 is fixed.
+cc = "=1.1.22"
 cmake = "=0.1.48"
 
 build_helper = { path = "../build_helper" }
diff --git a/src/bootstrap/configure.py b/src/bootstrap/configure.py
index ac971a64d7c2..e3f58d97cbc4 100755
--- a/src/bootstrap/configure.py
+++ b/src/bootstrap/configure.py
@@ -776,6 +776,6 @@ if __name__ == "__main__":
         f.write(contents)
 
     p("")
-    p("run `python {}/x.py --help`".format(rust_dir))
+    p("run `{} {}/x.py --help`".format(os.path.basename(sys.executable), rust_dir))
     if "GITHUB_ACTIONS" in os.environ:
         print("::endgroup::")
diff --git a/src/bootstrap/src/core/build_steps/compile.rs b/src/bootstrap/src/core/build_steps/compile.rs
index 9d3d07c83d25..d645d922ef40 100644
--- a/src/bootstrap/src/core/build_steps/compile.rs
+++ b/src/bootstrap/src/core/build_steps/compile.rs
@@ -19,6 +19,7 @@ use serde_derive::Deserialize;
 #[cfg(feature = "tracing")]
 use tracing::{instrument, span};
 
+use crate::core::build_steps::gcc::{Gcc, add_cg_gcc_cargo_flags};
 use crate::core::build_steps::tool::SourceType;
 use crate::core::build_steps::{dist, llvm};
 use crate::core::builder;
@@ -1614,6 +1615,14 @@ impl Step for CodegenBackend {
             .arg(builder.src.join(format!("compiler/rustc_codegen_{backend}/Cargo.toml")));
         rustc_cargo_env(builder, &mut cargo, target, compiler.stage);
 
+        // Ideally, we'd have a separate step for the individual codegen backends,
+        // like we have in tests (test::CodegenGCC) but that would require a lot of restructuring.
+        // If the logic gets more complicated, it should probably be done.
+        if backend == "gcc" {
+            let gcc = builder.ensure(Gcc { target });
+            add_cg_gcc_cargo_flags(&mut cargo, &gcc);
+        }
+
         let tmp_stamp = BuildStamp::new(&out_dir).with_prefix("tmp");
 
         let _guard = builder.msg_build(compiler, format_args!("codegen backend {backend}"), target);
diff --git a/src/bootstrap/src/core/build_steps/doc.rs b/src/bootstrap/src/core/build_steps/doc.rs
index aee56fe78e21..8e913f681842 100644
--- a/src/bootstrap/src/core/build_steps/doc.rs
+++ b/src/bootstrap/src/core/build_steps/doc.rs
@@ -987,9 +987,7 @@ macro_rules! tool_doc {
                 cargo.rustdocflag("-Arustdoc::private-intra-doc-links");
                 cargo.rustdocflag("--enable-index-page");
                 cargo.rustdocflag("--show-type-layout");
-                // FIXME: `--generate-link-to-definition` tries to resolve cfged out code
-                // see https://github.com/rust-lang/rust/pull/122066#issuecomment-1983049222
-                // cargo.rustdocflag("--generate-link-to-definition");
+                cargo.rustdocflag("--generate-link-to-definition");
 
                 let out_dir = builder.stage_out(compiler, Mode::ToolRustc).join(target).join("doc");
                 $(for krate in $crates {
diff --git a/src/bootstrap/src/core/build_steps/gcc.rs b/src/bootstrap/src/core/build_steps/gcc.rs
index 98b8635132b0..e8b6a577cea5 100644
--- a/src/bootstrap/src/core/build_steps/gcc.rs
+++ b/src/bootstrap/src/core/build_steps/gcc.rs
@@ -9,13 +9,13 @@
 //! ensure that they're always in place if needed.
 
 use std::fs;
-use std::path::PathBuf;
+use std::path::{Path, PathBuf};
 use std::sync::OnceLock;
 
 use build_helper::ci::CiEnv;
 
 use crate::Kind;
-use crate::core::builder::{Builder, RunConfig, ShouldRun, Step};
+use crate::core::builder::{Builder, Cargo, RunConfig, ShouldRun, Step};
 use crate::core::config::TargetSelection;
 use crate::utils::build_stamp::{BuildStamp, generate_smart_stamp_hash};
 use crate::utils::exec::command;
@@ -29,7 +29,8 @@ pub struct Meta {
 }
 
 pub enum GccBuildStatus {
-    AlreadyBuilt,
+    /// libgccjit is already built at this path
+    AlreadyBuilt(PathBuf),
     ShouldBuild(Meta),
 }
 
@@ -41,9 +42,6 @@ pub fn prebuilt_gcc_config(builder: &Builder<'_>, target: TargetSelection) -> Gc
     // Initialize the gcc submodule if not initialized already.
     builder.config.update_submodule("src/gcc");
 
-    // FIXME (GuillaumeGomez): To be done once gccjit has been built in the CI.
-    // builder.config.maybe_download_ci_gcc();
-
     let root = builder.src.join("src/gcc");
     let out_dir = builder.gcc_out(target).join("build");
     let install_dir = builder.gcc_out(target).join("install");
@@ -70,19 +68,37 @@ pub fn prebuilt_gcc_config(builder: &Builder<'_>, target: TargetSelection) -> Gc
                 stamp.path().display()
             ));
         }
-        return GccBuildStatus::AlreadyBuilt;
+        let path = libgccjit_built_path(&install_dir);
+        if path.is_file() {
+            return GccBuildStatus::AlreadyBuilt(path);
+        } else {
+            builder.info(&format!(
+                "GCC stamp is up-to-date, but the libgccjit.so file was not found at `{}`",
+                path.display(),
+            ));
+        }
     }
 
     GccBuildStatus::ShouldBuild(Meta { stamp, out_dir, install_dir, root })
 }
 
+/// Returns the path to a libgccjit.so file in the install directory of GCC.
+fn libgccjit_built_path(install_dir: &Path) -> PathBuf {
+    install_dir.join("lib/libgccjit.so")
+}
+
 #[derive(Debug, Clone, Hash, PartialEq, Eq)]
 pub struct Gcc {
     pub target: TargetSelection,
 }
 
+#[derive(Clone)]
+pub struct GccOutput {
+    pub libgccjit: PathBuf,
+}
+
 impl Step for Gcc {
-    type Output = bool;
+    type Output = GccOutput;
 
     const ONLY_HOSTS: bool = true;
 
@@ -94,14 +110,14 @@ impl Step for Gcc {
         run.builder.ensure(Gcc { target: run.target });
     }
 
-    /// Compile GCC for `target`.
-    fn run(self, builder: &Builder<'_>) -> bool {
+    /// Compile GCC (specifically `libgccjit`) for `target`.
+    fn run(self, builder: &Builder<'_>) -> Self::Output {
         let target = self.target;
 
         // If GCC has already been built, we avoid building it again.
         let Meta { stamp, out_dir, install_dir, root } = match prebuilt_gcc_config(builder, target)
         {
-            GccBuildStatus::AlreadyBuilt => return true,
+            GccBuildStatus::AlreadyBuilt(path) => return GccOutput { libgccjit: path },
             GccBuildStatus::ShouldBuild(m) => m,
         };
 
@@ -110,8 +126,9 @@ impl Step for Gcc {
         let _time = helpers::timeit(builder);
         t!(fs::create_dir_all(&out_dir));
 
+        let libgccjit_path = libgccjit_built_path(&install_dir);
         if builder.config.dry_run() {
-            return true;
+            return GccOutput { libgccjit: libgccjit_path };
         }
 
         // GCC creates files (e.g. symlinks to the downloaded dependencies)
@@ -173,11 +190,17 @@ impl Step for Gcc {
 
         let lib_alias = install_dir.join("lib/libgccjit.so.0");
         if !lib_alias.exists() {
-            t!(builder.symlink_file(install_dir.join("lib/libgccjit.so"), lib_alias,));
+            t!(builder.symlink_file(&libgccjit_path, lib_alias));
         }
 
         t!(stamp.write());
 
-        true
+        GccOutput { libgccjit: libgccjit_path }
     }
 }
+
+/// Configures a Cargo invocation so that it can build the GCC codegen backend.
+pub fn add_cg_gcc_cargo_flags(cargo: &mut Cargo, gcc: &GccOutput) {
+    // Add the path to libgccjit.so to the linker search paths.
+    cargo.rustflag(&format!("-L{}", gcc.libgccjit.parent().unwrap().to_str().unwrap()));
+}
diff --git a/src/bootstrap/src/core/build_steps/test.rs b/src/bootstrap/src/core/build_steps/test.rs
index d335ce65ad53..c9fa2e9ba966 100644
--- a/src/bootstrap/src/core/build_steps/test.rs
+++ b/src/bootstrap/src/core/build_steps/test.rs
@@ -12,6 +12,7 @@ use clap_complete::shells;
 
 use crate::core::build_steps::compile::run_cargo;
 use crate::core::build_steps::doc::DocumentationFormat;
+use crate::core::build_steps::gcc::{Gcc, add_cg_gcc_cargo_flags};
 use crate::core::build_steps::llvm::get_llvm_version;
 use crate::core::build_steps::synthetic_targets::MirOptPanicAbortSyntheticTarget;
 use crate::core::build_steps::tool::{self, SourceType, Tool};
@@ -268,7 +269,13 @@ impl Step for Cargotest {
             .args(builder.config.test_args())
             .env("RUSTC", builder.rustc(compiler))
             .env("RUSTDOC", builder.rustdoc(compiler));
-        add_rustdoc_cargo_linker_args(&mut cmd, builder, compiler.host, LldThreads::No);
+        add_rustdoc_cargo_linker_args(
+            &mut cmd,
+            builder,
+            compiler.host,
+            LldThreads::No,
+            compiler.stage,
+        );
         cmd.delay_failure().run(builder);
     }
 }
@@ -293,17 +300,27 @@ impl Step for Cargo {
     }
 
     fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(Cargo { stage: run.builder.top_stage, host: run.target });
+        // If stage is explicitly set or not lower than 2, keep it. Otherwise, make sure it's at least 2
+        // as tests for this step don't work with a lower stage.
+        let stage = if run.builder.config.is_explicit_stage() || run.builder.top_stage >= 2 {
+            run.builder.top_stage
+        } else {
+            2
+        };
+
+        run.builder.ensure(Cargo { stage, host: run.target });
     }
 
     /// Runs `cargo test` for `cargo` packaged with Rust.
     fn run(self, builder: &Builder<'_>) {
-        if self.stage < 2 {
-            eprintln!("WARNING: cargo tests on stage {} may not behave well.", self.stage);
+        let stage = self.stage;
+
+        if stage < 2 {
+            eprintln!("WARNING: cargo tests on stage {stage} may not behave well.");
             eprintln!("HELP: consider using stage 2");
         }
 
-        let compiler = builder.compiler(self.stage, self.host);
+        let compiler = builder.compiler(stage, self.host);
 
         let cargo = builder.ensure(tool::Cargo { compiler, target: self.host });
         let compiler = cargo.build_compiler;
@@ -340,7 +357,7 @@ impl Step for Cargo {
                 crates: vec!["cargo".into()],
                 target: self.host.triple.to_string(),
                 host: self.host.triple.to_string(),
-                stage: self.stage,
+                stage,
             },
             builder,
         );
@@ -739,7 +756,15 @@ impl Step for Clippy {
     }
 
     fn make_run(run: RunConfig<'_>) {
-        run.builder.ensure(Clippy { stage: run.builder.top_stage, host: run.target });
+        // If stage is explicitly set or not lower than 2, keep it. Otherwise, make sure it's at least 2
+        // as tests for this step don't work with a lower stage.
+        let stage = if run.builder.config.is_explicit_stage() || run.builder.top_stage >= 2 {
+            run.builder.top_stage
+        } else {
+            2
+        };
+
+        run.builder.ensure(Clippy { stage, host: run.target });
     }
 
     /// Runs `cargo test` for clippy.
@@ -828,7 +853,7 @@ impl Step for RustdocTheme {
             .env("CFG_RELEASE_CHANNEL", &builder.config.channel)
             .env("RUSTDOC_REAL", builder.rustdoc(self.compiler))
             .env("RUSTC_BOOTSTRAP", "1");
-        cmd.args(linker_args(builder, self.compiler.host, LldThreads::No));
+        cmd.args(linker_args(builder, self.compiler.host, LldThreads::No, self.compiler.stage));
 
         cmd.delay_failure().run(builder);
     }
@@ -1004,7 +1029,13 @@ impl Step for RustdocGUI {
         cmd.env("RUSTDOC", builder.rustdoc(self.compiler))
             .env("RUSTC", builder.rustc(self.compiler));
 
-        add_rustdoc_cargo_linker_args(&mut cmd, builder, self.compiler.host, LldThreads::No);
+        add_rustdoc_cargo_linker_args(
+            &mut cmd,
+            builder,
+            self.compiler.host,
+            LldThreads::No,
+            self.compiler.stage,
+        );
 
         for path in &builder.paths {
             if let Some(p) = helpers::is_valid_test_suite_arg(path, "tests/rustdoc-gui", builder) {
@@ -1774,14 +1805,18 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
         cmd.arg("--src-root").arg(&builder.src);
         cmd.arg("--src-test-suite-root").arg(builder.src.join("tests").join(suite));
 
-        cmd.arg("--build-base").arg(testdir(builder, compiler.host).join(suite));
+        // N.B. it's important to distinguish between the *root* build directory, the *host* build
+        // directory immediately under the root build directory, and the test-suite-specific build
+        // directory.
+        cmd.arg("--build-root").arg(&builder.out);
+        cmd.arg("--build-test-suite-root").arg(testdir(builder, compiler.host).join(suite));
 
         // When top stage is 0, that means that we're testing an externally provided compiler.
         // In that case we need to use its specific sysroot for tests to pass.
         let sysroot = if builder.top_stage == 0 {
             builder.initial_sysroot.clone()
         } else {
-            builder.sysroot(compiler).to_path_buf()
+            builder.sysroot(compiler)
         };
 
         cmd.arg("--sysroot-base").arg(sysroot);
@@ -1864,7 +1899,7 @@ NOTE: if you're sure you want to do this, please open an issue as to why. In the
 
         let mut hostflags = flags.clone();
         hostflags.push(format!("-Lnative={}", builder.test_helpers_out(compiler.host).display()));
-        hostflags.extend(linker_flags(builder, compiler.host, LldThreads::No));
+        hostflags.extend(linker_flags(builder, compiler.host, LldThreads::No, compiler.stage));
 
         let mut targetflags = flags;
         targetflags.push(format!("-Lnative={}", builder.test_helpers_out(target).display()));
@@ -3531,6 +3566,8 @@ impl Step for CodegenGCC {
         let compiler = self.compiler;
         let target = self.target;
 
+        let gcc = builder.ensure(Gcc { target });
+
         builder.ensure(
             compile::Std::new(compiler, target)
                 .extra_rust_args(&["-Csymbol-mangling-version=v0", "-Cpanic=abort"]),
@@ -3557,6 +3594,7 @@ impl Step for CodegenGCC {
                 .arg("--manifest-path")
                 .arg(builder.src.join("compiler/rustc_codegen_gcc/build_system/Cargo.toml"));
             compile::rustc_cargo_env(builder, &mut cargo, target, compiler.stage);
+            add_cg_gcc_cargo_flags(&mut cargo, &gcc);
 
             // Avoid incremental cache issues when changing rustc
             cargo.env("CARGO_BUILD_INCREMENTAL", "false");
@@ -3589,9 +3627,10 @@ impl Step for CodegenGCC {
             .env("CG_RUSTFLAGS", "-Alinker-messages")
             .arg("--")
             .arg("test")
-            .arg("--use-system-gcc")
             .arg("--use-backend")
             .arg("gcc")
+            .arg("--gcc-path")
+            .arg(gcc.libgccjit.parent().unwrap())
             .arg("--out-dir")
             .arg(builder.stage_out(compiler, Mode::ToolRustc).join("cg_gcc"))
             .arg("--release")
diff --git a/src/bootstrap/src/core/builder/cargo.rs b/src/bootstrap/src/core/builder/cargo.rs
index f08d229c76d5..d1d52d82eaa0 100644
--- a/src/bootstrap/src/core/builder/cargo.rs
+++ b/src/bootstrap/src/core/builder/cargo.rs
@@ -260,7 +260,7 @@ impl Cargo {
             }
         }
 
-        for arg in linker_args(builder, compiler.host, LldThreads::Yes) {
+        for arg in linker_args(builder, compiler.host, LldThreads::Yes, 0) {
             self.hostflags.arg(&arg);
         }
 
@@ -270,10 +270,10 @@ impl Cargo {
         }
         // We want to set -Clinker using Cargo, therefore we only call `linker_flags` and not
         // `linker_args` here.
-        for flag in linker_flags(builder, target, LldThreads::Yes) {
+        for flag in linker_flags(builder, target, LldThreads::Yes, compiler.stage) {
             self.rustflags.arg(&flag);
         }
-        for arg in linker_args(builder, target, LldThreads::Yes) {
+        for arg in linker_args(builder, target, LldThreads::Yes, compiler.stage) {
             self.rustdocflags.arg(&arg);
         }
 
@@ -608,11 +608,10 @@ impl Builder<'_> {
         }
 
         // FIXME: the following components don't build with `-Zrandomize-layout` yet:
-        // - wasm-component-ld, due to the `wast`crate
         // - rust-analyzer, due to the rowan crate
-        // so we exclude entire categories of steps here due to lack of fine-grained control over
+        // so we exclude an entire category of steps here due to lack of fine-grained control over
         // rustflags.
-        if self.config.rust_randomize_layout && mode != Mode::ToolStd && mode != Mode::ToolRustc {
+        if self.config.rust_randomize_layout && mode != Mode::ToolRustc {
             rustflags.arg("-Zrandomize-layout");
         }
 
@@ -776,6 +775,12 @@ impl Builder<'_> {
             Mode::Codegen => metadata.push_str("codegen"),
             _ => {}
         }
+        // `rustc_driver`'s version number is always `0.0.0`, which can cause linker search path
+        // problems on side-by-side installs because we don't include the version number of the
+        // `rustc_driver` being built. This can cause builds of different version numbers to produce
+        // `librustc_driver*.so` artifacts that end up with identical filename hashes.
+        metadata.push_str(&self.version);
+
         cargo.env("__CARGO_DEFAULT_LIB_METADATA", &metadata);
 
         if cmd_kind == Kind::Clippy {
diff --git a/src/bootstrap/src/core/builder/mod.rs b/src/bootstrap/src/core/builder/mod.rs
index 9c04f097bee2..c8e2856bdc87 100644
--- a/src/bootstrap/src/core/builder/mod.rs
+++ b/src/bootstrap/src/core/builder/mod.rs
@@ -1462,7 +1462,7 @@ impl<'a> Builder<'a> {
             cmd.arg("-Dwarnings");
         }
         cmd.arg("-Znormalize-docs");
-        cmd.args(linker_args(self, compiler.host, LldThreads::Yes));
+        cmd.args(linker_args(self, compiler.host, LldThreads::Yes, compiler.stage));
         cmd
     }
 
diff --git a/src/bootstrap/src/core/config/config.rs b/src/bootstrap/src/core/config/config.rs
index d4b72ead045e..d0e0ed50ad89 100644
--- a/src/bootstrap/src/core/config/config.rs
+++ b/src/bootstrap/src/core/config/config.rs
@@ -218,6 +218,8 @@ pub struct Config {
     pub stderr_is_tty: bool,
 
     pub on_fail: Option<String>,
+    pub explicit_stage_from_cli: bool,
+    pub explicit_stage_from_config: bool,
     pub stage: u32,
     pub keep_stage: Vec<u32>,
     pub keep_stage_std: Vec<u32>,
@@ -1775,7 +1777,11 @@ impl Config {
 
         let is_user_configured_rust_channel =
             if let Some(channel) = toml.rust.as_ref().and_then(|r| r.channel.clone()) {
-                config.channel = channel;
+                if channel == "auto-detect" {
+                    config.channel = ci_channel.into();
+                } else {
+                    config.channel = channel;
+                }
                 true
             } else {
                 false
@@ -2323,6 +2329,14 @@ impl Config {
         config.compiletest_diff_tool = compiletest_diff_tool;
 
         let download_rustc = config.download_rustc_commit.is_some();
+        config.explicit_stage_from_cli = flags.stage.is_some();
+        config.explicit_stage_from_config = test_stage.is_some()
+            || build_stage.is_some()
+            || doc_stage.is_some()
+            || dist_stage.is_some()
+            || install_stage.is_some()
+            || check_stage.is_some()
+            || bench_stage.is_some();
         // See https://github.com/rust-lang/compiler-team/issues/326
         config.stage = match config.cmd {
             Subcommand::Check { .. } => flags.stage.or(check_stage).unwrap_or(0),
@@ -2392,6 +2406,10 @@ impl Config {
         }
     }
 
+    pub fn is_explicit_stage(&self) -> bool {
+        self.explicit_stage_from_cli || self.explicit_stage_from_config
+    }
+
     /// Runs a command, printing out nice contextual information if it fails.
     /// Exits if the command failed to execute at all, otherwise returns its
     /// `status.success()`.
diff --git a/src/bootstrap/src/core/config/tests.rs b/src/bootstrap/src/core/config/tests.rs
index f0a185ee3a7e..eff5e0337428 100644
--- a/src/bootstrap/src/core/config/tests.rs
+++ b/src/bootstrap/src/core/config/tests.rs
@@ -454,3 +454,64 @@ fn check_rustc_if_unchanged_paths() {
         assert!(config.src.join(p).exists(), "{p} doesn't exist.");
     }
 }
+
+#[test]
+fn test_explicit_stage() {
+    let config = Config::parse_inner(
+        Flags::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()]),
+        |&_| {
+            toml::from_str(
+                r#"
+            [build]
+            test-stage = 1
+        "#,
+            )
+        },
+    );
+
+    assert!(!config.explicit_stage_from_cli);
+    assert!(config.explicit_stage_from_config);
+    assert!(config.is_explicit_stage());
+
+    let config = Config::parse_inner(
+        Flags::parse(&[
+            "check".to_owned(),
+            "--stage=2".to_owned(),
+            "--config=/does/not/exist".to_owned(),
+        ]),
+        |&_| toml::from_str(""),
+    );
+
+    assert!(config.explicit_stage_from_cli);
+    assert!(!config.explicit_stage_from_config);
+    assert!(config.is_explicit_stage());
+
+    let config = Config::parse_inner(
+        Flags::parse(&[
+            "check".to_owned(),
+            "--stage=2".to_owned(),
+            "--config=/does/not/exist".to_owned(),
+        ]),
+        |&_| {
+            toml::from_str(
+                r#"
+            [build]
+            test-stage = 1
+        "#,
+            )
+        },
+    );
+
+    assert!(config.explicit_stage_from_cli);
+    assert!(config.explicit_stage_from_config);
+    assert!(config.is_explicit_stage());
+
+    let config = Config::parse_inner(
+        Flags::parse(&["check".to_owned(), "--config=/does/not/exist".to_owned()]),
+        |&_| toml::from_str(""),
+    );
+
+    assert!(!config.explicit_stage_from_cli);
+    assert!(!config.explicit_stage_from_config);
+    assert!(!config.is_explicit_stage());
+}
diff --git a/src/bootstrap/src/utils/change_tracker.rs b/src/bootstrap/src/utils/change_tracker.rs
index 8dfe0d3a35ef..5f49c50c5ad3 100644
--- a/src/bootstrap/src/utils/change_tracker.rs
+++ b/src/bootstrap/src/utils/change_tracker.rs
@@ -360,4 +360,9 @@ pub const CONFIG_CHANGE_HISTORY: &[ChangeInfo] = &[
         severity: ChangeSeverity::Info,
         summary: "Added `build.test-stage = 2` to 'tools' profile defaults",
     },
+    ChangeInfo {
+        change_id: 137220,
+        severity: ChangeSeverity::Info,
+        summary: "`rust.channel` now supports \"auto-detect\" to load the channel from `src/ci/channel`",
+    },
 ];
diff --git a/src/bootstrap/src/utils/helpers.rs b/src/bootstrap/src/utils/helpers.rs
index 3fee397da091..7ad308cd0672 100644
--- a/src/bootstrap/src/utils/helpers.rs
+++ b/src/bootstrap/src/utils/helpers.rs
@@ -430,8 +430,9 @@ pub fn linker_args(
     builder: &Builder<'_>,
     target: TargetSelection,
     lld_threads: LldThreads,
+    stage: u32,
 ) -> Vec<String> {
-    let mut args = linker_flags(builder, target, lld_threads);
+    let mut args = linker_flags(builder, target, lld_threads, stage);
 
     if let Some(linker) = builder.linker(target) {
         args.push(format!("-Clinker={}", linker.display()));
@@ -446,12 +447,18 @@ pub fn linker_flags(
     builder: &Builder<'_>,
     target: TargetSelection,
     lld_threads: LldThreads,
+    stage: u32,
 ) -> Vec<String> {
     let mut args = vec![];
     if !builder.is_lld_direct_linker(target) && builder.config.lld_mode.is_used() {
         match builder.config.lld_mode {
             LldMode::External => {
-                args.push("-Clinker-flavor=gnu-lld-cc".to_string());
+                // cfg(bootstrap) - remove after updating bootstrap compiler (#137498)
+                if stage == 0 && target.is_windows() {
+                    args.push("-Clink-arg=-fuse-ld=lld".to_string());
+                } else {
+                    args.push("-Clinker-flavor=gnu-lld-cc".to_string());
+                }
                 // FIXME(kobzol): remove this flag once MCP510 gets stabilized
                 args.push("-Zunstable-options".to_string());
             }
@@ -479,8 +486,9 @@ pub fn add_rustdoc_cargo_linker_args(
     builder: &Builder<'_>,
     target: TargetSelection,
     lld_threads: LldThreads,
+    stage: u32,
 ) {
-    let args = linker_args(builder, target, lld_threads);
+    let args = linker_args(builder, target, lld_threads, stage);
     let mut flags = cmd
         .get_envs()
         .find_map(|(k, v)| if k == OsStr::new("RUSTDOCFLAGS") { v } else { None })
diff --git a/src/ci/citool/Cargo.lock b/src/ci/citool/Cargo.lock
new file mode 100644
index 000000000000..39b6b44da643
--- /dev/null
+++ b/src/ci/citool/Cargo.lock
@@ -0,0 +1,415 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "anstream"
+version = "0.6.18"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8acc5369981196006228e28809f761875c0327210a891e941f4c683b3a99529b"
+dependencies = [
+ "anstyle",
+ "anstyle-parse",
+ "anstyle-query",
+ "anstyle-wincon",
+ "colorchoice",
+ "is_terminal_polyfill",
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle"
+version = "1.0.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55cc3b69f167a1ef2e161439aa98aed94e6028e5f9a59be9a6ffb47aef1651f9"
+
+[[package]]
+name = "anstyle-parse"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3b2d16507662817a6a20a9ea92df6652ee4f94f914589377d69f3b21bc5798a9"
+dependencies = [
+ "utf8parse",
+]
+
+[[package]]
+name = "anstyle-query"
+version = "1.1.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79947af37f4177cfead1110013d678905c37501914fba0efea834c3fe9a8d60c"
+dependencies = [
+ "windows-sys",
+]
+
+[[package]]
+name = "anstyle-wincon"
+version = "3.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ca3534e77181a9cc07539ad51f2141fe32f6c3ffd4df76db8ad92346b003ae4e"
+dependencies = [
+ "anstyle",
+ "once_cell",
+ "windows-sys",
+]
+
+[[package]]
+name = "anyhow"
+version = "1.0.95"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34ac096ce696dc2fcabef30516bb13c0a68a11d30131d3df6f04711467681b04"
+
+[[package]]
+name = "citool"
+version = "0.1.0"
+dependencies = [
+ "anyhow",
+ "clap",
+ "insta",
+ "serde",
+ "serde_json",
+ "serde_yaml",
+]
+
+[[package]]
+name = "clap"
+version = "4.5.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3e77c3243bd94243c03672cb5154667347c457ca271254724f9f393aee1c05ff"
+dependencies = [
+ "clap_builder",
+ "clap_derive",
+]
+
+[[package]]
+name = "clap_builder"
+version = "4.5.27"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1b26884eb4b57140e4d2d93652abfa49498b938b3c9179f9fc487b0acc3edad7"
+dependencies = [
+ "anstream",
+ "anstyle",
+ "clap_lex",
+ "strsim",
+]
+
+[[package]]
+name = "clap_derive"
+version = "4.5.28"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf4ced95c6f4a675af3da73304b9ac4ed991640c36374e4b46795c49e17cf1ed"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "clap_lex"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f46ad14479a25103f283c0f10005961cf086d8dc42205bb44c46ac563475dca6"
+
+[[package]]
+name = "colorchoice"
+version = "1.0.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5b63caa9aa9397e2d9480a9b13673856c78d8ac123288526c37d7839f2a86990"
+
+[[package]]
+name = "console"
+version = "0.15.10"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ea3c6ecd8059b57859df5c69830340ed3c41d30e3da0c1cbed90a96ac853041b"
+dependencies = [
+ "encode_unicode",
+ "libc",
+ "once_cell",
+ "windows-sys",
+]
+
+[[package]]
+name = "encode_unicode"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "34aa73646ffb006b8f5147f3dc182bd4bcb190227ce861fc4a4844bf8e3cb2c0"
+
+[[package]]
+name = "equivalent"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5443807d6dff69373d433ab9ef5378ad8df50ca6298caf15de6e52e24aaf54d5"
+
+[[package]]
+name = "hashbrown"
+version = "0.15.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bf151400ff0baff5465007dd2f3e717f3fe502074ca563069ce3a6629d07b289"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indexmap"
+version = "2.7.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8c9c992b02b5b4c94ea26e32fe5bccb7aa7d9f390ab5c1221ff895bc7ea8b652"
+dependencies = [
+ "equivalent",
+ "hashbrown",
+]
+
+[[package]]
+name = "insta"
+version = "1.42.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "71c1b125e30d93896b365e156c33dadfffab45ee8400afcbba4752f59de08a86"
+dependencies = [
+ "console",
+ "linked-hash-map",
+ "once_cell",
+ "pin-project",
+ "similar",
+]
+
+[[package]]
+name = "is_terminal_polyfill"
+version = "1.70.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7943c866cc5cd64cbc25b2e01621d07fa8eb2a1a23160ee81ce38704e97b8ecf"
+
+[[package]]
+name = "itoa"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d75a2a4b1b190afb6f5425f10f6a8f959d2ea0b9c2b1d79553551850539e4674"
+
+[[package]]
+name = "libc"
+version = "0.2.169"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b5aba8db14291edd000dfcc4d620c7ebfb122c613afb886ca8803fa4e128a20a"
+
+[[package]]
+name = "linked-hash-map"
+version = "0.5.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0717cef1bc8b636c6e1c1bbdefc09e6322da8a9321966e8928ef80d20f7f770f"
+
+[[package]]
+name = "memchr"
+version = "2.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "78ca9ab1a0babb1e7d5695e3530886289c18cf2f87ec19a575a0abdce112e3a3"
+
+[[package]]
+name = "once_cell"
+version = "1.20.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "945462a4b81e43c4e3ba96bd7b49d834c6f61198356aa858733bc4acf3cbe62e"
+
+[[package]]
+name = "pin-project"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dfe2e71e1471fe07709406bf725f710b02927c9c54b2b5b2ec0e8087d97c327d"
+dependencies = [
+ "pin-project-internal",
+]
+
+[[package]]
+name = "pin-project-internal"
+version = "1.1.9"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f6e859e6e5bd50440ab63c47e3ebabc90f26251f7c73c3d3e837b74a1cc3fa67"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.93"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "60946a68e5f9d28b0dc1c21bb8a97ee7d018a8b322fa57838ba31cc878e22d99"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.38"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0e4dccaaaf89514f546c693ddc140f729f958c247918a13380cccc6078391acc"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "ryu"
+version = "1.0.19"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6ea1a2d0a644769cc99faa24c3ad26b379b786fe7c36fd3c546254801650e6dd"
+
+[[package]]
+name = "serde"
+version = "1.0.217"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "02fc4265df13d6fa1d00ecff087228cc0a2b5f3c0e87e258d8b94a156e984c70"
+dependencies = [
+ "serde_derive",
+]
+
+[[package]]
+name = "serde_derive"
+version = "1.0.217"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5a9bf7cf98d04a2b28aead066b7496853d4779c9cc183c440dbac457641e19a0"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "serde_json"
+version = "1.0.138"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "d434192e7da787e94a6ea7e9670b26a036d0ca41e0b7efb2676dd32bae872949"
+dependencies = [
+ "itoa",
+ "memchr",
+ "ryu",
+ "serde",
+]
+
+[[package]]
+name = "serde_yaml"
+version = "0.9.34+deprecated"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "6a8b1a1a2ebf674015cc02edccce75287f1a0130d394307b36743c2f5d504b47"
+dependencies = [
+ "indexmap",
+ "itoa",
+ "ryu",
+ "serde",
+ "unsafe-libyaml",
+]
+
+[[package]]
+name = "similar"
+version = "2.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bbbb5d9659141646ae647b42fe094daf6c6192d1620870b449d9557f748b2daa"
+
+[[package]]
+name = "strsim"
+version = "0.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7da8b5736845d9f2fcb837ea5d9e2628564b3b043a70948a3f0b778838c5fb4f"
+
+[[package]]
+name = "syn"
+version = "2.0.98"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "36147f1a48ae0ec2b5b3bc5b537d267457555a10dc06f3dbc8cb11ba3006d3b1"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.16"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a210d160f08b701c8721ba1c726c11662f877ea6b7094007e1ca9a1041945034"
+
+[[package]]
+name = "unsafe-libyaml"
+version = "0.2.11"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "673aac59facbab8a9007c7f6108d11f63b603f7cabff99fabf650fea5c32b861"
+
+[[package]]
+name = "utf8parse"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "06abde3611657adf66d383f00b093d7faecc7fa57071cce2578660c9f1010821"
+
+[[package]]
+name = "windows-sys"
+version = "0.59.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1e38bc4d79ed67fd075bcc251a1c39b32a1776bbe92e5bef1f0bf1f8c531853b"
+dependencies = [
+ "windows-targets",
+]
+
+[[package]]
+name = "windows-targets"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9b724f72796e036ab90c1021d4780d4d3d648aca59e491e6b98e725b84e99973"
+dependencies = [
+ "windows_aarch64_gnullvm",
+ "windows_aarch64_msvc",
+ "windows_i686_gnu",
+ "windows_i686_gnullvm",
+ "windows_i686_msvc",
+ "windows_x86_64_gnu",
+ "windows_x86_64_gnullvm",
+ "windows_x86_64_msvc",
+]
+
+[[package]]
+name = "windows_aarch64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "32a4622180e7a0ec044bb555404c800bc9fd9ec262ec147edd5989ccd0c02cd3"
+
+[[package]]
+name = "windows_aarch64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "09ec2a7bb152e2252b53fa7803150007879548bc709c039df7627cabbd05d469"
+
+[[package]]
+name = "windows_i686_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8e9b5ad5ab802e97eb8e295ac6720e509ee4c243f69d781394014ebfe8bbfa0b"
+
+[[package]]
+name = "windows_i686_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0eee52d38c090b3caa76c563b86c3a4bd71ef1a819287c19d586d7334ae8ed66"
+
+[[package]]
+name = "windows_i686_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "240948bc05c5e7c6dabba28bf89d89ffce3e303022809e73deaefe4f6ec56c66"
+
+[[package]]
+name = "windows_x86_64_gnu"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "147a5c80aabfbf0c7d901cb5895d1de30ef2907eb21fbbab29ca94c5b08b1a78"
+
+[[package]]
+name = "windows_x86_64_gnullvm"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "24d5b23dc417412679681396f2b49f3de8c1473deb516bd34410872eff51ed0d"
+
+[[package]]
+name = "windows_x86_64_msvc"
+version = "0.52.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "589f6da84c646204747d1270a2a5661ea66ed1cced2631d546fdfb155959f9ec"
diff --git a/src/ci/citool/Cargo.toml b/src/ci/citool/Cargo.toml
new file mode 100644
index 000000000000..e77c67c71477
--- /dev/null
+++ b/src/ci/citool/Cargo.toml
@@ -0,0 +1,19 @@
+[package]
+name = "citool"
+version = "0.1.0"
+edition = "2021"
+
+[dependencies]
+anyhow = "1"
+clap = { version = "4.5", features = ["derive"] }
+serde = { version = "1", features = ["derive"] }
+serde_yaml = "0.9"
+serde_json = "1"
+
+[dev-dependencies]
+insta = "1"
+
+# Tell cargo that citool is its own workspace.
+# If this is omitted, cargo will look for a workspace elsewhere.
+# We want to avoid this, since citool is independent of the other crates.
+[workspace]
diff --git a/src/ci/citool/README.md b/src/ci/citool/README.md
new file mode 100644
index 000000000000..685a255f1525
--- /dev/null
+++ b/src/ci/citool/README.md
@@ -0,0 +1,2 @@
+# CI tooling
+This is a simple Rust script that determines which jobs should be executed on CI based on the situation (pull request, try job, merge attempt). It also provides a simple way of executing (some) CI jobs locally.
diff --git a/src/ci/citool/src/main.rs b/src/ci/citool/src/main.rs
new file mode 100644
index 000000000000..ad9cc8b82a6f
--- /dev/null
+++ b/src/ci/citool/src/main.rs
@@ -0,0 +1,380 @@
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+use std::process::Command;
+
+use anyhow::Context;
+use clap::Parser;
+use serde_yaml::Value;
+
+const CI_DIRECTORY: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/..");
+const DOCKER_DIRECTORY: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../docker");
+const JOBS_YML_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/../github-actions/jobs.yml");
+
+/// Representation of a job loaded from the `src/ci/github-actions/jobs.yml` file.
+#[derive(serde::Deserialize, Debug, Clone)]
+struct Job {
+    /// Name of the job, e.g. mingw-check
+    name: String,
+    /// GitHub runner on which the job should be executed
+    os: String,
+    env: BTreeMap<String, Value>,
+    /// Should the job be only executed on a specific channel?
+    #[serde(default)]
+    only_on_channel: Option<String>,
+    /// Rest of attributes that will be passed through to GitHub actions
+    #[serde(flatten)]
+    extra_keys: BTreeMap<String, Value>,
+}
+
+impl Job {
+    fn is_linux(&self) -> bool {
+        self.os.contains("ubuntu")
+    }
+
+    /// By default, the Docker image of a job is based on its name.
+    /// However, it can be overridden by its IMAGE environment variable.
+    fn image(&self) -> String {
+        self.env
+            .get("IMAGE")
+            .map(|v| v.as_str().expect("IMAGE value should be a string").to_string())
+            .unwrap_or_else(|| self.name.clone())
+    }
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct JobEnvironments {
+    #[serde(rename = "pr")]
+    pr_env: BTreeMap<String, Value>,
+    #[serde(rename = "try")]
+    try_env: BTreeMap<String, Value>,
+    #[serde(rename = "auto")]
+    auto_env: BTreeMap<String, Value>,
+}
+
+#[derive(serde::Deserialize, Debug)]
+struct JobDatabase {
+    #[serde(rename = "pr")]
+    pr_jobs: Vec<Job>,
+    #[serde(rename = "try")]
+    try_jobs: Vec<Job>,
+    #[serde(rename = "auto")]
+    auto_jobs: Vec<Job>,
+
+    /// Shared environments for the individual run types.
+    envs: JobEnvironments,
+}
+
+impl JobDatabase {
+    fn find_auto_job_by_name(&self, name: &str) -> Option<Job> {
+        self.auto_jobs.iter().find(|j| j.name == name).cloned()
+    }
+}
+
+fn load_job_db(path: &Path) -> anyhow::Result<JobDatabase> {
+    let db = read_to_string(path)?;
+    let mut db: Value = serde_yaml::from_str(&db)?;
+
+    // We need to expand merge keys (<<), because serde_yaml can't deal with them
+    // `apply_merge` only applies the merge once, so do it a few times to unwrap nested merges.
+    db.apply_merge()?;
+    db.apply_merge()?;
+
+    let db: JobDatabase = serde_yaml::from_value(db)?;
+    Ok(db)
+}
+
+/// Representation of a job outputted to a GitHub Actions workflow.
+#[derive(serde::Serialize, Debug)]
+struct GithubActionsJob {
+    /// The main identifier of the job, used by CI scripts to determine what should be executed.
+    name: String,
+    /// Helper label displayed in GitHub Actions interface, containing the job name and a run type
+    /// prefix (PR/try/auto).
+    full_name: String,
+    os: String,
+    env: BTreeMap<String, serde_json::Value>,
+    #[serde(flatten)]
+    extra_keys: BTreeMap<String, serde_json::Value>,
+}
+
+/// Type of workflow that is being executed on CI
+#[derive(Debug)]
+enum RunType {
+    /// Workflows that run after a push to a PR branch
+    PullRequest,
+    /// Try run started with @bors try
+    TryJob { custom_jobs: Option<Vec<String>> },
+    /// Merge attempt workflow
+    AutoJob,
+}
+
+struct GitHubContext {
+    event_name: String,
+    branch_ref: String,
+    commit_message: Option<String>,
+}
+
+impl GitHubContext {
+    fn get_run_type(&self) -> Option<RunType> {
+        match (self.event_name.as_str(), self.branch_ref.as_str()) {
+            ("pull_request", _) => Some(RunType::PullRequest),
+            ("push", "refs/heads/try-perf") => Some(RunType::TryJob { custom_jobs: None }),
+            ("push", "refs/heads/try" | "refs/heads/automation/bors/try") => {
+                let custom_jobs = self.get_custom_jobs();
+                let custom_jobs = if !custom_jobs.is_empty() { Some(custom_jobs) } else { None };
+                Some(RunType::TryJob { custom_jobs })
+            }
+            ("push", "refs/heads/auto") => Some(RunType::AutoJob),
+            _ => None,
+        }
+    }
+
+    /// Tries to parse names of specific CI jobs that should be executed in the form of
+    /// try-job: <job-name>
+    /// from the commit message of the passed GitHub context.
+    fn get_custom_jobs(&self) -> Vec<String> {
+        if let Some(ref msg) = self.commit_message {
+            msg.lines()
+                .filter_map(|line| line.trim().strip_prefix("try-job: "))
+                .map(|l| l.trim().to_string())
+                .collect()
+        } else {
+            vec![]
+        }
+    }
+}
+
+fn load_env_var(name: &str) -> anyhow::Result<String> {
+    std::env::var(name).with_context(|| format!("Cannot find variable {name}"))
+}
+
+fn load_github_ctx() -> anyhow::Result<GitHubContext> {
+    let event_name = load_env_var("GITHUB_EVENT_NAME")?;
+    let commit_message =
+        if event_name == "push" { Some(load_env_var("COMMIT_MESSAGE")?) } else { None };
+
+    Ok(GitHubContext { event_name, branch_ref: load_env_var("GITHUB_REF")?, commit_message })
+}
+
+/// Skip CI jobs that are not supposed to be executed on the given `channel`.
+fn skip_jobs(jobs: Vec<Job>, channel: &str) -> Vec<Job> {
+    jobs.into_iter()
+        .filter(|job| {
+            job.only_on_channel.is_none() || job.only_on_channel.as_deref() == Some(channel)
+        })
+        .collect()
+}
+
+fn yaml_map_to_json(map: &BTreeMap<String, Value>) -> BTreeMap<String, serde_json::Value> {
+    map.into_iter()
+        .map(|(key, value)| {
+            (
+                key.clone(),
+                serde_json::to_value(&value).expect("Cannot convert map value from YAML to JSON"),
+            )
+        })
+        .collect()
+}
+
+fn calculate_jobs(
+    run_type: &RunType,
+    db: &JobDatabase,
+    channel: &str,
+) -> anyhow::Result<Vec<GithubActionsJob>> {
+    let (jobs, prefix, base_env) = match run_type {
+        RunType::PullRequest => (db.pr_jobs.clone(), "PR", &db.envs.pr_env),
+        RunType::TryJob { custom_jobs } => {
+            let jobs = if let Some(custom_jobs) = custom_jobs {
+                if custom_jobs.len() > 10 {
+                    return Err(anyhow::anyhow!(
+                        "It is only possible to schedule up to 10 custom jobs, received {} custom jobs",
+                        custom_jobs.len()
+                    ));
+                }
+
+                let mut jobs = vec![];
+                let mut unknown_jobs = vec![];
+                for custom_job in custom_jobs {
+                    if let Some(job) = db.find_auto_job_by_name(custom_job) {
+                        jobs.push(job);
+                    } else {
+                        unknown_jobs.push(custom_job.clone());
+                    }
+                }
+                if !unknown_jobs.is_empty() {
+                    return Err(anyhow::anyhow!(
+                        "Custom job(s) `{}` not found in auto jobs",
+                        unknown_jobs.join(", ")
+                    ));
+                }
+                jobs
+            } else {
+                db.try_jobs.clone()
+            };
+            (jobs, "try", &db.envs.try_env)
+        }
+        RunType::AutoJob => (db.auto_jobs.clone(), "auto", &db.envs.auto_env),
+    };
+    let jobs = skip_jobs(jobs, channel);
+    let jobs = jobs
+        .into_iter()
+        .map(|job| {
+            let mut env: BTreeMap<String, serde_json::Value> = yaml_map_to_json(base_env);
+            env.extend(yaml_map_to_json(&job.env));
+            let full_name = format!("{prefix} - {}", job.name);
+
+            GithubActionsJob {
+                name: job.name,
+                full_name,
+                os: job.os,
+                env,
+                extra_keys: yaml_map_to_json(&job.extra_keys),
+            }
+        })
+        .collect();
+
+    Ok(jobs)
+}
+
+fn calculate_job_matrix(
+    db: JobDatabase,
+    gh_ctx: GitHubContext,
+    channel: &str,
+) -> anyhow::Result<()> {
+    let run_type = gh_ctx.get_run_type().ok_or_else(|| {
+        anyhow::anyhow!("Cannot determine the type of workflow that is being executed")
+    })?;
+    eprintln!("Run type: {run_type:?}");
+
+    let jobs = calculate_jobs(&run_type, &db, channel)?;
+    if jobs.is_empty() {
+        return Err(anyhow::anyhow!("Computed job list is empty"));
+    }
+
+    let run_type = match run_type {
+        RunType::PullRequest => "pr",
+        RunType::TryJob { .. } => "try",
+        RunType::AutoJob => "auto",
+    };
+
+    eprintln!("Output");
+    eprintln!("jobs={jobs:?}");
+    eprintln!("run_type={run_type}");
+    println!("jobs={}", serde_json::to_string(&jobs)?);
+    println!("run_type={run_type}");
+
+    Ok(())
+}
+
+fn find_linux_job<'a>(jobs: &'a [Job], name: &str) -> anyhow::Result<&'a Job> {
+    let Some(job) = jobs.iter().find(|j| j.name == name) else {
+        let available_jobs: Vec<&Job> = jobs.iter().filter(|j| j.is_linux()).collect();
+        let mut available_jobs =
+            available_jobs.iter().map(|j| j.name.to_string()).collect::<Vec<_>>();
+        available_jobs.sort();
+        return Err(anyhow::anyhow!(
+            "Job {name} not found. The following jobs are available:\n{}",
+            available_jobs.join(", ")
+        ));
+    };
+    if !job.is_linux() {
+        return Err(anyhow::anyhow!("Only Linux jobs can be executed locally"));
+    }
+
+    Ok(job)
+}
+
+fn run_workflow_locally(db: JobDatabase, job_type: JobType, name: String) -> anyhow::Result<()> {
+    let jobs = match job_type {
+        JobType::Auto => &db.auto_jobs,
+        JobType::PR => &db.pr_jobs,
+    };
+    let job = find_linux_job(jobs, &name).with_context(|| format!("Cannot find job {name}"))?;
+
+    let mut custom_env: BTreeMap<String, String> = BTreeMap::new();
+    // Replicate src/ci/scripts/setup-environment.sh
+    // Adds custom environment variables to the job
+    if name.starts_with("dist-") {
+        if name.ends_with("-alt") {
+            custom_env.insert("DEPLOY_ALT".to_string(), "1".to_string());
+        } else {
+            custom_env.insert("DEPLOY".to_string(), "1".to_string());
+        }
+    }
+    custom_env.extend(job.env.iter().map(|(key, value)| {
+        let value = match value {
+            Value::Bool(value) => value.to_string(),
+            Value::Number(value) => value.to_string(),
+            Value::String(value) => value.clone(),
+            _ => panic!("Unexpected type for environment variable {key} Only bool/number/string is supported.")
+        };
+        (key.clone(), value)
+    }));
+
+    let mut cmd = Command::new(Path::new(DOCKER_DIRECTORY).join("run.sh"));
+    cmd.arg(job.image());
+    cmd.envs(custom_env);
+
+    eprintln!("Executing {cmd:?}");
+
+    let result = cmd.spawn()?.wait()?;
+    if !result.success() { Err(anyhow::anyhow!("Job failed")) } else { Ok(()) }
+}
+
+#[derive(clap::Parser)]
+enum Args {
+    /// Calculate a list of jobs that should be executed on CI.
+    /// Should only be used on CI inside GitHub actions.
+    CalculateJobMatrix {
+        #[clap(long)]
+        jobs_file: Option<PathBuf>,
+    },
+    /// Execute a given CI job locally.
+    #[clap(name = "run-local")]
+    RunJobLocally {
+        /// Name of the job that should be executed.
+        name: String,
+        /// Type of the job that should be executed.
+        #[clap(long = "type", default_value = "auto")]
+        job_type: JobType,
+    },
+}
+
+#[derive(clap::ValueEnum, Clone)]
+enum JobType {
+    /// Merge attempt ("auto") job
+    Auto,
+    /// Pull request job
+    PR,
+}
+
+fn main() -> anyhow::Result<()> {
+    let args = Args::parse();
+    let default_jobs_file = Path::new(JOBS_YML_PATH);
+    let load_db = |jobs_path| load_job_db(jobs_path).context("Cannot load jobs.yml");
+
+    match args {
+        Args::CalculateJobMatrix { jobs_file } => {
+            let jobs_path = jobs_file.as_deref().unwrap_or(default_jobs_file);
+            let gh_ctx = load_github_ctx()
+                .context("Cannot load environment variables from GitHub Actions")?;
+            let channel = read_to_string(Path::new(CI_DIRECTORY).join("channel"))
+                .context("Cannot read channel file")?
+                .trim()
+                .to_string();
+
+            calculate_job_matrix(load_db(jobs_path)?, gh_ctx, &channel)
+                .context("Failed to calculate job matrix")?;
+        }
+        Args::RunJobLocally { job_type, name } => {
+            run_workflow_locally(load_db(default_jobs_file)?, job_type, name)?
+        }
+    }
+
+    Ok(())
+}
+
+fn read_to_string<P: AsRef<Path>>(path: P) -> anyhow::Result<String> {
+    let error = format!("Cannot read file {:?}", path.as_ref());
+    std::fs::read_to_string(path).context(error)
+}
diff --git a/src/ci/citool/tests/jobs.rs b/src/ci/citool/tests/jobs.rs
new file mode 100644
index 000000000000..1d81d58f8931
--- /dev/null
+++ b/src/ci/citool/tests/jobs.rs
@@ -0,0 +1,64 @@
+use std::process::{Command, Stdio};
+
+const TEST_JOBS_YML_PATH: &str = concat!(env!("CARGO_MANIFEST_DIR"), "/tests/test-jobs.yml");
+
+#[test]
+fn auto_jobs() {
+    let stdout = get_matrix("push", "commit", "refs/heads/auto");
+    insta::assert_snapshot!(stdout, @r#"
+    jobs=[{"name":"aarch64-gnu","full_name":"auto - aarch64-gnu","os":"ubuntu-22.04-arm","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"x86_64-gnu-llvm-18-1","full_name":"auto - x86_64-gnu-llvm-18-1","os":"ubuntu-24.04","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DOCKER_SCRIPT":"stage_2_test_set1.sh","IMAGE":"x86_64-gnu-llvm-18","READ_ONLY_SRC":"0","RUST_BACKTRACE":1,"TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"aarch64-apple","full_name":"auto - aarch64-apple","os":"macos-14","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","MACOSX_DEPLOYMENT_TARGET":11.0,"MACOSX_STD_DEPLOYMENT_TARGET":11.0,"NO_DEBUG_ASSERTIONS":1,"NO_LLVM_ASSERTIONS":1,"NO_OVERFLOW_CHECKS":1,"RUSTC_RETRY_LINKER_ON_SEGFAULT":1,"RUST_CONFIGURE_ARGS":"--enable-sanitizers --enable-profiler --set rust.jemalloc","SCRIPT":"./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin","SELECT_XCODE":"/Applications/Xcode_15.4.app","TOOLSTATE_PUBLISH":1,"USE_XCODE_CLANG":1}},{"name":"dist-i686-msvc","full_name":"auto - dist-i686-msvc","os":"windows-2022","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","CODEGEN_BACKENDS":"llvm,cranelift","DEPLOY_BUCKET":"rust-lang-ci2","DIST_REQUIRE_ALL_TOOLS":1,"RUST_CONFIGURE_ARGS":"--build=i686-pc-windows-msvc --host=i686-pc-windows-msvc --target=i686-pc-windows-msvc,i586-pc-windows-msvc --enable-full-tools --enable-profiler","SCRIPT":"python x.py dist bootstrap --include-default-paths","TOOLSTATE_PUBLISH":1}}]
+    run_type=auto
+    "#);
+}
+
+#[test]
+fn try_jobs() {
+    let stdout = get_matrix("push", "commit", "refs/heads/try");
+    insta::assert_snapshot!(stdout, @r#"
+    jobs=[{"name":"dist-x86_64-linux","full_name":"try - dist-x86_64-linux","os":"ubuntu-22.04-16core-64gb","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","CODEGEN_BACKENDS":"llvm,cranelift","DEPLOY_BUCKET":"rust-lang-ci2","DIST_TRY_BUILD":1,"TOOLSTATE_PUBLISH":1}}]
+    run_type=try
+    "#);
+}
+
+#[test]
+fn try_custom_jobs() {
+    let stdout = get_matrix(
+        "push",
+        r#"This is a test PR
+
+try-job: aarch64-gnu
+try-job: dist-i686-msvc"#,
+        "refs/heads/try",
+    );
+    insta::assert_snapshot!(stdout, @r#"
+    jobs=[{"name":"aarch64-gnu","full_name":"try - aarch64-gnu","os":"ubuntu-22.04-arm","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","DEPLOY_BUCKET":"rust-lang-ci2","DIST_TRY_BUILD":1,"TOOLSTATE_PUBLISH":1},"free_disk":true},{"name":"dist-i686-msvc","full_name":"try - dist-i686-msvc","os":"windows-2022","env":{"ARTIFACTS_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZN24CBO55","AWS_REGION":"us-west-1","CACHES_AWS_ACCESS_KEY_ID":"AKIA46X5W6CZI5DHEBFL","CODEGEN_BACKENDS":"llvm,cranelift","DEPLOY_BUCKET":"rust-lang-ci2","DIST_REQUIRE_ALL_TOOLS":1,"DIST_TRY_BUILD":1,"RUST_CONFIGURE_ARGS":"--build=i686-pc-windows-msvc --host=i686-pc-windows-msvc --target=i686-pc-windows-msvc,i586-pc-windows-msvc --enable-full-tools --enable-profiler","SCRIPT":"python x.py dist bootstrap --include-default-paths","TOOLSTATE_PUBLISH":1}}]
+    run_type=try
+    "#);
+}
+
+#[test]
+fn pr_jobs() {
+    let stdout = get_matrix("pull_request", "commit", "refs/heads/pr/1234");
+    insta::assert_snapshot!(stdout, @r#"
+    jobs=[{"name":"mingw-check","full_name":"PR - mingw-check","os":"ubuntu-24.04","env":{"PR_CI_JOB":1},"free_disk":true},{"name":"mingw-check-tidy","full_name":"PR - mingw-check-tidy","os":"ubuntu-24.04","env":{"PR_CI_JOB":1},"continue_on_error":true,"free_disk":true}]
+    run_type=pr
+    "#);
+}
+
+fn get_matrix(event_name: &str, commit_msg: &str, branch_ref: &str) -> String {
+    let output = Command::new("cargo")
+        .args(["run", "-q", "calculate-job-matrix", "--jobs-file", TEST_JOBS_YML_PATH])
+        .env("GITHUB_EVENT_NAME", event_name)
+        .env("COMMIT_MESSAGE", commit_msg)
+        .env("GITHUB_REF", branch_ref)
+        .stdout(Stdio::piped())
+        .output()
+        .expect("Failed to execute command");
+
+    let stdout = String::from_utf8(output.stdout).unwrap();
+    let stderr = String::from_utf8(output.stderr).unwrap();
+    if !output.status.success() {
+        panic!("cargo run failed: {}\n{}", stdout, stderr);
+    }
+    stdout
+}
diff --git a/src/ci/citool/tests/test-jobs.yml b/src/ci/citool/tests/test-jobs.yml
new file mode 100644
index 000000000000..56b9ced20719
--- /dev/null
+++ b/src/ci/citool/tests/test-jobs.yml
@@ -0,0 +1,145 @@
+runners:
+  - &base-job
+    env: { }
+
+  - &job-linux-4c
+    os: ubuntu-24.04
+    # Free some disk space to avoid running out of space during the build.
+    free_disk: true
+    <<: *base-job
+
+  - &job-linux-16c
+    os: ubuntu-22.04-16core-64gb
+    <<: *base-job
+
+  - &job-macos-m1
+    os: macos-14
+    <<: *base-job
+
+  - &job-windows
+    os: windows-2022
+    <<: *base-job
+
+  - &job-aarch64-linux
+    # Free some disk space to avoid running out of space during the build.
+    free_disk: true
+    os: ubuntu-22.04-arm
+    <<: *base-job
+envs:
+  env-x86_64-apple-tests: &env-x86_64-apple-tests
+    SCRIPT: ./x.py --stage 2 test --skip tests/ui --skip tests/rustdoc -- --exact
+    RUST_CONFIGURE_ARGS: --build=x86_64-apple-darwin --enable-sanitizers --enable-profiler --set rust.jemalloc
+    RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+    # Ensure that host tooling is tested on our minimum supported macOS version.
+    MACOSX_DEPLOYMENT_TARGET: 10.12
+    MACOSX_STD_DEPLOYMENT_TARGET: 10.12
+    SELECT_XCODE: /Applications/Xcode_15.2.app
+    NO_LLVM_ASSERTIONS: 1
+    NO_DEBUG_ASSERTIONS: 1
+    NO_OVERFLOW_CHECKS: 1
+
+  production:
+    &production
+    DEPLOY_BUCKET: rust-lang-ci2
+    # AWS_SECRET_ACCESS_KEYs are stored in GitHub's secrets storage, named
+    # AWS_SECRET_ACCESS_KEY_<keyid>. Including the key id in the name allows to
+    # rotate them in a single branch while keeping the old key in another
+    # branch, which wouldn't be possible if the key was named with the kind
+    # (caches, artifacts...).
+    CACHES_AWS_ACCESS_KEY_ID: AKIA46X5W6CZI5DHEBFL
+    ARTIFACTS_AWS_ACCESS_KEY_ID: AKIA46X5W6CZN24CBO55
+    AWS_REGION: us-west-1
+    TOOLSTATE_PUBLISH: 1
+
+  try:
+    <<: *production
+    # The following env var activates faster `try` builds in `opt-dist` by, e.g.
+    # - building only the more commonly useful components (we rarely need e.g. rust-docs in try
+    #   builds)
+    # - not running `opt-dist`'s post-optimization smoke tests on the resulting toolchain
+    #
+    # If you *want* these to happen however, temporarily comment it before triggering a try build.
+    DIST_TRY_BUILD: 1
+
+  auto:
+    <<: *production
+
+  pr:
+    PR_CI_JOB: 1
+
+# Jobs that run on each push to a pull request (PR)
+# These jobs automatically inherit envs.pr, to avoid repeating
+# it in each job definition.
+pr:
+  - name: mingw-check
+    <<: *job-linux-4c
+  - name: mingw-check-tidy
+    continue_on_error: true
+    <<: *job-linux-4c
+
+# Jobs that run when you perform a try build (@bors try)
+# These jobs automatically inherit envs.try, to avoid repeating
+# it in each job definition.
+try:
+  - name: dist-x86_64-linux
+    env:
+      CODEGEN_BACKENDS: llvm,cranelift
+    <<: *job-linux-16c
+
+# Main CI jobs that have to be green to merge a commit into master
+# These jobs automatically inherit envs.auto, to avoid repeating
+# it in each job definition.
+auto:
+  - name: aarch64-gnu
+    <<: *job-aarch64-linux
+
+  # The x86_64-gnu-llvm-18 job is split into multiple jobs to run tests in parallel.
+  # x86_64-gnu-llvm-18-1 skips tests that run in x86_64-gnu-llvm-18-{2,3}.
+  - name: x86_64-gnu-llvm-18-1
+    env:
+      RUST_BACKTRACE: 1
+      READ_ONLY_SRC: "0"
+      IMAGE: x86_64-gnu-llvm-18
+      DOCKER_SCRIPT: stage_2_test_set1.sh
+    <<: *job-linux-4c
+
+
+  ####################
+  #  macOS Builders  #
+  ####################
+
+  - name: aarch64-apple
+    env:
+      SCRIPT: ./x.py --stage 2 test --host=aarch64-apple-darwin --target=aarch64-apple-darwin
+      RUST_CONFIGURE_ARGS: >-
+        --enable-sanitizers
+        --enable-profiler
+        --set rust.jemalloc
+      RUSTC_RETRY_LINKER_ON_SEGFAULT: 1
+      SELECT_XCODE: /Applications/Xcode_15.4.app
+      USE_XCODE_CLANG: 1
+      # Aarch64 tooling only needs to support macOS 11.0 and up as nothing else
+      # supports the hardware, so only need to test it there.
+      MACOSX_DEPLOYMENT_TARGET: 11.0
+      MACOSX_STD_DEPLOYMENT_TARGET: 11.0
+      NO_LLVM_ASSERTIONS: 1
+      NO_DEBUG_ASSERTIONS: 1
+      NO_OVERFLOW_CHECKS: 1
+    <<: *job-macos-m1
+
+  ######################
+  #  Windows Builders  #
+  ######################
+
+  - name: dist-i686-msvc
+    env:
+      RUST_CONFIGURE_ARGS: >-
+        --build=i686-pc-windows-msvc
+        --host=i686-pc-windows-msvc
+        --target=i686-pc-windows-msvc,i586-pc-windows-msvc
+        --enable-full-tools
+        --enable-profiler
+      SCRIPT: python x.py dist bootstrap --include-default-paths
+      DIST_REQUIRE_ALL_TOOLS: 1
+      CODEGEN_BACKENDS: llvm,cranelift
+    <<: *job-windows
diff --git a/src/ci/docker/README.md b/src/ci/docker/README.md
index 2b1de43c2f68..a1a3a1c37ced 100644
--- a/src/ci/docker/README.md
+++ b/src/ci/docker/README.md
@@ -8,15 +8,15 @@ Note that a single Docker image can be used by multiple CI jobs, so the job name
 is the important thing that you should know. You can examine the existing CI jobs in
 the [`jobs.yml`](../github-actions/jobs.yml) file.
 
-To run a specific CI job locally, you can use the following script:
+To run a specific CI job locally, you can use the `citool` Rust crate:
 
 ```
-python3 ./src/ci/github-actions/ci.py run-local <job-name>
+cargo --manifest-path src/ci/citool/Cargo.toml run run-local <job-name>
 ```
 
 For example, to run the `x86_64-gnu-llvm-18-1` job:
 ```
-python3 ./src/ci/github-actions/ci.py run-local x86_64-gnu-llvm-18-1
+cargo --manifest-path src/ci/citool/Cargo.toml run run-local x86_64-gnu-llvm-18-1
 ```
 
 The job will output artifacts in an `obj/<image-name>` dir at the root of a repository. Note
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-18/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-18/Dockerfile
index 0a58f337d9dd..aefc0f376f68 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-18/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-18/Dockerfile
@@ -3,6 +3,7 @@ FROM ubuntu:24.04
 ARG DEBIAN_FRONTEND=noninteractive
 
 RUN apt-get update && apt-get install -y --no-install-recommends \
+  bzip2 \
   g++ \
   gcc-multilib \
   make \
@@ -55,9 +56,6 @@ ENV RUST_CONFIGURE_ARGS \
       --set rust.thin-lto-import-instr-limit=10
 
 COPY scripts/shared.sh /scripts/
-COPY scripts/build-gccjit.sh /scripts/
-
-RUN /scripts/build-gccjit.sh /scripts
 
 ARG SCRIPT_ARG
 
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
index 092847cdfe04..e0ed2e227f81 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-llvm-19/Dockerfile
@@ -55,9 +55,6 @@ ENV RUST_CONFIGURE_ARGS \
       --set rust.thin-lto-import-instr-limit=10
 
 COPY scripts/shared.sh /scripts/
-COPY scripts/build-gccjit.sh /scripts/
-
-RUN /scripts/build-gccjit.sh /scripts
 
 ARG SCRIPT_ARG
 
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile b/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
index ab749b3fdd5a..89806634c6c2 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-tools/Dockerfile
@@ -90,9 +90,6 @@ ENV HOST_TARGET x86_64-unknown-linux-gnu
 #ENV FORCE_CI_RUSTC 1
 
 COPY scripts/shared.sh /scripts/
-COPY scripts/build-gccjit.sh /scripts/
-
-RUN /scripts/build-gccjit.sh /scripts
 
 # For now, we need to use `--unsafe-perm=true` to go around an issue when npm tries
 # to create a new folder. For reference:
diff --git a/src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version b/src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version
index a158e5b6253c..3428dd4826a7 100644
--- a/src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version
+++ b/src/ci/docker/host-x86_64/x86_64-gnu-tools/browser-ui-test.version
@@ -1 +1 @@
-0.20.2
\ No newline at end of file
+0.20.3
\ No newline at end of file
diff --git a/src/ci/docker/scripts/build-gccjit.sh b/src/ci/docker/scripts/build-gccjit.sh
deleted file mode 100755
index 43ed2270d313..000000000000
--- a/src/ci/docker/scripts/build-gccjit.sh
+++ /dev/null
@@ -1,37 +0,0 @@
-#!/usr/bin/env bash
-
-GIT_REPO="https://github.com/rust-lang/gcc"
-
-# This commit hash needs to be updated to use a more recent gcc fork version.
-GIT_COMMIT="45648c2edd4ecd862d9f08196d3d6c6ccba79f07"
-
-set -ex
-
-cd $1
-
-source shared.sh
-
-# Setting up folders for GCC
-curl -L "$GIT_REPO/archive/$GIT_COMMIT.tar.gz" |
-    tar -xz --transform "s/gcc-$GIT_COMMIT/gcc-src/"
-
-mkdir gcc-build gcc-install
-pushd gcc-build
-
-# Building GCC.
-hide_output \
-  ../gcc-src/configure \
-    --enable-host-shared \
-    --enable-languages=jit \
-    --enable-checking=release \
-    --disable-bootstrap \
-    --disable-multilib \
-    --prefix=$(pwd)/../gcc-install \
-
-hide_output make -j$(nproc)
-hide_output make install
-
-popd
-rm -rf gcc-src gcc-build
-ln -s /scripts/gcc-install/lib/libgccjit.so /usr/lib/x86_64-linux-gnu/libgccjit.so
-ln -s /scripts/gcc-install/lib/libgccjit.so /usr/lib/x86_64-linux-gnu/libgccjit.so.0
diff --git a/src/ci/github-actions/ci.py b/src/ci/github-actions/ci.py
deleted file mode 100755
index c93766ef33a0..000000000000
--- a/src/ci/github-actions/ci.py
+++ /dev/null
@@ -1,318 +0,0 @@
-#!/usr/bin/env python3
-
-"""
-This script contains CI functionality.
-It can be used to generate a matrix of jobs that should
-be executed on CI, or run a specific CI job locally.
-
-It reads job definitions from `src/ci/github-actions/jobs.yml`.
-"""
-
-import argparse
-import dataclasses
-import json
-import logging
-import os
-import re
-import subprocess
-import typing
-from pathlib import Path
-from typing import List, Dict, Any, Optional
-
-import yaml
-
-CI_DIR = Path(__file__).absolute().parent.parent
-JOBS_YAML_PATH = Path(__file__).absolute().parent / "jobs.yml"
-
-Job = Dict[str, Any]
-
-
-def add_job_properties(jobs: List[Dict], prefix: str) -> List[Job]:
-    """
-    Modify the `name` attribute of each job, based on its base name and the given `prefix`.
-    Add an `image` attribute to each job, based on its image.
-    """
-    modified_jobs = []
-    for job in jobs:
-        # Create a copy of the `job` dictionary to avoid modifying `jobs`
-        new_job = dict(job)
-        new_job["image"] = get_job_image(new_job)
-        new_job["full_name"] = f"{prefix} - {new_job['name']}"
-        modified_jobs.append(new_job)
-    return modified_jobs
-
-
-def add_base_env(jobs: List[Job], environment: Dict[str, str]) -> List[Job]:
-    """
-    Prepends `environment` to the `env` attribute of each job.
-    The `env` of each job has higher precedence than `environment`.
-    """
-    modified_jobs = []
-    for job in jobs:
-        env = environment.copy()
-        env.update(job.get("env", {}))
-
-        new_job = dict(job)
-        new_job["env"] = env
-        modified_jobs.append(new_job)
-    return modified_jobs
-
-
-@dataclasses.dataclass
-class PRRunType:
-    pass
-
-
-@dataclasses.dataclass
-class TryRunType:
-    custom_jobs: List[str]
-
-
-@dataclasses.dataclass
-class AutoRunType:
-    pass
-
-
-WorkflowRunType = typing.Union[PRRunType, TryRunType, AutoRunType]
-
-
-@dataclasses.dataclass
-class GitHubCtx:
-    event_name: str
-    ref: str
-    repository: str
-    commit_message: Optional[str]
-
-
-def get_custom_jobs(ctx: GitHubCtx) -> List[str]:
-    """
-    Tries to parse names of specific CI jobs that should be executed in the form of
-    try-job: <job-name>
-    from the commit message of the passed GitHub context.
-    """
-    if ctx.commit_message is None:
-        return []
-
-    regex = re.compile(r"^try-job: (.*)", re.MULTILINE)
-    jobs = []
-    for match in regex.finditer(ctx.commit_message):
-        jobs.append(match.group(1))
-    return jobs
-
-
-def find_run_type(ctx: GitHubCtx) -> Optional[WorkflowRunType]:
-    if ctx.event_name == "pull_request":
-        return PRRunType()
-    elif ctx.event_name == "push":
-        try_build = ctx.ref in (
-            "refs/heads/try",
-            "refs/heads/try-perf",
-            "refs/heads/automation/bors/try",
-        )
-
-        # Unrolled branch from a rollup for testing perf
-        # This should **not** allow custom try jobs
-        is_unrolled_perf_build = ctx.ref == "refs/heads/try-perf"
-
-        if try_build:
-            custom_jobs = []
-            if not is_unrolled_perf_build:
-                custom_jobs = get_custom_jobs(ctx)
-            return TryRunType(custom_jobs=custom_jobs)
-
-        if ctx.ref == "refs/heads/auto":
-            return AutoRunType()
-
-    return None
-
-
-def calculate_jobs(run_type: WorkflowRunType, job_data: Dict[str, Any]) -> List[Job]:
-    if isinstance(run_type, PRRunType):
-        return add_base_env(
-            add_job_properties(job_data["pr"], "PR"), job_data["envs"]["pr"]
-        )
-    elif isinstance(run_type, TryRunType):
-        jobs = job_data["try"]
-        custom_jobs = run_type.custom_jobs
-        if custom_jobs:
-            if len(custom_jobs) > 10:
-                raise Exception(
-                    f"It is only possible to schedule up to 10 custom jobs, "
-                    f"received {len(custom_jobs)} jobs"
-                )
-
-            jobs = []
-            unknown_jobs = []
-            for custom_job in custom_jobs:
-                job = [j for j in job_data["auto"] if j["name"] == custom_job]
-                if not job:
-                    unknown_jobs.append(custom_job)
-                    continue
-                jobs.append(job[0])
-            if unknown_jobs:
-                raise Exception(
-                    f"Custom job(s) `{unknown_jobs}` not found in auto jobs"
-                )
-
-        return add_base_env(add_job_properties(jobs, "try"), job_data["envs"]["try"])
-    elif isinstance(run_type, AutoRunType):
-        return add_base_env(
-            add_job_properties(job_data["auto"], "auto"), job_data["envs"]["auto"]
-        )
-
-    return []
-
-
-def skip_jobs(jobs: List[Dict[str, Any]], channel: str) -> List[Job]:
-    """
-    Skip CI jobs that are not supposed to be executed on the given `channel`.
-    """
-    return [j for j in jobs if j.get("only_on_channel", channel) == channel]
-
-
-def get_github_ctx() -> GitHubCtx:
-    event_name = os.environ["GITHUB_EVENT_NAME"]
-
-    commit_message = None
-    if event_name == "push":
-        commit_message = os.environ["COMMIT_MESSAGE"]
-    return GitHubCtx(
-        event_name=event_name,
-        ref=os.environ["GITHUB_REF"],
-        repository=os.environ["GITHUB_REPOSITORY"],
-        commit_message=commit_message,
-    )
-
-
-def format_run_type(run_type: WorkflowRunType) -> str:
-    if isinstance(run_type, PRRunType):
-        return "pr"
-    elif isinstance(run_type, AutoRunType):
-        return "auto"
-    elif isinstance(run_type, TryRunType):
-        return "try"
-    else:
-        raise AssertionError()
-
-
-def get_job_image(job: Job) -> str:
-    """
-    By default, the Docker image of a job is based on its name.
-    However, it can be overridden by its IMAGE environment variable.
-    """
-    env = job.get("env", {})
-    # Return the IMAGE environment variable if it exists, otherwise return the job name
-    return env.get("IMAGE", job["name"])
-
-
-def is_linux_job(job: Job) -> bool:
-    return "ubuntu" in job["os"]
-
-
-def find_linux_job(job_data: Dict[str, Any], job_name: str, pr_jobs: bool) -> Job:
-    candidates = job_data["pr"] if pr_jobs else job_data["auto"]
-    jobs = [job for job in candidates if job.get("name") == job_name]
-    if len(jobs) == 0:
-        available_jobs = "\n".join(
-            sorted(job["name"] for job in candidates if is_linux_job(job))
-        )
-        raise Exception(f"""Job `{job_name}` not found in {'pr' if pr_jobs else 'auto'} jobs.
-The following jobs are available:
-{available_jobs}""")
-    assert len(jobs) == 1
-
-    job = jobs[0]
-    if not is_linux_job(job):
-        raise Exception("Only Linux jobs can be executed locally")
-    return job
-
-
-def run_workflow_locally(job_data: Dict[str, Any], job_name: str, pr_jobs: bool):
-    DOCKER_DIR = Path(__file__).absolute().parent.parent / "docker"
-
-    job = find_linux_job(job_data, job_name=job_name, pr_jobs=pr_jobs)
-
-    custom_env = {}
-    # Replicate src/ci/scripts/setup-environment.sh
-    # Adds custom environment variables to the job
-    if job_name.startswith("dist-"):
-        if job_name.endswith("-alt"):
-            custom_env["DEPLOY_ALT"] = "1"
-        else:
-            custom_env["DEPLOY"] = "1"
-    custom_env.update({k: str(v) for (k, v) in job.get("env", {}).items()})
-
-    args = [str(DOCKER_DIR / "run.sh"), get_job_image(job)]
-    env_formatted = [f"{k}={v}" for (k, v) in sorted(custom_env.items())]
-    print(f"Executing `{' '.join(env_formatted)} {' '.join(args)}`")
-
-    env = os.environ.copy()
-    env.update(custom_env)
-
-    subprocess.run(args, env=env, check=True)
-
-
-def calculate_job_matrix(job_data: Dict[str, Any]):
-    github_ctx = get_github_ctx()
-
-    run_type = find_run_type(github_ctx)
-    logging.info(f"Job type: {run_type}")
-
-    with open(CI_DIR / "channel") as f:
-        channel = f.read().strip()
-
-    jobs = []
-    if run_type is not None:
-        jobs = calculate_jobs(run_type, job_data)
-    jobs = skip_jobs(jobs, channel)
-
-    if not jobs:
-        raise Exception("Scheduled job list is empty, this is an error")
-
-    run_type = format_run_type(run_type)
-
-    logging.info(f"Output:\n{yaml.dump(dict(jobs=jobs, run_type=run_type), indent=4)}")
-    print(f"jobs={json.dumps(jobs)}")
-    print(f"run_type={run_type}")
-
-
-def create_cli_parser():
-    parser = argparse.ArgumentParser(
-        prog="ci.py", description="Generate or run CI workflows"
-    )
-    subparsers = parser.add_subparsers(
-        help="Command to execute", dest="command", required=True
-    )
-    subparsers.add_parser(
-        "calculate-job-matrix",
-        help="Generate a matrix of jobs that should be executed in CI",
-    )
-    run_parser = subparsers.add_parser(
-        "run-local", help="Run a CI jobs locally (on Linux)"
-    )
-    run_parser.add_argument(
-        "job_name",
-        help="CI job that should be executed. By default, a merge (auto) "
-        "job with the given name will be executed",
-    )
-    run_parser.add_argument(
-        "--pr", action="store_true", help="Run a PR job instead of an auto job"
-    )
-    return parser
-
-
-if __name__ == "__main__":
-    logging.basicConfig(level=logging.INFO)
-
-    with open(JOBS_YAML_PATH) as f:
-        data = yaml.safe_load(f)
-
-    parser = create_cli_parser()
-    args = parser.parse_args()
-
-    if args.command == "calculate-job-matrix":
-        calculate_job_matrix(data)
-    elif args.command == "run-local":
-        run_workflow_locally(data, args.job_name, args.pr)
-    else:
-        raise Exception(f"Unknown command {args.command}")
diff --git a/src/ci/github-actions/jobs.yml b/src/ci/github-actions/jobs.yml
index 64e64867de26..bbcc01a0c299 100644
--- a/src/ci/github-actions/jobs.yml
+++ b/src/ci/github-actions/jobs.yml
@@ -51,9 +51,11 @@ runners:
     # Free some disk space to avoid running out of space during the build.
     free_disk: true
     os: ubuntu-24.04-arm
+    <<: *base-job
 
   - &job-aarch64-linux-8c
     os: ubuntu-22.04-arm64-8core-32gb
+    <<: *base-job
 envs:
   env-x86_64-apple-tests: &env-x86_64-apple-tests
     SCRIPT: ./x.py --stage 2 test --skip tests/ui --skip tests/rustdoc -- --exact
diff --git a/src/ci/run.sh b/src/ci/run.sh
index 536754f12bc6..b874f71832d7 100755
--- a/src/ci/run.sh
+++ b/src/ci/run.sh
@@ -279,5 +279,5 @@ if [ "$RUN_CHECK_WITH_PARALLEL_QUERIES" != "" ]; then
 fi
 
 echo "::group::sccache stats"
-sccache --show-adv-stats || true
+sccache --show-stats || true
 echo "::endgroup::"
diff --git a/src/doc/book b/src/doc/book
index d4d2c18cbd20..4a01a9182496 160000
--- a/src/doc/book
+++ b/src/doc/book
@@ -1 +1 @@
-Subproject commit d4d2c18cbd20876b2130a546e790446a8444cb32
+Subproject commit 4a01a9182496f807aaa5f72d93a25ce18bcbe105
diff --git a/src/doc/edition-guide b/src/doc/edition-guide
index 8dbdda7cae4f..daa4b763cd84 160000
--- a/src/doc/edition-guide
+++ b/src/doc/edition-guide
@@ -1 +1 @@
-Subproject commit 8dbdda7cae4fa030f09f8f5b63994d4d1dde74b9
+Subproject commit daa4b763cd848f986813b5cf8069e1649f7147af
diff --git a/src/doc/nomicon b/src/doc/nomicon
index 336f75835a6c..8f5c7322b65d 160000
--- a/src/doc/nomicon
+++ b/src/doc/nomicon
@@ -1 +1 @@
-Subproject commit 336f75835a6c0514852cc65aba9a698b699b13c8
+Subproject commit 8f5c7322b65d079aa5b242eb10d89a98e12471e1
diff --git a/src/doc/reference b/src/doc/reference
index 6195dbd70fc6..615b4cec60c2 160000
--- a/src/doc/reference
+++ b/src/doc/reference
@@ -1 +1 @@
-Subproject commit 6195dbd70fc6f0980c314b4d23875ac570d8253a
+Subproject commit 615b4cec60c269cfc105d511c93287620032d5b0
diff --git a/src/doc/rustc-dev-guide/.github/workflows/ci.yml b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
index 3f810e2fbcc9..22a4fb1901ab 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/ci.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/ci.yml
@@ -6,8 +6,8 @@ on:
       - master
   pull_request:
   schedule:
-    # Run at 18:00 UTC every day
-    - cron: '0 18 * * *'
+    # Run multiple times a day as the successfull cached links are not checked every time.
+    - cron: '0 */8 * * *'
 
 jobs:
   ci:
@@ -15,7 +15,7 @@ jobs:
     runs-on: ubuntu-latest
     env:
       MDBOOK_VERSION: 0.4.21
-      MDBOOK_LINKCHECK2_VERSION: 0.8.1
+      MDBOOK_LINKCHECK2_VERSION: 0.9.1
       MDBOOK_MERMAID_VERSION: 0.12.6
       MDBOOK_TOC_VERSION: 0.11.2
       DEPLOY_DIR: book/html
diff --git a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
index dc5395a19dd0..b19eccf9eb8c 100644
--- a/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
+++ b/src/doc/rustc-dev-guide/.github/workflows/rustc-pull.yml
@@ -111,4 +111,4 @@ jobs:
           to: 196385
           type: "stream"
           topic: "Subtree sync automation"
-          content: ${{ steps.message.outputs.message }}
+          content: ${{ steps.create-message.outputs.message }}
diff --git a/src/doc/rustc-dev-guide/examples/README b/src/doc/rustc-dev-guide/examples/README
index ca49dd74db26..05e44673700a 100644
--- a/src/doc/rustc-dev-guide/examples/README
+++ b/src/doc/rustc-dev-guide/examples/README
@@ -4,7 +4,10 @@ For each example to compile, you will need to first run the following:
 
 To create an executable:
 
-    rustc rustc-driver-example.rs
+    rustup run nightly rustc rustc-driver-example.rs
+
+You might need to be more specific about the exact nightly version. See the comments at the top of
+the examples for the version they were written for.
 
 To run an executable:
 
diff --git a/src/doc/rustc-dev-guide/examples/rustc-driver-example.rs b/src/doc/rustc-dev-guide/examples/rustc-driver-example.rs
index 14998965ac86..984bd3e37ae3 100644
--- a/src/doc/rustc-dev-guide/examples/rustc-driver-example.rs
+++ b/src/doc/rustc-dev-guide/examples/rustc-driver-example.rs
@@ -1,3 +1,5 @@
+// Tested with nightly-2025-02-13
+
 #![feature(rustc_private)]
 
 extern crate rustc_ast;
@@ -73,7 +75,7 @@ impl rustc_driver::Callbacks for MyCallbacks {
             let hir = tcx.hir();
             let item = hir.item(id);
             match item.kind {
-                rustc_hir::ItemKind::Static(_, _, _) | rustc_hir::ItemKind::Fn(_, _, _) => {
+                rustc_hir::ItemKind::Static(_, _, _) | rustc_hir::ItemKind::Fn { .. } => {
                     let name = item.ident;
                     let ty = tcx.type_of(item.hir_id().owner.def_id);
                     println!("{name:?}:\t{ty:?}")
@@ -87,5 +89,13 @@ impl rustc_driver::Callbacks for MyCallbacks {
 }
 
 fn main() {
-    run_compiler(&["main.rs".to_string()], &mut MyCallbacks);
+    run_compiler(
+        &[
+            // The first argument, which in practice contains the name of the binary being executed
+            // (i.e. "rustc") is ignored by rustc.
+            "ignored".to_string(),
+            "main.rs".to_string(),
+        ],
+        &mut MyCallbacks,
+    );
 }
diff --git a/src/doc/rustc-dev-guide/examples/rustc-driver-interacting-with-the-ast.rs b/src/doc/rustc-dev-guide/examples/rustc-driver-interacting-with-the-ast.rs
index dc63e1aa511b..3270c722e077 100644
--- a/src/doc/rustc-dev-guide/examples/rustc-driver-interacting-with-the-ast.rs
+++ b/src/doc/rustc-dev-guide/examples/rustc-driver-interacting-with-the-ast.rs
@@ -1,3 +1,5 @@
+// Tested with nightly-2025-02-13
+
 #![feature(rustc_private)]
 
 extern crate rustc_ast;
@@ -18,7 +20,7 @@ use std::path::Path;
 use std::sync::Arc;
 
 use rustc_ast_pretty::pprust::item_to_string;
-use rustc_driver::{Compilation, run_compiler};
+use rustc_driver::{run_compiler, Compilation};
 use rustc_interface::interface::{Compiler, Config};
 use rustc_middle::ty::TyCtxt;
 
@@ -74,8 +76,8 @@ impl rustc_driver::Callbacks for MyCallbacks {
         for id in hir_krate.items() {
             let item = hir_krate.item(id);
             // Use pattern-matching to find a specific node inside the main function.
-            if let rustc_hir::ItemKind::Fn(_, _, body_id) = item.kind {
-                let expr = &tcx.hir_body(body_id).value;
+            if let rustc_hir::ItemKind::Fn { body, .. } = item.kind {
+                let expr = &tcx.hir_body(body).value;
                 if let rustc_hir::ExprKind::Block(block, _) = expr.kind {
                     if let rustc_hir::StmtKind::Let(let_stmt) = block.stmts[0].kind {
                         if let Some(expr) = let_stmt.init {
@@ -94,5 +96,13 @@ impl rustc_driver::Callbacks for MyCallbacks {
 }
 
 fn main() {
-    run_compiler(&["main.rs".to_string()], &mut MyCallbacks);
+    run_compiler(
+        &[
+            // The first argument, which in practice contains the name of the binary being executed
+            // (i.e. "rustc") is ignored by rustc.
+            "ignored".to_string(),
+            "main.rs".to_string(),
+        ],
+        &mut MyCallbacks,
+    );
 }
diff --git a/src/doc/rustc-dev-guide/examples/rustc-interface-example.rs b/src/doc/rustc-dev-guide/examples/rustc-interface-example.rs
index 30f48ea52978..70f27c2a82a9 100644
--- a/src/doc/rustc-dev-guide/examples/rustc-interface-example.rs
+++ b/src/doc/rustc-dev-guide/examples/rustc-interface-example.rs
@@ -1,3 +1,5 @@
+// Tested with nightly-2025-02-13
+
 #![feature(rustc_private)]
 
 extern crate rustc_driver;
@@ -9,8 +11,6 @@ extern crate rustc_interface;
 extern crate rustc_session;
 extern crate rustc_span;
 
-use std::sync::Arc;
-
 use rustc_errors::registry;
 use rustc_hash::FxHashMap;
 use rustc_session::config;
@@ -56,7 +56,7 @@ fn main() {
         expanded_args: Vec::new(),
         ice_file: None,
         hash_untracked_state: None,
-        using_internal_features: Arc::default(),
+        using_internal_features: &rustc_driver::USING_INTERNAL_FEATURES,
     };
     rustc_interface::run_compiler(config, |compiler| {
         // Parse the program and print the syntax tree.
@@ -68,7 +68,7 @@ fn main() {
                 let hir = tcx.hir();
                 let item = hir.item(id);
                 match item.kind {
-                    rustc_hir::ItemKind::Static(_, _, _) | rustc_hir::ItemKind::Fn(_, _, _) => {
+                    rustc_hir::ItemKind::Static(_, _, _) | rustc_hir::ItemKind::Fn { .. } => {
                         let name = item.ident;
                         let ty = tcx.type_of(item.hir_id().owner.def_id);
                         println!("{name:?}:\t{ty:?}")
diff --git a/src/doc/rustc-dev-guide/examples/rustc-interface-getting-diagnostics.rs b/src/doc/rustc-dev-guide/examples/rustc-interface-getting-diagnostics.rs
index 2355cb85ab3d..39b236e1783a 100644
--- a/src/doc/rustc-dev-guide/examples/rustc-interface-getting-diagnostics.rs
+++ b/src/doc/rustc-dev-guide/examples/rustc-interface-getting-diagnostics.rs
@@ -1,3 +1,5 @@
+// Tested with nightly-2025-02-13
+
 #![feature(rustc_private)]
 
 extern crate rustc_data_structures;
@@ -15,7 +17,7 @@ use std::sync::{Arc, Mutex};
 use rustc_errors::emitter::Emitter;
 use rustc_errors::registry::{self, Registry};
 use rustc_errors::translation::Translate;
-use rustc_errors::{DiagCtxt, DiagInner, FluentBundle};
+use rustc_errors::{DiagInner, FluentBundle};
 use rustc_session::config;
 use rustc_span::source_map::SourceMap;
 
@@ -79,7 +81,7 @@ fn main() {
         expanded_args: Vec::new(),
         ice_file: None,
         hash_untracked_state: None,
-        using_internal_features: Arc::default(),
+        using_internal_features: &rustc_driver::USING_INTERNAL_FEATURES,
     };
     rustc_interface::run_compiler(config, |compiler| {
         let krate = rustc_interface::passes::parse(&compiler.sess);
diff --git a/src/doc/rustc-dev-guide/rust-version b/src/doc/rustc-dev-guide/rust-version
index 78e9ecdf174b..ce21bb8ef390 100644
--- a/src/doc/rustc-dev-guide/rust-version
+++ b/src/doc/rustc-dev-guide/rust-version
@@ -1 +1 @@
-124cc92199ffa924f6b4c7cc819a85b65e0c3984
+4ecd70ddd1039a3954056c1071e40278048476fa
diff --git a/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md b/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md
index 04d8e91dcb4f..24b9783ddf09 100644
--- a/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md
+++ b/src/doc/rustc-dev-guide/src/building/bootstrapping/debugging-bootstrap.md
@@ -1,7 +1,46 @@
 # Debugging bootstrap
 
+There are two main ways to debug bootstrap itself. The first is through println logging, and the second is through the `tracing` feature.
+
 > FIXME: this section should be expanded
 
+## `println` logging
+
+Bootstrap has extensive unstructured logging. Most of it is gated behind the `--verbose` flag (pass `-vv` for even more detail).
+
+If you want to know which `Step` ran a command, you could invoke bootstrap like so:
+
+```
+$ ./x dist rustc --dry-run -vv
+learning about cargo
+running: RUSTC_BOOTSTRAP="1" "/home/jyn/src/rust2/build/x86_64-unknown-linux-gnu/stage0/bin/cargo" "metadata" "--format-version" "1" "--no-deps" "--manifest-path" "/home/jyn/src/rust2/Cargo.toml" (failure_mode=Exit) (created at src/bootstrap/src/core/metadata.rs:81:25, executed at src/bootstrap/src/core/metadata.rs:92:50)
+running: RUSTC_BOOTSTRAP="1" "/home/jyn/src/rust2/build/x86_64-unknown-linux-gnu/stage0/bin/cargo" "metadata" "--format-version" "1" "--no-deps" "--manifest-path" "/home/jyn/src/rust2/library/Cargo.toml" (failure_mode=Exit) (created at src/bootstrap/src/core/metadata.rs:81:25, executed at src/bootstrap/src/core/metadata.rs:92:50)
+> Assemble { target_compiler: Compiler { stage: 1, host: x86_64-unknown-linux-gnu } }
+  > Libdir { compiler: Compiler { stage: 1, host: x86_64-unknown-linux-gnu }, target: x86_64-unknown-linux-gnu }
+    > Sysroot { compiler: Compiler { stage: 1, host: x86_64-unknown-linux-gnu }, force_recompile: false }
+Removing sysroot /home/jyn/src/rust2/build/tmp-dry-run/x86_64-unknown-linux-gnu/stage1 to avoid caching bugs
+    < Sysroot { compiler: Compiler { stage: 1, host: x86_64-unknown-linux-gnu }, force_recompile: false }
+  < Libdir { compiler: Compiler { stage: 1, host: x86_64-unknown-linux-gnu }, target: x86_64-unknown-linux-gnu }
+...
+```
+
+This will go through all the recursive dependency calculations, where `Step`s internally call `builder.ensure()`, without actually running cargo or the compiler.
+
+In some cases, even this may not be enough logging (if so, please add more!). In that case, you can omit `--dry-run`, which will show the normal output inline with the debug logging:
+
+```
+      c Sysroot { compiler: Compiler { stage: 0, host: x86_64-unknown-linux-gnu }, force_recompile: false }
+using sysroot /home/jyn/src/rust2/build/x86_64-unknown-linux-gnu/stage0-sysroot
+Building stage0 library artifacts (x86_64-unknown-linux-gnu)
+running: cd "/home/jyn/src/rust2" && env ... RUSTC_VERBOSE="2" RUSTC_WRAPPER="/home/jyn/src/rust2/build/bootstrap/debug/rustc" "/home/jyn/src/rust2/build/x86_64-unknown-linux-gnu/stage0/bin/cargo" "build" "--target" "x86_64-unknown-linux-gnu" "-Zbinary-dep-depinfo" "-Zroot-dir=/home/jyn/src/rust2" "-v" "-v" "--manifest-path" "/home/jyn/src/rust2/library/sysroot/Cargo.toml" "--message-format" "json-render-diagnostics"
+   0.293440230s  INFO prepare_target{force=false package_id=sysroot v0.0.0 (/home/jyn/src/rust2/library/sysroot) target="sysroot"}: cargo::core::compiler::fingerprint: fingerprint error for sysroot v0.0.0 (/home/jyn/src/rust2/library/sysroot)/Build/TargetInner { name_inferred: true, ..: lib_target("sysroot", ["lib"], "/home/jyn/src/rust2/library/sysroot/src/lib.rs", Edition2021) }
+...
+```
+
+In most cases this should not be necessary.
+
+TODO: we should convert all this to structured logging so it's easier to control precisely.
+
 ## `tracing` in bootstrap
 
 Bootstrap has conditional [`tracing`][tracing] setup to provide structured logging.
@@ -53,11 +92,11 @@ Checking stage0 bootstrap artifacts (x86_64-unknown-linux-gnu)
 Build completed successfully in 0:00:08
 ```
 
-#### Controlling log output
+#### Controlling tracing output
 
 The env var `BOOTSTRAP_TRACING` accepts a [`tracing` env-filter][tracing-env-filter].
 
-There are two orthogonal ways to control which kind of logs you want:
+There are two orthogonal ways to control which kind of tracing logs you want:
 
 1. You can specify the log **level**, e.g. `DEBUG` or `TRACE`.
 2. You can also control the log **target**, e.g. `bootstrap` or `bootstrap::core::config` vs custom targets like `CONFIG_HANDLING`.
diff --git a/src/doc/rustc-dev-guide/src/building/optimized-build.md b/src/doc/rustc-dev-guide/src/building/optimized-build.md
index 8feda59829b4..f8ca1d0dc391 100644
--- a/src/doc/rustc-dev-guide/src/building/optimized-build.md
+++ b/src/doc/rustc-dev-guide/src/building/optimized-build.md
@@ -126,4 +126,4 @@ Here is an example of how can `opt-dist` be used locally (outside of CI):
 [`Environment`]: https://github.com/rust-lang/rust/blob/ee451f8faccf3050c76cdcd82543c917b40c7962/src/tools/opt-dist/src/environment.rs#L5
 
 > Note: if you want to run the actual CI pipeline, instead of running `opt-dist` locally,
-> you can execute `python3 src/ci/github-actions/ci.py run-local dist-x86_64-linux`.
+> you can execute `cargo run --manifest-path src/ci/citool/Cargo.toml run-local dist-x86_64-linux`.
diff --git a/src/doc/rustc-dev-guide/src/building/suggested.md b/src/doc/rustc-dev-guide/src/building/suggested.md
index 5c041d6cb70f..2498838144e7 100644
--- a/src/doc/rustc-dev-guide/src/building/suggested.md
+++ b/src/doc/rustc-dev-guide/src/building/suggested.md
@@ -120,10 +120,35 @@ create a `.vim/coc-settings.json`. The settings can be edited with
 [`src/etc/rust_analyzer_settings.json`].
 
 Another way is without a plugin, and creating your own logic in your
-configuration. To do this you must translate the JSON to Lua yourself. The
-translation is 1:1 and fairly straight-forward. It must be put in the
-`["rust-analyzer"]` key of the setup table, which is [shown
-here](https://github.com/neovim/nvim-lspconfig/blob/master/doc/server_configurations.md#rust_analyzer).
+configuration. The following code will work for any checkout of rust-lang/rust (newer than Febuary 2025):
+
+```lua
+lspconfig.rust_analyzer.setup {
+    root_dir = function()
+        local default = lspconfig.rust_analyzer.config_def.default_config.root_dir()
+        -- the default root detection uses the cargo workspace root.
+        -- but for rust-lang/rust, the standard library is in its own workspace.
+        -- use the git root instead.
+        local compiler_config = vim.fs.joinpath(default, "../src/bootstrap/defaults/config.compiler.toml")
+        if vim.fs.basename(default) == "library" and vim.uv.fs_stat(compiler_config) then
+            return vim.fs.dirname(default)
+        end
+        return default
+    end,
+    on_init = function(client)
+        local path = client.workspace_folders[1].name
+        local config = vim.fs.joinpath(path, "src/etc/rust_analyzer_zed.json")
+        if vim.uv.fs_stat(config) then
+            -- load rust-lang/rust settings
+            local file = io.open(config)
+            local json = vim.json.decode(file:read("*a"))
+            client.config.settings["rust-analyzer"] = json.lsp["rust-analyzer"].initialization_options
+            client.notify("workspace/didChangeConfiguration", { settings = client.config.settings })
+        end
+        return true
+    end
+}
+```
 
 If you would like to use the build task that is described above, you may either
 make your own command in your config, or you can install a plugin such as
diff --git a/src/doc/rustc-dev-guide/src/compiler-debugging.md b/src/doc/rustc-dev-guide/src/compiler-debugging.md
index e2097b26e5c8..c16b3ee7abdb 100644
--- a/src/doc/rustc-dev-guide/src/compiler-debugging.md
+++ b/src/doc/rustc-dev-guide/src/compiler-debugging.md
@@ -368,7 +368,7 @@ error: layout_of(&'a u32) = Layout {
 error: aborting due to previous error
 ```
 
-[`Layout`]: https://doc.rust-lang.org/nightly/nightly-rustc/rustc_target/abi/struct.Layout.html
+[`Layout`]: https://doc.rust-lang.org/nightly/nightly-rustc/stable_mir/abi/struct.Layout.html
 
 
 ## Configuring CodeLLDB for debugging `rustc`
diff --git a/src/doc/rustc-dev-guide/src/profiling/with_perf.md b/src/doc/rustc-dev-guide/src/profiling/with_perf.md
index 6cd98f886ddd..51a22d18577e 100644
--- a/src/doc/rustc-dev-guide/src/profiling/with_perf.md
+++ b/src/doc/rustc-dev-guide/src/profiling/with_perf.md
@@ -52,6 +52,13 @@ you made in the beginning. But there are some things to be aware of:
 - You probably don't want incremental messing about with your
   profile. So something like `CARGO_INCREMENTAL=0` can be helpful.
 
+In case to avoid the issue of `addr2line xxx/elf: could not read first record` when reading
+collected data from `cargo`, you may need use the latest version of `addr2line`:
+
+```bash
+cargo install addr2line --features="bin"
+```
+
 ### Gathering a perf profile from a `perf.rust-lang.org` test
 
 Often we want to analyze a specific test from `perf.rust-lang.org`.
diff --git a/src/doc/rustc-dev-guide/src/rustc-driver/getting-diagnostics.md b/src/doc/rustc-dev-guide/src/rustc-driver/getting-diagnostics.md
index e3ca323058c8..1043df6ecb65 100644
--- a/src/doc/rustc-dev-guide/src/rustc-driver/getting-diagnostics.md
+++ b/src/doc/rustc-dev-guide/src/rustc-driver/getting-diagnostics.md
@@ -8,7 +8,6 @@ otherwise be printed to stderr.
 To get diagnostics from the compiler,
 configure [`rustc_interface::Config`] to output diagnostic to a buffer,
 and run [`TyCtxt.analysis`].
-The following was tested with <!-- date-check: september 2024 --> `nightly-2024-09-16`:
 
 ```rust
 {{#include ../../examples/rustc-interface-getting-diagnostics.rs}}
diff --git a/src/doc/rustc-dev-guide/src/rustc-driver/interacting-with-the-ast.md b/src/doc/rustc-dev-guide/src/rustc-driver/interacting-with-the-ast.md
index 5eaa0c82c9ee..f46418701a7d 100644
--- a/src/doc/rustc-dev-guide/src/rustc-driver/interacting-with-the-ast.md
+++ b/src/doc/rustc-dev-guide/src/rustc-driver/interacting-with-the-ast.md
@@ -5,7 +5,6 @@
 ## Getting the type of an expression
 
 To get the type of an expression, use the [`after_analysis`] callback to get a [`TyCtxt`].
-The following was tested with <!-- date-check: december 2024 --> `nightly-2024-12-15`:
 
 ```rust
 {{#include ../../examples/rustc-driver-interacting-with-the-ast.rs}}
diff --git a/src/doc/rustc-dev-guide/src/tests/ci.md b/src/doc/rustc-dev-guide/src/tests/ci.md
index a4b22392f197..ae6adb678af1 100644
--- a/src/doc/rustc-dev-guide/src/tests/ci.md
+++ b/src/doc/rustc-dev-guide/src/tests/ci.md
@@ -28,7 +28,7 @@ Our CI is primarily executed on [GitHub Actions], with a single workflow defined
 in [`.github/workflows/ci.yml`], which contains a bunch of steps that are
 unified for all CI jobs that we execute. When a commit is pushed to a
 corresponding branch or a PR, the workflow executes the
-[`src/ci/github-actions/ci.py`] script, which dynamically generates the specific CI
+[`src/ci/citool`] crate, which dynamically generates the specific CI
 jobs that should be executed. This script uses the [`jobs.yml`] file as an
 input, which contains a declarative configuration of all our CI jobs.
 
@@ -299,7 +299,7 @@ platform’s custom [Docker container]. This has a lot of advantages for us:
 - We can avoid reinstalling tools (like QEMU or the Android emulator) every time
   thanks to Docker image caching.
 - Users can run the same tests in the same environment locally by just running
-  `python3 src/ci/github-actions/ci.py run-local <job-name>`, which is awesome to debug failures. Note that there are only linux docker images available locally due to licensing and
+  `cargo run --manifest-path src/ci/citool/Cargo.toml run-local <job-name>`, which is awesome to debug failures. Note that there are only linux docker images available locally due to licensing and
   other restrictions.
 
 The docker images prefixed with `dist-` are used for building artifacts while
@@ -443,7 +443,7 @@ this:
 [GitHub Actions]: https://github.com/rust-lang/rust/actions
 [`jobs.yml`]: https://github.com/rust-lang/rust/blob/master/src/ci/github-actions/jobs.yml
 [`.github/workflows/ci.yml`]: https://github.com/rust-lang/rust/blob/master/.github/workflows/ci.yml
-[`src/ci/github-actions/ci.py`]: https://github.com/rust-lang/rust/blob/master/src/ci/github-actions/ci.py
+[`src/ci/citool`]: https://github.com/rust-lang/rust/blob/master/src/ci/citool
 [rust-lang-ci]: https://github.com/rust-lang-ci/rust/actions
 [bors]: https://github.com/bors
 [homu]: https://github.com/rust-lang/homu
diff --git a/src/doc/rustc-dev-guide/src/tests/docker.md b/src/doc/rustc-dev-guide/src/tests/docker.md
index 2ca08d42130a..a8a388ef90cf 100644
--- a/src/doc/rustc-dev-guide/src/tests/docker.md
+++ b/src/doc/rustc-dev-guide/src/tests/docker.md
@@ -53,6 +53,15 @@ Some additional notes about using the interactive mode:
   containers. With the container name, run `docker exec -it <CONTAINER>
   /bin/bash` where `<CONTAINER>` is the container name like `4ba195e95cef`.
 
+The approach described above is a relatively low-level interface for running the Docker images
+directly. If you want to run a full CI Linux job locally with Docker, in a way that is as close to CI as possible, you can use the following command:
+
+```bash
+cargo run --manifest-path src/ci/citool/Cargo.toml run-local <job-name>
+# For example:
+cargo run --manifest-path src/ci/citool/Cargo.toml run-local dist-x86_64-linux-alt
+```
+
 [Docker]: https://www.docker.com/
 [`src/ci/docker`]: https://github.com/rust-lang/rust/tree/master/src/ci/docker
 [`src/ci/docker/run.sh`]: https://github.com/rust-lang/rust/blob/master/src/ci/docker/run.sh
diff --git a/src/doc/rustdoc/src/write-documentation/re-exports.md b/src/doc/rustdoc/src/write-documentation/re-exports.md
index 34688545c74e..ee60916351ab 100644
--- a/src/doc/rustdoc/src/write-documentation/re-exports.md
+++ b/src/doc/rustdoc/src/write-documentation/re-exports.md
@@ -85,7 +85,22 @@ pub struct Hidden;
 pub use self::Hidden as InlinedHidden;
 ```
 
-The same applies on re-exports themselves: if you have multiple re-exports and some of them have
+However, if you still want the re-export itself to be visible, you can add the `#[doc(inline)]`
+attribute on it:
+
+```rust,ignore (inline)
+// This struct won't be visible.
+#[doc(hidden)]
+pub struct Hidden;
+
+#[doc(inline)]
+pub use self::Hidden as InlinedHidden;
+```
+
+In this case, you will have `pub use self::Hidden as InlinedHidden;` in the generated documentation
+but no link to the `Hidden` item.
+
+So back to `#[doc(hidden)]`: if you have multiple re-exports and some of them have
 `#[doc(hidden)]`, then these ones (and only these) won't appear in the documentation:
 
 ```rust,ignore (inline)
diff --git a/src/doc/unstable-book/src/language-features/intrinsics.md b/src/doc/unstable-book/src/language-features/intrinsics.md
index 13a6814d31be..975b400447eb 100644
--- a/src/doc/unstable-book/src/language-features/intrinsics.md
+++ b/src/doc/unstable-book/src/language-features/intrinsics.md
@@ -62,13 +62,19 @@ These must be implemented by all backends.
 
 ### `#[rustc_intrinsic]` declarations
 
-These are written like intrinsics with fallback bodies, but the body is irrelevant.
-Use `loop {}` for the body or call the intrinsic recursively and add
-`#[rustc_intrinsic_must_be_overridden]` to the function to ensure that backends don't
-invoke the body.
+These are written without a body:
+```rust
+#![feature(intrinsics)]
+#![allow(internal_features)]
+
+#[rustc_intrinsic]
+pub fn abort() -> !;
+```
 
 ### Legacy extern ABI based intrinsics
 
+*This style is deprecated, always prefer the above form.*
+
 These are imported as if they were FFI functions, with the special
 `rust-intrinsic` ABI. For example, if one was in a freestanding
 context, but wished to be able to `transmute` between types, and
diff --git a/src/gcc b/src/gcc
index fd3498bff0b9..48664a6cab29 160000
--- a/src/gcc
+++ b/src/gcc
@@ -1 +1 @@
-Subproject commit fd3498bff0b939dda91d56960acc33d55f2f9cdf
+Subproject commit 48664a6cab29d48138ffa004b7978d52ef73e3ac
diff --git a/src/librustdoc/Cargo.toml b/src/librustdoc/Cargo.toml
index c07cc4dc347a..91cc40887882 100644
--- a/src/librustdoc/Cargo.toml
+++ b/src/librustdoc/Cargo.toml
@@ -15,6 +15,7 @@ itertools = "0.12"
 indexmap = "2"
 minifier = { version = "0.3.5", default-features = false }
 pulldown-cmark-old = { version = "0.9.6", package = "pulldown-cmark", default-features = false }
+pulldown-cmark-escape = { version = "0.11.0", features = ["simd"] }
 regex = "1"
 rustdoc-json-types = { path = "../rustdoc-json-types" }
 serde_json = "1.0"
diff --git a/src/librustdoc/clean/mod.rs b/src/librustdoc/clean/mod.rs
index dcc5fd12d81b..ceffe5e5ce04 100644
--- a/src/librustdoc/clean/mod.rs
+++ b/src/librustdoc/clean/mod.rs
@@ -2737,13 +2737,13 @@ fn add_without_unwanted_attributes<'hir>(
     import_parent: Option<DefId>,
 ) {
     for attr in new_attrs {
-        if matches!(attr.kind, hir::AttrKind::DocComment(..)) {
+        if attr.is_doc_comment() {
             attrs.push((Cow::Borrowed(attr), import_parent));
             continue;
         }
         let mut attr = attr.clone();
-        match attr.kind {
-            hir::AttrKind::Normal(ref mut normal) => {
+        match attr {
+            hir::Attribute::Unparsed(ref mut normal) => {
                 if let [ident] = &*normal.path.segments {
                     let ident = ident.name;
                     if ident == sym::doc {
@@ -2755,7 +2755,11 @@ fn add_without_unwanted_attributes<'hir>(
                     }
                 }
             }
-            _ => unreachable!(),
+            hir::Attribute::Parsed(..) => {
+                if is_inline {
+                    attrs.push((Cow::Owned(attr), import_parent));
+                }
+            }
         }
     }
 }
diff --git a/src/librustdoc/clean/types.rs b/src/librustdoc/clean/types.rs
index fc7c4b42047d..178b6a60b41f 100644
--- a/src/librustdoc/clean/types.rs
+++ b/src/librustdoc/clean/types.rs
@@ -265,7 +265,7 @@ impl ExternalCrate {
                     let attr_value = attr.value_str().expect("syntax should already be validated");
                     let Some(prim) = PrimitiveType::from_symbol(attr_value) else {
                         span_bug!(
-                            attr.span,
+                            attr.span(),
                             "primitive `{attr_value}` is not a member of `PrimitiveType`"
                         );
                     };
diff --git a/src/librustdoc/doctest/make.rs b/src/librustdoc/doctest/make.rs
index 4792bc525a59..9935074877bc 100644
--- a/src/librustdoc/doctest/make.rs
+++ b/src/librustdoc/doctest/make.rs
@@ -208,7 +208,7 @@ impl DocTestBuilder {
             let (main_pre, main_post) = if returns_result {
                 (
                     format!(
-                        "fn main() {{ {inner_attr}fn {inner_fn_name}() -> Result<(), impl core::fmt::Debug> {{\n",
+                        "fn main() {{ {inner_attr}fn {inner_fn_name}() -> core::result::Result<(), impl core::fmt::Debug> {{\n",
                     ),
                     format!("\n}} {inner_fn_name}().unwrap() }}"),
                 )
diff --git a/src/librustdoc/doctest/rust.rs b/src/librustdoc/doctest/rust.rs
index 1ac3c040b591..3ac7abd0aa5d 100644
--- a/src/librustdoc/doctest/rust.rs
+++ b/src/librustdoc/doctest/rust.rs
@@ -123,7 +123,7 @@ impl HirCollector<'_> {
                     .iter()
                     .find(|attr| attr.doc_str().is_some())
                     .map(|attr| {
-                        attr.span.ctxt().outer_expn().expansion_cause().unwrap_or(attr.span)
+                        attr.span().ctxt().outer_expn().expansion_cause().unwrap_or(attr.span())
                     })
                     .unwrap_or(DUMMY_SP)
             };
diff --git a/src/librustdoc/doctest/tests.rs b/src/librustdoc/doctest/tests.rs
index fa6cca3681be..e2b964bf5af5 100644
--- a/src/librustdoc/doctest/tests.rs
+++ b/src/librustdoc/doctest/tests.rs
@@ -316,7 +316,7 @@ let mut input = String::new();
 io::stdin().read_line(&mut input)?;
 Ok::<(), io:Error>(())";
     let expected = "#![allow(unused)]
-fn main() { fn _inner() -> Result<(), impl core::fmt::Debug> {
+fn main() { fn _inner() -> core::result::Result<(), impl core::fmt::Debug> {
 use std::io;
 let mut input = String::new();
 io::stdin().read_line(&mut input)?;
diff --git a/src/librustdoc/html/escape.rs b/src/librustdoc/html/escape.rs
index 88654ed32da9..ac9e2f42cc6d 100644
--- a/src/librustdoc/html/escape.rs
+++ b/src/librustdoc/html/escape.rs
@@ -5,6 +5,7 @@
 
 use std::fmt;
 
+use pulldown_cmark_escape::FmtWriter;
 use unicode_segmentation::UnicodeSegmentation;
 
 /// Wrapper struct which will emit the HTML-escaped version of the contained
@@ -13,31 +14,7 @@ pub(crate) struct Escape<'a>(pub &'a str);
 
 impl fmt::Display for Escape<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Because the internet is always right, turns out there's not that many
-        // characters to escape: http://stackoverflow.com/questions/7381974
-        let Escape(s) = *self;
-        let pile_o_bits = s;
-        let mut last = 0;
-        for (i, ch) in s.char_indices() {
-            let s = match ch {
-                '>' => "&gt;",
-                '<' => "&lt;",
-                '&' => "&amp;",
-                '\'' => "&#39;",
-                '"' => "&quot;",
-                _ => continue,
-            };
-            fmt.write_str(&pile_o_bits[last..i])?;
-            fmt.write_str(s)?;
-            // NOTE: we only expect single byte characters here - which is fine as long as we
-            // only match single byte characters
-            last = i + 1;
-        }
-
-        if last < s.len() {
-            fmt.write_str(&pile_o_bits[last..])?;
-        }
-        Ok(())
+        pulldown_cmark_escape::escape_html(FmtWriter(fmt), self.0)
     }
 }
 
@@ -51,29 +28,7 @@ pub(crate) struct EscapeBodyText<'a>(pub &'a str);
 
 impl fmt::Display for EscapeBodyText<'_> {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Because the internet is always right, turns out there's not that many
-        // characters to escape: http://stackoverflow.com/questions/7381974
-        let EscapeBodyText(s) = *self;
-        let pile_o_bits = s;
-        let mut last = 0;
-        for (i, ch) in s.char_indices() {
-            let s = match ch {
-                '>' => "&gt;",
-                '<' => "&lt;",
-                '&' => "&amp;",
-                _ => continue,
-            };
-            fmt.write_str(&pile_o_bits[last..i])?;
-            fmt.write_str(s)?;
-            // NOTE: we only expect single byte characters here - which is fine as long as we
-            // only match single byte characters
-            last = i + 1;
-        }
-
-        if last < s.len() {
-            fmt.write_str(&pile_o_bits[last..])?;
-        }
-        Ok(())
+        pulldown_cmark_escape::escape_html_body_text(FmtWriter(fmt), self.0)
     }
 }
 
diff --git a/src/librustdoc/html/format.rs b/src/librustdoc/html/format.rs
index 91b4b3ba1eba..522ef1af376c 100644
--- a/src/librustdoc/html/format.rs
+++ b/src/librustdoc/html/format.rs
@@ -30,7 +30,7 @@ use super::url_parts_builder::{UrlPartsBuilder, estimate_item_path_byte_length};
 use crate::clean::types::ExternalLocation;
 use crate::clean::utils::find_nearest_parent_module;
 use crate::clean::{self, ExternalCrate, PrimitiveType};
-use crate::display::Joined as _;
+use crate::display::{Joined as _, MaybeDisplay as _};
 use crate::formats::cache::Cache;
 use crate::formats::item_type::ItemType;
 use crate::html::escape::{Escape, EscapeBodyText};
@@ -178,12 +178,12 @@ pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
     cx: &'a Context<'tcx>,
     indent: usize,
     ending: Ending,
-) -> impl Display + 'a + Captures<'tcx> {
-    fmt::from_fn(move |f| {
-        if gens.where_predicates.is_empty() {
-            return Ok(());
-        }
+) -> Option<impl Display + 'a + Captures<'tcx>> {
+    if gens.where_predicates.is_empty() {
+        return None;
+    }
 
+    Some(fmt::from_fn(move |f| {
         let where_preds = fmt::from_fn(|f| {
             gens.where_predicates
                 .iter()
@@ -246,7 +246,7 @@ pub(crate) fn print_where_clause<'a, 'tcx: 'a>(
             }
         };
         write!(f, "{clause}")
-    })
+    }))
 }
 
 impl clean::Lifetime {
@@ -1179,7 +1179,7 @@ impl clean::Impl {
                 self.print_type(&self.for_, f, use_absolute, cx)?;
             }
 
-            print_where_clause(&self.generics, cx, 0, Ending::Newline).fmt(f)
+            print_where_clause(&self.generics, cx, 0, Ending::Newline).maybe_display().fmt(f)
         })
     }
     fn print_type<'a, 'tcx: 'a>(
diff --git a/src/librustdoc/html/render/context.rs b/src/librustdoc/html/render/context.rs
index 146bdd340697..5f69e79f3ab1 100644
--- a/src/librustdoc/html/render/context.rs
+++ b/src/librustdoc/html/render/context.rs
@@ -237,8 +237,7 @@ impl<'tcx> Context<'tcx> {
         };
 
         if !render_redirect_pages {
-            let mut page_buffer = String::new();
-            print_item(self, it, &mut page_buffer);
+            let content = print_item(self, it);
             let page = layout::Page {
                 css_class: tyname_s,
                 root_path: &self.root_path(),
@@ -254,7 +253,7 @@ impl<'tcx> Context<'tcx> {
                 BufDisplay(|buf: &mut String| {
                     print_sidebar(self, it, buf);
                 }),
-                page_buffer,
+                content,
                 &self.shared.style_files,
             )
         } else {
diff --git a/src/librustdoc/html/render/mod.rs b/src/librustdoc/html/render/mod.rs
index 204631063a23..bd4af359404a 100644
--- a/src/librustdoc/html/render/mod.rs
+++ b/src/librustdoc/html/render/mod.rs
@@ -38,7 +38,7 @@ mod type_layout;
 mod write_shared;
 
 use std::collections::VecDeque;
-use std::fmt::{self, Write};
+use std::fmt::{self, Display as _, Write};
 use std::iter::Peekable;
 use std::path::PathBuf;
 use std::{fs, str};
@@ -774,9 +774,7 @@ pub(crate) fn render_impls(
             let did = i.trait_did().unwrap();
             let provided_trait_methods = i.inner_impl().provided_trait_methods(cx.tcx());
             let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_trait_methods);
-            let mut buffer = String::new();
-            render_impl(
-                &mut buffer,
+            let imp = render_impl(
                 cx,
                 i,
                 containing_item,
@@ -791,7 +789,7 @@ pub(crate) fn render_impls(
                     toggle_open_by_default,
                 },
             );
-            buffer
+            imp.to_string()
         })
         .collect::<Vec<_>>();
     rendered_impls.sort();
@@ -879,20 +877,19 @@ enum AssocConstValue<'a> {
     None,
 }
 
-fn assoc_const(
-    w: &mut String,
-    it: &clean::Item,
-    generics: &clean::Generics,
-    ty: &clean::Type,
-    value: AssocConstValue<'_>,
-    link: AssocItemLink<'_>,
+fn assoc_const<'a, 'tcx>(
+    it: &'a clean::Item,
+    generics: &'a clean::Generics,
+    ty: &'a clean::Type,
+    value: AssocConstValue<'a>,
+    link: AssocItemLink<'a>,
     indent: usize,
-    cx: &Context<'_>,
-) {
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
     let tcx = cx.tcx();
-    write_str(
-        w,
-        format_args!(
+    fmt::from_fn(move |w| {
+        write!(
+            w,
             "{indent}{vis}const <a{href} class=\"constant\">{name}</a>{generics}: {ty}",
             indent = " ".repeat(indent),
             vis = visibility_print_with_space(it, cx),
@@ -900,67 +897,65 @@ fn assoc_const(
             name = it.name.as_ref().unwrap(),
             generics = generics.print(cx),
             ty = ty.print(cx),
-        ),
-    );
-    if let AssocConstValue::TraitDefault(konst) | AssocConstValue::Impl(konst) = value {
-        // FIXME: `.value()` uses `clean::utils::format_integer_with_underscore_sep` under the
-        //        hood which adds noisy underscores and a type suffix to number literals.
-        //        This hurts readability in this context especially when more complex expressions
-        //        are involved and it doesn't add much of value.
-        //        Find a way to print constants here without all that jazz.
-        let repr = konst.value(tcx).unwrap_or_else(|| konst.expr(tcx));
-        if match value {
-            AssocConstValue::TraitDefault(_) => true, // always show
-            AssocConstValue::Impl(_) => repr != "_",  // show if there is a meaningful value to show
-            AssocConstValue::None => unreachable!(),
-        } {
-            write_str(w, format_args!(" = {}", Escape(&repr)));
+        )?;
+        if let AssocConstValue::TraitDefault(konst) | AssocConstValue::Impl(konst) = value {
+            // FIXME: `.value()` uses `clean::utils::format_integer_with_underscore_sep` under the
+            //        hood which adds noisy underscores and a type suffix to number literals.
+            //        This hurts readability in this context especially when more complex expressions
+            //        are involved and it doesn't add much of value.
+            //        Find a way to print constants here without all that jazz.
+            let repr = konst.value(tcx).unwrap_or_else(|| konst.expr(tcx));
+            if match value {
+                AssocConstValue::TraitDefault(_) => true, // always show
+                AssocConstValue::Impl(_) => repr != "_", // show if there is a meaningful value to show
+                AssocConstValue::None => unreachable!(),
+            } {
+                write!(w, " = {}", Escape(&repr))?;
+            }
         }
-    }
-    write_str(w, format_args!("{}", print_where_clause(generics, cx, indent, Ending::NoNewline)));
+        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline).maybe_display())
+    })
 }
 
-fn assoc_type(
-    w: &mut String,
-    it: &clean::Item,
-    generics: &clean::Generics,
-    bounds: &[clean::GenericBound],
-    default: Option<&clean::Type>,
-    link: AssocItemLink<'_>,
+fn assoc_type<'a, 'tcx>(
+    it: &'a clean::Item,
+    generics: &'a clean::Generics,
+    bounds: &'a [clean::GenericBound],
+    default: Option<&'a clean::Type>,
+    link: AssocItemLink<'a>,
     indent: usize,
-    cx: &Context<'_>,
-) {
-    write_str(
-        w,
-        format_args!(
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        write!(
+            w,
             "{indent}{vis}type <a{href} class=\"associatedtype\">{name}</a>{generics}",
             indent = " ".repeat(indent),
             vis = visibility_print_with_space(it, cx),
             href = assoc_href_attr(it, link, cx).maybe_display(),
             name = it.name.as_ref().unwrap(),
             generics = generics.print(cx),
-        ),
-    );
-    if !bounds.is_empty() {
-        write_str(w, format_args!(": {}", print_generic_bounds(bounds, cx)));
-    }
-    // Render the default before the where-clause which aligns with the new recommended style. See #89122.
-    if let Some(default) = default {
-        write_str(w, format_args!(" = {}", default.print(cx)));
-    }
-    write_str(w, format_args!("{}", print_where_clause(generics, cx, indent, Ending::NoNewline)));
+        )?;
+        if !bounds.is_empty() {
+            write!(w, ": {}", print_generic_bounds(bounds, cx))?;
+        }
+        // Render the default before the where-clause which aligns with the new recommended style. See #89122.
+        if let Some(default) = default {
+            write!(w, " = {}", default.print(cx))?;
+        }
+        write!(w, "{}", print_where_clause(generics, cx, indent, Ending::NoNewline).maybe_display())
+    })
 }
 
-fn assoc_method(
-    w: &mut String,
-    meth: &clean::Item,
-    g: &clean::Generics,
-    d: &clean::FnDecl,
-    link: AssocItemLink<'_>,
+fn assoc_method<'a, 'tcx>(
+    meth: &'a clean::Item,
+    g: &'a clean::Generics,
+    d: &'a clean::FnDecl,
+    link: AssocItemLink<'a>,
     parent: ItemType,
-    cx: &Context<'_>,
+    cx: &'a Context<'tcx>,
     render_mode: RenderMode,
-) {
+) -> impl fmt::Display + 'a + Captures<'tcx> {
     let tcx = cx.tcx();
     let header = meth.fn_header(tcx).expect("Trying to get header from a non-function item");
     let name = meth.name.as_ref().unwrap();
@@ -976,61 +971,53 @@ fn assoc_method(
         ),
         RenderMode::ForDeref { .. } => "",
     };
-    let asyncness = header.asyncness.print_with_space();
-    let safety = header.safety.print_with_space();
-    let abi = print_abi_with_space(header.abi).to_string();
-    let href = assoc_href_attr(meth, link, cx).maybe_display();
 
-    // NOTE: `{:#}` does not print HTML formatting, `{}` does. So `g.print` can't be reused between the length calculation and `write!`.
-    let generics_len = format!("{:#}", g.print(cx)).len();
-    let mut header_len = "fn ".len()
-        + vis.len()
-        + defaultness.len()
-        + constness.len()
-        + asyncness.len()
-        + safety.len()
-        + abi.len()
-        + name.as_str().len()
-        + generics_len;
+    fmt::from_fn(move |w| {
+        let asyncness = header.asyncness.print_with_space();
+        let safety = header.safety.print_with_space();
+        let abi = print_abi_with_space(header.abi).to_string();
+        let href = assoc_href_attr(meth, link, cx).maybe_display();
 
-    let notable_traits = notable_traits_button(&d.output, cx).maybe_display();
+        // NOTE: `{:#}` does not print HTML formatting, `{}` does. So `g.print` can't be reused between the length calculation and `write!`.
+        let generics_len = format!("{:#}", g.print(cx)).len();
+        let mut header_len = "fn ".len()
+            + vis.len()
+            + defaultness.len()
+            + constness.len()
+            + asyncness.len()
+            + safety.len()
+            + abi.len()
+            + name.as_str().len()
+            + generics_len;
 
-    let (indent, indent_str, end_newline) = if parent == ItemType::Trait {
-        header_len += 4;
-        let indent_str = "    ";
-        write_str(w, format_args!("{}", render_attributes_in_pre(meth, indent_str, cx)));
-        (4, indent_str, Ending::NoNewline)
-    } else {
-        render_attributes_in_code(w, meth, cx);
-        (0, "", Ending::Newline)
-    };
-    w.reserve(header_len + "<a href=\"\" class=\"fn\">{".len() + "</a>".len());
-    write_str(
-        w,
-        format_args!(
+        let notable_traits = notable_traits_button(&d.output, cx).maybe_display();
+
+        let (indent, indent_str, end_newline) = if parent == ItemType::Trait {
+            header_len += 4;
+            let indent_str = "    ";
+            write!(w, "{}", render_attributes_in_pre(meth, indent_str, cx))?;
+            (4, indent_str, Ending::NoNewline)
+        } else {
+            render_attributes_in_code(w, meth, cx);
+            (0, "", Ending::Newline)
+        };
+        write!(
+            w,
             "{indent}{vis}{defaultness}{constness}{asyncness}{safety}{abi}fn \
-         <a{href} class=\"fn\">{name}</a>{generics}{decl}{notable_traits}{where_clause}",
+            <a{href} class=\"fn\">{name}</a>{generics}{decl}{notable_traits}{where_clause}",
             indent = indent_str,
-            vis = vis,
-            defaultness = defaultness,
-            constness = constness,
-            asyncness = asyncness,
-            safety = safety,
-            abi = abi,
-            href = href,
-            name = name,
             generics = g.print(cx),
             decl = d.full_print(header_len, indent, cx),
-            where_clause = print_where_clause(g, cx, indent, end_newline),
-        ),
-    );
+            where_clause = print_where_clause(g, cx, indent, end_newline).maybe_display(),
+        )
+    })
 }
 
 /// Writes a span containing the versions at which an item became stable and/or const-stable. For
 /// example, if the item became stable at 1.0.0, and const-stable at 1.45.0, this function would
 /// write a span containing "1.0.0 (const: 1.45.0)".
 ///
-/// Returns `true` if a stability annotation was rendered.
+/// Returns `None` if there is no stability annotation to be rendered.
 ///
 /// Stability and const-stability are considered separately. If the item is unstable, no version
 /// will be written. If the item is const-unstable, "const: unstable" will be appended to the
@@ -1041,11 +1028,10 @@ fn assoc_method(
 /// will include the const-stable version, but no stable version will be emitted, as a natural
 /// consequence of the above rules.
 fn render_stability_since_raw_with_extra(
-    w: &mut String,
     stable_version: Option<StableSince>,
     const_stability: Option<ConstStability>,
     extra_class: &str,
-) -> bool {
+) -> Option<impl fmt::Display + '_> {
     let mut title = String::new();
     let mut stability = String::new();
 
@@ -1095,14 +1081,9 @@ fn render_stability_since_raw_with_extra(
         }
     }
 
-    if !stability.is_empty() {
-        write_str(
-            w,
-            format_args!(r#"<span class="since{extra_class}" title="{title}">{stability}</span>"#),
-        );
-    }
-
-    !stability.is_empty()
+    (!stability.is_empty()).then_some(fmt::from_fn(move |w| {
+        write!(w, r#"<span class="since{extra_class}" title="{title}">{stability}</span>"#)
+    }))
 }
 
 fn since_to_string(since: &StableSince) -> Option<String> {
@@ -1115,31 +1096,25 @@ fn since_to_string(since: &StableSince) -> Option<String> {
 
 #[inline]
 fn render_stability_since_raw(
-    w: &mut String,
     ver: Option<StableSince>,
     const_stability: Option<ConstStability>,
-) -> bool {
-    render_stability_since_raw_with_extra(w, ver, const_stability, "")
+) -> Option<impl fmt::Display> {
+    render_stability_since_raw_with_extra(ver, const_stability, "")
 }
 
-fn render_assoc_item(
-    w: &mut String,
-    item: &clean::Item,
-    link: AssocItemLink<'_>,
+fn render_assoc_item<'a, 'tcx>(
+    item: &'a clean::Item,
+    link: AssocItemLink<'a>,
     parent: ItemType,
-    cx: &Context<'_>,
+    cx: &'a Context<'tcx>,
     render_mode: RenderMode,
-) {
-    match &item.kind {
-        clean::StrippedItem(..) => {}
-        clean::RequiredMethodItem(m) => {
-            assoc_method(w, item, &m.generics, &m.decl, link, parent, cx, render_mode)
-        }
-        clean::MethodItem(m, _) => {
-            assoc_method(w, item, &m.generics, &m.decl, link, parent, cx, render_mode)
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |f| match &item.kind {
+        clean::StrippedItem(..) => Ok(()),
+        clean::RequiredMethodItem(m) | clean::MethodItem(m, _) => {
+            assoc_method(item, &m.generics, &m.decl, link, parent, cx, render_mode).fmt(f)
         }
         clean::RequiredAssocConstItem(generics, ty) => assoc_const(
-            w,
             item,
             generics,
             ty,
@@ -1147,9 +1122,9 @@ fn render_assoc_item(
             link,
             if parent == ItemType::Trait { 4 } else { 0 },
             cx,
-        ),
+        )
+        .fmt(f),
         clean::ProvidedAssocConstItem(ci) => assoc_const(
-            w,
             item,
             &ci.generics,
             &ci.type_,
@@ -1157,9 +1132,9 @@ fn render_assoc_item(
             link,
             if parent == ItemType::Trait { 4 } else { 0 },
             cx,
-        ),
+        )
+        .fmt(f),
         clean::ImplAssocConstItem(ci) => assoc_const(
-            w,
             item,
             &ci.generics,
             &ci.type_,
@@ -1167,9 +1142,9 @@ fn render_assoc_item(
             link,
             if parent == ItemType::Trait { 4 } else { 0 },
             cx,
-        ),
+        )
+        .fmt(f),
         clean::RequiredAssocTypeItem(ref generics, ref bounds) => assoc_type(
-            w,
             item,
             generics,
             bounds,
@@ -1177,9 +1152,9 @@ fn render_assoc_item(
             link,
             if parent == ItemType::Trait { 4 } else { 0 },
             cx,
-        ),
+        )
+        .fmt(f),
         clean::AssocTypeItem(ref ty, ref bounds) => assoc_type(
-            w,
             item,
             &ty.generics,
             bounds,
@@ -1187,9 +1162,10 @@ fn render_assoc_item(
             link,
             if parent == ItemType::Trait { 4 } else { 0 },
             cx,
-        ),
+        )
+        .fmt(f),
         _ => panic!("render_assoc_item called on non-associated-item"),
-    }
+    })
 }
 
 // When an attribute is rendered inside a `<pre>` tag, it is formatted using
@@ -1230,29 +1206,29 @@ impl<'a> AssocItemLink<'a> {
     }
 }
 
-pub fn write_section_heading(
-    w: &mut impl fmt::Write,
-    title: &str,
-    id: &str,
-    extra_class: Option<&str>,
-    extra: impl fmt::Display,
-) {
-    let (extra_class, whitespace) = match extra_class {
-        Some(extra) => (extra, " "),
-        None => ("", ""),
-    };
-    write!(
-        w,
-        "<h2 id=\"{id}\" class=\"{extra_class}{whitespace}section-header\">\
+pub fn write_section_heading<'a>(
+    title: &'a str,
+    id: &'a str,
+    extra_class: Option<&'a str>,
+    extra: impl fmt::Display + 'a,
+) -> impl fmt::Display + 'a {
+    fmt::from_fn(move |w| {
+        let (extra_class, whitespace) = match extra_class {
+            Some(extra) => (extra, " "),
+            None => ("", ""),
+        };
+        write!(
+            w,
+            "<h2 id=\"{id}\" class=\"{extra_class}{whitespace}section-header\">\
             {title}\
             <a href=\"#{id}\" class=\"anchor\">§</a>\
          </h2>{extra}",
-    )
-    .unwrap();
+        )
+    })
 }
 
-fn write_impl_section_heading(w: &mut impl fmt::Write, title: &str, id: &str) {
-    write_section_heading(w, title, id, None, "")
+fn write_impl_section_heading<'a>(title: &'a str, id: &'a str) -> impl fmt::Display + 'a {
+    write_section_heading(title, id, None, "")
 }
 
 pub(crate) fn render_all_impls(
@@ -1269,24 +1245,32 @@ pub(crate) fn render_all_impls(
         buf
     };
     if !impls.is_empty() {
-        write_impl_section_heading(&mut w, "Trait Implementations", "trait-implementations");
-        write!(w, "<div id=\"trait-implementations-list\">{impls}</div>").unwrap();
+        write!(
+            w,
+            "{}<div id=\"trait-implementations-list\">{impls}</div>",
+            write_impl_section_heading("Trait Implementations", "trait-implementations")
+        )
+        .unwrap();
     }
 
     if !synthetic.is_empty() {
-        write_impl_section_heading(
-            &mut w,
-            "Auto Trait Implementations",
-            "synthetic-implementations",
-        );
-        w.write_str("<div id=\"synthetic-implementations-list\">").unwrap();
+        write!(
+            w,
+            "{}<div id=\"synthetic-implementations-list\">",
+            write_impl_section_heading("Auto Trait Implementations", "synthetic-implementations",)
+        )
+        .unwrap();
         render_impls(cx, &mut w, synthetic, containing_item, false);
         w.write_str("</div>").unwrap();
     }
 
     if !blanket_impl.is_empty() {
-        write_impl_section_heading(&mut w, "Blanket Implementations", "blanket-implementations");
-        w.write_str("<div id=\"blanket-implementations-list\">").unwrap();
+        write!(
+            w,
+            "{}<div id=\"blanket-implementations-list\">",
+            write_impl_section_heading("Blanket Implementations", "blanket-implementations")
+        )
+        .unwrap();
         render_impls(cx, &mut w, blanket_impl, containing_item, false);
         w.write_str("</div>").unwrap();
     }
@@ -1323,25 +1307,34 @@ fn render_assoc_items_inner(
         let mut tmp_buf = String::new();
         let (render_mode, id, class_html) = match what {
             AssocItemRender::All => {
-                write_impl_section_heading(&mut tmp_buf, "Implementations", "implementations");
+                write_str(
+                    &mut tmp_buf,
+                    format_args!(
+                        "{}",
+                        write_impl_section_heading("Implementations", "implementations")
+                    ),
+                );
                 (RenderMode::Normal, "implementations-list".to_owned(), "")
             }
             AssocItemRender::DerefFor { trait_, type_, deref_mut_ } => {
                 let id =
                     cx.derive_id(small_url_encode(format!("deref-methods-{:#}", type_.print(cx))));
                 let derived_id = cx.derive_id(&id);
-                tmp_buf.push_str("<details class=\"toggle big-toggle\" open><summary>");
                 close_tags.push("</details>");
-                write_impl_section_heading(
+                write_str(
                     &mut tmp_buf,
-                    &format!(
-                        "<span>Methods from {trait_}&lt;Target = {type_}&gt;</span>",
-                        trait_ = trait_.print(cx),
-                        type_ = type_.print(cx),
+                    format_args!(
+                        "<details class=\"toggle big-toggle\" open><summary>{}</summary>",
+                        write_impl_section_heading(
+                            &format!(
+                                "<span>Methods from {trait_}&lt;Target = {type_}&gt;</span>",
+                                trait_ = trait_.print(cx),
+                                type_ = type_.print(cx),
+                            ),
+                            &id,
+                        )
                     ),
-                    &id,
                 );
-                tmp_buf.push_str("</summary>");
                 if let Some(def_id) = type_.def_id(cx.cache()) {
                     cx.deref_id_map.borrow_mut().insert(def_id, id);
                 }
@@ -1350,21 +1343,26 @@ fn render_assoc_items_inner(
         };
         let mut impls_buf = String::new();
         for i in &non_trait {
-            render_impl(
+            write_str(
                 &mut impls_buf,
-                cx,
-                i,
-                containing_item,
-                AssocItemLink::Anchor(None),
-                render_mode,
-                None,
-                &[],
-                ImplRenderingParameters {
-                    show_def_docs: true,
-                    show_default_items: true,
-                    show_non_assoc_items: true,
-                    toggle_open_by_default: true,
-                },
+                format_args!(
+                    "{}",
+                    render_impl(
+                        cx,
+                        i,
+                        containing_item,
+                        AssocItemLink::Anchor(None),
+                        render_mode,
+                        None,
+                        &[],
+                        ImplRenderingParameters {
+                            show_def_docs: true,
+                            show_default_items: true,
+                            show_non_assoc_items: true,
+                            toggle_open_by_default: true,
+                        },
+                    )
+                ),
             );
         }
         if !impls_buf.is_empty() {
@@ -1564,20 +1562,23 @@ fn notable_traits_decl(ty: &clean::Type, cx: &Context<'_>) -> (String, String) {
                 );
                 for it in &impl_.items {
                     if let clean::AssocTypeItem(ref tydef, ref _bounds) = it.kind {
-                        out.push_str("<div class=\"where\">    ");
                         let empty_set = FxIndexSet::default();
                         let src_link = AssocItemLink::GotoSource(trait_did.into(), &empty_set);
-                        assoc_type(
+                        write_str(
                             &mut out,
-                            it,
-                            &tydef.generics,
-                            &[], // intentionally leaving out bounds
-                            Some(&tydef.type_),
-                            src_link,
-                            0,
-                            cx,
+                            format_args!(
+                                "<div class=\"where\">    {};</div>",
+                                assoc_type(
+                                    it,
+                                    &tydef.generics,
+                                    &[], // intentionally leaving out bounds
+                                    Some(&tydef.type_),
+                                    src_link,
+                                    0,
+                                    cx,
+                                )
+                            ),
                         );
-                        out.push_str(";</div>");
                     }
                 }
             }
@@ -1622,592 +1623,627 @@ struct ImplRenderingParameters {
     toggle_open_by_default: bool,
 }
 
-fn render_impl(
-    w: &mut String,
-    cx: &Context<'_>,
-    i: &Impl,
-    parent: &clean::Item,
-    link: AssocItemLink<'_>,
+fn render_impl<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    i: &'a Impl,
+    parent: &'a clean::Item,
+    link: AssocItemLink<'a>,
     render_mode: RenderMode,
     use_absolute: Option<bool>,
-    aliases: &[String],
+    aliases: &'a [String],
     rendering_params: ImplRenderingParameters,
-) {
-    let cache = &cx.shared.cache;
-    let traits = &cache.traits;
-    let trait_ = i.trait_did().map(|did| &traits[&did]);
-    let mut close_tags = <Vec<&str>>::with_capacity(2);
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        let cache = &cx.shared.cache;
+        let traits = &cache.traits;
+        let trait_ = i.trait_did().map(|did| &traits[&did]);
+        let mut close_tags = <Vec<&str>>::with_capacity(2);
 
-    // For trait implementations, the `interesting` output contains all methods that have doc
-    // comments, and the `boring` output contains all methods that do not. The distinction is
-    // used to allow hiding the boring methods.
-    // `containing_item` is used for rendering stability info. If the parent is a trait impl,
-    // `containing_item` will the grandparent, since trait impls can't have stability attached.
-    fn doc_impl_item(
-        boring: &mut String,
-        interesting: &mut String,
-        cx: &Context<'_>,
-        item: &clean::Item,
-        parent: &clean::Item,
-        link: AssocItemLink<'_>,
-        render_mode: RenderMode,
-        is_default_item: bool,
-        trait_: Option<&clean::Trait>,
-        rendering_params: ImplRenderingParameters,
-    ) {
-        let item_type = item.type_();
-        let name = item.name.as_ref().unwrap();
+        // For trait implementations, the `interesting` output contains all methods that have doc
+        // comments, and the `boring` output contains all methods that do not. The distinction is
+        // used to allow hiding the boring methods.
+        // `containing_item` is used for rendering stability info. If the parent is a trait impl,
+        // `containing_item` will the grandparent, since trait impls can't have stability attached.
+        fn doc_impl_item(
+            boring: &mut String,
+            interesting: &mut String,
+            cx: &Context<'_>,
+            item: &clean::Item,
+            parent: &clean::Item,
+            link: AssocItemLink<'_>,
+            render_mode: RenderMode,
+            is_default_item: bool,
+            trait_: Option<&clean::Trait>,
+            rendering_params: ImplRenderingParameters,
+        ) {
+            let item_type = item.type_();
+            let name = item.name.as_ref().unwrap();
 
-        let render_method_item = rendering_params.show_non_assoc_items
-            && match render_mode {
-                RenderMode::Normal => true,
-                RenderMode::ForDeref { mut_: deref_mut_ } => {
-                    should_render_item(item, deref_mut_, cx.tcx())
-                }
-            };
+            let render_method_item = rendering_params.show_non_assoc_items
+                && match render_mode {
+                    RenderMode::Normal => true,
+                    RenderMode::ForDeref { mut_: deref_mut_ } => {
+                        should_render_item(item, deref_mut_, cx.tcx())
+                    }
+                };
 
-        let in_trait_class = if trait_.is_some() { " trait-impl" } else { "" };
+            let in_trait_class = if trait_.is_some() { " trait-impl" } else { "" };
 
-        let mut doc_buffer = String::new();
-        let mut info_buffer = String::new();
-        let mut short_documented = true;
+            let mut doc_buffer = String::new();
+            let mut info_buffer = String::new();
+            let mut short_documented = true;
 
-        if render_method_item {
-            if !is_default_item {
-                if let Some(t) = trait_ {
-                    // The trait item may have been stripped so we might not
-                    // find any documentation or stability for it.
-                    if let Some(it) = t.items.iter().find(|i| i.name == item.name) {
-                        // We need the stability of the item from the trait
-                        // because impls can't have a stability.
-                        if !item.doc_value().is_empty() {
-                            document_item_info(cx, it, Some(parent))
-                                .render_into(&mut info_buffer)
-                                .unwrap();
+            if render_method_item {
+                if !is_default_item {
+                    if let Some(t) = trait_ {
+                        // The trait item may have been stripped so we might not
+                        // find any documentation or stability for it.
+                        if let Some(it) = t.items.iter().find(|i| i.name == item.name) {
+                            // We need the stability of the item from the trait
+                            // because impls can't have a stability.
+                            if !item.doc_value().is_empty() {
+                                document_item_info(cx, it, Some(parent))
+                                    .render_into(&mut info_buffer)
+                                    .unwrap();
+                                write_str(
+                                    &mut doc_buffer,
+                                    format_args!("{}", document_full(item, cx, HeadingOffset::H5)),
+                                );
+                                short_documented = false;
+                            } else {
+                                // In case the item isn't documented,
+                                // provide short documentation from the trait.
+                                write_str(
+                                    &mut doc_buffer,
+                                    format_args!(
+                                        "{}",
+                                        document_short(
+                                            it,
+                                            cx,
+                                            link,
+                                            parent,
+                                            rendering_params.show_def_docs,
+                                        )
+                                    ),
+                                );
+                            }
+                        }
+                    } else {
+                        document_item_info(cx, item, Some(parent))
+                            .render_into(&mut info_buffer)
+                            .unwrap();
+                        if rendering_params.show_def_docs {
                             write_str(
                                 &mut doc_buffer,
                                 format_args!("{}", document_full(item, cx, HeadingOffset::H5)),
                             );
                             short_documented = false;
-                        } else {
-                            // In case the item isn't documented,
-                            // provide short documentation from the trait.
-                            write_str(
-                                &mut doc_buffer,
-                                format_args!(
-                                    "{}",
-                                    document_short(
-                                        it,
-                                        cx,
-                                        link,
-                                        parent,
-                                        rendering_params.show_def_docs,
-                                    )
-                                ),
-                            );
                         }
                     }
                 } else {
-                    document_item_info(cx, item, Some(parent))
-                        .render_into(&mut info_buffer)
-                        .unwrap();
-                    if rendering_params.show_def_docs {
-                        write_str(
-                            &mut doc_buffer,
-                            format_args!("{}", document_full(item, cx, HeadingOffset::H5)),
-                        );
-                        short_documented = false;
-                    }
+                    write_str(
+                        &mut doc_buffer,
+                        format_args!(
+                            "{}",
+                            document_short(item, cx, link, parent, rendering_params.show_def_docs)
+                        ),
+                    );
                 }
-            } else {
+            }
+            let w = if short_documented && trait_.is_some() { interesting } else { boring };
+
+            let toggled = !doc_buffer.is_empty();
+            if toggled {
+                let method_toggle_class = if item_type.is_method() { " method-toggle" } else { "" };
                 write_str(
-                    &mut doc_buffer,
-                    format_args!(
-                        "{}",
-                        document_short(item, cx, link, parent, rendering_params.show_def_docs)
-                    ),
+                    w,
+                    format_args!("<details class=\"toggle{method_toggle_class}\" open><summary>"),
                 );
             }
-        }
-        let w = if short_documented && trait_.is_some() { interesting } else { boring };
-
-        let toggled = !doc_buffer.is_empty();
-        if toggled {
-            let method_toggle_class = if item_type.is_method() { " method-toggle" } else { "" };
-            write_str(
-                w,
-                format_args!("<details class=\"toggle{method_toggle_class}\" open><summary>"),
-            );
-        }
-        match &item.kind {
-            clean::MethodItem(..) | clean::RequiredMethodItem(_) => {
-                // Only render when the method is not static or we allow static methods
-                if render_method_item {
-                    let id = cx.derive_id(format!("{item_type}.{name}"));
-                    let source_id = trait_
-                        .and_then(|trait_| {
-                            trait_
-                                .items
-                                .iter()
-                                .find(|item| item.name.map(|n| n == *name).unwrap_or(false))
-                        })
-                        .map(|item| format!("{}.{name}", item.type_()));
+            match &item.kind {
+                clean::MethodItem(..) | clean::RequiredMethodItem(_) => {
+                    // Only render when the method is not static or we allow static methods
+                    if render_method_item {
+                        let id = cx.derive_id(format!("{item_type}.{name}"));
+                        let source_id = trait_
+                            .and_then(|trait_| {
+                                trait_
+                                    .items
+                                    .iter()
+                                    .find(|item| item.name.map(|n| n == *name).unwrap_or(false))
+                            })
+                            .map(|item| format!("{}.{name}", item.type_()));
+                        write_str(
+                            w,
+                            format_args!(
+                                "<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">\
+                                {}",
+                                render_rightside(cx, item, render_mode)
+                            ),
+                        );
+                        if trait_.is_some() {
+                            // Anchors are only used on trait impls.
+                            write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
+                        }
+                        write_str(
+                            w,
+                            format_args!(
+                                "<h4 class=\"code-header\">{}</h4></section>",
+                                render_assoc_item(
+                                    item,
+                                    link.anchor(source_id.as_ref().unwrap_or(&id)),
+                                    ItemType::Impl,
+                                    cx,
+                                    render_mode,
+                                ),
+                            ),
+                        );
+                    }
+                }
+                clean::RequiredAssocConstItem(ref generics, ref ty) => {
+                    let source_id = format!("{item_type}.{name}");
+                    let id = cx.derive_id(&source_id);
                     write_str(
                         w,
-                        format_args!("<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">"),
+                        format_args!(
+                            "<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">\
+                            {}",
+                            render_rightside(cx, item, render_mode)
+                        ),
                     );
-                    render_rightside(w, cx, item, render_mode);
                     if trait_.is_some() {
                         // Anchors are only used on trait impls.
                         write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
                     }
-                    w.push_str("<h4 class=\"code-header\">");
-                    render_assoc_item(
+                    write_str(
                         w,
-                        item,
-                        link.anchor(source_id.as_ref().unwrap_or(&id)),
-                        ItemType::Impl,
-                        cx,
-                        render_mode,
-                    );
-                    w.push_str("</h4></section>");
-                }
-            }
-            clean::RequiredAssocConstItem(ref generics, ref ty) => {
-                let source_id = format!("{item_type}.{name}");
-                let id = cx.derive_id(&source_id);
-                write_str(
-                    w,
-                    format_args!("<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">"),
-                );
-                render_rightside(w, cx, item, render_mode);
-                if trait_.is_some() {
-                    // Anchors are only used on trait impls.
-                    write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
-                }
-                w.push_str("<h4 class=\"code-header\">");
-                assoc_const(
-                    w,
-                    item,
-                    generics,
-                    ty,
-                    AssocConstValue::None,
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
-                );
-                w.push_str("</h4></section>");
-            }
-            clean::ProvidedAssocConstItem(ci) | clean::ImplAssocConstItem(ci) => {
-                let source_id = format!("{item_type}.{name}");
-                let id = cx.derive_id(&source_id);
-                write_str(
-                    w,
-                    format_args!("<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">"),
-                );
-                render_rightside(w, cx, item, render_mode);
-                if trait_.is_some() {
-                    // Anchors are only used on trait impls.
-                    write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
-                }
-                w.push_str("<h4 class=\"code-header\">");
-                assoc_const(
-                    w,
-                    item,
-                    &ci.generics,
-                    &ci.type_,
-                    match item.kind {
-                        clean::ProvidedAssocConstItem(_) => AssocConstValue::TraitDefault(&ci.kind),
-                        clean::ImplAssocConstItem(_) => AssocConstValue::Impl(&ci.kind),
-                        _ => unreachable!(),
-                    },
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
-                );
-                w.push_str("</h4></section>");
-            }
-            clean::RequiredAssocTypeItem(ref generics, ref bounds) => {
-                let source_id = format!("{item_type}.{name}");
-                let id = cx.derive_id(&source_id);
-                write_str(
-                    w,
-                    format_args!("<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">"),
-                );
-                render_rightside(w, cx, item, render_mode);
-                if trait_.is_some() {
-                    // Anchors are only used on trait impls.
-                    write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
-                }
-                w.push_str("<h4 class=\"code-header\">");
-                assoc_type(
-                    w,
-                    item,
-                    generics,
-                    bounds,
-                    None,
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
-                );
-                w.push_str("</h4></section>");
-            }
-            clean::AssocTypeItem(tydef, _bounds) => {
-                let source_id = format!("{item_type}.{name}");
-                let id = cx.derive_id(&source_id);
-                write_str(
-                    w,
-                    format_args!("<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">"),
-                );
-                render_rightside(w, cx, item, render_mode);
-                if trait_.is_some() {
-                    // Anchors are only used on trait impls.
-                    write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
-                }
-                w.push_str("<h4 class=\"code-header\">");
-                assoc_type(
-                    w,
-                    item,
-                    &tydef.generics,
-                    &[], // intentionally leaving out bounds
-                    Some(tydef.item_type.as_ref().unwrap_or(&tydef.type_)),
-                    link.anchor(if trait_.is_some() { &source_id } else { &id }),
-                    0,
-                    cx,
-                );
-                w.push_str("</h4></section>");
-            }
-            clean::StrippedItem(..) => return,
-            _ => panic!("can't make docs for trait item with name {:?}", item.name),
-        }
-
-        w.push_str(&info_buffer);
-        if toggled {
-            w.push_str("</summary>");
-            w.push_str(&doc_buffer);
-            w.push_str("</details>");
-        }
-    }
-
-    let mut impl_items = String::new();
-    let mut default_impl_items = String::new();
-    let impl_ = i.inner_impl();
-
-    // Impl items are grouped by kinds:
-    //
-    // 1. Constants
-    // 2. Types
-    // 3. Functions
-    //
-    // This order is because you can have associated constants used in associated types (like array
-    // length), and both in associcated functions. So with this order, when reading from top to
-    // bottom, you should see items definitions before they're actually used most of the time.
-    let mut assoc_types = Vec::new();
-    let mut methods = Vec::new();
-
-    if !impl_.is_negative_trait_impl() {
-        for trait_item in &impl_.items {
-            match trait_item.kind {
-                clean::MethodItem(..) | clean::RequiredMethodItem(_) => methods.push(trait_item),
-                clean::RequiredAssocTypeItem(..) | clean::AssocTypeItem(..) => {
-                    assoc_types.push(trait_item)
-                }
-                clean::RequiredAssocConstItem(..)
-                | clean::ProvidedAssocConstItem(_)
-                | clean::ImplAssocConstItem(_) => {
-                    // We render it directly since they're supposed to come first.
-                    doc_impl_item(
-                        &mut default_impl_items,
-                        &mut impl_items,
-                        cx,
-                        trait_item,
-                        if trait_.is_some() { &i.impl_item } else { parent },
-                        link,
-                        render_mode,
-                        false,
-                        trait_,
-                        rendering_params,
+                        format_args!(
+                            "<h4 class=\"code-header\">{}</h4></section>",
+                            assoc_const(
+                                item,
+                                generics,
+                                ty,
+                                AssocConstValue::None,
+                                link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                                0,
+                                cx,
+                            )
+                        ),
                     );
                 }
-                _ => {}
+                clean::ProvidedAssocConstItem(ci) | clean::ImplAssocConstItem(ci) => {
+                    let source_id = format!("{item_type}.{name}");
+                    let id = cx.derive_id(&source_id);
+                    write_str(
+                        w,
+                        format_args!(
+                            "<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">\
+                            {}",
+                            render_rightside(cx, item, render_mode)
+                        ),
+                    );
+                    if trait_.is_some() {
+                        // Anchors are only used on trait impls.
+                        write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
+                    }
+                    write_str(
+                        w,
+                        format_args!(
+                            "<h4 class=\"code-header\">{}</h4></section>",
+                            assoc_const(
+                                item,
+                                &ci.generics,
+                                &ci.type_,
+                                match item.kind {
+                                    clean::ProvidedAssocConstItem(_) =>
+                                        AssocConstValue::TraitDefault(&ci.kind),
+                                    clean::ImplAssocConstItem(_) => AssocConstValue::Impl(&ci.kind),
+                                    _ => unreachable!(),
+                                },
+                                link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                                0,
+                                cx,
+                            )
+                        ),
+                    );
+                }
+                clean::RequiredAssocTypeItem(ref generics, ref bounds) => {
+                    let source_id = format!("{item_type}.{name}");
+                    let id = cx.derive_id(&source_id);
+                    write_str(
+                        w,
+                        format_args!(
+                            "<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">\
+                            {}",
+                            render_rightside(cx, item, render_mode)
+                        ),
+                    );
+                    if trait_.is_some() {
+                        // Anchors are only used on trait impls.
+                        write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
+                    }
+                    write_str(
+                        w,
+                        format_args!(
+                            "<h4 class=\"code-header\">{}</h4></section>",
+                            assoc_type(
+                                item,
+                                generics,
+                                bounds,
+                                None,
+                                link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                                0,
+                                cx,
+                            )
+                        ),
+                    );
+                }
+                clean::AssocTypeItem(tydef, _bounds) => {
+                    let source_id = format!("{item_type}.{name}");
+                    let id = cx.derive_id(&source_id);
+                    write_str(
+                        w,
+                        format_args!(
+                            "<section id=\"{id}\" class=\"{item_type}{in_trait_class}\">\
+                            {}",
+                            render_rightside(cx, item, render_mode)
+                        ),
+                    );
+                    if trait_.is_some() {
+                        // Anchors are only used on trait impls.
+                        write_str(w, format_args!("<a href=\"#{id}\" class=\"anchor\">§</a>"));
+                    }
+                    write_str(
+                        w,
+                        format_args!(
+                            "<h4 class=\"code-header\">{}</h4></section>",
+                            assoc_type(
+                                item,
+                                &tydef.generics,
+                                &[], // intentionally leaving out bounds
+                                Some(tydef.item_type.as_ref().unwrap_or(&tydef.type_)),
+                                link.anchor(if trait_.is_some() { &source_id } else { &id }),
+                                0,
+                                cx,
+                            )
+                        ),
+                    );
+                }
+                clean::StrippedItem(..) => return,
+                _ => panic!("can't make docs for trait item with name {:?}", item.name),
+            }
+
+            w.push_str(&info_buffer);
+            if toggled {
+                w.push_str("</summary>");
+                w.push_str(&doc_buffer);
+                w.push_str("</details>");
             }
         }
 
-        for assoc_type in assoc_types {
-            doc_impl_item(
-                &mut default_impl_items,
-                &mut impl_items,
-                cx,
-                assoc_type,
-                if trait_.is_some() { &i.impl_item } else { parent },
-                link,
-                render_mode,
-                false,
-                trait_,
-                rendering_params,
-            );
-        }
-        for method in methods {
-            doc_impl_item(
-                &mut default_impl_items,
-                &mut impl_items,
-                cx,
-                method,
-                if trait_.is_some() { &i.impl_item } else { parent },
-                link,
-                render_mode,
-                false,
-                trait_,
-                rendering_params,
-            );
-        }
-    }
+        let mut impl_items = String::new();
+        let mut default_impl_items = String::new();
+        let impl_ = i.inner_impl();
 
-    fn render_default_items(
-        boring: &mut String,
-        interesting: &mut String,
-        cx: &Context<'_>,
-        t: &clean::Trait,
-        i: &clean::Impl,
-        parent: &clean::Item,
-        render_mode: RenderMode,
-        rendering_params: ImplRenderingParameters,
-    ) {
-        for trait_item in &t.items {
-            // Skip over any default trait items that are impossible to reference
-            // (e.g. if it has a `Self: Sized` bound on an unsized type).
-            if let Some(impl_def_id) = parent.item_id.as_def_id()
-                && let Some(trait_item_def_id) = trait_item.item_id.as_def_id()
-                && cx.tcx().is_impossible_associated_item((impl_def_id, trait_item_def_id))
+        // Impl items are grouped by kinds:
+        //
+        // 1. Constants
+        // 2. Types
+        // 3. Functions
+        //
+        // This order is because you can have associated constants used in associated types (like array
+        // length), and both in associcated functions. So with this order, when reading from top to
+        // bottom, you should see items definitions before they're actually used most of the time.
+        let mut assoc_types = Vec::new();
+        let mut methods = Vec::new();
+
+        if !impl_.is_negative_trait_impl() {
+            for trait_item in &impl_.items {
+                match trait_item.kind {
+                    clean::MethodItem(..) | clean::RequiredMethodItem(_) => {
+                        methods.push(trait_item)
+                    }
+                    clean::RequiredAssocTypeItem(..) | clean::AssocTypeItem(..) => {
+                        assoc_types.push(trait_item)
+                    }
+                    clean::RequiredAssocConstItem(..)
+                    | clean::ProvidedAssocConstItem(_)
+                    | clean::ImplAssocConstItem(_) => {
+                        // We render it directly since they're supposed to come first.
+                        doc_impl_item(
+                            &mut default_impl_items,
+                            &mut impl_items,
+                            cx,
+                            trait_item,
+                            if trait_.is_some() { &i.impl_item } else { parent },
+                            link,
+                            render_mode,
+                            false,
+                            trait_,
+                            rendering_params,
+                        );
+                    }
+                    _ => {}
+                }
+            }
+
+            for assoc_type in assoc_types {
+                doc_impl_item(
+                    &mut default_impl_items,
+                    &mut impl_items,
+                    cx,
+                    assoc_type,
+                    if trait_.is_some() { &i.impl_item } else { parent },
+                    link,
+                    render_mode,
+                    false,
+                    trait_,
+                    rendering_params,
+                );
+            }
+            for method in methods {
+                doc_impl_item(
+                    &mut default_impl_items,
+                    &mut impl_items,
+                    cx,
+                    method,
+                    if trait_.is_some() { &i.impl_item } else { parent },
+                    link,
+                    render_mode,
+                    false,
+                    trait_,
+                    rendering_params,
+                );
+            }
+        }
+
+        fn render_default_items(
+            boring: &mut String,
+            interesting: &mut String,
+            cx: &Context<'_>,
+            t: &clean::Trait,
+            i: &clean::Impl,
+            parent: &clean::Item,
+            render_mode: RenderMode,
+            rendering_params: ImplRenderingParameters,
+        ) {
+            for trait_item in &t.items {
+                // Skip over any default trait items that are impossible to reference
+                // (e.g. if it has a `Self: Sized` bound on an unsized type).
+                if let Some(impl_def_id) = parent.item_id.as_def_id()
+                    && let Some(trait_item_def_id) = trait_item.item_id.as_def_id()
+                    && cx.tcx().is_impossible_associated_item((impl_def_id, trait_item_def_id))
+                {
+                    continue;
+                }
+
+                let n = trait_item.name;
+                if i.items.iter().any(|m| m.name == n) {
+                    continue;
+                }
+                let did = i.trait_.as_ref().unwrap().def_id();
+                let provided_methods = i.provided_trait_methods(cx.tcx());
+                let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_methods);
+
+                doc_impl_item(
+                    boring,
+                    interesting,
+                    cx,
+                    trait_item,
+                    parent,
+                    assoc_link,
+                    render_mode,
+                    true,
+                    Some(t),
+                    rendering_params,
+                );
+            }
+        }
+
+        // If we've implemented a trait, then also emit documentation for all
+        // default items which weren't overridden in the implementation block.
+        // We don't emit documentation for default items if they appear in the
+        // Implementations on Foreign Types or Implementors sections.
+        if rendering_params.show_default_items {
+            if let Some(t) = trait_
+                && !impl_.is_negative_trait_impl()
             {
-                continue;
+                render_default_items(
+                    &mut default_impl_items,
+                    &mut impl_items,
+                    cx,
+                    t,
+                    impl_,
+                    &i.impl_item,
+                    render_mode,
+                    rendering_params,
+                );
             }
-
-            let n = trait_item.name;
-            if i.items.iter().any(|m| m.name == n) {
-                continue;
-            }
-            let did = i.trait_.as_ref().unwrap().def_id();
-            let provided_methods = i.provided_trait_methods(cx.tcx());
-            let assoc_link = AssocItemLink::GotoSource(did.into(), &provided_methods);
-
-            doc_impl_item(
-                boring,
-                interesting,
-                cx,
-                trait_item,
-                parent,
-                assoc_link,
-                render_mode,
-                true,
-                Some(t),
-                rendering_params,
-            );
         }
-    }
-
-    // If we've implemented a trait, then also emit documentation for all
-    // default items which weren't overridden in the implementation block.
-    // We don't emit documentation for default items if they appear in the
-    // Implementations on Foreign Types or Implementors sections.
-    if rendering_params.show_default_items {
-        if let Some(t) = trait_
-            && !impl_.is_negative_trait_impl()
-        {
-            render_default_items(
-                &mut default_impl_items,
-                &mut impl_items,
-                cx,
-                t,
-                impl_,
-                &i.impl_item,
-                render_mode,
-                rendering_params,
-            );
-        }
-    }
-    if render_mode == RenderMode::Normal {
-        let toggled = !(impl_items.is_empty() && default_impl_items.is_empty());
-        if toggled {
-            close_tags.push("</details>");
-            write_str(
-                w,
-                format_args!(
+        if render_mode == RenderMode::Normal {
+            let toggled = !(impl_items.is_empty() && default_impl_items.is_empty());
+            if toggled {
+                close_tags.push("</details>");
+                write!(
+                    w,
                     "<details class=\"toggle implementors-toggle\"{}>\
                         <summary>",
                     if rendering_params.toggle_open_by_default { " open" } else { "" }
-                ),
-            );
-        }
+                )?;
+            }
 
-        let (before_dox, after_dox) = i
-            .impl_item
-            .opt_doc_value()
-            .map(|dox| {
-                Markdown {
-                    content: &dox,
-                    links: &i.impl_item.links(cx),
-                    ids: &mut cx.id_map.borrow_mut(),
-                    error_codes: cx.shared.codes,
-                    edition: cx.shared.edition(),
-                    playground: &cx.shared.playground,
-                    heading_offset: HeadingOffset::H4,
-                }
-                .split_summary_and_content()
-            })
-            .unwrap_or((None, None));
-        render_impl_summary(
-            w,
-            cx,
-            i,
-            parent,
-            rendering_params.show_def_docs,
-            use_absolute,
-            aliases,
-            &before_dox,
-        );
-        if toggled {
-            w.push_str("</summary>");
-        }
+            let (before_dox, after_dox) = i
+                .impl_item
+                .opt_doc_value()
+                .map(|dox| {
+                    Markdown {
+                        content: &dox,
+                        links: &i.impl_item.links(cx),
+                        ids: &mut cx.id_map.borrow_mut(),
+                        error_codes: cx.shared.codes,
+                        edition: cx.shared.edition(),
+                        playground: &cx.shared.playground,
+                        heading_offset: HeadingOffset::H4,
+                    }
+                    .split_summary_and_content()
+                })
+                .unwrap_or((None, None));
+            write!(
+                w,
+                "{}",
+                render_impl_summary(
+                    cx,
+                    i,
+                    parent,
+                    rendering_params.show_def_docs,
+                    use_absolute,
+                    aliases,
+                    before_dox.as_deref(),
+                )
+            )?;
+            if toggled {
+                w.write_str("</summary>")?;
+            }
 
-        if before_dox.is_some() {
-            if trait_.is_none() && impl_.items.is_empty() {
-                w.push_str(
-                    "<div class=\"item-info\">\
+            if before_dox.is_some() {
+                if trait_.is_none() && impl_.items.is_empty() {
+                    w.write_str(
+                        "<div class=\"item-info\">\
                          <div class=\"stab empty-impl\">This impl block contains no items.</div>\
                      </div>",
-                );
+                    )?;
+                }
+                if let Some(after_dox) = after_dox {
+                    write!(w, "<div class=\"docblock\">{after_dox}</div>")?;
+                }
             }
-            if let Some(after_dox) = after_dox {
-                write_str(w, format_args!("<div class=\"docblock\">{after_dox}</div>"));
+            if !default_impl_items.is_empty() || !impl_items.is_empty() {
+                w.write_str("<div class=\"impl-items\">")?;
+                close_tags.push("</div>");
             }
         }
         if !default_impl_items.is_empty() || !impl_items.is_empty() {
-            w.push_str("<div class=\"impl-items\">");
-            close_tags.push("</div>");
+            w.write_str(&default_impl_items)?;
+            w.write_str(&impl_items)?;
         }
-    }
-    if !default_impl_items.is_empty() || !impl_items.is_empty() {
-        w.push_str(&default_impl_items);
-        w.push_str(&impl_items);
-    }
-    for tag in close_tags.into_iter().rev() {
-        w.push_str(tag);
-    }
+        for tag in close_tags.into_iter().rev() {
+            w.write_str(tag)?;
+        }
+        Ok(())
+    })
 }
 
 // Render the items that appear on the right side of methods, impls, and
 // associated types. For example "1.0.0 (const: 1.39.0) · source".
-fn render_rightside(w: &mut String, cx: &Context<'_>, item: &clean::Item, render_mode: RenderMode) {
+fn render_rightside<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    item: &'a clean::Item,
+    render_mode: RenderMode,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
     let tcx = cx.tcx();
 
-    // FIXME: Once https://github.com/rust-lang/rust/issues/67792 is implemented, we can remove
-    // this condition.
-    let const_stability = match render_mode {
-        RenderMode::Normal => item.const_stability(tcx),
-        RenderMode::ForDeref { .. } => None,
-    };
-    let src_href = cx.src_href(item);
-    let has_src_ref = src_href.is_some();
+    fmt::from_fn(move |w| {
+        // FIXME: Once https://github.com/rust-lang/rust/issues/67792 is implemented, we can remove
+        // this condition.
+        let const_stability = match render_mode {
+            RenderMode::Normal => item.const_stability(tcx),
+            RenderMode::ForDeref { .. } => None,
+        };
+        let src_href = cx.src_href(item);
+        let stability = render_stability_since_raw_with_extra(
+            item.stable_since(tcx),
+            const_stability,
+            if src_href.is_some() { "" } else { " rightside" },
+        );
 
-    let mut rightside = String::new();
-    let has_stability = render_stability_since_raw_with_extra(
-        &mut rightside,
-        item.stable_since(tcx),
-        const_stability,
-        if has_src_ref { "" } else { " rightside" },
-    );
-    if let Some(link) = src_href {
-        if has_stability {
-            write_str(
-                &mut rightside,
-                format_args!(" · <a class=\"src\" href=\"{link}\">Source</a>"),
-            );
-        } else {
-            write_str(
-                &mut rightside,
-                format_args!("<a class=\"src rightside\" href=\"{link}\">Source</a>"),
-            );
+        match (stability, src_href) {
+            (Some(stability), Some(link)) => {
+                write!(
+                    w,
+                    "<span class=\"rightside\">{stability} · <a class=\"src\" href=\"{link}\">Source</a></span>",
+                )
+            }
+            (Some(stability), None) => {
+                write!(w, "{stability}")
+            }
+            (None, Some(link)) => {
+                write!(w, "<a class=\"src rightside\" href=\"{link}\">Source</a>")
+            }
+            (None, None) => Ok(()),
         }
-    }
-    if has_stability && has_src_ref {
-        write_str(w, format_args!("<span class=\"rightside\">{rightside}</span>"));
-    } else {
-        w.push_str(&rightside);
-    }
+    })
 }
 
-pub(crate) fn render_impl_summary(
-    w: &mut String,
-    cx: &Context<'_>,
-    i: &Impl,
-    parent: &clean::Item,
+pub(crate) fn render_impl_summary<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    i: &'a Impl,
+    parent: &'a clean::Item,
     show_def_docs: bool,
     use_absolute: Option<bool>,
     // This argument is used to reference same type with different paths to avoid duplication
     // in documentation pages for trait with automatic implementations like "Send" and "Sync".
-    aliases: &[String],
-    doc: &Option<String>,
-) {
-    let inner_impl = i.inner_impl();
-    let id = cx.derive_id(get_id_for_impl(cx.tcx(), i.impl_item.item_id));
-    let aliases = (!aliases.is_empty())
-        .then_some(fmt::from_fn(|f| {
-            write!(f, " data-aliases=\"{}\"", fmt::from_fn(|f| aliases.iter().joined(",", f)))
-        }))
-        .maybe_display();
-    write_str(w, format_args!("<section id=\"{id}\" class=\"impl\"{aliases}>"));
-    render_rightside(w, cx, &i.impl_item, RenderMode::Normal);
-    write_str(
-        w,
-        format_args!(
-            "<a href=\"#{id}\" class=\"anchor\">§</a>\
-            <h3 class=\"code-header\">"
-        ),
-    );
+    aliases: &'a [String],
+    doc: Option<&'a str>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        let inner_impl = i.inner_impl();
+        let id = cx.derive_id(get_id_for_impl(cx.tcx(), i.impl_item.item_id));
+        let aliases = (!aliases.is_empty())
+            .then_some(fmt::from_fn(|f| {
+                write!(f, " data-aliases=\"{}\"", fmt::from_fn(|f| aliases.iter().joined(",", f)))
+            }))
+            .maybe_display();
+        write!(
+            w,
+            "<section id=\"{id}\" class=\"impl\"{aliases}>\
+                {}\
+                <a href=\"#{id}\" class=\"anchor\">§</a>\
+                <h3 class=\"code-header\">",
+            render_rightside(cx, &i.impl_item, RenderMode::Normal)
+        )?;
 
-    if let Some(use_absolute) = use_absolute {
-        write_str(w, format_args!("{}", inner_impl.print(use_absolute, cx)));
-        if show_def_docs {
-            for it in &inner_impl.items {
-                if let clean::AssocTypeItem(ref tydef, ref _bounds) = it.kind {
-                    w.push_str("<div class=\"where\">  ");
-                    assoc_type(
-                        w,
-                        it,
-                        &tydef.generics,
-                        &[], // intentionally leaving out bounds
-                        Some(&tydef.type_),
-                        AssocItemLink::Anchor(None),
-                        0,
-                        cx,
-                    );
-                    w.push_str(";</div>");
+        if let Some(use_absolute) = use_absolute {
+            write!(w, "{}", inner_impl.print(use_absolute, cx))?;
+            if show_def_docs {
+                for it in &inner_impl.items {
+                    if let clean::AssocTypeItem(ref tydef, ref _bounds) = it.kind {
+                        write!(
+                            w,
+                            "<div class=\"where\">  {};</div>",
+                            assoc_type(
+                                it,
+                                &tydef.generics,
+                                &[], // intentionally leaving out bounds
+                                Some(&tydef.type_),
+                                AssocItemLink::Anchor(None),
+                                0,
+                                cx,
+                            )
+                        )?;
+                    }
                 }
             }
+        } else {
+            write!(w, "{}", inner_impl.print(false, cx))?;
         }
-    } else {
-        write_str(w, format_args!("{}", inner_impl.print(false, cx)));
-    }
-    w.push_str("</h3>");
+        w.write_str("</h3>")?;
 
-    let is_trait = inner_impl.trait_.is_some();
-    if is_trait && let Some(portability) = portability(&i.impl_item, Some(parent)) {
-        write_str(
-            w,
-            format_args!(
+        let is_trait = inner_impl.trait_.is_some();
+        if is_trait && let Some(portability) = portability(&i.impl_item, Some(parent)) {
+            write!(
+                w,
                 "<span class=\"item-info\">\
-                 <div class=\"stab portability\">{portability}</div>\
-             </span>",
-            ),
-        );
-    }
+                    <div class=\"stab portability\">{portability}</div>\
+                </span>",
+            )?;
+        }
 
-    if let Some(doc) = doc {
-        write_str(w, format_args!("<div class=\"docblock\">{doc}</div>"));
-    }
+        if let Some(doc) = doc {
+            write!(w, "<div class=\"docblock\">{doc}</div>")?;
+        }
 
-    w.push_str("</section>");
+        w.write_str("</section>")
+    })
 }
 
 pub(crate) fn small_url_encode(s: String) -> String {
diff --git a/src/librustdoc/html/render/print_item.rs b/src/librustdoc/html/render/print_item.rs
index f32011470399..b647b2aad75a 100644
--- a/src/librustdoc/html/render/print_item.rs
+++ b/src/librustdoc/html/render/print_item.rs
@@ -1,6 +1,6 @@
 use std::cmp::Ordering;
 use std::fmt;
-use std::fmt::Display;
+use std::fmt::{Display, Write as _};
 
 use rinja::Template;
 use rustc_abi::VariantIdx;
@@ -32,7 +32,7 @@ use crate::formats::item_type::ItemType;
 use crate::html::escape::{Escape, EscapeBodyTextWithWbr};
 use crate::html::format::{
     Ending, PrintWithSpace, join_with_double_colon, print_abi_with_space,
-    print_constness_with_space, print_where_clause, visibility_print_with_space, write_str,
+    print_constness_with_space, print_where_clause, visibility_print_with_space,
 };
 use crate::html::markdown::{HeadingOffset, MarkdownSummaryLine};
 use crate::html::render::{document_full, document_item_info};
@@ -162,132 +162,139 @@ struct ItemVars<'a> {
     src_href: Option<&'a str>,
 }
 
-/// Calls `print_where_clause` and returns `true` if a `where` clause was generated.
-fn print_where_clause_and_check<'a, 'tcx: 'a>(
-    buffer: &mut String,
-    gens: &'a clean::Generics,
+pub(super) fn print_item<'a, 'tcx>(
     cx: &'a Context<'tcx>,
-) -> bool {
-    let len_before = buffer.len();
-    write_str(buffer, format_args!("{}", print_where_clause(gens, cx, 0, Ending::Newline)));
-    len_before != buffer.len()
-}
-
-pub(super) fn print_item(cx: &Context<'_>, item: &clean::Item, buf: &mut String) {
+    item: &'a clean::Item,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
     debug_assert!(!item.is_stripped());
-    let typ = match item.kind {
-        clean::ModuleItem(_) => {
-            if item.is_crate() {
-                "Crate "
-            } else {
-                "Module "
+
+    fmt::from_fn(|buf| {
+        let typ = match item.kind {
+            clean::ModuleItem(_) => {
+                if item.is_crate() {
+                    "Crate "
+                } else {
+                    "Module "
+                }
             }
-        }
-        clean::FunctionItem(..) | clean::ForeignFunctionItem(..) => "Function ",
-        clean::TraitItem(..) => "Trait ",
-        clean::StructItem(..) => "Struct ",
-        clean::UnionItem(..) => "Union ",
-        clean::EnumItem(..) => "Enum ",
-        clean::TypeAliasItem(..) => "Type Alias ",
-        clean::MacroItem(..) => "Macro ",
-        clean::ProcMacroItem(ref mac) => match mac.kind {
-            MacroKind::Bang => "Macro ",
-            MacroKind::Attr => "Attribute Macro ",
-            MacroKind::Derive => "Derive Macro ",
-        },
-        clean::PrimitiveItem(..) => "Primitive Type ",
-        clean::StaticItem(..) | clean::ForeignStaticItem(..) => "Static ",
-        clean::ConstantItem(..) => "Constant ",
-        clean::ForeignTypeItem => "Foreign Type ",
-        clean::KeywordItem => "Keyword ",
-        clean::TraitAliasItem(..) => "Trait Alias ",
-        _ => {
-            // We don't generate pages for any other type.
-            unreachable!();
-        }
-    };
-    let stability_since_raw = {
-        let mut buf = String::new();
-        render_stability_since_raw(
-            &mut buf,
-            item.stable_since(cx.tcx()),
-            item.const_stability(cx.tcx()),
-        );
-        buf
-    };
+            clean::FunctionItem(..) | clean::ForeignFunctionItem(..) => "Function ",
+            clean::TraitItem(..) => "Trait ",
+            clean::StructItem(..) => "Struct ",
+            clean::UnionItem(..) => "Union ",
+            clean::EnumItem(..) => "Enum ",
+            clean::TypeAliasItem(..) => "Type Alias ",
+            clean::MacroItem(..) => "Macro ",
+            clean::ProcMacroItem(ref mac) => match mac.kind {
+                MacroKind::Bang => "Macro ",
+                MacroKind::Attr => "Attribute Macro ",
+                MacroKind::Derive => "Derive Macro ",
+            },
+            clean::PrimitiveItem(..) => "Primitive Type ",
+            clean::StaticItem(..) | clean::ForeignStaticItem(..) => "Static ",
+            clean::ConstantItem(..) => "Constant ",
+            clean::ForeignTypeItem => "Foreign Type ",
+            clean::KeywordItem => "Keyword ",
+            clean::TraitAliasItem(..) => "Trait Alias ",
+            _ => {
+                // We don't generate pages for any other type.
+                unreachable!();
+            }
+        };
+        let stability_since_raw =
+            render_stability_since_raw(item.stable_since(cx.tcx()), item.const_stability(cx.tcx()))
+                .maybe_display()
+                .to_string();
 
-    // Write source tag
-    //
-    // When this item is part of a `crate use` in a downstream crate, the
-    // source link in the downstream documentation will actually come back to
-    // this page, and this link will be auto-clicked. The `id` attribute is
-    // used to find the link to auto-click.
-    let src_href =
-        if cx.info.include_sources && !item.is_primitive() { cx.src_href(item) } else { None };
+        // Write source tag
+        //
+        // When this item is part of a `crate use` in a downstream crate, the
+        // source link in the downstream documentation will actually come back to
+        // this page, and this link will be auto-clicked. The `id` attribute is
+        // used to find the link to auto-click.
+        let src_href =
+            if cx.info.include_sources && !item.is_primitive() { cx.src_href(item) } else { None };
 
-    let path_components = if item.is_primitive() || item.is_keyword() {
-        vec![]
-    } else {
-        let cur = &cx.current;
-        let amt = if item.is_mod() { cur.len() - 1 } else { cur.len() };
-        cur.iter()
-            .enumerate()
-            .take(amt)
-            .map(|(i, component)| PathComponent {
-                path: "../".repeat(cur.len() - i - 1),
-                name: *component,
-            })
-            .collect()
-    };
+        let path_components = if item.is_primitive() || item.is_keyword() {
+            vec![]
+        } else {
+            let cur = &cx.current;
+            let amt = if item.is_mod() { cur.len() - 1 } else { cur.len() };
+            cur.iter()
+                .enumerate()
+                .take(amt)
+                .map(|(i, component)| PathComponent {
+                    path: "../".repeat(cur.len() - i - 1),
+                    name: *component,
+                })
+                .collect()
+        };
 
-    let item_vars = ItemVars {
-        typ,
-        name: item.name.as_ref().unwrap().as_str(),
-        item_type: &item.type_().to_string(),
-        path_components,
-        stability_since_raw: &stability_since_raw,
-        src_href: src_href.as_deref(),
-    };
+        let item_vars = ItemVars {
+            typ,
+            name: item.name.as_ref().unwrap().as_str(),
+            item_type: &item.type_().to_string(),
+            path_components,
+            stability_since_raw: &stability_since_raw,
+            src_href: src_href.as_deref(),
+        };
 
-    item_vars.render_into(buf).unwrap();
+        item_vars.render_into(buf).unwrap();
 
-    match &item.kind {
-        clean::ModuleItem(ref m) => item_module(buf, cx, item, &m.items),
-        clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f, _) => {
-            item_function(buf, cx, item, f)
-        }
-        clean::TraitItem(ref t) => item_trait(buf, cx, item, t),
-        clean::StructItem(ref s) => item_struct(buf, cx, item, s),
-        clean::UnionItem(ref s) => item_union(buf, cx, item, s),
-        clean::EnumItem(ref e) => item_enum(buf, cx, item, e),
-        clean::TypeAliasItem(ref t) => item_type_alias(buf, cx, item, t),
-        clean::MacroItem(ref m) => item_macro(buf, cx, item, m),
-        clean::ProcMacroItem(ref m) => item_proc_macro(buf, cx, item, m),
-        clean::PrimitiveItem(_) => item_primitive(buf, cx, item),
-        clean::StaticItem(ref i) => item_static(buf, cx, item, i, None),
-        clean::ForeignStaticItem(ref i, safety) => item_static(buf, cx, item, i, Some(*safety)),
-        clean::ConstantItem(ci) => item_constant(buf, cx, item, &ci.generics, &ci.type_, &ci.kind),
-        clean::ForeignTypeItem => item_foreign_type(buf, cx, item),
-        clean::KeywordItem => item_keyword(buf, cx, item),
-        clean::TraitAliasItem(ref ta) => item_trait_alias(buf, cx, item, ta),
-        _ => {
-            // We don't generate pages for any other type.
-            unreachable!();
-        }
-    }
+        match &item.kind {
+            clean::ModuleItem(ref m) => {
+                write!(buf, "{}", item_module(cx, item, &m.items))
+            }
+            clean::FunctionItem(ref f) | clean::ForeignFunctionItem(ref f, _) => {
+                write!(buf, "{}", item_function(cx, item, f))
+            }
+            clean::TraitItem(ref t) => write!(buf, "{}", item_trait(cx, item, t)),
+            clean::StructItem(ref s) => {
+                write!(buf, "{}", item_struct(cx, item, s))
+            }
+            clean::UnionItem(ref s) => write!(buf, "{}", item_union(cx, item, s)),
+            clean::EnumItem(ref e) => write!(buf, "{}", item_enum(cx, item, e)),
+            clean::TypeAliasItem(ref t) => {
+                write!(buf, "{}", item_type_alias(cx, item, t))
+            }
+            clean::MacroItem(ref m) => write!(buf, "{}", item_macro(cx, item, m)),
+            clean::ProcMacroItem(ref m) => {
+                write!(buf, "{}", item_proc_macro(cx, item, m))
+            }
+            clean::PrimitiveItem(_) => write!(buf, "{}", item_primitive(cx, item)),
+            clean::StaticItem(ref i) => {
+                write!(buf, "{}", item_static(cx, item, i, None))
+            }
+            clean::ForeignStaticItem(ref i, safety) => {
+                write!(buf, "{}", item_static(cx, item, i, Some(*safety)))
+            }
+            clean::ConstantItem(ci) => {
+                write!(buf, "{}", item_constant(cx, item, &ci.generics, &ci.type_, &ci.kind))
+            }
+            clean::ForeignTypeItem => {
+                write!(buf, "{}", item_foreign_type(cx, item))
+            }
+            clean::KeywordItem => write!(buf, "{}", item_keyword(cx, item)),
+            clean::TraitAliasItem(ref ta) => {
+                write!(buf, "{}", item_trait_alias(cx, item, ta))
+            }
+            _ => {
+                // We don't generate pages for any other type.
+                unreachable!();
+            }
+        }?;
 
-    // Render notable-traits.js used for all methods in this module.
-    let mut types_with_notable_traits = cx.types_with_notable_traits.borrow_mut();
-    if !types_with_notable_traits.is_empty() {
-        write_str(
-            buf,
-            format_args!(
+        // Render notable-traits.js used for all methods in this module.
+        let mut types_with_notable_traits = cx.types_with_notable_traits.borrow_mut();
+        if !types_with_notable_traits.is_empty() {
+            write!(
+                buf,
                 r#"<script type="text/json" id="notable-traits-data">{}</script>"#,
-                notable_traits_json(types_with_notable_traits.iter(), cx)
-            ),
-        );
-        types_with_notable_traits.clear();
-    }
+                notable_traits_json(types_with_notable_traits.iter(), cx),
+            )?;
+            types_with_notable_traits.clear();
+        }
+        Ok(())
+    })
 }
 
 /// For large structs, enums, unions, etc, determine whether to hide their fields
@@ -314,192 +321,198 @@ trait ItemTemplate<'a, 'cx: 'a>: rinja::Template + Display {
     fn item_and_cx(&self) -> (&'a clean::Item, &'a Context<'cx>);
 }
 
-fn item_module(w: &mut String, cx: &Context<'_>, item: &clean::Item, items: &[clean::Item]) {
-    write_str(w, format_args!("{}", document(cx, item, None, HeadingOffset::H2)));
+fn item_module<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    item: &'a clean::Item,
+    items: &'a [clean::Item],
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        write!(w, "{}", document(cx, item, None, HeadingOffset::H2))?;
 
-    let mut not_stripped_items =
-        items.iter().filter(|i| !i.is_stripped()).enumerate().collect::<Vec<_>>();
+        let mut not_stripped_items =
+            items.iter().filter(|i| !i.is_stripped()).enumerate().collect::<Vec<_>>();
 
-    // the order of item types in the listing
-    fn reorder(ty: ItemType) -> u8 {
-        match ty {
-            ItemType::ExternCrate => 0,
-            ItemType::Import => 1,
-            ItemType::Primitive => 2,
-            ItemType::Module => 3,
-            ItemType::Macro => 4,
-            ItemType::Struct => 5,
-            ItemType::Enum => 6,
-            ItemType::Constant => 7,
-            ItemType::Static => 8,
-            ItemType::Trait => 9,
-            ItemType::Function => 10,
-            ItemType::TypeAlias => 12,
-            ItemType::Union => 13,
-            _ => 14 + ty as u8,
-        }
-    }
-
-    fn cmp(i1: &clean::Item, i2: &clean::Item, tcx: TyCtxt<'_>) -> Ordering {
-        let rty1 = reorder(i1.type_());
-        let rty2 = reorder(i2.type_());
-        if rty1 != rty2 {
-            return rty1.cmp(&rty2);
-        }
-        let is_stable1 = i1.stability(tcx).as_ref().map(|s| s.level.is_stable()).unwrap_or(true);
-        let is_stable2 = i2.stability(tcx).as_ref().map(|s| s.level.is_stable()).unwrap_or(true);
-        if is_stable1 != is_stable2 {
-            // true is bigger than false in the standard bool ordering,
-            // but we actually want stable items to come first
-            return is_stable2.cmp(&is_stable1);
-        }
-        let lhs = i1.name.unwrap_or(kw::Empty);
-        let rhs = i2.name.unwrap_or(kw::Empty);
-        compare_names(lhs.as_str(), rhs.as_str())
-    }
-
-    let tcx = cx.tcx();
-
-    match cx.shared.module_sorting {
-        ModuleSorting::Alphabetical => {
-            not_stripped_items.sort_by(|(_, i1), (_, i2)| cmp(i1, i2, tcx));
-        }
-        ModuleSorting::DeclarationOrder => {}
-    }
-    // This call is to remove re-export duplicates in cases such as:
-    //
-    // ```
-    // pub(crate) mod foo {
-    //     pub(crate) mod bar {
-    //         pub(crate) trait Double { fn foo(); }
-    //     }
-    // }
-    //
-    // pub(crate) use foo::bar::*;
-    // pub(crate) use foo::*;
-    // ```
-    //
-    // `Double` will appear twice in the generated docs.
-    //
-    // FIXME: This code is quite ugly and could be improved. Small issue: DefId
-    // can be identical even if the elements are different (mostly in imports).
-    // So in case this is an import, we keep everything by adding a "unique id"
-    // (which is the position in the vector).
-    not_stripped_items.dedup_by_key(|(idx, i)| {
-        (
-            i.item_id,
-            if i.name.is_some() { Some(full_path(cx, i)) } else { None },
-            i.type_(),
-            if i.is_import() { *idx } else { 0 },
-        )
-    });
-
-    debug!("{not_stripped_items:?}");
-    let mut last_section = None;
-
-    for (_, myitem) in &not_stripped_items {
-        let my_section = item_ty_to_section(myitem.type_());
-        if Some(my_section) != last_section {
-            if last_section.is_some() {
-                w.push_str(ITEM_TABLE_CLOSE);
+        // the order of item types in the listing
+        fn reorder(ty: ItemType) -> u8 {
+            match ty {
+                ItemType::ExternCrate => 0,
+                ItemType::Import => 1,
+                ItemType::Primitive => 2,
+                ItemType::Module => 3,
+                ItemType::Macro => 4,
+                ItemType::Struct => 5,
+                ItemType::Enum => 6,
+                ItemType::Constant => 7,
+                ItemType::Static => 8,
+                ItemType::Trait => 9,
+                ItemType::Function => 10,
+                ItemType::TypeAlias => 12,
+                ItemType::Union => 13,
+                _ => 14 + ty as u8,
             }
-            last_section = Some(my_section);
-            let section_id = my_section.id();
-            let tag =
-                if section_id == "reexports" { REEXPORTS_TABLE_OPEN } else { ITEM_TABLE_OPEN };
-            write_section_heading(w, my_section.name(), &cx.derive_id(section_id), None, tag);
         }
 
-        match myitem.kind {
-            clean::ExternCrateItem { ref src } => {
-                use crate::html::format::anchor;
+        fn cmp(i1: &clean::Item, i2: &clean::Item, tcx: TyCtxt<'_>) -> Ordering {
+            let rty1 = reorder(i1.type_());
+            let rty2 = reorder(i2.type_());
+            if rty1 != rty2 {
+                return rty1.cmp(&rty2);
+            }
+            let is_stable1 =
+                i1.stability(tcx).as_ref().map(|s| s.level.is_stable()).unwrap_or(true);
+            let is_stable2 =
+                i2.stability(tcx).as_ref().map(|s| s.level.is_stable()).unwrap_or(true);
+            if is_stable1 != is_stable2 {
+                // true is bigger than false in the standard bool ordering,
+                // but we actually want stable items to come first
+                return is_stable2.cmp(&is_stable1);
+            }
+            let lhs = i1.name.unwrap_or(kw::Empty);
+            let rhs = i2.name.unwrap_or(kw::Empty);
+            compare_names(lhs.as_str(), rhs.as_str())
+        }
 
-                match *src {
-                    Some(src) => {
-                        write_str(
-                            w,
-                            format_args!(
+        let tcx = cx.tcx();
+
+        match cx.shared.module_sorting {
+            ModuleSorting::Alphabetical => {
+                not_stripped_items.sort_by(|(_, i1), (_, i2)| cmp(i1, i2, tcx));
+            }
+            ModuleSorting::DeclarationOrder => {}
+        }
+        // This call is to remove re-export duplicates in cases such as:
+        //
+        // ```
+        // pub(crate) mod foo {
+        //     pub(crate) mod bar {
+        //         pub(crate) trait Double { fn foo(); }
+        //     }
+        // }
+        //
+        // pub(crate) use foo::bar::*;
+        // pub(crate) use foo::*;
+        // ```
+        //
+        // `Double` will appear twice in the generated docs.
+        //
+        // FIXME: This code is quite ugly and could be improved. Small issue: DefId
+        // can be identical even if the elements are different (mostly in imports).
+        // So in case this is an import, we keep everything by adding a "unique id"
+        // (which is the position in the vector).
+        not_stripped_items.dedup_by_key(|(idx, i)| {
+            (
+                i.item_id,
+                if i.name.is_some() { Some(full_path(cx, i)) } else { None },
+                i.type_(),
+                if i.is_import() { *idx } else { 0 },
+            )
+        });
+
+        debug!("{not_stripped_items:?}");
+        let mut last_section = None;
+
+        for (_, myitem) in &not_stripped_items {
+            let my_section = item_ty_to_section(myitem.type_());
+            if Some(my_section) != last_section {
+                if last_section.is_some() {
+                    w.write_str(ITEM_TABLE_CLOSE)?;
+                }
+                last_section = Some(my_section);
+                let section_id = my_section.id();
+                let tag =
+                    if section_id == "reexports" { REEXPORTS_TABLE_OPEN } else { ITEM_TABLE_OPEN };
+                write!(
+                    w,
+                    "{}",
+                    write_section_heading(my_section.name(), &cx.derive_id(section_id), None, tag)
+                )?;
+            }
+
+            match myitem.kind {
+                clean::ExternCrateItem { ref src } => {
+                    use crate::html::format::anchor;
+
+                    match *src {
+                        Some(src) => {
+                            write!(
+                                w,
                                 "<dt><code>{}extern crate {} as {};",
                                 visibility_print_with_space(myitem, cx),
                                 anchor(myitem.item_id.expect_def_id(), src, cx),
                                 EscapeBodyTextWithWbr(myitem.name.unwrap().as_str())
-                            ),
-                        );
-                    }
-                    None => {
-                        write_str(
-                            w,
-                            format_args!(
+                            )?;
+                        }
+                        None => {
+                            write!(
+                                w,
                                 "<dt><code>{}extern crate {};",
                                 visibility_print_with_space(myitem, cx),
                                 anchor(myitem.item_id.expect_def_id(), myitem.name.unwrap(), cx)
-                            ),
-                        );
+                            )?;
+                        }
                     }
+                    w.write_str("</code></dt>")?;
                 }
-                w.push_str("</code></dt>");
-            }
 
-            clean::ImportItem(ref import) => {
-                let stab_tags = import.source.did.map_or_else(String::new, |import_def_id| {
-                    extra_info_tags(tcx, myitem, item, Some(import_def_id)).to_string()
-                });
+                clean::ImportItem(ref import) => {
+                    let stab_tags = import.source.did.map_or_else(String::new, |import_def_id| {
+                        extra_info_tags(tcx, myitem, item, Some(import_def_id)).to_string()
+                    });
 
-                let id = match import.kind {
-                    clean::ImportKind::Simple(s) => {
-                        format!(" id=\"{}\"", cx.derive_id(format!("reexport.{s}")))
-                    }
-                    clean::ImportKind::Glob => String::new(),
-                };
-                write_str(
-                    w,
-                    format_args!(
+                    let id = match import.kind {
+                        clean::ImportKind::Simple(s) => {
+                            format!(" id=\"{}\"", cx.derive_id(format!("reexport.{s}")))
+                        }
+                        clean::ImportKind::Glob => String::new(),
+                    };
+                    write!(
+                        w,
                         "<dt{id}>\
                             <code>{vis}{imp}</code>{stab_tags}\
                         </dt>",
                         vis = visibility_print_with_space(myitem, cx),
                         imp = import.print(cx)
-                    ),
-                );
-            }
-
-            _ => {
-                if myitem.name.is_none() {
-                    continue;
+                    )?;
                 }
 
-                let unsafety_flag = match myitem.kind {
-                    clean::FunctionItem(_) | clean::ForeignFunctionItem(..)
-                        if myitem.fn_header(tcx).unwrap().is_unsafe() =>
-                    {
-                        "<sup title=\"unsafe function\">⚠</sup>"
+                _ => {
+                    if myitem.name.is_none() {
+                        continue;
                     }
-                    clean::ForeignStaticItem(_, hir::Safety::Unsafe) => {
-                        "<sup title=\"unsafe static\">⚠</sup>"
-                    }
-                    _ => "",
-                };
 
-                let visibility_and_hidden = match myitem.visibility(tcx) {
-                    Some(ty::Visibility::Restricted(_)) => {
-                        if myitem.is_doc_hidden() {
-                            // Don't separate with a space when there are two of them
-                            "<span title=\"Restricted Visibility\">&nbsp;🔒</span><span title=\"Hidden item\">👻</span> "
-                        } else {
-                            "<span title=\"Restricted Visibility\">&nbsp;🔒</span> "
+                    let unsafety_flag = match myitem.kind {
+                        clean::FunctionItem(_) | clean::ForeignFunctionItem(..)
+                            if myitem.fn_header(tcx).unwrap().is_unsafe() =>
+                        {
+                            "<sup title=\"unsafe function\">⚠</sup>"
                         }
-                    }
-                    _ if myitem.is_doc_hidden() => "<span title=\"Hidden item\">&nbsp;👻</span> ",
-                    _ => "",
-                };
+                        clean::ForeignStaticItem(_, hir::Safety::Unsafe) => {
+                            "<sup title=\"unsafe static\">⚠</sup>"
+                        }
+                        _ => "",
+                    };
 
-                let docs =
-                    MarkdownSummaryLine(&myitem.doc_value(), &myitem.links(cx)).into_string();
-                let (docs_before, docs_after) =
-                    if docs.is_empty() { ("", "") } else { ("<dd>", "</dd>") };
-                write_str(
-                    w,
-                    format_args!(
+                    let visibility_and_hidden = match myitem.visibility(tcx) {
+                        Some(ty::Visibility::Restricted(_)) => {
+                            if myitem.is_doc_hidden() {
+                                // Don't separate with a space when there are two of them
+                                "<span title=\"Restricted Visibility\">&nbsp;🔒</span><span title=\"Hidden item\">👻</span> "
+                            } else {
+                                "<span title=\"Restricted Visibility\">&nbsp;🔒</span> "
+                            }
+                        }
+                        _ if myitem.is_doc_hidden() => {
+                            "<span title=\"Hidden item\">&nbsp;👻</span> "
+                        }
+                        _ => "",
+                    };
+
+                    let docs =
+                        MarkdownSummaryLine(&myitem.doc_value(), &myitem.links(cx)).into_string();
+                    let (docs_before, docs_after) =
+                        if docs.is_empty() { ("", "") } else { ("<dd>", "</dd>") };
+                    write!(
+                        w,
                         "<dt>\
                             <a class=\"{class}\" href=\"{href}\" title=\"{title}\">{name}</a>\
                             {visibility_and_hidden}\
@@ -514,15 +527,16 @@ fn item_module(w: &mut String, cx: &Context<'_>, item: &clean::Item, items: &[cl
                         unsafety_flag = unsafety_flag,
                         href = item_path(myitem.type_(), myitem.name.unwrap().as_str()),
                         title = format_args!("{} {}", myitem.type_(), full_path(cx, myitem)),
-                    ),
-                );
+                    )?;
+                }
             }
         }
-    }
 
-    if last_section.is_some() {
-        w.push_str(ITEM_TABLE_CLOSE);
-    }
+        if last_section.is_some() {
+            w.write_str(ITEM_TABLE_CLOSE)?;
+        }
+        Ok(())
+    })
 }
 
 /// Render the stability, deprecation and portability tags that are displayed in the item's summary
@@ -583,44 +597,47 @@ fn extra_info_tags<'a, 'tcx: 'a>(
     })
 }
 
-fn item_function(w: &mut String, cx: &Context<'_>, it: &clean::Item, f: &clean::Function) {
-    let tcx = cx.tcx();
-    let header = it.fn_header(tcx).expect("printing a function which isn't a function");
-    debug!(
-        "item_function/const: {:?} {:?} {:?} {:?}",
-        it.name,
-        &header.constness,
-        it.stable_since(tcx),
-        it.const_stability(tcx),
-    );
-    let constness = print_constness_with_space(
-        &header.constness,
-        it.stable_since(tcx),
-        it.const_stability(tcx),
-    );
-    let safety = header.safety.print_with_space();
-    let abi = print_abi_with_space(header.abi).to_string();
-    let asyncness = header.asyncness.print_with_space();
-    let visibility = visibility_print_with_space(it, cx).to_string();
-    let name = it.name.unwrap();
+fn item_function<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    f: &'a clean::Function,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        let tcx = cx.tcx();
+        let header = it.fn_header(tcx).expect("printing a function which isn't a function");
+        debug!(
+            "item_function/const: {:?} {:?} {:?} {:?}",
+            it.name,
+            &header.constness,
+            it.stable_since(tcx),
+            it.const_stability(tcx),
+        );
+        let constness = print_constness_with_space(
+            &header.constness,
+            it.stable_since(tcx),
+            it.const_stability(tcx),
+        );
+        let safety = header.safety.print_with_space();
+        let abi = print_abi_with_space(header.abi).to_string();
+        let asyncness = header.asyncness.print_with_space();
+        let visibility = visibility_print_with_space(it, cx).to_string();
+        let name = it.name.unwrap();
 
-    let generics_len = format!("{:#}", f.generics.print(cx)).len();
-    let header_len = "fn ".len()
-        + visibility.len()
-        + constness.len()
-        + asyncness.len()
-        + safety.len()
-        + abi.len()
-        + name.as_str().len()
-        + generics_len;
+        let generics_len = format!("{:#}", f.generics.print(cx)).len();
+        let header_len = "fn ".len()
+            + visibility.len()
+            + constness.len()
+            + asyncness.len()
+            + safety.len()
+            + abi.len()
+            + name.as_str().len()
+            + generics_len;
 
-    let notable_traits = notable_traits_button(&f.decl.output, cx).maybe_display();
+        let notable_traits = notable_traits_button(&f.decl.output, cx).maybe_display();
 
-    wrap_item(w, |w| {
-        w.reserve(header_len);
-        write_str(
-            w,
-            format_args!(
+        wrap_item(w, |w| {
+            write!(
+                w,
                 "{attrs}{vis}{constness}{asyncness}{safety}{abi}fn \
                 {name}{generics}{decl}{notable_traits}{where_clause}",
                 attrs = render_attributes_in_pre(it, "", cx),
@@ -631,35 +648,41 @@ fn item_function(w: &mut String, cx: &Context<'_>, it: &clean::Item, f: &clean::
                 abi = abi,
                 name = name,
                 generics = f.generics.print(cx),
-                where_clause = print_where_clause(&f.generics, cx, 0, Ending::Newline),
+                where_clause =
+                    print_where_clause(&f.generics, cx, 0, Ending::Newline).maybe_display(),
                 decl = f.decl.full_print(header_len, 0, cx),
-            ),
-        );
-    });
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
+            )
+        })?;
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))
+    })
 }
 
-fn item_trait(w: &mut String, cx: &Context<'_>, it: &clean::Item, t: &clean::Trait) {
-    let tcx = cx.tcx();
-    let bounds = bounds(&t.bounds, false, cx);
-    let required_types =
-        t.items.iter().filter(|m| m.is_required_associated_type()).collect::<Vec<_>>();
-    let provided_types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
-    let required_consts =
-        t.items.iter().filter(|m| m.is_required_associated_const()).collect::<Vec<_>>();
-    let provided_consts = t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
-    let required_methods = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>();
-    let provided_methods = t.items.iter().filter(|m| m.is_method()).collect::<Vec<_>>();
-    let count_types = required_types.len() + provided_types.len();
-    let count_consts = required_consts.len() + provided_consts.len();
-    let count_methods = required_methods.len() + provided_methods.len();
-    let must_implement_one_of_functions = tcx.trait_def(t.def_id).must_implement_one_of.clone();
+fn item_trait<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    t: &'a clean::Trait,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        let tcx = cx.tcx();
+        let bounds = bounds(&t.bounds, false, cx);
+        let required_types =
+            t.items.iter().filter(|m| m.is_required_associated_type()).collect::<Vec<_>>();
+        let provided_types = t.items.iter().filter(|m| m.is_associated_type()).collect::<Vec<_>>();
+        let required_consts =
+            t.items.iter().filter(|m| m.is_required_associated_const()).collect::<Vec<_>>();
+        let provided_consts =
+            t.items.iter().filter(|m| m.is_associated_const()).collect::<Vec<_>>();
+        let required_methods = t.items.iter().filter(|m| m.is_ty_method()).collect::<Vec<_>>();
+        let provided_methods = t.items.iter().filter(|m| m.is_method()).collect::<Vec<_>>();
+        let count_types = required_types.len() + provided_types.len();
+        let count_consts = required_consts.len() + provided_consts.len();
+        let count_methods = required_methods.len() + provided_methods.len();
+        let must_implement_one_of_functions = tcx.trait_def(t.def_id).must_implement_one_of.clone();
 
-    // Output the trait definition
-    wrap_item(w, |mut w| {
-        write_str(
-            w,
-            format_args!(
+        // Output the trait definition
+        wrap_item(w, |mut w| {
+            write!(
+                w,
                 "{attrs}{vis}{safety}{is_auto}trait {name}{generics}{bounds}",
                 attrs = render_attributes_in_pre(it, "", cx),
                 vis = visibility_print_with_space(it, cx),
@@ -667,747 +690,820 @@ fn item_trait(w: &mut String, cx: &Context<'_>, it: &clean::Item, t: &clean::Tra
                 is_auto = if t.is_auto(tcx) { "auto " } else { "" },
                 name = it.name.unwrap(),
                 generics = t.generics.print(cx),
-            ),
-        );
+            )?;
 
-        if !t.generics.where_predicates.is_empty() {
-            write_str(
-                w,
-                format_args!("{}", print_where_clause(&t.generics, cx, 0, Ending::Newline)),
-            );
-        } else {
-            w.push_str(" ");
-        }
-
-        if t.items.is_empty() {
-            w.push_str("{ }");
-        } else {
-            // FIXME: we should be using a derived_id for the Anchors here
-            w.push_str("{\n");
-            let mut toggle = false;
-
-            // If there are too many associated types, hide _everything_
-            if should_hide_fields(count_types) {
-                toggle = true;
-                toggle_open(
-                    &mut w,
-                    format_args!("{} associated items", count_types + count_consts + count_methods),
-                );
+            if !t.generics.where_predicates.is_empty() {
+                write!(
+                    w,
+                    "{}",
+                    print_where_clause(&t.generics, cx, 0, Ending::Newline).maybe_display()
+                )?;
+            } else {
+                w.write_char(' ')?;
             }
-            for types in [&required_types, &provided_types] {
-                for t in types {
-                    render_assoc_item(
-                        w,
-                        t,
-                        AssocItemLink::Anchor(None),
-                        ItemType::Trait,
-                        cx,
-                        RenderMode::Normal,
+
+            if t.items.is_empty() {
+                w.write_str("{ }")
+            } else {
+                // FIXME: we should be using a derived_id for the Anchors here
+                w.write_str("{\n")?;
+                let mut toggle = false;
+
+                // If there are too many associated types, hide _everything_
+                if should_hide_fields(count_types) {
+                    toggle = true;
+                    toggle_open(
+                        &mut w,
+                        format_args!(
+                            "{} associated items",
+                            count_types + count_consts + count_methods
+                        ),
                     );
-                    w.push_str(";\n");
                 }
-            }
-            // If there are too many associated constants, hide everything after them
-            // We also do this if the types + consts is large because otherwise we could
-            // render a bunch of types and _then_ a bunch of consts just because both were
-            // _just_ under the limit
-            if !toggle && should_hide_fields(count_types + count_consts) {
-                toggle = true;
-                toggle_open(
-                    &mut w,
-                    format_args!(
-                        "{count_consts} associated constant{plural_const} and \
-                         {count_methods} method{plural_method}",
-                        plural_const = pluralize(count_consts),
-                        plural_method = pluralize(count_methods),
-                    ),
-                );
-            }
-            if count_types != 0 && (count_consts != 0 || count_methods != 0) {
-                w.push_str("\n");
-            }
-            for consts in [&required_consts, &provided_consts] {
-                for c in consts {
-                    render_assoc_item(
-                        w,
-                        c,
-                        AssocItemLink::Anchor(None),
-                        ItemType::Trait,
-                        cx,
-                        RenderMode::Normal,
-                    );
-                    w.push_str(";\n");
-                }
-            }
-            if !toggle && should_hide_fields(count_methods) {
-                toggle = true;
-                toggle_open(&mut w, format_args!("{count_methods} methods"));
-            }
-            if count_consts != 0 && count_methods != 0 {
-                w.push_str("\n");
-            }
-
-            if !required_methods.is_empty() {
-                write_str(
-                    w,
-                    format_args_nl!("    // Required method{}", pluralize(required_methods.len())),
-                );
-            }
-            for (pos, m) in required_methods.iter().enumerate() {
-                render_assoc_item(
-                    w,
-                    m,
-                    AssocItemLink::Anchor(None),
-                    ItemType::Trait,
-                    cx,
-                    RenderMode::Normal,
-                );
-                w.push_str(";\n");
-
-                if pos < required_methods.len() - 1 {
-                    w.push_str("<span class=\"item-spacer\"></span>");
-                }
-            }
-            if !required_methods.is_empty() && !provided_methods.is_empty() {
-                w.push_str("\n");
-            }
-
-            if !provided_methods.is_empty() {
-                write_str(
-                    w,
-                    format_args_nl!("    // Provided method{}", pluralize(provided_methods.len())),
-                );
-            }
-            for (pos, m) in provided_methods.iter().enumerate() {
-                render_assoc_item(
-                    w,
-                    m,
-                    AssocItemLink::Anchor(None),
-                    ItemType::Trait,
-                    cx,
-                    RenderMode::Normal,
-                );
-
-                w.push_str(" { ... }\n");
-
-                if pos < provided_methods.len() - 1 {
-                    w.push_str("<span class=\"item-spacer\"></span>");
-                }
-            }
-            if toggle {
-                toggle_close(&mut w);
-            }
-            w.push_str("}");
-        }
-    });
-
-    // Trait documentation
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
-
-    fn trait_item(w: &mut String, cx: &Context<'_>, m: &clean::Item, t: &clean::Item) {
-        let name = m.name.unwrap();
-        info!("Documenting {name} on {ty_name:?}", ty_name = t.name);
-        let item_type = m.type_();
-        let id = cx.derive_id(format!("{item_type}.{name}"));
-
-        let mut content = String::new();
-        write_str(&mut content, format_args!("{}", document_full(m, cx, HeadingOffset::H5)));
-
-        let toggled = !content.is_empty();
-        if toggled {
-            let method_toggle_class = if item_type.is_method() { " method-toggle" } else { "" };
-            write_str(
-                w,
-                format_args!("<details class=\"toggle{method_toggle_class}\" open><summary>"),
-            );
-        }
-        write_str(w, format_args!("<section id=\"{id}\" class=\"method\">"));
-        render_rightside(w, cx, m, RenderMode::Normal);
-        write_str(w, format_args!("<h4 class=\"code-header\">"));
-        render_assoc_item(
-            w,
-            m,
-            AssocItemLink::Anchor(Some(&id)),
-            ItemType::Impl,
-            cx,
-            RenderMode::Normal,
-        );
-        w.push_str("</h4></section>");
-        document_item_info(cx, m, Some(t)).render_into(w).unwrap();
-        if toggled {
-            write_str(w, format_args!("</summary>"));
-            w.push_str(&content);
-            write_str(w, format_args!("</details>"));
-        }
-    }
-
-    if !required_consts.is_empty() {
-        write_section_heading(
-            w,
-            "Required Associated Constants",
-            "required-associated-consts",
-            None,
-            "<div class=\"methods\">",
-        );
-        for t in required_consts {
-            trait_item(w, cx, t, it);
-        }
-        w.push_str("</div>");
-    }
-    if !provided_consts.is_empty() {
-        write_section_heading(
-            w,
-            "Provided Associated Constants",
-            "provided-associated-consts",
-            None,
-            "<div class=\"methods\">",
-        );
-        for t in provided_consts {
-            trait_item(w, cx, t, it);
-        }
-        w.push_str("</div>");
-    }
-
-    if !required_types.is_empty() {
-        write_section_heading(
-            w,
-            "Required Associated Types",
-            "required-associated-types",
-            None,
-            "<div class=\"methods\">",
-        );
-        for t in required_types {
-            trait_item(w, cx, t, it);
-        }
-        w.push_str("</div>");
-    }
-    if !provided_types.is_empty() {
-        write_section_heading(
-            w,
-            "Provided Associated Types",
-            "provided-associated-types",
-            None,
-            "<div class=\"methods\">",
-        );
-        for t in provided_types {
-            trait_item(w, cx, t, it);
-        }
-        w.push_str("</div>");
-    }
-
-    // Output the documentation for each function individually
-    if !required_methods.is_empty() || must_implement_one_of_functions.is_some() {
-        write_section_heading(
-            w,
-            "Required Methods",
-            "required-methods",
-            None,
-            "<div class=\"methods\">",
-        );
-
-        if let Some(list) = must_implement_one_of_functions.as_deref() {
-            write_str(
-                w,
-                format_args!(
-                    "<div class=\"stab must_implement\">At least one of the `{}` methods is required.</div>",
-                    fmt::from_fn(|f| list.iter().joined("`, `", f))
-                ),
-            );
-        }
-
-        for m in required_methods {
-            trait_item(w, cx, m, it);
-        }
-        w.push_str("</div>");
-    }
-    if !provided_methods.is_empty() {
-        write_section_heading(
-            w,
-            "Provided Methods",
-            "provided-methods",
-            None,
-            "<div class=\"methods\">",
-        );
-        for m in provided_methods {
-            trait_item(w, cx, m, it);
-        }
-        w.push_str("</div>");
-    }
-
-    // If there are methods directly on this trait object, render them here.
-    write_str(
-        w,
-        format_args!(
-            "{}",
-            render_assoc_items(cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
-        ),
-    );
-
-    let mut extern_crates = FxIndexSet::default();
-
-    if !t.is_dyn_compatible(cx.tcx()) {
-        write_section_heading(
-            w,
-            "Dyn Compatibility",
-            "dyn-compatibility",
-            None,
-            format!(
-                "<div class=\"dyn-compatibility-info\"><p>This trait is <b>not</b> \
-                <a href=\"{base}/reference/items/traits.html#dyn-compatibility\">dyn compatible</a>.</p>\
-                <p><i>In older versions of Rust, dyn compatibility was called \"object safety\", \
-                so this trait is not object safe.</i></p></div>",
-                base = crate::clean::utils::DOC_RUST_LANG_ORG_VERSION
-            ),
-        );
-    }
-
-    if let Some(implementors) = cx.shared.cache.implementors.get(&it.item_id.expect_def_id()) {
-        // The DefId is for the first Type found with that name. The bool is
-        // if any Types with the same name but different DefId have been found.
-        let mut implementor_dups: FxHashMap<Symbol, (DefId, bool)> = FxHashMap::default();
-        for implementor in implementors {
-            if let Some(did) =
-                implementor.inner_impl().for_.without_borrowed_ref().def_id(&cx.shared.cache)
-                && !did.is_local()
-            {
-                extern_crates.insert(did.krate);
-            }
-            match implementor.inner_impl().for_.without_borrowed_ref() {
-                clean::Type::Path { ref path } if !path.is_assoc_ty() => {
-                    let did = path.def_id();
-                    let &mut (prev_did, ref mut has_duplicates) =
-                        implementor_dups.entry(path.last()).or_insert((did, false));
-                    if prev_did != did {
-                        *has_duplicates = true;
+                for types in [&required_types, &provided_types] {
+                    for t in types {
+                        writeln!(
+                            w,
+                            "{};",
+                            render_assoc_item(
+                                t,
+                                AssocItemLink::Anchor(None),
+                                ItemType::Trait,
+                                cx,
+                                RenderMode::Normal,
+                            )
+                        )?;
                     }
                 }
-                _ => {}
+                // If there are too many associated constants, hide everything after them
+                // We also do this if the types + consts is large because otherwise we could
+                // render a bunch of types and _then_ a bunch of consts just because both were
+                // _just_ under the limit
+                if !toggle && should_hide_fields(count_types + count_consts) {
+                    toggle = true;
+                    toggle_open(
+                        &mut w,
+                        format_args!(
+                            "{count_consts} associated constant{plural_const} and \
+                         {count_methods} method{plural_method}",
+                            plural_const = pluralize(count_consts),
+                            plural_method = pluralize(count_methods),
+                        ),
+                    );
+                }
+                if count_types != 0 && (count_consts != 0 || count_methods != 0) {
+                    w.write_str("\n")?;
+                }
+                for consts in [&required_consts, &provided_consts] {
+                    for c in consts {
+                        writeln!(
+                            w,
+                            "{};",
+                            render_assoc_item(
+                                c,
+                                AssocItemLink::Anchor(None),
+                                ItemType::Trait,
+                                cx,
+                                RenderMode::Normal,
+                            )
+                        )?;
+                    }
+                }
+                if !toggle && should_hide_fields(count_methods) {
+                    toggle = true;
+                    toggle_open(&mut w, format_args!("{count_methods} methods"));
+                }
+                if count_consts != 0 && count_methods != 0 {
+                    w.write_str("\n")?;
+                }
+
+                if !required_methods.is_empty() {
+                    writeln!(w, "    // Required method{}", pluralize(required_methods.len()))?;
+                }
+                for (pos, m) in required_methods.iter().enumerate() {
+                    writeln!(
+                        w,
+                        "{};",
+                        render_assoc_item(
+                            m,
+                            AssocItemLink::Anchor(None),
+                            ItemType::Trait,
+                            cx,
+                            RenderMode::Normal,
+                        )
+                    )?;
+
+                    if pos < required_methods.len() - 1 {
+                        w.write_str("<span class=\"item-spacer\"></span>")?;
+                    }
+                }
+                if !required_methods.is_empty() && !provided_methods.is_empty() {
+                    w.write_str("\n")?;
+                }
+
+                if !provided_methods.is_empty() {
+                    writeln!(w, "    // Provided method{}", pluralize(provided_methods.len()))?;
+                }
+                for (pos, m) in provided_methods.iter().enumerate() {
+                    writeln!(
+                        w,
+                        "{} {{ ... }}",
+                        render_assoc_item(
+                            m,
+                            AssocItemLink::Anchor(None),
+                            ItemType::Trait,
+                            cx,
+                            RenderMode::Normal,
+                        )
+                    )?;
+
+                    if pos < provided_methods.len() - 1 {
+                        w.write_str("<span class=\"item-spacer\"></span>")?;
+                    }
+                }
+                if toggle {
+                    toggle_close(&mut w);
+                }
+                w.write_str("}")
             }
+        })?;
+
+        // Trait documentation
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))?;
+
+        fn trait_item<'a, 'tcx>(
+            cx: &'a Context<'tcx>,
+            m: &'a clean::Item,
+            t: &'a clean::Item,
+        ) -> impl fmt::Display + 'a + Captures<'tcx> {
+            fmt::from_fn(|w| {
+                let name = m.name.unwrap();
+                info!("Documenting {name} on {ty_name:?}", ty_name = t.name);
+                let item_type = m.type_();
+                let id = cx.derive_id(format!("{item_type}.{name}"));
+
+                let content = document_full(m, cx, HeadingOffset::H5).to_string();
+
+                let toggled = !content.is_empty();
+                if toggled {
+                    let method_toggle_class =
+                        if item_type.is_method() { " method-toggle" } else { "" };
+                    write!(w, "<details class=\"toggle{method_toggle_class}\" open><summary>")?;
+                }
+                write!(
+                    w,
+                    "<section id=\"{id}\" class=\"method\">\
+                    {}\
+                    <h4 class=\"code-header\">{}</h4></section>",
+                    render_rightside(cx, m, RenderMode::Normal),
+                    render_assoc_item(
+                        m,
+                        AssocItemLink::Anchor(Some(&id)),
+                        ItemType::Impl,
+                        cx,
+                        RenderMode::Normal,
+                    )
+                )?;
+                document_item_info(cx, m, Some(t)).render_into(w).unwrap();
+                if toggled {
+                    write!(w, "</summary>{content}</details>")?;
+                }
+                Ok(())
+            })
         }
 
-        let (local, mut foreign) =
-            implementors.iter().partition::<Vec<_>, _>(|i| i.is_on_local_type(cx));
-
-        let (mut synthetic, mut concrete): (Vec<&&Impl>, Vec<&&Impl>) =
-            local.iter().partition(|i| i.inner_impl().kind.is_auto());
-
-        synthetic.sort_by_cached_key(|i| ImplString::new(i, cx));
-        concrete.sort_by_cached_key(|i| ImplString::new(i, cx));
-        foreign.sort_by_cached_key(|i| ImplString::new(i, cx));
-
-        if !foreign.is_empty() {
-            write_section_heading(w, "Implementations on Foreign Types", "foreign-impls", None, "");
-
-            for implementor in foreign {
-                let provided_methods = implementor.inner_impl().provided_trait_methods(tcx);
-                let assoc_link =
-                    AssocItemLink::GotoSource(implementor.impl_item.item_id, &provided_methods);
-                render_impl(
-                    w,
-                    cx,
-                    implementor,
-                    it,
-                    assoc_link,
-                    RenderMode::Normal,
+        if !required_consts.is_empty() {
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    "Required Associated Constants",
+                    "required-associated-consts",
                     None,
-                    &[],
-                    ImplRenderingParameters {
-                        show_def_docs: false,
-                        show_default_items: false,
-                        show_non_assoc_items: true,
-                        toggle_open_by_default: false,
-                    },
-                );
+                    "<div class=\"methods\">",
+                )
+            )?;
+            for t in required_consts {
+                write!(w, "{}", trait_item(cx, t, it))?;
             }
+            w.write_str("</div>")?;
         }
-
-        write_section_heading(
-            w,
-            "Implementors",
-            "implementors",
-            None,
-            "<div id=\"implementors-list\">",
-        );
-        for implementor in concrete {
-            render_implementor(cx, implementor, it, w, &implementor_dups, &[]);
-        }
-        w.push_str("</div>");
-
-        if t.is_auto(tcx) {
-            write_section_heading(
+        if !provided_consts.is_empty() {
+            write!(
                 w,
-                "Auto implementors",
-                "synthetic-implementors",
-                None,
-                "<div id=\"synthetic-implementors-list\">",
-            );
-            for implementor in synthetic {
-                render_implementor(
-                    cx,
-                    implementor,
-                    it,
+                "{}",
+                write_section_heading(
+                    "Provided Associated Constants",
+                    "provided-associated-consts",
+                    None,
+                    "<div class=\"methods\">",
+                )
+            )?;
+            for t in provided_consts {
+                write!(w, "{}", trait_item(cx, t, it))?;
+            }
+            w.write_str("</div>")?;
+        }
+
+        if !required_types.is_empty() {
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    "Required Associated Types",
+                    "required-associated-types",
+                    None,
+                    "<div class=\"methods\">",
+                )
+            )?;
+            for t in required_types {
+                write!(w, "{}", trait_item(cx, t, it))?;
+            }
+            w.write_str("</div>")?;
+        }
+        if !provided_types.is_empty() {
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    "Provided Associated Types",
+                    "provided-associated-types",
+                    None,
+                    "<div class=\"methods\">",
+                )
+            )?;
+            for t in provided_types {
+                write!(w, "{}", trait_item(cx, t, it))?;
+            }
+            w.write_str("</div>")?;
+        }
+
+        // Output the documentation for each function individually
+        if !required_methods.is_empty() || must_implement_one_of_functions.is_some() {
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    "Required Methods",
+                    "required-methods",
+                    None,
+                    "<div class=\"methods\">",
+                )
+            )?;
+
+            if let Some(list) = must_implement_one_of_functions.as_deref() {
+                write!(
                     w,
-                    &implementor_dups,
-                    &collect_paths_for_type(
-                        implementor.inner_impl().for_.clone(),
-                        &cx.shared.cache,
-                    ),
-                );
+                    "<div class=\"stab must_implement\">At least one of the `{}` methods is required.</div>",
+                    fmt::from_fn(|f| list.iter().joined("`, `", f)),
+                )?;
             }
-            w.push_str("</div>");
-        }
-    } else {
-        // even without any implementations to write in, we still want the heading and list, so the
-        // implementors javascript file pulled in below has somewhere to write the impls into
-        write_section_heading(
-            w,
-            "Implementors",
-            "implementors",
-            None,
-            "<div id=\"implementors-list\"></div>",
-        );
 
-        if t.is_auto(tcx) {
-            write_section_heading(
+            for m in required_methods {
+                write!(w, "{}", trait_item(cx, m, it))?;
+            }
+            w.write_str("</div>")?;
+        }
+        if !provided_methods.is_empty() {
+            write!(
                 w,
-                "Auto implementors",
-                "synthetic-implementors",
-                None,
-                "<div id=\"synthetic-implementors-list\"></div>",
-            );
+                "{}",
+                write_section_heading(
+                    "Provided Methods",
+                    "provided-methods",
+                    None,
+                    "<div class=\"methods\">",
+                )
+            )?;
+            for m in provided_methods {
+                write!(w, "{}", trait_item(cx, m, it))?;
+            }
+            w.write_str("</div>")?;
         }
-    }
 
-    // [RUSTDOCIMPL] trait.impl
-    //
-    // Include implementors in crates that depend on the current crate.
-    //
-    // This is complicated by the way rustdoc is invoked, which is basically
-    // the same way rustc is invoked: it gets called, one at a time, for each
-    // crate. When building the rustdocs for the current crate, rustdoc can
-    // see crate metadata for its dependencies, but cannot see metadata for its
-    // dependents.
-    //
-    // To make this work, we generate a "hook" at this stage, and our
-    // dependents can "plug in" to it when they build. For simplicity's sake,
-    // it's [JSONP]: a JavaScript file with the data we need (and can parse),
-    // surrounded by a tiny wrapper that the Rust side ignores, but allows the
-    // JavaScript side to include without having to worry about Same Origin
-    // Policy. The code for *that* is in `write_shared.rs`.
-    //
-    // This is further complicated by `#[doc(inline)]`. We want all copies
-    // of an inlined trait to reference the same JS file, to address complex
-    // dependency graphs like this one (lower crates depend on higher crates):
-    //
-    // ```text
-    //  --------------------------------------------
-    //  |            crate A: trait Foo            |
-    //  --------------------------------------------
-    //      |                               |
-    //  --------------------------------    |
-    //  | crate B: impl A::Foo for Bar |    |
-    //  --------------------------------    |
-    //      |                               |
-    //  ---------------------------------------------
-    //  | crate C: #[doc(inline)] use A::Foo as Baz |
-    //  |          impl Baz for Quux                |
-    //  ---------------------------------------------
-    // ```
-    //
-    // Basically, we want `C::Baz` and `A::Foo` to show the same set of
-    // impls, which is easier if they both treat `/trait.impl/A/trait.Foo.js`
-    // as the Single Source of Truth.
-    //
-    // We also want the `impl Baz for Quux` to be written to
-    // `trait.Foo.js`. However, when we generate plain HTML for `C::Baz`,
-    // we're going to want to generate plain HTML for `impl Baz for Quux` too,
-    // because that'll load faster, and it's better for SEO. And we don't want
-    // the same impl to show up twice on the same page.
-    //
-    // To make this work, the trait.impl/A/trait.Foo.js JS file has a structure kinda
-    // like this:
-    //
-    // ```js
-    // JSONP({
-    // "B": {"impl A::Foo for Bar"},
-    // "C": {"impl Baz for Quux"},
-    // });
-    // ```
-    //
-    // First of all, this means we can rebuild a crate, and it'll replace its own
-    // data if something changes. That is, `rustdoc` is idempotent. The other
-    // advantage is that we can list the crates that get included in the HTML,
-    // and ignore them when doing the JavaScript-based part of rendering.
-    // So C's HTML will have something like this:
-    //
-    // ```html
-    // <script src="/trait.impl/A/trait.Foo.js"
-    //     data-ignore-extern-crates="A,B" async></script>
-    // ```
-    //
-    // And, when the JS runs, anything in data-ignore-extern-crates is known
-    // to already be in the HTML, and will be ignored.
-    //
-    // [JSONP]: https://en.wikipedia.org/wiki/JSONP
-    let mut js_src_path: UrlPartsBuilder = std::iter::repeat("..")
-        .take(cx.current.len())
-        .chain(std::iter::once("trait.impl"))
-        .collect();
-    if let Some(did) = it.item_id.as_def_id()
-        && let get_extern = { || cx.shared.cache.external_paths.get(&did).map(|s| &s.0) }
-        && let Some(fqp) = cx.shared.cache.exact_paths.get(&did).or_else(get_extern)
-    {
-        js_src_path.extend(fqp[..fqp.len() - 1].iter().copied());
-        js_src_path.push_fmt(format_args!("{}.{}.js", it.type_(), fqp.last().unwrap()));
-    } else {
-        js_src_path.extend(cx.current.iter().copied());
-        js_src_path.push_fmt(format_args!("{}.{}.js", it.type_(), it.name.unwrap()));
-    }
-    let extern_crates = fmt::from_fn(|f| {
-        if !extern_crates.is_empty() {
-            f.write_str(" data-ignore-extern-crates=\"")?;
-            extern_crates.iter().map(|&cnum| tcx.crate_name(cnum)).joined(",", f)?;
-            f.write_str("\"")?;
-        }
-        Ok(())
-    });
-    write_str(
-        w,
-        format_args!(
-            "<script src=\"{src}\"{extern_crates} async></script>",
-            src = js_src_path.finish()
-        ),
-    );
-}
-
-fn item_trait_alias(
-    w: &mut impl fmt::Write,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    t: &clean::TraitAlias,
-) {
-    wrap_item(w, |w| {
+        // If there are methods directly on this trait object, render them here.
         write!(
             w,
-            "{attrs}trait {name}{generics}{where_b} = {bounds};",
-            attrs = render_attributes_in_pre(it, "", cx),
-            name = it.name.unwrap(),
-            generics = t.generics.print(cx),
-            where_b = print_where_clause(&t.generics, cx, 0, Ending::Newline),
-            bounds = bounds(&t.bounds, true, cx),
-        )
-        .unwrap();
-    });
+            "{}",
+            render_assoc_items(cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
+        )?;
 
-    write!(w, "{}", document(cx, it, None, HeadingOffset::H2)).unwrap();
-    // Render any items associated directly to this alias, as otherwise they
-    // won't be visible anywhere in the docs. It would be nice to also show
-    // associated items from the aliased type (see discussion in #32077), but
-    // we need #14072 to make sense of the generics.
-    write!(w, "{}", render_assoc_items(cx, it, it.item_id.expect_def_id(), AssocItemRender::All))
-        .unwrap();
+        let mut extern_crates = FxIndexSet::default();
+
+        if !t.is_dyn_compatible(cx.tcx()) {
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    "Dyn Compatibility",
+                    "dyn-compatibility",
+                    None,
+                    format!(
+                        "<div class=\"dyn-compatibility-info\"><p>This trait is <b>not</b> \
+                        <a href=\"{base}/reference/items/traits.html#dyn-compatibility\">dyn compatible</a>.</p>\
+                        <p><i>In older versions of Rust, dyn compatibility was called \"object safety\", \
+                        so this trait is not object safe.</i></p></div>",
+                        base = crate::clean::utils::DOC_RUST_LANG_ORG_VERSION
+                    ),
+                ),
+            )?;
+        }
+
+        if let Some(implementors) = cx.shared.cache.implementors.get(&it.item_id.expect_def_id()) {
+            // The DefId is for the first Type found with that name. The bool is
+            // if any Types with the same name but different DefId have been found.
+            let mut implementor_dups: FxHashMap<Symbol, (DefId, bool)> = FxHashMap::default();
+            for implementor in implementors {
+                if let Some(did) =
+                    implementor.inner_impl().for_.without_borrowed_ref().def_id(&cx.shared.cache)
+                    && !did.is_local()
+                {
+                    extern_crates.insert(did.krate);
+                }
+                match implementor.inner_impl().for_.without_borrowed_ref() {
+                    clean::Type::Path { ref path } if !path.is_assoc_ty() => {
+                        let did = path.def_id();
+                        let &mut (prev_did, ref mut has_duplicates) =
+                            implementor_dups.entry(path.last()).or_insert((did, false));
+                        if prev_did != did {
+                            *has_duplicates = true;
+                        }
+                    }
+                    _ => {}
+                }
+            }
+
+            let (local, mut foreign) =
+                implementors.iter().partition::<Vec<_>, _>(|i| i.is_on_local_type(cx));
+
+            let (mut synthetic, mut concrete): (Vec<&&Impl>, Vec<&&Impl>) =
+                local.iter().partition(|i| i.inner_impl().kind.is_auto());
+
+            synthetic.sort_by_cached_key(|i| ImplString::new(i, cx));
+            concrete.sort_by_cached_key(|i| ImplString::new(i, cx));
+            foreign.sort_by_cached_key(|i| ImplString::new(i, cx));
+
+            if !foreign.is_empty() {
+                write!(
+                    w,
+                    "{}",
+                    write_section_heading(
+                        "Implementations on Foreign Types",
+                        "foreign-impls",
+                        None,
+                        ""
+                    )
+                )?;
+
+                for implementor in foreign {
+                    let provided_methods = implementor.inner_impl().provided_trait_methods(tcx);
+                    let assoc_link =
+                        AssocItemLink::GotoSource(implementor.impl_item.item_id, &provided_methods);
+                    write!(
+                        w,
+                        "{}",
+                        render_impl(
+                            cx,
+                            implementor,
+                            it,
+                            assoc_link,
+                            RenderMode::Normal,
+                            None,
+                            &[],
+                            ImplRenderingParameters {
+                                show_def_docs: false,
+                                show_default_items: false,
+                                show_non_assoc_items: true,
+                                toggle_open_by_default: false,
+                            },
+                        )
+                    )?;
+                }
+            }
+
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    "Implementors",
+                    "implementors",
+                    None,
+                    "<div id=\"implementors-list\">",
+                )
+            )?;
+            for implementor in concrete {
+                write!(w, "{}", render_implementor(cx, implementor, it, &implementor_dups, &[]))?;
+            }
+            w.write_str("</div>")?;
+
+            if t.is_auto(tcx) {
+                write!(
+                    w,
+                    "{}",
+                    write_section_heading(
+                        "Auto implementors",
+                        "synthetic-implementors",
+                        None,
+                        "<div id=\"synthetic-implementors-list\">",
+                    )
+                )?;
+                for implementor in synthetic {
+                    write!(
+                        w,
+                        "{}",
+                        render_implementor(
+                            cx,
+                            implementor,
+                            it,
+                            &implementor_dups,
+                            &collect_paths_for_type(
+                                implementor.inner_impl().for_.clone(),
+                                &cx.shared.cache,
+                            ),
+                        )
+                    )?;
+                }
+                w.write_str("</div>")?;
+            }
+        } else {
+            // even without any implementations to write in, we still want the heading and list, so the
+            // implementors javascript file pulled in below has somewhere to write the impls into
+            write!(
+                w,
+                "{}",
+                write_section_heading(
+                    "Implementors",
+                    "implementors",
+                    None,
+                    "<div id=\"implementors-list\"></div>",
+                )
+            )?;
+
+            if t.is_auto(tcx) {
+                write!(
+                    w,
+                    "{}",
+                    write_section_heading(
+                        "Auto implementors",
+                        "synthetic-implementors",
+                        None,
+                        "<div id=\"synthetic-implementors-list\"></div>",
+                    )
+                )?;
+            }
+        }
+
+        // [RUSTDOCIMPL] trait.impl
+        //
+        // Include implementors in crates that depend on the current crate.
+        //
+        // This is complicated by the way rustdoc is invoked, which is basically
+        // the same way rustc is invoked: it gets called, one at a time, for each
+        // crate. When building the rustdocs for the current crate, rustdoc can
+        // see crate metadata for its dependencies, but cannot see metadata for its
+        // dependents.
+        //
+        // To make this work, we generate a "hook" at this stage, and our
+        // dependents can "plug in" to it when they build. For simplicity's sake,
+        // it's [JSONP]: a JavaScript file with the data we need (and can parse),
+        // surrounded by a tiny wrapper that the Rust side ignores, but allows the
+        // JavaScript side to include without having to worry about Same Origin
+        // Policy. The code for *that* is in `write_shared.rs`.
+        //
+        // This is further complicated by `#[doc(inline)]`. We want all copies
+        // of an inlined trait to reference the same JS file, to address complex
+        // dependency graphs like this one (lower crates depend on higher crates):
+        //
+        // ```text
+        //  --------------------------------------------
+        //  |            crate A: trait Foo            |
+        //  --------------------------------------------
+        //      |                               |
+        //  --------------------------------    |
+        //  | crate B: impl A::Foo for Bar |    |
+        //  --------------------------------    |
+        //      |                               |
+        //  ---------------------------------------------
+        //  | crate C: #[doc(inline)] use A::Foo as Baz |
+        //  |          impl Baz for Quux                |
+        //  ---------------------------------------------
+        // ```
+        //
+        // Basically, we want `C::Baz` and `A::Foo` to show the same set of
+        // impls, which is easier if they both treat `/trait.impl/A/trait.Foo.js`
+        // as the Single Source of Truth.
+        //
+        // We also want the `impl Baz for Quux` to be written to
+        // `trait.Foo.js`. However, when we generate plain HTML for `C::Baz`,
+        // we're going to want to generate plain HTML for `impl Baz for Quux` too,
+        // because that'll load faster, and it's better for SEO. And we don't want
+        // the same impl to show up twice on the same page.
+        //
+        // To make this work, the trait.impl/A/trait.Foo.js JS file has a structure kinda
+        // like this:
+        //
+        // ```js
+        // JSONP({
+        // "B": {"impl A::Foo for Bar"},
+        // "C": {"impl Baz for Quux"},
+        // });
+        // ```
+        //
+        // First of all, this means we can rebuild a crate, and it'll replace its own
+        // data if something changes. That is, `rustdoc` is idempotent. The other
+        // advantage is that we can list the crates that get included in the HTML,
+        // and ignore them when doing the JavaScript-based part of rendering.
+        // So C's HTML will have something like this:
+        //
+        // ```html
+        // <script src="/trait.impl/A/trait.Foo.js"
+        //     data-ignore-extern-crates="A,B" async></script>
+        // ```
+        //
+        // And, when the JS runs, anything in data-ignore-extern-crates is known
+        // to already be in the HTML, and will be ignored.
+        //
+        // [JSONP]: https://en.wikipedia.org/wiki/JSONP
+        let mut js_src_path: UrlPartsBuilder = std::iter::repeat("..")
+            .take(cx.current.len())
+            .chain(std::iter::once("trait.impl"))
+            .collect();
+        if let Some(did) = it.item_id.as_def_id()
+            && let get_extern = { || cx.shared.cache.external_paths.get(&did).map(|s| &s.0) }
+            && let Some(fqp) = cx.shared.cache.exact_paths.get(&did).or_else(get_extern)
+        {
+            js_src_path.extend(fqp[..fqp.len() - 1].iter().copied());
+            js_src_path.push_fmt(format_args!("{}.{}.js", it.type_(), fqp.last().unwrap()));
+        } else {
+            js_src_path.extend(cx.current.iter().copied());
+            js_src_path.push_fmt(format_args!("{}.{}.js", it.type_(), it.name.unwrap()));
+        }
+        let extern_crates = fmt::from_fn(|f| {
+            if !extern_crates.is_empty() {
+                f.write_str(" data-ignore-extern-crates=\"")?;
+                extern_crates.iter().map(|&cnum| tcx.crate_name(cnum)).joined(",", f)?;
+                f.write_str("\"")?;
+            }
+            Ok(())
+        });
+        write!(
+            w,
+            "<script src=\"{src}\"{extern_crates} async></script>",
+            src = js_src_path.finish()
+        )
+    })
 }
 
-fn item_type_alias(w: &mut String, cx: &Context<'_>, it: &clean::Item, t: &clean::TypeAlias) {
-    wrap_item(w, |w| {
-        write_str(
+fn item_trait_alias<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    t: &'a clean::TraitAlias,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        wrap_item(w, |w| {
+            write!(
+                w,
+                "{attrs}trait {name}{generics}{where_b} = {bounds};",
+                attrs = render_attributes_in_pre(it, "", cx),
+                name = it.name.unwrap(),
+                generics = t.generics.print(cx),
+                where_b = print_where_clause(&t.generics, cx, 0, Ending::Newline).maybe_display(),
+                bounds = bounds(&t.bounds, true, cx),
+            )
+        })?;
+
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))?;
+        // Render any items associated directly to this alias, as otherwise they
+        // won't be visible anywhere in the docs. It would be nice to also show
+        // associated items from the aliased type (see discussion in #32077), but
+        // we need #14072 to make sense of the generics.
+        write!(
             w,
-            format_args!(
+            "{}",
+            render_assoc_items(cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
+        )
+    })
+}
+
+fn item_type_alias<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    t: &'a clean::TypeAlias,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        wrap_item(w, |w| {
+            write!(
+                w,
                 "{attrs}{vis}type {name}{generics}{where_clause} = {type_};",
                 attrs = render_attributes_in_pre(it, "", cx),
                 vis = visibility_print_with_space(it, cx),
                 name = it.name.unwrap(),
                 generics = t.generics.print(cx),
-                where_clause = print_where_clause(&t.generics, cx, 0, Ending::Newline),
+                where_clause =
+                    print_where_clause(&t.generics, cx, 0, Ending::Newline).maybe_display(),
                 type_ = t.type_.print(cx),
-            ),
-        );
-    });
+            )
+        })?;
 
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))?;
 
-    if let Some(inner_type) = &t.inner_type {
-        write_section_heading(w, "Aliased Type", "aliased-type", None, "");
+        if let Some(inner_type) = &t.inner_type {
+            write!(w, "{}", write_section_heading("Aliased Type", "aliased-type", None, ""),)?;
 
-        match inner_type {
-            clean::TypeAliasInnerType::Enum { variants, is_non_exhaustive } => {
-                let variants_iter = || variants.iter().filter(|i| !i.is_stripped());
-                let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity();
-                let enum_def_id = ty.ty_adt_def().unwrap().did();
+            match inner_type {
+                clean::TypeAliasInnerType::Enum { variants, is_non_exhaustive } => {
+                    let variants_iter = || variants.iter().filter(|i| !i.is_stripped());
+                    let ty = cx.tcx().type_of(it.def_id().unwrap()).instantiate_identity();
+                    let enum_def_id = ty.ty_adt_def().unwrap().did();
 
-                wrap_item(w, |w| {
-                    let variants_len = variants.len();
-                    let variants_count = variants_iter().count();
-                    let has_stripped_entries = variants_len != variants_count;
+                    wrap_item(w, |w| {
+                        let variants_len = variants.len();
+                        let variants_count = variants_iter().count();
+                        let has_stripped_entries = variants_len != variants_count;
 
-                    write_str(w, format_args!("enum {}{}", it.name.unwrap(), t.generics.print(cx)));
-                    render_enum_fields(
-                        w,
-                        cx,
-                        Some(&t.generics),
-                        variants,
-                        variants_count,
-                        has_stripped_entries,
-                        *is_non_exhaustive,
-                        enum_def_id,
-                    )
-                });
-                item_variants(w, cx, it, variants, enum_def_id);
-            }
-            clean::TypeAliasInnerType::Union { fields } => {
-                wrap_item(w, |w| {
-                    let fields_count = fields.iter().filter(|i| !i.is_stripped()).count();
-                    let has_stripped_fields = fields.len() != fields_count;
+                        write!(
+                            w,
+                            "enum {}{}{}",
+                            it.name.unwrap(),
+                            t.generics.print(cx),
+                            render_enum_fields(
+                                cx,
+                                Some(&t.generics),
+                                variants,
+                                variants_count,
+                                has_stripped_entries,
+                                *is_non_exhaustive,
+                                enum_def_id,
+                            )
+                        )
+                    })?;
+                    write!(w, "{}", item_variants(cx, it, variants, enum_def_id))?;
+                }
+                clean::TypeAliasInnerType::Union { fields } => {
+                    wrap_item(w, |w| {
+                        let fields_count = fields.iter().filter(|i| !i.is_stripped()).count();
+                        let has_stripped_fields = fields.len() != fields_count;
 
-                    write_str(
-                        w,
-                        format_args!("union {}{}", it.name.unwrap(), t.generics.print(cx)),
-                    );
-                    render_struct_fields(
-                        w,
-                        Some(&t.generics),
-                        None,
-                        fields,
-                        "",
-                        true,
-                        has_stripped_fields,
-                        cx,
-                    );
-                });
-                item_fields(w, cx, it, fields, None);
-            }
-            clean::TypeAliasInnerType::Struct { ctor_kind, fields } => {
-                wrap_item(w, |w| {
-                    let fields_count = fields.iter().filter(|i| !i.is_stripped()).count();
-                    let has_stripped_fields = fields.len() != fields_count;
+                        write!(
+                            w,
+                            "union {}{}{}",
+                            it.name.unwrap(),
+                            t.generics.print(cx),
+                            render_struct_fields(
+                                Some(&t.generics),
+                                None,
+                                fields,
+                                "",
+                                true,
+                                has_stripped_fields,
+                                cx,
+                            ),
+                        )
+                    })?;
+                    write!(w, "{}", item_fields(cx, it, fields, None))?;
+                }
+                clean::TypeAliasInnerType::Struct { ctor_kind, fields } => {
+                    wrap_item(w, |w| {
+                        let fields_count = fields.iter().filter(|i| !i.is_stripped()).count();
+                        let has_stripped_fields = fields.len() != fields_count;
 
-                    write_str(
-                        w,
-                        format_args!("struct {}{}", it.name.unwrap(), t.generics.print(cx)),
-                    );
-                    render_struct_fields(
-                        w,
-                        Some(&t.generics),
-                        *ctor_kind,
-                        fields,
-                        "",
-                        true,
-                        has_stripped_fields,
-                        cx,
-                    );
-                });
-                item_fields(w, cx, it, fields, None);
+                        write!(
+                            w,
+                            "struct {}{}{}",
+                            it.name.unwrap(),
+                            t.generics.print(cx),
+                            render_struct_fields(
+                                Some(&t.generics),
+                                *ctor_kind,
+                                fields,
+                                "",
+                                true,
+                                has_stripped_fields,
+                                cx,
+                            ),
+                        )
+                    })?;
+                    write!(w, "{}", item_fields(cx, it, fields, None))?;
+                }
             }
         }
-    }
 
-    let def_id = it.item_id.expect_def_id();
-    // Render any items associated directly to this alias, as otherwise they
-    // won't be visible anywhere in the docs. It would be nice to also show
-    // associated items from the aliased type (see discussion in #32077), but
-    // we need #14072 to make sense of the generics.
-    write_str(w, format_args!("{}", render_assoc_items(cx, it, def_id, AssocItemRender::All)));
-    write_str(w, format_args!("{}", document_type_layout(cx, def_id)));
-
-    // [RUSTDOCIMPL] type.impl
-    //
-    // Include type definitions from the alias target type.
-    //
-    // Earlier versions of this code worked by having `render_assoc_items`
-    // include this data directly. That generates *O*`(types*impls)` of HTML
-    // text, and some real crates have a lot of types and impls.
-    //
-    // To create the same UX without generating half a gigabyte of HTML for a
-    // crate that only contains 20 megabytes of actual documentation[^115718],
-    // rustdoc stashes these type-alias-inlined docs in a [JSONP]
-    // "database-lite". The file itself is generated in `write_shared.rs`,
-    // and hooks into functions provided by `main.js`.
-    //
-    // The format of `trait.impl` and `type.impl` JS files are superficially
-    // similar. Each line, except the JSONP wrapper itself, belongs to a crate,
-    // and they are otherwise separate (rustdoc should be idempotent). The
-    // "meat" of the file is HTML strings, so the frontend code is very simple.
-    // Links are relative to the doc root, though, so the frontend needs to fix
-    // that up, and inlined docs can reuse these files.
-    //
-    // However, there are a few differences, caused by the sophisticated
-    // features that type aliases have. Consider this crate graph:
-    //
-    // ```text
-    //  ---------------------------------
-    //  | crate A: struct Foo<T>        |
-    //  |          type Bar = Foo<i32>  |
-    //  |          impl X for Foo<i8>   |
-    //  |          impl Y for Foo<i32>  |
-    //  ---------------------------------
-    //      |
-    //  ----------------------------------
-    //  | crate B: type Baz = A::Foo<i8> |
-    //  |          type Xyy = A::Foo<i8> |
-    //  |          impl Z for Xyy        |
-    //  ----------------------------------
-    // ```
-    //
-    // The type.impl/A/struct.Foo.js JS file has a structure kinda like this:
-    //
-    // ```js
-    // JSONP({
-    // "A": [["impl Y for Foo<i32>", "Y", "A::Bar"]],
-    // "B": [["impl X for Foo<i8>", "X", "B::Baz", "B::Xyy"], ["impl Z for Xyy", "Z", "B::Baz"]],
-    // });
-    // ```
-    //
-    // When the type.impl file is loaded, only the current crate's docs are
-    // actually used. The main reason to bundle them together is that there's
-    // enough duplication in them for DEFLATE to remove the redundancy.
-    //
-    // The contents of a crate are a list of impl blocks, themselves
-    // represented as lists. The first item in the sublist is the HTML block,
-    // the second item is the name of the trait (which goes in the sidebar),
-    // and all others are the names of type aliases that successfully match.
-    //
-    // This way:
-    //
-    // - There's no need to generate these files for types that have no aliases
-    //   in the current crate. If a dependent crate makes a type alias, it'll
-    //   take care of generating its own docs.
-    // - There's no need to reimplement parts of the type checker in
-    //   JavaScript. The Rust backend does the checking, and includes its
-    //   results in the file.
-    // - Docs defined directly on the type alias are dropped directly in the
-    //   HTML by `render_assoc_items`, and are accessible without JavaScript.
-    //   The JSONP file will not list impl items that are known to be part
-    //   of the main HTML file already.
-    //
-    // [JSONP]: https://en.wikipedia.org/wiki/JSONP
-    // [^115718]: https://github.com/rust-lang/rust/issues/115718
-    let cache = &cx.shared.cache;
-    if let Some(target_did) = t.type_.def_id(cache) &&
-        let get_extern = { || cache.external_paths.get(&target_did) } &&
-        let Some(&(ref target_fqp, target_type)) = cache.paths.get(&target_did).or_else(get_extern) &&
-        target_type.is_adt() && // primitives cannot be inlined
-        let Some(self_did) = it.item_id.as_def_id() &&
-        let get_local = { || cache.paths.get(&self_did).map(|(p, _)| p) } &&
-        let Some(self_fqp) = cache.exact_paths.get(&self_did).or_else(get_local)
-    {
-        let mut js_src_path: UrlPartsBuilder = std::iter::repeat("..")
-            .take(cx.current.len())
-            .chain(std::iter::once("type.impl"))
-            .collect();
-        js_src_path.extend(target_fqp[..target_fqp.len() - 1].iter().copied());
-        js_src_path.push_fmt(format_args!("{target_type}.{}.js", target_fqp.last().unwrap()));
-        let self_path = fmt::from_fn(|f| self_fqp.iter().joined("::", f));
-        write_str(
+        let def_id = it.item_id.expect_def_id();
+        // Render any items associated directly to this alias, as otherwise they
+        // won't be visible anywhere in the docs. It would be nice to also show
+        // associated items from the aliased type (see discussion in #32077), but
+        // we need #14072 to make sense of the generics.
+        write!(
             w,
-            format_args!(
+            "{}{}",
+            render_assoc_items(cx, it, def_id, AssocItemRender::All),
+            document_type_layout(cx, def_id)
+        )?;
+
+        // [RUSTDOCIMPL] type.impl
+        //
+        // Include type definitions from the alias target type.
+        //
+        // Earlier versions of this code worked by having `render_assoc_items`
+        // include this data directly. That generates *O*`(types*impls)` of HTML
+        // text, and some real crates have a lot of types and impls.
+        //
+        // To create the same UX without generating half a gigabyte of HTML for a
+        // crate that only contains 20 megabytes of actual documentation[^115718],
+        // rustdoc stashes these type-alias-inlined docs in a [JSONP]
+        // "database-lite". The file itself is generated in `write_shared.rs`,
+        // and hooks into functions provided by `main.js`.
+        //
+        // The format of `trait.impl` and `type.impl` JS files are superficially
+        // similar. Each line, except the JSONP wrapper itself, belongs to a crate,
+        // and they are otherwise separate (rustdoc should be idempotent). The
+        // "meat" of the file is HTML strings, so the frontend code is very simple.
+        // Links are relative to the doc root, though, so the frontend needs to fix
+        // that up, and inlined docs can reuse these files.
+        //
+        // However, there are a few differences, caused by the sophisticated
+        // features that type aliases have. Consider this crate graph:
+        //
+        // ```text
+        //  ---------------------------------
+        //  | crate A: struct Foo<T>        |
+        //  |          type Bar = Foo<i32>  |
+        //  |          impl X for Foo<i8>   |
+        //  |          impl Y for Foo<i32>  |
+        //  ---------------------------------
+        //      |
+        //  ----------------------------------
+        //  | crate B: type Baz = A::Foo<i8> |
+        //  |          type Xyy = A::Foo<i8> |
+        //  |          impl Z for Xyy        |
+        //  ----------------------------------
+        // ```
+        //
+        // The type.impl/A/struct.Foo.js JS file has a structure kinda like this:
+        //
+        // ```js
+        // JSONP({
+        // "A": [["impl Y for Foo<i32>", "Y", "A::Bar"]],
+        // "B": [["impl X for Foo<i8>", "X", "B::Baz", "B::Xyy"], ["impl Z for Xyy", "Z", "B::Baz"]],
+        // });
+        // ```
+        //
+        // When the type.impl file is loaded, only the current crate's docs are
+        // actually used. The main reason to bundle them together is that there's
+        // enough duplication in them for DEFLATE to remove the redundancy.
+        //
+        // The contents of a crate are a list of impl blocks, themselves
+        // represented as lists. The first item in the sublist is the HTML block,
+        // the second item is the name of the trait (which goes in the sidebar),
+        // and all others are the names of type aliases that successfully match.
+        //
+        // This way:
+        //
+        // - There's no need to generate these files for types that have no aliases
+        //   in the current crate. If a dependent crate makes a type alias, it'll
+        //   take care of generating its own docs.
+        // - There's no need to reimplement parts of the type checker in
+        //   JavaScript. The Rust backend does the checking, and includes its
+        //   results in the file.
+        // - Docs defined directly on the type alias are dropped directly in the
+        //   HTML by `render_assoc_items`, and are accessible without JavaScript.
+        //   The JSONP file will not list impl items that are known to be part
+        //   of the main HTML file already.
+        //
+        // [JSONP]: https://en.wikipedia.org/wiki/JSONP
+        // [^115718]: https://github.com/rust-lang/rust/issues/115718
+        let cache = &cx.shared.cache;
+        if let Some(target_did) = t.type_.def_id(cache)
+            && let get_extern = { || cache.external_paths.get(&target_did) }
+            && let Some(&(ref target_fqp, target_type)) =
+                cache.paths.get(&target_did).or_else(get_extern)
+            && target_type.is_adt() // primitives cannot be inlined
+            && let Some(self_did) = it.item_id.as_def_id()
+            && let get_local = { || cache.paths.get(&self_did).map(|(p, _)| p) }
+            && let Some(self_fqp) = cache.exact_paths.get(&self_did).or_else(get_local)
+        {
+            let mut js_src_path: UrlPartsBuilder = std::iter::repeat("..")
+                .take(cx.current.len())
+                .chain(std::iter::once("type.impl"))
+                .collect();
+            js_src_path.extend(target_fqp[..target_fqp.len() - 1].iter().copied());
+            js_src_path.push_fmt(format_args!("{target_type}.{}.js", target_fqp.last().unwrap()));
+            let self_path = fmt::from_fn(|f| self_fqp.iter().joined("::", f));
+            write!(
+                w,
                 "<script src=\"{src}\" data-self-path=\"{self_path}\" async></script>",
-                src = js_src_path.finish()
-            ),
-        );
-    }
+                src = js_src_path.finish(),
+            )?;
+        }
+        Ok(())
+    })
 }
 
-fn item_union(w: &mut String, cx: &Context<'_>, it: &clean::Item, s: &clean::Union) {
+fn item_union<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    s: &'a clean::Union,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
     item_template!(
         #[template(path = "item_union.html")]
         struct ItemUnion<'a, 'cx> {
@@ -1464,7 +1560,10 @@ fn item_union(w: &mut String, cx: &Context<'_>, it: &clean::Item, s: &clean::Uni
         }
     }
 
-    ItemUnion { cx, it, s }.render_into(w).unwrap();
+    fmt::from_fn(|w| {
+        ItemUnion { cx, it, s }.render_into(w).unwrap();
+        Ok(())
+    })
 }
 
 fn print_tuple_struct_fields<'a, 'cx: 'a>(
@@ -1492,40 +1591,46 @@ fn print_tuple_struct_fields<'a, 'cx: 'a>(
     })
 }
 
-fn item_enum(w: &mut String, cx: &Context<'_>, it: &clean::Item, e: &clean::Enum) {
-    let count_variants = e.variants().count();
-    wrap_item(w, |w| {
-        render_attributes_in_code(w, it, cx);
-        write_str(
-            w,
-            format_args!(
-                "{}enum {}{}",
+fn item_enum<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    e: &'a clean::Enum,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        let count_variants = e.variants().count();
+        wrap_item(w, |w| {
+            render_attributes_in_code(w, it, cx);
+            write!(
+                w,
+                "{}enum {}{}{}",
                 visibility_print_with_space(it, cx),
                 it.name.unwrap(),
                 e.generics.print(cx),
-            ),
-        );
+                render_enum_fields(
+                    cx,
+                    Some(&e.generics),
+                    &e.variants,
+                    count_variants,
+                    e.has_stripped_entries(),
+                    it.is_non_exhaustive(),
+                    it.def_id().unwrap(),
+                ),
+            )
+        })?;
 
-        render_enum_fields(
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))?;
+
+        if count_variants != 0 {
+            write!(w, "{}", item_variants(cx, it, &e.variants, it.def_id().unwrap()))?;
+        }
+        let def_id = it.item_id.expect_def_id();
+        write!(
             w,
-            cx,
-            Some(&e.generics),
-            &e.variants,
-            count_variants,
-            e.has_stripped_entries(),
-            it.is_non_exhaustive(),
-            it.def_id().unwrap(),
-        );
-    });
-
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
-
-    if count_variants != 0 {
-        item_variants(w, cx, it, &e.variants, it.def_id().unwrap());
-    }
-    let def_id = it.item_id.expect_def_id();
-    write_str(w, format_args!("{}", render_assoc_items(cx, it, def_id, AssocItemRender::All)));
-    write_str(w, format_args!("{}", document_type_layout(cx, def_id)));
+            "{}{}",
+            render_assoc_items(cx, it, def_id, AssocItemRender::All),
+            document_type_layout(cx, def_id)
+        )
+    })
 }
 
 /// It'll return false if any variant is not a C-like variant. Otherwise it'll return true if at
@@ -1553,456 +1658,508 @@ fn should_show_enum_discriminant(
     repr.c() || repr.int.is_some()
 }
 
-fn display_c_like_variant(
-    w: &mut String,
-    cx: &Context<'_>,
-    item: &clean::Item,
-    variant: &clean::Variant,
+fn display_c_like_variant<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    item: &'a clean::Item,
+    variant: &'a clean::Variant,
     index: VariantIdx,
     should_show_enum_discriminant: bool,
     enum_def_id: DefId,
-) {
-    let name = item.name.unwrap();
-    if let Some(ref value) = variant.discriminant {
-        write_str(w, format_args!("{} = {}", name.as_str(), value.value(cx.tcx(), true)));
-    } else if should_show_enum_discriminant {
-        let adt_def = cx.tcx().adt_def(enum_def_id);
-        let discr = adt_def.discriminant_for_variant(cx.tcx(), index);
-        if discr.ty.is_signed() {
-            write_str(w, format_args!("{} = {}", name.as_str(), discr.val as i128));
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        let name = item.name.unwrap();
+        if let Some(ref value) = variant.discriminant {
+            write!(w, "{} = {}", name.as_str(), value.value(cx.tcx(), true))?;
+        } else if should_show_enum_discriminant {
+            let adt_def = cx.tcx().adt_def(enum_def_id);
+            let discr = adt_def.discriminant_for_variant(cx.tcx(), index);
+            if discr.ty.is_signed() {
+                write!(w, "{} = {}", name.as_str(), discr.val as i128)?;
+            } else {
+                write!(w, "{} = {}", name.as_str(), discr.val)?;
+            }
         } else {
-            write_str(w, format_args!("{} = {}", name.as_str(), discr.val));
+            write!(w, "{name}")?;
         }
-    } else {
-        w.push_str(name.as_str());
-    }
+        Ok(())
+    })
 }
 
-fn render_enum_fields(
-    mut w: &mut String,
-    cx: &Context<'_>,
-    g: Option<&clean::Generics>,
-    variants: &IndexVec<VariantIdx, clean::Item>,
+fn render_enum_fields<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    g: Option<&'a clean::Generics>,
+    variants: &'a IndexVec<VariantIdx, clean::Item>,
     count_variants: usize,
     has_stripped_entries: bool,
     is_non_exhaustive: bool,
     enum_def_id: DefId,
-) {
-    let should_show_enum_discriminant = should_show_enum_discriminant(cx, enum_def_id, variants);
-    if !g.is_some_and(|g| print_where_clause_and_check(w, g, cx)) {
-        // If there wasn't a `where` clause, we add a whitespace.
-        w.push_str(" ");
-    }
-
-    let variants_stripped = has_stripped_entries;
-    if count_variants == 0 && !variants_stripped {
-        w.push_str("{}");
-    } else {
-        w.push_str("{\n");
-        let toggle = should_hide_fields(count_variants);
-        if toggle {
-            toggle_open(&mut w, format_args!("{count_variants} variants"));
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        let should_show_enum_discriminant =
+            should_show_enum_discriminant(cx, enum_def_id, variants);
+        if let Some(generics) = g
+            && let Some(where_clause) = print_where_clause(generics, cx, 0, Ending::Newline)
+        {
+            write!(w, "{where_clause}")?;
+        } else {
+            // If there wasn't a `where` clause, we add a whitespace.
+            w.write_char(' ')?;
         }
-        const TAB: &str = "    ";
-        for (index, v) in variants.iter_enumerated() {
-            if v.is_stripped() {
+
+        let variants_stripped = has_stripped_entries;
+        if count_variants == 0 && !variants_stripped {
+            w.write_str("{}")
+        } else {
+            w.write_str("{\n")?;
+            let toggle = should_hide_fields(count_variants);
+            if toggle {
+                toggle_open(&mut *w, format_args!("{count_variants} variants"));
+            }
+            const TAB: &str = "    ";
+            for (index, v) in variants.iter_enumerated() {
+                if v.is_stripped() {
+                    continue;
+                }
+                w.write_str(TAB)?;
+                match v.kind {
+                    clean::VariantItem(ref var) => match var.kind {
+                        clean::VariantKind::CLike => {
+                            write!(
+                                w,
+                                "{}",
+                                display_c_like_variant(
+                                    cx,
+                                    v,
+                                    var,
+                                    index,
+                                    should_show_enum_discriminant,
+                                    enum_def_id,
+                                )
+                            )?;
+                        }
+                        clean::VariantKind::Tuple(ref s) => {
+                            write!(w, "{}({})", v.name.unwrap(), print_tuple_struct_fields(cx, s))?;
+                        }
+                        clean::VariantKind::Struct(ref s) => {
+                            write!(
+                                w,
+                                "{}",
+                                render_struct(v, None, None, &s.fields, TAB, false, cx)
+                            )?;
+                        }
+                    },
+                    _ => unreachable!(),
+                }
+                w.write_str(",\n")?;
+            }
+
+            if variants_stripped && !is_non_exhaustive {
+                w.write_str("    <span class=\"comment\">// some variants omitted</span>\n")?;
+            }
+            if toggle {
+                toggle_close(&mut *w);
+            }
+            w.write_str("}")
+        }
+    })
+}
+
+fn item_variants<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    variants: &'a IndexVec<VariantIdx, clean::Item>,
+    enum_def_id: DefId,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        let tcx = cx.tcx();
+        write!(
+            w,
+            "{}",
+            write_section_heading(
+                &format!("Variants{}", document_non_exhaustive_header(it)),
+                "variants",
+                Some("variants"),
+                format!("{}<div class=\"variants\">", document_non_exhaustive(it)),
+            ),
+        )?;
+
+        let should_show_enum_discriminant =
+            should_show_enum_discriminant(cx, enum_def_id, variants);
+        for (index, variant) in variants.iter_enumerated() {
+            if variant.is_stripped() {
                 continue;
             }
-            w.push_str(TAB);
-            match v.kind {
-                clean::VariantItem(ref var) => match var.kind {
-                    clean::VariantKind::CLike => display_c_like_variant(
-                        w,
+            let id = cx.derive_id(format!("{}.{}", ItemType::Variant, variant.name.unwrap()));
+            write!(
+                w,
+                "<section id=\"{id}\" class=\"variant\">\
+                    <a href=\"#{id}\" class=\"anchor\">§</a>\
+                    {}\
+                    <h3 class=\"code-header\">",
+                render_stability_since_raw_with_extra(
+                    variant.stable_since(tcx),
+                    variant.const_stability(tcx),
+                    " rightside",
+                )
+                .maybe_display()
+            )?;
+            if let clean::VariantItem(ref var) = variant.kind
+                && let clean::VariantKind::CLike = var.kind
+            {
+                write!(
+                    w,
+                    "{}",
+                    display_c_like_variant(
                         cx,
-                        v,
+                        variant,
                         var,
                         index,
                         should_show_enum_discriminant,
                         enum_def_id,
-                    ),
-                    clean::VariantKind::Tuple(ref s) => {
-                        write_str(
-                            w,
-                            format_args!(
-                                "{}({})",
-                                v.name.unwrap(),
-                                print_tuple_struct_fields(cx, s)
-                            ),
-                        );
+                    )
+                )?;
+            } else {
+                w.write_str(variant.name.unwrap().as_str())?;
+            }
+
+            let clean::VariantItem(variant_data) = &variant.kind else { unreachable!() };
+
+            if let clean::VariantKind::Tuple(ref s) = variant_data.kind {
+                write!(w, "({})", print_tuple_struct_fields(cx, s))?;
+            }
+            w.write_str("</h3></section>")?;
+
+            write!(w, "{}", document(cx, variant, Some(it), HeadingOffset::H4))?;
+
+            let heading_and_fields = match &variant_data.kind {
+                clean::VariantKind::Struct(s) => {
+                    // If there is no field to display, no need to add the heading.
+                    if s.fields.iter().any(|f| !f.is_doc_hidden()) {
+                        Some(("Fields", &s.fields))
+                    } else {
+                        None
                     }
-                    clean::VariantKind::Struct(ref s) => {
-                        render_struct(w, v, None, None, &s.fields, TAB, false, cx);
+                }
+                clean::VariantKind::Tuple(fields) => {
+                    // Documentation on tuple variant fields is rare, so to reduce noise we only emit
+                    // the section if at least one field is documented.
+                    if fields.iter().any(|f| !f.doc_value().is_empty()) {
+                        Some(("Tuple Fields", fields))
+                    } else {
+                        None
                     }
-                },
-                _ => unreachable!(),
-            }
-            w.push_str(",\n");
-        }
-
-        if variants_stripped && !is_non_exhaustive {
-            w.push_str("    <span class=\"comment\">// some variants omitted</span>\n");
-        }
-        if toggle {
-            toggle_close(&mut w);
-        }
-        w.push_str("}");
-    }
-}
-
-fn item_variants(
-    w: &mut String,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    variants: &IndexVec<VariantIdx, clean::Item>,
-    enum_def_id: DefId,
-) {
-    let tcx = cx.tcx();
-    write_section_heading(
-        w,
-        &format!("Variants{}", document_non_exhaustive_header(it)),
-        "variants",
-        Some("variants"),
-        format!("{}<div class=\"variants\">", document_non_exhaustive(it)),
-    );
-
-    let should_show_enum_discriminant = should_show_enum_discriminant(cx, enum_def_id, variants);
-    for (index, variant) in variants.iter_enumerated() {
-        if variant.is_stripped() {
-            continue;
-        }
-        let id = cx.derive_id(format!("{}.{}", ItemType::Variant, variant.name.unwrap()));
-        write_str(
-            w,
-            format_args!(
-                "<section id=\"{id}\" class=\"variant\">\
-                <a href=\"#{id}\" class=\"anchor\">§</a>"
-            ),
-        );
-        render_stability_since_raw_with_extra(
-            w,
-            variant.stable_since(tcx),
-            variant.const_stability(tcx),
-            " rightside",
-        );
-        w.push_str("<h3 class=\"code-header\">");
-        if let clean::VariantItem(ref var) = variant.kind
-            && let clean::VariantKind::CLike = var.kind
-        {
-            display_c_like_variant(
-                w,
-                cx,
-                variant,
-                var,
-                index,
-                should_show_enum_discriminant,
-                enum_def_id,
-            );
-        } else {
-            w.push_str(variant.name.unwrap().as_str());
-        }
-
-        let clean::VariantItem(variant_data) = &variant.kind else { unreachable!() };
-
-        if let clean::VariantKind::Tuple(ref s) = variant_data.kind {
-            write_str(w, format_args!("({})", print_tuple_struct_fields(cx, s)));
-        }
-        w.push_str("</h3></section>");
-
-        write_str(w, format_args!("{}", document(cx, variant, Some(it), HeadingOffset::H4)));
-
-        let heading_and_fields = match &variant_data.kind {
-            clean::VariantKind::Struct(s) => {
-                // If there is no field to display, no need to add the heading.
-                if s.fields.iter().any(|f| !f.is_doc_hidden()) {
-                    Some(("Fields", &s.fields))
-                } else {
-                    None
                 }
-            }
-            clean::VariantKind::Tuple(fields) => {
-                // Documentation on tuple variant fields is rare, so to reduce noise we only emit
-                // the section if at least one field is documented.
-                if fields.iter().any(|f| !f.doc_value().is_empty()) {
-                    Some(("Tuple Fields", fields))
-                } else {
-                    None
-                }
-            }
-            clean::VariantKind::CLike => None,
-        };
+                clean::VariantKind::CLike => None,
+            };
 
-        if let Some((heading, fields)) = heading_and_fields {
-            let variant_id =
-                cx.derive_id(format!("{}.{}.fields", ItemType::Variant, variant.name.unwrap()));
-            write_str(
-                w,
-                format_args!(
+            if let Some((heading, fields)) = heading_and_fields {
+                let variant_id =
+                    cx.derive_id(format!("{}.{}.fields", ItemType::Variant, variant.name.unwrap()));
+                write!(
+                    w,
                     "<div class=\"sub-variant\" id=\"{variant_id}\">\
                         <h4>{heading}</h4>\
                         {}",
                     document_non_exhaustive(variant)
-                ),
-            );
-            for field in fields {
-                match field.kind {
-                    clean::StrippedItem(box clean::StructFieldItem(_)) => {}
-                    clean::StructFieldItem(ref ty) => {
-                        let id = cx.derive_id(format!(
-                            "variant.{}.field.{}",
-                            variant.name.unwrap(),
-                            field.name.unwrap()
-                        ));
-                        write_str(
-                            w,
-                            format_args!(
+                )?;
+                for field in fields {
+                    match field.kind {
+                        clean::StrippedItem(box clean::StructFieldItem(_)) => {}
+                        clean::StructFieldItem(ref ty) => {
+                            let id = cx.derive_id(format!(
+                                "variant.{}.field.{}",
+                                variant.name.unwrap(),
+                                field.name.unwrap()
+                            ));
+                            write!(
+                                w,
                                 "<div class=\"sub-variant-field\">\
                                     <span id=\"{id}\" class=\"section-header\">\
                                         <a href=\"#{id}\" class=\"anchor field\">§</a>\
                                         <code>{f}: {t}</code>\
-                                    </span>",
+                                    </span>\
+                                    {doc}\
+                                </div>",
                                 f = field.name.unwrap(),
                                 t = ty.print(cx),
-                            ),
-                        );
-                        write_str(
-                            w,
-                            format_args!(
-                                "{}</div>",
-                                document(cx, field, Some(variant), HeadingOffset::H5),
-                            ),
-                        );
+                                doc = document(cx, field, Some(variant), HeadingOffset::H5),
+                            )?;
+                        }
+                        _ => unreachable!(),
                     }
-                    _ => unreachable!(),
                 }
+                w.write_str("</div>")?;
             }
-            w.push_str("</div>");
         }
-    }
-    write_str(w, format_args!("</div>"));
+        w.write_str("</div>")
+    })
 }
 
-fn item_macro(w: &mut String, cx: &Context<'_>, it: &clean::Item, t: &clean::Macro) {
-    wrap_item(w, |w| {
-        // FIXME: Also print `#[doc(hidden)]` for `macro_rules!` if it `is_doc_hidden`.
-        if !t.macro_rules {
-            write_str(w, format_args!("{}", visibility_print_with_space(it, cx)));
-        }
-        write_str(w, format_args!("{}", Escape(&t.source)));
-    });
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
+fn item_macro<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    t: &'a clean::Macro,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        wrap_item(w, |w| {
+            // FIXME: Also print `#[doc(hidden)]` for `macro_rules!` if it `is_doc_hidden`.
+            if !t.macro_rules {
+                write!(w, "{}", visibility_print_with_space(it, cx))?;
+            }
+            write!(w, "{}", Escape(&t.source))
+        })?;
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))
+    })
 }
 
-fn item_proc_macro(
-    w: &mut impl fmt::Write,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    m: &clean::ProcMacro,
-) {
-    wrap_item(w, |buffer| {
-        let name = it.name.expect("proc-macros always have names");
-        match m.kind {
-            MacroKind::Bang => {
-                write!(buffer, "{name}!() {{ <span class=\"comment\">/* proc-macro */</span> }}")
-                    .unwrap();
-            }
-            MacroKind::Attr => {
-                write!(buffer, "#[{name}]").unwrap();
-            }
-            MacroKind::Derive => {
-                write!(buffer, "#[derive({name})]").unwrap();
-                if !m.helpers.is_empty() {
-                    buffer
-                        .write_str(
+fn item_proc_macro<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    m: &'a clean::ProcMacro,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        wrap_item(w, |w| {
+            let name = it.name.expect("proc-macros always have names");
+            match m.kind {
+                MacroKind::Bang => {
+                    write!(w, "{name}!() {{ <span class=\"comment\">/* proc-macro */</span> }}")?;
+                }
+                MacroKind::Attr => {
+                    write!(w, "#[{name}]")?;
+                }
+                MacroKind::Derive => {
+                    write!(w, "#[derive({name})]")?;
+                    if !m.helpers.is_empty() {
+                        w.write_str(
                             "\n{\n    \
-                        <span class=\"comment\">// Attributes available to this derive:</span>\n",
-                        )
-                        .unwrap();
-                    for attr in &m.helpers {
-                        writeln!(buffer, "    #[{attr}]").unwrap();
+                            <span class=\"comment\">// Attributes available to this derive:</span>\n",
+                        )?;
+                        for attr in &m.helpers {
+                            writeln!(w, "    #[{attr}]")?;
+                        }
+                        w.write_str("}\n")?;
                     }
-                    buffer.write_str("}\n").unwrap();
                 }
             }
+            Ok(())
+        })?;
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))
+    })
+}
+
+fn item_primitive<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        let def_id = it.item_id.expect_def_id();
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))?;
+        if it.name.map(|n| n.as_str() != "reference").unwrap_or(false) {
+            write!(w, "{}", render_assoc_items(cx, it, def_id, AssocItemRender::All))?;
+        } else {
+            // We handle the "reference" primitive type on its own because we only want to list
+            // implementations on generic types.
+            let (concrete, synthetic, blanket_impl) =
+                get_filtered_impls_for_reference(&cx.shared, it);
+
+            render_all_impls(w, cx, it, &concrete, &synthetic, &blanket_impl);
         }
-    });
-    write!(w, "{}", document(cx, it, None, HeadingOffset::H2)).unwrap();
+        Ok(())
+    })
 }
 
-fn item_primitive(w: &mut impl fmt::Write, cx: &Context<'_>, it: &clean::Item) {
-    let def_id = it.item_id.expect_def_id();
-    write!(w, "{}", document(cx, it, None, HeadingOffset::H2)).unwrap();
-    if it.name.map(|n| n.as_str() != "reference").unwrap_or(false) {
-        write!(w, "{}", render_assoc_items(cx, it, def_id, AssocItemRender::All)).unwrap();
-    } else {
-        // We handle the "reference" primitive type on its own because we only want to list
-        // implementations on generic types.
-        let (concrete, synthetic, blanket_impl) = get_filtered_impls_for_reference(&cx.shared, it);
+fn item_constant<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    generics: &'a clean::Generics,
+    ty: &'a clean::Type,
+    c: &'a clean::ConstantKind,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        wrap_item(w, |w| {
+            let tcx = cx.tcx();
+            render_attributes_in_code(w, it, cx);
 
-        render_all_impls(w, cx, it, &concrete, &synthetic, &blanket_impl);
-    }
-}
-
-fn item_constant(
-    w: &mut String,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    generics: &clean::Generics,
-    ty: &clean::Type,
-    c: &clean::ConstantKind,
-) {
-    wrap_item(w, |w| {
-        let tcx = cx.tcx();
-        render_attributes_in_code(w, it, cx);
-
-        write_str(
-            w,
-            format_args!(
+            write!(
+                w,
                 "{vis}const {name}{generics}: {typ}{where_clause}",
                 vis = visibility_print_with_space(it, cx),
                 name = it.name.unwrap(),
                 generics = generics.print(cx),
                 typ = ty.print(cx),
-                where_clause = print_where_clause(generics, cx, 0, Ending::NoNewline)
-            ),
-        );
+                where_clause =
+                    print_where_clause(generics, cx, 0, Ending::NoNewline).maybe_display(),
+            )?;
 
-        // FIXME: The code below now prints
-        //            ` = _; // 100i32`
-        //        if the expression is
-        //            `50 + 50`
-        //        which looks just wrong.
-        //        Should we print
-        //            ` = 100i32;`
-        //        instead?
+            // FIXME: The code below now prints
+            //            ` = _; // 100i32`
+            //        if the expression is
+            //            `50 + 50`
+            //        which looks just wrong.
+            //        Should we print
+            //            ` = 100i32;`
+            //        instead?
 
-        let value = c.value(tcx);
-        let is_literal = c.is_literal(tcx);
-        let expr = c.expr(tcx);
-        if value.is_some() || is_literal {
-            write_str(w, format_args!(" = {expr};", expr = Escape(&expr)));
-        } else {
-            w.push_str(";");
-        }
+            let value = c.value(tcx);
+            let is_literal = c.is_literal(tcx);
+            let expr = c.expr(tcx);
+            if value.is_some() || is_literal {
+                write!(w, " = {expr};", expr = Escape(&expr))?;
+            } else {
+                w.write_str(";")?;
+            }
 
-        if !is_literal {
-            if let Some(value) = &value {
-                let value_lowercase = value.to_lowercase();
-                let expr_lowercase = expr.to_lowercase();
+            if !is_literal {
+                if let Some(value) = &value {
+                    let value_lowercase = value.to_lowercase();
+                    let expr_lowercase = expr.to_lowercase();
 
-                if value_lowercase != expr_lowercase
-                    && value_lowercase.trim_end_matches("i32") != expr_lowercase
-                {
-                    write_str(w, format_args!(" // {value}", value = Escape(value)));
+                    if value_lowercase != expr_lowercase
+                        && value_lowercase.trim_end_matches("i32") != expr_lowercase
+                    {
+                        write!(w, " // {value}", value = Escape(value))?;
+                    }
                 }
             }
-        }
-    });
+            Ok(())
+        })?;
 
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))
+    })
 }
 
-fn item_struct(w: &mut String, cx: &Context<'_>, it: &clean::Item, s: &clean::Struct) {
-    wrap_item(w, |w| {
-        render_attributes_in_code(w, it, cx);
-        render_struct(w, it, Some(&s.generics), s.ctor_kind, &s.fields, "", true, cx);
-    });
+fn item_struct<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    s: &'a clean::Struct,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        wrap_item(w, |w| {
+            render_attributes_in_code(w, it, cx);
+            write!(
+                w,
+                "{}",
+                render_struct(it, Some(&s.generics), s.ctor_kind, &s.fields, "", true, cx)
+            )
+        })?;
 
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
+        let def_id = it.item_id.expect_def_id();
 
-    item_fields(w, cx, it, &s.fields, s.ctor_kind);
-
-    let def_id = it.item_id.expect_def_id();
-    write_str(w, format_args!("{}", render_assoc_items(cx, it, def_id, AssocItemRender::All)));
-    write_str(w, format_args!("{}", document_type_layout(cx, def_id)));
+        write!(
+            w,
+            "{}{}{}{}",
+            document(cx, it, None, HeadingOffset::H2),
+            item_fields(cx, it, &s.fields, s.ctor_kind),
+            render_assoc_items(cx, it, def_id, AssocItemRender::All),
+            document_type_layout(cx, def_id),
+        )
+    })
 }
 
-fn item_fields(
-    w: &mut String,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    fields: &[clean::Item],
+fn item_fields<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    fields: &'a [clean::Item],
     ctor_kind: Option<CtorKind>,
-) {
-    let mut fields = fields
-        .iter()
-        .filter_map(|f| match f.kind {
-            clean::StructFieldItem(ref ty) => Some((f, ty)),
-            _ => None,
-        })
-        .peekable();
-    if let None | Some(CtorKind::Fn) = ctor_kind {
-        if fields.peek().is_some() {
-            let title = format!(
-                "{}{}",
-                if ctor_kind.is_none() { "Fields" } else { "Tuple Fields" },
-                document_non_exhaustive_header(it),
-            );
-            write_section_heading(w, &title, "fields", Some("fields"), document_non_exhaustive(it));
-            for (index, (field, ty)) in fields.enumerate() {
-                let field_name =
-                    field.name.map_or_else(|| index.to_string(), |sym| sym.as_str().to_string());
-                let id = cx.derive_id(format!("{typ}.{field_name}", typ = ItemType::StructField));
-                write_str(
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        let mut fields = fields
+            .iter()
+            .filter_map(|f| match f.kind {
+                clean::StructFieldItem(ref ty) => Some((f, ty)),
+                _ => None,
+            })
+            .peekable();
+        if let None | Some(CtorKind::Fn) = ctor_kind {
+            if fields.peek().is_some() {
+                let title = format!(
+                    "{}{}",
+                    if ctor_kind.is_none() { "Fields" } else { "Tuple Fields" },
+                    document_non_exhaustive_header(it),
+                );
+                write!(
                     w,
-                    format_args!(
+                    "{}",
+                    write_section_heading(
+                        &title,
+                        "fields",
+                        Some("fields"),
+                        document_non_exhaustive(it)
+                    )
+                )?;
+                for (index, (field, ty)) in fields.enumerate() {
+                    let field_name = field
+                        .name
+                        .map_or_else(|| index.to_string(), |sym| sym.as_str().to_string());
+                    let id =
+                        cx.derive_id(format!("{typ}.{field_name}", typ = ItemType::StructField));
+                    write!(
+                        w,
                         "<span id=\"{id}\" class=\"{item_type} section-header\">\
                             <a href=\"#{id}\" class=\"anchor field\">§</a>\
                             <code>{field_name}: {ty}</code>\
-                        </span>",
+                        </span>\
+                        {doc}",
                         item_type = ItemType::StructField,
-                        ty = ty.print(cx)
-                    ),
-                );
-                write_str(w, format_args!("{}", document(cx, field, Some(it), HeadingOffset::H3)));
+                        ty = ty.print(cx),
+                        doc = document(cx, field, Some(it), HeadingOffset::H3),
+                    )?;
+                }
             }
         }
-    }
+        Ok(())
+    })
 }
 
-fn item_static(
-    w: &mut impl fmt::Write,
-    cx: &Context<'_>,
-    it: &clean::Item,
-    s: &clean::Static,
+fn item_static<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+    s: &'a clean::Static,
     safety: Option<hir::Safety>,
-) {
-    wrap_item(w, |buffer| {
-        render_attributes_in_code(buffer, it, cx);
-        write!(
-            buffer,
-            "{vis}{safe}static {mutability}{name}: {typ}",
-            vis = visibility_print_with_space(it, cx),
-            safe = safety.map(|safe| safe.prefix_str()).unwrap_or(""),
-            mutability = s.mutability.print_with_space(),
-            name = it.name.unwrap(),
-            typ = s.type_.print(cx)
-        )
-        .unwrap();
-    });
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        wrap_item(w, |w| {
+            render_attributes_in_code(w, it, cx);
+            write!(
+                w,
+                "{vis}{safe}static {mutability}{name}: {typ}",
+                vis = visibility_print_with_space(it, cx),
+                safe = safety.map(|safe| safe.prefix_str()).unwrap_or(""),
+                mutability = s.mutability.print_with_space(),
+                name = it.name.unwrap(),
+                typ = s.type_.print(cx)
+            )
+        })?;
 
-    write!(w, "{}", document(cx, it, None, HeadingOffset::H2)).unwrap();
+        write!(w, "{}", document(cx, it, None, HeadingOffset::H2))
+    })
 }
 
-fn item_foreign_type(w: &mut impl fmt::Write, cx: &Context<'_>, it: &clean::Item) {
-    wrap_item(w, |buffer| {
-        buffer.write_str("extern {\n").unwrap();
-        render_attributes_in_code(buffer, it, cx);
-        write!(
-            buffer,
-            "    {}type {};\n}}",
-            visibility_print_with_space(it, cx),
-            it.name.unwrap(),
-        )
-        .unwrap();
-    });
+fn item_foreign_type<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(|w| {
+        wrap_item(w, |w| {
+            w.write_str("extern {\n")?;
+            render_attributes_in_code(w, it, cx);
+            write!(w, "    {}type {};\n}}", visibility_print_with_space(it, cx), it.name.unwrap(),)
+        })?;
 
-    write!(w, "{}", document(cx, it, None, HeadingOffset::H2)).unwrap();
-    write!(w, "{}", render_assoc_items(cx, it, it.item_id.expect_def_id(), AssocItemRender::All))
-        .unwrap();
+        write!(
+            w,
+            "{}{}",
+            document(cx, it, None, HeadingOffset::H2),
+            render_assoc_items(cx, it, it.item_id.expect_def_id(), AssocItemRender::All)
+        )
+    })
 }
 
-fn item_keyword(w: &mut String, cx: &Context<'_>, it: &clean::Item) {
-    write_str(w, format_args!("{}", document(cx, it, None, HeadingOffset::H2)));
+fn item_keyword<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    it: &'a clean::Item,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    document(cx, it, None, HeadingOffset::H2)
 }
 
 /// Compare two strings treating multi-digit numbers as single units (i.e. natural sort order).
@@ -2140,14 +2297,15 @@ fn bounds<'a, 'tcx>(
         .maybe_display()
 }
 
-fn wrap_item<W, F>(w: &mut W, f: F)
+fn wrap_item<W, F, T>(w: &mut W, f: F) -> T
 where
     W: fmt::Write,
-    F: FnOnce(&mut W),
+    F: FnOnce(&mut W) -> T,
 {
     write!(w, r#"<pre class="rust item-decl"><code>"#).unwrap();
-    f(w);
+    let res = f(w);
     write!(w, "</code></pre>").unwrap();
+    res
 }
 
 #[derive(PartialEq, Eq)]
@@ -2171,14 +2329,13 @@ impl Ord for ImplString {
     }
 }
 
-fn render_implementor(
-    cx: &Context<'_>,
-    implementor: &Impl,
-    trait_: &clean::Item,
-    w: &mut String,
-    implementor_dups: &FxHashMap<Symbol, (DefId, bool)>,
-    aliases: &[String],
-) {
+fn render_implementor<'a, 'tcx>(
+    cx: &'a Context<'tcx>,
+    implementor: &'a Impl,
+    trait_: &'a clean::Item,
+    implementor_dups: &'a FxHashMap<Symbol, (DefId, bool)>,
+    aliases: &'a [String],
+) -> impl fmt::Display + 'a + Captures<'tcx> {
     // If there's already another implementor that has the same abridged name, use the
     // full path, for example in `std::iter::ExactSizeIterator`
     let use_absolute = match implementor.inner_impl().for_ {
@@ -2191,7 +2348,6 @@ fn render_implementor(
         _ => false,
     };
     render_impl(
-        w,
         cx,
         implementor,
         trait_,
@@ -2205,7 +2361,7 @@ fn render_implementor(
             show_non_assoc_items: false,
             toggle_open_by_default: false,
         },
-    );
+    )
 }
 
 fn render_union<'a, 'cx: 'a>(
@@ -2217,14 +2373,17 @@ fn render_union<'a, 'cx: 'a>(
     fmt::from_fn(move |mut f| {
         write!(f, "{}union {}", visibility_print_with_space(it, cx), it.name.unwrap(),)?;
 
-        let where_displayed = g
-            .map(|g| {
-                let mut buf = g.print(cx).to_string();
-                let where_displayed = print_where_clause_and_check(&mut buf, g, cx);
-                f.write_str(&buf).unwrap();
-                where_displayed
-            })
-            .unwrap_or(false);
+        let where_displayed = if let Some(generics) = g {
+            write!(f, "{}", generics.print(cx))?;
+            if let Some(where_clause) = print_where_clause(generics, cx, 0, Ending::Newline) {
+                write!(f, "{where_clause}")?;
+                true
+            } else {
+                false
+            }
+        } else {
+            false
+        };
 
         // If there wasn't a `where` clause, we add a whitespace.
         if !where_displayed {
@@ -2262,148 +2421,160 @@ fn render_union<'a, 'cx: 'a>(
     })
 }
 
-fn render_struct(
-    w: &mut String,
-    it: &clean::Item,
-    g: Option<&clean::Generics>,
+fn render_struct<'a, 'tcx>(
+    it: &'a clean::Item,
+    g: Option<&'a clean::Generics>,
     ty: Option<CtorKind>,
-    fields: &[clean::Item],
-    tab: &str,
+    fields: &'a [clean::Item],
+    tab: &'a str,
     structhead: bool,
-    cx: &Context<'_>,
-) {
-    write_str(
-        w,
-        format_args!(
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        write!(
+            w,
             "{}{}{}",
             visibility_print_with_space(it, cx),
             if structhead { "struct " } else { "" },
             it.name.unwrap()
-        ),
-    );
-    if let Some(g) = g {
-        write_str(w, format_args!("{}", g.print(cx)));
-    }
-    render_struct_fields(
-        w,
-        g,
-        ty,
-        fields,
-        tab,
-        structhead,
-        it.has_stripped_entries().unwrap_or(false),
-        cx,
-    )
+        )?;
+        if let Some(g) = g {
+            write!(w, "{}", g.print(cx))?;
+        }
+        write!(
+            w,
+            "{}",
+            render_struct_fields(
+                g,
+                ty,
+                fields,
+                tab,
+                structhead,
+                it.has_stripped_entries().unwrap_or(false),
+                cx,
+            )
+        )
+    })
 }
 
-fn render_struct_fields(
-    mut w: &mut String,
-    g: Option<&clean::Generics>,
+fn render_struct_fields<'a, 'tcx>(
+    g: Option<&'a clean::Generics>,
     ty: Option<CtorKind>,
-    fields: &[clean::Item],
-    tab: &str,
+    fields: &'a [clean::Item],
+    tab: &'a str,
     structhead: bool,
     has_stripped_entries: bool,
-    cx: &Context<'_>,
-) {
-    match ty {
-        None => {
-            let where_displayed =
-                g.map(|g| print_where_clause_and_check(w, g, cx)).unwrap_or(false);
+    cx: &'a Context<'tcx>,
+) -> impl fmt::Display + 'a + Captures<'tcx> {
+    fmt::from_fn(move |w| {
+        match ty {
+            None => {
+                let where_displayed = if let Some(generics) = g
+                    && let Some(where_clause) = print_where_clause(generics, cx, 0, Ending::Newline)
+                {
+                    write!(w, "{where_clause}")?;
+                    true
+                } else {
+                    false
+                };
 
-            // If there wasn't a `where` clause, we add a whitespace.
-            if !where_displayed {
-                w.push_str(" {");
-            } else {
-                w.push_str("{");
-            }
-            let count_fields =
-                fields.iter().filter(|f| matches!(f.kind, clean::StructFieldItem(..))).count();
-            let has_visible_fields = count_fields > 0;
-            let toggle = should_hide_fields(count_fields);
-            if toggle {
-                toggle_open(&mut w, format_args!("{count_fields} fields"));
-            }
-            for field in fields {
-                if let clean::StructFieldItem(ref ty) = field.kind {
-                    write_str(
-                        w,
-                        format_args!(
+                // If there wasn't a `where` clause, we add a whitespace.
+                if !where_displayed {
+                    w.write_str(" {")?;
+                } else {
+                    w.write_str("{")?;
+                }
+                let count_fields =
+                    fields.iter().filter(|f| matches!(f.kind, clean::StructFieldItem(..))).count();
+                let has_visible_fields = count_fields > 0;
+                let toggle = should_hide_fields(count_fields);
+                if toggle {
+                    toggle_open(&mut *w, format_args!("{count_fields} fields"));
+                }
+                for field in fields {
+                    if let clean::StructFieldItem(ref ty) = field.kind {
+                        write!(
+                            w,
                             "\n{tab}    {vis}{name}: {ty},",
                             vis = visibility_print_with_space(field, cx),
                             name = field.name.unwrap(),
                             ty = ty.print(cx)
-                        ),
-                    );
-                }
-            }
-
-            if has_visible_fields {
-                if has_stripped_entries {
-                    write_str(
-                        w,
-                        format_args!(
-                            "\n{tab}    <span class=\"comment\">/* private fields */</span>"
-                        ),
-                    );
-                }
-                write_str(w, format_args!("\n{tab}"));
-            } else if has_stripped_entries {
-                write_str(w, format_args!(" <span class=\"comment\">/* private fields */</span> "));
-            }
-            if toggle {
-                toggle_close(&mut w);
-            }
-            w.push_str("}");
-        }
-        Some(CtorKind::Fn) => {
-            w.push_str("(");
-            if !fields.is_empty()
-                && fields.iter().all(|field| {
-                    matches!(field.kind, clean::StrippedItem(box clean::StructFieldItem(..)))
-                })
-            {
-                write_str(w, format_args!("<span class=\"comment\">/* private fields */</span>"));
-            } else {
-                for (i, field) in fields.iter().enumerate() {
-                    if i > 0 {
-                        w.push_str(", ");
+                        )?;
                     }
-                    match field.kind {
-                        clean::StrippedItem(box clean::StructFieldItem(..)) => {
-                            write_str(w, format_args!("_"));
+                }
+
+                if has_visible_fields {
+                    if has_stripped_entries {
+                        write!(
+                            w,
+                            "\n{tab}    <span class=\"comment\">/* private fields */</span>"
+                        )?;
+                    }
+                    write!(w, "\n{tab}")?;
+                } else if has_stripped_entries {
+                    write!(w, " <span class=\"comment\">/* private fields */</span> ")?;
+                }
+                if toggle {
+                    toggle_close(&mut *w);
+                }
+                w.write_str("}")?;
+            }
+            Some(CtorKind::Fn) => {
+                w.write_str("(")?;
+                if !fields.is_empty()
+                    && fields.iter().all(|field| {
+                        matches!(field.kind, clean::StrippedItem(box clean::StructFieldItem(..)))
+                    })
+                {
+                    write!(w, "<span class=\"comment\">/* private fields */</span>")?;
+                } else {
+                    for (i, field) in fields.iter().enumerate() {
+                        if i > 0 {
+                            w.write_str(", ")?;
                         }
-                        clean::StructFieldItem(ref ty) => {
-                            write_str(
-                                w,
-                                format_args!(
+                        match field.kind {
+                            clean::StrippedItem(box clean::StructFieldItem(..)) => {
+                                write!(w, "_")?;
+                            }
+                            clean::StructFieldItem(ref ty) => {
+                                write!(
+                                    w,
                                     "{}{}",
                                     visibility_print_with_space(field, cx),
                                     ty.print(cx)
-                                ),
-                            );
+                                )?;
+                            }
+                            _ => unreachable!(),
                         }
-                        _ => unreachable!(),
                     }
                 }
+                w.write_str(")")?;
+                if let Some(g) = g {
+                    write!(
+                        w,
+                        "{}",
+                        print_where_clause(g, cx, 0, Ending::NoNewline).maybe_display()
+                    )?;
+                }
+                // We only want a ";" when we are displaying a tuple struct, not a variant tuple struct.
+                if structhead {
+                    w.write_str(";")?;
+                }
             }
-            w.push_str(")");
-            if let Some(g) = g {
-                write_str(w, format_args!("{}", print_where_clause(g, cx, 0, Ending::NoNewline)));
-            }
-            // We only want a ";" when we are displaying a tuple struct, not a variant tuple struct.
-            if structhead {
-                w.push_str(";");
+            Some(CtorKind::Const) => {
+                // Needed for PhantomData.
+                if let Some(g) = g {
+                    write!(
+                        w,
+                        "{}",
+                        print_where_clause(g, cx, 0, Ending::NoNewline).maybe_display()
+                    )?;
+                }
+                w.write_str(";")?;
             }
         }
-        Some(CtorKind::Const) => {
-            // Needed for PhantomData.
-            if let Some(g) = g {
-                write_str(w, format_args!("{}", print_where_clause(g, cx, 0, Ending::NoNewline)));
-            }
-            w.push_str(";");
-        }
-    }
+        Ok(())
+    })
 }
 
 fn document_non_exhaustive_header(item: &clean::Item) -> &str {
diff --git a/src/librustdoc/html/render/write_shared.rs b/src/librustdoc/html/render/write_shared.rs
index a4dec013fc04..0185d0c3bb54 100644
--- a/src/librustdoc/html/render/write_shared.rs
+++ b/src/librustdoc/html/render/write_shared.rs
@@ -636,26 +636,22 @@ impl TypeAliasPart {
                         } else {
                             AssocItemLink::Anchor(None)
                         };
-                        let text = {
-                            let mut buf = String::new();
-                            super::render_impl(
-                                &mut buf,
-                                cx,
-                                impl_,
-                                type_alias_item,
-                                assoc_link,
-                                RenderMode::Normal,
-                                None,
-                                &[],
-                                ImplRenderingParameters {
-                                    show_def_docs: true,
-                                    show_default_items: true,
-                                    show_non_assoc_items: true,
-                                    toggle_open_by_default: true,
-                                },
-                            );
-                            buf
-                        };
+                        let text = super::render_impl(
+                            cx,
+                            impl_,
+                            type_alias_item,
+                            assoc_link,
+                            RenderMode::Normal,
+                            None,
+                            &[],
+                            ImplRenderingParameters {
+                                show_def_docs: true,
+                                show_default_items: true,
+                                show_non_assoc_items: true,
+                                toggle_open_by_default: true,
+                            },
+                        )
+                        .to_string();
                         let type_alias_fqp = (*type_alias_fqp).iter().join("::");
                         if Some(&text) == ret.last().map(|s: &AliasSerializableImpl| &s.text) {
                             ret.last_mut()
diff --git a/src/librustdoc/html/static/COPYRIGHT.txt b/src/librustdoc/html/static/COPYRIGHT.txt
index 111340298c5e..752dab0a3478 100644
--- a/src/librustdoc/html/static/COPYRIGHT.txt
+++ b/src/librustdoc/html/static/COPYRIGHT.txt
@@ -45,6 +45,27 @@ included, and carry their own copyright notices and license terms:
     Licensed under the SIL Open Font License, Version 1.1.
     See SourceSerif4-LICENSE.md.
 
+* Nanum Barun Gothic Font (NanumBarunGothic.woff2)
+
+    Copyright 2010, NAVER Corporation (http://www.nhncorp.com)
+    with Reserved Font Name Nanum, Naver Nanum, NanumGothic, Naver NanumGothic,
+    NanumMyeongjo, Naver NanumMyeongjo, NanumBrush, Naver NanumBrush, NanumPen,
+    Naver NanumPen, Naver NanumGothicEco, NanumGothicEco,
+    Naver NanumMyeongjoEco, NanumMyeongjoEco, Naver NanumGothicLight,
+    NanumGothicLight, NanumBarunGothic, Naver NanumBarunGothic.
+
+    https://hangeul.naver.com/2017/nanum
+    https://github.com/hiun/NanumBarunGothic
+
+    Licensed under the SIL Open Font License, Version 1.1.
+    See NanumBarunGothic-LICENSE.txt.
+
+* Rust logos (rust-logo.svg, favicon.svg, favicon-32x32.png)
+
+    Copyright 2025 Rust Foundation.
+    Licensed under the Creative Commons Attribution license (CC-BY).
+    https://rustfoundation.org/policy/rust-trademark-policy/
+
 This copyright file is intended to be distributed with rustdoc output.
 
 # REUSE-IgnoreEnd
diff --git a/src/librustdoc/html/static/css/rustdoc.css b/src/librustdoc/html/static/css/rustdoc.css
index 4f5f8f92264c..0ea4d8f1e391 100644
--- a/src/librustdoc/html/static/css/rustdoc.css
+++ b/src/librustdoc/html/static/css/rustdoc.css
@@ -41,6 +41,7 @@ xmlns="http://www.w3.org/2000/svg" fill="black" height="18px">\
 	--font-family: "Source Serif 4", NanumBarunGothic, serif;
 	--font-family-code: "Source Code Pro", monospace;
 	--line-number-padding: 4px;
+	--line-number-right-margin: 20px;
 	/* scraped examples icons (34x33px) */
 	--prev-arrow-image: url('data:image/svg+xml,<svg width="16" height="16" viewBox="0 0 16 16" \
 	enable-background="new 0 0 16 16" xmlns="http://www.w3.org/2000/svg"><path fill="none" \
@@ -848,22 +849,6 @@ ul.block, .block li, .block ul {
 	border-radius: 6px;
 }
 
-/*
-If the code example line numbers are displayed, there will be a weird radius in the middle from
-both the code example and the line numbers, so we need to remove the radius in this case.
-*/
-.rustdoc .example-wrap > .example-line-numbers,
-.rustdoc .scraped-example .src-line-numbers,
-.rustdoc .scraped-example .src-line-numbers > pre {
-	border-top-right-radius: 0;
-	border-bottom-right-radius: 0;
-}
-.rustdoc .example-wrap > .example-line-numbers + pre,
-.rustdoc .scraped-example .rust {
-	border-top-left-radius: 0;
-	border-bottom-left-radius: 0;
-}
-
 .rustdoc .scraped-example {
 	position: relative;
 }
@@ -908,45 +893,31 @@ both the code example and the line numbers, so we need to remove the radius in t
 	overflow: auto;
 }
 
-.rustdoc .example-wrap pre.example-line-numbers,
-.rustdoc .example-wrap .src-line-numbers {
-	min-width: fit-content; /* prevent collapsing into nothing in truncated scraped examples */
-	flex-grow: 0;
-	text-align: right;
-	-moz-user-select: none;
-	-webkit-user-select: none;
-	-ms-user-select: none;
-	user-select: none;
-	padding: 14px 8px;
-	padding-right: 2px;
-	color: var(--src-line-numbers-span-color);
-}
-
-.example-wrap.digits-1 [data-nosnippet] {
+.example-wrap.digits-1:not(.hide-lines) [data-nosnippet] {
 	width: calc(1ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-2 [data-nosnippet] {
+.example-wrap.digits-2:not(.hide-lines) [data-nosnippet] {
 	width: calc(2ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-3 [data-nosnippet] {
+.example-wrap.digits-3:not(.hide-lines) [data-nosnippet] {
 	width: calc(3ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-4 [data-nosnippet] {
+.example-wrap.digits-4:not(.hide-lines) [data-nosnippet] {
 	width: calc(4ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-5 [data-nosnippet] {
+.example-wrap.digits-5:not(.hide-lines) [data-nosnippet] {
 	width: calc(5ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-6 [data-nosnippet] {
+.example-wrap.digits-6:not(.hide-lines) [data-nosnippet] {
 	width: calc(6ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-7 [data-nosnippet] {
+.example-wrap.digits-7:not(.hide-lines) [data-nosnippet] {
 	width: calc(7ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-8 [data-nosnippet] {
+.example-wrap.digits-8:not(.hide-lines) [data-nosnippet] {
 	width: calc(8ch + var(--line-number-padding) * 2);
 }
-.example-wrap.digits-9 [data-nosnippet] {
+.example-wrap.digits-9:not(.hide-lines) [data-nosnippet] {
 	width: calc(9ch + var(--line-number-padding) * 2);
 }
 
@@ -954,12 +925,12 @@ both the code example and the line numbers, so we need to remove the radius in t
 	color: var(--src-line-numbers-span-color);
 	text-align: right;
 	display: inline-block;
-	margin-right: 20px;
+	margin-right: var(--line-number-right-margin);
 	-moz-user-select: none;
 	-webkit-user-select: none;
 	-ms-user-select: none;
 	user-select: none;
-	padding: 0 4px;
+	padding: 0 var(--line-number-padding);
 }
 .example-wrap [data-nosnippet]:target {
 	border-right: none;
@@ -967,6 +938,60 @@ both the code example and the line numbers, so we need to remove the radius in t
 .example-wrap .line-highlighted[data-nosnippet] {
 	background-color: var(--src-line-number-highlighted-background-color);
 }
+:root.word-wrap-source-code .example-wrap [data-nosnippet] {
+	position: absolute;
+	left: 0;
+}
+.word-wrap-source-code .example-wrap pre > code {
+	position: relative;
+	word-break: break-all;
+}
+:root.word-wrap-source-code .example-wrap pre > code {
+	display: block;
+	white-space: pre-wrap;
+}
+:root.word-wrap-source-code .example-wrap pre > code * {
+	word-break: break-all;
+}
+:root.word-wrap-source-code .example-wrap.digits-1 pre > code {
+	padding-left: calc(
+		1ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-2 pre > code {
+	padding-left: calc(
+		2ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-3 pre > code {
+	padding-left: calc(
+		3ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-4 pre > code {
+	padding-left: calc(
+		4ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-5 pre > code {
+	padding-left: calc(
+		5ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-6 pre > code {
+	padding-left: calc(
+		6ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-7 pre > code {
+	padding-left: calc(
+		7ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-8 pre > code {
+	padding-left: calc(
+		8ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+:root.word-wrap-source-code .example-wrap.digits-9 pre > code {
+	padding-left: calc(
+		9ch + var(--line-number-padding) * 2 + var(--line-number-right-margin));
+}
+.example-wrap.hide-lines [data-nosnippet] {
+	display: none;
+}
 
 .search-loading {
 	text-align: center;
diff --git a/src/librustdoc/html/static/js/main.js b/src/librustdoc/html/static/js/main.js
index e46cc1897e9e..edfcc1291b97 100644
--- a/src/librustdoc/html/static/js/main.js
+++ b/src/librustdoc/html/static/js/main.js
@@ -1112,35 +1112,32 @@ function preLoadCss(cssUrl) {
 
     // @ts-expect-error
     window.rustdoc_add_line_numbers_to_examples = () => {
-        if (document.querySelector(".rustdoc.src")) {
-            // We are in the source code page, nothing to be done here!
-            return;
+        // @ts-expect-error
+        function generateLine(nb) {
+            return `<span data-nosnippet>${nb}</span>`;
         }
+
         onEachLazy(document.querySelectorAll(
-            ":not(.scraped-example) > .example-wrap > pre:not(.example-line-numbers)",
-        ), x => {
-            const parent = x.parentNode;
-            const line_numbers = parent.querySelectorAll(".example-line-numbers");
-            if (line_numbers.length > 0) {
+            ".rustdoc:not(.src) :not(.scraped-example) > .example-wrap > pre > code",
+        ), code => {
+            if (hasClass(code.parentElement.parentElement, "hide-lines")) {
+                removeClass(code.parentElement.parentElement, "hide-lines");
                 return;
             }
-            const count = x.textContent.split("\n").length;
-            const elems = [];
-            for (let i = 0; i < count; ++i) {
-                elems.push(i + 1);
-            }
-            const node = document.createElement("pre");
-            addClass(node, "example-line-numbers");
-            node.innerHTML = elems.join("\n");
-            parent.insertBefore(node, x);
+            const lines = code.innerHTML.split("\n");
+            const digits = (lines.length + "").length;
+            // @ts-expect-error
+            code.innerHTML = lines.map((line, index) => generateLine(index + 1) + line).join("\n");
+            addClass(code.parentElement.parentElement, `digits-${digits}`);
         });
     };
 
     // @ts-expect-error
     window.rustdoc_remove_line_numbers_from_examples = () => {
-        onEachLazy(document.querySelectorAll(".example-wrap > .example-line-numbers"), x => {
-            x.parentNode.removeChild(x);
-        });
+        onEachLazy(
+            document.querySelectorAll(".rustdoc:not(.src) :not(.scraped-example) > .example-wrap"),
+            x => addClass(x, "hide-lines"),
+        );
     };
 
     if (getSettingValue("line-numbers") === "true") {
diff --git a/src/librustdoc/html/static/js/settings.js b/src/librustdoc/html/static/js/settings.js
index bf33e0f17e5f..5f1bbd27328c 100644
--- a/src/librustdoc/html/static/js/settings.js
+++ b/src/librustdoc/html/static/js/settings.js
@@ -59,6 +59,14 @@
                 } else {
                     removeClass(document.documentElement, "sans-serif");
                 }
+                break;
+            case "word-wrap-source-code":
+                if (value === true) {
+                    addClass(document.documentElement, "word-wrap-source-code");
+                } else {
+                    removeClass(document.documentElement, "word-wrap-source-code");
+                }
+                break;
         }
     }
 
@@ -246,6 +254,11 @@
                 "js_name": "sans-serif-fonts",
                 "default": false,
             },
+            {
+                "name": "Word wrap source code",
+                "js_name": "word-wrap-source-code",
+                "default": false,
+            },
         ];
 
         // Then we build the DOM.
diff --git a/src/librustdoc/html/static/js/storage.js b/src/librustdoc/html/static/js/storage.js
index 3042373fb096..425b915b5f94 100644
--- a/src/librustdoc/html/static/js/storage.js
+++ b/src/librustdoc/html/static/js/storage.js
@@ -286,6 +286,9 @@ if (getSettingValue("hide-modnav") === "true") {
 if (getSettingValue("sans-serif-fonts") === "true") {
     addClass(document.documentElement, "sans-serif");
 }
+if (getSettingValue("word-wrap-source-code") === "true") {
+    addClass(document.documentElement, "word-wrap-source-code");
+}
 function updateSidebarWidth() {
     const desktopSidebarWidth = getSettingValue("desktop-sidebar-width");
     if (desktopSidebarWidth && desktopSidebarWidth !== "null") {
diff --git a/src/librustdoc/passes/propagate_stability.rs b/src/librustdoc/passes/propagate_stability.rs
index 9c958710c420..8cf39afd55c5 100644
--- a/src/librustdoc/passes/propagate_stability.rs
+++ b/src/librustdoc/passes/propagate_stability.rs
@@ -39,6 +39,16 @@ impl DocFolder for StabilityPropagator<'_, '_> {
                 let item_stability = self.cx.tcx.lookup_stability(def_id);
                 let inline_stability =
                     item.inline_stmt_id.and_then(|did| self.cx.tcx.lookup_stability(did));
+                let is_glob_export = item.inline_stmt_id.and_then(|id| {
+                    let hir_id = self.cx.tcx.local_def_id_to_hir_id(id);
+                    Some(matches!(
+                        self.cx.tcx.hir_node(hir_id),
+                        rustc_hir::Node::Item(rustc_hir::Item {
+                            kind: rustc_hir::ItemKind::Use(_, rustc_hir::UseKind::Glob),
+                            ..
+                        })
+                    ))
+                });
                 let own_stability = if let Some(item_stab) = item_stability
                     && let StabilityLevel::Stable { since: _, allowed_through_unstable_modules } =
                         item_stab.level
@@ -47,6 +57,8 @@ impl DocFolder for StabilityPropagator<'_, '_> {
                         since: inline_since,
                         allowed_through_unstable_modules: _,
                     } = inline_stab.level
+                    && let Some(is_global_export) = is_glob_export
+                    && !is_global_export
                 {
                     inline_stab.level = StabilityLevel::Stable {
                         since: inline_since,
diff --git a/src/llvm-project b/src/llvm-project
index 92e80685d0d5..1c3bb96fdb6d 160000
--- a/src/llvm-project
+++ b/src/llvm-project
@@ -1 +1 @@
-Subproject commit 92e80685d0d5dcea3ccf321995c43b72338639c6
+Subproject commit 1c3bb96fdb6db7b8e8f24edb016099c223fdd27e
diff --git a/src/rustdoc-json-types/lib.rs b/src/rustdoc-json-types/lib.rs
index a92f3ded7746..8f6496e9626c 100644
--- a/src/rustdoc-json-types/lib.rs
+++ b/src/rustdoc-json-types/lib.rs
@@ -30,7 +30,7 @@ pub type FxHashMap<K, V> = HashMap<K, V>; // re-export for use in src/librustdoc
 /// This integer is incremented with every breaking change to the API,
 /// and is returned along with the JSON blob as [`Crate::format_version`].
 /// Consuming code should assert that this value matches the format version(s) that it supports.
-pub const FORMAT_VERSION: u32 = 39;
+pub const FORMAT_VERSION: u32 = 40;
 
 /// The root of the emitted JSON blob.
 ///
@@ -120,7 +120,9 @@ pub struct Item {
     pub docs: Option<String>,
     /// This mapping resolves [intra-doc links](https://github.com/rust-lang/rfcs/blob/master/text/1946-intra-rustdoc-links.md) from the docstring to their IDs
     pub links: HashMap<String, Id>,
-    /// Stringified versions of the attributes on this item (e.g. `"#[inline]"`)
+    /// Stringified versions of parsed attributes on this item.
+    /// Essentially debug printed (e.g. `#[inline]` becomes something similar to `#[attr="Inline(Hint)"]`).
+    /// Equivalent to the hir pretty-printing of attributes.
     pub attrs: Vec<String>,
     /// Information about the item’s deprecation, if present.
     pub deprecation: Option<Deprecation>,
diff --git a/src/tools/cargo b/src/tools/cargo
index 1d1d646c06a8..2622e844bc1e 160000
--- a/src/tools/cargo
+++ b/src/tools/cargo
@@ -1 +1 @@
-Subproject commit 1d1d646c06a84c1aa53967b394b7f1218f85db82
+Subproject commit 2622e844bc1e2e6123e54e94e4706f7b6195ce3d
diff --git a/src/tools/clippy/CHANGELOG.md b/src/tools/clippy/CHANGELOG.md
index fa03c953aa59..51441ab9fc0d 100644
--- a/src/tools/clippy/CHANGELOG.md
+++ b/src/tools/clippy/CHANGELOG.md
@@ -6,11 +6,53 @@ document.
 
 ## Unreleased / Beta / In Rust Nightly
 
-[786fbd6d...master](https://github.com/rust-lang/rust-clippy/compare/786fbd6d...master)
+[609cd310...master](https://github.com/rust-lang/rust-clippy/compare/609cd310...master)
+
+## Rust 1.85
+
+Current stable, released 2025-02-20
+
+[View all 72 merged pull requests](https://github.com/rust-lang/rust-clippy/pulls?q=merged%3A2024-11-15T19%3A31%3A08Z..2024-12-26T13%3A59%3A48Z+base%3Amaster)
+
+### New Lints
+
+* Added [`repr_packed_without_abi`] to `suspicious`
+  [#13398](https://github.com/rust-lang/rust-clippy/pull/13398)
+* Added [`as_pointer_underscore`] to `restriction`
+  [#13251](https://github.com/rust-lang/rust-clippy/pull/13251)
+* Added [`doc_nested_refdefs`] to `suspicious`
+  [#13707](https://github.com/rust-lang/rust-clippy/pull/13707)
+* Added [`literal_string_with_formatting_args`] to `nursery`
+  [#13410](https://github.com/rust-lang/rust-clippy/pull/13410)
+* Added [`doc_include_without_cfg`] to `restriction`
+  [#13625](https://github.com/rust-lang/rust-clippy/pull/13625)
+
+### Enhancements
+
+* [`indexing_slicing`]: Can now be allowed in tests using the [`allow-indexing-slicing-in-tests`]
+  configuration
+  [#13854](https://github.com/rust-lang/rust-clippy/pull/13854)
+* [`if_let_mutex`]: disable lint from Edition 2024 since
+  [if_let_rescope](https://github.com/rust-lang/rust/issues/131154) was stabilized
+  [#13695](https://github.com/rust-lang/rust-clippy/pull/13695)
+* [`format_in_format_args`], [`recursive_format_impl`], [`to_string_in_format_args`],
+  [`uninlined_format_args`], [`unused_format_specs`]: Can now support 3rd party format macros
+  if they're marked with the `#[clippy::format_args]` attribute
+  [#9948](https://github.com/rust-lang/rust-clippy/pull/9948)
+
+### ICE Fixes
+
+* [`trait_duplication_in_bounds`]: fix ICE on duplicate type or constant bound
+  [#13722](https://github.com/rust-lang/rust-clippy/pull/13722)
+
+### Others
+
+* `clippy_utils` is now published to crates.io. Note that this crate is and will remain unstable.
+  [#13700](https://github.com/rust-lang/rust-clippy/pull/13700)
 
 ## Rust 1.84
 
-Current stable, released 2025-01-09
+Released 2025-01-09
 
 [View all 84 merged pull requests](https://github.com/rust-lang/rust-clippy/pulls?q=merged%3A2024-10-03T21%3A23%3A58Z..2024-11-14T17%3A41%3A37Z+base%3Amaster)
 
@@ -5530,6 +5572,7 @@ Released 2018-09-13
 [`diverging_sub_expression`]: https://rust-lang.github.io/rust-clippy/master/index.html#diverging_sub_expression
 [`doc_include_without_cfg`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_include_without_cfg
 [`doc_lazy_continuation`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_lazy_continuation
+[`doc_link_code`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_link_code
 [`doc_link_with_quotes`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_link_with_quotes
 [`doc_markdown`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_markdown
 [`doc_nested_refdefs`]: https://rust-lang.github.io/rust-clippy/master/index.html#doc_nested_refdefs
@@ -5549,6 +5592,7 @@ Released 2018-09-13
 [`duplicated_attributes`]: https://rust-lang.github.io/rust-clippy/master/index.html#duplicated_attributes
 [`duration_subsec`]: https://rust-lang.github.io/rust-clippy/master/index.html#duration_subsec
 [`eager_transmute`]: https://rust-lang.github.io/rust-clippy/master/index.html#eager_transmute
+[`elidable_lifetime_names`]: https://rust-lang.github.io/rust-clippy/master/index.html#elidable_lifetime_names
 [`else_if_without_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#else_if_without_else
 [`empty_docs`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_docs
 [`empty_drop`]: https://rust-lang.github.io/rust-clippy/master/index.html#empty_drop
@@ -5683,6 +5727,7 @@ Released 2018-09-13
 [`invalid_utf8_in_unchecked`]: https://rust-lang.github.io/rust-clippy/master/index.html#invalid_utf8_in_unchecked
 [`inverted_saturating_sub`]: https://rust-lang.github.io/rust-clippy/master/index.html#inverted_saturating_sub
 [`invisible_characters`]: https://rust-lang.github.io/rust-clippy/master/index.html#invisible_characters
+[`io_other_error`]: https://rust-lang.github.io/rust-clippy/master/index.html#io_other_error
 [`is_digit_ascii_radix`]: https://rust-lang.github.io/rust-clippy/master/index.html#is_digit_ascii_radix
 [`items_after_statements`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_statements
 [`items_after_test_module`]: https://rust-lang.github.io/rust-clippy/master/index.html#items_after_test_module
@@ -5742,6 +5787,7 @@ Released 2018-09-13
 [`manual_bits`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits
 [`manual_c_str_literals`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_c_str_literals
 [`manual_clamp`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp
+[`manual_contains`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_contains
 [`manual_div_ceil`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_div_ceil
 [`manual_filter`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter
 [`manual_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_filter_map
@@ -5761,6 +5807,7 @@ Released 2018-09-13
 [`manual_main_separator_str`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_main_separator_str
 [`manual_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_map
 [`manual_memcpy`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_memcpy
+[`manual_midpoint`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_midpoint
 [`manual_next_back`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_next_back
 [`manual_non_exhaustive`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive
 [`manual_ok_err`]: https://rust-lang.github.io/rust-clippy/master/index.html#manual_ok_err
@@ -5812,6 +5859,7 @@ Released 2018-09-13
 [`mem_discriminant_non_enum`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_discriminant_non_enum
 [`mem_forget`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_forget
 [`mem_replace_option_with_none`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_option_with_none
+[`mem_replace_option_with_some`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_option_with_some
 [`mem_replace_with_default`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default
 [`mem_replace_with_uninit`]: https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_uninit
 [`min_ident_chars`]: https://rust-lang.github.io/rust-clippy/master/index.html#min_ident_chars
@@ -5939,6 +5987,7 @@ Released 2018-09-13
 [`out_of_bounds_indexing`]: https://rust-lang.github.io/rust-clippy/master/index.html#out_of_bounds_indexing
 [`overflow_check_conditional`]: https://rust-lang.github.io/rust-clippy/master/index.html#overflow_check_conditional
 [`overly_complex_bool_expr`]: https://rust-lang.github.io/rust-clippy/master/index.html#overly_complex_bool_expr
+[`owned_cow`]: https://rust-lang.github.io/rust-clippy/master/index.html#owned_cow
 [`panic`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic
 [`panic_in_result_fn`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_in_result_fn
 [`panic_params`]: https://rust-lang.github.io/rust-clippy/master/index.html#panic_params
@@ -6067,6 +6116,7 @@ Released 2018-09-13
 [`single_element_loop`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_element_loop
 [`single_match`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match
 [`single_match_else`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_match_else
+[`single_option_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_option_map
 [`single_range_in_vec_init`]: https://rust-lang.github.io/rust-clippy/master/index.html#single_range_in_vec_init
 [`size_of_in_element_count`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_in_element_count
 [`size_of_ref`]: https://rust-lang.github.io/rust-clippy/master/index.html#size_of_ref
@@ -6143,6 +6193,7 @@ Released 2018-09-13
 [`type_complexity`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_complexity
 [`type_id_on_box`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_id_on_box
 [`type_repetition_in_bounds`]: https://rust-lang.github.io/rust-clippy/master/index.html#type_repetition_in_bounds
+[`unbuffered_bytes`]: https://rust-lang.github.io/rust-clippy/master/index.html#unbuffered_bytes
 [`unchecked_duration_subtraction`]: https://rust-lang.github.io/rust-clippy/master/index.html#unchecked_duration_subtraction
 [`unconditional_recursion`]: https://rust-lang.github.io/rust-clippy/master/index.html#unconditional_recursion
 [`undocumented_unsafe_blocks`]: https://rust-lang.github.io/rust-clippy/master/index.html#undocumented_unsafe_blocks
@@ -6161,6 +6212,7 @@ Released 2018-09-13
 [`unnecessary_box_returns`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_box_returns
 [`unnecessary_cast`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_cast
 [`unnecessary_clippy_cfg`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_clippy_cfg
+[`unnecessary_debug_formatting`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_debug_formatting
 [`unnecessary_fallible_conversions`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_fallible_conversions
 [`unnecessary_filter_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_filter_map
 [`unnecessary_find_map`]: https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_find_map
@@ -6267,6 +6319,7 @@ Released 2018-09-13
 [`accept-comment-above-statement`]: https://doc.rust-lang.org/clippy/lint_configuration.html#accept-comment-above-statement
 [`allow-comparison-to-zero`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-comparison-to-zero
 [`allow-dbg-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-dbg-in-tests
+[`allow-expect-in-consts`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-expect-in-consts
 [`allow-expect-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-expect-in-tests
 [`allow-indexing-slicing-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-indexing-slicing-in-tests
 [`allow-mixed-uninlined-format-args`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-mixed-uninlined-format-args
@@ -6275,6 +6328,7 @@ Released 2018-09-13
 [`allow-print-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-print-in-tests
 [`allow-private-module-inception`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-private-module-inception
 [`allow-renamed-params-for`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-renamed-params-for
+[`allow-unwrap-in-consts`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-unwrap-in-consts
 [`allow-unwrap-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-unwrap-in-tests
 [`allow-useless-vec-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allow-useless-vec-in-tests
 [`allowed-dotfiles`]: https://doc.rust-lang.org/clippy/lint_configuration.html#allowed-dotfiles
@@ -6290,6 +6344,7 @@ Released 2018-09-13
 [`avoid-breaking-exported-api`]: https://doc.rust-lang.org/clippy/lint_configuration.html#avoid-breaking-exported-api
 [`await-holding-invalid-types`]: https://doc.rust-lang.org/clippy/lint_configuration.html#await-holding-invalid-types
 [`cargo-ignore-publish`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cargo-ignore-publish
+[`check-incompatible-msrv-in-tests`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-incompatible-msrv-in-tests
 [`check-private-items`]: https://doc.rust-lang.org/clippy/lint_configuration.html#check-private-items
 [`cognitive-complexity-threshold`]: https://doc.rust-lang.org/clippy/lint_configuration.html#cognitive-complexity-threshold
 [`disallowed-macros`]: https://doc.rust-lang.org/clippy/lint_configuration.html#disallowed-macros
diff --git a/src/tools/clippy/Cargo.toml b/src/tools/clippy/Cargo.toml
index c9e4f15afbf8..c4588002dc99 100644
--- a/src/tools/clippy/Cargo.toml
+++ b/src/tools/clippy/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "clippy"
 # begin autogenerated version
-version = "0.1.86"
+version = "0.1.87"
 # end autogenerated version
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
@@ -25,7 +25,7 @@ path = "src/driver.rs"
 [dependencies]
 clippy_config = { path = "clippy_config" }
 clippy_lints = { path = "clippy_lints" }
-rustc_tools_util = "0.4.0"
+rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }
 tempfile = { version = "3.3", optional = true }
 termize = "0.1"
 color-print = "0.3.4"
@@ -54,7 +54,7 @@ parking_lot = "0.12"
 tokio = { version = "1", features = ["io-util"] }
 
 [build-dependencies]
-rustc_tools_util = "0.4.0"
+rustc_tools_util = { path = "rustc_tools_util", version = "0.4.2" }
 
 [features]
 integration = ["tempfile"]
diff --git a/src/tools/clippy/book/src/development/adding_lints.md b/src/tools/clippy/book/src/development/adding_lints.md
index 48506127dee4..0b9010f01071 100644
--- a/src/tools/clippy/book/src/development/adding_lints.md
+++ b/src/tools/clippy/book/src/development/adding_lints.md
@@ -169,7 +169,7 @@ from the lint to the code of the test file and compare that to the contents of a
 Use `cargo bless` to automatically generate the `.fixed` file while running
 the tests.
 
-[rustfix]: https://github.com/rust-lang/rustfix
+[rustfix]: https://github.com/rust-lang/cargo/tree/master/crates/rustfix
 
 ## Testing manually
 
@@ -460,7 +460,7 @@ pub struct ManualStrip {
 
 impl ManualStrip {
     pub fn new(conf: &'static Conf) -> Self {
-        Self { msrv: conf.msrv.clone() }
+        Self { msrv: conf.msrv }
     }
 }
 ```
@@ -469,24 +469,13 @@ The project's MSRV can then be matched against the feature MSRV in the LintPass
 using the `Msrv::meets` method.
 
 ``` rust
-if !self.msrv.meets(msrvs::STR_STRIP_PREFIX) {
+if !self.msrv.meets(cx, msrvs::STR_STRIP_PREFIX) {
     return;
 }
 ```
 
-The project's MSRV can also be specified as an attribute, which overrides
-the value from `clippy.toml`. This can be accounted for using the
-`extract_msrv_attr!(LintContext)` macro and passing
-`LateContext`/`EarlyContext`.
-
-```rust,ignore
-impl<'tcx> LateLintPass<'tcx> for ManualStrip {
-    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        ...
-    }
-    extract_msrv_attr!(LateContext);
-}
-```
+Early lint passes should instead use `MsrvStack` coupled with
+`extract_msrv_attr!()`
 
 Once the `msrv` is added to the lint, a relevant test case should be added to
 the lint's test file, `tests/ui/manual_strip.rs` in this example. It should
@@ -512,8 +501,16 @@ in `clippy_config/src/conf.rs`:
 
 ```rust
 define_Conf! {
-    /// Lint: LIST, OF, LINTS, <THE_NEWLY_ADDED_LINT>. The minimum rust version that the project supports
-    (msrv: Option<String> = None),
+    #[lints(
+        allow_attributes,
+        allow_attributes_without_reason,
+        ..
+        <the newly added lint name>,
+        ..
+        unused_trait_names,
+        use_self,
+    )]
+    msrv: Msrv = Msrv::default(),
     ...
 }
 ```
diff --git a/src/tools/clippy/book/src/development/basics.md b/src/tools/clippy/book/src/development/basics.md
index 166b6aab9fb3..931e5c3a2942 100644
--- a/src/tools/clippy/book/src/development/basics.md
+++ b/src/tools/clippy/book/src/development/basics.md
@@ -75,7 +75,7 @@ or if you modify a test file to add a test case.
 > _Note:_ This command may update more files than you intended. In that case
 > only commit the files you wanted to update.
 
-[UI test]: https://rustc-dev-guide.rust-lang.org/tests/adding.html#guide-to-the-ui-tests
+[UI test]: https://rustc-dev-guide.rust-lang.org/tests/adding.html#ui-test-walkthrough
 
 ## `cargo dev`
 
diff --git a/src/tools/clippy/book/src/development/writing_tests.md b/src/tools/clippy/book/src/development/writing_tests.md
index 39a5ad966885..d4cca2a72f0b 100644
--- a/src/tools/clippy/book/src/development/writing_tests.md
+++ b/src/tools/clippy/book/src/development/writing_tests.md
@@ -203,7 +203,7 @@ We'll talk about suggestions more in depth in a [later chapter](emitting_lints.m
 Use `cargo bless` to automatically generate the `.fixed` file after running
 the tests.
 
-[`rustfix`]: https://github.com/rust-lang/rustfix
+[`rustfix`]: https://github.com/rust-lang/cargo/tree/master/crates/rustfix
 [`span_lint_and_sugg`]: https://doc.rust-lang.org/beta/nightly-rustc/clippy_utils/diagnostics/fn.span_lint_and_sugg.html
 
 ## Testing Manually
diff --git a/src/tools/clippy/book/src/lint_configuration.md b/src/tools/clippy/book/src/lint_configuration.md
index dab2630a56fc..28b613ea3295 100644
--- a/src/tools/clippy/book/src/lint_configuration.md
+++ b/src/tools/clippy/book/src/lint_configuration.md
@@ -71,6 +71,16 @@ Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
 * [`dbg_macro`](https://rust-lang.github.io/rust-clippy/master/index.html#dbg_macro)
 
 
+## `allow-expect-in-consts`
+Whether `expect` should be allowed in code always evaluated at compile time
+
+**Default Value:** `true`
+
+---
+**Affected lints:**
+* [`expect_used`](https://rust-lang.github.io/rust-clippy/master/index.html#expect_used)
+
+
 ## `allow-expect-in-tests`
 Whether `expect` should be allowed in test functions or `#[cfg(test)]`
 
@@ -108,7 +118,7 @@ Whether to allow `r#""#` when `r""` can be used
 
 ---
 **Affected lints:**
-* [`unnecessary_raw_string_hashes`](https://rust-lang.github.io/rust-clippy/master/index.html#unnecessary_raw_string_hashes)
+* [`needless_raw_string_hashes`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_raw_string_hashes)
 
 
 ## `allow-panic-in-tests`
@@ -164,6 +174,16 @@ default configuration of Clippy. By default, any configuration will replace the
 * [`renamed_function_params`](https://rust-lang.github.io/rust-clippy/master/index.html#renamed_function_params)
 
 
+## `allow-unwrap-in-consts`
+Whether `unwrap` should be allowed in code always evaluated at compile time
+
+**Default Value:** `true`
+
+---
+**Affected lints:**
+* [`unwrap_used`](https://rust-lang.github.io/rust-clippy/master/index.html#unwrap_used)
+
+
 ## `allow-unwrap-in-tests`
 Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
 
@@ -360,6 +380,7 @@ Suppress lints whenever the suggested change would cause breakage for other crat
 * [`linkedlist`](https://rust-lang.github.io/rust-clippy/master/index.html#linkedlist)
 * [`needless_pass_by_ref_mut`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_pass_by_ref_mut)
 * [`option_option`](https://rust-lang.github.io/rust-clippy/master/index.html#option_option)
+* [`owned_cow`](https://rust-lang.github.io/rust-clippy/master/index.html#owned_cow)
 * [`rc_buffer`](https://rust-lang.github.io/rust-clippy/master/index.html#rc_buffer)
 * [`rc_mutex`](https://rust-lang.github.io/rust-clippy/master/index.html#rc_mutex)
 * [`redundant_allocation`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_allocation)
@@ -394,6 +415,16 @@ For internal testing only, ignores the current `publish` settings in the Cargo m
 * [`cargo_common_metadata`](https://rust-lang.github.io/rust-clippy/master/index.html#cargo_common_metadata)
 
 
+## `check-incompatible-msrv-in-tests`
+Whether to check MSRV compatibility in `#[test]` and `#[cfg(test)]` code.
+
+**Default Value:** `false`
+
+---
+**Affected lints:**
+* [`incompatible_msrv`](https://rust-lang.github.io/rust-clippy/master/index.html#incompatible_msrv)
+
+
 ## `check-private-items`
 Whether to also run the listed lints on private items.
 
@@ -738,15 +769,21 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`from_over_into`](https://rust-lang.github.io/rust-clippy/master/index.html#from_over_into)
 * [`if_then_some_else_none`](https://rust-lang.github.io/rust-clippy/master/index.html#if_then_some_else_none)
 * [`index_refutable_slice`](https://rust-lang.github.io/rust-clippy/master/index.html#index_refutable_slice)
+* [`io_other_error`](https://rust-lang.github.io/rust-clippy/master/index.html#io_other_error)
 * [`iter_kv_map`](https://rust-lang.github.io/rust-clippy/master/index.html#iter_kv_map)
 * [`legacy_numeric_constants`](https://rust-lang.github.io/rust-clippy/master/index.html#legacy_numeric_constants)
+* [`lines_filter_map_ok`](https://rust-lang.github.io/rust-clippy/master/index.html#lines_filter_map_ok)
 * [`manual_bits`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_bits)
 * [`manual_c_str_literals`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_c_str_literals)
 * [`manual_clamp`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_clamp)
+* [`manual_div_ceil`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_div_ceil)
+* [`manual_flatten`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_flatten)
 * [`manual_hash_one`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_hash_one)
 * [`manual_is_ascii_check`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_is_ascii_check)
 * [`manual_let_else`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_let_else)
+* [`manual_midpoint`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_midpoint)
 * [`manual_non_exhaustive`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_non_exhaustive)
+* [`manual_option_as_slice`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_option_as_slice)
 * [`manual_pattern_char_comparison`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_pattern_char_comparison)
 * [`manual_range_contains`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_range_contains)
 * [`manual_rem_euclid`](https://rust-lang.github.io/rust-clippy/master/index.html#manual_rem_euclid)
@@ -761,6 +798,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`map_unwrap_or`](https://rust-lang.github.io/rust-clippy/master/index.html#map_unwrap_or)
 * [`map_with_unused_argument_over_ranges`](https://rust-lang.github.io/rust-clippy/master/index.html#map_with_unused_argument_over_ranges)
 * [`match_like_matches_macro`](https://rust-lang.github.io/rust-clippy/master/index.html#match_like_matches_macro)
+* [`mem_replace_option_with_some`](https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_option_with_some)
 * [`mem_replace_with_default`](https://rust-lang.github.io/rust-clippy/master/index.html#mem_replace_with_default)
 * [`missing_const_for_fn`](https://rust-lang.github.io/rust-clippy/master/index.html#missing_const_for_fn)
 * [`needless_borrow`](https://rust-lang.github.io/rust-clippy/master/index.html#needless_borrow)
@@ -770,6 +808,7 @@ The minimum rust version that the project supports. Defaults to the `rust-versio
 * [`ptr_as_ptr`](https://rust-lang.github.io/rust-clippy/master/index.html#ptr_as_ptr)
 * [`redundant_field_names`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_field_names)
 * [`redundant_static_lifetimes`](https://rust-lang.github.io/rust-clippy/master/index.html#redundant_static_lifetimes)
+* [`repeat_vec_with_capacity`](https://rust-lang.github.io/rust-clippy/master/index.html#repeat_vec_with_capacity)
 * [`same_item_push`](https://rust-lang.github.io/rust-clippy/master/index.html#same_item_push)
 * [`seek_from_current`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_from_current)
 * [`seek_rewind`](https://rust-lang.github.io/rust-clippy/master/index.html#seek_rewind)
diff --git a/src/tools/clippy/clippy_config/Cargo.toml b/src/tools/clippy/clippy_config/Cargo.toml
index e473a5839402..934725fccb8e 100644
--- a/src/tools/clippy/clippy_config/Cargo.toml
+++ b/src/tools/clippy/clippy_config/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "clippy_config"
 # begin autogenerated version
-version = "0.1.86"
+version = "0.1.87"
 # end autogenerated version
 edition = "2024"
 publish = false
diff --git a/src/tools/clippy/clippy_config/src/conf.rs b/src/tools/clippy/clippy_config/src/conf.rs
index a1591188bee7..a61acbaa96bc 100644
--- a/src/tools/clippy/clippy_config/src/conf.rs
+++ b/src/tools/clippy/clippy_config/src/conf.rs
@@ -1,8 +1,8 @@
 use crate::ClippyConfiguration;
 use crate::types::{
-    DisallowedPath, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour, Rename, SourceItemOrdering,
-    SourceItemOrderingCategory, SourceItemOrderingModuleItemGroupings, SourceItemOrderingModuleItemKind,
-    SourceItemOrderingTraitAssocItemKind, SourceItemOrderingTraitAssocItemKinds,
+    DisallowedPath, DisallowedPathWithoutReplacement, MacroMatcher, MatchLintBehaviour, PubUnderscoreFieldsBehaviour,
+    Rename, SourceItemOrdering, SourceItemOrderingCategory, SourceItemOrderingModuleItemGroupings,
+    SourceItemOrderingModuleItemKind, SourceItemOrderingTraitAssocItemKind, SourceItemOrderingTraitAssocItemKinds,
 };
 use clippy_utils::msrvs::Msrv;
 use rustc_errors::Applicability;
@@ -288,6 +288,9 @@ define_Conf! {
     /// Whether `dbg!` should be allowed in test functions or `#[cfg(test)]`
     #[lints(dbg_macro)]
     allow_dbg_in_tests: bool = false,
+    /// Whether `expect` should be allowed in code always evaluated at compile time
+    #[lints(expect_used)]
+    allow_expect_in_consts: bool = true,
     /// Whether `expect` should be allowed in test functions or `#[cfg(test)]`
     #[lints(expect_used)]
     allow_expect_in_tests: bool = false,
@@ -298,7 +301,7 @@ define_Conf! {
     #[lints(uninlined_format_args)]
     allow_mixed_uninlined_format_args: bool = true,
     /// Whether to allow `r#""#` when `r""` can be used
-    #[lints(unnecessary_raw_string_hashes)]
+    #[lints(needless_raw_string_hashes)]
     allow_one_hash_in_raw_strings: bool = false,
     /// Whether `panic` should be allowed in test functions or `#[cfg(test)]`
     #[lints(panic)]
@@ -325,6 +328,9 @@ define_Conf! {
     #[lints(renamed_function_params)]
     allow_renamed_params_for: Vec<String> =
         DEFAULT_ALLOWED_TRAITS_WITH_RENAMED_PARAMS.iter().map(ToString::to_string).collect(),
+    /// Whether `unwrap` should be allowed in code always evaluated at compile time
+    #[lints(unwrap_used)]
+    allow_unwrap_in_consts: bool = true,
     /// Whether `unwrap` should be allowed in test functions or `#[cfg(test)]`
     #[lints(unwrap_used)]
     allow_unwrap_in_tests: bool = false,
@@ -432,6 +438,7 @@ define_Conf! {
         linkedlist,
         needless_pass_by_ref_mut,
         option_option,
+        owned_cow,
         rc_buffer,
         rc_mutex,
         redundant_allocation,
@@ -448,7 +455,7 @@ define_Conf! {
     avoid_breaking_exported_api: bool = true,
     /// The list of types which may not be held across an await point.
     #[lints(await_holding_invalid_type)]
-    await_holding_invalid_types: Vec<DisallowedPath> = Vec::new(),
+    await_holding_invalid_types: Vec<DisallowedPathWithoutReplacement> = Vec::new(),
     /// DEPRECATED LINT: BLACKLISTED_NAME.
     ///
     /// Use the Disallowed Names lint instead
@@ -457,6 +464,9 @@ define_Conf! {
     /// For internal testing only, ignores the current `publish` settings in the Cargo manifest.
     #[lints(cargo_common_metadata)]
     cargo_ignore_publish: bool = false,
+    /// Whether to check MSRV compatibility in `#[test]` and `#[cfg(test)]` code.
+    #[lints(incompatible_msrv)]
+    check_incompatible_msrv_in_tests: 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)]
     check_private_items: bool = false,
@@ -607,15 +617,21 @@ define_Conf! {
         from_over_into,
         if_then_some_else_none,
         index_refutable_slice,
+        io_other_error,
         iter_kv_map,
         legacy_numeric_constants,
+        lines_filter_map_ok,
         manual_bits,
         manual_c_str_literals,
         manual_clamp,
+        manual_div_ceil,
+        manual_flatten,
         manual_hash_one,
         manual_is_ascii_check,
         manual_let_else,
+        manual_midpoint,
         manual_non_exhaustive,
+        manual_option_as_slice,
         manual_pattern_char_comparison,
         manual_range_contains,
         manual_rem_euclid,
@@ -630,6 +646,7 @@ define_Conf! {
         map_unwrap_or,
         map_with_unused_argument_over_ranges,
         match_like_matches_macro,
+        mem_replace_option_with_some,
         mem_replace_with_default,
         missing_const_for_fn,
         needless_borrow,
@@ -639,6 +656,7 @@ define_Conf! {
         ptr_as_ptr,
         redundant_field_names,
         redundant_static_lifetimes,
+        repeat_vec_with_capacity,
         same_item_push,
         seek_from_current,
         seek_rewind,
@@ -652,7 +670,7 @@ define_Conf! {
         unused_trait_names,
         use_self,
     )]
-    msrv: Msrv = Msrv::empty(),
+    msrv: Msrv = Msrv::default(),
     /// The minimum size (in bytes) to consider a type for passing by reference instead of by value.
     #[lints(large_types_passed_by_value)]
     pass_by_value_size_limit: u64 = 256,
diff --git a/src/tools/clippy/clippy_config/src/types.rs b/src/tools/clippy/clippy_config/src/types.rs
index c949db9109de..c72291e9799f 100644
--- a/src/tools/clippy/clippy_config/src/types.rs
+++ b/src/tools/clippy/clippy_config/src/types.rs
@@ -1,6 +1,8 @@
 use clippy_utils::def_path_def_ids;
+use rustc_errors::{Applicability, Diag};
 use rustc_hir::def_id::DefIdMap;
 use rustc_middle::ty::TyCtxt;
+use rustc_span::Span;
 use serde::de::{self, Deserializer, Visitor};
 use serde::{Deserialize, Serialize, ser};
 use std::collections::HashMap;
@@ -12,37 +14,99 @@ pub struct Rename {
     pub rename: String,
 }
 
-#[derive(Debug, Deserialize)]
-#[serde(untagged)]
-pub enum DisallowedPath {
-    Simple(String),
-    WithReason { path: String, reason: Option<String> },
+pub type DisallowedPathWithoutReplacement = DisallowedPath<false>;
+
+#[derive(Debug, Serialize)]
+pub struct DisallowedPath<const REPLACEMENT_ALLOWED: bool = true> {
+    path: String,
+    reason: Option<String>,
+    replacement: Option<String>,
 }
 
-impl DisallowedPath {
+impl<'de, const REPLACEMENT_ALLOWED: bool> Deserialize<'de> for DisallowedPath<REPLACEMENT_ALLOWED> {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let enum_ = DisallowedPathEnum::deserialize(deserializer)?;
+        if !REPLACEMENT_ALLOWED && enum_.replacement().is_some() {
+            return Err(de::Error::custom("replacement not allowed for this configuration"));
+        }
+        Ok(Self {
+            path: enum_.path().to_owned(),
+            reason: enum_.reason().map(ToOwned::to_owned),
+            replacement: enum_.replacement().map(ToOwned::to_owned),
+        })
+    }
+}
+
+// `DisallowedPathEnum` is an implementation detail to enable the `Deserialize` implementation just
+// above. `DisallowedPathEnum` is not meant to be used outside of this file.
+#[derive(Debug, Deserialize, Serialize)]
+#[serde(untagged)]
+enum DisallowedPathEnum {
+    Simple(String),
+    WithReason {
+        path: String,
+        reason: Option<String>,
+        replacement: Option<String>,
+    },
+}
+
+impl<const REPLACEMENT_ALLOWED: bool> DisallowedPath<REPLACEMENT_ALLOWED> {
+    pub fn path(&self) -> &str {
+        &self.path
+    }
+
+    pub fn diag_amendment(&self, span: Span) -> impl FnOnce(&mut Diag<'_, ()>) + use<'_, REPLACEMENT_ALLOWED> {
+        move |diag| {
+            if let Some(replacement) = &self.replacement {
+                diag.span_suggestion(
+                    span,
+                    self.reason.as_ref().map_or_else(|| String::from("use"), Clone::clone),
+                    replacement,
+                    Applicability::MachineApplicable,
+                );
+            } else if let Some(reason) = &self.reason {
+                diag.note(reason.clone());
+            }
+        }
+    }
+}
+
+impl DisallowedPathEnum {
     pub fn path(&self) -> &str {
         let (Self::Simple(path) | Self::WithReason { path, .. }) = self;
 
         path
     }
 
-    pub fn reason(&self) -> Option<&str> {
+    fn reason(&self) -> Option<&str> {
         match &self {
             Self::WithReason { reason, .. } => reason.as_deref(),
             Self::Simple(_) => None,
         }
     }
+
+    fn replacement(&self) -> Option<&str> {
+        match &self {
+            Self::WithReason { replacement, .. } => replacement.as_deref(),
+            Self::Simple(_) => None,
+        }
+    }
 }
 
 /// Creates a map of disallowed items to the reason they were disallowed.
-pub fn create_disallowed_map(
+pub fn create_disallowed_map<const REPLACEMENT_ALLOWED: bool>(
     tcx: TyCtxt<'_>,
-    disallowed: &'static [DisallowedPath],
-) -> DefIdMap<(&'static str, Option<&'static str>)> {
+    disallowed: &'static [DisallowedPath<REPLACEMENT_ALLOWED>],
+) -> DefIdMap<(&'static str, &'static DisallowedPath<REPLACEMENT_ALLOWED>)> {
     disallowed
         .iter()
-        .map(|x| (x.path(), x.path().split("::").collect::<Vec<_>>(), x.reason()))
-        .flat_map(|(name, path, reason)| def_path_def_ids(tcx, &path).map(move |id| (id, (name, reason))))
+        .map(|x| (x.path(), x.path().split("::").collect::<Vec<_>>(), x))
+        .flat_map(|(name, path, disallowed_path)| {
+            def_path_def_ids(tcx, &path).map(move |id| (id, (name, disallowed_path)))
+        })
         .collect()
 }
 
@@ -436,7 +500,6 @@ macro_rules! unimplemented_serialize {
 }
 
 unimplemented_serialize! {
-    DisallowedPath,
     Rename,
     MacroMatcher,
 }
diff --git a/src/tools/clippy/clippy_dev/src/dogfood.rs b/src/tools/clippy/clippy_dev/src/dogfood.rs
index 75a4cbd2f92e..05fa24d8d4ee 100644
--- a/src/tools/clippy/clippy_dev/src/dogfood.rs
+++ b/src/tools/clippy/clippy_dev/src/dogfood.rs
@@ -4,7 +4,8 @@ use std::process::Command;
 /// # Panics
 ///
 /// Panics if unable to run the dogfood test
-pub fn dogfood(fix: bool, allow_dirty: bool, allow_staged: bool) {
+#[allow(clippy::fn_params_excessive_bools)]
+pub fn dogfood(fix: bool, allow_dirty: bool, allow_staged: bool, allow_no_vcs: bool) {
     let mut cmd = Command::new("cargo");
 
     cmd.current_dir(clippy_project_root())
@@ -25,6 +26,10 @@ pub fn dogfood(fix: bool, allow_dirty: bool, allow_staged: bool) {
         dogfood_args.push("--allow-staged");
     }
 
+    if allow_no_vcs {
+        dogfood_args.push("--allow-no-vcs");
+    }
+
     cmd.env("__CLIPPY_DOGFOOD_ARGS", dogfood_args.join(" "));
 
     exit_if_err(cmd.status());
diff --git a/src/tools/clippy/clippy_dev/src/fmt.rs b/src/tools/clippy/clippy_dev/src/fmt.rs
index 790dafa811f9..bdddf46a2cb1 100644
--- a/src/tools/clippy/clippy_dev/src/fmt.rs
+++ b/src/tools/clippy/clippy_dev/src/fmt.rs
@@ -290,8 +290,13 @@ fn run_rustfmt(context: &FmtContext) -> Result<(), Error> {
         .filter_map(|entry| {
             let entry = entry.expect("failed to find tests");
             let path = entry.path();
-
-            if path.extension() != Some("rs".as_ref()) || entry.file_name() == "ice-3891.rs" {
+            if path.extension() != Some("rs".as_ref())
+                || path
+                    .components()
+                    .nth_back(1)
+                    .is_some_and(|c| c.as_os_str() == "syntax-error-recovery")
+                || entry.file_name() == "ice-3891.rs"
+            {
                 None
             } else {
                 Some(entry.into_path().into_os_string())
diff --git a/src/tools/clippy/clippy_dev/src/lint.rs b/src/tools/clippy/clippy_dev/src/lint.rs
index 125195397e6c..e0e036757d56 100644
--- a/src/tools/clippy/clippy_dev/src/lint.rs
+++ b/src/tools/clippy/clippy_dev/src/lint.rs
@@ -2,7 +2,7 @@ use crate::utils::{cargo_clippy_path, exit_if_err};
 use std::process::{self, Command};
 use std::{env, fs};
 
-pub fn run<'a>(path: &str, args: impl Iterator<Item = &'a String>) {
+pub fn run<'a>(path: &str, edition: &str, args: impl Iterator<Item = &'a String>) {
     let is_file = match fs::metadata(path) {
         Ok(metadata) => metadata.is_file(),
         Err(e) => {
@@ -17,7 +17,7 @@ pub fn run<'a>(path: &str, args: impl Iterator<Item = &'a String>) {
                 .args(["run", "--bin", "clippy-driver", "--"])
                 .args(["-L", "./target/debug"])
                 .args(["-Z", "no-codegen"])
-                .args(["--edition", "2021"])
+                .args(["--edition", edition])
                 .arg(path)
                 .args(args)
                 // Prevent rustc from creating `rustc-ice-*` files the console output is enough.
diff --git a/src/tools/clippy/clippy_dev/src/main.rs b/src/tools/clippy/clippy_dev/src/main.rs
index 56ed60256f16..074dea4ab77b 100644
--- a/src/tools/clippy/clippy_dev/src/main.rs
+++ b/src/tools/clippy/clippy_dev/src/main.rs
@@ -17,7 +17,8 @@ fn main() {
             fix,
             allow_dirty,
             allow_staged,
-        } => dogfood::dogfood(fix, allow_dirty, allow_staged),
+            allow_no_vcs,
+        } => dogfood::dogfood(fix, allow_dirty, allow_staged, allow_no_vcs),
         DevCommand::Fmt { check, verbose } => fmt::run(check, verbose),
         DevCommand::UpdateLints { print_only, check } => {
             if print_only {
@@ -34,7 +35,7 @@ fn main() {
             category,
             r#type,
             msrv,
-        } => match new_lint::create(&pass, &name, &category, r#type.as_deref(), msrv) {
+        } => match new_lint::create(pass, &name, &category, r#type.as_deref(), msrv) {
             Ok(()) => update_lints::update(utils::UpdateMode::Change),
             Err(e) => eprintln!("Unable to create lint: {e}"),
         },
@@ -53,7 +54,12 @@ fn main() {
                     setup::git_hook::install_hook(force_override);
                 }
             },
-            SetupSubcommand::Toolchain { force, release, name } => setup::toolchain::create(force, release, &name),
+            SetupSubcommand::Toolchain {
+                standalone,
+                force,
+                release,
+                name,
+            } => setup::toolchain::create(standalone, force, release, &name),
             SetupSubcommand::VscodeTasks { remove, force_override } => {
                 if remove {
                     setup::vscode::remove_tasks();
@@ -68,7 +74,7 @@ fn main() {
             RemoveSubcommand::VscodeTasks => setup::vscode::remove_tasks(),
         },
         DevCommand::Serve { port, lint } => serve::run(port, lint),
-        DevCommand::Lint { path, args } => lint::run(&path, args.iter()),
+        DevCommand::Lint { path, edition, args } => lint::run(&path, &edition, args.iter()),
         DevCommand::RenameLint {
             old_name,
             new_name,
@@ -106,6 +112,9 @@ enum DevCommand {
         #[arg(long, requires = "fix")]
         /// Fix code even if the working directory has staged changes
         allow_staged: bool,
+        #[arg(long, requires = "fix")]
+        /// Fix code even if a VCS was not detected
+        allow_no_vcs: bool,
     },
     /// Run rustfmt on all projects and tests
     Fmt {
@@ -138,9 +147,9 @@ enum DevCommand {
     #[command(name = "new_lint")]
     /// Create a new lint and run `cargo dev update_lints`
     NewLint {
-        #[arg(short, long, value_parser = ["early", "late"], conflicts_with = "type", default_value = "late")]
+        #[arg(short, long, conflicts_with = "type", default_value = "late")]
         /// Specify whether the lint runs during the early or late pass
-        pass: String,
+        pass: new_lint::Pass,
         #[arg(
             short,
             long,
@@ -206,6 +215,9 @@ enum DevCommand {
     ///     cargo dev lint file.rs -- -W clippy::pedantic {n}
     ///     cargo dev lint ~/my-project -- -- -W clippy::pedantic
     Lint {
+        /// The Rust edition to use
+        #[arg(long, default_value = "2024")]
+        edition: String,
         /// The path to a file or package directory to lint
         path: String,
         /// Pass extra arguments to cargo/clippy-driver
@@ -264,14 +276,25 @@ enum SetupSubcommand {
         force_override: bool,
     },
     /// Install a rustup toolchain pointing to the local clippy build
+    ///
+    /// This creates a toolchain with symlinks pointing at
+    /// `target/.../{clippy-driver,cargo-clippy}`, rebuilds of the project will be reflected in the
+    /// created toolchain unless `--standalone` is passed
     Toolchain {
+        #[arg(long, short)]
+        /// Create a standalone toolchain by copying the clippy binaries instead
+        /// of symlinking them
+        ///
+        /// Use this for example to create a toolchain, make a small change and then make another
+        /// toolchain with a different name in order to easily compare the two
+        standalone: bool,
         #[arg(long, short)]
         /// Override an existing toolchain
         force: bool,
         #[arg(long, short)]
         /// Point to --release clippy binary
         release: bool,
-        #[arg(long, default_value = "clippy")]
+        #[arg(long, short, default_value = "clippy")]
         /// Name of the toolchain
         name: String,
     },
diff --git a/src/tools/clippy/clippy_dev/src/new_lint.rs b/src/tools/clippy/clippy_dev/src/new_lint.rs
index cc4b26867a20..96e12706c9e2 100644
--- a/src/tools/clippy/clippy_dev/src/new_lint.rs
+++ b/src/tools/clippy/clippy_dev/src/new_lint.rs
@@ -1,14 +1,28 @@
 use crate::utils::{clippy_project_root, clippy_version};
+use clap::ValueEnum;
 use indoc::{formatdoc, writedoc};
-use std::fmt;
-use std::fmt::Write as _;
+use std::fmt::{self, Write as _};
 use std::fs::{self, OpenOptions};
-use std::io::prelude::*;
-use std::io::{self, ErrorKind};
+use std::io::{self, Write as _};
 use std::path::{Path, PathBuf};
 
+#[derive(Clone, Copy, PartialEq, ValueEnum)]
+pub enum Pass {
+    Early,
+    Late,
+}
+
+impl fmt::Display for Pass {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str(match self {
+            Pass::Early => "early",
+            Pass::Late => "late",
+        })
+    }
+}
+
 struct LintData<'a> {
-    pass: &'a str,
+    pass: Pass,
     name: &'a str,
     category: &'a str,
     ty: Option<&'a str>,
@@ -25,7 +39,7 @@ impl<T> Context for io::Result<T> {
             Ok(t) => Ok(t),
             Err(e) => {
                 let message = format!("{}: {e}", text.as_ref());
-                Err(io::Error::new(ErrorKind::Other, message))
+                Err(io::Error::other(message))
             },
         }
     }
@@ -36,7 +50,7 @@ impl<T> Context for io::Result<T> {
 /// # Errors
 ///
 /// This function errors out if the files couldn't be created or written to.
-pub fn create(pass: &str, name: &str, category: &str, mut ty: Option<&str>, msrv: bool) -> io::Result<()> {
+pub fn create(pass: Pass, name: &str, category: &str, mut ty: Option<&str>, msrv: bool) -> io::Result<()> {
     if category == "cargo" && ty.is_none() {
         // `cargo` is a special category, these lints should always be in `clippy_lints/src/cargo`
         ty = Some("cargo");
@@ -57,7 +71,7 @@ pub fn create(pass: &str, name: &str, category: &str, mut ty: Option<&str>, msrv
         add_lint(&lint, msrv).context("Unable to add lint to clippy_lints/src/lib.rs")?;
     }
 
-    if pass == "early" {
+    if pass == Pass::Early {
         println!(
             "\n\
             NOTE: Use a late pass unless you need something specific from\n\
@@ -137,23 +151,17 @@ fn add_lint(lint: &LintData<'_>, enable_msrv: bool) -> io::Result<()> {
     let mut lib_rs = fs::read_to_string(path).context("reading")?;
 
     let comment_start = lib_rs.find("// add lints here,").expect("Couldn't find comment");
+    let ctor_arg = if lint.pass == Pass::Late { "_" } else { "" };
+    let lint_pass = lint.pass;
+    let module_name = lint.name;
+    let camel_name = to_camel_case(lint.name);
 
     let new_lint = if enable_msrv {
         format!(
             "store.register_{lint_pass}_pass(move |{ctor_arg}| Box::new({module_name}::{camel_name}::new(conf)));\n    ",
-            lint_pass = lint.pass,
-            ctor_arg = if lint.pass == "late" { "_" } else { "" },
-            module_name = lint.name,
-            camel_name = to_camel_case(lint.name),
         )
     } else {
-        format!(
-            "store.register_{lint_pass}_pass(|{ctor_arg}| Box::new({module_name}::{camel_name}));\n    ",
-            lint_pass = lint.pass,
-            ctor_arg = if lint.pass == "late" { "_" } else { "" },
-            module_name = lint.name,
-            camel_name = to_camel_case(lint.name),
-        )
+        format!("store.register_{lint_pass}_pass(|{ctor_arg}| Box::new({module_name}::{camel_name}));\n    ",)
     };
 
     lib_rs.insert_str(comment_start, &new_lint);
@@ -243,11 +251,16 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
     let mut result = String::new();
 
     let (pass_type, pass_lifetimes, pass_import, context_import) = match lint.pass {
-        "early" => ("EarlyLintPass", "", "use rustc_ast::ast::*;", "EarlyContext"),
-        "late" => ("LateLintPass", "<'_>", "use rustc_hir::*;", "LateContext"),
-        _ => {
-            unreachable!("`pass_type` should only ever be `early` or `late`!");
-        },
+        Pass::Early => ("EarlyLintPass", "", "use rustc_ast::ast::*;", "EarlyContext"),
+        Pass::Late => ("LateLintPass", "<'_>", "use rustc_hir::*;", "LateContext"),
+    };
+    let (msrv_ty, msrv_ctor, extract_msrv) = match lint.pass {
+        Pass::Early => (
+            "MsrvStack",
+            "MsrvStack::new(conf.msrv)",
+            "\n    extract_msrv_attr!();\n",
+        ),
+        Pass::Late => ("Msrv", "conf.msrv", ""),
     };
 
     let lint_name = lint.name;
@@ -259,10 +272,10 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
         let _: fmt::Result = writedoc!(
             result,
             r"
-            use clippy_utils::msrvs::{{self, Msrv}};
+            use clippy_utils::msrvs::{{self, {msrv_ty}}};
             use clippy_config::Conf;
             {pass_import}
-            use rustc_lint::{{{context_import}, {pass_type}, LintContext}};
+            use rustc_lint::{{{context_import}, {pass_type}}};
             use rustc_session::impl_lint_pass;
 
         "
@@ -286,20 +299,18 @@ fn get_lint_file_contents(lint: &LintData<'_>, enable_msrv: bool) -> String {
             result,
             r"
             pub struct {name_camel} {{
-                msrv: Msrv,
+                msrv: {msrv_ty},
             }}
 
             impl {name_camel} {{
                 pub fn new(conf: &'static Conf) -> Self {{
-                    Self {{ msrv: conf.msrv.clone() }}
+                    Self {{ msrv: {msrv_ctor} }}
                 }}
             }}
 
             impl_lint_pass!({name_camel} => [{name_upper}]);
 
-            impl {pass_type}{pass_lifetimes} for {name_camel} {{
-                extract_msrv_attr!({context_import});
-            }}
+            impl {pass_type}{pass_lifetimes} for {name_camel} {{{extract_msrv}}}
 
             // TODO: Add MSRV level to `clippy_config/src/msrvs.rs` if needed.
             // TODO: Update msrv config comment in `clippy_config/src/conf.rs`
@@ -376,9 +387,9 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
 
     let mod_file_path = ty_dir.join("mod.rs");
     let context_import = setup_mod_file(&mod_file_path, lint)?;
-    let pass_lifetimes = match context_import {
-        "LateContext" => "<'_>",
-        _ => "",
+    let (pass_lifetimes, msrv_ty, msrv_ref, msrv_cx) = match context_import {
+        "LateContext" => ("<'_>", "Msrv", "", "cx, "),
+        _ => ("", "MsrvStack", "&", ""),
     };
 
     let name_upper = lint.name.to_uppercase();
@@ -388,14 +399,14 @@ fn create_lint_for_ty(lint: &LintData<'_>, enable_msrv: bool, ty: &str) -> io::R
         let _: fmt::Result = writedoc!(
             lint_file_contents,
             r#"
-                use clippy_utils::msrvs::{{self, Msrv}};
+                use clippy_utils::msrvs::{{self, {msrv_ty}}};
                 use rustc_lint::{{{context_import}, LintContext}};
 
                 use super::{name_upper};
 
                 // TODO: Adjust the parameters as necessary
-                pub(super) fn check(cx: &{context_import}{pass_lifetimes}, msrv: &Msrv) {{
-                    if !msrv.meets(todo!("Add a new entry in `clippy_utils/src/msrvs`")) {{
+                pub(super) fn check(cx: &{context_import}{pass_lifetimes}, msrv: {msrv_ref}{msrv_ty}) {{
+                    if !msrv.meets({msrv_cx}todo!("Add a new entry in `clippy_utils/src/msrvs`")) {{
                         return;
                     }}
                     todo!();
diff --git a/src/tools/clippy/clippy_dev/src/setup/toolchain.rs b/src/tools/clippy/clippy_dev/src/setup/toolchain.rs
index 8d98c6c92d9d..2966629cf70a 100644
--- a/src/tools/clippy/clippy_dev/src/setup/toolchain.rs
+++ b/src/tools/clippy/clippy_dev/src/setup/toolchain.rs
@@ -3,11 +3,14 @@ use std::env::current_dir;
 use std::ffi::OsStr;
 use std::fs;
 use std::path::{Path, PathBuf};
+use std::process::Command;
 use walkdir::WalkDir;
 
+use crate::utils::exit_if_err;
+
 use super::verify_inside_clippy_dir;
 
-pub fn create(force: bool, release: bool, name: &str) {
+pub fn create(standalone: bool, force: bool, release: bool, name: &str) {
     if !verify_inside_clippy_dir() {
         return;
     }
@@ -48,14 +51,22 @@ pub fn create(force: bool, release: bool, name: &str) {
         }
     }
 
-    symlink_bin("cargo-clippy", &dest, release);
-    symlink_bin("clippy-driver", &dest, release);
+    let status = Command::new("cargo")
+        .arg("build")
+        .args(release.then_some("--release"))
+        .status();
+    exit_if_err(status);
+
+    install_bin("cargo-clippy", &dest, standalone, release);
+    install_bin("clippy-driver", &dest, standalone, release);
 
     println!("Created toolchain {name}, use it in other projects with e.g. `cargo +{name} clippy`");
-    println!("Note: This will need to be re-run whenever the Clippy `rust-toolchain` changes");
+    if !standalone {
+        println!("Note: This will need to be re-run whenever the Clippy `rust-toolchain` changes");
+    }
 }
 
-fn symlink_bin(bin: &str, dest: &Path, release: bool) {
+fn install_bin(bin: &str, dest: &Path, standalone: bool, release: bool) {
     #[cfg(windows)]
     use std::os::windows::fs::symlink_file as symlink;
 
@@ -71,5 +82,9 @@ fn symlink_bin(bin: &str, dest: &Path, release: bool) {
     let mut dest = dest.to_path_buf();
     dest.extend(["bin", &file_name]);
 
-    symlink(src, dest).unwrap();
+    if standalone {
+        fs::copy(src, dest).unwrap();
+    } else {
+        symlink(src, dest).unwrap();
+    }
 }
diff --git a/src/tools/clippy/clippy_lints/Cargo.toml b/src/tools/clippy/clippy_lints/Cargo.toml
index c62a7ec783b6..54347043a13d 100644
--- a/src/tools/clippy/clippy_lints/Cargo.toml
+++ b/src/tools/clippy/clippy_lints/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "clippy_lints"
 # begin autogenerated version
-version = "0.1.86"
+version = "0.1.87"
 # end autogenerated version
 description = "A bunch of helpful lints to avoid common pitfalls in Rust"
 repository = "https://github.com/rust-lang/rust-clippy"
diff --git a/src/tools/clippy/clippy_lints/src/almost_complete_range.rs b/src/tools/clippy/clippy_lints/src/almost_complete_range.rs
index 0f7f779e8ea7..4f55968d5625 100644
--- a/src/tools/clippy/clippy_lints/src/almost_complete_range.rs
+++ b/src/tools/clippy/clippy_lints/src/almost_complete_range.rs
@@ -1,6 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs::{self, MsrvStack};
 use clippy_utils::source::{trim_span, walk_span_to_context};
 use rustc_ast::ast::{Expr, ExprKind, LitKind, Pat, PatKind, RangeEnd, RangeLimits};
 use rustc_errors::Applicability;
@@ -31,12 +31,12 @@ declare_clippy_lint! {
 impl_lint_pass!(AlmostCompleteRange => [ALMOST_COMPLETE_RANGE]);
 
 pub struct AlmostCompleteRange {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 impl AlmostCompleteRange {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: MsrvStack::new(conf.msrv),
         }
     }
 }
@@ -96,7 +96,7 @@ impl EarlyLintPass for AlmostCompleteRange {
         }
     }
 
-    extract_msrv_attr!(EarlyContext);
+    extract_msrv_attr!();
 }
 
 fn is_incomplete_range(start: &Expr, end: &Expr) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/approx_const.rs b/src/tools/clippy/clippy_lints/src/approx_const.rs
index 95f64b74044b..9ae746c13b26 100644
--- a/src/tools/clippy/clippy_lints/src/approx_const.rs
+++ b/src/tools/clippy/clippy_lints/src/approx_const.rs
@@ -69,13 +69,11 @@ pub struct ApproxConstant {
 
 impl ApproxConstant {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
-impl<'tcx> LateLintPass<'tcx> for ApproxConstant {
+impl LateLintPass<'_> for ApproxConstant {
     fn check_lit(&mut self, cx: &LateContext<'_>, _hir_id: HirId, lit: &Lit, _negated: bool) {
         match lit.node {
             LitKind::Float(s, LitFloatType::Suffixed(fty)) => match fty {
@@ -89,8 +87,6 @@ impl<'tcx> LateLintPass<'tcx> for ApproxConstant {
             _ => (),
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 impl ApproxConstant {
@@ -98,7 +94,7 @@ impl ApproxConstant {
         let s = s.as_str();
         if s.parse::<f64>().is_ok() {
             for &(constant, name, min_digits, msrv) in &KNOWN_CONSTS {
-                if is_approx_const(constant, s, min_digits) && msrv.is_none_or(|msrv| self.msrv.meets(msrv)) {
+                if is_approx_const(constant, s, min_digits) && msrv.is_none_or(|msrv| self.msrv.meets(cx, msrv)) {
                     span_lint_and_help(
                         cx,
                         APPROX_CONSTANT,
diff --git a/src/tools/clippy/clippy_lints/src/as_conversions.rs b/src/tools/clippy/clippy_lints/src/as_conversions.rs
index 847653ed6e98..78102772927c 100644
--- a/src/tools/clippy/clippy_lints/src/as_conversions.rs
+++ b/src/tools/clippy/clippy_lints/src/as_conversions.rs
@@ -9,12 +9,24 @@ declare_clippy_lint! {
     /// Checks for usage of `as` conversions.
     ///
     /// Note that this lint is specialized in linting *every single* use of `as`
-    /// regardless of whether good alternatives exist or not.
-    /// If you want more precise lints for `as`, please consider using these separate lints:
-    /// `unnecessary_cast`, `cast_lossless/cast_possible_truncation/cast_possible_wrap/cast_precision_loss/cast_sign_loss`,
-    /// `fn_to_numeric_cast(_with_truncation)`, `char_lit_as_u8`, `ref_to_mut` and `ptr_as_ptr`.
-    /// There is a good explanation the reason why this lint should work in this way and how it is useful
-    /// [in this issue](https://github.com/rust-lang/rust-clippy/issues/5122).
+    /// regardless of whether good alternatives exist or not. If you want more
+    /// precise lints for `as`, please consider using these separate lints:
+    ///
+    /// - clippy::cast_lossless
+    /// - clippy::cast_possible_truncation
+    /// - clippy::cast_possible_wrap
+    /// - clippy::cast_precision_loss
+    /// - clippy::cast_sign_loss
+    /// - clippy::char_lit_as_u8
+    /// - clippy::fn_to_numeric_cast
+    /// - clippy::fn_to_numeric_cast_with_truncation
+    /// - clippy::ptr_as_ptr
+    /// - clippy::unnecessary_cast
+    /// - invalid_reference_casting
+    ///
+    /// There is a good explanation the reason why this lint should work in this
+    /// way and how it is useful [in this
+    /// issue](https://github.com/rust-lang/rust-clippy/issues/5122).
     ///
     /// ### Why restrict this?
     /// `as` conversions will perform many kinds of
diff --git a/src/tools/clippy/clippy_lints/src/assigning_clones.rs b/src/tools/clippy/clippy_lints/src/assigning_clones.rs
index 348495f97a27..ab34af7c3174 100644
--- a/src/tools/clippy/clippy_lints/src/assigning_clones.rs
+++ b/src/tools/clippy/clippy_lints/src/assigning_clones.rs
@@ -59,9 +59,7 @@ pub struct AssigningClones {
 
 impl AssigningClones {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -90,7 +88,7 @@ impl<'tcx> LateLintPass<'tcx> for AssigningClones {
                 sym::clone if is_diag_trait_item(cx, fn_id, sym::Clone) => CloneTrait::Clone,
                 _ if fn_name.as_str() == "to_owned"
                     && is_diag_trait_item(cx, fn_id, sym::ToOwned)
-                    && self.msrv.meets(msrvs::CLONE_INTO) =>
+                    && self.msrv.meets(cx, msrvs::CLONE_INTO) =>
                 {
                     CloneTrait::ToOwned
                 },
@@ -143,8 +141,6 @@ impl<'tcx> LateLintPass<'tcx> for AssigningClones {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 /// Checks if the data being cloned borrows from the place that is being assigned to:
diff --git a/src/tools/clippy/clippy_lints/src/attrs/deprecated_cfg_attr.rs b/src/tools/clippy/clippy_lints/src/attrs/deprecated_cfg_attr.rs
index 3a462018e3e0..cd38aed26a3e 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/deprecated_cfg_attr.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/deprecated_cfg_attr.rs
@@ -1,12 +1,12 @@
 use super::{Attribute, DEPRECATED_CFG_ATTR, DEPRECATED_CLIPPY_CFG_ATTR, unnecessary_clippy_cfg};
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs::{self, MsrvStack};
 use rustc_ast::AttrStyle;
 use rustc_errors::Applicability;
 use rustc_lint::EarlyContext;
 use rustc_span::sym;
 
-pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &Msrv) {
+pub(super) fn check(cx: &EarlyContext<'_>, attr: &Attribute, msrv: &MsrvStack) {
     // check cfg_attr
     if attr.has_name(sym::cfg_attr)
         && let Some(items) = attr.meta_item_list()
diff --git a/src/tools/clippy/clippy_lints/src/attrs/inline_always.rs b/src/tools/clippy/clippy_lints/src/attrs/inline_always.rs
index 2325f914b0b0..cb63fadb4e21 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/inline_always.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/inline_always.rs
@@ -20,7 +20,7 @@ pub(super) fn check(cx: &LateContext<'_>, span: Span, name: Symbol, attrs: &[Att
                 span_lint(
                     cx,
                     INLINE_ALWAYS,
-                    attr.span,
+                    attr.span(),
                     format!("you have declared `#[inline(always)]` on `{name}`. This is usually a bad idea"),
                 );
             }
diff --git a/src/tools/clippy/clippy_lints/src/attrs/mixed_attributes_style.rs b/src/tools/clippy/clippy_lints/src/attrs/mixed_attributes_style.rs
index 5a26ba8bf932..d71c8e9894bf 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/mixed_attributes_style.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/mixed_attributes_style.rs
@@ -1,4 +1,3 @@
-use std::sync::Arc;
 use super::MIXED_ATTRIBUTES_STYLE;
 use clippy_utils::diagnostics::span_lint;
 use rustc_ast::{AttrKind, AttrStyle, Attribute};
@@ -6,6 +5,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{EarlyContext, LintContext};
 use rustc_span::source_map::SourceMap;
 use rustc_span::{SourceFile, Span, Symbol};
+use std::sync::Arc;
 
 #[derive(Hash, PartialEq, Eq)]
 enum SimpleAttrKind {
diff --git a/src/tools/clippy/clippy_lints/src/attrs/mod.rs b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
index 92efd1a4ddcd..2b59c218d57a 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/mod.rs
@@ -14,7 +14,7 @@ mod useless_attribute;
 mod utils;
 
 use clippy_config::Conf;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs::{self, Msrv, MsrvStack};
 use rustc_ast::{self as ast, Attribute, MetaItemInner, MetaItemKind};
 use rustc_hir::{ImplItem, Item, TraitItem};
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
@@ -305,7 +305,7 @@ declare_clippy_lint! {
     ///     header_version: u16
     /// }
     /// ```
-    #[clippy::version = "1.84.0"]
+    #[clippy::version = "1.85.0"]
     pub REPR_PACKED_WITHOUT_ABI,
     suspicious,
     "ensures that `repr(packed)` always comes with a qualified ABI"
@@ -459,9 +459,7 @@ impl_lint_pass!(Attributes => [
 
 impl Attributes {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -471,7 +469,7 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
         if is_relevant_item(cx, item) {
             inline_always::check(cx, item.span, item.ident.name, attrs);
         }
-        repr_attributes::check(cx, item.span, attrs, &self.msrv);
+        repr_attributes::check(cx, item.span, attrs, self.msrv);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx ImplItem<'_>) {
@@ -485,18 +483,16 @@ impl<'tcx> LateLintPass<'tcx> for Attributes {
             inline_always::check(cx, item.span, item.ident.name, cx.tcx.hir().attrs(item.hir_id()));
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 pub struct EarlyAttributes {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 
 impl EarlyAttributes {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: MsrvStack::new(conf.msrv),
         }
     }
 }
@@ -515,17 +511,17 @@ impl EarlyLintPass for EarlyAttributes {
         non_minimal_cfg::check(cx, attr);
     }
 
-    extract_msrv_attr!(EarlyContext);
+    extract_msrv_attr!();
 }
 
 pub struct PostExpansionEarlyAttributes {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 
 impl PostExpansionEarlyAttributes {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: MsrvStack::new(conf.msrv),
         }
     }
 }
@@ -589,5 +585,5 @@ impl EarlyLintPass for PostExpansionEarlyAttributes {
         duplicated_attributes::check(cx, &item.attrs);
     }
 
-    extract_msrv_attr!(EarlyContext);
+    extract_msrv_attr!();
 }
diff --git a/src/tools/clippy/clippy_lints/src/attrs/repr_attributes.rs b/src/tools/clippy/clippy_lints/src/attrs/repr_attributes.rs
index 6d1ab46aa0c1..e5cfbaf952a7 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/repr_attributes.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/repr_attributes.rs
@@ -1,43 +1,39 @@
+use rustc_attr_parsing::{AttributeKind, ReprAttr, find_attr};
 use rustc_hir::Attribute;
 use rustc_lint::LateContext;
-use rustc_span::{Span, sym};
+use rustc_span::Span;
 
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs;
+use clippy_utils::msrvs::{self, Msrv};
 
 use super::REPR_PACKED_WITHOUT_ABI;
 
-pub(super) fn check(cx: &LateContext<'_>, item_span: Span, attrs: &[Attribute], msrv: &msrvs::Msrv) {
-    if msrv.meets(msrvs::REPR_RUST) {
-        check_packed(cx, item_span, attrs);
-    }
-}
+pub(super) fn check(cx: &LateContext<'_>, item_span: Span, attrs: &[Attribute], msrv: Msrv) {
+    if let Some(reprs) = find_attr!(attrs, AttributeKind::Repr(r) => r) {
+        let packed_span = reprs
+            .iter()
+            .find(|(r, _)| matches!(r, ReprAttr::ReprPacked(..)))
+            .map(|(_, s)| *s);
 
-fn check_packed(cx: &LateContext<'_>, item_span: Span, attrs: &[Attribute]) {
-    if let Some(items) = attrs.iter().find_map(|attr| {
-        if attr.ident().is_some_and(|ident| matches!(ident.name, sym::repr)) {
-            attr.meta_item_list()
-        } else {
-            None
-        }
-    }) && let Some(packed) = items
-        .iter()
-        .find(|item| item.ident().is_some_and(|ident| matches!(ident.name, sym::packed)))
-        && !items.iter().any(|item| {
-            item.ident()
-                .is_some_and(|ident| matches!(ident.name, sym::C | sym::Rust))
-        })
-    {
-        span_lint_and_then(
-            cx,
-            REPR_PACKED_WITHOUT_ABI,
-            item_span,
-            "item uses `packed` representation without ABI-qualification",
-            |diag| {
-                diag.warn("unqualified `#[repr(packed)]` defaults to `#[repr(Rust, packed)]`, which has no stable ABI")
+        if let Some(packed_span) = packed_span
+            && !reprs
+                .iter()
+                .any(|(x, _)| *x == ReprAttr::ReprC || *x == ReprAttr::ReprRust)
+            && msrv.meets(cx, msrvs::REPR_RUST)
+        {
+            span_lint_and_then(
+                cx,
+                REPR_PACKED_WITHOUT_ABI,
+                item_span,
+                "item uses `packed` representation without ABI-qualification",
+                |diag| {
+                    diag.warn(
+                        "unqualified `#[repr(packed)]` defaults to `#[repr(Rust, packed)]`, which has no stable ABI",
+                    )
                     .help("qualify the desired ABI explicity via `#[repr(C, packed)]` or `#[repr(Rust, packed)]`")
-                    .span_label(packed.span(), "`packed` representation set here");
-            },
-        );
+                    .span_label(packed_span, "`packed` representation set here");
+                },
+            );
+        }
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs b/src/tools/clippy/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs
index 478ba7a187be..6ee3290fa761 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/unnecessary_clippy_cfg.rs
@@ -15,7 +15,7 @@ pub(super) fn check(
 ) {
     if cfg_attr.has_name(sym::clippy)
         && let Some(ident) = behind_cfg_attr.ident()
-        && Level::from_symbol(ident.name, Some(attr.id)).is_some()
+        && Level::from_symbol(ident.name, || Some(attr.id)).is_some()
         && let Some(items) = behind_cfg_attr.meta_item_list()
     {
         let nb_items = items.len();
diff --git a/src/tools/clippy/clippy_lints/src/attrs/utils.rs b/src/tools/clippy/clippy_lints/src/attrs/utils.rs
index a667649f7343..0e650e493925 100644
--- a/src/tools/clippy/clippy_lints/src/attrs/utils.rs
+++ b/src/tools/clippy/clippy_lints/src/attrs/utils.rs
@@ -17,7 +17,7 @@ pub(super) fn is_word(nmi: &MetaItemInner, expected: Symbol) -> bool {
 }
 
 pub(super) fn is_lint_level(symbol: Symbol, attr_id: AttrId) -> bool {
-    Level::from_symbol(symbol, Some(attr_id)).is_some()
+    Level::from_symbol(symbol, || Some(attr_id)).is_some()
 }
 
 pub(super) fn is_relevant_item(cx: &LateContext<'_>, item: &Item<'_>) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/await_holding_invalid.rs b/src/tools/clippy/clippy_lints/src/await_holding_invalid.rs
index 2eb0566bf9a6..92a0c7f9acbc 100644
--- a/src/tools/clippy/clippy_lints/src/await_holding_invalid.rs
+++ b/src/tools/clippy/clippy_lints/src/await_holding_invalid.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_config::types::create_disallowed_map;
+use clippy_config::types::{DisallowedPathWithoutReplacement, create_disallowed_map};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::{match_def_path, paths};
 use rustc_hir as hir;
@@ -174,7 +174,7 @@ declare_clippy_lint! {
 impl_lint_pass!(AwaitHolding => [AWAIT_HOLDING_LOCK, AWAIT_HOLDING_REFCELL_REF, AWAIT_HOLDING_INVALID_TYPE]);
 
 pub struct AwaitHolding {
-    def_ids: DefIdMap<(&'static str, Option<&'static str>)>,
+    def_ids: DefIdMap<(&'static str, &'static DisallowedPathWithoutReplacement)>,
 }
 
 impl AwaitHolding {
@@ -247,25 +247,26 @@ impl AwaitHolding {
                             );
                         },
                     );
-                } else if let Some(&(path, reason)) = self.def_ids.get(&adt.did()) {
-                    emit_invalid_type(cx, ty_cause.source_info.span, path, reason);
+                } else if let Some(&(path, disallowed_path)) = self.def_ids.get(&adt.did()) {
+                    emit_invalid_type(cx, ty_cause.source_info.span, path, disallowed_path);
                 }
             }
         }
     }
 }
 
-fn emit_invalid_type(cx: &LateContext<'_>, span: Span, path: &'static str, reason: Option<&'static str>) {
+fn emit_invalid_type(
+    cx: &LateContext<'_>,
+    span: Span,
+    path: &'static str,
+    disallowed_path: &'static DisallowedPathWithoutReplacement,
+) {
     span_lint_and_then(
         cx,
         AWAIT_HOLDING_INVALID_TYPE,
         span,
         format!("holding a disallowed type across an await point `{path}`"),
-        |diag| {
-            if let Some(reason) = reason {
-                diag.note(reason);
-            }
-        },
+        disallowed_path.diag_amendment(span),
     );
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/booleans.rs b/src/tools/clippy/clippy_lints/src/booleans.rs
index f30f16997d76..48b5d4da8886 100644
--- a/src/tools/clippy/clippy_lints/src/booleans.rs
+++ b/src/tools/clippy/clippy_lints/src/booleans.rs
@@ -3,6 +3,7 @@ use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::eq_expr_value;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::SpanRangeExt;
+use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{implements_trait, is_type_diagnostic_item};
 use rustc_ast::ast::LitKind;
 use rustc_attr_parsing::RustcVersion;
@@ -84,9 +85,7 @@ pub struct NonminimalBool {
 
 impl NonminimalBool {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -102,7 +101,7 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
         _: Span,
         _: LocalDefId,
     ) {
-        NonminimalBoolVisitor { cx, msrv: &self.msrv }.visit_body(body);
+        NonminimalBoolVisitor { cx, msrv: self.msrv }.visit_body(body);
     }
 
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
@@ -119,8 +118,6 @@ impl<'tcx> LateLintPass<'tcx> for NonminimalBool {
             _ => {},
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn inverted_bin_op_eq_str(op: BinOpKind) -> Option<&'static str> {
@@ -197,7 +194,7 @@ fn check_inverted_bool_in_condition(
     );
 }
 
-fn check_simplify_not(cx: &LateContext<'_>, msrv: &Msrv, expr: &Expr<'_>) {
+fn check_simplify_not(cx: &LateContext<'_>, msrv: Msrv, expr: &Expr<'_>) {
     if let ExprKind::Unary(UnOp::Not, inner) = &expr.kind
         && !expr.span.from_expansion()
         && !inner.span.from_expansion()
@@ -233,7 +230,7 @@ fn check_simplify_not(cx: &LateContext<'_>, msrv: &Msrv, expr: &Expr<'_>) {
 
 struct NonminimalBoolVisitor<'a, 'tcx> {
     cx: &'a LateContext<'tcx>,
-    msrv: &'a Msrv,
+    msrv: Msrv,
 }
 
 use quine_mc_cluskey::Bool;
@@ -326,7 +323,7 @@ impl<'v> Hir2Qmm<'_, '_, 'v> {
 struct SuggestContext<'a, 'tcx, 'v> {
     terminals: &'v [&'v Expr<'v>],
     cx: &'a LateContext<'tcx>,
-    msrv: &'a Msrv,
+    msrv: Msrv,
     output: String,
 }
 
@@ -353,7 +350,8 @@ impl SuggestContext<'_, '_, '_> {
                         self.output.push_str(&str);
                     } else {
                         self.output.push('!');
-                        self.output.push_str(&terminal.span.get_source_text(self.cx)?);
+                        self.output
+                            .push_str(&Sugg::hir_opt(self.cx, terminal)?.maybe_par().to_string());
                     }
                 },
                 True | False | Not(_) => {
@@ -396,7 +394,7 @@ impl SuggestContext<'_, '_, '_> {
     }
 }
 
-fn simplify_not(cx: &LateContext<'_>, curr_msrv: &Msrv, expr: &Expr<'_>) -> Option<String> {
+fn simplify_not(cx: &LateContext<'_>, curr_msrv: Msrv, expr: &Expr<'_>) -> Option<String> {
     match &expr.kind {
         ExprKind::Binary(binop, lhs, rhs) => {
             if !implements_ord(cx, lhs) {
@@ -438,7 +436,9 @@ fn simplify_not(cx: &LateContext<'_>, curr_msrv: &Msrv, expr: &Expr<'_>) -> Opti
                 .iter()
                 .copied()
                 .flat_map(|(msrv, a, b)| vec![(msrv, a, b), (msrv, b, a)])
-                .find(|&(msrv, a, _)| msrv.is_none_or(|msrv| curr_msrv.meets(msrv)) && a == path.ident.name.as_str())
+                .find(|&(msrv, a, _)| {
+                    a == path.ident.name.as_str() && msrv.is_none_or(|msrv| curr_msrv.meets(cx, msrv))
+                })
                 .and_then(|(_, _, neg_method)| {
                     let negated_args = args
                         .iter()
@@ -467,7 +467,7 @@ fn simplify_not(cx: &LateContext<'_>, curr_msrv: &Msrv, expr: &Expr<'_>) -> Opti
     }
 }
 
-fn suggest(cx: &LateContext<'_>, msrv: &Msrv, suggestion: &Bool, terminals: &[&Expr<'_>]) -> String {
+fn suggest(cx: &LateContext<'_>, msrv: Msrv, suggestion: &Bool, terminals: &[&Expr<'_>]) -> String {
     let mut suggest_context = SuggestContext {
         terminals,
         cx,
@@ -553,7 +553,7 @@ impl<'tcx> NonminimalBoolVisitor<'_, 'tcx> {
                     _ => simplified.push(Bool::Not(Box::new(simple.clone()))),
                 }
                 let simple_negated = simple_negate(simple);
-                if simplified.iter().any(|s| *s == simple_negated) {
+                if simplified.contains(&simple_negated) {
                     continue;
                 }
                 simplified.push(simple_negated);
diff --git a/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs
index 6057144bc6a4..d143629da3a0 100644
--- a/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/borrow_as_ptr.rs
@@ -16,7 +16,7 @@ pub(super) fn check<'tcx>(
     expr: &'tcx Expr<'_>,
     cast_expr: &'tcx Expr<'_>,
     cast_to: &'tcx Ty<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     if matches!(cast_to.kind, TyKind::Ptr(_))
         && let ExprKind::AddrOf(BorrowKind::Ref, mutability, e) = cast_expr.kind
@@ -34,7 +34,7 @@ pub(super) fn check<'tcx>(
             return false;
         }
 
-        let (suggestion, span) = if msrv.meets(msrvs::RAW_REF_OP) {
+        let (suggestion, span) = if msrv.meets(cx, msrvs::RAW_REF_OP) {
             let operator_kind = match mutability {
                 Mutability::Not => "const",
                 Mutability::Mut => "mut",
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_abs_to_unsigned.rs b/src/tools/clippy/clippy_lints/src/casts/cast_abs_to_unsigned.rs
index ae433773193a..8b3529e84fc6 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_abs_to_unsigned.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_abs_to_unsigned.rs
@@ -14,13 +14,13 @@ pub(super) fn check(
     cast_expr: &Expr<'_>,
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if msrv.meets(msrvs::UNSIGNED_ABS)
-        && let ty::Int(from) = cast_from.kind()
+    if let ty::Int(from) = cast_from.kind()
         && let ty::Uint(to) = cast_to.kind()
         && let ExprKind::MethodCall(method_path, receiver, [], _) = cast_expr.kind
         && method_path.ident.name.as_str() == "abs"
+        && msrv.meets(cx, msrvs::UNSIGNED_ABS)
     {
         let span = if from.bit_width() == to.bit_width() {
             expr.span
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs b/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs
index c326a0d935c7..3ae43732dc03 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_lossless.rs
@@ -19,7 +19,7 @@ pub(super) fn check(
     cast_from: Ty<'_>,
     cast_to: Ty<'_>,
     cast_to_hir: &rustc_hir::Ty<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if !should_lint(cx, cast_from, cast_to, msrv) {
         return;
@@ -70,7 +70,7 @@ pub(super) fn check(
     );
 }
 
-fn should_lint(cx: &LateContext<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: &Msrv) -> bool {
+fn should_lint(cx: &LateContext<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: Msrv) -> bool {
     // Do not suggest using From in consts/statics until it is valid to do so (see #2267).
     if is_in_const_context(cx) {
         return false;
@@ -96,7 +96,7 @@ fn should_lint(cx: &LateContext<'_>, cast_from: Ty<'_>, cast_to: Ty<'_>, msrv: &
             };
             !is_isize_or_usize(cast_from) && from_nbits < to_nbits
         },
-        (false, true) if matches!(cast_from.kind(), ty::Bool) && msrv.meets(msrvs::FROM_BOOL) => true,
+        (false, true) if matches!(cast_from.kind(), ty::Bool) && msrv.meets(cx, msrvs::FROM_BOOL) => true,
         (_, _) => {
             matches!(cast_from.kind(), ty::Float(FloatTy::F32)) && matches!(cast_to.kind(), ty::Float(FloatTy::F64))
         },
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
index 45045e58ac75..c8abf9dac9af 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_sign_loss.rs
@@ -142,11 +142,11 @@ fn expr_sign<'cx, 'tcx>(cx: &LateContext<'cx>, mut expr: &'tcx Expr<'tcx>, ty: i
             expr = recv;
         }
 
-        if METHODS_POW.iter().any(|&name| method_name == name)
+        if METHODS_POW.contains(&method_name)
             && let [arg] = args
         {
             return pow_call_result_sign(cx, caller, arg);
-        } else if METHODS_RET_POSITIVE.iter().any(|&name| method_name == name) {
+        } else if METHODS_RET_POSITIVE.contains(&method_name) {
             return Sign::ZeroOrPositive;
         }
     }
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs b/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs
index 030c2d322db6..c48f253606dc 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_slice_different_sizes.rs
@@ -9,12 +9,7 @@ use rustc_middle::ty::{self, Ty, TypeAndMut};
 
 use super::CAST_SLICE_DIFFERENT_SIZES;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Msrv) {
-    // suggestion is invalid if `ptr::slice_from_raw_parts` does not exist
-    if !msrv.meets(msrvs::PTR_SLICE_RAW_PARTS) {
-        return;
-    }
-
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: Msrv) {
     // if this cast is the child of another cast expression then don't emit something for it, the full
     // chain will be analyzed
     if is_child_of_cast(cx, expr) {
@@ -30,7 +25,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>, msrv: &Msrv
         if let (Ok(from_layout), Ok(to_layout)) = (cx.layout_of(start_ty.ty), cx.layout_of(end_ty.ty)) {
             let from_size = from_layout.size.bytes();
             let to_size = to_layout.size.bytes();
-            if from_size != to_size && from_size != 0 && to_size != 0 {
+            if from_size != to_size && from_size != 0 && to_size != 0 && msrv.meets(cx, msrvs::PTR_SLICE_RAW_PARTS) {
                 span_lint_and_then(
                     cx,
                     CAST_SLICE_DIFFERENT_SIZES,
diff --git a/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs b/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
index c3bc5c0c9f2a..46b0c88d3fed 100644
--- a/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/cast_slice_from_raw_parts.rs
@@ -23,9 +23,8 @@ fn raw_parts_kind(cx: &LateContext<'_>, did: DefId) -> Option<RawPartsKind> {
     }
 }
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>, msrv: &Msrv) {
-    if msrv.meets(msrvs::PTR_SLICE_RAW_PARTS)
-        && let ty::RawPtr(ptrty, _) = cast_to.kind()
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>, cast_to: Ty<'_>, msrv: Msrv) {
+    if let ty::RawPtr(ptrty, _) = cast_to.kind()
         && let ty::Slice(_) = ptrty.kind()
         && let ExprKind::Call(fun, [ptr_arg, len_arg]) = cast_expr.peel_blocks().kind
         && let ExprKind::Path(ref qpath) = fun.kind
@@ -33,6 +32,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, cast_expr: &Expr<'_>,
         && let Some(rpk) = raw_parts_kind(cx, fun_def_id)
         && let ctxt = expr.span.ctxt()
         && cast_expr.span.ctxt() == ctxt
+        && msrv.meets(cx, msrvs::PTR_SLICE_RAW_PARTS)
     {
         let func = match rpk {
             RawPartsKind::Immutable => "from_raw_parts",
diff --git a/src/tools/clippy/clippy_lints/src/casts/mod.rs b/src/tools/clippy/clippy_lints/src/casts/mod.rs
index 521bd394901a..dc2a1fa85bf5 100644
--- a/src/tools/clippy/clippy_lints/src/casts/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/mod.rs
@@ -134,8 +134,14 @@ declare_clippy_lint! {
     ///
     /// ### Example
     /// ```no_run
-    /// u32::MAX as i32; // will yield a value of `-1`
+    /// let _ = u32::MAX as i32; // will yield a value of `-1`
     /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// let _ = i32::try_from(u32::MAX).ok();
+    /// ```
+    ///
     #[clippy::version = "pre 1.29.0"]
     pub CAST_POSSIBLE_WRAP,
     pedantic,
@@ -747,7 +753,7 @@ declare_clippy_lint! {
     ///     t as *const T as usize
     /// }
     /// ```
-    #[clippy::version = "1.81.0"]
+    #[clippy::version = "1.85.0"]
     pub AS_POINTER_UNDERSCORE,
     restriction,
     "detects `as *mut _` and `as *const _` conversion"
@@ -759,9 +765,7 @@ pub struct Casts {
 
 impl Casts {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -811,8 +815,8 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
             if !expr.span.from_expansion() && unnecessary_cast::check(cx, expr, cast_from_expr, cast_from, cast_to) {
                 return;
             }
-            cast_slice_from_raw_parts::check(cx, expr, cast_from_expr, cast_to, &self.msrv);
-            ptr_cast_constness::check(cx, expr, cast_from_expr, cast_from, cast_to, &self.msrv);
+            cast_slice_from_raw_parts::check(cx, expr, cast_from_expr, cast_to, self.msrv);
+            ptr_cast_constness::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
             as_ptr_cast_mut::check(cx, expr, cast_from_expr, cast_to);
             fn_to_numeric_cast_any::check(cx, expr, cast_from_expr, cast_from, cast_to);
             fn_to_numeric_cast::check(cx, expr, cast_from_expr, cast_from, cast_to);
@@ -825,29 +829,27 @@ impl<'tcx> LateLintPass<'tcx> for Casts {
                     cast_possible_wrap::check(cx, expr, cast_from, cast_to);
                     cast_precision_loss::check(cx, expr, cast_from, cast_to);
                     cast_sign_loss::check(cx, expr, cast_from_expr, cast_from, cast_to);
-                    cast_abs_to_unsigned::check(cx, expr, cast_from_expr, cast_from, cast_to, &self.msrv);
+                    cast_abs_to_unsigned::check(cx, expr, cast_from_expr, cast_from, cast_to, self.msrv);
                     cast_nan_to_int::check(cx, expr, cast_from_expr, cast_from, cast_to);
                 }
-                cast_lossless::check(cx, expr, cast_from_expr, cast_from, cast_to, cast_to_hir, &self.msrv);
+                cast_lossless::check(cx, expr, cast_from_expr, cast_from, cast_to, cast_to_hir, self.msrv);
                 cast_enum_constructor::check(cx, expr, cast_from_expr, cast_from);
             }
 
             as_underscore::check(cx, expr, cast_to_hir);
             as_pointer_underscore::check(cx, cast_to, cast_to_hir);
 
-            let was_borrow_as_ptr_emitted = self.msrv.meets(msrvs::BORROW_AS_PTR)
-                && borrow_as_ptr::check(cx, expr, cast_from_expr, cast_to_hir, &self.msrv);
-            if self.msrv.meets(msrvs::PTR_FROM_REF) && !was_borrow_as_ptr_emitted {
+            let was_borrow_as_ptr_emitted = self.msrv.meets(cx, msrvs::BORROW_AS_PTR)
+                && borrow_as_ptr::check(cx, expr, cast_from_expr, cast_to_hir, self.msrv);
+            if !was_borrow_as_ptr_emitted && self.msrv.meets(cx, msrvs::PTR_FROM_REF) {
                 ref_as_ptr::check(cx, expr, cast_from_expr, cast_to_hir);
             }
         }
 
         cast_ptr_alignment::check(cx, expr);
         char_lit_as_u8::check(cx, expr);
-        ptr_as_ptr::check(cx, expr, &self.msrv);
-        cast_slice_different_sizes::check(cx, expr, &self.msrv);
+        ptr_as_ptr::check(cx, expr, self.msrv);
+        cast_slice_different_sizes::check(cx, expr, self.msrv);
         ptr_cast_constness::check_null_ptr_cast_method(cx, expr);
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/casts/ptr_as_ptr.rs b/src/tools/clippy/clippy_lints/src/casts/ptr_as_ptr.rs
index bdc389d39dd3..d57e391b55d5 100644
--- a/src/tools/clippy/clippy_lints/src/casts/ptr_as_ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/ptr_as_ptr.rs
@@ -26,11 +26,7 @@ impl OmitFollowedCastReason<'_> {
     }
 }
 
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
-    if !msrv.meets(msrvs::POINTER_CAST) {
-        return;
-    }
-
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Msrv) {
     if let ExprKind::Cast(cast_expr, cast_to_hir_ty) = expr.kind
         && let (cast_from, cast_to) = (cx.typeck_results().expr_ty(cast_expr), cx.typeck_results().expr_ty(expr))
         && let ty::RawPtr(_, from_mutbl) = cast_from.kind()
@@ -40,6 +36,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: &Msrv) {
         // The `U` in `pointer::cast` have to be `Sized`
         // as explained here: https://github.com/rust-lang/rust/issues/60602.
         && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())
+        && msrv.meets(cx, msrvs::POINTER_CAST)
     {
         let mut app = Applicability::MachineApplicable;
         let turbofish = match &cast_to_hir_ty.kind {
diff --git a/src/tools/clippy/clippy_lints/src/casts/ptr_cast_constness.rs b/src/tools/clippy/clippy_lints/src/casts/ptr_cast_constness.rs
index 945c05ee9436..cad9c1df273f 100644
--- a/src/tools/clippy/clippy_lints/src/casts/ptr_cast_constness.rs
+++ b/src/tools/clippy/clippy_lints/src/casts/ptr_cast_constness.rs
@@ -16,7 +16,7 @@ pub(super) fn check<'tcx>(
     cast_expr: &Expr<'_>,
     cast_from: Ty<'tcx>,
     cast_to: Ty<'tcx>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if let ty::RawPtr(from_ty, from_mutbl) = cast_from.kind()
         && let ty::RawPtr(to_ty, to_mutbl) = cast_to.kind()
@@ -52,7 +52,7 @@ pub(super) fn check<'tcx>(
             return;
         }
 
-        if msrv.meets(msrvs::POINTER_CAST_CONSTNESS) {
+        if msrv.meets(cx, msrvs::POINTER_CAST_CONSTNESS) {
             let sugg = Sugg::hir(cx, cast_expr, "_");
             let constness = match *to_mutbl {
                 Mutability::Not => "const",
diff --git a/src/tools/clippy/clippy_lints/src/checked_conversions.rs b/src/tools/clippy/clippy_lints/src/checked_conversions.rs
index 9516af7334d7..b36c8662289c 100644
--- a/src/tools/clippy/clippy_lints/src/checked_conversions.rs
+++ b/src/tools/clippy/clippy_lints/src/checked_conversions.rs
@@ -39,9 +39,7 @@ pub struct CheckedConversions {
 
 impl CheckedConversions {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -65,7 +63,6 @@ impl LateLintPass<'_> for CheckedConversions {
             }
             && !item.span.in_external_macro(cx.sess().source_map())
             && !is_in_const_context(cx)
-            && self.msrv.meets(msrvs::TRY_FROM)
             && let Some(cv) = match op2 {
                 // todo: check for case signed -> larger unsigned == only x >= 0
                 None => check_upper_bound(lt1, gt1).filter(|cv| cv.cvt == ConversionType::FromUnsigned),
@@ -79,6 +76,7 @@ impl LateLintPass<'_> for CheckedConversions {
                 },
             }
             && let Some(to_type) = cv.to_type
+            && self.msrv.meets(cx, msrvs::TRY_FROM)
         {
             let mut applicability = Applicability::MachineApplicable;
             let snippet = snippet_with_applicability(cx, cv.expr_to_cast.span, "_", &mut applicability);
@@ -93,8 +91,6 @@ impl LateLintPass<'_> for CheckedConversions {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 /// Contains the result of a tried conversion check
diff --git a/src/tools/clippy/clippy_lints/src/copies.rs b/src/tools/clippy/clippy_lints/src/copies.rs
index 89808d38b9f3..03ed9c657b30 100644
--- a/src/tools/clippy/clippy_lints/src/copies.rs
+++ b/src/tools/clippy/clippy_lints/src/copies.rs
@@ -18,7 +18,6 @@ use rustc_session::impl_lint_pass;
 use rustc_span::hygiene::walk_chain;
 use rustc_span::source_map::SourceMap;
 use rustc_span::{Span, Symbol};
-use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -130,11 +129,6 @@ declare_clippy_lint! {
     /// ### Why is this bad?
     /// Duplicate code is less maintainable.
     ///
-    /// ### Known problems
-    /// * The lint doesn't check if the moved expressions modify values that are being used in
-    ///   the if condition. The suggestion can in that case modify the behavior of the program.
-    ///   See [rust-clippy#7452](https://github.com/rust-lang/rust-clippy/issues/7452)
-    ///
     /// ### Example
     /// ```ignore
     /// let foo = if … {
@@ -248,18 +242,18 @@ fn lint_branches_sharing_code<'tcx>(
         let first_line_span = first_line_of_span(cx, expr.span);
         let replace_span = first_line_span.with_hi(span.hi());
         let cond_span = first_line_span.until(first_block.span);
-        let cond_snippet = reindent_multiline(snippet(cx, cond_span, "_"), false, None);
+        let cond_snippet = reindent_multiline(&snippet(cx, cond_span, "_"), false, None);
         let cond_indent = indent_of(cx, cond_span);
-        let moved_snippet = reindent_multiline(snippet(cx, span, "_"), true, None);
+        let moved_snippet = reindent_multiline(&snippet(cx, span, "_"), true, None);
         let suggestion = moved_snippet.to_string() + "\n" + &cond_snippet + "{";
-        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, cond_indent);
+        let suggestion = reindent_multiline(&suggestion, true, cond_indent);
         (replace_span, suggestion.to_string())
     });
     let end_suggestion = res.end_span(last_block, sm).map(|span| {
-        let moved_snipped = reindent_multiline(snippet(cx, span, "_"), true, None);
+        let moved_snipped = reindent_multiline(&snippet(cx, span, "_"), true, None);
         let indent = indent_of(cx, expr.span.shrink_to_hi());
         let suggestion = "}\n".to_string() + &moved_snipped;
-        let suggestion = reindent_multiline(Cow::Borrowed(&suggestion), true, indent);
+        let suggestion = reindent_multiline(&suggestion, true, indent);
 
         let span = span.with_hi(last_block.span.hi());
         // Improve formatting if the inner block has indention (i.e. normal Rust formatting)
diff --git a/src/tools/clippy/clippy_lints/src/declared_lints.rs b/src/tools/clippy/clippy_lints/src/declared_lints.rs
index 5c5978b55598..0834618499c7 100644
--- a/src/tools/clippy/clippy_lints/src/declared_lints.rs
+++ b/src/tools/clippy/clippy_lints/src/declared_lints.rs
@@ -139,6 +139,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::disallowed_types::DISALLOWED_TYPES_INFO,
     crate::doc::DOC_INCLUDE_WITHOUT_CFG_INFO,
     crate::doc::DOC_LAZY_CONTINUATION_INFO,
+    crate::doc::DOC_LINK_CODE_INFO,
     crate::doc::DOC_LINK_WITH_QUOTES_INFO,
     crate::doc::DOC_MARKDOWN_INFO,
     crate::doc::DOC_NESTED_REFDEFS_INFO,
@@ -192,6 +193,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::format_args::FORMAT_IN_FORMAT_ARGS_INFO,
     crate::format_args::TO_STRING_IN_FORMAT_ARGS_INFO,
     crate::format_args::UNINLINED_FORMAT_ARGS_INFO,
+    crate::format_args::UNNECESSARY_DEBUG_FORMATTING_INFO,
     crate::format_args::UNUSED_FORMAT_SPECS_INFO,
     crate::format_impl::PRINT_IN_FORMAT_IMPL_INFO,
     crate::format_impl::RECURSIVE_FORMAT_IMPL_INFO,
@@ -272,6 +274,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::let_underscore::LET_UNDERSCORE_MUST_USE_INFO,
     crate::let_underscore::LET_UNDERSCORE_UNTYPED_INFO,
     crate::let_with_type_underscore::LET_WITH_TYPE_UNDERSCORE_INFO,
+    crate::lifetimes::ELIDABLE_LIFETIME_NAMES_INFO,
     crate::lifetimes::EXTRA_UNUSED_LIFETIMES_INFO,
     crate::lifetimes::NEEDLESS_LIFETIMES_INFO,
     crate::lines_filter_map_ok::LINES_FILTER_MAP_OK_INFO,
@@ -362,6 +365,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::matches::WILDCARD_ENUM_MATCH_ARM_INFO,
     crate::matches::WILDCARD_IN_OR_PATTERNS_INFO,
     crate::mem_replace::MEM_REPLACE_OPTION_WITH_NONE_INFO,
+    crate::mem_replace::MEM_REPLACE_OPTION_WITH_SOME_INFO,
     crate::mem_replace::MEM_REPLACE_WITH_DEFAULT_INFO,
     crate::mem_replace::MEM_REPLACE_WITH_UNINIT_INFO,
     crate::methods::BIND_INSTEAD_OF_MAP_INFO,
@@ -398,6 +402,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::methods::INEFFICIENT_TO_STRING_INFO,
     crate::methods::INSPECT_FOR_EACH_INFO,
     crate::methods::INTO_ITER_ON_REF_INFO,
+    crate::methods::IO_OTHER_ERROR_INFO,
     crate::methods::IS_DIGIT_ASCII_RADIX_INFO,
     crate::methods::ITERATOR_STEP_BY_ZERO_INFO,
     crate::methods::ITER_CLONED_COLLECT_INFO,
@@ -416,6 +421,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::methods::ITER_SKIP_ZERO_INFO,
     crate::methods::ITER_WITH_DRAIN_INFO,
     crate::methods::JOIN_ABSOLUTE_PATHS_INFO,
+    crate::methods::MANUAL_CONTAINS_INFO,
     crate::methods::MANUAL_C_STR_LITERALS_INFO,
     crate::methods::MANUAL_FILTER_MAP_INFO,
     crate::methods::MANUAL_FIND_MAP_INFO,
@@ -452,7 +458,6 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::methods::OPTION_AS_REF_CLONED_INFO,
     crate::methods::OPTION_AS_REF_DEREF_INFO,
     crate::methods::OPTION_FILTER_MAP_INFO,
-    crate::methods::OPTION_MAP_OR_ERR_OK_INFO,
     crate::methods::OPTION_MAP_OR_NONE_INFO,
     crate::methods::OR_FUN_CALL_INFO,
     crate::methods::OR_THEN_UNWRAP_INFO,
@@ -483,6 +488,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::methods::SUSPICIOUS_SPLITN_INFO,
     crate::methods::SUSPICIOUS_TO_OWNED_INFO,
     crate::methods::TYPE_ID_ON_BOX_INFO,
+    crate::methods::UNBUFFERED_BYTES_INFO,
     crate::methods::UNINIT_ASSUMED_INIT_INFO,
     crate::methods::UNIT_HASH_INFO,
     crate::methods::UNNECESSARY_FALLIBLE_CONVERSIONS_INFO,
@@ -602,6 +608,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::operators::IMPOSSIBLE_COMPARISONS_INFO,
     crate::operators::INEFFECTIVE_BIT_MASK_INFO,
     crate::operators::INTEGER_DIVISION_INFO,
+    crate::operators::MANUAL_MIDPOINT_INFO,
     crate::operators::MISREFACTORED_ASSIGN_OP_INFO,
     crate::operators::MODULO_ARITHMETIC_INFO,
     crate::operators::MODULO_ONE_INFO,
@@ -684,6 +691,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::single_call_fn::SINGLE_CALL_FN_INFO,
     crate::single_char_lifetime_names::SINGLE_CHAR_LIFETIME_NAMES_INFO,
     crate::single_component_path_imports::SINGLE_COMPONENT_PATH_IMPORTS_INFO,
+    crate::single_option_map::SINGLE_OPTION_MAP_INFO,
     crate::single_range_in_vec_init::SINGLE_RANGE_IN_VEC_INIT_INFO,
     crate::size_of_in_element_count::SIZE_OF_IN_ELEMENT_COUNT_INFO,
     crate::size_of_ref::SIZE_OF_REF_INFO,
@@ -741,6 +749,7 @@ pub static LINTS: &[&crate::LintInfo] = &[
     crate::types::BOX_COLLECTION_INFO,
     crate::types::LINKEDLIST_INFO,
     crate::types::OPTION_OPTION_INFO,
+    crate::types::OWNED_COW_INFO,
     crate::types::RC_BUFFER_INFO,
     crate::types::RC_MUTEX_INFO,
     crate::types::REDUNDANT_ALLOCATION_INFO,
diff --git a/src/tools/clippy/clippy_lints/src/default_union_representation.rs b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
index 9f020d3081c4..085ed9222c91 100644
--- a/src/tools/clippy/clippy_lints/src/default_union_representation.rs
+++ b/src/tools/clippy/clippy_lints/src/default_union_representation.rs
@@ -1,10 +1,10 @@
 use clippy_utils::diagnostics::span_lint_and_then;
+use rustc_attr_parsing::{AttributeKind, ReprAttr, find_attr};
 use rustc_hir::{HirId, Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::ty::{self, FieldDef};
 use rustc_session::declare_lint_pass;
-use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -97,16 +97,7 @@ fn is_zst<'tcx>(cx: &LateContext<'tcx>, field: &FieldDef, args: ty::GenericArgsR
 }
 
 fn has_c_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    cx.tcx.hir().attrs(hir_id).iter().any(|attr| {
-        if attr.has_name(sym::repr) {
-            if let Some(items) = attr.meta_item_list() {
-                for item in items {
-                    if item.is_word() && matches!(item.name_or_empty(), sym::C) {
-                        return true;
-                    }
-                }
-            }
-        }
-        false
-    })
+    let attrs = cx.tcx.hir().attrs(hir_id);
+
+    find_attr!(attrs, AttributeKind::Repr(r) if r.iter().any(|(x, _)| *x == ReprAttr::ReprC))
 }
diff --git a/src/tools/clippy/clippy_lints/src/deprecated_lints.rs b/src/tools/clippy/clippy_lints/src/deprecated_lints.rs
index 5604172d6f30..0031da406f17 100644
--- a/src/tools/clippy/clippy_lints/src/deprecated_lints.rs
+++ b/src/tools/clippy/clippy_lints/src/deprecated_lints.rs
@@ -40,6 +40,8 @@ declare_with_version! { DEPRECATED(DEPRECATED_VERSION): &[(&str, &str)] = &[
     ("clippy::pub_enum_variant_names", "`clippy::enum_variant_names` now covers this case via the `avoid-breaking-exported-api` config"),
     #[clippy::version = "1.54.0"]
     ("clippy::wrong_pub_self_convention", "`clippy::wrong_self_convention` now covers this case via the `avoid-breaking-exported-api` config"),
+    #[clippy::version = "1.86.0"]
+    ("clippy::option_map_or_err_ok", "`clippy::manual_ok_or` covers this case"),
     // end deprecated lints. used by `cargo dev deprecate_lint`
 ]}
 
diff --git a/src/tools/clippy/clippy_lints/src/derivable_impls.rs b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
index bb445e0155f6..66a3e5e3d3c7 100644
--- a/src/tools/clippy/clippy_lints/src/derivable_impls.rs
+++ b/src/tools/clippy/clippy_lints/src/derivable_impls.rs
@@ -62,9 +62,7 @@ pub struct DerivableImpls {
 
 impl DerivableImpls {
     pub fn new(conf: &'static Conf) -> Self {
-        DerivableImpls {
-            msrv: conf.msrv.clone(),
-        }
+        DerivableImpls { msrv: conf.msrv }
     }
 }
 
@@ -205,11 +203,9 @@ impl<'tcx> LateLintPass<'tcx> for DerivableImpls {
         {
             if adt_def.is_struct() {
                 check_struct(cx, item, self_ty, func_expr, adt_def, args, cx.tcx.typeck_body(*b));
-            } else if adt_def.is_enum() && self.msrv.meets(msrvs::DEFAULT_ENUM_ATTRIBUTE) {
+            } else if adt_def.is_enum() && self.msrv.meets(cx, msrvs::DEFAULT_ENUM_ATTRIBUTE) {
                 check_enum(cx, item, func_expr, adt_def);
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/disallowed_macros.rs b/src/tools/clippy/clippy_lints/src/disallowed_macros.rs
index 4e8853821c3e..4b8a689e9947 100644
--- a/src/tools/clippy/clippy_lints/src/disallowed_macros.rs
+++ b/src/tools/clippy/clippy_lints/src/disallowed_macros.rs
@@ -1,9 +1,9 @@
+
 use clippy_config::Conf;
-use clippy_config::types::create_disallowed_map;
+use clippy_config::types::{DisallowedPath, create_disallowed_map};
 use clippy_utils::diagnostics::{span_lint_and_then, span_lint_hir_and_then};
 use clippy_utils::macros::macro_backtrace;
 use rustc_data_structures::fx::FxHashSet;
-use rustc_errors::Diag;
 use rustc_hir::def_id::DefIdMap;
 use rustc_hir::{
     AmbigArg, Expr, ExprKind, ForeignItem, HirId, ImplItem, Item, ItemKind, OwnerId, Pat, Path, Stmt, TraitItem, Ty,
@@ -59,7 +59,7 @@ declare_clippy_lint! {
 }
 
 pub struct DisallowedMacros {
-    disallowed: DefIdMap<(&'static str, Option<&'static str>)>,
+    disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
     seen: FxHashSet<ExpnId>,
     // Track the most recently seen node that can have a `derive` attribute.
     // Needed to use the correct lint level.
@@ -90,13 +90,9 @@ impl DisallowedMacros {
                 return;
             }
 
-            if let Some(&(path, reason)) = self.disallowed.get(&mac.def_id) {
+            if let Some(&(path, disallowed_path)) = self.disallowed.get(&mac.def_id) {
                 let msg = format!("use of a disallowed macro `{path}`");
-                let add_note = |diag: &mut Diag<'_, _>| {
-                    if let Some(reason) = reason {
-                        diag.note(reason);
-                    }
-                };
+                let add_note = disallowed_path.diag_amendment(mac.span);
                 if matches!(mac.kind, MacroKind::Derive)
                     && let Some(derive_src) = derive_src
                 {
diff --git a/src/tools/clippy/clippy_lints/src/disallowed_methods.rs b/src/tools/clippy/clippy_lints/src/disallowed_methods.rs
index c4ed118b7c9f..149cf1cf2def 100644
--- a/src/tools/clippy/clippy_lints/src/disallowed_methods.rs
+++ b/src/tools/clippy/clippy_lints/src/disallowed_methods.rs
@@ -1,5 +1,5 @@
 use clippy_config::Conf;
-use clippy_config::types::create_disallowed_map;
+use clippy_config::types::{DisallowedPath, create_disallowed_map};
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_hir::def::{CtorKind, DefKind, Res};
 use rustc_hir::def_id::DefIdMap;
@@ -31,6 +31,8 @@ declare_clippy_lint! {
     ///     # When using an inline table, can add a `reason` for why the method
     ///     # is disallowed.
     ///     { path = "std::vec::Vec::leak", reason = "no leaking memory" },
+    ///     # Can also add a `replacement` that will be offered as a suggestion.
+    ///     { path = "std::sync::Mutex::new", reason = "prefer faster & simpler non-poisonable mutex", replacement = "parking_lot::Mutex::new" },
     /// ]
     /// ```
     ///
@@ -56,7 +58,7 @@ declare_clippy_lint! {
 }
 
 pub struct DisallowedMethods {
-    disallowed: DefIdMap<(&'static str, Option<&'static str>)>,
+    disallowed: DefIdMap<(&'static str, &'static DisallowedPath)>,
 }
 
 impl DisallowedMethods {
@@ -83,17 +85,13 @@ impl<'tcx> LateLintPass<'tcx> for DisallowedMethods {
             },
             _ => return,
         };
-        if let Some(&(path, reason)) = self.disallowed.get(&id) {
+        if let Some(&(path, disallowed_path)) = self.disallowed.get(&id) {
             span_lint_and_then(
                 cx,
                 DISALLOWED_METHODS,
                 span,
                 format!("use of a disallowed method `{path}`"),
-                |diag| {
-                    if let Some(reason) = reason {
-                        diag.note(reason);
-                    }
-                },
+                disallowed_path.diag_amendment(span),
             );
         }
     }
diff --git a/src/tools/clippy/clippy_lints/src/disallowed_types.rs b/src/tools/clippy/clippy_lints/src/disallowed_types.rs
index 947677e14bd0..3659946b7042 100644
--- a/src/tools/clippy/clippy_lints/src/disallowed_types.rs
+++ b/src/tools/clippy/clippy_lints/src/disallowed_types.rs
@@ -1,4 +1,5 @@
 use clippy_config::Conf;
+use clippy_config::types::DisallowedPath;
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_data_structures::fx::FxHashMap;
 use rustc_hir::def::Res;
@@ -31,6 +32,8 @@ declare_clippy_lint! {
     ///     # When using an inline table, can add a `reason` for why the type
     ///     # is disallowed.
     ///     { path = "std::net::Ipv4Addr", reason = "no IPv4 allowed" },
+    ///     # Can also add a `replacement` that will be offered as a suggestion.
+    ///     { path = "std::sync::Mutex", reason = "prefer faster & simpler non-poisonable mutex", replacement = "parking_lot::Mutex" },
     /// ]
     /// ```
     ///
@@ -51,24 +54,23 @@ declare_clippy_lint! {
 }
 
 pub struct DisallowedTypes {
-    def_ids: DefIdMap<(&'static str, Option<&'static str>)>,
-    prim_tys: FxHashMap<PrimTy, (&'static str, Option<&'static str>)>,
+    def_ids: DefIdMap<(&'static str, &'static DisallowedPath)>,
+    prim_tys: FxHashMap<PrimTy, (&'static str, &'static DisallowedPath)>,
 }
 
 impl DisallowedTypes {
     pub fn new(tcx: TyCtxt<'_>, conf: &'static Conf) -> Self {
         let mut def_ids = DefIdMap::default();
         let mut prim_tys = FxHashMap::default();
-        for x in &conf.disallowed_types {
-            let path: Vec<_> = x.path().split("::").collect::<Vec<_>>();
-            let reason = x.reason();
+        for disallowed_path in &conf.disallowed_types {
+            let path: Vec<_> = disallowed_path.path().split("::").collect::<Vec<_>>();
             for res in clippy_utils::def_path_res(tcx, &path) {
                 match res {
                     Res::Def(_, id) => {
-                        def_ids.insert(id, (x.path(), reason));
+                        def_ids.insert(id, (disallowed_path.path(), disallowed_path));
                     },
                     Res::PrimTy(ty) => {
-                        prim_tys.insert(ty, (x.path(), reason));
+                        prim_tys.insert(ty, (disallowed_path.path(), disallowed_path));
                     },
                     _ => {},
                 }
@@ -78,7 +80,7 @@ impl DisallowedTypes {
     }
 
     fn check_res_emit(&self, cx: &LateContext<'_>, res: &Res, span: Span) {
-        let (path, reason) = match res {
+        let (path, disallowed_path) = match res {
             Res::Def(_, did) if let Some(&x) = self.def_ids.get(did) => x,
             Res::PrimTy(prim) if let Some(&x) = self.prim_tys.get(prim) => x,
             _ => return,
@@ -88,11 +90,7 @@ impl DisallowedTypes {
             DISALLOWED_TYPES,
             span,
             format!("use of a disallowed type `{path}`"),
-            |diag| {
-                if let Some(reason) = reason {
-                    diag.note(reason);
-                }
-            },
+            disallowed_path.diag_amendment(span),
         );
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs b/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs
index 4b40fc0b1ee2..bca1cd03bb7e 100644
--- a/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/include_in_doc_without_cfg.rs
@@ -1,18 +1,17 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::AttrStyle;
+use rustc_ast::{AttrArgs, AttrKind, AttrStyle, Attribute};
 use rustc_errors::Applicability;
-use rustc_hir::{AttrArgs, AttrKind, Attribute};
-use rustc_lint::LateContext;
+use rustc_lint::EarlyContext;
 
 use super::DOC_INCLUDE_WITHOUT_CFG;
 
-pub fn check(cx: &LateContext<'_>, attrs: &[Attribute]) {
+pub fn check(cx: &EarlyContext<'_>, attrs: &[Attribute]) {
     for attr in attrs {
         if !attr.span.from_expansion()
             && let AttrKind::Normal(ref item) = attr.kind
             && attr.doc_str().is_some()
-            && let AttrArgs::Eq { expr: meta, .. } = &item.args
+            && let AttrArgs::Eq { expr: meta, .. } = &item.item.args
             && !attr.span.contains(meta.span)
             // Since the `include_str` is already expanded at this point, we can only take the
             // whole attribute snippet and then modify for our suggestion.
diff --git a/src/tools/clippy/clippy_lints/src/doc/lazy_continuation.rs b/src/tools/clippy/clippy_lints/src/doc/lazy_continuation.rs
index 2577324f23df..8aeb835fe393 100644
--- a/src/tools/clippy/clippy_lints/src/doc/lazy_continuation.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/lazy_continuation.rs
@@ -16,7 +16,6 @@ fn map_container_to_text(c: &super::Container) -> &'static str {
     }
 }
 
-// TODO: Adjust the parameters as necessary
 pub(super) fn check(
     cx: &LateContext<'_>,
     doc: &str,
diff --git a/src/tools/clippy/clippy_lints/src/doc/mod.rs b/src/tools/clippy/clippy_lints/src/doc/mod.rs
index 713d62a8801d..0296ff13112f 100644
--- a/src/tools/clippy/clippy_lints/src/doc/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/mod.rs
@@ -20,7 +20,7 @@ use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::{self, Visitor};
 use rustc_hir::{AnonConst, Attribute, Expr, ImplItemKind, ItemKind, Node, Safety, TraitItemKind};
-use rustc_lint::{LateContext, LateLintPass, LintContext};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass, LintContext};
 use rustc_middle::hir::nested_filter;
 use rustc_middle::ty;
 use rustc_resolve::rustdoc::{
@@ -82,6 +82,28 @@ declare_clippy_lint! {
     "presence of `_`, `::` or camel-case outside backticks in documentation"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for links with code directly adjacent to code text:
+    /// `` [`MyItem`]`<`[`u32`]`>` ``.
+    ///
+    /// ### Why is this bad?
+    /// It can be written more simply using HTML-style `<code>` tags.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// //! [`first`](x)`second`
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// //! <code>[first](x)second</code>
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub DOC_LINK_CODE,
+    nursery,
+    "link with code back-to-back with other code"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for the doc comments of publicly visible
@@ -453,7 +475,7 @@ declare_clippy_lint! {
     /// ///   and this line is overindented.
     /// # fn foo() {}
     /// ```
-    #[clippy::version = "1.80.0"]
+    #[clippy::version = "1.86.0"]
     pub DOC_OVERINDENTED_LIST_ITEMS,
     style,
     "ensure list items are not overindented"
@@ -513,7 +535,7 @@ declare_clippy_lint! {
     /// ```no_run
     /// #![cfg_attr(doc, doc = include_str!("some_file.md"))]
     /// ```
-    #[clippy::version = "1.84.0"]
+    #[clippy::version = "1.85.0"]
     pub DOC_INCLUDE_WITHOUT_CFG,
     restriction,
     "check if files included in documentation are behind `cfg(doc)`"
@@ -539,7 +561,7 @@ declare_clippy_lint! {
     /// //!
     /// //! [link]: destination (for link reference definition)
     /// ```
-    #[clippy::version = "1.84.0"]
+    #[clippy::version = "1.85.0"]
     pub DOC_NESTED_REFDEFS,
     suspicious,
     "link reference defined in list item or quote"
@@ -560,6 +582,7 @@ impl Documentation {
 }
 
 impl_lint_pass!(Documentation => [
+    DOC_LINK_CODE,
     DOC_LINK_WITH_QUOTES,
     DOC_MARKDOWN,
     DOC_NESTED_REFDEFS,
@@ -577,6 +600,12 @@ impl_lint_pass!(Documentation => [
     DOC_INCLUDE_WITHOUT_CFG,
 ]);
 
+impl EarlyLintPass for Documentation {
+    fn check_attributes(&mut self, cx: &EarlyContext<'_>, attrs: &[rustc_ast::Attribute]) {
+        include_in_doc_without_cfg::check(cx, attrs);
+    }
+}
+
 impl<'tcx> LateLintPass<'tcx> for Documentation {
     fn check_attributes(&mut self, cx: &LateContext<'tcx>, attrs: &'tcx [Attribute]) {
         let Some(headers) = check_attrs(cx, &self.valid_idents, attrs) else {
@@ -704,14 +733,13 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
         Some(("fake".into(), "fake".into()))
     }
 
-    include_in_doc_without_cfg::check(cx, attrs);
     if suspicious_doc_comments::check(cx, attrs) || is_doc_hidden(attrs) {
         return None;
     }
 
     let (fragments, _) = attrs_to_doc_fragments(
         attrs.iter().filter_map(|attr| {
-            if attr.span.in_external_macro(cx.sess().source_map()) {
+            if attr.doc_str_and_comment_kind().is_none() || attr.span().in_external_macro(cx.sess().source_map()) {
                 None
             } else {
                 Some((attr, None))
@@ -741,6 +769,21 @@ fn check_attrs(cx: &LateContext<'_>, valid_idents: &FxHashSet<String>, attrs: &[
 
     let mut cb = fake_broken_link_callback;
 
+    check_for_code_clusters(
+        cx,
+        pulldown_cmark::Parser::new_with_broken_link_callback(
+            &doc,
+            main_body_opts() - Options::ENABLE_SMART_PUNCTUATION,
+            Some(&mut cb),
+        )
+        .into_offset_iter(),
+        &doc,
+        Fragments {
+            doc: &doc,
+            fragments: &fragments,
+        },
+    );
+
     // disable smart punctuation to pick up ['link'] more easily
     let opts = main_body_opts() - Options::ENABLE_SMART_PUNCTUATION;
     let parser = pulldown_cmark::Parser::new_with_broken_link_callback(&doc, opts, Some(&mut cb));
@@ -764,6 +807,66 @@ enum Container {
     List(usize),
 }
 
+/// Scan the documentation for code links that are back-to-back with code spans.
+///
+/// This is done separately from the rest of the docs, because that makes it easier to produce
+/// the correct messages.
+fn check_for_code_clusters<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize>)>>(
+    cx: &LateContext<'_>,
+    events: Events,
+    doc: &str,
+    fragments: Fragments<'_>,
+) {
+    let mut events = events.peekable();
+    let mut code_starts_at = None;
+    let mut code_ends_at = None;
+    let mut code_includes_link = false;
+    while let Some((event, range)) = events.next() {
+        match event {
+            Start(Link { .. }) if matches!(events.peek(), Some((Code(_), _range))) => {
+                if code_starts_at.is_some() {
+                    code_ends_at = Some(range.end);
+                } else {
+                    code_starts_at = Some(range.start);
+                }
+                code_includes_link = true;
+                // skip the nested "code", because we're already handling it here
+                let _ = events.next();
+            },
+            Code(_) => {
+                if code_starts_at.is_some() {
+                    code_ends_at = Some(range.end);
+                } else {
+                    code_starts_at = Some(range.start);
+                }
+            },
+            End(TagEnd::Link) => {},
+            _ => {
+                if let Some(start) = code_starts_at
+                    && let Some(end) = code_ends_at
+                    && code_includes_link
+                {
+                    if let Some(span) = fragments.span(cx, start..end) {
+                        span_lint_and_then(cx, DOC_LINK_CODE, span, "code link adjacent to code text", |diag| {
+                            let sugg = format!("<code>{}</code>", doc[start..end].replace('`', ""));
+                            diag.span_suggestion_verbose(
+                                span,
+                                "wrap the entire group in `<code>` tags",
+                                sugg,
+                                Applicability::MaybeIncorrect,
+                            );
+                            diag.help("separate code snippets will be shown with a gap");
+                        });
+                    }
+                }
+                code_includes_link = false;
+                code_starts_at = None;
+                code_ends_at = None;
+            },
+        }
+    }
+}
+
 /// Checks parsed documentation.
 /// This walks the "events" (think sections of markdown) produced by `pulldown_cmark`,
 /// so lints here will generally access that information.
@@ -906,7 +1009,12 @@ fn check_doc<'a, Events: Iterator<Item = (pulldown_cmark::Event<'a>, Range<usize
                                 // backslashes aren't in the event stream...
                                 start -= 1;
                             }
-                            start - range.start
+
+                            if start > range.start {
+                                start - range.start
+                            } else {
+                                0
+                            }
                         }
                     } else {
                         0
@@ -1086,6 +1194,10 @@ impl<'tcx> Visitor<'tcx> for FindPanicUnwrap<'_, 'tcx> {
 
 #[expect(clippy::range_plus_one)] // inclusive ranges aren't the same type
 fn looks_like_refdef(doc: &str, range: Range<usize>) -> Option<Range<usize>> {
+    if range.end < range.start {
+        return None;
+    }
+
     let offset = range.start;
     let mut iterator = doc.as_bytes()[range].iter().copied().enumerate();
     let mut start = None;
diff --git a/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs b/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs
index ce5beab24bfa..3008082c2329 100644
--- a/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/needless_doctest_main.rs
@@ -1,6 +1,6 @@
 use std::ops::Range;
-use std::{io, thread};
 use std::sync::Arc;
+use std::{io, thread};
 
 use crate::doc::{NEEDLESS_DOCTEST_MAIN, TEST_ATTR_IN_DOCTEST};
 use clippy_utils::diagnostics::span_lint;
diff --git a/src/tools/clippy/clippy_lints/src/doc/suspicious_doc_comments.rs b/src/tools/clippy/clippy_lints/src/doc/suspicious_doc_comments.rs
index 84393213e6f0..9637546b8680 100644
--- a/src/tools/clippy/clippy_lints/src/doc/suspicious_doc_comments.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/suspicious_doc_comments.rs
@@ -1,6 +1,7 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use rustc_ast::AttrStyle;
 use rustc_ast::token::CommentKind;
+use rustc_attr_parsing::AttributeKind;
 use rustc_errors::Applicability;
 use rustc_hir::Attribute;
 use rustc_lint::LateContext;
@@ -36,15 +37,19 @@ fn collect_doc_replacements(attrs: &[Attribute]) -> Vec<(Span, String)> {
     attrs
         .iter()
         .filter_map(|attr| {
-            if let Some((sym, com_kind)) = attr.doc_str_and_comment_kind()
-                && let AttrStyle::Outer = attr.style
-                && let Some(com) = sym.as_str().strip_prefix('!')
+            if let Attribute::Parsed(AttributeKind::DocComment {
+                style: AttrStyle::Outer,
+                kind,
+                comment,
+                ..
+            }) = attr
+                && let Some(com) = comment.as_str().strip_prefix('!')
             {
-                let sugg = match com_kind {
+                let sugg = match kind {
                     CommentKind::Line => format!("//!{com}"),
                     CommentKind::Block => format!("/*!{com}*/"),
                 };
-                Some((attr.span, sugg))
+                Some((attr.span(), sugg))
             } else {
                 None
             }
diff --git a/src/tools/clippy/clippy_lints/src/doc/too_long_first_doc_paragraph.rs b/src/tools/clippy/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
index 1f89cab91480..dc6cbb425430 100644
--- a/src/tools/clippy/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
+++ b/src/tools/clippy/clippy_lints/src/doc/too_long_first_doc_paragraph.rs
@@ -1,3 +1,4 @@
+use rustc_attr_parsing::AttributeKind;
 use rustc_errors::Applicability;
 use rustc_hir::{Attribute, Item, ItemKind};
 use rustc_lint::LateContext;
@@ -43,15 +44,19 @@ pub(super) fn check(
     let mut should_suggest_empty_doc = false;
 
     for attr in attrs {
-        if let Some(doc) = attr.doc_str() {
-            spans.push(attr.span);
-            let doc = doc.as_str();
+        if let Attribute::Parsed(AttributeKind::DocComment { span, comment, .. }) = attr {
+            spans.push(span);
+            let doc = comment.as_str();
             let doc = doc.trim();
             if spans.len() == 1 {
                 // We make this suggestion only if the first doc line ends with a punctuation
                 // because it might just need to add an empty line with `///`.
                 should_suggest_empty_doc = doc.ends_with('.') || doc.ends_with('!') || doc.ends_with('?');
+            } else if spans.len() == 2 {
+                // We make this suggestion only if the second doc line is not empty.
+                should_suggest_empty_doc &= !doc.is_empty();
             }
+
             let len = doc.chars().count();
             if len >= first_paragraph_len {
                 break;
@@ -78,7 +83,7 @@ pub(super) fn check(
                 && let new_span = first_span.with_hi(second_span.lo()).with_lo(first_span.hi())
                 && let Some(snippet) = snippet_opt(cx, new_span)
             {
-                let Some(first) = snippet_opt(cx, first_span) else {
+                let Some(first) = snippet_opt(cx, *first_span) else {
                     return;
                 };
                 let Some(comment_form) = first.get(..3) else {
diff --git a/src/tools/clippy/clippy_lints/src/empty_line_after.rs b/src/tools/clippy/clippy_lints/src/empty_line_after.rs
index 578ff6e38a6a..80c2b03c41cf 100644
--- a/src/tools/clippy/clippy_lints/src/empty_line_after.rs
+++ b/src/tools/clippy/clippy_lints/src/empty_line_after.rs
@@ -289,10 +289,13 @@ impl EmptyLineAfter {
             format!("empty {lines} after {kind_desc}"),
             |diag| {
                 let info = self.items.last().unwrap();
-                diag.span_label(info.span, match kind {
-                    StopKind::Attr => format!("the attribute applies to this {}", info.kind),
-                    StopKind::Doc(_) => format!("the comment documents this {}", info.kind),
-                });
+                diag.span_label(
+                    info.span,
+                    match kind {
+                        StopKind::Attr => format!("the attribute applies to this {}", info.kind),
+                        StopKind::Doc(_) => format!("the comment documents this {}", info.kind),
+                    },
+                );
 
                 diag.multipart_suggestion_with_style(
                     format!("if the empty {lines} {are} unintentional, remove {them}"),
diff --git a/src/tools/clippy/clippy_lints/src/entry.rs b/src/tools/clippy/clippy_lints/src/entry.rs
index 2bec4f2f99e5..f404bc59b3b8 100644
--- a/src/tools/clippy/clippy_lints/src/entry.rs
+++ b/src/tools/clippy/clippy_lints/src/entry.rs
@@ -1,5 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::{reindent_multiline, snippet_indent, snippet_with_applicability, snippet_with_context};
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{
     SpanlessEq, can_move_expr_to_closure_no_visit, higher, is_expr_final_block_expr, is_expr_used_or_unified,
     peel_hir_expr_while,
@@ -7,11 +8,12 @@ use clippy_utils::{
 use core::fmt::{self, Write};
 use rustc_errors::Applicability;
 use rustc_hir::hir_id::HirIdSet;
-use rustc_hir::intravisit::{Visitor, walk_expr};
+use rustc_hir::intravisit::{Visitor, walk_body, walk_expr};
 use rustc_hir::{Block, Expr, ExprKind, HirId, Pat, Stmt, StmtKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::{DUMMY_SP, Span, SyntaxContext, sym};
+use std::ops::ControlFlow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -135,8 +137,8 @@ impl<'tcx> LateLintPass<'tcx> for HashMapPass {
                 format!(
                     "match {map_str}.entry({key_str}) {{\n{indent_str}    {entry}::{then_entry} => {}\n\
                         {indent_str}    {entry}::{else_entry} => {}\n{indent_str}}}",
-                    reindent_multiline(then_str.into(), true, Some(4 + indent_str.len())),
-                    reindent_multiline(else_str.into(), true, Some(4 + indent_str.len())),
+                    reindent_multiline(&then_str, true, Some(4 + indent_str.len())),
+                    reindent_multiline(&else_str, true, Some(4 + indent_str.len())),
                     entry = map_ty.entry_path(),
                 )
             }
@@ -329,7 +331,7 @@ impl<'tcx> Edit<'tcx> {
         if let Self::Insertion(i) = self { Some(i) } else { None }
     }
 }
-#[derive(Clone, Copy)]
+#[derive(Clone, Copy, Debug)]
 struct Insertion<'tcx> {
     call: &'tcx Expr<'tcx>,
     value: &'tcx Expr<'tcx>,
@@ -500,7 +502,7 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
                 self.visit_non_tail_expr(insert_expr.value);
                 self.is_single_insert = is_single_insert;
             },
-            _ if SpanlessEq::new(self.cx).eq_expr(self.map, expr) => {
+            _ if is_any_expr_in_map_used(self.cx, self.map, expr) => {
                 self.is_map_used = true;
             },
             _ => match expr.kind {
@@ -542,6 +544,7 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
                 ExprKind::InlineAsm(_) => {
                     self.can_use_entry = false;
                 },
+                ExprKind::Closure(closure) => walk_body(self, self.cx.tcx.hir_body(closure.body)),
                 _ => {
                     self.allow_insert_closure &= !self.in_tail_pos;
                     self.allow_insert_closure &=
@@ -562,6 +565,19 @@ impl<'tcx> Visitor<'tcx> for InsertSearcher<'_, 'tcx> {
     }
 }
 
+/// Check if the given expression is used for each sub-expression in the given map.
+/// For example, in map `a.b.c.my_map`, The expression `a.b.c.my_map`, `a.b.c`, `a.b`, and `a` are
+/// all checked.
+fn is_any_expr_in_map_used<'tcx>(cx: &LateContext<'tcx>, map: &'tcx Expr<'tcx>, expr: &'tcx Expr<'tcx>) -> bool {
+    for_each_expr(cx, map, |e| {
+        if SpanlessEq::new(cx).eq_expr(e, expr) {
+            return ControlFlow::Break(());
+        }
+        ControlFlow::Continue(())
+    })
+    .is_some()
+}
+
 struct InsertSearchResults<'tcx> {
     edits: Vec<Edit<'tcx>>,
     allow_insert_closure: bool,
diff --git a/src/tools/clippy/clippy_lints/src/escape.rs b/src/tools/clippy/clippy_lints/src/escape.rs
index 0c06c9117d73..8d1e893cb1af 100644
--- a/src/tools/clippy/clippy_lints/src/escape.rs
+++ b/src/tools/clippy/clippy_lints/src/escape.rs
@@ -1,5 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_hir;
+use rustc_abi::ExternAbi;
 use rustc_hir::{AssocItemKind, Body, FnDecl, HirId, HirIdSet, Impl, ItemKind, Node, Pat, PatKind, intravisit};
 use rustc_hir_typeck::expr_use_visitor::{Delegate, ExprUseVisitor, PlaceBase, PlaceWithHirId};
 use rustc_lint::{LateContext, LateLintPass};
@@ -10,7 +11,6 @@ use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
-use rustc_abi::ExternAbi;
 
 pub struct BoxedLocal {
     too_large_for_stack: u64,
diff --git a/src/tools/clippy/clippy_lints/src/eta_reduction.rs b/src/tools/clippy/clippy_lints/src/eta_reduction.rs
index d1782d582f4d..645f93068496 100644
--- a/src/tools/clippy/clippy_lints/src/eta_reduction.rs
+++ b/src/tools/clippy/clippy_lints/src/eta_reduction.rs
@@ -6,6 +6,7 @@ use clippy_utils::usage::{local_used_after_expr, local_used_in};
 use clippy_utils::{
     get_path_from_caller_to_method_type, is_adjusted, is_no_std_crate, path_to_local, path_to_local_id,
 };
+use rustc_abi::ExternAbi;
 use rustc_errors::Applicability;
 use rustc_hir::{BindingMode, Expr, ExprKind, FnRetTy, GenericArgs, Param, PatKind, QPath, Safety, TyKind};
 use rustc_infer::infer::TyCtxtInferExt;
@@ -15,7 +16,6 @@ use rustc_middle::ty::{
 };
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::sym;
-use rustc_abi::ExternAbi;
 use rustc_trait_selection::error_reporting::InferCtxtErrorExt as _;
 
 declare_clippy_lint! {
diff --git a/src/tools/clippy/clippy_lints/src/excessive_bools.rs b/src/tools/clippy/clippy_lints/src/excessive_bools.rs
index 15afe3e8c145..54a1ac21c85c 100644
--- a/src/tools/clippy/clippy_lints/src/excessive_bools.rs
+++ b/src/tools/clippy/clippy_lints/src/excessive_bools.rs
@@ -1,13 +1,13 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::{get_parent_as_impl, has_repr_attr, is_bool};
+use rustc_abi::ExternAbi;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{Body, FnDecl, Item, ItemKind, TraitFn, TraitItem, TraitItemKind, Ty};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
-use rustc_abi::ExternAbi;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/format_args.rs b/src/tools/clippy/clippy_lints/src/format_args.rs
index da5825b7ab21..fc5f76179f90 100644
--- a/src/tools/clippy/clippy_lints/src/format_args.rs
+++ b/src/tools/clippy/clippy_lints/src/format_args.rs
@@ -1,26 +1,28 @@
 use arrayvec::ArrayVec;
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_and_then};
-use clippy_utils::is_diag_trait_item;
 use clippy_utils::macros::{
     FormatArgsStorage, FormatParamUsage, MacroCall, find_format_arg_expr, format_arg_removal_span,
     format_placeholder_format_span, is_assert_macro, is_format_macro, is_panic, matching_root_macro_call,
     root_macro_call_first_node,
 };
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::SpanRangeExt;
+use clippy_utils::source::{SpanRangeExt, snippet};
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
+use clippy_utils::{is_diag_trait_item, is_from_proc_macro};
 use itertools::Itertools;
 use rustc_ast::{
     FormatArgPosition, FormatArgPositionKind, FormatArgsPiece, FormatArgumentKind, FormatCount, FormatOptions,
     FormatPlaceholder, FormatTrait,
 };
+use rustc_attr_parsing::RustcVersion;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_errors::SuggestionStyle::{CompletelyHidden, ShowCode};
 use rustc_hir::{Expr, ExprKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass, LintContext};
-use rustc_middle::ty::Ty;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment};
+use rustc_middle::ty::{List, Ty, TyCtxt};
 use rustc_session::impl_lint_pass;
 use rustc_span::edition::Edition::Edition2021;
 use rustc_span::{Span, Symbol, sym};
@@ -50,6 +52,36 @@ declare_clippy_lint! {
     "`format!` used in a macro that does formatting"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `Debug` formatting (`{:?}`) applied to an `OsStr` or `Path`.
+    ///
+    /// ### 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.
+    ///
+    /// Furthermore, with `Debug` formatting, certain characters are escaped.
+    /// Thus, a `Debug` formatted `Path` is less likely to be clickable.
+    ///
+    /// ### 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());
+    /// ```
+    #[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! {
     /// ### What it does
     /// Checks for [`ToString::to_string`](https://doc.rust-lang.org/std/string/trait.ToString.html#tymethod.to_string)
@@ -162,31 +194,35 @@ declare_clippy_lint! {
     "use of a format specifier that has no effect"
 }
 
-impl_lint_pass!(FormatArgs => [
+impl_lint_pass!(FormatArgs<'_> => [
     FORMAT_IN_FORMAT_ARGS,
     TO_STRING_IN_FORMAT_ARGS,
     UNINLINED_FORMAT_ARGS,
+    UNNECESSARY_DEBUG_FORMATTING,
     UNUSED_FORMAT_SPECS,
 ]);
 
 #[allow(clippy::struct_field_names)]
-pub struct FormatArgs {
+pub struct FormatArgs<'tcx> {
     format_args: FormatArgsStorage,
     msrv: Msrv,
     ignore_mixed: bool,
+    ty_msrv_map: FxHashMap<Ty<'tcx>, Option<RustcVersion>>,
 }
 
-impl FormatArgs {
-    pub fn new(conf: &'static Conf, format_args: FormatArgsStorage) -> Self {
+impl<'tcx> FormatArgs<'tcx> {
+    pub fn new(tcx: TyCtxt<'tcx>, conf: &'static Conf, format_args: FormatArgsStorage) -> Self {
+        let ty_msrv_map = make_ty_msrv_map(tcx);
         Self {
             format_args,
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             ignore_mixed: conf.allow_mixed_uninlined_format_args,
+            ty_msrv_map,
         }
     }
 }
 
-impl<'tcx> LateLintPass<'tcx> for FormatArgs {
+impl<'tcx> LateLintPass<'tcx> for FormatArgs<'tcx> {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let Some(macro_call) = root_macro_call_first_node(cx, expr)
             && is_format_macro(cx, macro_call.def_id)
@@ -198,17 +234,17 @@ impl<'tcx> LateLintPass<'tcx> for FormatArgs {
                 macro_call: &macro_call,
                 format_args,
                 ignore_mixed: self.ignore_mixed,
+                msrv: &self.msrv,
+                ty_msrv_map: &self.ty_msrv_map,
             };
 
             linter.check_templates();
 
-            if self.msrv.meets(msrvs::FORMAT_ARGS_CAPTURE) {
+            if self.msrv.meets(cx, msrvs::FORMAT_ARGS_CAPTURE) {
                 linter.check_uninlined_args();
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 struct FormatArgsExpr<'a, 'tcx> {
@@ -217,9 +253,11 @@ struct FormatArgsExpr<'a, 'tcx> {
     macro_call: &'a MacroCall,
     format_args: &'a rustc_ast::FormatArgs,
     ignore_mixed: bool,
+    msrv: &'a Msrv,
+    ty_msrv_map: &'a FxHashMap<Ty<'tcx>, Option<RustcVersion>>,
 }
 
-impl FormatArgsExpr<'_, '_> {
+impl<'tcx> FormatArgsExpr<'_, 'tcx> {
     fn check_templates(&self) {
         for piece in &self.format_args.template {
             if let FormatArgsPiece::Placeholder(placeholder) = piece
@@ -237,6 +275,11 @@ impl FormatArgsExpr<'_, '_> {
                     self.check_format_in_format_args(name, arg_expr);
                     self.check_to_string_in_format_args(name, arg_expr);
                 }
+
+                if placeholder.format_trait == FormatTrait::Debug {
+                    let name = self.cx.tcx.item_name(self.macro_call.def_id);
+                    self.check_unnecessary_debug_formatting(name, arg_expr);
+                }
             }
         }
     }
@@ -439,6 +482,33 @@ impl FormatArgsExpr<'_, '_> {
         }
     }
 
+    fn check_unnecessary_debug_formatting(&self, name: Symbol, value: &Expr<'tcx>) {
+        let cx = self.cx;
+        if !value.span.from_expansion()
+            && !is_from_proc_macro(cx, value)
+            && let ty = cx.typeck_results().expr_ty(value)
+            && self.can_display_format(ty)
+        {
+            let snippet = snippet(cx.sess(), value.span, "..");
+            span_lint_and_then(
+                cx,
+                UNNECESSARY_DEBUG_FORMATTING,
+                value.span,
+                format!("unnecessary `Debug` formatting in `{name}!` args"),
+                |diag| {
+                    diag.help(format!(
+                        "use `Display` formatting and change this to `{snippet}.display()`"
+                    ));
+                    diag.note(
+                        "switching to `Display` formatting will change how the value is shown; \
+                         escaped characters will no longer be escaped and surrounding quotes will \
+                         be removed",
+                    );
+                },
+            );
+        }
+    }
+
     fn format_arg_positions(&self) -> impl Iterator<Item = (&FormatArgPosition, FormatParamUsage)> {
         self.format_args.template.iter().flat_map(|piece| match piece {
             FormatArgsPiece::Placeholder(placeholder) => {
@@ -465,6 +535,41 @@ impl FormatArgsExpr<'_, '_> {
             .at_most_one()
             .is_err()
     }
+
+    fn can_display_format(&self, ty: Ty<'tcx>) -> bool {
+        let ty = ty.peel_refs();
+
+        if let Some(msrv) = self.ty_msrv_map.get(&ty)
+            && msrv.is_none_or(|msrv| self.msrv.meets(self.cx, msrv))
+        {
+            return true;
+        }
+
+        // Even if `ty` is not in `self.ty_msrv_map`, check whether `ty` implements `Deref` with
+        // a `Target` that is in `self.ty_msrv_map`.
+        if let Some(deref_trait_id) = self.cx.tcx.lang_items().deref_trait()
+            && implements_trait(self.cx, ty, deref_trait_id, &[])
+            && let Some(target_ty) = self.cx.get_associated_type(ty, deref_trait_id, "Target")
+            && let Some(msrv) = self.ty_msrv_map.get(&target_ty)
+            && msrv.is_none_or(|msrv| self.msrv.meets(self.cx, msrv))
+        {
+            return true;
+        }
+
+        false
+    }
+}
+
+fn make_ty_msrv_map(tcx: TyCtxt<'_>) -> FxHashMap<Ty<'_>, Option<RustcVersion>> {
+    [(sym::OsStr, Some(msrvs::OS_STR_DISPLAY)), (sym::Path, None)]
+        .into_iter()
+        .filter_map(|(name, feature)| {
+            tcx.get_diagnostic_item(name).map(|def_id| {
+                let ty = Ty::new_adt(tcx, tcx.adt_def(def_id), List::empty());
+                (ty, feature)
+            })
+        })
+        .collect()
 }
 
 fn count_needed_derefs<'tcx, I>(mut ty: Ty<'tcx>, mut iter: I) -> (usize, Ty<'tcx>)
diff --git a/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs b/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs
index 0599e08e6c0a..0bdb99d7b9a4 100644
--- a/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs
+++ b/src/tools/clippy/clippy_lints/src/four_forward_slashes.rs
@@ -46,7 +46,8 @@ impl<'tcx> LateLintPass<'tcx> for FourForwardSlashes {
             .hir()
             .attrs(item.hir_id())
             .iter()
-            .fold(item.span.shrink_to_lo(), |span, attr| span.to(attr.span));
+            .filter(|i| i.is_doc_comment())
+            .fold(item.span.shrink_to_lo(), |span, attr| span.to(attr.span()));
         let (Some(file), _, _, end_line, _) = sm.span_to_location_info(span) else {
             return;
         };
diff --git a/src/tools/clippy/clippy_lints/src/from_over_into.rs b/src/tools/clippy/clippy_lints/src/from_over_into.rs
index 41bf6e81916a..6da5567d9c70 100644
--- a/src/tools/clippy/clippy_lints/src/from_over_into.rs
+++ b/src/tools/clippy/clippy_lints/src/from_over_into.rs
@@ -58,9 +58,7 @@ pub struct FromOverInto {
 
 impl FromOverInto {
     pub fn new(conf: &'static Conf) -> Self {
-        FromOverInto {
-            msrv: conf.msrv.clone(),
-        }
+        FromOverInto { msrv: conf.msrv }
     }
 }
 
@@ -77,12 +75,12 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
             && let Some(into_trait_seg) = hir_trait_ref.path.segments.last()
             // `impl Into<target_ty> for self_ty`
             && let Some(GenericArgs { args: [GenericArg::Type(target_ty)], .. }) = into_trait_seg.args
-            && self.msrv.meets(msrvs::RE_REBALANCING_COHERENCE)
             && span_is_local(item.span)
             && let Some(middle_trait_ref) = cx.tcx.impl_trait_ref(item.owner_id)
-                                                  .map(ty::EarlyBinder::instantiate_identity)
+            .map(ty::EarlyBinder::instantiate_identity)
             && cx.tcx.is_diagnostic_item(sym::Into, middle_trait_ref.def_id)
             && !matches!(middle_trait_ref.args.type_at(1).kind(), ty::Alias(ty::Opaque, _))
+            && self.msrv.meets(cx, msrvs::RE_REBALANCING_COHERENCE)
         {
             span_lint_and_then(
                 cx,
@@ -114,8 +112,6 @@ impl<'tcx> LateLintPass<'tcx> for FromOverInto {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 /// Finds the occurrences of `Self` and `self`
diff --git a/src/tools/clippy/clippy_lints/src/functions/mod.rs b/src/tools/clippy/clippy_lints/src/functions/mod.rs
index 243eb5cbfd40..5f3fc5100e75 100644
--- a/src/tools/clippy/clippy_lints/src/functions/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/mod.rs
@@ -471,7 +471,7 @@ impl Functions {
                 .iter()
                 .flat_map(|p| def_path_def_ids(tcx, &p.split("::").collect::<Vec<_>>()))
                 .collect(),
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
         }
     }
 }
@@ -521,12 +521,12 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
 
     fn check_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::Item<'_>) {
         must_use::check_item(cx, item);
-        result::check_item(cx, item, self.large_error_threshold, &self.msrv);
+        result::check_item(cx, item, self.large_error_threshold, self.msrv);
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'tcx>, item: &'tcx hir::ImplItem<'_>) {
         must_use::check_impl_item(cx, item);
-        result::check_impl_item(cx, item, self.large_error_threshold, &self.msrv);
+        result::check_impl_item(cx, item, self.large_error_threshold, self.msrv);
         impl_trait_in_params::check_impl_item(cx, item);
         renamed_function_params::check_impl_item(cx, item, &self.trait_ids);
     }
@@ -535,10 +535,8 @@ impl<'tcx> LateLintPass<'tcx> for Functions {
         too_many_arguments::check_trait_item(cx, item, self.too_many_arguments_threshold);
         not_unsafe_ptr_arg_deref::check_trait_item(cx, item);
         must_use::check_trait_item(cx, item);
-        result::check_trait_item(cx, item, self.large_error_threshold, &self.msrv);
+        result::check_trait_item(cx, item, self.large_error_threshold, self.msrv);
         impl_trait_in_params::check_trait_item(cx, item, self.avoid_breaking_exported_api);
         ref_option::check_trait_item(cx, item, self.avoid_breaking_exported_api);
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/functions/must_use.rs b/src/tools/clippy/clippy_lints/src/functions/must_use.rs
index e6e3ea59a9f6..f1c9657f2240 100644
--- a/src/tools/clippy/clippy_lints/src/functions/must_use.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/must_use.rs
@@ -95,6 +95,7 @@ pub(super) fn check_trait_item<'tcx>(cx: &LateContext<'tcx>, item: &'tcx hir::Tr
     }
 }
 
+// FIXME: needs to be an EARLY LINT. all attribute lints should be
 #[allow(clippy::too_many_arguments)]
 fn check_needless_must_use(
     cx: &LateContext<'_>,
@@ -117,38 +118,27 @@ fn check_needless_must_use(
                 fn_header_span,
                 "this unit-returning function has a `#[must_use]` attribute",
                 |diag| {
-                    diag.span_suggestion(attr.span, "remove the attribute", "", Applicability::MachineApplicable);
+                    diag.span_suggestion(
+                        attr.span(),
+                        "remove the attribute",
+                        "",
+                        Applicability::MachineApplicable,
+                    );
                 },
             );
         } else {
             // When there are multiple attributes, it is not sufficient to simply make `must_use` empty, see
             // issue #12320.
-            span_lint_and_then(
+            // FIXME(jdonszelmann): this used to give a machine-applicable fix. However, it was super fragile,
+            // honestly looked incorrect, and is a little hard to support for a little bit now. Some day this
+            // could be re-added.
+            span_lint_and_help(
                 cx,
                 MUST_USE_UNIT,
                 fn_header_span,
                 "this unit-returning function has a `#[must_use]` attribute",
-                |diag| {
-                    let mut attrs_without_must_use = attrs.to_vec();
-                    attrs_without_must_use.retain(|a| a.id != attr.id);
-                    let sugg_str = attrs_without_must_use
-                        .iter()
-                        .map(|a| {
-                            if a.value_str().is_none() {
-                                return a.name_or_empty().to_string();
-                            }
-                            format!("{} = \"{}\"", a.name_or_empty(), a.value_str().unwrap())
-                        })
-                        .collect::<Vec<_>>()
-                        .join(", ");
-
-                    diag.span_suggestion(
-                        attrs[0].span.with_hi(attrs[attrs.len() - 1].span.hi()),
-                        "change these attributes to",
-                        sugg_str,
-                        Applicability::MachineApplicable,
-                    );
-                },
+                Some(attr.span()),
+                "remove `must_use`",
             );
         }
     } else if attr.value_str().is_none() && is_must_use_ty(cx, return_ty(cx, item_id)) {
diff --git a/src/tools/clippy/clippy_lints/src/functions/result.rs b/src/tools/clippy/clippy_lints/src/functions/result.rs
index 74d365a72556..cade56f58226 100644
--- a/src/tools/clippy/clippy_lints/src/functions/result.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/result.rs
@@ -34,7 +34,7 @@ fn result_err_ty<'tcx>(
     }
 }
 
-pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::Item<'tcx>, large_err_threshold: u64, msrv: &Msrv) {
+pub(super) fn check_item<'tcx>(cx: &LateContext<'tcx>, item: &hir::Item<'tcx>, large_err_threshold: u64, msrv: Msrv) {
     if let hir::ItemKind::Fn { ref sig, .. } = item.kind
         && let Some((hir_ty, err_ty)) = result_err_ty(cx, sig.decl, item.owner_id.def_id, item.span)
     {
@@ -50,7 +50,7 @@ pub(super) fn check_impl_item<'tcx>(
     cx: &LateContext<'tcx>,
     item: &hir::ImplItem<'tcx>,
     large_err_threshold: u64,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     // Don't lint if method is a trait's implementation, we can't do anything about those
     if let hir::ImplItemKind::Fn(ref sig, _) = item.kind
@@ -69,7 +69,7 @@ pub(super) fn check_trait_item<'tcx>(
     cx: &LateContext<'tcx>,
     item: &hir::TraitItem<'tcx>,
     large_err_threshold: u64,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if let hir::TraitItemKind::Fn(ref sig, _) = item.kind {
         let fn_header_span = item.span.with_hi(sig.decl.output.span().hi());
@@ -82,8 +82,8 @@ pub(super) fn check_trait_item<'tcx>(
     }
 }
 
-fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header_span: Span, msrv: &Msrv) {
-    if err_ty.is_unit() && (!is_no_std_crate(cx) || msrv.meets(msrvs::ERROR_IN_CORE)) {
+fn check_result_unit_err(cx: &LateContext<'_>, err_ty: Ty<'_>, fn_header_span: Span, msrv: Msrv) {
+    if err_ty.is_unit() && (!is_no_std_crate(cx) || msrv.meets(cx, msrvs::ERROR_IN_CORE)) {
         span_lint_and_help(
             cx,
             RESULT_UNIT_ERR,
diff --git a/src/tools/clippy/clippy_lints/src/functions/too_many_arguments.rs b/src/tools/clippy/clippy_lints/src/functions/too_many_arguments.rs
index f17f687719f2..05dc47f6fe58 100644
--- a/src/tools/clippy/clippy_lints/src/functions/too_many_arguments.rs
+++ b/src/tools/clippy/clippy_lints/src/functions/too_many_arguments.rs
@@ -1,7 +1,7 @@
+use rustc_abi::ExternAbi;
 use rustc_hir::{self as hir, intravisit};
 use rustc_lint::LateContext;
 use rustc_span::Span;
-use rustc_abi::ExternAbi;
 
 use clippy_utils::diagnostics::span_lint;
 use clippy_utils::is_trait_impl_item;
@@ -23,11 +23,19 @@ pub(super) fn check_fn(
             intravisit::FnKind::Method(
                 _,
                 &hir::FnSig {
-                    header: hir::FnHeader { abi: ExternAbi::Rust, .. },
+                    header: hir::FnHeader {
+                        abi: ExternAbi::Rust, ..
+                    },
                     ..
                 },
             )
-            | intravisit::FnKind::ItemFn(_, _, hir::FnHeader { abi: ExternAbi::Rust, .. }) => check_arg_number(
+            | intravisit::FnKind::ItemFn(
+                _,
+                _,
+                hir::FnHeader {
+                    abi: ExternAbi::Rust, ..
+                },
+            ) => check_arg_number(
                 cx,
                 decl,
                 span.with_hi(decl.output.span().hi()),
diff --git a/src/tools/clippy/clippy_lints/src/if_not_else.rs b/src/tools/clippy/clippy_lints/src/if_not_else.rs
index 2806d4d0e5d6..45f9aa0a53e4 100644
--- a/src/tools/clippy/clippy_lints/src/if_not_else.rs
+++ b/src/tools/clippy/clippy_lints/src/if_not_else.rs
@@ -7,7 +7,6 @@ use rustc_hir::{BinOpKind, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
-use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -107,7 +106,7 @@ fn make_sugg<'a>(
     els_span: Span,
     default: &'a str,
     indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
+) -> String {
     let cond_inner_snip = snippet(sess, cond_inner, default);
     let els_snip = snippet(sess, els_span, default);
     let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
@@ -130,5 +129,5 @@ fn make_sugg<'a>(
         _ => String::new(),
     };
 
-    reindent_multiline(suggestion.into(), true, indent)
+    reindent_multiline(&suggestion, true, indent)
 }
diff --git a/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs b/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs
index 51e2944e6f99..fbbd33efd02d 100644
--- a/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs
+++ b/src/tools/clippy/clippy_lints/src/if_then_some_else_none.rs
@@ -54,9 +54,7 @@ pub struct IfThenSomeElseNone {
 
 impl IfThenSomeElseNone {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -79,10 +77,10 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             && !is_else_clause(cx.tcx, expr)
             && !is_in_const_context(cx)
             && !expr.span.in_external_macro(cx.sess().source_map())
-            && self.msrv.meets(msrvs::BOOL_THEN)
+            && self.msrv.meets(cx, msrvs::BOOL_THEN)
             && !contains_return(then_block.stmts)
         {
-            let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(msrvs::BOOL_THEN_SOME) {
+            let method_name = if switch_to_eager_eval(cx, expr) && self.msrv.meets(cx, msrvs::BOOL_THEN_SOME) {
                 "then_some"
             } else {
                 "then"
@@ -94,7 +92,7 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
                 expr.span,
                 format!("this could be simplified with `bool::{method_name}`"),
                 |diag| {
-                    let mut app = Applicability::Unspecified;
+                    let mut app = Applicability::MachineApplicable;
                     let cond_snip = Sugg::hir_with_context(cx, cond, expr.span.ctxt(), "[condition]", &mut app)
                         .maybe_par()
                         .to_string();
@@ -120,6 +118,4 @@ impl<'tcx> LateLintPass<'tcx> for IfThenSomeElseNone {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs b/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs
index 152d506a7c00..f2d16ff2e564 100644
--- a/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs
+++ b/src/tools/clippy/clippy_lints/src/implicit_saturating_sub.rs
@@ -83,9 +83,7 @@ impl_lint_pass!(ImplicitSaturatingSub => [IMPLICIT_SATURATING_SUB, INVERTED_SATU
 
 impl ImplicitSaturatingSub {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -108,12 +106,10 @@ impl<'tcx> LateLintPass<'tcx> for ImplicitSaturatingSub {
             && let ExprKind::Binary(ref cond_op, cond_left, cond_right) = cond.kind
         {
             check_manual_check(
-                cx, expr, cond_op, cond_left, cond_right, if_block, else_block, &self.msrv,
+                cx, expr, cond_op, cond_left, cond_right, if_block, else_block, self.msrv,
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -125,7 +121,7 @@ fn check_manual_check<'tcx>(
     right_hand: &Expr<'tcx>,
     if_block: &Expr<'tcx>,
     else_block: &Expr<'tcx>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     let ty = cx.typeck_results().expr_ty(left_hand);
     if ty.is_numeric() && !ty.is_signed() {
@@ -178,7 +174,7 @@ fn check_gt(
     little_var: &Expr<'_>,
     if_block: &Expr<'_>,
     else_block: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
     is_composited: bool,
 ) {
     if let Some(big_var) = Var::new(big_var)
@@ -221,7 +217,7 @@ fn check_subtraction(
     little_var: Var,
     if_block: &Expr<'_>,
     else_block: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
     is_composited: bool,
 ) {
     let if_block = peel_blocks(if_block);
@@ -258,7 +254,7 @@ fn check_subtraction(
             // if `snippet_opt` fails, it won't try the next conditions.
             if let Some(big_var_snippet) = snippet_opt(cx, big_var.span)
                 && let Some(little_var_snippet) = snippet_opt(cx, little_var.span)
-                && (!is_in_const_context(cx) || msrv.meets(msrvs::SATURATING_SUB_CONST))
+                && (!is_in_const_context(cx) || msrv.meets(cx, msrvs::SATURATING_SUB_CONST))
             {
                 let sugg = format!(
                     "{}{big_var_snippet}.saturating_sub({little_var_snippet}){}",
diff --git a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
index b10206dcd05e..12dfb14c454d 100644
--- a/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
+++ b/src/tools/clippy/clippy_lints/src/incompatible_msrv.rs
@@ -42,6 +42,7 @@ declare_clippy_lint! {
 pub struct IncompatibleMsrv {
     msrv: Msrv,
     is_above_msrv: FxHashMap<DefId, RustcVersion>,
+    check_in_tests: bool,
 }
 
 impl_lint_pass!(IncompatibleMsrv => [INCOMPATIBLE_MSRV]);
@@ -49,8 +50,9 @@ impl_lint_pass!(IncompatibleMsrv => [INCOMPATIBLE_MSRV]);
 impl IncompatibleMsrv {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             is_above_msrv: FxHashMap::default(),
+            check_in_tests: conf.check_incompatible_msrv_in_tests,
         }
     }
 
@@ -86,39 +88,30 @@ impl IncompatibleMsrv {
             // We don't check local items since their MSRV is supposed to always be valid.
             return;
         }
-        let version = self.get_def_id_version(cx.tcx, def_id);
-        if self.msrv.meets(version) || is_in_test(cx.tcx, node) {
-            return;
-        }
         if let ExpnKind::AstPass(_) | ExpnKind::Desugaring(_) = span.ctxt().outer_expn_data().kind {
             // Desugared expressions get to cheat and stability is ignored.
             // Intentionally not using `.from_expansion()`, since we do still care about macro expansions
             return;
         }
-        self.emit_lint_for(cx, span, version);
-    }
-
-    fn emit_lint_for(&self, cx: &LateContext<'_>, span: Span, version: RustcVersion) {
-        span_lint(
-            cx,
-            INCOMPATIBLE_MSRV,
-            span,
-            format!(
-                "current MSRV (Minimum Supported Rust Version) is `{}` but this item is stable since `{version}`",
-                self.msrv
-            ),
-        );
+        if (self.check_in_tests || !is_in_test(cx.tcx, node))
+            && let Some(current) = self.msrv.current(cx)
+            && let version = self.get_def_id_version(cx.tcx, def_id)
+            && version > current
+        {
+            span_lint(
+                cx,
+                INCOMPATIBLE_MSRV,
+                span,
+                format!(
+                    "current MSRV (Minimum Supported Rust Version) is `{current}` but this item is stable since `{version}`"
+                ),
+            );
+        }
     }
 }
 
 impl<'tcx> LateLintPass<'tcx> for IncompatibleMsrv {
-    extract_msrv_attr!(LateContext);
-
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if self.msrv.current().is_none() {
-            // If there is no MSRV, then no need to check anything...
-            return;
-        }
         match expr.kind {
             ExprKind::MethodCall(_, _, _, span) => {
                 if let Some(method_did) = cx.typeck_results().type_dependent_def_id(expr.hir_id) {
diff --git a/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs b/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs
index 39ff3c13bcce..5b58113169b1 100644
--- a/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs
+++ b/src/tools/clippy/clippy_lints/src/inconsistent_struct_constructor.rs
@@ -183,7 +183,7 @@ fn suggestion<'tcx>(
 
 fn field_with_attrs_span(tcx: TyCtxt<'_>, field: &hir::ExprField<'_>) -> Span {
     if let Some(attr) = tcx.hir().attrs(field.hir_id).first() {
-        field.span.with_lo(attr.span.lo())
+        field.span.with_lo(attr.span().lo())
     } else {
         field.span
     }
diff --git a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
index deac51ab4c49..d53e139de014 100644
--- a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
+++ b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
@@ -62,7 +62,7 @@ impl IndexRefutableSlice {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             max_suggested_slice: conf.max_suggested_slice_pattern_length,
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
         }
     }
 }
@@ -74,19 +74,17 @@ impl<'tcx> LateLintPass<'tcx> for IndexRefutableSlice {
         if let Some(IfLet { let_pat, if_then, .. }) = IfLet::hir(cx, expr)
             && (!expr.span.from_expansion() || is_expn_of(expr.span, "if_chain").is_some())
             && !is_lint_allowed(cx, INDEX_REFUTABLE_SLICE, expr.hir_id)
-            && self.msrv.meets(msrvs::SLICE_PATTERNS)
             && let found_slices = find_slice_values(cx, let_pat)
             && !found_slices.is_empty()
             && let filtered_slices = filter_lintable_slices(cx, found_slices, self.max_suggested_slice, if_then)
             && !filtered_slices.is_empty()
+            && self.msrv.meets(cx, msrvs::SLICE_PATTERNS)
         {
             for slice in filtered_slices.values() {
                 lint_slice(cx, slice);
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn find_slice_values(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> FxIndexMap<HirId, SliceLintInformation> {
diff --git a/src/tools/clippy/clippy_lints/src/inherent_to_string.rs b/src/tools/clippy/clippy_lints/src/inherent_to_string.rs
index c58e8773e3a2..1d582fb0223e 100644
--- a/src/tools/clippy/clippy_lints/src/inherent_to_string.rs
+++ b/src/tools/clippy/clippy_lints/src/inherent_to_string.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_help;
 use clippy_utils::ty::{implements_trait, is_type_lang_item};
 use clippy_utils::{return_ty, trait_ref_of_method};
+use rustc_abi::ExternAbi;
 use rustc_hir::{GenericParamKind, ImplItem, ImplItemKind, LangItem};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
-use rustc_abi::ExternAbi;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs b/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs
index 1b900f6be8e8..9b4a3b3f9c84 100644
--- a/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs
+++ b/src/tools/clippy/clippy_lints/src/inline_fn_without_body.rs
@@ -42,10 +42,10 @@ impl<'tcx> LateLintPass<'tcx> for InlineFnWithoutBody {
             span_lint_and_then(
                 cx,
                 INLINE_FN_WITHOUT_BODY,
-                attr.span,
+                attr.span(),
                 format!("use of `#[inline]` on trait method `{}` which has no body", item.ident),
                 |diag| {
-                    diag.suggest_remove_item(cx, attr.span, "remove", Applicability::MachineApplicable);
+                    diag.suggest_remove_item(cx, attr.span(), "remove", Applicability::MachineApplicable);
                 },
             );
         }
diff --git a/src/tools/clippy/clippy_lints/src/instant_subtraction.rs b/src/tools/clippy/clippy_lints/src/instant_subtraction.rs
index f4e41dc826b0..4ae1119ab3a2 100644
--- a/src/tools/clippy/clippy_lints/src/instant_subtraction.rs
+++ b/src/tools/clippy/clippy_lints/src/instant_subtraction.rs
@@ -70,9 +70,7 @@ pub struct InstantSubtraction {
 
 impl InstantSubtraction {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -99,14 +97,12 @@ impl LateLintPass<'_> for InstantSubtraction {
                 print_manual_instant_elapsed_sugg(cx, expr, sugg);
             } else if ty::is_type_diagnostic_item(cx, rhs_ty, sym::Duration)
                 && !expr.span.from_expansion()
-                && self.msrv.meets(msrvs::TRY_FROM)
+                && self.msrv.meets(cx, msrvs::TRY_FROM)
             {
                 print_unchecked_duration_subtraction_sugg(cx, lhs, rhs, expr);
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn is_instant_now_call(cx: &LateContext<'_>, expr_block: &'_ Expr<'_>) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs b/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs
index 1929fbded3b5..b42664340d1c 100644
--- a/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs
+++ b/src/tools/clippy/clippy_lints/src/invalid_upcast_comparisons.rs
@@ -22,9 +22,6 @@ declare_clippy_lint! {
     /// will mistakenly imply that it is possible for `x` to be outside the range of
     /// `u8`.
     ///
-    /// ### Known problems
-    /// https://github.com/rust-lang/rust-clippy/issues/886
-    ///
     /// ### Example
     /// ```no_run
     /// let x: u8 = 1;
diff --git a/src/tools/clippy/clippy_lints/src/large_include_file.rs b/src/tools/clippy/clippy_lints/src/large_include_file.rs
index f3d62b513e84..621a2af1d322 100644
--- a/src/tools/clippy/clippy_lints/src/large_include_file.rs
+++ b/src/tools/clippy/clippy_lints/src/large_include_file.rs
@@ -2,11 +2,11 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::macros::root_macro_call_first_node;
 use clippy_utils::source::snippet_opt;
-use rustc_ast::LitKind;
-use rustc_hir::{AttrArgs, AttrKind, Attribute, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_ast::{AttrArgs, AttrKind, Attribute, LitKind};
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
-use rustc_span::{Span, sym};
+use rustc_span::sym;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -52,24 +52,6 @@ impl LargeIncludeFile {
 
 impl_lint_pass!(LargeIncludeFile => [LARGE_INCLUDE_FILE]);
 
-impl LargeIncludeFile {
-    fn emit_lint(&self, cx: &LateContext<'_>, span: Span) {
-        #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
-        span_lint_and_then(
-            cx,
-            LARGE_INCLUDE_FILE,
-            span,
-            "attempted to include a large file",
-            |diag| {
-                diag.note(format!(
-                    "the configuration allows a maximum size of {} bytes",
-                    self.max_file_size
-                ));
-            },
-        );
-    }
-}
-
 impl LateLintPass<'_> for LargeIncludeFile {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &'_ Expr<'_>) {
         if let ExprKind::Lit(lit) = &expr.kind
@@ -85,18 +67,32 @@ impl LateLintPass<'_> for LargeIncludeFile {
             && (cx.tcx.is_diagnostic_item(sym::include_bytes_macro, macro_call.def_id)
                 || cx.tcx.is_diagnostic_item(sym::include_str_macro, macro_call.def_id))
         {
-            self.emit_lint(cx, expr.span.source_callsite());
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
+                cx,
+                LARGE_INCLUDE_FILE,
+                expr.span.source_callsite(),
+                "attempted to include a large file",
+                |diag| {
+                    diag.note(format!(
+                        "the configuration allows a maximum size of {} bytes",
+                        self.max_file_size
+                    ));
+                },
+            );
         }
     }
+}
 
-    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &Attribute) {
+impl EarlyLintPass for LargeIncludeFile {
+    fn check_attribute(&mut self, cx: &EarlyContext<'_>, attr: &Attribute) {
         if !attr.span.from_expansion()
             // Currently, rustc limits the usage of macro at the top-level of attributes,
             // so we don't need to recurse into each level.
             && let AttrKind::Normal(ref item) = attr.kind
             && let Some(doc) = attr.doc_str()
             && doc.as_str().len() as u64 > self.max_file_size
-            && let AttrArgs::Eq { expr: meta, .. } = &item.args
+            && let AttrArgs::Eq { expr: meta, .. } = &item.item.args
             && !attr.span.contains(meta.span)
             // Since the `include_str` is already expanded at this point, we can only take the
             // whole attribute snippet and then modify for our suggestion.
@@ -113,7 +109,19 @@ impl LateLintPass<'_> for LargeIncludeFile {
             && let sub_snippet = sub_snippet.trim()
             && (sub_snippet.starts_with("include_str!") || sub_snippet.starts_with("include_bytes!"))
         {
-            self.emit_lint(cx, attr.span);
+            #[expect(clippy::collapsible_span_lint_calls, reason = "rust-clippy#7797")]
+            span_lint_and_then(
+                cx,
+                LARGE_INCLUDE_FILE,
+                attr.span,
+                "attempted to include a large file",
+                |diag| {
+                    diag.note(format!(
+                        "the configuration allows a maximum size of {} bytes",
+                        self.max_file_size
+                    ));
+                },
+            );
         }
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/legacy_numeric_constants.rs b/src/tools/clippy/clippy_lints/src/legacy_numeric_constants.rs
index 6f2ce04e8f8e..3939318bee6e 100644
--- a/src/tools/clippy/clippy_lints/src/legacy_numeric_constants.rs
+++ b/src/tools/clippy/clippy_lints/src/legacy_numeric_constants.rs
@@ -39,9 +39,7 @@ pub struct LegacyNumericConstants {
 
 impl LegacyNumericConstants {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -52,9 +50,9 @@ impl<'tcx> LateLintPass<'tcx> for LegacyNumericConstants {
         // Integer modules are "TBD" deprecated, and the contents are too,
         // so lint on the `use` statement directly.
         if let ItemKind::Use(path, kind @ (UseKind::Single | UseKind::Glob)) = item.kind
-            && self.msrv.meets(msrvs::NUMERIC_ASSOCIATED_CONSTANTS)
             && !item.span.in_external_macro(cx.sess().source_map())
             && let Some(def_id) = path.res[0].opt_def_id()
+            && self.msrv.meets(cx, msrvs::NUMERIC_ASSOCIATED_CONSTANTS)
         {
             let module = if is_integer_module(cx, def_id) {
                 true
@@ -137,8 +135,8 @@ impl<'tcx> LateLintPass<'tcx> for LegacyNumericConstants {
             return;
         };
 
-        if self.msrv.meets(msrvs::NUMERIC_ASSOCIATED_CONSTANTS)
-            && !expr.span.in_external_macro(cx.sess().source_map())
+        if !expr.span.in_external_macro(cx.sess().source_map())
+            && self.msrv.meets(cx, msrvs::NUMERIC_ASSOCIATED_CONSTANTS)
             && !is_from_proc_macro(cx, expr)
         {
             span_lint_hir_and_then(cx, LEGACY_NUMERIC_CONSTANTS, expr.hir_id, span, msg, |diag| {
@@ -151,8 +149,6 @@ impl<'tcx> LateLintPass<'tcx> for LegacyNumericConstants {
             });
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn is_integer_module(cx: &LateContext<'_>, did: DefId) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/lib.rs b/src/tools/clippy/clippy_lints/src/lib.rs
index 13218331a67b..cc3d972f017b 100644
--- a/src/tools/clippy/clippy_lints/src/lib.rs
+++ b/src/tools/clippy/clippy_lints/src/lib.rs
@@ -340,6 +340,7 @@ mod significant_drop_tightening;
 mod single_call_fn;
 mod single_char_lifetime_names;
 mod single_component_path_imports;
+mod single_option_map;
 mod single_range_in_vec_init;
 mod size_of_in_element_count;
 mod size_of_ref;
@@ -407,9 +408,9 @@ mod zombie_processes;
 
 use clippy_config::{Conf, get_configuration_metadata, sanitize_explanation};
 use clippy_utils::macros::FormatArgsStorage;
+use utils::attr_collector::{AttrCollector, AttrStorage};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_lint::{Lint, LintId};
-use utils::attr_collector::{AttrCollector, AttrStorage};
 
 /// Register all pre expansion lints
 ///
@@ -717,6 +718,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(disallowed_names::DisallowedNames::new(conf)));
     store.register_late_pass(move |tcx| Box::new(functions::Functions::new(tcx, conf)));
     store.register_late_pass(move |_| Box::new(doc::Documentation::new(conf)));
+    store.register_early_pass(move || Box::new(doc::Documentation::new(conf)));
     store.register_late_pass(|_| Box::new(neg_multiply::NegMultiply));
     store.register_late_pass(|_| Box::new(let_if_seq::LetIfSeq));
     store.register_late_pass(|_| Box::new(mixed_read_write_in_expression::EvalOrderDependence));
@@ -840,7 +842,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(non_send_fields_in_send_ty::NonSendFieldInSendTy::new(conf)));
     store.register_late_pass(move |_| Box::new(undocumented_unsafe_blocks::UndocumentedUnsafeBlocks::new(conf)));
     let format_args = format_args_storage.clone();
-    store.register_late_pass(move |_| Box::new(format_args::FormatArgs::new(conf, format_args.clone())));
+    store.register_late_pass(move |tcx| Box::new(format_args::FormatArgs::new(tcx, conf, format_args.clone())));
     store.register_late_pass(|_| Box::new(trailing_empty_array::TrailingEmptyArray));
     store.register_early_pass(|| Box::new(octal_escapes::OctalEscapes));
     store.register_late_pass(|_| Box::new(needless_late_init::NeedlessLateInit));
@@ -860,6 +862,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_early_pass(|| Box::new(pub_use::PubUse));
     store.register_late_pass(|_| Box::new(format_push_string::FormatPushString));
     store.register_late_pass(move |_| Box::new(large_include_file::LargeIncludeFile::new(conf)));
+    store.register_early_pass(move || Box::new(large_include_file::LargeIncludeFile::new(conf)));
     store.register_late_pass(|_| Box::new(strings::TrimSplitWhitespace));
     store.register_late_pass(|_| Box::new(rc_clone_in_vec_init::RcCloneInVecInit));
     store.register_early_pass(|| Box::<duplicate_mod::DuplicateMod>::default());
@@ -902,7 +905,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(move |_| Box::new(manual_main_separator_str::ManualMainSeparatorStr::new(conf)));
     store.register_late_pass(|_| Box::new(unnecessary_struct_initialization::UnnecessaryStruct));
     store.register_late_pass(move |_| Box::new(unnecessary_box_returns::UnnecessaryBoxReturns::new(conf)));
-    store.register_late_pass(|_| Box::new(lines_filter_map_ok::LinesFilterMapOk));
+    store.register_late_pass(move |_| Box::new(lines_filter_map_ok::LinesFilterMapOk::new(conf)));
     store.register_late_pass(|_| Box::new(tests_outside_test_module::TestsOutsideTestModule));
     store.register_late_pass(|_| Box::new(manual_slice_size_calculation::ManualSliceSizeCalculation));
     store.register_early_pass(move || Box::new(excessive_nesting::ExcessiveNesting::new(conf)));
@@ -946,7 +949,7 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::<pathbuf_init_then_push::PathbufThenPush<'_>>::default());
     store.register_late_pass(|_| Box::new(iter_over_hash_type::IterOverHashType));
     store.register_late_pass(|_| Box::new(impl_hash_with_borrow_str_and_bytes::ImplHashWithBorrowStrBytes));
-    store.register_late_pass(|_| Box::new(repeat_vec_with_capacity::RepeatVecWithCapacity));
+    store.register_late_pass(move |_| Box::new(repeat_vec_with_capacity::RepeatVecWithCapacity::new(conf)));
     store.register_late_pass(|_| Box::new(uninhabited_references::UninhabitedReferences));
     store.register_late_pass(|_| Box::new(ineffective_open_options::IneffectiveOpenOptions));
     store.register_late_pass(|_| Box::<unconditional_recursion::UnconditionalRecursion>::default());
@@ -980,5 +983,6 @@ pub fn register_lints(store: &mut rustc_lint::LintStore, conf: &'static Conf) {
     store.register_late_pass(|_| Box::<unnecessary_semicolon::UnnecessarySemicolon>::default());
     store.register_late_pass(move |_| Box::new(non_std_lazy_statics::NonStdLazyStatic::new(conf)));
     store.register_late_pass(|_| Box::new(manual_option_as_slice::ManualOptionAsSlice::new(conf)));
+    store.register_late_pass(|_| Box::new(single_option_map::SingleOptionMap));
     // add lints here, do not remove this comment, it's used in `new_lint`
 }
diff --git a/src/tools/clippy/clippy_lints/src/lifetimes.rs b/src/tools/clippy/clippy_lints/src/lifetimes.rs
index f08812017b9c..3dd2de1fafc7 100644
--- a/src/tools/clippy/clippy_lints/src/lifetimes.rs
+++ b/src/tools/clippy/clippy_lints/src/lifetimes.rs
@@ -38,8 +38,8 @@ declare_clippy_lint! {
     /// them leads to more readable code.
     ///
     /// ### Known problems
-    /// - We bail out if the function has a `where` clause where lifetimes
-    /// are mentioned due to potential false positives.
+    /// This lint ignores functions with `where` clauses that reference
+    /// lifetimes to prevent false positives.
     ///
     /// ### Example
     /// ```no_run
@@ -62,6 +62,38 @@ declare_clippy_lint! {
      would allow omitting them"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for lifetime annotations which can be replaced with anonymous lifetimes (`'_`).
+    ///
+    /// ### Why is this bad?
+    /// The additional lifetimes can make the code look more complicated.
+    ///
+    /// ### Known problems
+    /// This lint ignores functions with `where` clauses that reference
+    /// lifetimes to prevent false positives.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # use std::str::Chars;
+    /// fn f<'a>(x: &'a str) -> Chars<'a> {
+    ///     x.chars()
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    /// ```no_run
+    /// # use std::str::Chars;
+    /// fn f(x: &str) -> Chars<'_> {
+    ///     x.chars()
+    /// }
+    /// ```
+    #[clippy::version = "1.84.0"]
+    pub ELIDABLE_LIFETIME_NAMES,
+    pedantic,
+    "lifetime name that can be replaced with the anonymous lifetime"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for lifetimes in generics that are never used
@@ -98,13 +130,15 @@ pub struct Lifetimes {
 
 impl Lifetimes {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
-impl_lint_pass!(Lifetimes => [NEEDLESS_LIFETIMES, EXTRA_UNUSED_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<'_>) {
@@ -115,7 +149,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
             ..
         } = item.kind
         {
-            check_fn_inner(cx, sig, Some(id), None, generics, item.span, true, &self.msrv);
+            check_fn_inner(cx, sig, Some(id), None, generics, item.span, true, self.msrv);
         } else if let ItemKind::Impl(impl_) = item.kind {
             if !item.span.from_expansion() {
                 report_extra_impl_lifetimes(cx, impl_);
@@ -134,7 +168,7 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
                 item.generics,
                 item.span,
                 report_extra_lifetimes,
-                &self.msrv,
+                self.msrv,
             );
         }
     }
@@ -145,11 +179,9 @@ impl<'tcx> LateLintPass<'tcx> for Lifetimes {
                 TraitFn::Required(sig) => (None, Some(sig)),
                 TraitFn::Provided(id) => (Some(id), None),
             };
-            check_fn_inner(cx, sig, body, trait_sig, item.generics, item.span, true, &self.msrv);
+            check_fn_inner(cx, sig, body, trait_sig, item.generics, item.span, true, self.msrv);
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 #[allow(clippy::too_many_arguments)]
@@ -161,7 +193,7 @@ fn check_fn_inner<'tcx>(
     generics: &'tcx Generics<'_>,
     span: Span,
     report_extra_lifetimes: bool,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if span.in_external_macro(cx.sess().source_map()) || has_where_lifetimes(cx, generics) {
         return;
@@ -234,7 +266,7 @@ fn could_use_elision<'tcx>(
     body: Option<BodyId>,
     trait_sig: Option<&[Ident]>,
     named_generics: &'tcx [GenericParam<'_>],
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> Option<(Vec<LocalDefId>, Vec<Lifetime>)> {
     // There are two scenarios where elision works:
     // * no output references, all input references have different LT
@@ -352,17 +384,12 @@ fn allowed_lts_from(named_generics: &[GenericParam<'_>]) -> FxIndexSet<LocalDefI
 }
 
 // elision doesn't work for explicit self types before Rust 1.81, see rust-lang/rust#69064
-fn non_elidable_self_type<'tcx>(
-    cx: &LateContext<'tcx>,
-    func: &FnDecl<'tcx>,
-    ident: Option<Ident>,
-    msrv: &Msrv,
-) -> bool {
-    if !msrv.meets(msrvs::EXPLICIT_SELF_TYPE_ELISION)
-        && let Some(ident) = ident
+fn non_elidable_self_type<'tcx>(cx: &LateContext<'tcx>, func: &FnDecl<'tcx>, ident: Option<Ident>, msrv: Msrv) -> bool {
+    if let Some(ident) = ident
         && ident.name == kw::SelfLower
         && !func.implicit_self.has_implicit_self()
         && let Some(self_ty) = func.inputs.first()
+        && !msrv.meets(cx, msrvs::EXPLICIT_SELF_TYPE_ELISION)
     {
         let mut visitor = RefVisitor::new(cx);
         visitor.visit_ty_unambig(self_ty);
@@ -746,6 +773,15 @@ fn report_elidable_impl_lifetimes<'tcx>(
     report_elidable_lifetimes(cx, impl_.generics, &elidable_lts, &usages, true);
 }
 
+#[derive(Copy, Clone)]
+enum ElidableUsage {
+    /// Used in a ref (`&'a T`), can be removed
+    Ref(Span),
+    /// Used as a generic param (`T<'a>`) or an impl lifetime (`impl T + 'a`), can be replaced
+    /// with `'_`
+    Other(Span),
+}
+
 /// Generate diagnostic messages for elidable lifetimes.
 fn report_elidable_lifetimes(
     cx: &LateContext<'_>,
@@ -763,9 +799,29 @@ fn report_elidable_lifetimes(
         .collect::<Vec<_>>()
         .join(", ");
 
+    let elidable_usages: Vec<ElidableUsage> = usages
+        .iter()
+        .filter(|usage| named_lifetime(usage).is_some_and(|id| elidable_lts.contains(&id)))
+        .map(|usage| match cx.tcx.parent_hir_node(usage.hir_id) {
+            Node::Ty(Ty {
+                kind: TyKind::Ref(..), ..
+            }) => ElidableUsage::Ref(usage.ident.span),
+            _ => ElidableUsage::Other(usage.ident.span),
+        })
+        .collect();
+
+    let lint = if elidable_usages
+        .iter()
+        .any(|usage| matches!(usage, ElidableUsage::Other(_)))
+    {
+        ELIDABLE_LIFETIME_NAMES
+    } else {
+        NEEDLESS_LIFETIMES
+    };
+
     span_lint_and_then(
         cx,
-        NEEDLESS_LIFETIMES,
+        lint,
         elidable_lts
             .iter()
             .map(|&lt| cx.tcx.def_span(lt))
@@ -785,7 +841,7 @@ fn report_elidable_lifetimes(
                 return;
             }
 
-            if let Some(suggestions) = elision_suggestions(cx, generics, elidable_lts, usages) {
+            if let Some(suggestions) = elision_suggestions(cx, generics, elidable_lts, &elidable_usages) {
                 diag.multipart_suggestion("elide the lifetimes", suggestions, Applicability::MachineApplicable);
             }
         },
@@ -796,7 +852,7 @@ fn elision_suggestions(
     cx: &LateContext<'_>,
     generics: &Generics<'_>,
     elidable_lts: &[LocalDefId],
-    usages: &[Lifetime],
+    usages: &[ElidableUsage],
 ) -> Option<Vec<(Span, String)>> {
     let explicit_params = generics
         .params
@@ -836,26 +892,21 @@ fn elision_suggestions(
             .collect::<Option<Vec<_>>>()?
     };
 
-    suggestions.extend(
-        usages
-            .iter()
-            .filter(|usage| named_lifetime(usage).is_some_and(|id| elidable_lts.contains(&id)))
-            .map(|usage| {
-                match cx.tcx.parent_hir_node(usage.hir_id) {
-                    Node::Ty(Ty {
-                        kind: TyKind::Ref(..), ..
-                    }) => {
-                        // expand `&'a T` to `&'a T`
-                        //          ^^         ^^^
-                        let span = cx.sess().source_map().span_extend_while_whitespace(usage.ident.span);
+    suggestions.extend(usages.iter().map(|&usage| {
+        match usage {
+            ElidableUsage::Ref(span) => {
+                // expand `&'a T` to `&'a T`
+                //          ^^         ^^^
+                let span = cx.sess().source_map().span_extend_while_whitespace(span);
 
-                        (span, String::new())
-                    },
-                    // `T<'a>` and `impl Foo + 'a` should be replaced by `'_`
-                    _ => (usage.ident.span, String::from("'_")),
-                }
-            }),
-    );
+                (span, String::new())
+            },
+            ElidableUsage::Other(span) => {
+                // `T<'a>` and `impl Foo + 'a` should be replaced by `'_`
+                (span, String::from("'_"))
+            },
+        }
+    }));
 
     Some(suggestions)
 }
diff --git a/src/tools/clippy/clippy_lints/src/lines_filter_map_ok.rs b/src/tools/clippy/clippy_lints/src/lines_filter_map_ok.rs
index f022598651b7..d8af44233d3e 100644
--- a/src/tools/clippy/clippy_lints/src/lines_filter_map_ok.rs
+++ b/src/tools/clippy/clippy_lints/src/lines_filter_map_ok.rs
@@ -1,12 +1,24 @@
+use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::{is_diag_item_method, is_trait_method, path_to_local_id};
 use rustc_errors::Applicability;
 use rustc_hir::{Body, Closure, Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 use rustc_span::sym;
 
+pub struct LinesFilterMapOk {
+    msrv: Msrv,
+}
+
+impl LinesFilterMapOk {
+    pub fn new(conf: &Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for usage of `lines.filter_map(Result::ok)` or `lines.flat_map(Result::ok)`
@@ -55,7 +67,8 @@ declare_clippy_lint! {
     suspicious,
     "filtering `std::io::Lines` with `filter_map()`, `flat_map()`, or `flatten()` might cause an infinite loop"
 }
-declare_lint_pass!(LinesFilterMapOk => [LINES_FILTER_MAP_OK]);
+
+impl_lint_pass!(LinesFilterMapOk => [LINES_FILTER_MAP_OK]);
 
 impl LateLintPass<'_> for LinesFilterMapOk {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
@@ -65,6 +78,7 @@ impl LateLintPass<'_> for LinesFilterMapOk {
             && matches!(fm_method_str, "filter_map" | "flat_map" | "flatten")
             && is_type_diagnostic_item(cx, cx.typeck_results().expr_ty_adjusted(fm_receiver), sym::IoLines)
             && should_lint(cx, fm_args, fm_method_str)
+            && self.msrv.meets(cx, msrvs::MAP_WHILE)
         {
             span_lint_and_then(
                 cx,
diff --git a/src/tools/clippy/clippy_lints/src/literal_string_with_formatting_args.rs b/src/tools/clippy/clippy_lints/src/literal_string_with_formatting_args.rs
index a957c0e22a29..975e6833a35f 100644
--- a/src/tools/clippy/clippy_lints/src/literal_string_with_formatting_args.rs
+++ b/src/tools/clippy/clippy_lints/src/literal_string_with_formatting_args.rs
@@ -7,6 +7,7 @@ use rustc_session::declare_lint_pass;
 use rustc_span::{BytePos, Span};
 
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_from_proc_macro;
 use clippy_utils::mir::enclosing_mir;
 
 declare_clippy_lint! {
@@ -79,9 +80,9 @@ fn emit_lint(cx: &LateContext<'_>, expr: &Expr<'_>, spans: &[(Span, Option<Strin
     }
 }
 
-impl LateLintPass<'_> for LiteralStringWithFormattingArg {
-    fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
-        if expr.span.from_expansion() {
+impl<'tcx> LateLintPass<'tcx> for LiteralStringWithFormattingArg {
+    fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'tcx>) {
+        if expr.span.from_expansion() || expr.span.is_dummy() {
             return;
         }
         if let ExprKind::Lit(lit) = expr.kind {
@@ -95,6 +96,9 @@ impl LateLintPass<'_> for LiteralStringWithFormattingArg {
                 },
                 _ => return,
             };
+            if is_from_proc_macro(cx, expr) {
+                return;
+            }
             let fmt_str = symbol.as_str();
             let lo = expr.span.lo();
             let mut current = fmt_str;
@@ -124,7 +128,11 @@ impl LateLintPass<'_> for LiteralStringWithFormattingArg {
                     pos.start += diff_len;
                     pos.end += diff_len;
 
-                    let start = fmt_str[..pos.start].rfind('{').unwrap_or(pos.start);
+                    let mut start = pos.start;
+                    while start < fmt_str.len() && !fmt_str.is_char_boundary(start) {
+                        start += 1;
+                    }
+                    let start = fmt_str[..start].rfind('{').unwrap_or(start);
                     // If this is a unicode character escape, we don't want to lint.
                     if start > 1 && fmt_str[..start].ends_with("\\u") {
                         continue;
diff --git a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs
index 06cf901bfb23..412c78cc8041 100644
--- a/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/explicit_iter_loop.rs
@@ -17,7 +17,7 @@ pub(super) fn check(
     cx: &LateContext<'_>,
     self_arg: &Expr<'_>,
     call_expr: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
     enforce_iter_loop_reborrow: bool,
 ) {
     let Some((adjust, ty)) = is_ref_iterable(cx, self_arg, call_expr, enforce_iter_loop_reborrow, msrv) else {
@@ -26,10 +26,11 @@ pub(super) fn check(
 
     if let ty::Array(_, count) = *ty.peel_refs().kind() {
         if !ty.is_ref() {
-            if !msrv.meets(msrvs::ARRAY_INTO_ITERATOR) {
+            if !msrv.meets(cx, msrvs::ARRAY_INTO_ITERATOR) {
                 return;
             }
-        } else if count.try_to_target_usize(cx.tcx).is_none_or(|x| x > 32) && !msrv.meets(msrvs::ARRAY_IMPL_ANY_LEN) {
+        } else if count.try_to_target_usize(cx.tcx).is_none_or(|x| x > 32) && !msrv.meets(cx, msrvs::ARRAY_IMPL_ANY_LEN)
+        {
             return;
         }
     }
@@ -106,7 +107,7 @@ fn is_ref_iterable<'tcx>(
     self_arg: &Expr<'_>,
     call_expr: &Expr<'_>,
     enforce_iter_loop_reborrow: bool,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> Option<(AdjustKind, Ty<'tcx>)> {
     let typeck = cx.typeck_results();
     if let Some(trait_id) = cx.tcx.get_diagnostic_item(sym::IntoIterator)
@@ -126,8 +127,8 @@ fn is_ref_iterable<'tcx>(
         let self_ty = typeck.expr_ty(self_arg);
         let self_is_copy = is_copy(cx, self_ty);
 
-        if !msrv.meets(msrvs::BOX_INTO_ITER)
-            && is_type_lang_item(cx, self_ty.peel_refs(), rustc_hir::LangItem::OwnedBox)
+        if is_type_lang_item(cx, self_ty.peel_refs(), rustc_hir::LangItem::OwnedBox)
+            && !msrv.meets(cx, msrvs::BOX_INTO_ITER)
         {
             return None;
         }
diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs b/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs
index 366c310592f5..9b6f97b9a2eb 100644
--- a/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/manual_flatten.rs
@@ -1,6 +1,7 @@
 use super::MANUAL_FLATTEN;
 use super::utils::make_iterator_snippet;
 use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{higher, path_to_local_id, peel_blocks_with_stmt};
 use rustc_errors::Applicability;
@@ -18,6 +19,7 @@ pub(super) fn check<'tcx>(
     arg: &'tcx Expr<'_>,
     body: &'tcx Expr<'_>,
     span: Span,
+    msrv: Msrv,
 ) {
     let inner_expr = peel_blocks_with_stmt(body);
     if let Some(higher::IfLet { let_pat, let_expr, if_then, if_else: None, .. })
@@ -34,6 +36,7 @@ pub(super) fn check<'tcx>(
         && (some_ctor || ok_ctor)
         // Ensure expr in `if let` is not used afterwards
         && !is_local_used(cx, if_then, pat_hir_id)
+        && msrv.meets(cx, msrvs::ITER_FLATTEN)
     {
         let if_let_type = if some_ctor { "Some" } else { "Ok" };
         // Prepare the error message
diff --git a/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs b/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs
index 7c6564235796..343f7c5d2d12 100644
--- a/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/manual_slice_fill.rs
@@ -1,9 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
-use clippy_utils::macros::span_is_local;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::{HasSession, snippet_with_applicability};
 use clippy_utils::ty::implements_trait;
+use clippy_utils::visitors::is_local_used;
 use clippy_utils::{higher, peel_blocks_with_stmt, span_contains_comment};
 use rustc_ast::ast::LitKind;
 use rustc_ast::{RangeLimits, UnOp};
@@ -24,12 +24,8 @@ pub(super) fn check<'tcx>(
     arg: &'tcx Expr<'_>,
     body: &'tcx Expr<'_>,
     expr: &'tcx Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if !msrv.meets(msrvs::SLICE_FILL) {
-        return;
-    }
-
     // `for _ in 0..slice.len() { slice[_] = value; }`
     if let Some(higher::Range {
         start: Some(start),
@@ -43,7 +39,7 @@ pub(super) fn check<'tcx>(
         && let ExprKind::Block(..) = body.kind
         // Check if the body is an assignment to a slice element.
         && let ExprKind::Assign(assignee, assignval, _) = peel_blocks_with_stmt(body).kind
-        && let ExprKind::Index(slice, _, _) = assignee.kind
+        && let ExprKind::Index(slice, idx, _) = assignee.kind
         // Check if `len()` is used for the range end.
         && let ExprKind::MethodCall(path, recv,..) = end.kind
         && path.ident.name == sym::len
@@ -54,10 +50,14 @@ pub(super) fn check<'tcx>(
         && !assignval.span.from_expansion()
         // It is generally not equivalent to use the `fill` method if `assignval` can have side effects
         && switch_to_eager_eval(cx, assignval)
-        && span_is_local(assignval.span)
         // The `fill` method requires that the slice's element type implements the `Clone` trait.
         && let Some(clone_trait) = cx.tcx.lang_items().clone_trait()
         && implements_trait(cx, cx.typeck_results().expr_ty(slice), clone_trait, &[])
+        // https://github.com/rust-lang/rust-clippy/issues/14192
+        && let ExprKind::Path(Resolved(_, idx_path)) = idx.kind
+        && let Res::Local(idx_hir) = idx_path.res
+        && !is_local_used(cx, assignval, idx_hir)
+        && msrv.meets(cx, msrvs::SLICE_FILL)
     {
         sugg(cx, body, expr, slice.span, assignval.span);
     }
@@ -73,10 +73,12 @@ pub(super) fn check<'tcx>(
         && local == pat.hir_id
         && !assignval.span.from_expansion()
         && switch_to_eager_eval(cx, assignval)
-        && span_is_local(assignval.span)
+        // `assignval` must not reference the iterator
+        && !is_local_used(cx, assignval, local)
         // The `fill` method cannot be used if the slice's element type does not implement the `Clone` trait.
         && let Some(clone_trait) = cx.tcx.lang_items().clone_trait()
         && implements_trait(cx, cx.typeck_results().expr_ty(recv), clone_trait, &[])
+        && msrv.meets(cx, msrvs::SLICE_FILL)
     {
         sugg(cx, body, expr, recv_path.span, assignval.span);
     }
diff --git a/src/tools/clippy/clippy_lints/src/loops/mod.rs b/src/tools/clippy/clippy_lints/src/loops/mod.rs
index cdc8c18c3b74..ed725a039891 100644
--- a/src/tools/clippy/clippy_lints/src/loops/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/mod.rs
@@ -747,7 +747,7 @@ pub struct Loops {
 impl Loops {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             enforce_iter_loop_reborrow: conf.enforce_iter_loop_reborrow,
         }
     }
@@ -832,8 +832,6 @@ impl<'tcx> LateLintPass<'tcx> for Loops {
             manual_while_let_some::check(cx, condition, body, span);
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 impl Loops {
@@ -850,7 +848,7 @@ impl Loops {
     ) {
         let is_manual_memcpy_triggered = manual_memcpy::check(cx, pat, arg, body, expr);
         if !is_manual_memcpy_triggered {
-            manual_slice_fill::check(cx, pat, arg, body, expr, &self.msrv);
+            manual_slice_fill::check(cx, pat, arg, body, expr, self.msrv);
             needless_range_loop::check(cx, pat, arg, body, expr);
             explicit_counter_loop::check(cx, pat, arg, body, expr, label);
         }
@@ -858,8 +856,8 @@ impl Loops {
         for_kv_map::check(cx, pat, arg, body);
         mut_range_bound::check(cx, arg, body);
         single_element_loop::check(cx, pat, arg, body, expr);
-        same_item_push::check(cx, pat, arg, body, expr, &self.msrv);
-        manual_flatten::check(cx, pat, arg, body, span);
+        same_item_push::check(cx, pat, arg, body, expr, self.msrv);
+        manual_flatten::check(cx, pat, arg, body, span, self.msrv);
         manual_find::check(cx, pat, arg, body, span, expr);
         unused_enumerate_index::check(cx, pat, arg, body);
     }
@@ -868,7 +866,7 @@ impl Loops {
         if let ExprKind::MethodCall(method, self_arg, [], _) = arg.kind {
             match method.ident.as_str() {
                 "iter" | "iter_mut" => {
-                    explicit_iter_loop::check(cx, self_arg, arg, &self.msrv, self.enforce_iter_loop_reborrow);
+                    explicit_iter_loop::check(cx, self_arg, arg, self.msrv, self.enforce_iter_loop_reborrow);
                 },
                 "into_iter" => {
                     explicit_into_iter_loop::check(cx, self_arg, arg);
diff --git a/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs b/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs
index c27e930c99a5..661b4b590d8f 100644
--- a/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs
+++ b/src/tools/clippy/clippy_lints/src/loops/same_item_push.rs
@@ -20,14 +20,14 @@ pub(super) fn check<'tcx>(
     _: &'tcx Expr<'_>,
     body: &'tcx Expr<'_>,
     _: &'tcx Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>, ctxt: SyntaxContext, msrv: &Msrv) {
+    fn emit_lint(cx: &LateContext<'_>, vec: &Expr<'_>, pushed_item: &Expr<'_>, ctxt: SyntaxContext, msrv: Msrv) {
         let mut app = Applicability::Unspecified;
         let vec_str = snippet_with_context(cx, vec.span, ctxt, "", &mut app).0;
         let item_str = snippet_with_context(cx, pushed_item.span, ctxt, "", &mut app).0;
 
-        let secondary_help = if msrv.meets(msrvs::REPEAT_N)
+        let secondary_help = if msrv.meets(cx, msrvs::REPEAT_N)
             && let Some(std_or_core) = std_or_core(cx)
         {
             format!("or `{vec_str}.extend({std_or_core}::iter::repeat_n({item_str}, SIZE))`")
diff --git a/src/tools/clippy/clippy_lints/src/macro_use.rs b/src/tools/clippy/clippy_lints/src/macro_use.rs
index 374128665392..20be22850b76 100644
--- a/src/tools/clippy/clippy_lints/src/macro_use.rs
+++ b/src/tools/clippy/clippy_lints/src/macro_use.rs
@@ -21,7 +21,21 @@ declare_clippy_lint! {
     /// ### Example
     /// ```rust,ignore
     /// #[macro_use]
-    /// use some_macro;
+    /// extern crate some_crate;
+    ///
+    /// fn main() {
+    ///     some_macro!();
+    /// }
+    /// ```
+    ///
+    /// Use instead:
+    ///
+    /// ```rust,ignore
+    /// use some_crate::some_macro;
+    ///
+    /// fn main() {
+    ///     some_macro!();
+    /// }
     /// ```
     #[clippy::version = "1.44.0"]
     pub MACRO_USE_IMPORTS,
@@ -94,7 +108,7 @@ impl LateLintPass<'_> for MacroUseImports {
         {
             for kid in cx.tcx.module_children(id) {
                 if let Res::Def(DefKind::Macro(_mac_type), mac_id) = kid.res {
-                    let span = mac_attr.span;
+                    let span = mac_attr.span();
                     let def_path = cx.tcx.def_path_str(mac_id);
                     self.imports.push((def_path, span, hir_id));
                 }
@@ -103,11 +117,6 @@ impl LateLintPass<'_> for MacroUseImports {
             self.push_unique_macro_pat_ty(cx, item.span);
         }
     }
-    fn check_attribute(&mut self, cx: &LateContext<'_>, attr: &hir::Attribute) {
-        if attr.span.from_expansion() {
-            self.push_unique_macro(cx, attr.span);
-        }
-    }
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &hir::Expr<'_>) {
         if expr.span.from_expansion() {
             self.push_unique_macro(cx, expr.span);
diff --git a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
index 6f3a7d8cccc8..abd1ac954cda 100644
--- a/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_async_fn.rs
@@ -62,6 +62,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualAsyncFn {
             && let Some(closure_body) = desugared_async_block(cx, block)
             && let Node::Item(Item {vis_span, ..}) | Node::ImplItem(ImplItem {vis_span, ..}) =
                 cx.tcx.hir_node_by_def_id(fn_def_id)
+            && !span.from_expansion()
         {
             let header_span = span.with_hi(ret_ty.span.hi());
 
diff --git a/src/tools/clippy/clippy_lints/src/manual_bits.rs b/src/tools/clippy/clippy_lints/src/manual_bits.rs
index 17e25635ce10..39c4857b3e87 100644
--- a/src/tools/clippy/clippy_lints/src/manual_bits.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_bits.rs
@@ -40,9 +40,7 @@ pub struct ManualBits {
 
 impl ManualBits {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -53,7 +51,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
         if let ExprKind::Binary(bin_op, left_expr, right_expr) = expr.kind
             && let BinOpKind::Mul = &bin_op.node
             && !expr.span.from_expansion()
-            && self.msrv.meets(msrvs::MANUAL_BITS)
             && let ctxt = expr.span.ctxt()
             && left_expr.span.ctxt() == ctxt
             && right_expr.span.ctxt() == ctxt
@@ -61,6 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
             && matches!(resolved_ty.kind(), ty::Int(_) | ty::Uint(_))
             && let ExprKind::Lit(lit) = &other_expr.kind
             && let LitKind::Int(Pu128(8), _) = lit.node
+            && self.msrv.meets(cx, msrvs::INTEGER_BITS)
         {
             let mut app = Applicability::MachineApplicable;
             let ty_snip = snippet_with_context(cx, real_ty_span, ctxt, "..", &mut app).0;
@@ -77,8 +75,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualBits {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn get_one_size_of_ty<'tcx>(
diff --git a/src/tools/clippy/clippy_lints/src/manual_clamp.rs b/src/tools/clippy/clippy_lints/src/manual_clamp.rs
index 484a7ba256bd..50c8331eebab 100644
--- a/src/tools/clippy/clippy_lints/src/manual_clamp.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_clamp.rs
@@ -99,9 +99,7 @@ pub struct ManualClamp {
 
 impl ManualClamp {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -144,30 +142,28 @@ struct InputMinMax<'tcx> {
 
 impl<'tcx> LateLintPass<'tcx> for ManualClamp {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if !self.msrv.meets(msrvs::CLAMP) {
-            return;
-        }
         if !expr.span.from_expansion() && !is_in_const_context(cx) {
             let suggestion = is_if_elseif_else_pattern(cx, expr)
                 .or_else(|| is_max_min_pattern(cx, expr))
                 .or_else(|| is_call_max_min_pattern(cx, expr))
                 .or_else(|| is_match_pattern(cx, expr))
                 .or_else(|| is_if_elseif_pattern(cx, expr));
-            if let Some(suggestion) = suggestion {
+            if let Some(suggestion) = suggestion
+                && self.msrv.meets(cx, msrvs::CLAMP)
+            {
                 maybe_emit_suggestion(cx, &suggestion);
             }
         }
     }
 
     fn check_block(&mut self, cx: &LateContext<'tcx>, block: &'tcx Block<'tcx>) {
-        if !self.msrv.meets(msrvs::CLAMP) || is_in_const_context(cx) {
+        if is_in_const_context(cx) || !self.msrv.meets(cx, msrvs::CLAMP) {
             return;
         }
         for suggestion in is_two_if_pattern(cx, block) {
             maybe_emit_suggestion(cx, &suggestion);
         }
     }
-    extract_msrv_attr!(LateContext);
 }
 
 fn maybe_emit_suggestion<'tcx>(cx: &LateContext<'tcx>, suggestion: &ClampSuggestion<'tcx>) {
diff --git a/src/tools/clippy/clippy_lints/src/manual_div_ceil.rs b/src/tools/clippy/clippy_lints/src/manual_div_ceil.rs
index 04357cdd8f66..9c1419175d55 100644
--- a/src/tools/clippy/clippy_lints/src/manual_div_ceil.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_div_ceil.rs
@@ -49,9 +49,7 @@ pub struct ManualDivCeil {
 impl ManualDivCeil {
     #[must_use]
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -59,10 +57,6 @@ impl_lint_pass!(ManualDivCeil => [MANUAL_DIV_CEIL]);
 
 impl<'tcx> LateLintPass<'tcx> for ManualDivCeil {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &Expr<'_>) {
-        if !self.msrv.meets(msrvs::MANUAL_DIV_CEIL) {
-            return;
-        }
-
         let mut applicability = Applicability::MachineApplicable;
 
         if let ExprKind::Binary(div_op, div_lhs, div_rhs) = expr.kind
@@ -70,6 +64,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualDivCeil {
             && check_int_ty_and_feature(cx, div_lhs)
             && check_int_ty_and_feature(cx, div_rhs)
             && let ExprKind::Binary(inner_op, inner_lhs, inner_rhs) = div_lhs.kind
+            && self.msrv.meets(cx, msrvs::MANUAL_DIV_CEIL)
         {
             // (x + (y - 1)) / y
             if let ExprKind::Binary(sub_op, sub_lhs, sub_rhs) = inner_rhs.kind
@@ -122,8 +117,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualDivCeil {
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 /// Checks if two expressions represent non-zero integer literals such that `small_expr + 1 ==
diff --git a/src/tools/clippy/clippy_lints/src/manual_float_methods.rs b/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
index 2a5aa12d126c..bd2785fea270 100644
--- a/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_float_methods.rs
@@ -90,9 +90,7 @@ pub struct ManualFloatMethods {
 
 impl ManualFloatMethods {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -144,7 +142,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             && !expr.span.in_external_macro(cx.sess().source_map())
             && (
                 is_not_const(cx.tcx, cx.tcx.hir_enclosing_body_owner(expr.hir_id).into())
-                    || self.msrv.meets(msrvs::CONST_FLOAT_CLASSIFY)
+                    || self.msrv.meets(cx, msrvs::CONST_FLOAT_CLASSIFY)
             )
             && let [first, second, const_1, const_2] = exprs
             && let ecx = ConstEvalCtxt::new(cx)
@@ -202,8 +200,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualFloatMethods {
             });
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn is_infinity(constant: &Constant<'_>) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/manual_hash_one.rs b/src/tools/clippy/clippy_lints/src/manual_hash_one.rs
index 7e092d11f1b4..f71264a93ca8 100644
--- a/src/tools/clippy/clippy_lints/src/manual_hash_one.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_hash_one.rs
@@ -53,9 +53,7 @@ pub struct ManualHashOne {
 
 impl ManualHashOne {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -98,7 +96,7 @@ impl LateLintPass<'_> for ManualHashOne {
             && let ExprKind::MethodCall(seg, _, [], _) = finish_expr.kind
             && seg.ident.name.as_str() == "finish"
 
-            && self.msrv.meets(msrvs::BUILD_HASHER_HASH_ONE)
+            && self.msrv.meets(cx, msrvs::BUILD_HASHER_HASH_ONE)
         {
             span_lint_hir_and_then(
                 cx,
@@ -129,6 +127,4 @@ impl LateLintPass<'_> for ManualHashOne {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs b/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs
index 38106277a88f..faf01a276a13 100644
--- a/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_is_ascii_check.rs
@@ -64,9 +64,7 @@ pub struct ManualIsAsciiCheck {
 
 impl ManualIsAsciiCheck {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -91,11 +89,11 @@ enum CharRange {
 
 impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
-        if !self.msrv.meets(msrvs::IS_ASCII_DIGIT) {
+        if !self.msrv.meets(cx, msrvs::IS_ASCII_DIGIT) {
             return;
         }
 
-        if is_in_const_context(cx) && !self.msrv.meets(msrvs::IS_ASCII_DIGIT_CONST) {
+        if is_in_const_context(cx) && !self.msrv.meets(cx, msrvs::IS_ASCII_DIGIT_CONST) {
             return;
         }
 
@@ -119,8 +117,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualIsAsciiCheck {
             check_is_ascii(cx, expr.span, arg, &range, ty_sugg);
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn get_ty_sugg<'tcx>(cx: &LateContext<'tcx>, arg: &Expr<'_>) -> Option<(Span, Ty<'tcx>)> {
diff --git a/src/tools/clippy/clippy_lints/src/manual_let_else.rs b/src/tools/clippy/clippy_lints/src/manual_let_else.rs
index 3643b8c4425e..47939767212e 100644
--- a/src/tools/clippy/clippy_lints/src/manual_let_else.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_let_else.rs
@@ -53,8 +53,8 @@ impl<'tcx> QuestionMark {
             && local.ty.is_none()
             && init.span.eq_ctxt(stmt.span)
             && let Some(if_let_or_match) = IfLetOrMatch::parse(cx, init)
-            && self.msrv.meets(msrvs::LET_ELSE)
             && !stmt.span.in_external_macro(cx.sess().source_map())
+            && self.msrv.meets(cx, msrvs::LET_ELSE)
         {
             match if_let_or_match {
                 IfLetOrMatch::IfLet(if_let_expr, let_pat, if_then, if_else, ..) => {
diff --git a/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs b/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs
index b7563a2508d0..f54ccf2c87b0 100644
--- a/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_main_separator_str.rs
@@ -39,9 +39,7 @@ pub struct ManualMainSeparatorStr {
 
 impl ManualMainSeparatorStr {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -55,10 +53,10 @@ impl LateLintPass<'_> for ManualMainSeparatorStr {
             && let ExprKind::Path(QPath::Resolved(None, path)) = receiver.kind
             && let Res::Def(DefKind::Const, receiver_def_id) = path.res
             && is_trait_method(cx, target, sym::ToString)
-            && self.msrv.meets(msrvs::PATH_MAIN_SEPARATOR_STR)
             && cx.tcx.is_diagnostic_item(sym::path_main_separator, receiver_def_id)
             && let ty::Ref(_, ty, Mutability::Not) = cx.typeck_results().expr_ty_adjusted(expr).kind()
             && ty.is_str()
+            && self.msrv.meets(cx, msrvs::PATH_MAIN_SEPARATOR_STR)
         {
             span_lint_and_sugg(
                 cx,
@@ -71,6 +69,4 @@ impl LateLintPass<'_> for ManualMainSeparatorStr {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs b/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
index 00800231fe46..496e0660d4f9 100644
--- a/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_non_exhaustive.rs
@@ -71,7 +71,7 @@ pub struct ManualNonExhaustive {
 impl ManualNonExhaustive {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             constructed_enum_variants: FxHashSet::default(),
             potential_enums: Vec::new(),
         }
@@ -82,7 +82,7 @@ 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 !self.msrv.meets(msrvs::NON_EXHAUSTIVE) || !cx.effective_visibilities.is_exported(item.owner_id.def_id) {
+        if !cx.effective_visibilities.is_exported(item.owner_id.def_id) || !self.msrv.meets(cx, msrvs::NON_EXHAUSTIVE) {
             return;
         }
 
@@ -116,7 +116,7 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
                             if let Some(non_exhaustive) =
                                 attr::find_by_name(cx.tcx.hir().attrs(item.hir_id()), sym::non_exhaustive)
                             {
-                                diag.span_note(non_exhaustive.span, "the struct is already non-exhaustive");
+                                diag.span_note(non_exhaustive.span(), "the struct is already non-exhaustive");
                             } else {
                                 let indent = snippet_indent(cx, item.span).unwrap_or_default();
                                 diag.span_suggestion_verbose(
@@ -171,6 +171,4 @@ impl<'tcx> LateLintPass<'tcx> for ManualNonExhaustive {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs b/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs
index e4360518b66e..8dee29b2a0b5 100644
--- a/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_option_as_slice.rs
@@ -1,5 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_sugg};
+use clippy_utils::msrvs::Msrv;
 use clippy_utils::{is_none_arm, msrvs, peel_hir_expr_refs};
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -40,31 +41,21 @@ declare_clippy_lint! {
 }
 
 pub struct ManualOptionAsSlice {
-    msrv: msrvs::Msrv,
+    msrv: Msrv,
 }
 
 impl ManualOptionAsSlice {
     pub fn new(conf: &Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
 impl_lint_pass!(ManualOptionAsSlice => [MANUAL_OPTION_AS_SLICE]);
 
 impl LateLintPass<'_> for ManualOptionAsSlice {
-    extract_msrv_attr!(LateContext);
-
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         let span = expr.span;
-        if span.from_expansion()
-            || !self.msrv.meets(if clippy_utils::is_in_const_context(cx) {
-                msrvs::CONST_OPTION_AS_SLICE
-            } else {
-                msrvs::OPTION_AS_SLICE
-            })
-        {
+        if span.from_expansion() {
             return;
         }
         match expr.kind {
@@ -72,7 +63,7 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
                 if is_none_arm(cx, arm2) && check_arms(cx, arm2, arm1)
                     || is_none_arm(cx, arm1) && check_arms(cx, arm1, arm2)
                 {
-                    check_as_ref(cx, scrutinee, span);
+                    check_as_ref(cx, scrutinee, span, self.msrv);
                 }
             },
             ExprKind::If(cond, then, Some(other)) => {
@@ -81,23 +72,23 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
                     && check_some_body(cx, binding, then)
                     && is_empty_slice(cx, other.peel_blocks())
                 {
-                    check_as_ref(cx, let_expr.init, span);
+                    check_as_ref(cx, let_expr.init, span, self.msrv);
                 }
             },
             ExprKind::MethodCall(seg, callee, [], _) => {
                 if seg.ident.name.as_str() == "unwrap_or_default" {
-                    check_map(cx, callee, span);
+                    check_map(cx, callee, span, self.msrv);
                 }
             },
             ExprKind::MethodCall(seg, callee, [or], _) => match seg.ident.name.as_str() {
                 "unwrap_or" => {
                     if is_empty_slice(cx, or) {
-                        check_map(cx, callee, span);
+                        check_map(cx, callee, span, self.msrv);
                     }
                 },
                 "unwrap_or_else" => {
                     if returns_empty_slice(cx, or) {
-                        check_map(cx, callee, span);
+                        check_map(cx, callee, span, self.msrv);
                     }
                 },
                 _ => {},
@@ -105,12 +96,12 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
             ExprKind::MethodCall(seg, callee, [or_else, map], _) => match seg.ident.name.as_str() {
                 "map_or" => {
                     if is_empty_slice(cx, or_else) && is_slice_from_ref(cx, map) {
-                        check_as_ref(cx, callee, span);
+                        check_as_ref(cx, callee, span, self.msrv);
                     }
                 },
                 "map_or_else" => {
                     if returns_empty_slice(cx, or_else) && is_slice_from_ref(cx, map) {
-                        check_as_ref(cx, callee, span);
+                        check_as_ref(cx, callee, span, self.msrv);
                     }
                 },
                 _ => {},
@@ -120,20 +111,28 @@ impl LateLintPass<'_> for ManualOptionAsSlice {
     }
 }
 
-fn check_map(cx: &LateContext<'_>, map: &Expr<'_>, span: Span) {
+fn check_map(cx: &LateContext<'_>, map: &Expr<'_>, span: Span, msrv: Msrv) {
     if let ExprKind::MethodCall(seg, callee, [mapping], _) = map.kind
         && seg.ident.name == sym::map
         && is_slice_from_ref(cx, mapping)
     {
-        check_as_ref(cx, callee, span);
+        check_as_ref(cx, callee, span, msrv);
     }
 }
 
-fn check_as_ref(cx: &LateContext<'_>, expr: &Expr<'_>, span: Span) {
+fn check_as_ref(cx: &LateContext<'_>, expr: &Expr<'_>, span: Span, msrv: Msrv) {
     if let ExprKind::MethodCall(seg, callee, [], _) = expr.kind
         && seg.ident.name == sym::as_ref
         && let ty::Adt(adtdef, ..) = cx.typeck_results().expr_ty(callee).kind()
         && cx.tcx.is_diagnostic_item(sym::Option, adtdef.did())
+        && msrv.meets(
+            cx,
+            if clippy_utils::is_in_const_context(cx) {
+                msrvs::CONST_OPTION_AS_SLICE
+            } else {
+                msrvs::OPTION_AS_SLICE
+            },
+        )
     {
         if let Some(snippet) = clippy_utils::source::snippet_opt(cx, callee.span) {
             span_lint_and_sugg(
diff --git a/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs b/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs
index 469b4b7cf89f..41e07e26bff0 100644
--- a/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_rem_euclid.rs
@@ -39,9 +39,7 @@ pub struct ManualRemEuclid {
 
 impl ManualRemEuclid {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -60,8 +58,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             && add_lhs.span.ctxt() == ctxt
             && add_rhs.span.ctxt() == ctxt
             && !expr.span.in_external_macro(cx.sess().source_map())
-            && self.msrv.meets(msrvs::REM_EUCLID)
-            && (self.msrv.meets(msrvs::REM_EUCLID_CONST) || !is_in_const_context(cx))
             && let Some(const1) = check_for_unsigned_int_constant(cx, rem_rhs)
             && let Some((const2, add_other)) = check_for_either_unsigned_int_constant(cx, add_lhs, add_rhs)
             && let ExprKind::Binary(rem2_op, rem2_lhs, rem2_rhs) = add_other.kind
@@ -73,6 +69,8 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             && const2 == const3
             && rem2_lhs.span.ctxt() == ctxt
             && rem2_rhs.span.ctxt() == ctxt
+            && self.msrv.meets(cx, msrvs::REM_EUCLID)
+            && (self.msrv.meets(cx, msrvs::REM_EUCLID_CONST) || !is_in_const_context(cx))
         {
             // Apply only to params or locals with annotated types
             match cx.tcx.parent_hir_node(hir_id) {
@@ -99,8 +97,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualRemEuclid {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 // Checks if either the left or right expressions can be an unsigned int constant and returns that
diff --git a/src/tools/clippy/clippy_lints/src/manual_retain.rs b/src/tools/clippy/clippy_lints/src/manual_retain.rs
index 0a4e756096e9..16dd1ad4e478 100644
--- a/src/tools/clippy/clippy_lints/src/manual_retain.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_retain.rs
@@ -50,9 +50,7 @@ pub struct ManualRetain {
 
 impl ManualRetain {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -66,13 +64,11 @@ impl<'tcx> LateLintPass<'tcx> for ManualRetain {
             && let Some(collect_def_id) = cx.typeck_results().type_dependent_def_id(collect_expr.hir_id)
             && cx.tcx.is_diagnostic_item(sym::iterator_collect_fn, collect_def_id)
         {
-            check_into_iter(cx, left_expr, target_expr, expr.span, &self.msrv);
-            check_iter(cx, left_expr, target_expr, expr.span, &self.msrv);
-            check_to_owned(cx, left_expr, target_expr, expr.span, &self.msrv);
+            check_into_iter(cx, left_expr, target_expr, expr.span, self.msrv);
+            check_iter(cx, left_expr, target_expr, expr.span, self.msrv);
+            check_to_owned(cx, left_expr, target_expr, expr.span, self.msrv);
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn check_into_iter(
@@ -80,7 +76,7 @@ fn check_into_iter(
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
     parent_expr_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if let hir::ExprKind::MethodCall(_, into_iter_expr, [_], _) = &target_expr.kind
         && let Some(filter_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
@@ -123,7 +119,7 @@ fn check_iter(
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
     parent_expr_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
         && let Some(copied_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
@@ -181,10 +177,9 @@ fn check_to_owned(
     left_expr: &hir::Expr<'_>,
     target_expr: &hir::Expr<'_>,
     parent_expr_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if msrv.meets(msrvs::STRING_RETAIN)
-        && let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
+    if let hir::ExprKind::MethodCall(_, filter_expr, [], _) = &target_expr.kind
         && let Some(to_owned_def_id) = cx.typeck_results().type_dependent_def_id(target_expr.hir_id)
         && cx.tcx.is_diagnostic_item(sym::to_owned_method, to_owned_def_id)
         && let hir::ExprKind::MethodCall(_, chars_expr, [_], _) = &filter_expr.kind
@@ -200,6 +195,7 @@ fn check_to_owned(
         && let hir::ExprKind::Closure(closure) = closure_expr.kind
         && let filter_body = cx.tcx.hir_body(closure.body)
         && let [filter_params] = filter_body.params
+        && msrv.meets(cx, msrvs::STRING_RETAIN)
     {
         if let hir::PatKind::Ref(pat, _) = filter_params.pat.kind {
             make_span_lint_and_sugg(
@@ -253,7 +249,7 @@ fn match_acceptable_sym(cx: &LateContext<'_>, collect_def_id: DefId) -> bool {
         .any(|&method| cx.tcx.is_diagnostic_item(method, collect_def_id))
 }
 
-fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: &Msrv) -> bool {
+fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: Msrv) -> bool {
     let ty = cx.typeck_results().expr_ty(expr).peel_refs();
     let required = match get_type_diagnostic_name(cx, ty) {
         Some(sym::BinaryHeap) => msrvs::BINARY_HEAP_RETAIN,
@@ -264,7 +260,7 @@ fn match_acceptable_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>, msrv: &Msrv
         Some(sym::Vec | sym::VecDeque) => return true,
         _ => return false,
     };
-    msrv.meets(required)
+    msrv.meets(cx, required)
 }
 
 fn match_map_type(cx: &LateContext<'_>, expr: &hir::Expr<'_>) -> bool {
diff --git a/src/tools/clippy/clippy_lints/src/manual_strip.rs b/src/tools/clippy/clippy_lints/src/manual_strip.rs
index d69384a2cb70..9e911e61f196 100644
--- a/src/tools/clippy/clippy_lints/src/manual_strip.rs
+++ b/src/tools/clippy/clippy_lints/src/manual_strip.rs
@@ -2,19 +2,21 @@ use clippy_config::Conf;
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::source::snippet;
+use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::usage::mutated_variables;
 use clippy_utils::{eq_expr_value, higher};
+use rustc_ast::BindingMode;
 use rustc_ast::ast::LitKind;
+use rustc_data_structures::fx::FxHashMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::intravisit::{Visitor, walk_expr};
-use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind};
-use rustc_lint::{LateContext, LateLintPass};
+use rustc_hir::intravisit::{Visitor, walk_expr, walk_pat};
+use rustc_hir::{BinOpKind, BorrowKind, Expr, ExprKind, Node, PatKind};
+use rustc_lint::{LateContext, LateLintPass, LintContext as _};
 use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::source_map::Spanned;
-use rustc_span::{Span, sym};
+use rustc_span::{Symbol, sym};
 use std::iter;
 
 declare_clippy_lint! {
@@ -54,9 +56,7 @@ pub struct ManualStrip {
 
 impl ManualStrip {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -73,7 +73,6 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
         if let Some(higher::If { cond, then, .. }) = higher::If::hir(expr)
             && let ExprKind::MethodCall(_, target_arg, [pattern], _) = cond.kind
             && let ExprKind::Path(target_path) = &target_arg.kind
-            && self.msrv.meets(msrvs::STR_STRIP_PREFIX)
             && let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(cond.hir_id)
         {
             let strip_kind = if cx.tcx.is_diagnostic_item(sym::str_starts_with, method_def_id) {
@@ -95,18 +94,37 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                 return;
             }
 
-            let strippings = find_stripping(cx, strip_kind, target_res, pattern, then);
-            if !strippings.is_empty() {
+            let (strippings, bindings) = find_stripping(cx, strip_kind, target_res, pattern, then);
+            if !strippings.is_empty() && self.msrv.meets(cx, msrvs::STR_STRIP_PREFIX) {
                 let kind_word = match strip_kind {
                     StripKind::Prefix => "prefix",
                     StripKind::Suffix => "suffix",
                 };
 
                 let test_span = expr.span.until(then.span);
+
+                // If the first use is a simple `let` statement, reuse its identifier in the `if let Some(…)` and
+                // remove the `let` statement as long as the identifier is never bound again within the lexical
+                // scope of interest.
+                let (ident_name, let_stmt_span, skip, mut app) = if let Node::LetStmt(let_stmt) =
+                    cx.tcx.parent_hir_node(strippings[0].hir_id)
+                    && let PatKind::Binding(BindingMode::NONE, _, ident, None) = &let_stmt.pat.kind
+                    && bindings.get(&ident.name) == Some(&1)
+                {
+                    (
+                        ident.name.as_str(),
+                        Some(cx.sess().source_map().span_extend_while_whitespace(let_stmt.span)),
+                        1,
+                        Applicability::MachineApplicable,
+                    )
+                } else {
+                    ("<stripped>", None, 0, Applicability::HasPlaceholders)
+                };
+
                 span_lint_and_then(
                     cx,
                     MANUAL_STRIP,
-                    strippings[0],
+                    strippings[0].span,
                     format!("stripping a {kind_word} manually"),
                     |diag| {
                         diag.span_note(test_span, format!("the {kind_word} was tested here"));
@@ -115,22 +133,26 @@ impl<'tcx> LateLintPass<'tcx> for ManualStrip {
                             iter::once((
                                 test_span,
                                 format!(
-                                    "if let Some(<stripped>) = {}.strip_{kind_word}({}) ",
-                                    snippet(cx, target_arg.span, ".."),
-                                    snippet(cx, pattern.span, "..")
+                                    "if let Some({ident_name}) = {}.strip_{kind_word}({}) ",
+                                    snippet_with_applicability(cx, target_arg.span, "_", &mut app),
+                                    snippet_with_applicability(cx, pattern.span, "_", &mut app)
                                 ),
                             ))
-                            .chain(strippings.into_iter().map(|span| (span, "<stripped>".into())))
+                            .chain(let_stmt_span.map(|span| (span, String::new())))
+                            .chain(
+                                strippings
+                                    .into_iter()
+                                    .skip(skip)
+                                    .map(|expr| (expr.span, ident_name.into())),
+                            )
                             .collect(),
-                            Applicability::HasPlaceholders,
+                            app,
                         );
                     },
                 );
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 // Returns `Some(arg)` if `expr` matches `arg.len()` and `None` otherwise.
@@ -188,19 +210,21 @@ fn peel_ref<'a>(expr: &'a Expr<'_>) -> &'a Expr<'a> {
 /// Find expressions where `target` is stripped using the length of `pattern`.
 /// We'll suggest replacing these expressions with the result of the `strip_{prefix,suffix}`
 /// method.
+/// Also, all bindings found during the visit are counted and returned.
 fn find_stripping<'tcx>(
     cx: &LateContext<'tcx>,
     strip_kind: StripKind,
     target: Res,
     pattern: &'tcx Expr<'_>,
-    expr: &'tcx Expr<'_>,
-) -> Vec<Span> {
+    expr: &'tcx Expr<'tcx>,
+) -> (Vec<&'tcx Expr<'tcx>>, FxHashMap<Symbol, usize>) {
     struct StrippingFinder<'a, 'tcx> {
         cx: &'a LateContext<'tcx>,
         strip_kind: StripKind,
         target: Res,
         pattern: &'tcx Expr<'tcx>,
-        results: Vec<Span>,
+        results: Vec<&'tcx Expr<'tcx>>,
+        bindings: FxHashMap<Symbol, usize>,
     }
 
     impl<'tcx> Visitor<'tcx> for StrippingFinder<'_, 'tcx> {
@@ -215,7 +239,7 @@ fn find_stripping<'tcx>(
                 match (self.strip_kind, start, end) {
                     (StripKind::Prefix, Some(start), None) => {
                         if eq_pattern_length(self.cx, self.pattern, start) {
-                            self.results.push(ex.span);
+                            self.results.push(ex);
                             return;
                         }
                     },
@@ -232,7 +256,7 @@ fn find_stripping<'tcx>(
                             && self.cx.qpath_res(left_path, left_arg.hir_id) == self.target
                             && eq_pattern_length(self.cx, self.pattern, right)
                         {
-                            self.results.push(ex.span);
+                            self.results.push(ex);
                             return;
                         }
                     },
@@ -242,6 +266,13 @@ fn find_stripping<'tcx>(
 
             walk_expr(self, ex);
         }
+
+        fn visit_pat(&mut self, pat: &'tcx rustc_hir::Pat<'tcx>) -> Self::Result {
+            if let PatKind::Binding(_, _, ident, _) = pat.kind {
+                *self.bindings.entry(ident.name).or_default() += 1;
+            }
+            walk_pat(self, pat);
+        }
     }
 
     let mut finder = StrippingFinder {
@@ -250,7 +281,8 @@ fn find_stripping<'tcx>(
         target,
         pattern,
         results: vec![],
+        bindings: FxHashMap::default(),
     };
     walk_expr(&mut finder, expr);
-    finder.results
+    (finder.results, finder.bindings)
 }
diff --git a/src/tools/clippy/clippy_lints/src/matches/collapsible_match.rs b/src/tools/clippy/clippy_lints/src/matches/collapsible_match.rs
index 97e8423695d9..6f446bf95658 100644
--- a/src/tools/clippy/clippy_lints/src/matches/collapsible_match.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/collapsible_match.rs
@@ -14,7 +14,7 @@ use rustc_span::Span;
 
 use super::{COLLAPSIBLE_MATCH, pat_contains_disallowed_or};
 
-pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], msrv: &Msrv) {
+pub(super) fn check_match<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'_>], msrv: Msrv) {
     if let Some(els_arm) = arms.iter().rfind(|arm| arm_is_wild_like(cx, arm)) {
         for arm in arms {
             check_arm(cx, true, arm.pat, arm.body, arm.guard, Some(els_arm.body), msrv);
@@ -27,7 +27,7 @@ pub(super) fn check_if_let<'tcx>(
     pat: &'tcx Pat<'_>,
     body: &'tcx Expr<'_>,
     else_expr: Option<&'tcx Expr<'_>>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     check_arm(cx, false, pat, body, None, else_expr, msrv);
 }
@@ -39,7 +39,7 @@ fn check_arm<'tcx>(
     outer_then_body: &'tcx Expr<'tcx>,
     outer_guard: Option<&'tcx Expr<'tcx>>,
     outer_else_body: Option<&'tcx Expr<'tcx>>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     let inner_expr = peel_blocks_with_stmt(outer_then_body);
     if let Some(inner) = IfLetOrMatch::parse(cx, inner_expr)
@@ -60,7 +60,7 @@ fn check_arm<'tcx>(
         // match expression must be a local binding
         // match <local> { .. }
         && let Some(binding_id) = path_to_local(peel_ref_operators(cx, inner_scrutinee))
-        && !pat_contains_disallowed_or(inner_then_pat, msrv)
+        && !pat_contains_disallowed_or(cx, inner_then_pat, msrv)
         // the binding must come from the pattern of the containing match arm
         // ..<local>.. => match <local> { .. }
         && let (Some(binding_span), is_innermost_parent_pat_struct)
diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs b/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs
index 3deaaf96c1e8..576e42a564c2 100644
--- a/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/manual_ok_err.rs
@@ -1,7 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::{indent_of, reindent_multiline};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::option_arg_ty;
-use clippy_utils::{is_res_lang_ctor, path_res, peel_blocks, span_contains_comment};
+use clippy_utils::{get_parent_expr, is_res_lang_ctor, path_res, peel_blocks, span_contains_comment};
 use rustc_ast::BindingMode;
 use rustc_errors::Applicability;
 use rustc_hir::LangItem::{OptionNone, OptionSome, ResultErr};
@@ -132,13 +133,23 @@ fn apply_lint(cx: &LateContext<'_>, expr: &Expr<'_>, scrutinee: &Expr<'_>, is_ok
         Applicability::MachineApplicable
     };
     let scrut = Sugg::hir_with_applicability(cx, scrutinee, "..", &mut app).maybe_par();
+    let sugg = format!("{scrut}.{method}()");
+    // If the expression being expanded is the `if …` part of an `else if …`, it must be blockified.
+    let sugg = if let Some(parent_expr) = get_parent_expr(cx, expr)
+        && let ExprKind::If(_, _, Some(else_part)) = parent_expr.kind
+        && else_part.hir_id == expr.hir_id
+    {
+        reindent_multiline(&format!("{{\n    {sugg}\n}}"), true, indent_of(cx, parent_expr.span))
+    } else {
+        sugg
+    };
     span_lint_and_sugg(
         cx,
         MANUAL_OK_ERR,
         expr.span,
         format!("manual implementation of `{method}`"),
         "replace with",
-        format!("{scrut}.{method}()"),
+        sugg,
         app,
     );
 }
diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs b/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs
index b69294d567d1..2bf7ec8ab7dd 100644
--- a/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/manual_unwrap_or.rs
@@ -117,7 +117,7 @@ fn lint<'tcx>(
     or_body_snippet: &str,
     indent: usize,
 ) {
-    let reindented_or_body = reindent_multiline(or_body_snippet.into(), true, Some(indent));
+    let reindented_or_body = reindent_multiline(or_body_snippet, true, Some(indent));
 
     let mut app = Applicability::MachineApplicable;
     let suggestion = sugg::Sugg::hir_with_context(cx, scrutinee, expr.span.ctxt(), "..", &mut app).maybe_par();
diff --git a/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs b/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs
index 2ad55d9bf1fd..09440c396ee1 100644
--- a/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/manual_utils.rs
@@ -4,8 +4,8 @@ use clippy_utils::source::{snippet_with_applicability, snippet_with_context};
 use clippy_utils::sugg::Sugg;
 use clippy_utils::ty::{is_copy, is_type_diagnostic_item, peel_mid_ty_refs_is_mutable, type_is_unsafe_function};
 use clippy_utils::{
-    CaptureKind, can_move_expr_to_closure, is_else_clause, is_lint_allowed, is_res_lang_ctor, path_res,
-    path_to_local_id, peel_blocks, peel_hir_expr_refs, peel_hir_expr_while,
+    CaptureKind, can_move_expr_to_closure, expr_requires_coercion, is_else_clause, is_lint_allowed, is_res_lang_ctor,
+    path_res, path_to_local_id, peel_blocks, peel_hir_expr_refs, peel_hir_expr_while,
 };
 use rustc_ast::util::parser::ExprPrecedence;
 use rustc_errors::Applicability;
@@ -73,7 +73,7 @@ where
     }
 
     // `map` won't perform any adjustments.
-    if !cx.typeck_results().expr_adjustments(some_expr.expr).is_empty() {
+    if expr_requires_coercion(cx, expr) {
         return None;
     }
 
@@ -124,6 +124,12 @@ where
     };
 
     let closure_expr_snip = some_expr.to_snippet_with_context(cx, expr_ctxt, &mut app);
+    let closure_body = if some_expr.needs_unsafe_block {
+        format!("unsafe {}", closure_expr_snip.blockify())
+    } else {
+        closure_expr_snip.to_string()
+    };
+
     let body_str = if let PatKind::Binding(annotation, id, some_binding, None) = some_pat.kind {
         if !some_expr.needs_unsafe_block
             && let Some(func) = can_pass_as_func(cx, id, some_expr.expr)
@@ -145,20 +151,12 @@ where
                 ""
             };
 
-            if some_expr.needs_unsafe_block {
-                format!("|{annotation}{some_binding}| unsafe {{ {closure_expr_snip} }}")
-            } else {
-                format!("|{annotation}{some_binding}| {closure_expr_snip}")
-            }
+            format!("|{annotation}{some_binding}| {closure_body}")
         }
     } else if !is_wild_none && explicit_ref.is_none() {
         // TODO: handle explicit reference annotations.
         let pat_snip = snippet_with_context(cx, some_pat.span, expr_ctxt, "..", &mut app).0;
-        if some_expr.needs_unsafe_block {
-            format!("|{pat_snip}| unsafe {{ {closure_expr_snip} }}")
-        } else {
-            format!("|{pat_snip}| {closure_expr_snip}")
-        }
+        format!("|{pat_snip}| {closure_body}")
     } else {
         // Refutable bindings and mixed reference annotations can't be handled by `map`.
         return None;
diff --git a/src/tools/clippy/clippy_lints/src/matches/mod.rs b/src/tools/clippy/clippy_lints/src/matches/mod.rs
index 9ca914af281b..35caa7d1f3a6 100644
--- a/src/tools/clippy/clippy_lints/src/matches/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/mod.rs
@@ -1014,7 +1014,7 @@ pub struct Matches {
 impl Matches {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             infallible_destructuring_match_linted: false,
         }
     }
@@ -1073,7 +1073,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 significant_drop_in_scrutinee::check_match(cx, expr, ex, arms, source);
             }
 
-            collapsible_match::check_match(cx, arms, &self.msrv);
+            collapsible_match::check_match(cx, arms, self.msrv);
             if !from_expansion {
                 // These don't depend on a relationship between multiple arms
                 match_wild_err_arm::check(cx, ex, arms);
@@ -1086,7 +1086,9 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
 
             if !from_expansion && !contains_cfg_arm(cx, expr, ex, arms) {
                 if source == MatchSource::Normal {
-                    if !(self.msrv.meets(msrvs::MATCHES_MACRO) && match_like_matches::check_match(cx, expr, ex, arms)) {
+                    if !(self.msrv.meets(cx, msrvs::MATCHES_MACRO)
+                        && match_like_matches::check_match(cx, expr, ex, arms))
+                    {
                         match_same_arms::check(cx, arms);
                     }
 
@@ -1120,7 +1122,7 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                     needless_match::check_match(cx, ex, arms, expr);
                     match_on_vec_items::check(cx, ex);
                     match_str_case_mismatch::check(cx, ex, arms);
-                    redundant_guards::check(cx, arms, &self.msrv);
+                    redundant_guards::check(cx, arms, self.msrv);
 
                     if !is_in_const_context(cx) {
                         manual_unwrap_or::check_match(cx, expr, ex, arms);
@@ -1138,11 +1140,11 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
                 match_ref_pats::check(cx, ex, arms.iter().map(|el| el.pat), expr);
             }
         } else if let Some(if_let) = higher::IfLet::hir(cx, expr) {
-            collapsible_match::check_if_let(cx, if_let.let_pat, if_let.if_then, if_let.if_else, &self.msrv);
+            collapsible_match::check_if_let(cx, if_let.let_pat, if_let.if_then, if_let.if_else, self.msrv);
             significant_drop_in_scrutinee::check_if_let(cx, expr, if_let.let_expr, if_let.if_then, if_let.if_else);
             if !from_expansion {
                 if let Some(else_expr) = if_let.if_else {
-                    if self.msrv.meets(msrvs::MATCHES_MACRO) {
+                    if self.msrv.meets(cx, msrvs::MATCHES_MACRO) {
                         match_like_matches::check_if_let(
                             cx,
                             expr,
@@ -1208,8 +1210,6 @@ impl<'tcx> LateLintPass<'tcx> for Matches {
     fn check_pat(&mut self, cx: &LateContext<'tcx>, pat: &'tcx Pat<'_>) {
         rest_pat_in_fully_bound_struct::check(cx, pat);
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 /// Checks if there are any arms with a `#[cfg(..)]` attribute.
@@ -1274,16 +1274,12 @@ fn contains_cfg_arm(cx: &LateContext<'_>, e: &Expr<'_>, scrutinee: &Expr<'_>, ar
 }
 
 /// Checks if `pat` contains OR patterns that cannot be nested due to a too low MSRV.
-fn pat_contains_disallowed_or(pat: &Pat<'_>, msrv: &Msrv) -> bool {
-    if msrv.meets(msrvs::OR_PATTERNS) {
-        return false;
-    }
-
-    let mut result = false;
+fn pat_contains_disallowed_or(cx: &LateContext<'_>, pat: &Pat<'_>, msrv: Msrv) -> bool {
+    let mut contains_or = false;
     pat.walk(|p| {
         let is_or = matches!(p.kind, PatKind::Or(_));
-        result |= is_or;
+        contains_or |= is_or;
         !is_or
     });
-    result
+    contains_or && !msrv.meets(cx, msrvs::OR_PATTERNS)
 }
diff --git a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
index dfc0513add93..ab53ad98572e 100644
--- a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
@@ -16,7 +16,7 @@ use std::ops::ControlFlow;
 
 use super::{REDUNDANT_GUARDS, pat_contains_disallowed_or};
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>], msrv: &Msrv) {
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>], msrv: Msrv) {
     for outer_arm in arms {
         let Some(guard) = outer_arm.guard else {
             continue;
@@ -26,7 +26,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>], msrv:
         if let ExprKind::Match(scrutinee, [arm, _], MatchSource::Normal) = guard.kind
             && matching_root_macro_call(cx, guard.span, sym::matches_macro).is_some()
             && let Some(binding) = get_pat_binding(cx, scrutinee, outer_arm)
-            && !pat_contains_disallowed_or(arm.pat, msrv)
+            && !pat_contains_disallowed_or(cx, arm.pat, msrv)
         {
             let pat_span = match (arm.pat.kind, binding.byref_ident) {
                 (PatKind::Ref(pat, _), Some(_)) => pat.span,
@@ -45,7 +45,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, arms: &'tcx [Arm<'tcx>], msrv:
         // `Some(x) if let Some(2) = x`
         else if let ExprKind::Let(let_expr) = guard.kind
             && let Some(binding) = get_pat_binding(cx, let_expr.init, outer_arm)
-            && !pat_contains_disallowed_or(let_expr.pat, msrv)
+            && !pat_contains_disallowed_or(cx, let_expr.pat, msrv)
         {
             let pat_span = match (let_expr.pat.kind, binding.byref_ident) {
                 (PatKind::Ref(pat, _), Some(_)) => pat.span,
diff --git a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
index 35f2e780d2e2..37bac561a6e0 100644
--- a/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/significant_drop_in_scrutinee.rs
@@ -199,7 +199,7 @@ impl<'a, 'tcx> SigDropChecker<'a, 'tcx> {
             return false;
         }
 
-        let result = match ty.kind() {
+        match ty.kind() {
             rustc_middle::ty::Adt(adt, args) => {
                 // if some field has significant drop,
                 adt.all_fields()
@@ -223,9 +223,7 @@ impl<'a, 'tcx> SigDropChecker<'a, 'tcx> {
             rustc_middle::ty::Tuple(tys) => tys.iter().any(|ty| self.has_sig_drop_attr_impl(ty)),
             rustc_middle::ty::Array(ty, _) | rustc_middle::ty::Slice(ty) => self.has_sig_drop_attr_impl(*ty),
             _ => false,
-        };
-
-        result
+        }
     }
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/mem_replace.rs b/src/tools/clippy/clippy_lints/src/mem_replace.rs
index 41528c5dee3a..a0919947b3fc 100644
--- a/src/tools/clippy/clippy_lints/src/mem_replace.rs
+++ b/src/tools/clippy/clippy_lints/src/mem_replace.rs
@@ -8,7 +8,7 @@ use clippy_utils::{
     is_default_equivalent, is_expr_used_or_unified, is_res_lang_ctor, path_res, peel_ref_operators, std_or_core,
 };
 use rustc_errors::Applicability;
-use rustc_hir::LangItem::OptionNone;
+use rustc_hir::LangItem::{OptionNone, OptionSome};
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -43,6 +43,31 @@ declare_clippy_lint! {
     "replacing an `Option` with `None` instead of `take()`"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for `mem::replace()` on an `Option` with `Some(…)`.
+    ///
+    /// ### Why is this bad?
+    /// `Option` already has the method `replace()` for
+    /// taking its current value (Some(…) or None) and replacing it with
+    /// `Some(…)`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// let mut an_option = Some(0);
+    /// let replaced = std::mem::replace(&mut an_option, Some(1));
+    /// ```
+    /// Is better expressed with:
+    /// ```no_run
+    /// let mut an_option = Some(0);
+    /// let taken = an_option.replace(1);
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub MEM_REPLACE_OPTION_WITH_SOME,
+    style,
+    "replacing an `Option` with `Some` instead of `replace()`"
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for `mem::replace(&mut _, mem::uninitialized())`
@@ -101,28 +126,67 @@ declare_clippy_lint! {
 }
 
 impl_lint_pass!(MemReplace =>
-    [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
+    [MEM_REPLACE_OPTION_WITH_NONE, MEM_REPLACE_OPTION_WITH_SOME, MEM_REPLACE_WITH_UNINIT, MEM_REPLACE_WITH_DEFAULT]);
 
-fn check_replace_option_with_none(cx: &LateContext<'_>, dest: &Expr<'_>, expr_span: Span) {
-    // Since this is a late pass (already type-checked),
-    // and we already know that the second argument is an
-    // `Option`, we do not need to check the first
-    // argument's type. All that's left is to get
-    // the replacee's expr after peeling off the `&mut`
-    let sugg_expr = peel_ref_operators(cx, dest);
-    let mut applicability = Applicability::MachineApplicable;
-    span_lint_and_sugg(
-        cx,
-        MEM_REPLACE_OPTION_WITH_NONE,
-        expr_span,
-        "replacing an `Option` with `None`",
-        "consider `Option::take()` instead",
-        format!(
-            "{}.take()",
-            Sugg::hir_with_context(cx, sugg_expr, expr_span.ctxt(), "", &mut applicability).maybe_par()
-        ),
-        applicability,
-    );
+fn check_replace_option_with_none(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) -> bool {
+    if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
+        // Since this is a late pass (already type-checked),
+        // and we already know that the second argument is an
+        // `Option`, we do not need to check the first
+        // argument's type. All that's left is to get
+        // the replacee's expr after peeling off the `&mut`
+        let sugg_expr = peel_ref_operators(cx, dest);
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            MEM_REPLACE_OPTION_WITH_NONE,
+            expr_span,
+            "replacing an `Option` with `None`",
+            "consider `Option::take()` instead",
+            format!(
+                "{}.take()",
+                Sugg::hir_with_context(cx, sugg_expr, expr_span.ctxt(), "", &mut applicability).maybe_par()
+            ),
+            applicability,
+        );
+        true
+    } else {
+        false
+    }
+}
+
+fn check_replace_option_with_some(
+    cx: &LateContext<'_>,
+    src: &Expr<'_>,
+    dest: &Expr<'_>,
+    expr_span: Span,
+    msrv: Msrv,
+) -> bool {
+    if let ExprKind::Call(src_func, [src_arg]) = src.kind
+        && is_res_lang_ctor(cx, path_res(cx, src_func), OptionSome)
+        && msrv.meets(cx, msrvs::OPTION_REPLACE)
+    {
+        // We do not have to check for a `const` context here, because `core::mem::replace()` and
+        // `Option::replace()` have been const-stabilized simultaneously in version 1.83.0.
+        let sugg_expr = peel_ref_operators(cx, dest);
+        let mut applicability = Applicability::MachineApplicable;
+        span_lint_and_sugg(
+            cx,
+            MEM_REPLACE_OPTION_WITH_SOME,
+            expr_span,
+            "replacing an `Option` with `Some(..)`",
+            "consider `Option::replace()` instead",
+            format!(
+                "{}.replace({})",
+                Sugg::hir_with_context(cx, sugg_expr, expr_span.ctxt(), "_", &mut applicability).maybe_par(),
+                snippet_with_applicability(cx, src_arg.span, "_", &mut applicability)
+            ),
+            applicability,
+        );
+        true
+    } else {
+        false
+    }
 }
 
 fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
@@ -181,27 +245,35 @@ fn check_replace_with_uninit(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'
     }
 }
 
-fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<'_>, expr_span: Span) {
-    // disable lint for primitives
-    let expr_type = cx.typeck_results().expr_ty_adjusted(src);
-    if is_non_aggregate_primitive_type(expr_type) {
-        return;
-    }
-    if is_default_equivalent(cx, src) && !expr_span.in_external_macro(cx.tcx.sess.source_map()) {
-        let Some(top_crate) = std_or_core(cx) else { return };
+fn check_replace_with_default(
+    cx: &LateContext<'_>,
+    src: &Expr<'_>,
+    dest: &Expr<'_>,
+    expr: &Expr<'_>,
+    msrv: Msrv,
+) -> bool {
+    if is_expr_used_or_unified(cx.tcx, expr)
+        // disable lint for primitives
+        && let expr_type = cx.typeck_results().expr_ty_adjusted(src)
+        && !is_non_aggregate_primitive_type(expr_type)
+        && is_default_equivalent(cx, src)
+        && !expr.span.in_external_macro(cx.tcx.sess.source_map())
+        && let Some(top_crate) = std_or_core(cx)
+        && msrv.meets(cx, msrvs::MEM_TAKE)
+    {
         span_lint_and_then(
             cx,
             MEM_REPLACE_WITH_DEFAULT,
-            expr_span,
+            expr.span,
             format!(
                 "replacing a value of type `T` with `T::default()` is better expressed using `{top_crate}::mem::take`"
             ),
             |diag| {
-                if !expr_span.from_expansion() {
+                if !expr.span.from_expansion() {
                     let suggestion = format!("{top_crate}::mem::take({})", snippet(cx, dest.span, ""));
 
                     diag.span_suggestion(
-                        expr_span,
+                        expr.span,
                         "consider using",
                         suggestion,
                         Applicability::MachineApplicable,
@@ -209,6 +281,9 @@ fn check_replace_with_default(cx: &LateContext<'_>, src: &Expr<'_>, dest: &Expr<
                 }
             },
         );
+        true
+    } else {
+        false
     }
 }
 
@@ -218,9 +293,7 @@ pub struct MemReplace {
 
 impl MemReplace {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -233,13 +306,12 @@ impl<'tcx> LateLintPass<'tcx> for MemReplace {
             && cx.tcx.is_diagnostic_item(sym::mem_replace, def_id)
         {
             // Check that second argument is `Option::None`
-            if is_res_lang_ctor(cx, path_res(cx, src), OptionNone) {
-                check_replace_option_with_none(cx, dest, expr.span);
-            } else if self.msrv.meets(msrvs::MEM_TAKE) && is_expr_used_or_unified(cx.tcx, expr) {
-                check_replace_with_default(cx, src, dest, expr.span);
+            if !check_replace_option_with_none(cx, src, dest, expr.span)
+                && !check_replace_option_with_some(cx, src, dest, expr.span, self.msrv)
+                && !check_replace_with_default(cx, src, dest, expr, self.msrv)
+            {
+                check_replace_with_uninit(cx, src, dest, expr.span);
             }
-            check_replace_with_uninit(cx, src, dest, expr.span);
         }
     }
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs b/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
index 76bdbe55e2f3..18568e3661fe 100644
--- a/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/case_sensitive_file_extension_comparisons.rs
@@ -57,14 +57,13 @@ pub(super) fn check<'tcx>(
                     };
 
                     let suggestion_source = reindent_multiline(
-                        format!(
+                        &format!(
                             "std::path::Path::new({})
                                 .extension()
                                 .map_or(false, |ext| ext.eq_ignore_ascii_case(\"{}\"))",
                             recv_source,
                             ext_str.strip_prefix('.').unwrap()
-                        )
-                        .into(),
+                        ),
                         true,
                         Some(indent_of(cx, call_span).unwrap_or(0) + 4),
                     );
diff --git a/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs b/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs
index 223a960b800e..f50fb627b89a 100644
--- a/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/cloned_instead_of_copied.rs
@@ -10,16 +10,16 @@ use rustc_span::{Span, sym};
 
 use super::CLONED_INSTEAD_OF_COPIED;
 
-pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: &Msrv) {
+pub fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, span: Span, msrv: Msrv) {
     let recv_ty = cx.typeck_results().expr_ty_adjusted(recv);
     let inner_ty = match recv_ty.kind() {
         // `Option<T>` -> `T`
         ty::Adt(adt, subst)
-            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) && msrv.meets(msrvs::OPTION_COPIED) =>
+            if cx.tcx.is_diagnostic_item(sym::Option, adt.did()) && msrv.meets(cx, msrvs::OPTION_COPIED) =>
         {
             subst.type_at(0)
         },
-        _ if is_trait_method(cx, expr, sym::Iterator) && msrv.meets(msrvs::ITERATOR_COPIED) => {
+        _ if is_trait_method(cx, expr, sym::Iterator) && msrv.meets(cx, msrvs::ITERATOR_COPIED) => {
             match get_iterator_item_ty(cx, recv_ty) {
                 // <T as Iterator>::Item
                 Some(ty) => ty,
diff --git a/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs b/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs
index 208172980c9f..e82211bbf3ef 100644
--- a/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/double_ended_iterator_last.rs
@@ -1,8 +1,8 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::is_trait_method;
+use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::implements_trait;
+use clippy_utils::{is_mutable, is_trait_method, path_to_local};
 use rustc_errors::Applicability;
-use rustc_hir::Expr;
+use rustc_hir::{Expr, Node, PatKind};
 use rustc_lint::LateContext;
 use rustc_middle::ty::Instance;
 use rustc_span::{Span, sym};
@@ -28,14 +28,47 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &'_ Expr<'_>, self_expr: &'_ Exp
         // if the resolved method is the same as the provided definition
         && fn_def.def_id() == last_def.def_id
     {
-        span_lint_and_sugg(
+        let mut sugg = vec![(call_span, String::from("next_back()"))];
+        let mut dont_apply = false;
+        // if `self_expr` is a reference, it is mutable because it is used for `.last()`
+        if !(is_mutable(cx, self_expr) || self_type.is_ref()) {
+            if let Some(hir_id) = path_to_local(self_expr)
+                && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
+                && let PatKind::Binding(_, _, ident, _) = pat.kind
+            {
+                sugg.push((ident.span.shrink_to_lo(), String::from("mut ")));
+            } else {
+                // If we can't make the binding mutable, make the suggestion `Unspecified` to prevent it from being
+                // automatically applied, and add a complementary help message.
+                dont_apply = true;
+            }
+        }
+        span_lint_and_then(
             cx,
             DOUBLE_ENDED_ITERATOR_LAST,
-            call_span,
+            expr.span,
             "called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator",
-            "try",
-            "next_back()".to_string(),
-            Applicability::MachineApplicable,
+            |diag| {
+                let expr_ty = cx.typeck_results().expr_ty(expr);
+                let droppable_elements = expr_ty.has_significant_drop(cx.tcx, cx.typing_env());
+                diag.multipart_suggestion(
+                    "try",
+                    sugg,
+                    if dont_apply {
+                        Applicability::Unspecified
+                    } else if droppable_elements {
+                        Applicability::MaybeIncorrect
+                    } else {
+                        Applicability::MachineApplicable
+                    },
+                );
+                if droppable_elements {
+                    diag.note("this change will alter drop order which may be undesirable");
+                }
+                if dont_apply {
+                    diag.span_note(self_expr.span, "this must be made mutable to use `.next_back()`");
+                }
+            },
         );
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/methods/err_expect.rs b/src/tools/clippy/clippy_lints/src/methods/err_expect.rs
index f2786efa44cb..91ddaca07d8b 100644
--- a/src/tools/clippy/clippy_lints/src/methods/err_expect.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/err_expect.rs
@@ -14,19 +14,16 @@ pub(super) fn check(
     recv: &rustc_hir::Expr<'_>,
     expect_span: Span,
     err_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result)
-        // Test the version to make sure the lint can be showed (expect_err has been
-        // introduced in rust 1.17.0 : https://github.com/rust-lang/rust/pull/38982)
-        && msrv.meets(msrvs::EXPECT_ERR)
-
         // Grabs the `Result<T, E>` type
         && let result_type = cx.typeck_results().expr_ty(recv)
         // Tests if the T type in a `Result<T, E>` is not None
         && let Some(data_type) = get_data_type(cx, result_type)
         // Tests if the T type in a `Result<T, E>` implements debug
         && has_debug_impl(cx, data_type)
+        && msrv.meets(cx, msrvs::EXPECT_ERR)
     {
         span_lint_and_sugg(
             cx,
diff --git a/src/tools/clippy/clippy_lints/src/methods/filter_map.rs b/src/tools/clippy/clippy_lints/src/methods/filter_map.rs
index 5b9df6c2bfdd..ae300cd5fe56 100644
--- a/src/tools/clippy/clippy_lints/src/methods/filter_map.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/filter_map.rs
@@ -12,7 +12,6 @@ use rustc_lint::LateContext;
 use rustc_middle::ty::adjustment::Adjust;
 use rustc_span::Span;
 use rustc_span::symbol::{Ident, Symbol, sym};
-use std::borrow::Cow;
 
 use super::{MANUAL_FILTER_MAP, MANUAL_FIND_MAP, OPTION_FILTER_MAP, RESULT_FILTER_MAP};
 
@@ -302,7 +301,7 @@ pub(super) fn check(
             filter_span.with_hi(expr.span.hi()),
             "`filter` for `Some` followed by `unwrap`",
             "consider using `flatten` instead",
-            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, map_span)).into_owned(),
+            reindent_multiline("flatten()", true, indent_of(cx, map_span)),
             Applicability::MachineApplicable,
         );
 
@@ -316,7 +315,7 @@ pub(super) fn check(
             filter_span.with_hi(expr.span.hi()),
             "`filter` for `Ok` followed by `unwrap`",
             "consider using `flatten` instead",
-            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, map_span)).into_owned(),
+            reindent_multiline("flatten()", true, indent_of(cx, map_span)),
             Applicability::MachineApplicable,
         );
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/filter_map_next.rs b/src/tools/clippy/clippy_lints/src/methods/filter_map_next.rs
index 3f89e5931487..9f3c346042ff 100644
--- a/src/tools/clippy/clippy_lints/src/methods/filter_map_next.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/filter_map_next.rs
@@ -14,10 +14,10 @@ pub(super) fn check<'tcx>(
     expr: &'tcx hir::Expr<'_>,
     recv: &'tcx hir::Expr<'_>,
     arg: &'tcx hir::Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if is_trait_method(cx, expr, sym::Iterator) {
-        if !msrv.meets(msrvs::ITERATOR_FIND_MAP) {
+        if !msrv.meets(cx, msrvs::ITERATOR_FIND_MAP) {
             return;
         }
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/io_other_error.rs b/src/tools/clippy/clippy_lints/src/methods/io_other_error.rs
new file mode 100644
index 000000000000..4659e9e163fe
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/io_other_error.rs
@@ -0,0 +1,37 @@
+use clippy_utils::diagnostics::span_lint_and_then;
+use clippy_utils::msrvs::{self, Msrv};
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind, QPath};
+use rustc_lint::LateContext;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, path: &Expr<'_>, args: &[Expr<'_>], msrv: Msrv) {
+    if let [error_kind, error] = args
+        && !expr.span.from_expansion()
+        && !error_kind.span.from_expansion()
+        && clippy_utils::is_expr_path_def_path(cx, path, &clippy_utils::paths::IO_ERROR_NEW)
+        && clippy_utils::is_expr_path_def_path(
+            cx,
+            clippy_utils::expr_or_init(cx, error_kind),
+            &clippy_utils::paths::IO_ERRORKIND_OTHER,
+        )
+        && let ExprKind::Path(QPath::TypeRelative(_, new_segment)) = path.kind
+        && msrv.meets(cx, msrvs::IO_ERROR_OTHER)
+    {
+        span_lint_and_then(
+            cx,
+            super::IO_OTHER_ERROR,
+            expr.span,
+            "this can be `std::io::Error::other(_)`",
+            |diag| {
+                diag.multipart_suggestion_verbose(
+                    "use `std::io::Error::other`",
+                    vec![
+                        (new_segment.ident.span, "other".to_owned()),
+                        (error_kind.span.until(error.span), String::new()),
+                    ],
+                    Applicability::MachineApplicable,
+                );
+            },
+        );
+    }
+}
diff --git a/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs b/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs
index d8bb9e377a0c..9c32e9ac539d 100644
--- a/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/is_digit_ascii_radix.rs
@@ -12,12 +12,8 @@ pub(super) fn check<'tcx>(
     expr: &'tcx Expr<'_>,
     self_arg: &'tcx Expr<'_>,
     radix: &'tcx Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if !msrv.meets(msrvs::IS_ASCII_DIGIT) {
-        return;
-    }
-
     if !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_char() {
         return;
     }
@@ -30,6 +26,10 @@ pub(super) fn check<'tcx>(
         };
         let mut applicability = Applicability::MachineApplicable;
 
+        if !msrv.meets(cx, msrvs::IS_ASCII_DIGIT) {
+            return;
+        }
+
         span_lint_and_sugg(
             cx,
             IS_DIGIT_ASCII_RADIX,
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs b/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs
index 76a0c0061e52..bafabec7e069 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_filter.rs
@@ -12,7 +12,6 @@ use rustc_hir as hir;
 use rustc_hir::QPath;
 use rustc_span::Span;
 use rustc_span::symbol::{Ident, Symbol, sym};
-use std::borrow::Cow;
 
 ///
 /// Returns true if the expression is a method call to `method_name`
@@ -181,7 +180,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir
             filter_span.with_hi(expr.span.hi()),
             "`filter` for `is_ok` on iterator over `Result`s",
             "consider using `flatten` instead",
-            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
+            reindent_multiline("flatten()", true, indent_of(cx, filter_span)),
             Applicability::HasPlaceholders,
         ),
         Some(FilterType::IsSome) => span_lint_and_sugg(
@@ -190,7 +189,7 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, filter_arg: &hir
             filter_span.with_hi(expr.span.hi()),
             "`filter` for `is_some` on iterator over `Option`",
             "consider using `flatten` instead",
-            reindent_multiline(Cow::Borrowed("flatten()"), true, indent_of(cx, filter_span)).into_owned(),
+            reindent_multiline("flatten()", true, indent_of(cx, filter_span)),
             Applicability::HasPlaceholders,
         ),
     }
diff --git a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
index 518041177e92..94415fc91061 100644
--- a/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/iter_kv_map.rs
@@ -20,9 +20,9 @@ pub(super) fn check<'tcx>(
     expr: &'tcx Expr<'tcx>,  // .iter().map(|(_, v_| v))
     recv: &'tcx Expr<'tcx>,  // hashmap
     m_arg: &'tcx Expr<'tcx>, // |(_, v)| v
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if map_type == "into_iter" && !msrv.meets(msrvs::INTO_KEYS) {
+    if map_type == "into_iter" && !msrv.meets(cx, msrvs::INTO_KEYS) {
         return;
     }
     if !expr.span.from_expansion()
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_c_str_literals.rs b/src/tools/clippy/clippy_lints/src/methods/manual_c_str_literals.rs
index e1ebca0b09df..0274e31b4c33 100644
--- a/src/tools/clippy/clippy_lints/src/methods/manual_c_str_literals.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_c_str_literals.rs
@@ -22,7 +22,7 @@ pub(super) fn check_as_ptr<'tcx>(
     cx: &LateContext<'tcx>,
     expr: &'tcx Expr<'tcx>,
     receiver: &'tcx Expr<'tcx>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if let ExprKind::Lit(lit) = receiver.kind
         && let LitKind::ByteStr(_, StrStyle::Cooked) | LitKind::Str(_, StrStyle::Cooked) = lit.node
@@ -32,7 +32,7 @@ pub(super) fn check_as_ptr<'tcx>(
             |parent| matches!(parent.kind, ExprKind::Call(func, _) if is_c_str_function(cx, func).is_some()),
         )
         && let Some(sugg) = rewrite_as_cstr(cx, lit.span)
-        && msrv.meets(msrvs::C_STR_LITERALS)
+        && msrv.meets(cx, msrvs::C_STR_LITERALS)
     {
         span_lint_and_sugg(
             cx,
@@ -65,11 +65,11 @@ fn is_c_str_function(cx: &LateContext<'_>, func: &Expr<'_>) -> Option<Symbol> {
 /// - `CStr::from_bytes_with_nul(..)`
 /// - `CStr::from_bytes_with_nul_unchecked(..)`
 /// - `CStr::from_ptr(..)`
-pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args: &[Expr<'_>], msrv: &Msrv) {
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, func: &Expr<'_>, args: &[Expr<'_>], msrv: Msrv) {
     if let Some(fn_name) = is_c_str_function(cx, func)
         && let [arg] = args
         && cx.tcx.sess.edition() >= Edition2021
-        && msrv.meets(msrvs::C_STR_LITERALS)
+        && msrv.meets(cx, msrvs::C_STR_LITERALS)
     {
         match fn_name.as_str() {
             name @ ("from_bytes_with_nul" | "from_bytes_with_nul_unchecked")
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs b/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs
new file mode 100644
index 000000000000..8ba0f835d3dd
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_contains.rs
@@ -0,0 +1,113 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::eager_or_lazy::switch_to_eager_eval;
+use clippy_utils::peel_hir_pat_refs;
+use clippy_utils::source::snippet_with_applicability;
+use clippy_utils::sugg::Sugg;
+use rustc_ast::UnOp;
+use rustc_errors::Applicability;
+use rustc_hir::def::Res;
+use rustc_hir::{BinOpKind, Body, Expr, ExprKind, HirId, QPath};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self};
+use rustc_span::source_map::Spanned;
+
+use super::MANUAL_CONTAINS;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, recv: &Expr<'_>, closure_arg: &Expr<'_>) {
+    let mut app = Applicability::MachineApplicable;
+
+    if !expr.span.from_expansion()
+        // check if `iter().any()` can be replaced with `contains()`
+        && let ExprKind::Closure(closure) = closure_arg.kind
+        && let Body{params: [param],value} = cx.tcx.hir_body(closure.body)
+        && let ExprKind::Binary(op, lhs, rhs) = value.kind
+        && let (peeled_ref_pat, _) = peel_hir_pat_refs(param.pat)
+        && let Some((snip,snip_expr)) = can_replace_with_contains(cx, op, lhs, rhs, peeled_ref_pat.hir_id, &mut app)
+        && let ref_type = cx.typeck_results().expr_ty_adjusted(recv)
+        && let ty::Ref(_, inner_type, _) = ref_type.kind()
+        && let ty::Slice(slice_type) = inner_type.kind()
+        && *slice_type == cx.typeck_results().expr_ty(snip_expr)
+    {
+        span_lint_and_sugg(
+            cx,
+            MANUAL_CONTAINS,
+            expr.span,
+            "using `contains()` instead of `iter().any()` is more efficient",
+            "try",
+            format!(
+                "{}.contains({})",
+                snippet_with_applicability(cx, recv.span, "_", &mut app),
+                snip
+            ),
+            app,
+        );
+    }
+}
+
+enum EligibleArg {
+    IsClosureArg,
+    ContainsArg(String),
+}
+
+fn try_get_eligible_arg<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'tcx>,
+    closure_arg_id: HirId,
+    applicability: &mut Applicability,
+) -> Option<(EligibleArg, &'tcx Expr<'tcx>)> {
+    let mut get_snippet = |expr: &Expr<'_>, needs_borrow: bool| {
+        let sugg = Sugg::hir_with_applicability(cx, expr, "_", applicability);
+        EligibleArg::ContainsArg((if needs_borrow { sugg.addr() } else { sugg }).to_string())
+    };
+
+    match expr.kind {
+        ExprKind::Path(QPath::Resolved(_, path)) => {
+            if path.res == Res::Local(closure_arg_id) {
+                Some((EligibleArg::IsClosureArg, expr))
+            } else {
+                Some((get_snippet(expr, true), expr))
+            }
+        },
+        ExprKind::Unary(UnOp::Deref, inner) => {
+            if let ExprKind::Path(QPath::Resolved(_, path)) = inner.kind {
+                if path.res == Res::Local(closure_arg_id) {
+                    Some((EligibleArg::IsClosureArg, expr))
+                } else {
+                    Some((get_snippet(inner, false), expr))
+                }
+            } else {
+                None
+            }
+        },
+        _ => {
+            if switch_to_eager_eval(cx, expr) {
+                Some((get_snippet(expr, true), expr))
+            } else {
+                None
+            }
+        },
+    }
+}
+
+fn can_replace_with_contains<'tcx>(
+    cx: &LateContext<'tcx>,
+    bin_op: Spanned<BinOpKind>,
+    left_expr: &'tcx Expr<'tcx>,
+    right_expr: &'tcx Expr<'tcx>,
+    closure_arg_id: HirId,
+    applicability: &mut Applicability,
+) -> Option<(String, &'tcx Expr<'tcx>)> {
+    if bin_op.node != BinOpKind::Eq {
+        return None;
+    }
+
+    let left_candidate = try_get_eligible_arg(cx, left_expr, closure_arg_id, applicability)?;
+    let right_candidate = try_get_eligible_arg(cx, right_expr, closure_arg_id, applicability)?;
+    match (left_candidate, right_candidate) {
+        ((EligibleArg::IsClosureArg, _), (EligibleArg::ContainsArg(snip), candidate_expr))
+        | ((EligibleArg::ContainsArg(snip), candidate_expr), (EligibleArg::IsClosureArg, _)) => {
+            Some((snip, candidate_expr))
+        },
+        _ => None,
+    }
+}
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs b/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs
index 09ccb386a20b..173ebcb7020b 100644
--- a/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_inspect.rs
@@ -14,14 +14,14 @@ use rustc_span::{DUMMY_SP, Span, Symbol, sym};
 use super::MANUAL_INSPECT;
 
 #[expect(clippy::too_many_lines)]
-pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, name: &str, name_span: Span, msrv: &Msrv) {
+pub(crate) fn check(cx: &LateContext<'_>, expr: &Expr<'_>, arg: &Expr<'_>, name: &str, name_span: Span, msrv: Msrv) {
     if let ExprKind::Closure(c) = arg.kind
         && matches!(c.kind, ClosureKind::Closure)
         && let typeck = cx.typeck_results()
         && let Some(fn_id) = typeck.type_dependent_def_id(expr.hir_id)
         && (is_diag_trait_item(cx, fn_id, sym::Iterator)
-            || (msrv.meets(msrvs::OPTION_RESULT_INSPECT)
-                && (is_diag_item_method(cx, fn_id, sym::Option) || is_diag_item_method(cx, fn_id, sym::Result))))
+            || ((is_diag_item_method(cx, fn_id, sym::Option) || is_diag_item_method(cx, fn_id, sym::Result))
+                && msrv.meets(cx, msrvs::OPTION_RESULT_INSPECT)))
         && let body = cx.tcx.hir_body(c.body)
         && let [param] = body.params
         && let PatKind::Binding(BindingMode(ByRef::No, Mutability::Not), arg_id, _, None) = param.pat.kind
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs b/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs
index 90e502f244fa..40aad03960c4 100644
--- a/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_is_variant_and.rs
@@ -14,7 +14,7 @@ pub(super) fn check<'tcx>(
     map_recv: &'tcx rustc_hir::Expr<'_>,
     map_arg: &'tcx rustc_hir::Expr<'_>,
     map_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     // Don't lint if:
 
@@ -36,7 +36,7 @@ pub(super) fn check<'tcx>(
     }
 
     // 4. msrv doesn't meet `OPTION_RESULT_IS_VARIANT_AND`
-    if !msrv.meets(msrvs::OPTION_RESULT_IS_VARIANT_AND) {
+    if !msrv.meets(cx, msrvs::OPTION_RESULT_IS_VARIANT_AND) {
         return;
     }
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs b/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs
index 8265c93bfe9f..c286c5faaed3 100644
--- a/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_ok_or.rs
@@ -27,7 +27,7 @@ pub(super) fn check<'tcx>(
         && let Some(err_arg_snippet) = err_arg.span.get_source_text(cx)
         && let Some(indent) = indent_of(cx, expr.span)
     {
-        let reindented_err_arg_snippet = reindent_multiline(err_arg_snippet.as_str().into(), true, Some(indent + 4));
+        let reindented_err_arg_snippet = reindent_multiline(err_arg_snippet.as_str(), true, Some(indent + 4));
         span_lint_and_sugg(
             cx,
             MANUAL_OK_OR,
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs b/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs
index 6e09bf132aa1..83b57cca17bf 100644
--- a/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_repeat_n.rs
@@ -14,16 +14,16 @@ pub(super) fn check<'tcx>(
     expr: &'tcx Expr<'tcx>,
     repeat_expr: &Expr<'_>,
     take_arg: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if msrv.meets(msrvs::REPEAT_N)
-        && !expr.span.from_expansion()
+    if !expr.span.from_expansion()
         && is_trait_method(cx, expr, sym::Iterator)
         && let ExprKind::Call(_, [repeat_arg]) = repeat_expr.kind
         && let Some(def_id) = fn_def_id(cx, repeat_expr)
         && cx.tcx.is_diagnostic_item(sym::iter_repeat, def_id)
         && !expr_use_ctxt(cx, expr).is_ty_unified
         && let Some(std_or_core) = std_or_core(cx)
+        && msrv.meets(cx, msrvs::REPEAT_N)
     {
         let mut app = Applicability::MachineApplicable;
         span_lint_and_sugg(
diff --git a/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs b/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs
index a56378b5b73a..23dba47f60f4 100644
--- a/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/manual_try_fold.rs
@@ -17,10 +17,9 @@ pub(super) fn check<'tcx>(
     init: &Expr<'_>,
     acc: &Expr<'_>,
     fold_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if !fold_span.in_external_macro(cx.sess().source_map())
-        && msrv.meets(msrvs::ITERATOR_TRY_FOLD)
         && is_trait_method(cx, expr, sym::Iterator)
         && let init_ty = cx.typeck_results().expr_ty(init)
         && let Some(try_trait) = cx.tcx.lang_items().try_trait()
@@ -29,6 +28,7 @@ pub(super) fn check<'tcx>(
         && let ExprKind::Path(qpath) = path.kind
         && let Res::Def(DefKind::Ctor(_, _), _) = cx.qpath_res(&qpath, path.hir_id)
         && let ExprKind::Closure(closure) = acc.kind
+        && msrv.meets(cx, msrvs::ITERATOR_TRY_FOLD)
         && !is_from_proc_macro(cx, expr)
         && let Some(args_snip) = closure
             .fn_arg_span
diff --git a/src/tools/clippy/clippy_lints/src/methods/map_clone.rs b/src/tools/clippy/clippy_lints/src/methods/map_clone.rs
index b2705e1ffc2d..128b3695f48b 100644
--- a/src/tools/clippy/clippy_lints/src/methods/map_clone.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/map_clone.rs
@@ -41,7 +41,7 @@ fn should_run_lint(cx: &LateContext<'_>, e: &hir::Expr<'_>, method_id: DefId) ->
     true
 }
 
-pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: &Msrv) {
+pub(super) fn check(cx: &LateContext<'_>, e: &hir::Expr<'_>, recv: &hir::Expr<'_>, arg: &hir::Expr<'_>, msrv: Msrv) {
     if let Some(method_id) = cx.typeck_results().type_dependent_def_id(e.hir_id)
         && should_run_lint(cx, e, method_id)
     {
@@ -169,10 +169,10 @@ fn lint_path(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool) {
     );
 }
 
-fn lint_explicit_closure(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool, msrv: &Msrv) {
+fn lint_explicit_closure(cx: &LateContext<'_>, replace: Span, root: Span, is_copy: bool, msrv: Msrv) {
     let mut applicability = Applicability::MachineApplicable;
 
-    let (message, sugg_method) = if is_copy && msrv.meets(msrvs::ITERATOR_COPIED) {
+    let (message, sugg_method) = if is_copy && msrv.meets(cx, msrvs::ITERATOR_COPIED) {
         ("you are using an explicit closure for copying elements", "copied")
     } else {
         ("you are using an explicit closure for cloning elements", "cloned")
diff --git a/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs b/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs
index 428da0cf107e..df5a0de3392b 100644
--- a/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/map_unwrap_or.rs
@@ -19,13 +19,13 @@ pub(super) fn check<'tcx>(
     recv: &'tcx hir::Expr<'_>,
     map_arg: &'tcx hir::Expr<'_>,
     unwrap_arg: &'tcx hir::Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     // lint if the caller of `map()` is an `Option` or a `Result`.
     let is_option = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option);
     let is_result = is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Result);
 
-    if is_result && !msrv.meets(msrvs::RESULT_MAP_OR_ELSE) {
+    if is_result && !msrv.meets(cx, msrvs::RESULT_MAP_OR_ELSE) {
         return false;
     }
 
diff --git a/src/tools/clippy/clippy_lints/src/methods/map_with_unused_argument_over_ranges.rs b/src/tools/clippy/clippy_lints/src/methods/map_with_unused_argument_over_ranges.rs
index 35dd7c082c90..6cf0936c598f 100644
--- a/src/tools/clippy/clippy_lints/src/methods/map_with_unused_argument_over_ranges.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/map_with_unused_argument_over_ranges.rs
@@ -62,7 +62,7 @@ pub(super) fn check(
     ex: &Expr<'_>,
     receiver: &Expr<'_>,
     arg: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
     method_call_span: Span,
 ) {
     let mut applicability = Applicability::MaybeIncorrect;
@@ -82,7 +82,7 @@ pub(super) fn check(
         let use_take;
 
         if eager_or_lazy::switch_to_eager_eval(cx, body_expr) {
-            if msrv.meets(msrvs::REPEAT_N) {
+            if msrv.meets(cx, msrvs::REPEAT_N) {
                 method_to_use_name = "repeat_n";
                 let body_snippet = snippet_with_applicability(cx, body_expr.span, "..", &mut applicability);
                 new_span = (arg.span, format!("{body_snippet}, {count}"));
@@ -93,7 +93,7 @@ pub(super) fn check(
                 new_span = (arg.span, body_snippet.to_string());
                 use_take = true;
             }
-        } else if msrv.meets(msrvs::REPEAT_WITH) {
+        } else if msrv.meets(cx, msrvs::REPEAT_WITH) {
             method_to_use_name = "repeat_with";
             new_span = (param.span, String::new());
             use_take = true;
diff --git a/src/tools/clippy/clippy_lints/src/methods/mod.rs b/src/tools/clippy/clippy_lints/src/methods/mod.rs
index b58e8ba32e78..94d3657d9f12 100644
--- a/src/tools/clippy/clippy_lints/src/methods/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/mod.rs
@@ -36,6 +36,7 @@ mod implicit_clone;
 mod inefficient_to_string;
 mod inspect_for_each;
 mod into_iter_on_ref;
+mod io_other_error;
 mod is_digit_ascii_radix;
 mod is_empty;
 mod iter_cloned_collect;
@@ -54,6 +55,7 @@ mod iter_with_drain;
 mod iterator_step_by_zero;
 mod join_absolute_paths;
 mod manual_c_str_literals;
+mod manual_contains;
 mod manual_inspect;
 mod manual_is_variant_and;
 mod manual_next_back;
@@ -82,7 +84,6 @@ mod ok_expect;
 mod open_options;
 mod option_as_ref_cloned;
 mod option_as_ref_deref;
-mod option_map_or_err_ok;
 mod option_map_or_none;
 mod option_map_unwrap_or;
 mod or_fun_call;
@@ -114,6 +115,7 @@ mod suspicious_map;
 mod suspicious_splitn;
 mod suspicious_to_owned;
 mod type_id_on_box;
+mod unbuffered_bytes;
 mod uninit_assumed_init;
 mod unit_hash;
 mod unnecessary_fallible_conversions;
@@ -2642,7 +2644,7 @@ declare_clippy_lint! {
     /// ```
     #[clippy::version = "1.49.0"]
     pub MANUAL_OK_OR,
-    pedantic,
+    style,
     "finds patterns that can be encoded more concisely with `Option::ok_or`"
 }
 
@@ -3784,31 +3786,6 @@ declare_clippy_lint! {
     "calls to `Path::join` which will overwrite the original path"
 }
 
-declare_clippy_lint! {
-    /// ### What it does
-    /// Checks for usage of `_.map_or(Err(_), Ok)`.
-    ///
-    /// ### Why is this bad?
-    /// Readability, this can be written more concisely as
-    /// `_.ok_or(_)`.
-    ///
-    /// ### Example
-    /// ```no_run
-    /// # let opt = Some(1);
-    /// opt.map_or(Err("error"), Ok);
-    /// ```
-    ///
-    /// Use instead:
-    /// ```no_run
-    /// # let opt = Some(1);
-    /// opt.ok_or("error");
-    /// ```
-    #[clippy::version = "1.76.0"]
-    pub OPTION_MAP_OR_ERR_OK,
-    style,
-    "using `Option.map_or(Err(_), Ok)`, which is more succinctly expressed as `Option.ok_or(_)`"
-}
-
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for iterators of `Result`s using `.filter(Result::is_ok).map(Result::unwrap)` that may
@@ -4433,11 +4410,88 @@ declare_clippy_lint! {
     "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 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
+    /// use std::io::{BufReader, Read};
+    /// use std::fs::File;
+    /// let file = BufReader::new(std::fs::File::open("./bytes.txt").unwrap());
+    /// file.bytes();
+    /// ```
+    #[clippy::version = "1.86.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 `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, sometimes more fast.
+    ///
+    /// ### 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.86.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.86.0"]
+    pub IO_OTHER_ERROR,
+    style,
+    "calling `std::io::Error::new(std::io::ErrorKind::Other, _)`"
+}
+
+#[expect(clippy::struct_excessive_bools)]
 pub struct Methods {
     avoid_breaking_exported_api: bool,
     msrv: Msrv,
     allow_expect_in_tests: bool,
     allow_unwrap_in_tests: bool,
+    allow_expect_in_consts: bool,
+    allow_unwrap_in_consts: bool,
     allowed_dotfiles: FxHashSet<&'static str>,
     format_args: FormatArgsStorage,
 }
@@ -4449,9 +4503,11 @@ impl Methods {
 
         Self {
             avoid_breaking_exported_api: conf.avoid_breaking_exported_api,
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             allow_expect_in_tests: conf.allow_expect_in_tests,
             allow_unwrap_in_tests: conf.allow_unwrap_in_tests,
+            allow_expect_in_consts: conf.allow_expect_in_consts,
+            allow_unwrap_in_consts: conf.allow_unwrap_in_consts,
             allowed_dotfiles,
             format_args,
         }
@@ -4580,7 +4636,6 @@ impl_lint_pass!(Methods => [
     WAKER_CLONE_WAKE,
     UNNECESSARY_FALLIBLE_CONVERSIONS,
     JOIN_ABSOLUTE_PATHS,
-    OPTION_MAP_OR_ERR_OK,
     RESULT_FILTER_MAP,
     ITER_FILTER_IS_SOME,
     ITER_FILTER_IS_OK,
@@ -4603,6 +4658,9 @@ impl_lint_pass!(Methods => [
     MANUAL_REPEAT_N,
     SLICED_STRING_AS_BYTES,
     RETURN_AND_THEN,
+    UNBUFFERED_BYTES,
+    MANUAL_CONTAINS,
+    IO_OTHER_ERROR,
 ]);
 
 /// Extracts a method call name, args, and `Span` of the method name.
@@ -4630,8 +4688,9 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             ExprKind::Call(func, args) => {
                 from_iter_instead_of_collect::check(cx, expr, args, func);
                 unnecessary_fallible_conversions::check_function(cx, expr, func);
-                manual_c_str_literals::check(cx, expr, func, args, &self.msrv);
-                useless_nonzero_new_unchecked::check(cx, expr, func, args, &self.msrv);
+                manual_c_str_literals::check(cx, expr, func, args, self.msrv);
+                useless_nonzero_new_unchecked::check(cx, expr, func, args, self.msrv);
+                io_other_error::check(cx, expr, func, args, self.msrv);
             },
             ExprKind::MethodCall(method_call, receiver, args, _) => {
                 let method_span = method_call.ident.span;
@@ -4650,7 +4709,7 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
                 inefficient_to_string::check(cx, expr, method_call.ident.name, receiver, args);
                 single_char_add_str::check(cx, expr, receiver, args);
                 into_iter_on_ref::check(cx, expr, method_span, method_call.ident.name, receiver);
-                unnecessary_to_owned::check(cx, expr, method_call.ident.name, receiver, args, &self.msrv);
+                unnecessary_to_owned::check(cx, expr, method_call.ident.name, receiver, args, self.msrv);
             },
             ExprKind::Binary(op, lhs, rhs) if op.node == hir::BinOpKind::Eq || op.node == hir::BinOpKind::Ne => {
                 let mut info = BinaryExprInfo {
@@ -4796,8 +4855,6 @@ impl<'tcx> LateLintPass<'tcx> for Methods {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 impl Methods {
@@ -4855,11 +4912,14 @@ impl Methods {
                                 && let body = cx.tcx.hir_body(arg.body)
                                 && let [param] = body.params =>
                         {
-                            string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), &self.msrv);
+                            string_lit_chars_any::check(cx, expr, recv, param, peel_blocks(body.value), self.msrv);
                         },
                         Some(("map", _, [map_arg], _, map_call_span)) => {
                             map_all_any_identity::check(cx, expr, recv, map_call_span, map_arg, call_span, arg, "any");
                         },
+                        Some(("iter", iter_recv, ..)) => {
+                            manual_contains::check(cx, expr, iter_recv, arg);
+                        },
                         _ => {},
                     }
                 },
@@ -4876,11 +4936,12 @@ impl Methods {
                     sliced_string_as_bytes::check(cx, expr, recv);
                 },
                 ("as_mut", []) => useless_asref::check(cx, expr, "as_mut", recv),
-                ("as_ptr", []) => manual_c_str_literals::check_as_ptr(cx, expr, recv, &self.msrv),
+                ("as_ptr", []) => manual_c_str_literals::check_as_ptr(cx, expr, recv, self.msrv),
                 ("as_ref", []) => useless_asref::check(cx, expr, "as_ref", recv),
                 ("assume_init", []) => uninit_assumed_init::check(cx, expr, recv),
+                ("bytes", []) => unbuffered_bytes::check(cx, expr, recv),
                 ("cloned", []) => {
-                    cloned_instead_of_copied::check(cx, expr, recv, span, &self.msrv);
+                    cloned_instead_of_copied::check(cx, expr, recv, span, self.msrv);
                     option_as_ref_cloned::check(cx, recv, span);
                 },
                 ("collect", []) if is_trait_method(cx, expr, sym::Iterator) => {
@@ -4894,7 +4955,7 @@ impl Methods {
                             format_collect::check(cx, expr, m_arg, m_ident_span);
                         },
                         Some(("take", take_self_arg, [take_arg], _, _)) => {
-                            if self.msrv.meets(msrvs::STR_REPEAT) {
+                            if self.msrv.meets(cx, msrvs::STR_REPEAT) {
                                 manual_str_repeat::check(cx, expr, recv, take_self_arg, take_arg);
                             }
                         },
@@ -4933,19 +4994,20 @@ impl Methods {
                     if let ExprKind::MethodCall(.., span) = expr.kind {
                         case_sensitive_file_extension_comparisons::check(cx, expr, span, recv, arg);
                     }
-                    path_ends_with_ext::check(cx, recv, arg, expr, &self.msrv, &self.allowed_dotfiles);
+                    path_ends_with_ext::check(cx, recv, arg, expr, self.msrv, &self.allowed_dotfiles);
                 },
                 ("expect", [_]) => {
                     match method_call(recv) {
                         Some(("ok", recv, [], _, _)) => ok_expect::check(cx, expr, recv),
                         Some(("err", recv, [], err_span, _)) => {
-                            err_expect::check(cx, expr, recv, span, err_span, &self.msrv);
+                            err_expect::check(cx, expr, recv, span, err_span, self.msrv);
                         },
                         _ => unwrap_expect_used::check(
                             cx,
                             expr,
                             recv,
                             false,
+                            self.allow_expect_in_consts,
                             self.allow_expect_in_tests,
                             unwrap_expect_used::Variant::Expect,
                         ),
@@ -4959,6 +5021,7 @@ impl Methods {
                         expr,
                         recv,
                         true,
+                        self.allow_expect_in_consts,
                         self.allow_expect_in_tests,
                         unwrap_expect_used::Variant::Expect,
                     );
@@ -4979,7 +5042,7 @@ impl Methods {
                             false,
                         );
                     }
-                    if self.msrv.meets(msrvs::ITER_FLATTEN) {
+                    if self.msrv.meets(cx, msrvs::ITER_FLATTEN) {
                         // use the sourcemap to get the span of the closure
                         iter_filter::check(cx, expr, arg, span);
                     }
@@ -5027,7 +5090,7 @@ impl Methods {
                     _ => {},
                 },
                 ("fold", [init, acc]) => {
-                    manual_try_fold::check(cx, expr, init, acc, call_span, &self.msrv);
+                    manual_try_fold::check(cx, expr, init, acc, call_span, self.msrv);
                     unnecessary_fold::check(cx, expr, init, acc, span);
                 },
                 ("for_each", [arg]) => {
@@ -5068,7 +5131,7 @@ impl Methods {
                     is_empty::check(cx, expr, recv);
                 },
                 ("is_file", []) => filetype_is_file::check(cx, expr, recv),
-                ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, &self.msrv),
+                ("is_digit", [radix]) => is_digit_ascii_radix::check(cx, expr, recv, radix, self.msrv),
                 ("is_none", []) => check_is_some_is_none(cx, expr, recv, call_span, false),
                 ("is_some", []) => check_is_some_is_none(cx, expr, recv, call_span, true),
                 ("iter" | "iter_mut" | "into_iter", []) => {
@@ -5105,11 +5168,11 @@ impl Methods {
                 (name @ ("map" | "map_err"), [m_arg]) => {
                     if name == "map" {
                         unused_enumerate_index::check(cx, expr, recv, m_arg);
-                        map_clone::check(cx, expr, recv, m_arg, &self.msrv);
-                        map_with_unused_argument_over_ranges::check(cx, expr, recv, m_arg, &self.msrv, span);
+                        map_clone::check(cx, expr, recv, m_arg, self.msrv);
+                        map_with_unused_argument_over_ranges::check(cx, expr, recv, m_arg, self.msrv, span);
                         match method_call(recv) {
                             Some((map_name @ ("iter" | "into_iter"), recv2, _, _, _)) => {
-                                iter_kv_map::check(cx, map_name, expr, recv2, m_arg, &self.msrv);
+                                iter_kv_map::check(cx, map_name, expr, recv2, m_arg, self.msrv);
                             },
                             Some(("cloned", recv2, [], _, _)) => iter_overeager_cloned::check(
                                 cx,
@@ -5126,8 +5189,8 @@ impl Methods {
                     }
                     if let Some((name, recv2, args, span2, _)) = method_call(recv) {
                         match (name, args) {
-                            ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, &self.msrv),
-                            ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, &self.msrv),
+                            ("as_mut", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, true, self.msrv),
+                            ("as_ref", []) => option_as_ref_deref::check(cx, expr, recv2, m_arg, false, self.msrv),
                             ("filter", [f_arg]) => {
                                 filter_map::check(cx, expr, recv2, f_arg, span2, recv, m_arg, span, false);
                             },
@@ -5138,7 +5201,7 @@ impl Methods {
                         }
                     }
                     map_identity::check(cx, expr, recv, m_arg, name, span);
-                    manual_inspect::check(cx, expr, m_arg, name, span, &self.msrv);
+                    manual_inspect::check(cx, expr, m_arg, name, span, self.msrv);
                     crate::useless_conversion::check_function_application(cx, expr, recv, m_arg);
                 },
                 ("map_break" | "map_continue", [m_arg]) => {
@@ -5147,8 +5210,7 @@ impl Methods {
                 ("map_or", [def, map]) => {
                     option_map_or_none::check(cx, expr, recv, def, map);
                     manual_ok_or::check(cx, expr, recv, def, map);
-                    option_map_or_err_ok::check(cx, expr, recv, def, map);
-                    unnecessary_map_or::check(cx, expr, recv, def, map, span, &self.msrv);
+                    unnecessary_map_or::check(cx, expr, recv, def, map, span, self.msrv);
                 },
                 ("map_or_else", [def, map]) => {
                     result_map_or_else_none::check(cx, expr, recv, def, map);
@@ -5166,7 +5228,7 @@ impl Methods {
                                 false,
                             ),
                             ("filter", [arg]) => filter_next::check(cx, expr, recv2, arg),
-                            ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, &self.msrv),
+                            ("filter_map", [arg]) => filter_map_next::check(cx, expr, recv2, arg, self.msrv),
                             ("iter", []) => iter_next_slice::check(cx, expr, recv2),
                             ("skip", [arg]) => iter_skip_next::check(cx, expr, recv2, arg),
                             ("skip_while", [_]) => skip_while_next::check(cx, expr),
@@ -5222,7 +5284,7 @@ impl Methods {
                     no_effect_replace::check(cx, expr, arg1, arg2);
 
                     // Check for repeated `str::replace` calls to perform `collapsible_str_replace` lint
-                    if self.msrv.meets(msrvs::PATTERN_TRAIT_CHAR_ARRAY)
+                    if self.msrv.meets(cx, msrvs::PATTERN_TRAIT_CHAR_ARRAY)
                         && name == "replace"
                         && let Some(("replace", ..)) = method_call(recv)
                     {
@@ -5233,10 +5295,10 @@ impl Methods {
                     vec_resize_to_zero::check(cx, expr, count_arg, default_arg, span);
                 },
                 ("seek", [arg]) => {
-                    if self.msrv.meets(msrvs::SEEK_FROM_CURRENT) {
+                    if self.msrv.meets(cx, msrvs::SEEK_FROM_CURRENT) {
                         seek_from_current::check(cx, expr, recv, arg);
                     }
-                    if self.msrv.meets(msrvs::SEEK_REWIND) {
+                    if self.msrv.meets(cx, msrvs::SEEK_REWIND) {
                         seek_to_start_instead_of_rewind::check(cx, expr, recv, arg, span);
                     }
                 },
@@ -5270,7 +5332,7 @@ impl Methods {
                 ("splitn" | "rsplitn", [count_arg, pat_arg]) => {
                     if let Some(Constant::Int(count)) = ConstEvalCtxt::new(cx).eval(count_arg) {
                         suspicious_splitn::check(cx, name, expr, recv, count);
-                        str_splitn::check(cx, name, expr, recv, pat_arg, count, &self.msrv);
+                        str_splitn::check(cx, name, expr, recv, pat_arg, count, self.msrv);
                     }
                 },
                 ("splitn_mut" | "rsplitn_mut", [count_arg, _]) => {
@@ -5281,7 +5343,7 @@ impl Methods {
                 ("step_by", [arg]) => iterator_step_by_zero::check(cx, expr, arg),
                 ("take", [arg]) => {
                     iter_out_of_bounds::check_take(cx, expr, recv, arg);
-                    manual_repeat_n::check(cx, expr, recv, arg, &self.msrv);
+                    manual_repeat_n::check(cx, expr, recv, arg, self.msrv);
                     if let Some(("cloned", recv2, [], _span2, _)) = method_call(recv) {
                         iter_overeager_cloned::check(
                             cx,
@@ -5295,7 +5357,7 @@ impl Methods {
                 },
                 ("take", []) => needless_option_take::check(cx, expr, recv),
                 ("then", [arg]) => {
-                    if !self.msrv.meets(msrvs::BOOL_THEN_SOME) {
+                    if !self.msrv.meets(cx, msrvs::BOOL_THEN_SOME) {
                         return;
                     }
                     unnecessary_lazy_eval::check(cx, expr, recv, arg, "then_some");
@@ -5333,6 +5395,7 @@ impl Methods {
                         expr,
                         recv,
                         false,
+                        self.allow_unwrap_in_consts,
                         self.allow_unwrap_in_tests,
                         unwrap_expect_used::Variant::Unwrap,
                     );
@@ -5344,6 +5407,7 @@ impl Methods {
                         expr,
                         recv,
                         true,
+                        self.allow_unwrap_in_consts,
                         self.allow_unwrap_in_tests,
                         unwrap_expect_used::Variant::Unwrap,
                     );
@@ -5354,10 +5418,10 @@ impl Methods {
                             manual_saturating_arithmetic::check(cx, expr, lhs, rhs, u_arg, &arith["checked_".len()..]);
                         },
                         Some(("map", m_recv, [m_arg], span, _)) => {
-                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span, &self.msrv);
+                            option_map_unwrap_or::check(cx, expr, m_recv, m_arg, recv, u_arg, span, self.msrv);
                         },
                         Some((then_method @ ("then" | "then_some"), t_recv, [t_arg], _, _)) => {
-                            obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg, then_method);
+                            obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg, then_method, "unwrap_or");
                         },
                         _ => {},
                     }
@@ -5365,7 +5429,7 @@ impl Methods {
                 },
                 ("unwrap_or_default", []) => {
                     if let Some(("map", m_recv, [arg], span, _)) = method_call(recv) {
-                        manual_is_variant_and::check(cx, expr, m_recv, arg, span, &self.msrv);
+                        manual_is_variant_and::check(cx, expr, m_recv, arg, span, self.msrv);
                     }
                     unnecessary_literal_unwrap::check(cx, expr, recv, name, args);
                 },
@@ -5375,7 +5439,10 @@ impl Methods {
                 ("unwrap_or_else", [u_arg]) => {
                     match method_call(recv) {
                         Some(("map", recv, [map_arg], _, _))
-                            if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, &self.msrv) => {},
+                            if map_unwrap_or::check(cx, expr, recv, map_arg, u_arg, self.msrv) => {},
+                        Some((then_method @ ("then" | "then_some"), t_recv, [t_arg], _, _)) => {
+                            obfuscated_if_else::check(cx, expr, t_recv, t_arg, u_arg, then_method, "unwrap_or_else");
+                        },
                         _ => {
                             unnecessary_lazy_eval::check(cx, expr, recv, u_arg, "unwrap_or");
                         },
diff --git a/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs b/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs
index e0905374ddaa..9a5ffdeaf4e8 100644
--- a/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/obfuscated_if_else.rs
@@ -1,6 +1,7 @@
 use super::OBFUSCATED_IF_ELSE;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
+use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet_with_applicability;
 use clippy_utils::sugg::Sugg;
 use rustc_errors::Applicability;
@@ -15,6 +16,7 @@ pub(super) fn check<'tcx>(
     then_arg: &'tcx hir::Expr<'_>,
     unwrap_arg: &'tcx hir::Expr<'_>,
     then_method_name: &str,
+    unwrap_method_name: &str,
 ) {
     let recv_ty = cx.typeck_results().expr_ty(then_recv);
 
@@ -31,16 +33,40 @@ pub(super) fn check<'tcx>(
                 snippet_with_applicability(cx, body.value.span, "..", &mut applicability)
             },
             "then_some" => snippet_with_applicability(cx, then_arg.span, "..", &mut applicability),
-            _ => String::new().into(),
+            _ => return,
+        };
+
+        // FIXME: Add `unwrap_or_else` symbol
+        let els = match unwrap_method_name {
+            "unwrap_or" => snippet_with_applicability(cx, unwrap_arg.span, "..", &mut applicability),
+            "unwrap_or_else" if let ExprKind::Closure(closure) = unwrap_arg.kind => {
+                let body = cx.tcx.hir_body(closure.body);
+                snippet_with_applicability(cx, body.value.span, "..", &mut applicability)
+            },
+            "unwrap_or_else" if let ExprKind::Path(_) = unwrap_arg.kind => {
+                snippet_with_applicability(cx, unwrap_arg.span, "_", &mut applicability) + "()"
+            },
+            _ => return,
         };
 
         let sugg = format!(
             "if {} {{ {} }} else {{ {} }}",
             Sugg::hir_with_applicability(cx, then_recv, "..", &mut applicability),
             if_then,
-            snippet_with_applicability(cx, unwrap_arg.span, "..", &mut applicability)
+            els
         );
 
+        // To be parsed as an expression, the `if { … } else { … }` as the left operand of a binary operator
+        // requires parentheses.
+        let sugg = if let Some(parent_expr) = get_parent_expr(cx, expr)
+            && let ExprKind::Binary(_, left, _) = parent_expr.kind
+            && left.hir_id == expr.hir_id
+        {
+            format!("({sugg})")
+        } else {
+            sugg
+        };
+
         span_lint_and_sugg(
             cx,
             OBFUSCATED_IF_ELSE,
diff --git a/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs b/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs
index 469fcccbe4f6..63ee922acfa0 100644
--- a/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/option_as_ref_deref.rs
@@ -18,12 +18,8 @@ pub(super) fn check(
     as_ref_recv: &hir::Expr<'_>,
     map_arg: &hir::Expr<'_>,
     is_mut: bool,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if !msrv.meets(msrvs::OPTION_AS_DEREF) {
-        return;
-    }
-
     let same_mutability = |m| (is_mut && m == &hir::Mutability::Mut) || (!is_mut && m == &hir::Mutability::Not);
 
     let option_ty = cx.typeck_results().expr_ty(as_ref_recv);
@@ -93,7 +89,7 @@ pub(super) fn check(
         _ => false,
     };
 
-    if is_deref {
+    if is_deref && msrv.meets(cx, msrvs::OPTION_AS_DEREF) {
         let current_method = if is_mut {
             format!(".as_mut().map({})", snippet(cx, map_arg.span, ".."))
         } else {
diff --git a/src/tools/clippy/clippy_lints/src/methods/option_map_or_err_ok.rs b/src/tools/clippy/clippy_lints/src/methods/option_map_or_err_ok.rs
deleted file mode 100644
index 4e424d4c066a..000000000000
--- a/src/tools/clippy/clippy_lints/src/methods/option_map_or_err_ok.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::source::snippet;
-use clippy_utils::ty::is_type_diagnostic_item;
-use clippy_utils::{is_res_lang_ctor, path_res};
-use rustc_errors::Applicability;
-use rustc_hir::LangItem::{ResultErr, ResultOk};
-use rustc_hir::{Expr, ExprKind};
-use rustc_lint::LateContext;
-use rustc_span::symbol::sym;
-
-use super::OPTION_MAP_OR_ERR_OK;
-
-pub(super) fn check<'tcx>(
-    cx: &LateContext<'tcx>,
-    expr: &'tcx Expr<'tcx>,
-    recv: &'tcx Expr<'_>,
-    or_expr: &'tcx Expr<'_>,
-    map_expr: &'tcx Expr<'_>,
-) {
-    // We check that it's called on an `Option` type.
-    if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option)
-        // We check that first we pass an `Err`.
-        && let ExprKind::Call(call, &[arg]) = or_expr.kind
-        && is_res_lang_ctor(cx, path_res(cx, call), ResultErr)
-        // And finally we check that it is mapped as `Ok`.
-        && is_res_lang_ctor(cx, path_res(cx, map_expr), ResultOk)
-    {
-        let msg = "called `map_or(Err(_), Ok)` on an `Option` value";
-        let self_snippet = snippet(cx, recv.span, "..");
-        let err_snippet = snippet(cx, arg.span, "..");
-        span_lint_and_sugg(
-            cx,
-            OPTION_MAP_OR_ERR_OK,
-            expr.span,
-            msg,
-            "consider using `ok_or`",
-            format!("{self_snippet}.ok_or({err_snippet})"),
-            Applicability::MachineApplicable,
-        );
-    }
-}
diff --git a/src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs b/src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs
index b1107d8cc72f..4ba8e0109042 100644
--- a/src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/option_map_unwrap_or.rs
@@ -24,7 +24,7 @@ pub(super) fn check<'tcx>(
     unwrap_recv: &rustc_hir::Expr<'_>,
     unwrap_arg: &'tcx rustc_hir::Expr<'_>,
     map_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     // lint if the caller of `map()` is an `Option`
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv), sym::Option) {
@@ -71,9 +71,9 @@ pub(super) fn check<'tcx>(
         }
 
         // is_some_and is stabilised && `unwrap_or` argument is false; suggest `is_some_and` instead
-        let suggest_is_some_and = msrv.meets(msrvs::OPTION_RESULT_IS_VARIANT_AND)
-            && matches!(&unwrap_arg.kind, ExprKind::Lit(lit)
-            if matches!(lit.node, rustc_ast::LitKind::Bool(false)));
+        let suggest_is_some_and = matches!(&unwrap_arg.kind, ExprKind::Lit(lit)
+            if matches!(lit.node, rustc_ast::LitKind::Bool(false)))
+            && msrv.meets(cx, msrvs::OPTION_RESULT_IS_VARIANT_AND);
 
         let mut applicability = Applicability::MachineApplicable;
         // get snippet for unwrap_or()
diff --git a/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs b/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs
index 69f933fee68f..c03420a5143e 100644
--- a/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/or_fun_call.rs
@@ -104,7 +104,7 @@ pub(super) fn check<'tcx>(
         if (is_new(fun) && output_type_implements_default(fun))
             || match call_expr {
                 Some(call_expr) => is_default_equivalent(cx, call_expr),
-                None => is_default_equivalent_call(cx, fun) || closure_body_returns_empty_to_string(cx, fun),
+                None => is_default_equivalent_call(cx, fun, None) || closure_body_returns_empty_to_string(cx, fun),
             }
         {
             span_lint_and_sugg(
diff --git a/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs b/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs
index 2d3007e50b81..38d9c5f16778 100644
--- a/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/path_buf_push_overwrite.rs
@@ -28,7 +28,7 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, arg: &'t
             "calling `push` with '/' or '\\' (file system root) will overwrite the previous path definition",
             "try",
             format!("\"{}\"", pushed_path_lit.trim_start_matches(['/', '\\'])),
-            Applicability::MachineApplicable,
+            Applicability::MaybeIncorrect,
         );
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs b/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs
index b3811a335e1a..d3f513e7abd2 100644
--- a/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/path_ends_with_ext.rs
@@ -20,7 +20,7 @@ pub(super) fn check(
     recv: &Expr<'_>,
     path: &Expr<'_>,
     expr: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
     allowed_dotfiles: &FxHashSet<&'static str>,
 ) {
     if is_type_diagnostic_item(cx, cx.typeck_results().expr_ty(recv).peel_refs(), sym::Path)
@@ -33,7 +33,7 @@ pub(super) fn check(
         && path.chars().all(char::is_alphanumeric)
     {
         let mut sugg = snippet(cx, recv.span, "..").into_owned();
-        if msrv.meets(msrvs::OPTION_RESULT_IS_VARIANT_AND) {
+        if msrv.meets(cx, msrvs::OPTION_RESULT_IS_VARIANT_AND) {
             let _ = write!(sugg, r#".extension().is_some_and(|ext| ext == "{path}")"#);
         } else {
             let _ = write!(sugg, r#".extension().map_or(false, |ext| ext == "{path}")"#);
diff --git a/src/tools/clippy/clippy_lints/src/methods/range_zip_with_len.rs b/src/tools/clippy/clippy_lints/src/methods/range_zip_with_len.rs
index f4d206c5307c..3a5e32172086 100644
--- a/src/tools/clippy/clippy_lints/src/methods/range_zip_with_len.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/range_zip_with_len.rs
@@ -1,6 +1,7 @@
-use clippy_utils::diagnostics::span_lint;
+use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::{SpanlessEq, higher, is_integer_const, is_trait_method};
+use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::LateContext;
 use rustc_span::sym;
@@ -20,14 +21,14 @@ pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>, recv: &'
         && let ExprKind::Path(QPath::Resolved(_, len_path)) = len_recv.kind
         && SpanlessEq::new(cx).eq_path_segments(iter_path.segments, len_path.segments)
     {
-        span_lint(
+        span_lint_and_sugg(
             cx,
             RANGE_ZIP_WITH_LEN,
             expr.span,
-            format!(
-                "it is more idiomatic to use `{}.iter().enumerate()`",
-                snippet(cx, recv.span, "_")
-            ),
+            "using `.zip()` with a range and `.len()`",
+            "try",
+            format!("{}.iter().enumerate()", snippet(cx, recv.span, "_")),
+            Applicability::MachineApplicable,
         );
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs b/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs
index 82e66a0500a8..c9251c1b8497 100644
--- a/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/read_line_without_trim.rs
@@ -1,11 +1,10 @@
 use std::ops::ControlFlow;
 
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::paths::STDIN;
+use clippy_utils::get_parent_expr;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_type_diagnostic_item;
 use clippy_utils::visitors::for_each_local_use_after_expr;
-use clippy_utils::{get_parent_expr, match_def_path};
 use rustc_ast::LitKind;
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
@@ -34,7 +33,7 @@ fn parse_fails_on_trailing_newline(ty: Ty<'_>) -> bool {
 
 pub fn check(cx: &LateContext<'_>, call: &Expr<'_>, recv: &Expr<'_>, arg: &Expr<'_>) {
     if let Some(recv_adt) = cx.typeck_results().expr_ty(recv).ty_adt_def()
-        && match_def_path(cx, recv_adt.did(), &STDIN)
+        && cx.tcx.is_diagnostic_item(sym::Stdin, recv_adt.did())
         && let ExprKind::Path(QPath::Resolved(_, path)) = arg.peel_borrows().kind
         && let Res::Local(local_id) = path.res
     {
diff --git a/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs b/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs
index 68ffa81a2781..e8861935d421 100644
--- a/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/return_and_then.rs
@@ -60,7 +60,7 @@ pub(super) fn check<'tcx>(
         "let {} = {}?;\n{}",
         arg_snip,
         recv_snip,
-        reindent_multiline(inner.into(), false, indent_of(cx, expr.span))
+        reindent_multiline(inner, false, indent_of(cx, expr.span))
     );
 
     span_lint_and_sugg(cx, RETURN_AND_THEN, expr.span, msg, "try", sugg, applicability);
diff --git a/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs b/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
index 8389c2e3f982..4ccefb7ec9d7 100644
--- a/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/str_splitn.rs
@@ -23,7 +23,7 @@ pub(super) fn check(
     self_arg: &Expr<'_>,
     pat_arg: &Expr<'_>,
     count: u128,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if count < 2 || !cx.typeck_results().expr_ty_adjusted(self_arg).peel_refs().is_str() {
         return;
@@ -33,7 +33,7 @@ pub(super) fn check(
         IterUsageKind::Nth(n) => count > n + 1,
         IterUsageKind::NextTuple => count > 2,
     };
-    let manual = count == 2 && msrv.meets(msrvs::STR_SPLIT_ONCE);
+    let manual = count == 2 && msrv.meets(cx, msrvs::STR_SPLIT_ONCE);
 
     match parse_iter_usage(cx, expr.span.ctxt(), cx.tcx.hir_parent_iter(expr.hir_id)) {
         Some(usage) if needless(usage.kind) => lint_needless(cx, method_name, expr, self_arg, pat_arg),
diff --git a/src/tools/clippy/clippy_lints/src/methods/string_lit_chars_any.rs b/src/tools/clippy/clippy_lints/src/methods/string_lit_chars_any.rs
index cb719b34b1f0..f0f9d30d3000 100644
--- a/src/tools/clippy/clippy_lints/src/methods/string_lit_chars_any.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/string_lit_chars_any.rs
@@ -17,10 +17,9 @@ pub(super) fn check<'tcx>(
     recv: &Expr<'_>,
     param: &'tcx Param<'tcx>,
     body: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
-    if msrv.meets(msrvs::MATCHES_MACRO)
-        && is_trait_method(cx, expr, sym::Iterator)
+    if is_trait_method(cx, expr, sym::Iterator)
         && let PatKind::Binding(_, arg, _, _) = param.pat.kind
         && let ExprKind::Lit(lit_kind) = recv.kind
         && let LitKind::Str(val, _) = lit_kind.node
@@ -33,6 +32,7 @@ pub(super) fn check<'tcx>(
             (false, true) => lhs,
             _ => return,
         }
+        && msrv.meets(cx, msrvs::MATCHES_MACRO)
         && !is_from_proc_macro(cx, expr)
         && let Some(scrutinee_snip) = scrutinee.span.get_source_text(cx)
     {
diff --git a/src/tools/clippy/clippy_lints/src/methods/unbuffered_bytes.rs b/src/tools/clippy/clippy_lints/src/methods/unbuffered_bytes.rs
new file mode 100644
index 000000000000..dd5566f8c8ba
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/methods/unbuffered_bytes.rs
@@ -0,0 +1,25 @@
+use super::UNBUFFERED_BYTES;
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::is_trait_method;
+use clippy_utils::ty::implements_trait;
+use rustc_hir as hir;
+use rustc_lint::LateContext;
+use rustc_span::sym;
+
+pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, recv: &hir::Expr<'_>) {
+    // Lint if the `.bytes()` call is from the `Read` trait and the implementor is not buffered.
+    if is_trait_method(cx, expr, sym::IoRead)
+        && let Some(buf_read) = cx.tcx.get_diagnostic_item(sym::IoBufRead)
+        && let ty = cx.typeck_results().expr_ty_adjusted(recv)
+        && !implements_trait(cx, ty, buf_read, &[])
+    {
+        span_lint_and_help(
+            cx,
+            UNBUFFERED_BYTES,
+            expr.span,
+            "calling .bytes() is very inefficient when data is not in memory",
+            None,
+            "consider using `BufReader`",
+        );
+    }
+}
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
index 00690aca6d13..fa3a29e36670 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_literal_unwrap.rs
@@ -98,10 +98,7 @@ pub(super) fn check(
             ]),
             ("None", "unwrap_or_else", _) => match args[0].kind {
                 hir::ExprKind::Closure(hir::Closure { body, .. }) => Some(vec![
-                    (
-                        expr.span.with_hi(cx.tcx.hir_body(*body).value.span.lo()),
-                        String::new(),
-                    ),
+                    (expr.span.with_hi(cx.tcx.hir_body(*body).value.span.lo()), String::new()),
                     (expr.span.with_lo(args[0].span.hi()), String::new()),
                 ]),
                 _ => None,
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs
index 5f88a7fd31f2..d7bd522ddab9 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_map_or.rs
@@ -4,7 +4,7 @@ use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::eager_or_lazy::switch_to_eager_eval;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::sugg::{Sugg, make_binop};
-use clippy_utils::ty::{get_type_diagnostic_name, implements_trait};
+use clippy_utils::ty::{get_type_diagnostic_name, implements_trait, is_copy};
 use clippy_utils::visitors::is_local_used;
 use clippy_utils::{get_parent_expr, is_from_proc_macro, path_to_local_id};
 use rustc_ast::LitKind::Bool;
@@ -42,7 +42,7 @@ pub(super) fn check<'a>(
     def: &Expr<'_>,
     map: &Expr<'_>,
     method_span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     let ExprKind::Lit(def_kind) = def.kind else {
         return;
@@ -81,9 +81,11 @@ pub(super) fn check<'a>(
             && (path_to_local_id(l, hir_id) ^ path_to_local_id(r, hir_id))
             && !is_local_used(cx, non_binding_location, hir_id)
             && let typeck_results = cx.typeck_results()
-            && typeck_results.expr_ty(l) == typeck_results.expr_ty(r)
+            && let l_ty = typeck_results.expr_ty(l)
+            && l_ty == typeck_results.expr_ty(r)
             && let Some(partial_eq) = cx.tcx.get_diagnostic_item(sym::PartialEq)
             && implements_trait(cx, recv_ty, partial_eq, &[recv_ty.into()])
+            && is_copy(cx, l_ty)
     {
         let wrap = variant.variant_name();
 
@@ -117,14 +119,14 @@ pub(super) fn check<'a>(
         .into_string();
 
         (vec![(expr.span, sugg)], "a standard comparison", app)
-    } else if !def_bool && msrv.meets(msrvs::OPTION_RESULT_IS_VARIANT_AND) {
+    } else if !def_bool && msrv.meets(cx, msrvs::OPTION_RESULT_IS_VARIANT_AND) {
         let suggested_name = variant.method_name();
         (
             vec![(method_span, suggested_name.into()), (ext_def_span, String::default())],
             suggested_name,
             Applicability::MachineApplicable,
         )
-    } else if def_bool && matches!(variant, Variant::Some) && msrv.meets(msrvs::IS_NONE_OR) {
+    } else if def_bool && matches!(variant, Variant::Some) && msrv.meets(cx, msrvs::IS_NONE_OR) {
         (
             vec![(method_span, "is_none_or".into()), (ext_def_span, String::default())],
             "is_none_or",
diff --git a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
index ea134c057053..a71b3659fd24 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unnecessary_to_owned.rs
@@ -31,7 +31,7 @@ pub fn check<'tcx>(
     method_name: Symbol,
     receiver: &'tcx Expr<'_>,
     args: &'tcx [Expr<'_>],
-    msrv: &Msrv,
+    msrv: Msrv,
 ) {
     if let Some(method_def_id) = cx.typeck_results().type_dependent_def_id(expr.hir_id)
         && args.is_empty()
@@ -207,7 +207,7 @@ fn check_into_iter_call_arg(
     expr: &Expr<'_>,
     method_name: Symbol,
     receiver: &Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     if let Some(parent) = get_parent_expr(cx, expr)
         && let Some(callee_def_id) = fn_def_id(cx, parent)
@@ -224,7 +224,7 @@ fn check_into_iter_call_arg(
             return true;
         }
 
-        let cloned_or_copied = if is_copy(cx, item_ty) && msrv.meets(msrvs::ITERATOR_COPIED) {
+        let cloned_or_copied = if is_copy(cx, item_ty) && msrv.meets(cx, msrvs::ITERATOR_COPIED) {
             "copied"
         } else {
             "cloned"
diff --git a/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs b/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs
index 5b0bd0f716ab..027215e3b4d7 100644
--- a/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/unwrap_expect_used.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::ty::{is_never_like, is_type_diagnostic_item};
-use clippy_utils::{is_in_test, is_lint_allowed};
+use clippy_utils::{is_in_test, is_inside_always_const_context, is_lint_allowed};
 use rustc_hir::Expr;
 use rustc_lint::{LateContext, Lint};
 use rustc_middle::ty;
@@ -39,6 +39,7 @@ pub(super) fn check(
     expr: &Expr<'_>,
     recv: &Expr<'_>,
     is_err: bool,
+    allow_unwrap_in_consts: bool,
     allow_unwrap_in_tests: bool,
     variant: Variant,
 ) {
@@ -65,6 +66,10 @@ pub(super) fn check(
         return;
     }
 
+    if allow_unwrap_in_consts && is_inside_always_const_context(cx.tcx, expr.hir_id) {
+        return;
+    }
+
     span_lint_and_then(
         cx,
         variant.lint(),
diff --git a/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs b/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs
index 19152362fb5f..0cbf6004be3a 100644
--- a/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/useless_asref.rs
@@ -1,6 +1,6 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet_with_applicability;
-use clippy_utils::ty::{should_call_clone_as_function, walk_ptrs_ty_depth};
+use clippy_utils::ty::{implements_trait, should_call_clone_as_function, walk_ptrs_ty_depth};
 use clippy_utils::{
     get_parent_expr, is_diag_trait_item, match_def_path, path_to_local_id, peel_blocks, strip_pat_refs,
 };
@@ -55,12 +55,19 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
         let (base_res_ty, res_depth) = walk_ptrs_ty_depth(res_ty);
         let (base_rcv_ty, rcv_depth) = walk_ptrs_ty_depth(rcv_ty);
         if base_rcv_ty == base_res_ty && rcv_depth >= res_depth {
-            // allow the `as_ref` or `as_mut` if it is followed by another method call
-            if let Some(parent) = get_parent_expr(cx, expr)
-                && let hir::ExprKind::MethodCall(segment, ..) = parent.kind
-                && segment.ident.span != expr.span
-            {
-                return;
+            if let Some(parent) = get_parent_expr(cx, expr) {
+                // allow the `as_ref` or `as_mut` if it is followed by another method call
+                if let hir::ExprKind::MethodCall(segment, ..) = parent.kind
+                    && segment.ident.span != expr.span
+                {
+                    return;
+                }
+
+                // allow the `as_ref` or `as_mut` if they belong to a closure that changes
+                // the number of references
+                if matches!(parent.kind, hir::ExprKind::Closure(..)) && rcv_depth != res_depth {
+                    return;
+                }
             }
 
             let mut applicability = Applicability::MachineApplicable;
@@ -94,6 +101,9 @@ pub(super) fn check(cx: &LateContext<'_>, expr: &hir::Expr<'_>, call_name: &str,
             && is_calling_clone(cx, arg)
             // And that we are not recommending recv.clone() over Arc::clone() or similar
             && !should_call_clone_as_function(cx, rcv_ty)
+            // https://github.com/rust-lang/rust-clippy/issues/12357
+            && let Some(clone_trait) = cx.tcx.lang_items().clone_trait()
+            && implements_trait(cx, cx.typeck_results().expr_ty(recvr), clone_trait, &[])
         {
             lint_as_ref_clone(cx, expr.span.with_hi(parent.span.hi()), recvr, call_name);
         }
diff --git a/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs b/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs
index 0bd50429c09d..22df1f3f485e 100644
--- a/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/useless_nonzero_new_unchecked.rs
@@ -10,13 +10,13 @@ use rustc_span::sym;
 
 use super::USELESS_NONZERO_NEW_UNCHECKED;
 
-pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, func: &Expr<'tcx>, args: &[Expr<'_>], msrv: &Msrv) {
-    if msrv.meets(msrvs::CONST_UNWRAP)
-        && let ExprKind::Path(QPath::TypeRelative(ty, segment)) = func.kind
+pub(super) fn check<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'_>, func: &Expr<'tcx>, args: &[Expr<'_>], msrv: Msrv) {
+    if let ExprKind::Path(QPath::TypeRelative(ty, segment)) = func.kind
         && segment.ident.name == sym::new_unchecked
         && let [init_arg] = args
         && is_inside_always_const_context(cx.tcx, expr.hir_id)
         && is_type_diagnostic_item(cx, cx.typeck_results().node_type(ty.hir_id), sym::NonZero)
+        && msrv.meets(cx, msrvs::CONST_UNWRAP)
     {
         let mut app = Applicability::MachineApplicable;
         let ty_str = snippet_with_applicability(cx, ty.span, "_", &mut app);
diff --git a/src/tools/clippy/clippy_lints/src/min_ident_chars.rs b/src/tools/clippy/clippy_lints/src/min_ident_chars.rs
index e5801124db48..00ea9bba0d19 100644
--- a/src/tools/clippy/clippy_lints/src/min_ident_chars.rs
+++ b/src/tools/clippy/clippy_lints/src/min_ident_chars.rs
@@ -121,8 +121,7 @@ impl Visitor<'_> for IdentVisitor<'_, '_> {
             // Check whether the node is part of a `use` statement. We don't want to emit a warning if the user
             // has no control over the type.
             let usenode = opt_as_use_node(node).or_else(|| {
-                cx
-                    .tcx
+                cx.tcx
                     .hir_parent_iter(hir_id)
                     .find_map(|(_, node)| opt_as_use_node(node))
             });
diff --git a/src/tools/clippy/clippy_lints/src/misc.rs b/src/tools/clippy/clippy_lints/src/misc.rs
index fca416d9e64c..693d1a8dd764 100644
--- a/src/tools/clippy/clippy_lints/src/misc.rs
+++ b/src/tools/clippy/clippy_lints/src/misc.rs
@@ -7,7 +7,6 @@ use clippy_utils::{
 };
 use rustc_errors::Applicability;
 use rustc_hir::def::Res;
-use rustc_hir::def_id::LOCAL_CRATE;
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
     BinOpKind, BindingMode, Body, ByRef, Expr, ExprKind, FnDecl, Mutability, PatKind, QPath, Stmt, StmtKind,
@@ -286,7 +285,8 @@ fn used_underscore_items<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'_>) {
     if name.starts_with('_')
         && !name.starts_with("__")
         && !definition_span.from_expansion()
-        && def_id.krate == LOCAL_CRATE
+        && def_id.is_local()
+        && !cx.tcx.is_foreign_item(def_id)
     {
         span_lint_and_then(
             cx,
diff --git a/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs b/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
index 8d751c2c0acb..38a19dd2999b 100644
--- a/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_const_for_fn.rs
@@ -1,9 +1,9 @@
-
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::qualify_min_const_fn::is_min_const_fn;
 use clippy_utils::{fn_has_unsatisfiable_preds, is_entrypoint_fn, is_from_proc_macro, is_in_test, trait_ref_of_method};
+use rustc_abi::ExternAbi;
 use rustc_errors::Applicability;
 use rustc_hir::def_id::CRATE_DEF_ID;
 use rustc_hir::intravisit::FnKind;
@@ -13,7 +13,6 @@ use rustc_middle::ty;
 use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
-use rustc_abi::ExternAbi;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -81,9 +80,7 @@ pub struct MissingConstForFn {
 
 impl MissingConstForFn {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -102,10 +99,6 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
             return;
         }
 
-        if !self.msrv.meets(msrvs::CONST_IF_MATCH) {
-            return;
-        }
-
         if span.in_external_macro(cx.tcx.sess.source_map()) || is_entrypoint_fn(cx, def_id.to_def_id()) {
             return;
         }
@@ -124,7 +117,9 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
                     .iter()
                     .any(|param| matches!(param.kind, GenericParamKind::Const { .. }));
 
-                if already_const(header) || has_const_generic_params || !could_be_const_with_abi(&self.msrv, header.abi)
+                if already_const(header)
+                    || has_const_generic_params
+                    || !could_be_const_with_abi(cx, self.msrv, header.abi)
                 {
                     return;
                 }
@@ -153,13 +148,17 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
             }
         }
 
+        if !self.msrv.meets(cx, msrvs::CONST_IF_MATCH) {
+            return;
+        }
+
         if is_from_proc_macro(cx, &(&kind, body, hir_id, span)) {
             return;
         }
 
         let mir = cx.tcx.optimized_mir(def_id);
 
-        if let Ok(()) = is_min_const_fn(cx.tcx, mir, &self.msrv)
+        if let Ok(()) = is_min_const_fn(cx, mir, self.msrv)
             && let hir::Node::Item(hir::Item { vis_span, .. }) | hir::Node::ImplItem(hir::ImplItem { vis_span, .. }) =
                 cx.tcx.hir_node_by_def_id(def_id)
         {
@@ -174,8 +173,6 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForFn {
             });
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 // We don't have to lint on something that's already `const`
@@ -184,13 +181,13 @@ fn already_const(header: hir::FnHeader) -> bool {
     header.constness == Constness::Const
 }
 
-fn could_be_const_with_abi(msrv: &Msrv, abi: ExternAbi) -> bool {
+fn could_be_const_with_abi(cx: &LateContext<'_>, msrv: Msrv, abi: ExternAbi) -> bool {
     match abi {
         ExternAbi::Rust => true,
         // `const extern "C"` was stabilized after 1.62.0
-        ExternAbi::C { unwind: false } => msrv.meets(msrvs::CONST_EXTERN_C_FN),
+        ExternAbi::C { unwind: false } => msrv.meets(cx, msrvs::CONST_EXTERN_C_FN),
         // Rest ABIs are still unstable and need the `const_extern_fn` feature enabled.
-        _ => msrv.meets(msrvs::CONST_EXTERN_FN),
+        _ => msrv.meets(cx, msrvs::CONST_EXTERN_FN),
     }
 }
 
diff --git a/src/tools/clippy/clippy_lints/src/missing_const_for_thread_local.rs b/src/tools/clippy/clippy_lints/src/missing_const_for_thread_local.rs
index d4181c677afd..ea74940828a1 100644
--- a/src/tools/clippy/clippy_lints/src/missing_const_for_thread_local.rs
+++ b/src/tools/clippy/clippy_lints/src/missing_const_for_thread_local.rs
@@ -49,9 +49,7 @@ pub struct MissingConstForThreadLocal {
 
 impl MissingConstForThreadLocal {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -91,11 +89,11 @@ fn is_unreachable(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
 }
 
 #[inline]
-fn initializer_can_be_made_const(cx: &LateContext<'_>, defid: rustc_span::def_id::DefId, msrv: &Msrv) -> bool {
+fn initializer_can_be_made_const(cx: &LateContext<'_>, defid: rustc_span::def_id::DefId, msrv: Msrv) -> bool {
     // Building MIR for `fn`s with unsatisfiable preds results in ICE.
     if !fn_has_unsatisfiable_preds(cx, defid)
         && let mir = cx.tcx.optimized_mir(defid)
-        && let Ok(()) = is_min_const_fn(cx.tcx, mir, msrv)
+        && let Ok(()) = is_min_const_fn(cx, mir, msrv)
     {
         return true;
     }
@@ -113,8 +111,7 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForThreadLocal {
         local_defid: rustc_span::def_id::LocalDefId,
     ) {
         let defid = local_defid.to_def_id();
-        if self.msrv.meets(msrvs::THREAD_LOCAL_CONST_INIT)
-            && is_thread_local_initializer(cx, fn_kind, span).unwrap_or(false)
+        if is_thread_local_initializer(cx, fn_kind, span).unwrap_or(false)
             // Some implementations of `thread_local!` include an initializer fn.
             // In the case of a const initializer, the init fn is also const,
             // so we can skip the lint in that case. This occurs only on some
@@ -131,11 +128,12 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForThreadLocal {
             // https://github.com/rust-lang/rust-clippy/issues/12637
             // we ensure that this is reachable before we check in mir
             && !is_unreachable(cx, ret_expr)
-            && initializer_can_be_made_const(cx, defid, &self.msrv)
+            && initializer_can_be_made_const(cx, defid, self.msrv)
             // we know that the function is const-qualifiable, so now
             // we need only to get the initializer expression to span-lint it.
             && let initializer_snippet = snippet(cx, ret_expr.span, "thread_local! { ... }")
             && initializer_snippet != "thread_local! { ... }"
+            && self.msrv.meets(cx, msrvs::THREAD_LOCAL_CONST_INIT)
         {
             span_lint_and_sugg(
                 cx,
@@ -148,6 +146,4 @@ impl<'tcx> LateLintPass<'tcx> for MissingConstForThreadLocal {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/mut_reference.rs b/src/tools/clippy/clippy_lints/src/mut_reference.rs
index c382fb8fce1b..2fd1049f42e1 100644
--- a/src/tools/clippy/clippy_lints/src/mut_reference.rs
+++ b/src/tools/clippy/clippy_lints/src/mut_reference.rs
@@ -54,8 +54,9 @@ impl<'tcx> LateLintPass<'tcx> for UnnecessaryMutPassed {
                     );
                 }
             },
-            ExprKind::MethodCall(path, receiver, arguments, _) => {
-                let def_id = cx.typeck_results().type_dependent_def_id(e.hir_id).unwrap();
+            ExprKind::MethodCall(path, receiver, arguments, _)
+                if let Some(def_id) = cx.typeck_results().type_dependent_def_id(e.hir_id) =>
+            {
                 let args = cx.typeck_results().node_args(e.hir_id);
                 let method_type = cx.tcx.type_of(def_id).instantiate(cx.tcx, args);
                 check_arguments(
diff --git a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
index ea1d7e5d4382..f686cc912ddb 100644
--- a/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_borrows_for_generic_args.rs
@@ -72,7 +72,7 @@ impl NeedlessBorrowsForGenericArgs<'_> {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             possible_borrowers: Vec::new(),
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
         }
     }
 }
@@ -114,7 +114,7 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
                 i,
                 param_ty,
                 expr,
-                &self.msrv,
+                self.msrv,
             )
             && count != 0
         {
@@ -142,8 +142,6 @@ impl<'tcx> LateLintPass<'tcx> for NeedlessBorrowsForGenericArgs<'tcx> {
             self.possible_borrowers.pop();
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn path_has_args(p: &QPath<'_>) -> bool {
@@ -172,7 +170,7 @@ fn needless_borrow_count<'tcx>(
     arg_index: usize,
     param_ty: ParamTy,
     mut expr: &Expr<'tcx>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> usize {
     let destruct_trait_def_id = cx.tcx.lang_items().destruct_trait();
     let sized_trait_def_id = cx.tcx.lang_items().sized_trait();
@@ -273,7 +271,7 @@ fn needless_borrow_count<'tcx>(
                 && let ty::Param(param_ty) = trait_predicate.self_ty().kind()
                 && let GenericArgKind::Type(ty) = args_with_referent_ty[param_ty.index as usize].unpack()
                 && ty.is_array()
-                && !msrv.meets(msrvs::ARRAY_INTO_ITERATOR)
+                && !msrv.meets(cx, msrvs::ARRAY_INTO_ITERATOR)
             {
                 return false;
             }
diff --git a/src/tools/clippy/clippy_lints/src/needless_continue.rs b/src/tools/clippy/clippy_lints/src/needless_continue.rs
index 05b31fc84b9b..b8601f77e249 100644
--- a/src/tools/clippy/clippy_lints/src/needless_continue.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_continue.rs
@@ -356,7 +356,7 @@ fn suggestion_snippet_for_continue_inside_else(cx: &EarlyContext<'_>, data: &Lin
         .iter()
         .map(|stmt| {
             let span = cx.sess().source_map().stmt_span(stmt.span, data.loop_block.span);
-            let snip = snippet_block(cx, span, "..", None).into_owned();
+            let snip = snippet_block(cx, span, "..", None);
             snip.lines()
                 .map(|line| format!("{}{line}", " ".repeat(indent)))
                 .collect::<Vec<_>>()
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
index 36a0738cbc95..d5c5679c990d 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_ref_mut.rs
@@ -5,6 +5,7 @@ use clippy_utils::source::snippet;
 use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{inherits_cfg, is_from_proc_macro, is_self};
 use core::ops::ControlFlow;
+use rustc_abi::ExternAbi;
 use rustc_data_structures::fx::{FxHashSet, FxIndexMap, FxIndexSet};
 use rustc_errors::Applicability;
 use rustc_hir::intravisit::FnKind;
@@ -20,7 +21,6 @@ use rustc_session::impl_lint_pass;
 use rustc_span::Span;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
-use rustc_abi::ExternAbi;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
index 40c65d1ef9e8..380cc380ad0f 100644
--- a/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
+++ b/src/tools/clippy/clippy_lints/src/needless_pass_by_value.rs
@@ -5,6 +5,7 @@ use clippy_utils::source::{SpanRangeExt, snippet};
 use clippy_utils::ty::{
     implements_trait, implements_trait_with_env_from_iter, is_copy, is_type_diagnostic_item, is_type_lang_item,
 };
+use rustc_abi::ExternAbi;
 use rustc_errors::{Applicability, Diag};
 use rustc_hir::intravisit::FnKind;
 use rustc_hir::{
@@ -19,7 +20,6 @@ use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::symbol::kw;
 use rustc_span::{Span, sym};
-use rustc_abi::ExternAbi;
 use rustc_trait_selection::traits;
 use rustc_trait_selection::traits::misc::type_allowed_to_implement_copy;
 
diff --git a/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs b/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs
index b73b9083a991..1baa3cb2f0fd 100644
--- a/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs
+++ b/src/tools/clippy/clippy_lints/src/no_mangle_with_rust_abi.rs
@@ -1,11 +1,11 @@
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::source::{snippet, snippet_with_applicability};
+use rustc_abi::ExternAbi;
 use rustc_errors::Applicability;
 use rustc_hir::{Item, ItemKind};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 use rustc_span::{BytePos, Pos};
-use rustc_abi::ExternAbi;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -54,7 +54,7 @@ impl<'tcx> LateLintPass<'tcx> for NoMangleWithRustAbi {
                         .span
                         .with_lo(fn_sig.span.lo() + BytePos::from_usize(fn_attrs.len()))
                         .shrink_to_lo();
-                    let attr_snippet = snippet(cx, attr.span, "..");
+                    let attr_snippet = snippet(cx, attr.span(), "..");
 
                     span_lint_and_then(
                         cx,
diff --git a/src/tools/clippy/clippy_lints/src/non_copy_const.rs b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
index 4007ca88a00e..d4da12451f18 100644
--- a/src/tools/clippy/clippy_lints/src/non_copy_const.rs
+++ b/src/tools/clippy/clippy_lints/src/non_copy_const.rs
@@ -180,7 +180,9 @@ impl<'tcx> NonCopyConst<'tcx> {
 
     fn is_value_unfrozen_raw_inner(cx: &LateContext<'tcx>, val: ty::ValTree<'tcx>, ty: Ty<'tcx>) -> bool {
         // No branch that we check (yet) should continue if val isn't a branch
-        let Some(val) = val.try_to_branch() else { return false };
+        let Some(branched_val) = val.try_to_branch() else {
+            return false;
+        };
         match *ty.kind() {
             // the fact that we have to dig into every structs to search enums
             // leads us to the point checking `UnsafeCell` directly is the only option.
@@ -188,11 +190,11 @@ impl<'tcx> NonCopyConst<'tcx> {
             // As of 2022-09-08 miri doesn't track which union field is active so there's no safe way to check the
             // contained value.
             ty::Adt(def, ..) if def.is_union() => false,
-            ty::Array(ty, _) => val
+            ty::Array(ty, _) => branched_val
                 .iter()
                 .any(|field| Self::is_value_unfrozen_raw_inner(cx, *field, ty)),
             ty::Adt(def, args) if def.is_enum() => {
-                let Some((&variant_valtree, fields)) = val.split_first() else {
+                let Some((&variant_valtree, fields)) = branched_val.split_first() else {
                     return false;
                 };
                 let variant_index = variant_valtree.unwrap_leaf();
@@ -208,14 +210,18 @@ impl<'tcx> NonCopyConst<'tcx> {
                     )
                     .any(|(field, ty)| Self::is_value_unfrozen_raw_inner(cx, field, ty))
             },
-            ty::Adt(def, args) => val
+            ty::Adt(def, args) => branched_val
                 .iter()
                 .zip(def.non_enum_variant().fields.iter().map(|field| field.ty(cx.tcx, args)))
                 .any(|(field, ty)| Self::is_value_unfrozen_raw_inner(cx, *field, ty)),
-            ty::Tuple(tys) => val
+            ty::Tuple(tys) => branched_val
                 .iter()
                 .zip(tys)
                 .any(|(field, ty)| Self::is_value_unfrozen_raw_inner(cx, *field, ty)),
+            ty::Alias(ty::Projection, _) => match cx.tcx.try_normalize_erasing_regions(cx.typing_env(), ty) {
+                Ok(normalized_ty) if ty != normalized_ty => Self::is_value_unfrozen_raw_inner(cx, val, normalized_ty),
+                _ => false,
+            },
             _ => false,
         }
     }
diff --git a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs
index 1a3b43cbb10a..c5873589b26f 100644
--- a/src/tools/clippy/clippy_lints/src/non_expressive_names.rs
+++ b/src/tools/clippy/clippy_lints/src/non_expressive_names.rs
@@ -208,7 +208,8 @@ impl SimilarNamesNameVisitor<'_, '_, '_> {
 
     fn check_ident(&mut self, ident: Ident) {
         let interned_name = ident.name.as_str();
-        if interned_name.chars().any(char::is_uppercase) {
+        // name can be empty if it comes from recovery
+        if interned_name.chars().any(char::is_uppercase) || interned_name.is_empty() {
             return;
         }
         if interned_name.chars().all(|c| c.is_ascii_digit() || c == '_') {
diff --git a/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs b/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs
index 774a182d089f..a82365f94318 100644
--- a/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs
+++ b/src/tools/clippy/clippy_lints/src/non_std_lazy_statics.rs
@@ -1,8 +1,8 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::{span_lint, span_lint_and_then};
-use clippy_utils::msrvs::Msrv;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::visitors::for_each_expr;
-use clippy_utils::{def_path_def_ids, fn_def_id, path_def_id};
+use clippy_utils::{def_path_def_ids, fn_def_id, is_no_std_crate, path_def_id};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::Applicability;
 use rustc_hir::def::{DefKind, Res};
@@ -75,7 +75,7 @@ impl NonStdLazyStatic {
     #[must_use]
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             lazy_static_lazy_static: Vec::new(),
             once_cell_crate: Vec::new(),
             once_cell_sync_lazy: Vec::new(),
@@ -89,23 +89,12 @@ impl NonStdLazyStatic {
 
 impl_lint_pass!(NonStdLazyStatic => [NON_STD_LAZY_STATICS]);
 
-/// Return if current MSRV does not meet the requirement for `lazy_cell` feature,
-/// or current context has `no_std` attribute.
-macro_rules! ensure_prerequisite {
-    ($msrv:expr, $cx:ident) => {
-        if !$msrv.meets(clippy_utils::msrvs::LAZY_CELL) || clippy_utils::is_no_std_crate($cx) {
-            return;
-        }
-    };
+fn can_use_lazy_cell(cx: &LateContext<'_>, msrv: Msrv) -> bool {
+    msrv.meets(cx, msrvs::LAZY_CELL) && !is_no_std_crate(cx)
 }
 
 impl<'hir> LateLintPass<'hir> for NonStdLazyStatic {
-    extract_msrv_attr!(LateContext);
-
     fn check_crate(&mut self, cx: &LateContext<'hir>) {
-        // Do not lint if current crate does not support `LazyLock`.
-        ensure_prerequisite!(self.msrv, cx);
-
         // Fetch def_ids for external paths
         self.lazy_static_lazy_static = def_path_def_ids(cx.tcx, &["lazy_static", "lazy_static"]).collect();
         self.once_cell_sync_lazy = def_path_def_ids(cx.tcx, &["once_cell", "sync", "Lazy"]).collect();
@@ -123,11 +112,10 @@ impl<'hir> LateLintPass<'hir> for NonStdLazyStatic {
     }
 
     fn check_item(&mut self, cx: &LateContext<'hir>, item: &Item<'hir>) {
-        ensure_prerequisite!(self.msrv, cx);
-
         if let ItemKind::Static(..) = item.kind
             && let Some(macro_call) = clippy_utils::macros::root_macro_call(item.span)
             && self.lazy_static_lazy_static.contains(&macro_call.def_id)
+            && can_use_lazy_cell(cx, self.msrv)
         {
             span_lint(
                 cx,
@@ -142,14 +130,14 @@ impl<'hir> LateLintPass<'hir> for NonStdLazyStatic {
             return;
         }
 
-        if let Some(lazy_info) = LazyInfo::from_item(self, cx, item) {
+        if let Some(lazy_info) = LazyInfo::from_item(self, cx, item)
+            && can_use_lazy_cell(cx, self.msrv)
+        {
             self.lazy_type_defs.insert(item.owner_id.to_def_id(), lazy_info);
         }
     }
 
     fn check_expr(&mut self, cx: &LateContext<'hir>, expr: &Expr<'hir>) {
-        ensure_prerequisite!(self.msrv, cx);
-
         // All functions in the `FUNCTION_REPLACEMENTS` have only one args
         if let ExprKind::Call(callee, [arg]) = expr.kind
             && let Some(call_def_id) = fn_def_id(cx, expr)
@@ -163,8 +151,6 @@ impl<'hir> LateLintPass<'hir> for NonStdLazyStatic {
     }
 
     fn check_ty(&mut self, cx: &LateContext<'hir>, ty: &'hir rustc_hir::Ty<'hir, rustc_hir::AmbigArg>) {
-        ensure_prerequisite!(self.msrv, cx);
-
         // Record if types from `once_cell` besides `sync::Lazy` are used.
         if let rustc_hir::TyKind::Path(qpath) = ty.peel_refs().kind
             && let Some(ty_def_id) = cx.qpath_res(&qpath, ty.hir_id).opt_def_id()
@@ -178,8 +164,6 @@ impl<'hir> LateLintPass<'hir> for NonStdLazyStatic {
     }
 
     fn check_crate_post(&mut self, cx: &LateContext<'hir>) {
-        ensure_prerequisite!(self.msrv, cx);
-
         if !self.uses_other_once_cell_types {
             for (_, lazy_info) in &self.lazy_type_defs {
                 lazy_info.lint(cx, &self.sugg_map);
diff --git a/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs b/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs
index 34f7dbea84e4..74e0a6333db0 100644
--- a/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/float_equality_without_abs.rs
@@ -50,7 +50,7 @@ pub(crate) fn check<'tcx>(
         // format the suggestion
         let suggestion = format!(
             "{}.abs()",
-            sugg::make_assoc(AssocOp::Subtract, &sug_l, &sug_r).maybe_par()
+            sugg::make_assoc(AssocOp::Binary(BinOpKind::Sub), &sug_l, &sug_r).maybe_par()
         );
         // spans the lint
         span_lint_and_then(
diff --git a/src/tools/clippy/clippy_lints/src/operators/manual_midpoint.rs b/src/tools/clippy/clippy_lints/src/operators/manual_midpoint.rs
new file mode 100644
index 000000000000..81721a9f2af5
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/operators/manual_midpoint.rs
@@ -0,0 +1,64 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::sugg::Sugg;
+use clippy_utils::{is_float_literal, is_integer_literal};
+use rustc_ast::BinOpKind;
+use rustc_errors::Applicability;
+use rustc_hir::{Expr, ExprKind};
+use rustc_lint::LateContext;
+use rustc_middle::ty::{self, Ty};
+
+use super::MANUAL_MIDPOINT;
+
+pub(super) fn check<'tcx>(
+    cx: &LateContext<'tcx>,
+    expr: &'tcx Expr<'_>,
+    op: BinOpKind,
+    left: &'tcx Expr<'_>,
+    right: &'tcx Expr<'_>,
+    msrv: Msrv,
+) {
+    if !left.span.from_expansion()
+        && !right.span.from_expansion()
+        && op == BinOpKind::Div
+        && (is_integer_literal(right, 2) || is_float_literal(right, 2.0))
+        && let Some((ll_expr, lr_expr)) = add_operands(left)
+        && add_operands(ll_expr).is_none() && add_operands(lr_expr).is_none()
+        && let left_ty = cx.typeck_results().expr_ty_adjusted(ll_expr)
+        && let right_ty = cx.typeck_results().expr_ty_adjusted(lr_expr)
+        && left_ty == right_ty
+        // Do not lint on `(_+1)/2` and `(1+_)/2`, it is likely a `div_ceil()` operation
+        && !is_integer_literal(ll_expr, 1) && !is_integer_literal(lr_expr, 1)
+        && is_midpoint_implemented(cx, left_ty, msrv)
+    {
+        let mut app = Applicability::MachineApplicable;
+        let left_sugg = Sugg::hir_with_context(cx, ll_expr, expr.span.ctxt(), "..", &mut app);
+        let right_sugg = Sugg::hir_with_context(cx, lr_expr, expr.span.ctxt(), "..", &mut app);
+        let sugg = format!("{left_ty}::midpoint({left_sugg}, {right_sugg})");
+        span_lint_and_sugg(
+            cx,
+            MANUAL_MIDPOINT,
+            expr.span,
+            "manual implementation of `midpoint` which can overflow",
+            format!("use `{left_ty}::midpoint` instead"),
+            sugg,
+            app,
+        );
+    }
+}
+
+/// Return the left and right operands if `expr` represents an addition
+fn add_operands<'e, 'tcx>(expr: &'e Expr<'tcx>) -> Option<(&'e Expr<'tcx>, &'e Expr<'tcx>)> {
+    match expr.kind {
+        ExprKind::Binary(op, left, right) if op.node == BinOpKind::Add => Some((left, right)),
+        _ => None,
+    }
+}
+
+fn is_midpoint_implemented(cx: &LateContext<'_>, ty: Ty<'_>, msrv: Msrv) -> bool {
+    match ty.kind() {
+        ty::Uint(_) | ty::Float(_) => msrv.meets(cx, msrvs::UINT_FLOAT_MIDPOINT),
+        ty::Int(_) => msrv.meets(cx, msrvs::INT_MIDPOINT),
+        _ => false,
+    }
+}
diff --git a/src/tools/clippy/clippy_lints/src/operators/mod.rs b/src/tools/clippy/clippy_lints/src/operators/mod.rs
index 9ad32c2bd396..80459945094e 100644
--- a/src/tools/clippy/clippy_lints/src/operators/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/operators/mod.rs
@@ -11,6 +11,7 @@ mod float_cmp;
 mod float_equality_without_abs;
 mod identity_op;
 mod integer_division;
+mod manual_midpoint;
 mod misrefactored_assign_op;
 mod modulo_arithmetic;
 mod modulo_one;
@@ -24,6 +25,7 @@ mod verbose_bit_mask;
 pub(crate) mod arithmetic_side_effects;
 
 use clippy_config::Conf;
+use clippy_utils::msrvs::Msrv;
 use rustc_hir::{Body, Expr, ExprKind, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
@@ -834,10 +836,35 @@ declare_clippy_lint! {
     "explicit self-assignment"
 }
 
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for manual implementation of `midpoint`.
+    ///
+    /// ### Why is this bad?
+    /// Using `(x + y) / 2` might cause an overflow on the intermediate
+    /// addition result.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// # let a: u32 = 0;
+    /// let c = (a + 10) / 2;
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// # let a: u32 = 0;
+    /// let c = u32::midpoint(a, 10);
+    /// ```
+    #[clippy::version = "1.87.0"]
+    pub MANUAL_MIDPOINT,
+    pedantic,
+    "manual implementation of `midpoint` which can overflow"
+}
+
 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 {
@@ -845,6 +872,7 @@ impl Operators {
             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,
         }
     }
 }
@@ -876,6 +904,7 @@ impl_lint_pass!(Operators => [
     NEEDLESS_BITWISE_BOOL,
     PTR_EQ,
     SELF_ASSIGNMENT,
+    MANUAL_MIDPOINT,
 ]);
 
 impl<'tcx> LateLintPass<'tcx> for Operators {
@@ -893,6 +922,7 @@ impl<'tcx> LateLintPass<'tcx> for Operators {
                     identity_op::check(cx, e, op.node, lhs, rhs);
                     needless_bitwise_bool::check(cx, e, op.node, lhs, rhs);
                     ptr_eq::check(cx, e, op.node, lhs, rhs);
+                    manual_midpoint::check(cx, e, op.node, lhs, rhs, self.msrv);
                 }
                 self.arithmetic_context.check_binary(cx, e, op.node, lhs, rhs);
                 bit_mask::check(cx, e, op.node, lhs, rhs);
diff --git a/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs b/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs
index c9bdeed660e2..39ae9967e016 100644
--- a/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs
+++ b/src/tools/clippy/clippy_lints/src/panic_unimplemented.rs
@@ -1,11 +1,12 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint;
+use clippy_utils::is_in_test;
 use clippy_utils::macros::{is_panic, root_macro_call_first_node};
-use clippy_utils::{is_in_test, match_def_path, paths};
 use rustc_hir::def::{DefKind, Res};
 use rustc_hir::{Expr, ExprKind, QPath};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::impl_lint_pass;
+use rustc_span::sym;
 
 pub struct PanicUnimplemented {
     allow_panic_in_tests: bool,
@@ -137,7 +138,7 @@ impl<'tcx> LateLintPass<'tcx> for PanicUnimplemented {
         } else if let ExprKind::Call(func, [_]) = expr.kind
             && let ExprKind::Path(QPath::Resolved(None, expr_path)) = func.kind
             && let Res::Def(DefKind::Fn, def_id) = expr_path.res
-            && match_def_path(cx, def_id, &paths::PANIC_ANY)
+            && cx.tcx.is_diagnostic_item(sym::panic_any, def_id)
         {
             if cx.tcx.hir_is_inside_const_context(expr.hir_id)
                 || self.allow_panic_in_tests && is_in_test(cx.tcx, expr.hir_id)
diff --git a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
index 73c31b83b51f..49bc56083468 100644
--- a/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
+++ b/src/tools/clippy/clippy_lints/src/pass_by_ref_or_value.rs
@@ -6,6 +6,7 @@ use clippy_utils::source::snippet;
 use clippy_utils::ty::{for_each_top_level_late_bound_region, is_copy};
 use clippy_utils::{is_self, is_self_ty};
 use core::ops::ControlFlow;
+use rustc_abi::ExternAbi;
 use rustc_ast::attr;
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
@@ -19,7 +20,6 @@ use rustc_middle::ty::{self, RegionKind, TyCtxt};
 use rustc_session::impl_lint_pass;
 use rustc_span::def_id::LocalDefId;
 use rustc_span::{Span, sym};
-use rustc_abi::ExternAbi;
 
 declare_clippy_lint! {
     /// ### What it does
diff --git a/src/tools/clippy/clippy_lints/src/ptr.rs b/src/tools/clippy/clippy_lints/src/ptr.rs
index ef4948a05b7f..dae0709a5404 100644
--- a/src/tools/clippy/clippy_lints/src/ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/ptr.rs
@@ -4,6 +4,7 @@ use clippy_utils::sugg::Sugg;
 use clippy_utils::visitors::contains_unsafe_block;
 use clippy_utils::{get_expr_use_or_unification_node, is_lint_allowed, path_def_id, path_to_local, std_or_core};
 use hir::LifetimeName;
+use rustc_abi::ExternAbi;
 use rustc_errors::{Applicability, MultiSpan};
 use rustc_hir::hir_id::{HirId, HirIdMap};
 use rustc_hir::intravisit::{Visitor, walk_expr};
@@ -19,7 +20,6 @@ use rustc_middle::ty::{self, Binder, ClauseKind, ExistentialPredicate, List, Pre
 use rustc_session::declare_lint_pass;
 use rustc_span::symbol::Symbol;
 use rustc_span::{Span, sym};
-use rustc_abi::ExternAbi;
 use rustc_trait_selection::infer::InferCtxtExt as _;
 use rustc_trait_selection::traits::query::evaluate_obligation::InferCtxtExt as _;
 use std::{fmt, iter};
diff --git a/src/tools/clippy/clippy_lints/src/question_mark.rs b/src/tools/clippy/clippy_lints/src/question_mark.rs
index ffc3b86c502e..4f5f3eb6c15a 100644
--- a/src/tools/clippy/clippy_lints/src/question_mark.rs
+++ b/src/tools/clippy/clippy_lints/src/question_mark.rs
@@ -68,7 +68,7 @@ impl_lint_pass!(QuestionMark => [QUESTION_MARK, MANUAL_LET_ELSE]);
 impl QuestionMark {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             matches_behaviour: conf.matches_for_let_else,
             try_block_depth_stack: Vec::new(),
             inferred_ret_closure_stack: 0,
@@ -543,5 +543,4 @@ impl<'tcx> LateLintPass<'tcx> for QuestionMark {
                 .expect("blocks are always part of bodies and must have a depth") -= 1;
         }
     }
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/ranges.rs b/src/tools/clippy/clippy_lints/src/ranges.rs
index 1b0c0a4956f7..cc423eca74fb 100644
--- a/src/tools/clippy/clippy_lints/src/ranges.rs
+++ b/src/tools/clippy/clippy_lints/src/ranges.rs
@@ -166,9 +166,7 @@ pub struct Ranges {
 
 impl Ranges {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -182,7 +180,7 @@ impl_lint_pass!(Ranges => [
 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 {
-            if self.msrv.meets(msrvs::RANGE_CONTAINS) {
+            if self.msrv.meets(cx, msrvs::RANGE_CONTAINS) {
                 check_possible_range_contains(cx, op.node, l, r, expr, expr.span);
             }
         }
@@ -191,7 +189,6 @@ impl<'tcx> LateLintPass<'tcx> for Ranges {
         check_inclusive_range_minus_one(cx, expr);
         check_reversed_empty_range(cx, expr);
     }
-    extract_msrv_attr!(LateContext);
 }
 
 fn check_possible_range_contains(
diff --git a/src/tools/clippy/clippy_lints/src/redundant_else.rs b/src/tools/clippy/clippy_lints/src/redundant_else.rs
index a1b5a3aff323..a3be16ed858e 100644
--- a/src/tools/clippy/clippy_lints/src/redundant_else.rs
+++ b/src/tools/clippy/clippy_lints/src/redundant_else.rs
@@ -6,7 +6,6 @@ use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
 use rustc_session::declare_lint_pass;
 use rustc_span::Span;
-use std::borrow::Cow;
 
 declare_clippy_lint! {
     /// ### What it does
@@ -163,14 +162,9 @@ fn extract_else_block(mut block: &str) -> String {
     block.trim_end().to_string()
 }
 
-fn make_sugg<'a>(
-    cx: &EarlyContext<'_>,
-    els_span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
+fn make_sugg(cx: &EarlyContext<'_>, els_span: Span, default: &str, indent_relative_to: Option<Span>) -> String {
     let extracted = extract_else_block(&snippet(cx, els_span, default));
     let indent = indent_relative_to.and_then(|s| indent_of(cx, s));
 
-    reindent_multiline(extracted.into(), false, indent)
+    reindent_multiline(&extracted, false, indent)
 }
diff --git a/src/tools/clippy/clippy_lints/src/redundant_field_names.rs b/src/tools/clippy/clippy_lints/src/redundant_field_names.rs
index 707abc008a86..feefe10f57d7 100644
--- a/src/tools/clippy/clippy_lints/src/redundant_field_names.rs
+++ b/src/tools/clippy/clippy_lints/src/redundant_field_names.rs
@@ -1,6 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs::{self, MsrvStack};
 use rustc_ast::ast::{Expr, ExprKind};
 use rustc_errors::Applicability;
 use rustc_lint::{EarlyContext, EarlyLintPass, LintContext};
@@ -36,13 +36,13 @@ declare_clippy_lint! {
 }
 
 pub struct RedundantFieldNames {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 
 impl RedundantFieldNames {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: MsrvStack::new(conf.msrv),
         }
     }
 }
@@ -80,5 +80,6 @@ impl EarlyLintPass for RedundantFieldNames {
             }
         }
     }
-    extract_msrv_attr!(EarlyContext);
+
+    extract_msrv_attr!();
 }
diff --git a/src/tools/clippy/clippy_lints/src/redundant_locals.rs b/src/tools/clippy/clippy_lints/src/redundant_locals.rs
index f3ccc9e38f4d..defb6684cffb 100644
--- a/src/tools/clippy/clippy_lints/src/redundant_locals.rs
+++ b/src/tools/clippy/clippy_lints/src/redundant_locals.rs
@@ -123,6 +123,5 @@ fn find_binding(pat: &Pat<'_>, name: Ident) -> Option<BindingMode> {
 /// Check if a rebinding of a local changes the effect of assignments to the binding.
 fn affects_assignments(cx: &LateContext<'_>, mutability: Mutability, bind: HirId, rebind: HirId) -> bool {
     // the binding is mutable and the rebinding is in a different scope than the original binding
-    mutability == Mutability::Mut
-        && cx.tcx.hir_get_enclosing_scope(bind) != cx.tcx.hir_get_enclosing_scope(rebind)
+    mutability == Mutability::Mut && cx.tcx.hir_get_enclosing_scope(bind) != cx.tcx.hir_get_enclosing_scope(rebind)
 }
diff --git a/src/tools/clippy/clippy_lints/src/redundant_static_lifetimes.rs b/src/tools/clippy/clippy_lints/src/redundant_static_lifetimes.rs
index 06c854338066..b4e1f70d1535 100644
--- a/src/tools/clippy/clippy_lints/src/redundant_static_lifetimes.rs
+++ b/src/tools/clippy/clippy_lints/src/redundant_static_lifetimes.rs
@@ -1,6 +1,6 @@
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs::{self, MsrvStack};
 use clippy_utils::source::snippet;
 use rustc_ast::ast::{ConstItem, Item, ItemKind, StaticItem, Ty, TyKind};
 use rustc_errors::Applicability;
@@ -35,13 +35,13 @@ declare_clippy_lint! {
 }
 
 pub struct RedundantStaticLifetimes {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 
 impl RedundantStaticLifetimes {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: MsrvStack::new(conf.msrv),
         }
     }
 }
@@ -115,5 +115,5 @@ impl EarlyLintPass for RedundantStaticLifetimes {
         }
     }
 
-    extract_msrv_attr!(EarlyContext);
+    extract_msrv_attr!();
 }
diff --git a/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs b/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs
index 5dddf9263a35..8805687efccf 100644
--- a/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs
+++ b/src/tools/clippy/clippy_lints/src/repeat_vec_with_capacity.rs
@@ -1,15 +1,27 @@
+use clippy_config::Conf;
 use clippy_utils::consts::{ConstEvalCtxt, Constant};
 use clippy_utils::diagnostics::span_lint_and_then;
 use clippy_utils::higher::VecArgs;
 use clippy_utils::macros::matching_root_macro_call;
+use clippy_utils::msrvs::{self, Msrv};
 use clippy_utils::source::snippet;
 use clippy_utils::{expr_or_init, fn_def_id, std_or_core};
 use rustc_errors::Applicability;
 use rustc_hir::{Expr, ExprKind};
 use rustc_lint::{LateContext, LateLintPass};
-use rustc_session::declare_lint_pass;
+use rustc_session::impl_lint_pass;
 use rustc_span::{Span, sym};
 
+pub struct RepeatVecWithCapacity {
+    msrv: Msrv,
+}
+
+impl RepeatVecWithCapacity {
+    pub fn new(conf: &'static Conf) -> Self {
+        Self { msrv: conf.msrv }
+    }
+}
+
 declare_clippy_lint! {
     /// ### What it does
     /// Looks for patterns such as `vec![Vec::with_capacity(x); n]` or `iter::repeat(Vec::with_capacity(x))`.
@@ -48,7 +60,7 @@ declare_clippy_lint! {
     "repeating a `Vec::with_capacity` expression which does not retain capacity"
 }
 
-declare_lint_pass!(RepeatVecWithCapacity => [REPEAT_VEC_WITH_CAPACITY]);
+impl_lint_pass!(RepeatVecWithCapacity => [REPEAT_VEC_WITH_CAPACITY]);
 
 fn emit_lint(cx: &LateContext<'_>, span: Span, kind: &str, note: &'static str, sugg_msg: &'static str, sugg: String) {
     span_lint_and_then(
@@ -87,13 +99,14 @@ fn check_vec_macro(cx: &LateContext<'_>, expr: &Expr<'_>) {
 }
 
 /// Checks `iter::repeat(Vec::with_capacity(x))`
-fn check_repeat_fn(cx: &LateContext<'_>, expr: &Expr<'_>) {
+fn check_repeat_fn(cx: &LateContext<'_>, expr: &Expr<'_>, msrv: Msrv) {
     if !expr.span.from_expansion()
         && fn_def_id(cx, expr).is_some_and(|did| cx.tcx.is_diagnostic_item(sym::iter_repeat, did))
         && let ExprKind::Call(_, [repeat_expr]) = expr.kind
         && fn_def_id(cx, repeat_expr).is_some_and(|did| cx.tcx.is_diagnostic_item(sym::vec_with_capacity, did))
         && !repeat_expr.span.from_expansion()
         && let Some(exec_context) = std_or_core(cx)
+        && msrv.meets(cx, msrvs::REPEAT_WITH)
     {
         emit_lint(
             cx,
@@ -112,6 +125,6 @@ fn check_repeat_fn(cx: &LateContext<'_>, expr: &Expr<'_>) {
 impl LateLintPass<'_> for RepeatVecWithCapacity {
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         check_vec_macro(cx, expr);
-        check_repeat_fn(cx, expr);
+        check_repeat_fn(cx, expr, self.msrv);
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/returns.rs b/src/tools/clippy/clippy_lints/src/returns.rs
index 152739c2973b..3ba6d6284592 100644
--- a/src/tools/clippy/clippy_lints/src/returns.rs
+++ b/src/tools/clippy/clippy_lints/src/returns.rs
@@ -1,7 +1,7 @@
 use clippy_utils::diagnostics::{span_lint_and_sugg, span_lint_hir_and_then};
 use clippy_utils::source::{SpanRangeExt, snippet_with_context};
 use clippy_utils::sugg::has_enclosing_paren;
-use clippy_utils::visitors::{Descend, for_each_expr};
+use clippy_utils::visitors::for_each_expr;
 use clippy_utils::{
     binary_expr_needs_parentheses, fn_def_id, is_from_proc_macro, is_inside_let_else, is_res_lang_ctor,
     leaks_droppable_temporary_with_limited_lifetime, path_res, path_to_local_id, span_contains_cfg,
@@ -21,6 +21,7 @@ use rustc_middle::ty::adjustment::Adjust;
 use rustc_middle::ty::{self, GenericArgKind, Ty};
 use rustc_session::declare_lint_pass;
 use rustc_span::def_id::LocalDefId;
+use rustc_span::edition::Edition;
 use rustc_span::{BytePos, Pos, Span, sym};
 use std::borrow::Cow;
 use std::fmt::Display;
@@ -234,7 +235,7 @@ impl<'tcx> LateLintPass<'tcx> for Return {
             && let Some(initexpr) = &local.init
             && let PatKind::Binding(_, local_id, _, _) = local.pat.kind
             && path_to_local_id(retexpr, local_id)
-            && !last_statement_borrows(cx, initexpr)
+            && (cx.sess().edition() >= Edition::Edition2024 || !last_statement_borrows(cx, initexpr))
             && !initexpr.span.in_external_macro(cx.sess().source_map())
             && !retexpr.span.in_external_macro(cx.sess().source_map())
             && !local.span.from_expansion()
@@ -482,7 +483,7 @@ fn last_statement_borrows<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>)
         {
             ControlFlow::Break(())
         } else {
-            ControlFlow::Continue(Descend::from(!e.span.from_expansion()))
+            ControlFlow::Continue(())
         }
     })
     .is_some()
diff --git a/src/tools/clippy/clippy_lints/src/single_option_map.rs b/src/tools/clippy/clippy_lints/src/single_option_map.rs
new file mode 100644
index 000000000000..1fb54950612a
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/single_option_map.rs
@@ -0,0 +1,91 @@
+use clippy_utils::diagnostics::span_lint_and_help;
+use clippy_utils::ty::is_type_diagnostic_item;
+use clippy_utils::{path_res, peel_blocks};
+use rustc_hir::def::Res;
+use rustc_hir::def_id::LocalDefId;
+use rustc_hir::intravisit::FnKind;
+use rustc_hir::{Body, ExprKind, FnDecl, FnRetTy};
+use rustc_lint::{LateContext, LateLintPass};
+use rustc_session::declare_lint_pass;
+use rustc_span::{Span, sym};
+
+declare_clippy_lint! {
+    /// ### What it does
+    /// Checks for functions with method calls to `.map(_)` on an arg
+    /// of type `Option` as the outermost expression.
+    ///
+    /// ### Why is this bad?
+    /// Taking and returning an `Option<T>` may require additional
+    /// `Some(_)` and `unwrap` if all you have is a `T`.
+    ///
+    /// ### Example
+    /// ```no_run
+    /// fn double(param: Option<u32>) -> Option<u32> {
+    ///     param.map(|x| x * 2)
+    /// }
+    /// ```
+    /// Use instead:
+    /// ```no_run
+    /// fn double(param: u32) -> u32 {
+    ///     param * 2
+    /// }
+    /// ```
+    #[clippy::version = "1.86.0"]
+    pub SINGLE_OPTION_MAP,
+    nursery,
+    "Checks for functions with method calls to `.map(_)` on an arg of type `Option` as the outermost expression."
+}
+
+declare_lint_pass!(SingleOptionMap => [SINGLE_OPTION_MAP]);
+
+impl<'tcx> LateLintPass<'tcx> for SingleOptionMap {
+    fn check_fn(
+        &mut self,
+        cx: &LateContext<'tcx>,
+        kind: FnKind<'tcx>,
+        decl: &'tcx FnDecl<'tcx>,
+        body: &'tcx Body<'tcx>,
+        span: Span,
+        _fn_def: LocalDefId,
+    ) {
+        if let FnRetTy::Return(_ret) = decl.output
+            && matches!(kind, FnKind::ItemFn(_, _, _) | FnKind::Method(_, _))
+        {
+            let func_body = peel_blocks(body.value);
+            if let ExprKind::MethodCall(method_name, callee, args, _span) = func_body.kind
+                && method_name.ident.name == sym::map
+                && let callee_type = cx.typeck_results().expr_ty(callee)
+                && is_type_diagnostic_item(cx, callee_type, sym::Option)
+                && let ExprKind::Path(_path) = callee.kind
+                && let Res::Local(_id) = path_res(cx, callee)
+                && matches!(path_res(cx, callee), Res::Local(_id))
+                && !matches!(args[0].kind, ExprKind::Path(_))
+            {
+                if let ExprKind::Closure(closure) = args[0].kind {
+                    let Body { params: [..], value } = cx.tcx.hir_body(closure.body);
+                    if let ExprKind::Call(func, f_args) = value.kind
+                        && matches!(func.kind, ExprKind::Path(_))
+                        && f_args.iter().all(|arg| matches!(arg.kind, ExprKind::Path(_)))
+                    {
+                        return;
+                    } else if let ExprKind::MethodCall(_segment, receiver, method_args, _span) = value.kind
+                        && matches!(receiver.kind, ExprKind::Path(_))
+                        && method_args.iter().all(|arg| matches!(arg.kind, ExprKind::Path(_)))
+                        && method_args.iter().all(|arg| matches!(path_res(cx, arg), Res::Local(_)))
+                    {
+                        return;
+                    }
+                }
+
+                span_lint_and_help(
+                    cx,
+                    SINGLE_OPTION_MAP,
+                    span,
+                    "`fn` that only maps over argument",
+                    None,
+                    "move the `.map` to the caller or to an `_opt` function",
+                );
+            }
+        }
+    }
+}
diff --git a/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs b/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs
index b22c638fc363..dc19236011bd 100644
--- a/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs
+++ b/src/tools/clippy/clippy_lints/src/size_of_in_element_count.rs
@@ -99,7 +99,7 @@ fn get_pointee_ty_and_count_expr<'tcx>(
     if let ExprKind::MethodCall(method_path, ptr_self, [.., count], _) = expr.kind
         // Find calls to copy_{from,to}{,_nonoverlapping}
         && let method_ident = method_path.ident.as_str()
-        && METHODS.iter().any(|m| *m == method_ident)
+        && METHODS.contains(&method_ident)
 
         // Get the pointee type
         && let ty::RawPtr(pointee_ty, _) =
diff --git a/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs b/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
index 59c13a1e2c53..d68ac8bab128 100644
--- a/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
+++ b/src/tools/clippy/clippy_lints/src/std_instead_of_core.rs
@@ -99,7 +99,7 @@ impl StdReexports {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             prev_span: Span::default(),
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
         }
     }
 }
@@ -110,7 +110,7 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
     fn check_path(&mut self, cx: &LateContext<'tcx>, path: &Path<'tcx>, _: HirId) {
         if let Res::Def(_, def_id) = path.res
             && let Some(first_segment) = get_first_segment(path)
-            && is_stable(cx, def_id, &self.msrv)
+            && is_stable(cx, def_id, self.msrv)
             && !path.span.in_external_macro(cx.sess().source_map())
             && !is_from_proc_macro(cx, &first_segment.ident)
         {
@@ -153,8 +153,6 @@ impl<'tcx> LateLintPass<'tcx> for StdReexports {
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 /// Returns the first named segment of a [`Path`].
@@ -174,7 +172,7 @@ fn get_first_segment<'tcx>(path: &Path<'tcx>) -> Option<&'tcx PathSegment<'tcx>>
 /// or now stable moves that were once unstable.
 ///
 /// Does not catch individually moved items
-fn is_stable(cx: &LateContext<'_>, mut def_id: DefId, msrv: &Msrv) -> bool {
+fn is_stable(cx: &LateContext<'_>, mut def_id: DefId, msrv: Msrv) -> bool {
     loop {
         if let Some(stability) = cx.tcx.lookup_stability(def_id)
             && let StabilityLevel::Stable {
@@ -183,8 +181,8 @@ fn is_stable(cx: &LateContext<'_>, mut def_id: DefId, msrv: &Msrv) -> bool {
             } = stability.level
         {
             let stable = match since {
-                StableSince::Version(v) => msrv.meets(v),
-                StableSince::Current => msrv.current().is_none(),
+                StableSince::Version(v) => msrv.meets(cx, v),
+                StableSince::Current => msrv.current(cx).is_none(),
                 StableSince::Err => false,
             };
 
diff --git a/src/tools/clippy/clippy_lints/src/string_patterns.rs b/src/tools/clippy/clippy_lints/src/string_patterns.rs
index 694ad4f6347b..5c95dfe83473 100644
--- a/src/tools/clippy/clippy_lints/src/string_patterns.rs
+++ b/src/tools/clippy/clippy_lints/src/string_patterns.rs
@@ -77,9 +77,7 @@ pub struct StringPatterns {
 
 impl StringPatterns {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -136,7 +134,7 @@ fn get_char_span<'tcx>(cx: &'_ LateContext<'tcx>, expr: &'tcx Expr<'_>) -> Optio
     }
 }
 
-fn check_manual_pattern_char_comparison(cx: &LateContext<'_>, method_arg: &Expr<'_>, msrv: &Msrv) {
+fn check_manual_pattern_char_comparison(cx: &LateContext<'_>, method_arg: &Expr<'_>, msrv: Msrv) {
     if let ExprKind::Closure(closure) = method_arg.kind
         && let body = cx.tcx.hir_body(closure.body)
         && let Some(PatKind::Binding(_, binding, ..)) = body.params.first().map(|p| p.pat.kind)
@@ -192,7 +190,7 @@ fn check_manual_pattern_char_comparison(cx: &LateContext<'_>, method_arg: &Expr<
         {
             return;
         }
-        if set_char_spans.len() > 1 && !msrv.meets(msrvs::PATTERN_TRAIT_CHAR_ARRAY) {
+        if set_char_spans.len() > 1 && !msrv.meets(cx, msrvs::PATTERN_TRAIT_CHAR_ARRAY) {
             return;
         }
         span_lint_and_then(
@@ -238,9 +236,7 @@ impl<'tcx> LateLintPass<'tcx> for StringPatterns {
         {
             check_single_char_pattern_lint(cx, arg);
 
-            check_manual_pattern_char_comparison(cx, arg, &self.msrv);
+            check_manual_pattern_char_comparison(cx, arg, self.msrv);
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/trait_bounds.rs b/src/tools/clippy/clippy_lints/src/trait_bounds.rs
index cbf7b126632e..f961e1c4d1a3 100644
--- a/src/tools/clippy/clippy_lints/src/trait_bounds.rs
+++ b/src/tools/clippy/clippy_lints/src/trait_bounds.rs
@@ -95,7 +95,7 @@ impl TraitBounds {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             max_trait_bounds: conf.max_trait_bounds,
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
         }
     }
 }
@@ -223,17 +223,15 @@ impl<'tcx> LateLintPass<'tcx> for TraitBounds {
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 impl TraitBounds {
     /// Is the given bound a `?Sized` bound, and is combining it (i.e. `T: X + ?Sized`) an error on
     /// this MSRV? See <https://github.com/rust-lang/rust-clippy/issues/8772> for details.
     fn cannot_combine_maybe_bound(&self, cx: &LateContext<'_>, bound: &GenericBound<'_>) -> bool {
-        if !self.msrv.meets(msrvs::MAYBE_BOUND_IN_WHERE)
-            && let GenericBound::Trait(tr) = bound
+        if let GenericBound::Trait(tr) = bound
             && let BoundPolarity::Maybe(_) = tr.modifiers.polarity
+            && !self.msrv.meets(cx, msrvs::MAYBE_BOUND_IN_WHERE)
         {
             cx.tcx.lang_items().get(LangItem::Sized) == tr.trait_ref.path.res.opt_def_id()
         } else {
diff --git a/src/tools/clippy/clippy_lints/src/transmute/mod.rs b/src/tools/clippy/clippy_lints/src/transmute/mod.rs
index 1cb0f837227d..f2da8d35cb4f 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/mod.rs
@@ -49,7 +49,6 @@ declare_clippy_lint! {
     "transmutes that are confusing at best, undefined behavior at worst and always useless"
 }
 
-// FIXME: Move this to `complexity` again, after #5343 is fixed
 declare_clippy_lint! {
     /// ### What it does
     /// Checks for transmutes to the original type of the object
@@ -599,9 +598,7 @@ impl_lint_pass!(Transmute => [
 ]);
 impl Transmute {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 impl<'tcx> LateLintPass<'tcx> for Transmute {
@@ -633,16 +630,16 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
                 | crosspointer_transmute::check(cx, e, from_ty, to_ty)
                 | transmuting_null::check(cx, e, arg, to_ty)
                 | transmute_null_to_fn::check(cx, e, arg, to_ty)
-                | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, &self.msrv)
+                | transmute_ptr_to_ref::check(cx, e, from_ty, to_ty, arg, path, self.msrv)
                 | missing_transmute_annotations::check(cx, path, from_ty, to_ty, e.hir_id)
                 | transmute_int_to_char::check(cx, e, from_ty, to_ty, arg, const_context)
                 | transmute_ref_to_ref::check(cx, e, from_ty, to_ty, arg, const_context)
-                | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg, &self.msrv)
+                | transmute_ptr_to_ptr::check(cx, e, from_ty, to_ty, arg, self.msrv)
                 | transmute_int_to_bool::check(cx, e, from_ty, to_ty, arg)
-                | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context, &self.msrv)
+                | transmute_int_to_float::check(cx, e, from_ty, to_ty, arg, const_context, self.msrv)
                 | transmute_int_to_non_zero::check(cx, e, from_ty, to_ty, arg)
-                | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context, &self.msrv)
-                | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context, &self.msrv)
+                | transmute_float_to_int::check(cx, e, from_ty, to_ty, arg, const_context, self.msrv)
+                | transmute_num_to_bytes::check(cx, e, from_ty, to_ty, arg, const_context, self.msrv)
                 | (unsound_collection_transmute::check(cx, e, from_ty, to_ty)
                     || transmute_undefined_repr::check(cx, e, from_ty, to_ty))
                 | (eager_transmute::check(cx, e, arg, from_ty, to_ty));
@@ -652,6 +649,4 @@ impl<'tcx> LateLintPass<'tcx> for Transmute {
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs
index f0b8abf9af66..f2c757952af3 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_float_to_int.rs
@@ -17,11 +17,11 @@ pub(super) fn check<'tcx>(
     to_ty: Ty<'tcx>,
     mut arg: &'tcx Expr<'_>,
     const_context: bool,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::Float(float_ty), ty::Int(_) | ty::Uint(_))
-            if !const_context || msrv.meets(msrvs::CONST_FLOAT_BITS_CONV) =>
+            if !const_context || msrv.meets(cx, msrvs::CONST_FLOAT_BITS_CONV) =>
         {
             span_lint_and_then(
                 cx,
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs
index e5b9aea6423a..aaa95396b4b4 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_int_to_float.rs
@@ -16,10 +16,10 @@ pub(super) fn check<'tcx>(
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
     const_context: bool,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
-        (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context || msrv.meets(msrvs::CONST_FLOAT_BITS_CONV) => {
+        (ty::Int(_) | ty::Uint(_), ty::Float(_)) if !const_context || msrv.meets(cx, msrvs::CONST_FLOAT_BITS_CONV) => {
             span_lint_and_then(
                 cx,
                 TRANSMUTE_INT_TO_FLOAT,
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs
index 6d828bad9b32..d72be270b731 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_num_to_bytes.rs
@@ -16,14 +16,15 @@ pub(super) fn check<'tcx>(
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
     const_context: bool,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::Int(_) | ty::Uint(_) | ty::Float(_), ty::Array(arr_ty, _)) => {
             if !matches!(arr_ty.kind(), ty::Uint(UintTy::U8)) {
                 return false;
             }
-            if matches!(from_ty.kind(), ty::Float(_)) && const_context && !msrv.meets(msrvs::CONST_FLOAT_BITS_CONV) {
+            if matches!(from_ty.kind(), ty::Float(_)) && const_context && !msrv.meets(cx, msrvs::CONST_FLOAT_BITS_CONV)
+            {
                 return false;
             }
 
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
index c4a2e20fa9d3..fcc763763bd2 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ptr.rs
@@ -15,7 +15,7 @@ pub(super) fn check<'tcx>(
     from_ty: Ty<'tcx>,
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     match (from_ty.kind(), to_ty.kind()) {
         (ty::RawPtr(from_pointee_ty, from_mutbl), ty::RawPtr(to_pointee_ty, to_mutbl)) => {
@@ -28,7 +28,7 @@ pub(super) fn check<'tcx>(
                     if let Some(arg) = sugg::Sugg::hir_opt(cx, arg) {
                         if from_mutbl == to_mutbl
                             && to_pointee_ty.is_sized(cx.tcx, cx.typing_env())
-                            && msrv.meets(msrvs::POINTER_CAST)
+                            && msrv.meets(cx, msrvs::POINTER_CAST)
                         {
                             diag.span_suggestion_verbose(
                                 e.span,
@@ -43,7 +43,7 @@ pub(super) fn check<'tcx>(
                                 _ => None,
                             }
                             && !from_pointee_ty.has_erased_regions()
-                            && msrv.meets(msrvs::POINTER_CAST_CONSTNESS)
+                            && msrv.meets(cx, msrvs::POINTER_CAST_CONSTNESS)
                         {
                             diag.span_suggestion_verbose(
                                 e.span,
diff --git a/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs b/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
index ef18633d945f..45ee83c78ab6 100644
--- a/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
+++ b/src/tools/clippy/clippy_lints/src/transmute/transmute_ptr_to_ref.rs
@@ -17,7 +17,7 @@ pub(super) fn check<'tcx>(
     to_ty: Ty<'tcx>,
     arg: &'tcx Expr<'_>,
     path: &'tcx Path<'_>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> bool {
     match (&from_ty.kind(), &to_ty.kind()) {
         (ty::RawPtr(from_ptr_ty, _), ty::Ref(_, to_ref_ty, mutbl)) => {
@@ -37,7 +37,7 @@ pub(super) fn check<'tcx>(
 
                     let sugg = if let Some(ty) = get_explicit_type(path) {
                         let ty_snip = snippet_with_applicability(cx, ty.span, "..", &mut app);
-                        if msrv.meets(msrvs::POINTER_CAST) {
+                        if msrv.meets(cx, msrvs::POINTER_CAST) {
                             format!("{deref}{}.cast::<{ty_snip}>()", arg.maybe_par())
                         } else if from_ptr_ty.has_erased_regions() {
                             sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {ty_snip}"))).to_string()
@@ -46,7 +46,7 @@ pub(super) fn check<'tcx>(
                         }
                     } else if *from_ptr_ty == *to_ref_ty {
                         if from_ptr_ty.has_erased_regions() {
-                            if msrv.meets(msrvs::POINTER_CAST) {
+                            if msrv.meets(cx, msrvs::POINTER_CAST) {
                                 format!("{deref}{}.cast::<{to_ref_ty}>()", arg.maybe_par())
                             } else {
                                 sugg::make_unop(deref, arg.as_ty(format!("{cast} () as {cast} {to_ref_ty}")))
diff --git a/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs b/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs
index c7aefc65f707..95ce19975c7e 100644
--- a/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs
+++ b/src/tools/clippy/clippy_lints/src/tuple_array_conversions.rs
@@ -47,15 +47,13 @@ pub struct TupleArrayConversions {
 }
 impl TupleArrayConversions {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
 impl LateLintPass<'_> for TupleArrayConversions {
     fn check_expr<'tcx>(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
-        if expr.span.in_external_macro(cx.sess().source_map()) || !self.msrv.meets(msrvs::TUPLE_ARRAY_CONVERSIONS) {
+        if expr.span.in_external_macro(cx.sess().source_map()) || !self.msrv.meets(cx, msrvs::TUPLE_ARRAY_CONVERSIONS) {
             return;
         }
 
@@ -65,8 +63,6 @@ impl LateLintPass<'_> for TupleArrayConversions {
             _ => {},
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 fn check_array<'tcx>(cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>, elements: &'tcx [Expr<'tcx>]) {
diff --git a/src/tools/clippy/clippy_lints/src/types/mod.rs b/src/tools/clippy/clippy_lints/src/types/mod.rs
index 71e6e75c1bd3..151a6f67437c 100644
--- a/src/tools/clippy/clippy_lints/src/types/mod.rs
+++ b/src/tools/clippy/clippy_lints/src/types/mod.rs
@@ -2,6 +2,7 @@ mod borrowed_box;
 mod box_collection;
 mod linked_list;
 mod option_option;
+mod owned_cow;
 mod rc_buffer;
 mod rc_mutex;
 mod redundant_allocation;
@@ -355,13 +356,63 @@ declare_clippy_lint! {
     "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]>;
+    /// ```
+    #[clippy::version = "1.85.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,
 }
 
-impl_lint_pass!(Types => [BOX_COLLECTION, VEC_BOX, OPTION_OPTION, LINKEDLIST, BORROWED_BOX, REDUNDANT_ALLOCATION, RC_BUFFER, RC_MUTEX, TYPE_COMPLEXITY]);
+impl_lint_pass!(Types => [
+    BOX_COLLECTION,
+    VEC_BOX,
+    OPTION_OPTION,
+    LINKEDLIST,
+    BORROWED_BOX,
+    REDUNDANT_ALLOCATION,
+    RC_BUFFER,
+    RC_MUTEX,
+    TYPE_COMPLEXITY,
+    OWNED_COW
+]);
 
 impl<'tcx> LateLintPass<'tcx> for Types {
     fn check_fn(
@@ -373,11 +424,10 @@ impl<'tcx> LateLintPass<'tcx> for Types {
         _: Span,
         def_id: LocalDefId,
     ) {
-        let is_in_trait_impl = if let hir::Node::Item(item) = cx.tcx.hir_node_by_def_id(
-            cx.tcx
-                .hir_get_parent_item(cx.tcx.local_def_id_to_hir_id(def_id))
-                .def_id,
-        ) {
+        let is_in_trait_impl = if let hir::Node::Item(item) = cx
+            .tcx
+            .hir_node_by_def_id(cx.tcx.hir_get_parent_item(cx.tcx.local_def_id_to_hir_id(def_id)).def_id)
+        {
             matches!(item.kind, ItemKind::Impl(hir::Impl { of_trait: Some(_), .. }))
         } else {
             false
@@ -560,6 +610,7 @@ impl Types {
                         triggered |= option_option::check(cx, hir_ty, qpath, def_id);
                         triggered |= linked_list::check(cx, hir_ty, def_id);
                         triggered |= rc_mutex::check(cx, hir_ty, qpath, def_id);
+                        triggered |= owned_cow::check(cx, qpath, def_id);
 
                         if triggered {
                             return;
@@ -611,6 +662,14 @@ impl Types {
                     QPath::LangItem(..) => {},
                 }
             },
+            TyKind::Path(ref qpath) => {
+                let res = cx.qpath_res(qpath, hir_ty.hir_id);
+                if let Some(def_id) = res.opt_def_id()
+                    && self.is_type_change_allowed(context)
+                {
+                    owned_cow::check(cx, qpath, def_id);
+                }
+            },
             TyKind::Ref(lt, ref mut_ty) => {
                 context.is_nested_call = true;
                 if !borrowed_box::check(cx, hir_ty, lt, mut_ty) {
diff --git a/src/tools/clippy/clippy_lints/src/types/owned_cow.rs b/src/tools/clippy/clippy_lints/src/types/owned_cow.rs
new file mode 100644
index 000000000000..8933994d1855
--- /dev/null
+++ b/src/tools/clippy/clippy_lints/src/types/owned_cow.rs
@@ -0,0 +1,66 @@
+use clippy_utils::diagnostics::span_lint_and_sugg;
+use clippy_utils::source::snippet_opt;
+use rustc_errors::Applicability;
+use rustc_hir::def_id::DefId;
+use rustc_hir::{self as hir};
+use rustc_lint::LateContext;
+use rustc_span::{Span, sym};
+
+pub(super) fn check(cx: &LateContext<'_>, qpath: &hir::QPath<'_>, def_id: DefId) -> bool {
+    if cx.tcx.is_diagnostic_item(sym::Cow, def_id)
+        && let hir::QPath::Resolved(_, path) = qpath
+        && let [.., last_seg] = path.segments
+        && let Some(args) = last_seg.args
+        && let [_lt, carg] = args.args
+        && let hir::GenericArg::Type(cty) = carg
+        && let Some((span, repl)) = replacement(cx, cty.as_unambig_ty())
+    {
+        span_lint_and_sugg(
+            cx,
+            super::OWNED_COW,
+            span,
+            "needlessly owned Cow type",
+            "use",
+            repl,
+            Applicability::Unspecified,
+        );
+        return true;
+    }
+    false
+}
+
+fn replacement(cx: &LateContext<'_>, cty: &hir::Ty<'_>) -> Option<(Span, String)> {
+    if clippy_utils::is_path_lang_item(cx, cty, hir::LangItem::String) {
+        return Some((cty.span, "str".into()));
+    }
+    if clippy_utils::is_path_diagnostic_item(cx, cty, sym::Vec) {
+        return if let hir::TyKind::Path(hir::QPath::Resolved(_, path)) = cty.kind
+            && let [.., last_seg] = path.segments
+            && let Some(args) = last_seg.args
+            && let [t, ..] = args.args
+            && let Some(snip) = snippet_opt(cx, t.span())
+        {
+            Some((cty.span, format!("[{snip}]")))
+        } else {
+            None
+        };
+    }
+    if clippy_utils::is_path_diagnostic_item(cx, cty, sym::cstring_type) {
+        return Some((
+            cty.span,
+            (if clippy_utils::is_no_std_crate(cx) {
+                "core::ffi::CStr"
+            } else {
+                "std::ffi::CStr"
+            })
+            .into(),
+        ));
+    }
+    // Neither OsString nor PathBuf are available outside std
+    for (diag, repl) in [(sym::OsString, "std::ffi::OsStr"), (sym::PathBuf, "std::path::Path")] {
+        if clippy_utils::is_path_diagnostic_item(cx, cty, diag) {
+            return Some((cty.span, repl.into()));
+        }
+    }
+    None
+}
diff --git a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
index 93abf95e3577..746bf018bcc3 100644
--- a/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
+++ b/src/tools/clippy/clippy_lints/src/undocumented_unsafe_blocks.rs
@@ -1,5 +1,5 @@
-use std::sync::Arc;
 use std::ops::ControlFlow;
+use std::sync::Arc;
 
 use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_then;
@@ -432,7 +432,7 @@ fn include_attrs_in_span(cx: &LateContext<'_>, hir_id: HirId, span: Span) -> Spa
         .hir()
         .attrs(hir_id)
         .iter()
-        .fold(span, |acc, attr| acc.to(attr.span)))
+        .fold(span, |acc, attr| acc.to(attr.span())))
 }
 
 enum HasSafetyComment {
diff --git a/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs b/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs
index 47d6fe7db766..019ae16ca859 100644
--- a/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs
+++ b/src/tools/clippy/clippy_lints/src/unit_types/unit_arg.rs
@@ -177,7 +177,7 @@ fn fmt_stmts_and_call(
     stmts_and_call.push(call_snippet_with_replacements);
     stmts_and_call = stmts_and_call
         .into_iter()
-        .map(|v| reindent_multiline(v.into(), true, Some(call_expr_indent)).into_owned())
+        .map(|v| reindent_multiline(&v, true, Some(call_expr_indent)))
         .collect();
 
     let mut stmts_and_call_snippet = stmts_and_call.join(&format!("{}{}", ";\n", " ".repeat(call_expr_indent)));
@@ -185,8 +185,7 @@ fn fmt_stmts_and_call(
     let parent_node = cx.tcx.parent_hir_node(call_expr.hir_id);
     if !matches!(parent_node, Node::Block(_)) && !matches!(parent_node, Node::Stmt(_)) {
         let block_indent = call_expr_indent + 4;
-        stmts_and_call_snippet =
-            reindent_multiline(stmts_and_call_snippet.into(), true, Some(block_indent)).into_owned();
+        stmts_and_call_snippet = reindent_multiline(&stmts_and_call_snippet, true, Some(block_indent));
         stmts_and_call_snippet = format!(
             "{{\n{}{}\n{}}}",
             " ".repeat(block_indent),
diff --git a/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs b/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs
index 1df229c330eb..5792b6b3178d 100644
--- a/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs
+++ b/src/tools/clippy/clippy_lints/src/unnecessary_struct_initialization.rs
@@ -1,8 +1,8 @@
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::source::snippet;
 use clippy_utils::ty::is_copy;
-use clippy_utils::{get_parent_expr, path_to_local};
-use rustc_hir::{BindingMode, Expr, ExprField, ExprKind, Node, PatKind, Path, QPath, StructTailExpr, UnOp};
+use clippy_utils::{get_parent_expr, is_mutable, path_to_local};
+use rustc_hir::{Expr, ExprField, ExprKind, Path, QPath, StructTailExpr, UnOp};
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_session::declare_lint_pass;
 
@@ -157,16 +157,6 @@ fn same_path_in_all_fields<'tcx>(
     }
 }
 
-fn is_mutable(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
-    if let Some(hir_id) = path_to_local(expr)
-        && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
-    {
-        matches!(pat.kind, PatKind::Binding(BindingMode::MUT, ..))
-    } else {
-        true
-    }
-}
-
 fn check_references(cx: &LateContext<'_>, expr_a: &Expr<'_>, expr_b: &Expr<'_>) -> bool {
     if let Some(parent) = get_parent_expr(cx, expr_a)
         && let parent_ty = cx.typeck_results().expr_ty_adjusted(parent)
diff --git a/src/tools/clippy/clippy_lints/src/unnested_or_patterns.rs b/src/tools/clippy/clippy_lints/src/unnested_or_patterns.rs
index 8923484bb58f..f43715d6752e 100644
--- a/src/tools/clippy/clippy_lints/src/unnested_or_patterns.rs
+++ b/src/tools/clippy/clippy_lints/src/unnested_or_patterns.rs
@@ -3,7 +3,7 @@
 use clippy_config::Conf;
 use clippy_utils::ast_utils::{eq_field_pat, eq_id, eq_maybe_qself, eq_pat, eq_path};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::msrvs::{self, Msrv};
+use clippy_utils::msrvs::{self, MsrvStack};
 use clippy_utils::over;
 use rustc_ast::PatKind::*;
 use rustc_ast::mut_visit::*;
@@ -48,13 +48,13 @@ declare_clippy_lint! {
 }
 
 pub struct UnnestedOrPatterns {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 
 impl UnnestedOrPatterns {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: MsrvStack::new(conf.msrv),
         }
     }
 }
@@ -88,7 +88,7 @@ impl EarlyLintPass for UnnestedOrPatterns {
         }
     }
 
-    extract_msrv_attr!(EarlyContext);
+    extract_msrv_attr!();
 }
 
 fn lint_unnested_or_patterns(cx: &EarlyContext<'_>, pat: &Pat) {
diff --git a/src/tools/clippy/clippy_lints/src/unused_trait_names.rs b/src/tools/clippy/clippy_lints/src/unused_trait_names.rs
index f83415834351..2577f1ceaa2c 100644
--- a/src/tools/clippy/clippy_lints/src/unused_trait_names.rs
+++ b/src/tools/clippy/clippy_lints/src/unused_trait_names.rs
@@ -51,9 +51,7 @@ pub struct UnusedTraitNames {
 
 impl UnusedTraitNames {
     pub fn new(conf: &'static Conf) -> Self {
-        Self {
-            msrv: conf.msrv.clone(),
-        }
+        Self { msrv: conf.msrv }
     }
 }
 
@@ -61,8 +59,7 @@ 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 self.msrv.meets(msrvs::UNDERSCORE_IMPORTS)
-            && !item.span.in_external_macro(cx.sess().source_map())
+        if !item.span.in_external_macro(cx.sess().source_map())
             && let ItemKind::Use(path, UseKind::Single) = item.kind
             // Ignore imports that already use Underscore
             && item.ident.name != kw::Underscore
@@ -74,6 +71,7 @@ impl<'tcx> LateLintPass<'tcx> for UnusedTraitNames {
             && cx.tcx.visibility(item.owner_id.def_id) == Visibility::Restricted(module.to_def_id())
             && let Some(last_segment) = path.segments.last()
             && let Some(snip) = snippet_opt(cx, last_segment.ident.span)
+            && self.msrv.meets(cx, msrvs::UNDERSCORE_IMPORTS)
             && !is_from_proc_macro(cx, &last_segment.ident)
         {
             let complete_span = last_segment.ident.span.to(item.ident.span);
@@ -88,6 +86,4 @@ impl<'tcx> LateLintPass<'tcx> for UnusedTraitNames {
             );
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
diff --git a/src/tools/clippy/clippy_lints/src/use_self.rs b/src/tools/clippy/clippy_lints/src/use_self.rs
index 47ce2243aa09..743f54ca993a 100644
--- a/src/tools/clippy/clippy_lints/src/use_self.rs
+++ b/src/tools/clippy/clippy_lints/src/use_self.rs
@@ -2,7 +2,7 @@ use clippy_config::Conf;
 use clippy_utils::diagnostics::span_lint_and_sugg;
 use clippy_utils::is_from_proc_macro;
 use clippy_utils::msrvs::{self, Msrv};
-use clippy_utils::ty::same_type_and_consts;
+use clippy_utils::ty::{same_type_and_consts, ty_from_hir_ty};
 use rustc_data_structures::fx::FxHashSet;
 use rustc_errors::Applicability;
 use rustc_hir::def::{CtorOf, DefKind, Res};
@@ -12,7 +12,6 @@ use rustc_hir::{
     self as hir, AmbigArg, Expr, ExprKind, FnRetTy, FnSig, GenericArgsParentheses, GenericParam, GenericParamKind,
     HirId, Impl, ImplItemKind, Item, ItemKind, Pat, PatExpr, PatExprKind, PatKind, Path, QPath, Ty, TyKind,
 };
-use rustc_hir_analysis::lower_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::Ty as MiddleTy;
 use rustc_session::impl_lint_pass;
@@ -63,7 +62,7 @@ pub struct UseSelf {
 impl UseSelf {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             stack: Vec::new(),
         }
     }
@@ -73,7 +72,6 @@ impl UseSelf {
 enum StackItem {
     Check {
         impl_id: LocalDefId,
-        in_body: u32,
         types_to_skip: FxHashSet<HirId>,
     },
     NoCheck,
@@ -96,8 +94,8 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 .as_ref()
                 .is_none_or(|params| params.parenthesized == GenericArgsParentheses::No)
             && !item.span.from_expansion()
+            // expensive, should be last check
             && !is_from_proc_macro(cx, item)
-        // expensive, should be last check
         {
             // Self cannot be used inside const generic parameters
             let types_to_skip = generics
@@ -117,7 +115,6 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 .collect();
             StackItem::Check {
                 impl_id: item.owner_id.def_id,
-                in_body: 0,
                 types_to_skip,
             }
         } else {
@@ -131,6 +128,11 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
     }
 
     fn check_impl_item(&mut self, cx: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
+        // Checking items of `impl Self` blocks in which macro expands into.
+        if impl_item.span.from_expansion() {
+            self.stack.push(StackItem::NoCheck);
+            return;
+        }
         // We want to skip types in trait `impl`s that aren't declared as `Self` in the trait
         // declaration. The collection of those types is all this method implementation does.
         if let ImplItemKind::Fn(FnSig { decl, .. }, ..) = impl_item.kind
@@ -186,27 +188,18 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
         }
     }
 
-    fn check_body(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
-        // `lower_ty` cannot be called in `Body`s or it will panic (sometimes). But in bodies
-        // we can use `cx.typeck_results.node_type(..)` to get the `ty::Ty` from a `hir::Ty`.
-        // However the `node_type()` method can *only* be called in bodies.
-        if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
-            *in_body = in_body.saturating_add(1);
-        }
-    }
-
-    fn check_body_post(&mut self, _: &LateContext<'_>, _: &hir::Body<'_>) {
-        if let Some(&mut StackItem::Check { ref mut in_body, .. }) = self.stack.last_mut() {
-            *in_body = in_body.saturating_sub(1);
+    fn check_impl_item_post(&mut self, _: &LateContext<'_>, impl_item: &hir::ImplItem<'_>) {
+        if impl_item.span.from_expansion()
+            && let Some(StackItem::NoCheck) = self.stack.last()
+        {
+            self.stack.pop();
         }
     }
 
     fn check_ty(&mut self, cx: &LateContext<'tcx>, hir_ty: &Ty<'tcx, AmbigArg>) {
         if !hir_ty.span.from_expansion()
-            && self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS)
             && let Some(&StackItem::Check {
                 impl_id,
-                in_body,
                 ref types_to_skip,
             }) = self.stack.last()
             && let TyKind::Path(QPath::Resolved(_, path)) = hir_ty.kind
@@ -215,18 +208,14 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
                 Res::SelfTyParam { .. } | Res::SelfTyAlias { .. } | Res::Def(DefKind::TyParam, _)
             )
             && !types_to_skip.contains(&hir_ty.hir_id)
-            && let ty = if in_body > 0 {
-                cx.typeck_results().node_type(hir_ty.hir_id)
-            } else {
-                // We don't care about ignoring infer vars here
-                lower_ty(cx.tcx, hir_ty.as_unambig_ty())
-            }
+            && let ty = ty_from_hir_ty(cx, hir_ty.as_unambig_ty())
             && let impl_ty = cx.tcx.type_of(impl_id).instantiate_identity()
             && same_type_and_consts(ty, impl_ty)
             // Ensure the type we encounter and the one from the impl have the same lifetime parameters. It may be that
             // the lifetime parameters of `ty` are elided (`impl<'a> Foo<'a> { fn new() -> Self { Foo{..} } }`, in
             // which case we must still trigger the lint.
             && (has_no_lifetime(ty) || same_lifetimes(ty, impl_ty))
+            && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
             span_lint(cx, hir_ty.span);
         }
@@ -234,9 +223,9 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
 
     fn check_expr(&mut self, cx: &LateContext<'_>, expr: &Expr<'_>) {
         if !expr.span.from_expansion()
-            && self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS)
             && let Some(&StackItem::Check { impl_id, .. }) = self.stack.last()
             && cx.typeck_results().expr_ty(expr) == cx.tcx.type_of(impl_id).instantiate_identity()
+            && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
         } else {
             return;
@@ -255,19 +244,17 @@ impl<'tcx> LateLintPass<'tcx> for UseSelf {
 
     fn check_pat(&mut self, cx: &LateContext<'_>, pat: &Pat<'_>) {
         if !pat.span.from_expansion()
-            && self.msrv.meets(msrvs::TYPE_ALIAS_ENUM_VARIANTS)
             && let Some(&StackItem::Check { impl_id, .. }) = self.stack.last()
             // get the path from the pattern
             && let PatKind::Expr(&PatExpr { kind: PatExprKind::Path(QPath::Resolved(_, path)), .. })
                  | PatKind::TupleStruct(QPath::Resolved(_, path), _, _)
                  | PatKind::Struct(QPath::Resolved(_, path), _, _) = pat.kind
             && cx.typeck_results().pat_ty(pat) == cx.tcx.type_of(impl_id).instantiate_identity()
+            && self.msrv.meets(cx, msrvs::TYPE_ALIAS_ENUM_VARIANTS)
         {
             check_path(cx, path);
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 #[derive(Default)]
diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
index d6f10f1e4b80..89b4c48b8b11 100644
--- a/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/lint_without_lint_pass.rs
@@ -249,7 +249,7 @@ fn check_invalid_clippy_version_attribute(cx: &LateContext<'_>, item: &'_ Item<'
 pub(super) fn extract_clippy_version_value(cx: &LateContext<'_>, item: &'_ Item<'_>) -> Option<Symbol> {
     let attrs = cx.tcx.hir().attrs(item.hir_id());
     attrs.iter().find_map(|attr| {
-        if let hir::AttrKind::Normal(attr_kind) = &attr.kind
+        if let hir::Attribute::Unparsed(attr_kind) = &attr
             // Identify attribute
             && let [tool_name, attr_name] = &attr_kind.path.segments[..]
             && tool_name.name == sym::clippy
@@ -278,6 +278,6 @@ impl<'tcx> Visitor<'tcx> for LintCollector<'_, 'tcx> {
     }
 
     fn maybe_tcx(&mut self) -> Self::MaybeTyCtxt {
-        self.cx.tcx.hir()
+        self.cx.tcx
     }
 }
diff --git a/src/tools/clippy/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs b/src/tools/clippy/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
index 686922461530..558acacb9724 100644
--- a/src/tools/clippy/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/internal_lints/msrv_attr_impl.rs
@@ -30,8 +30,7 @@ impl LateLintPass<'_> for MsrvAttrImpl {
                 .tcx
                 .impl_trait_ref(item.owner_id)
                 .map(EarlyBinder::instantiate_identity)
-            && let is_late_pass = match_def_path(cx, trait_ref.def_id, &paths::LATE_LINT_PASS)
-            && (is_late_pass || match_def_path(cx, trait_ref.def_id, &paths::EARLY_LINT_PASS))
+            && match_def_path(cx, trait_ref.def_id, &paths::EARLY_LINT_PASS)
             && let ty::Adt(self_ty_def, _) = trait_ref.self_ty().kind()
             && self_ty_def.is_struct()
             && self_ty_def.all_fields().any(|f| {
@@ -40,20 +39,18 @@ impl LateLintPass<'_> for MsrvAttrImpl {
                     .instantiate_identity()
                     .walk()
                     .filter(|t| matches!(t.unpack(), GenericArgKind::Type(_)))
-                    .any(|t| match_type(cx, t.expect_ty(), &paths::MSRV))
+                    .any(|t| match_type(cx, t.expect_ty(), &paths::MSRV_STACK))
             })
             && !items.iter().any(|item| item.ident.name.as_str() == "check_attributes")
         {
-            let context = if is_late_pass { "LateContext" } else { "EarlyContext" };
-            let lint_pass = if is_late_pass { "LateLintPass" } else { "EarlyLintPass" };
             let span = cx.sess().source_map().span_through_char(item.span, '{');
             span_lint_and_sugg(
                 cx,
                 MISSING_MSRV_ATTR_IMPL,
                 span,
-                format!("`extract_msrv_attr!` macro missing from `{lint_pass}` implementation"),
-                format!("add `extract_msrv_attr!({context})` to the `{lint_pass}` implementation"),
-                format!("{}\n    extract_msrv_attr!({context});", snippet(cx, span, "..")),
+                "`extract_msrv_attr!` macro missing from `EarlyLintPass` implementation",
+                "add `extract_msrv_attr!()` to the `EarlyLintPass` implementation",
+                format!("{}\n    extract_msrv_attr!();", snippet(cx, span, "..")),
                 Applicability::MachineApplicable,
             );
         }
diff --git a/src/tools/clippy/clippy_lints/src/vec.rs b/src/tools/clippy/clippy_lints/src/vec.rs
index 03c667846b61..3346b15dae9c 100644
--- a/src/tools/clippy/clippy_lints/src/vec.rs
+++ b/src/tools/clippy/clippy_lints/src/vec.rs
@@ -27,7 +27,7 @@ impl UselessVec {
     pub fn new(conf: &'static Conf) -> Self {
         Self {
             too_large_for_stack: conf.too_large_for_stack,
-            msrv: conf.msrv.clone(),
+            msrv: conf.msrv,
             span_to_lint_map: BTreeMap::new(),
             allow_in_test: conf.allow_useless_vec_in_tests,
         }
@@ -111,7 +111,7 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
             },
             // search for `for _ in vec![...]`
             Node::Expr(Expr { span, .. })
-                if span.is_desugaring(DesugaringKind::ForLoop) && self.msrv.meets(msrvs::ARRAY_INTO_ITERATOR) =>
+                if span.is_desugaring(DesugaringKind::ForLoop) && self.msrv.meets(cx, msrvs::ARRAY_INTO_ITERATOR) =>
             {
                 let suggest_slice = suggest_type(expr);
                 self.check_vec_macro(cx, &vec_args, callsite, expr.hir_id, suggest_slice);
@@ -149,8 +149,6 @@ impl<'tcx> LateLintPass<'tcx> for UselessVec {
             }
         }
     }
-
-    extract_msrv_attr!(LateContext);
 }
 
 impl UselessVec {
diff --git a/src/tools/clippy/clippy_lints/src/zero_sized_map_values.rs b/src/tools/clippy/clippy_lints/src/zero_sized_map_values.rs
index 4c9a7f0e16de..f6948be7f67a 100644
--- a/src/tools/clippy/clippy_lints/src/zero_sized_map_values.rs
+++ b/src/tools/clippy/clippy_lints/src/zero_sized_map_values.rs
@@ -1,10 +1,9 @@
 use clippy_utils::diagnostics::span_lint_and_help;
-use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item};
+use clippy_utils::ty::{is_normalizable, is_type_diagnostic_item, ty_from_hir_ty};
 use rustc_hir::{self as hir, AmbigArg, HirId, ItemKind, Node};
-use rustc_hir_analysis::lower_ty;
 use rustc_lint::{LateContext, LateLintPass};
 use rustc_middle::ty::layout::LayoutOf as _;
-use rustc_middle::ty::{self, Ty, TypeVisitableExt};
+use rustc_middle::ty::{self, TypeVisitableExt};
 use rustc_session::declare_lint_pass;
 use rustc_span::sym;
 
@@ -82,15 +81,3 @@ fn in_trait_impl(cx: &LateContext<'_>, hir_id: HirId) -> bool {
     }
     false
 }
-
-fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
-    cx.maybe_typeck_results()
-        .and_then(|results| {
-            if results.hir_owner == hir_ty.hir_id.owner {
-                results.node_type_opt(hir_ty.hir_id)
-            } else {
-                None
-            }
-        })
-        .unwrap_or_else(|| lower_ty(cx.tcx, hir_ty))
-}
diff --git a/src/tools/clippy/clippy_lints/src/zombie_processes.rs b/src/tools/clippy/clippy_lints/src/zombie_processes.rs
index 9bd00b1e5c8c..7667db469689 100644
--- a/src/tools/clippy/clippy_lints/src/zombie_processes.rs
+++ b/src/tools/clippy/clippy_lints/src/zombie_processes.rs
@@ -1,6 +1,6 @@
 use ControlFlow::{Break, Continue};
 use clippy_utils::diagnostics::span_lint_and_then;
-use clippy_utils::{fn_def_id, get_enclosing_block, match_any_def_paths, match_def_path, path_to_local_id, paths};
+use clippy_utils::{fn_def_id, get_enclosing_block, path_to_local_id};
 use rustc_ast::Mutability;
 use rustc_ast::visit::visit_opt;
 use rustc_errors::Applicability;
@@ -58,7 +58,7 @@ impl<'tcx> LateLintPass<'tcx> for ZombieProcesses {
     fn check_expr(&mut self, cx: &LateContext<'tcx>, expr: &'tcx Expr<'tcx>) {
         if let ExprKind::Call(..) | ExprKind::MethodCall(..) = expr.kind
             && let Some(child_adt) = cx.typeck_results().expr_ty(expr).ty_adt_def()
-            && match_def_path(cx, child_adt.did(), &paths::CHILD)
+            && cx.tcx.is_diagnostic_item(sym::Child, child_adt.did())
         {
             match cx.tcx.parent_hir_node(expr.hir_id) {
                 Node::LetStmt(local)
@@ -178,8 +178,8 @@ impl<'tcx> Visitor<'tcx> for WaitFinder<'_, 'tcx> {
                 Node::Expr(expr) if let ExprKind::AddrOf(_, Mutability::Not, _) = expr.kind => {},
                 Node::Expr(expr)
                     if let Some(fn_did) = fn_def_id(self.cx, expr)
-                        && match_any_def_paths(self.cx, fn_did, &[&paths::CHILD_ID, &paths::CHILD_KILL]).is_some() => {
-                },
+                        && (self.cx.tcx.is_diagnostic_item(sym::child_id, fn_did)
+                            || self.cx.tcx.is_diagnostic_item(sym::child_kill, fn_did)) => {},
 
                 // Conservatively assume that all other kinds of nodes call `.wait()` somehow.
                 _ => return Break(MaybeWait(ex.span)),
@@ -353,7 +353,7 @@ fn check<'tcx>(cx: &LateContext<'tcx>, spawn_expr: &'tcx Expr<'tcx>, cause: Caus
 /// Checks if the given expression exits the process.
 fn is_exit_expression(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
     fn_def_id(cx, expr).is_some_and(|fn_did| {
-        cx.tcx.is_diagnostic_item(sym::process_exit, fn_did) || match_def_path(cx, fn_did, &paths::ABORT)
+        cx.tcx.is_diagnostic_item(sym::process_exit, fn_did) || cx.tcx.is_diagnostic_item(sym::process_abort, fn_did)
     })
 }
 
diff --git a/src/tools/clippy/clippy_utils/Cargo.toml b/src/tools/clippy/clippy_utils/Cargo.toml
index 68b7e1592e2e..ba4bb1d177c5 100644
--- a/src/tools/clippy/clippy_utils/Cargo.toml
+++ b/src/tools/clippy/clippy_utils/Cargo.toml
@@ -1,7 +1,7 @@
 [package]
 name = "clippy_utils"
 # begin autogenerated version
-version = "0.1.86"
+version = "0.1.87"
 # end autogenerated version
 edition = "2024"
 description = "Helpful tools for writing lints, provided as they are used in Clippy"
diff --git a/src/tools/clippy/clippy_utils/README.md b/src/tools/clippy/clippy_utils/README.md
index 41f3b1cbd507..5dd31b52f880 100644
--- a/src/tools/clippy/clippy_utils/README.md
+++ b/src/tools/clippy/clippy_utils/README.md
@@ -8,7 +8,7 @@ This crate is only guaranteed to build with this `nightly` toolchain:
 
 <!-- begin autogenerated nightly -->
 ```
-nightly-2025-02-06
+nightly-2025-02-27
 ```
 <!-- end autogenerated nightly -->
 
diff --git a/src/tools/clippy/clippy_utils/src/hir_utils.rs b/src/tools/clippy/clippy_utils/src/hir_utils.rs
index 0ac675345ae0..4bd86a253351 100644
--- a/src/tools/clippy/clippy_utils/src/hir_utils.rs
+++ b/src/tools/clippy/clippy_utils/src/hir_utils.rs
@@ -970,7 +970,7 @@ impl<'a, 'tcx> SpanlessHash<'a, 'tcx> {
                         },
                         InlineAsmOperand::SymFn { expr } => {
                             self.hash_expr(expr);
-                        }
+                        },
                         InlineAsmOperand::Const { anon_const } => {
                             self.hash_body(anon_const.body);
                         },
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index 40ddd75b7fad..d850cc410008 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -31,7 +31,6 @@
 // (Currently there is no way to opt into sysroot crates without `extern crate`.)
 extern crate rustc_abi;
 extern crate rustc_ast;
-extern crate rustc_ast_pretty;
 extern crate rustc_attr_parsing;
 extern crate rustc_const_eval;
 extern crate rustc_data_structures;
@@ -40,6 +39,7 @@ extern crate rustc_data_structures;
 extern crate rustc_driver;
 extern crate rustc_errors;
 extern crate rustc_hir;
+extern crate rustc_hir_analysis;
 extern crate rustc_hir_typeck;
 extern crate rustc_index;
 extern crate rustc_infer;
@@ -92,7 +92,9 @@ use std::iter::{once, repeat_n};
 use std::sync::{Mutex, MutexGuard, OnceLock};
 
 use itertools::Itertools;
+use rustc_abi::Integer;
 use rustc_ast::ast::{self, LitKind, RangeLimits};
+use rustc_attr_parsing::{AttributeKind, find_attr};
 use rustc_data_structures::fx::FxHashMap;
 use rustc_data_structures::packed::Pu128;
 use rustc_data_structures::unhash::UnhashMap;
@@ -106,24 +108,24 @@ use rustc_hir::{
     self as hir, Arm, BindingMode, Block, BlockCheckMode, Body, ByRef, Closure, ConstArgKind, ConstContext,
     Destination, Expr, ExprField, ExprKind, FnDecl, FnRetTy, GenericArgs, HirId, Impl, ImplItem, ImplItemKind,
     ImplItemRef, Item, ItemKind, LangItem, LetStmt, MatchSource, Mutability, Node, OwnerId, OwnerNode, Param, Pat,
-    PatExpr, PatExprKind, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitItem, TraitItemKind,
+    PatExpr, PatExprKind, PatKind, Path, PathSegment, PrimTy, QPath, Stmt, StmtKind, TraitFn, TraitItem, TraitItemKind,
     TraitItemRef, TraitRef, TyKind, UnOp, def,
 };
 use rustc_lexer::{TokenKind, tokenize};
 use rustc_lint::{LateContext, Level, Lint, LintContext};
 use rustc_middle::hir::place::PlaceBase;
+use rustc_middle::mir::{AggregateKind, Operand, RETURN_PLACE, Rvalue, StatementKind, TerminatorKind};
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow};
 use rustc_middle::ty::fast_reject::SimplifiedType;
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{
     self as rustc_ty, Binder, BorrowKind, ClosureKind, EarlyBinder, FloatTy, GenericArgKind, GenericArgsRef, IntTy, Ty,
-    TyCtxt, TypeVisitableExt, UintTy, UpvarCapture,
+    TyCtxt, TypeFlags, TypeVisitableExt, UintTy, UpvarCapture,
 };
 use rustc_span::hygiene::{ExpnKind, MacroKind};
 use rustc_span::source_map::SourceMap;
 use rustc_span::symbol::{Ident, Symbol, kw};
 use rustc_span::{InnerSpan, Span, sym};
-use rustc_abi::Integer;
 use visitors::{Visitable, for_each_unconsumed_temporary};
 
 use crate::consts::{ConstEvalCtxt, Constant, mir_to_const};
@@ -134,24 +136,13 @@ use rustc_middle::hir::nested_filter;
 
 #[macro_export]
 macro_rules! extract_msrv_attr {
-    (LateContext) => {
-        fn check_attributes(&mut self, cx: &rustc_lint::LateContext<'_>, attrs: &[rustc_hir::Attribute]) {
+    () => {
+        fn check_attributes(&mut self, cx: &rustc_lint::EarlyContext<'_>, attrs: &[rustc_ast::ast::Attribute]) {
             let sess = rustc_lint::LintContext::sess(cx);
             self.msrv.check_attributes(sess, attrs);
         }
 
-        fn check_attributes_post(&mut self, cx: &rustc_lint::LateContext<'_>, attrs: &[rustc_hir::Attribute]) {
-            let sess = rustc_lint::LintContext::sess(cx);
-            self.msrv.check_attributes_post(sess, attrs);
-        }
-    };
-    (EarlyContext) => {
-        fn check_attributes(&mut self, cx: &rustc_lint::EarlyContext<'_>, attrs: &[rustc_ast::Attribute]) {
-            let sess = rustc_lint::LintContext::sess(cx);
-            self.msrv.check_attributes(sess, attrs);
-        }
-
-        fn check_attributes_post(&mut self, cx: &rustc_lint::EarlyContext<'_>, attrs: &[rustc_ast::Attribute]) {
+        fn check_attributes_post(&mut self, cx: &rustc_lint::EarlyContext<'_>, attrs: &[rustc_ast::ast::Attribute]) {
             let sess = rustc_lint::LintContext::sess(cx);
             self.msrv.check_attributes_post(sess, attrs);
         }
@@ -914,22 +905,101 @@ fn is_default_equivalent_ctor(cx: &LateContext<'_>, def_id: DefId, path: &QPath<
 }
 
 /// Returns true if the expr is equal to `Default::default` when evaluated.
-pub fn is_default_equivalent_call(cx: &LateContext<'_>, repl_func: &Expr<'_>) -> bool {
+pub fn is_default_equivalent_call(
+    cx: &LateContext<'_>,
+    repl_func: &Expr<'_>,
+    whole_call_expr: Option<&Expr<'_>>,
+) -> bool {
     if let ExprKind::Path(ref repl_func_qpath) = repl_func.kind
         && let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id()
         && (is_diag_trait_item(cx, repl_def_id, sym::Default)
             || is_default_equivalent_ctor(cx, repl_def_id, repl_func_qpath))
     {
-        true
-    } else {
-        false
+        return true;
     }
+
+    // Get the type of the whole method call expression, find the exact method definition, look at
+    // its body and check if it is similar to the corresponding `Default::default()` body.
+    let Some(e) = whole_call_expr else { return false };
+    let Some(default_fn_def_id) = cx.tcx.get_diagnostic_item(sym::default_fn) else {
+        return false;
+    };
+    let Some(ty) = cx.tcx.typeck(e.hir_id.owner.def_id).expr_ty_adjusted_opt(e) else {
+        return false;
+    };
+    let args = rustc_ty::GenericArgs::for_item(cx.tcx, default_fn_def_id, |param, _| {
+        if let rustc_ty::GenericParamDefKind::Lifetime = param.kind {
+            cx.tcx.lifetimes.re_erased.into()
+        } else if param.index == 0 && param.name == kw::SelfUpper {
+            ty.into()
+        } else {
+            param.to_error(cx.tcx)
+        }
+    });
+    let instance = rustc_ty::Instance::try_resolve(cx.tcx, cx.typing_env(), default_fn_def_id, args);
+
+    let Ok(Some(instance)) = instance else { return false };
+    if let rustc_ty::InstanceKind::Item(def) = instance.def
+        && !cx.tcx.is_mir_available(def)
+    {
+        return false;
+    }
+    let ExprKind::Path(ref repl_func_qpath) = repl_func.kind else {
+        return false;
+    };
+    let Some(repl_def_id) = cx.qpath_res(repl_func_qpath, repl_func.hir_id).opt_def_id() else {
+        return false;
+    };
+
+    // Get the MIR Body for the `<Ty as Default>::default()` function.
+    // If it is a value or call (either fn or ctor), we compare its `DefId` against the one for the
+    // resolution of the expression we had in the path. This lets us identify, for example, that
+    // the body of `<Vec<T> as Default>::default()` is a `Vec::new()`, and the field was being
+    // initialized to `Vec::new()` as well.
+    let body = cx.tcx.instance_mir(instance.def);
+    for block_data in body.basic_blocks.iter() {
+        if block_data.statements.len() == 1
+            && let StatementKind::Assign(assign) = &block_data.statements[0].kind
+            && assign.0.local == RETURN_PLACE
+            && let Rvalue::Aggregate(kind, _places) = &assign.1
+            && let AggregateKind::Adt(did, variant_index, _, _, _) = &**kind
+            && let def = cx.tcx.adt_def(did)
+            && let variant = &def.variant(*variant_index)
+            && variant.fields.is_empty()
+            && let Some((_, did)) = variant.ctor
+            && did == repl_def_id
+        {
+            return true;
+        } else if block_data.statements.is_empty()
+            && let Some(term) = &block_data.terminator
+        {
+            match &term.kind {
+                TerminatorKind::Call {
+                    func: Operand::Constant(c),
+                    ..
+                } if let rustc_ty::FnDef(did, _args) = c.ty().kind()
+                    && *did == repl_def_id =>
+                {
+                    return true;
+                },
+                TerminatorKind::TailCall {
+                    func: Operand::Constant(c),
+                    ..
+                } if let rustc_ty::FnDef(did, _args) = c.ty().kind()
+                    && *did == repl_def_id =>
+                {
+                    return true;
+                },
+                _ => {},
+            }
+        }
+    }
+    false
 }
 
-/// Returns true if the expr is equal to `Default::default()` of it's type when evaluated.
+/// Returns true if the expr is equal to `Default::default()` of its type when evaluated.
 ///
-/// It doesn't cover all cases, for example indirect function calls (some of std
-/// functions are supported) but it is the best we have.
+/// It doesn't cover all cases, like struct literals, but it is a close approximation.
 pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
     match &e.kind {
         ExprKind::Lit(lit) => match lit.node {
@@ -950,7 +1020,7 @@ pub fn is_default_equivalent(cx: &LateContext<'_>, e: &Expr<'_>) -> bool {
                 false
             }
         },
-        ExprKind::Call(repl_func, []) => is_default_equivalent_call(cx, repl_func),
+        ExprKind::Call(repl_func, []) => is_default_equivalent_call(cx, repl_func, Some(e)),
         ExprKind::Call(from_func, [arg]) => is_default_equivalent_from(cx, from_func, arg),
         ExprKind::Path(qpath) => is_res_lang_ctor(cx, cx.qpath_res(qpath, e.hir_id), OptionNone),
         ExprKind::AddrOf(rustc_hir::BorrowKind::Ref, _, expr) => matches!(expr.kind, ExprKind::Array([])),
@@ -1094,7 +1164,6 @@ pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind {
         pat.each_binding_or_first(&mut |_, id, span, _| match cx
             .typeck_results()
             .extract_binding_mode(cx.sess(), id, span)
-            .unwrap()
             .0
         {
             ByRef::No if !is_copy(cx, cx.typeck_results().node_type(id)) => {
@@ -1420,6 +1489,10 @@ pub fn get_enclosing_block<'tcx>(cx: &LateContext<'tcx>, hir_id: HirId) -> Optio
         | Node::ImplItem(&ImplItem {
             kind: ImplItemKind::Fn(_, eid),
             ..
+        })
+        | Node::TraitItem(&TraitItem {
+            kind: TraitItemKind::Fn(_, TraitFn::Provided(eid)),
+            ..
         }) => match cx.tcx.hir_body(eid).value.kind {
             ExprKind::Block(block, _) => Some(block),
             _ => None,
@@ -1666,6 +1739,17 @@ pub fn is_integer_literal(expr: &Expr<'_>, value: u128) -> bool {
     false
 }
 
+/// Checks whether the given expression is a constant literal of the given value.
+pub fn is_float_literal(expr: &Expr<'_>, value: f64) -> bool {
+    if let ExprKind::Lit(spanned) = expr.kind
+        && let LitKind::Float(v, _) = spanned.node
+    {
+        v.as_str().parse() == Ok(value)
+    } else {
+        false
+    }
+}
+
 /// Returns `true` if the given `Expr` has been coerced before.
 ///
 /// Examples of coercions can be found in the Nomicon at
@@ -1949,7 +2033,7 @@ pub fn has_attr(attrs: &[hir::Attribute], symbol: Symbol) -> bool {
 }
 
 pub fn has_repr_attr(cx: &LateContext<'_>, hir_id: HirId) -> bool {
-    has_attr(cx.tcx.hir().attrs(hir_id), sym::repr)
+    find_attr!(cx.tcx.hir().attrs(hir_id), AttributeKind::Repr(..))
 }
 
 pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool {
@@ -1970,8 +2054,7 @@ pub fn any_parent_has_attr(tcx: TyCtxt<'_>, node: HirId, symbol: Symbol) -> bool
 /// Checks if the given HIR node is inside an `impl` block with the `automatically_derived`
 /// attribute.
 pub fn in_automatically_derived(tcx: TyCtxt<'_>, id: HirId) -> bool {
-    tcx
-        .hir_parent_owner_iter(id)
+    tcx.hir_parent_owner_iter(id)
         .filter(|(_, node)| matches!(node, OwnerNode::Item(item) if matches!(item.kind, ItemKind::Impl(_))))
         .any(|(id, _)| {
             has_attr(
@@ -2617,9 +2700,7 @@ pub fn is_cfg_test(tcx: TyCtxt<'_>, id: HirId) -> bool {
 
 /// Checks if any parent node of `HirId` has `#[cfg(test)]` attribute applied
 pub fn is_in_cfg_test(tcx: TyCtxt<'_>, id: HirId) -> bool {
-    tcx
-        .hir_parent_id_iter(id)
-        .any(|parent_id| is_cfg_test(tcx, parent_id))
+    tcx.hir_parent_id_iter(id).any(|parent_id| is_cfg_test(tcx, parent_id))
 }
 
 /// Checks if the node is in a `#[test]` function or has any parent node marked `#[cfg(test)]`
@@ -3503,3 +3584,114 @@ pub fn leaks_droppable_temporary_with_limited_lifetime<'tcx>(cx: &LateContext<'t
     })
     .is_break()
 }
+
+/// Returns true if the specified `expr` requires coercion,
+/// meaning that it either has a coercion or propagates a coercion from one of its sub expressions.
+///
+/// Similar to [`is_adjusted`], this not only checks if an expression's type was adjusted,
+/// but also going through extra steps to see if it fits the description of [coercion sites].
+///
+/// You should used this when you want to avoid suggesting replacing an expression that is currently
+/// a coercion site or coercion propagating expression with one that is not.
+///
+/// [coercion sites]: https://doc.rust-lang.org/stable/reference/type-coercions.html#coercion-sites
+pub fn expr_requires_coercion<'tcx>(cx: &LateContext<'tcx>, expr: &Expr<'tcx>) -> bool {
+    let expr_ty_is_adjusted = cx
+        .typeck_results()
+        .expr_adjustments(expr)
+        .iter()
+        // ignore `NeverToAny` adjustments, such as `panic!` call.
+        .any(|adj| !matches!(adj.kind, Adjust::NeverToAny));
+    if expr_ty_is_adjusted {
+        return true;
+    }
+
+    // Identify coercion sites and recursively check if those sites
+    // actually have type adjustments.
+    match expr.kind {
+        ExprKind::Call(_, args) | ExprKind::MethodCall(_, _, args, _) if let Some(def_id) = fn_def_id(cx, expr) => {
+            let fn_sig = cx.tcx.fn_sig(def_id).instantiate_identity();
+
+            if !fn_sig.output().skip_binder().has_type_flags(TypeFlags::HAS_TY_PARAM) {
+                return false;
+            }
+
+            let self_arg_count = usize::from(matches!(expr.kind, ExprKind::MethodCall(..)));
+            let mut args_with_ty_param = {
+                fn_sig
+                    .inputs()
+                    .skip_binder()
+                    .iter()
+                    .skip(self_arg_count)
+                    .zip(args)
+                    .filter_map(|(arg_ty, arg)| {
+                        if arg_ty.has_type_flags(TypeFlags::HAS_TY_PARAM) {
+                            Some(arg)
+                        } else {
+                            None
+                        }
+                    })
+            };
+            args_with_ty_param.any(|arg| expr_requires_coercion(cx, arg))
+        },
+        // Struct/union initialization.
+        ExprKind::Struct(qpath, _, _) => {
+            let res = cx.typeck_results().qpath_res(qpath, expr.hir_id);
+            if let Some((_, v_def)) = adt_and_variant_of_res(cx, res) {
+                let rustc_ty::Adt(_, generic_args) = cx.typeck_results().expr_ty_adjusted(expr).kind() else {
+                    // This should never happen, but when it does, not linting is the better option.
+                    return true;
+                };
+                v_def
+                    .fields
+                    .iter()
+                    .any(|field| field.ty(cx.tcx, generic_args).has_type_flags(TypeFlags::HAS_TY_PARAM))
+            } else {
+                false
+            }
+        },
+        // Function results, including the final line of a block or a `return` expression.
+        ExprKind::Block(
+            &Block {
+                expr: Some(ret_expr), ..
+            },
+            _,
+        )
+        | ExprKind::Ret(Some(ret_expr)) => expr_requires_coercion(cx, ret_expr),
+
+        // ===== Coercion-propagation expressions =====
+        ExprKind::Array(elems) | ExprKind::Tup(elems) => elems.iter().any(|elem| expr_requires_coercion(cx, elem)),
+        // Array but with repeating syntax.
+        ExprKind::Repeat(rep_elem, _) => expr_requires_coercion(cx, rep_elem),
+        // Others that may contain coercion sites.
+        ExprKind::If(_, then, maybe_else) => {
+            expr_requires_coercion(cx, then) || maybe_else.is_some_and(|e| expr_requires_coercion(cx, e))
+        },
+        ExprKind::Match(_, arms, _) => arms
+            .iter()
+            .map(|arm| arm.body)
+            .any(|body| expr_requires_coercion(cx, body)),
+        _ => false,
+    }
+}
+
+/// Returns `true` if `expr` designates a mutable static, a mutable local binding, or an expression
+/// that can be owned.
+pub fn is_mutable(cx: &LateContext<'_>, expr: &Expr<'_>) -> bool {
+    if let Some(hir_id) = path_to_local(expr)
+        && let Node::Pat(pat) = cx.tcx.hir_node(hir_id)
+    {
+        matches!(pat.kind, PatKind::Binding(BindingMode::MUT, ..))
+    } else if let ExprKind::Path(p) = &expr.kind
+        && let Some(mutability) = cx
+            .qpath_res(p, expr.hir_id)
+            .opt_def_id()
+            .and_then(|id| cx.tcx.static_mutability(id))
+    {
+        mutability == Mutability::Mut
+    } else if let ExprKind::Field(parent, _) = expr.kind {
+        is_mutable(cx, parent)
+    } else {
+        true
+    }
+}
diff --git a/src/tools/clippy/clippy_utils/src/macros.rs b/src/tools/clippy/clippy_utils/src/macros.rs
index 9ce0fd8318f1..3ce2cdfebe96 100644
--- a/src/tools/clippy/clippy_utils/src/macros.rs
+++ b/src/tools/clippy/clippy_utils/src/macros.rs
@@ -30,6 +30,8 @@ const FORMAT_MACRO_DIAG_ITEMS: &[Symbol] = &[
     sym::print_macro,
     sym::println_macro,
     sym::std_panic_macro,
+    sym::todo_macro,
+    sym::unimplemented_macro,
     sym::write_macro,
     sym::writeln_macro,
 ];
diff --git a/src/tools/clippy/clippy_utils/src/msrvs.rs b/src/tools/clippy/clippy_utils/src/msrvs.rs
index 24f73b9df268..5bb2b12988a6 100644
--- a/src/tools/clippy/clippy_utils/src/msrvs.rs
+++ b/src/tools/clippy/clippy_utils/src/msrvs.rs
@@ -1,11 +1,14 @@
+use rustc_ast::Attribute;
 use rustc_ast::attr::AttributeExt;
 
 use rustc_attr_parsing::{RustcVersion, parse_version};
+use rustc_lint::LateContext;
 use rustc_session::Session;
 use rustc_span::{Symbol, sym};
 use serde::Deserialize;
-use smallvec::{SmallVec, smallvec};
-use std::fmt;
+use smallvec::SmallVec;
+use std::iter::once;
+use std::sync::atomic::{AtomicBool, Ordering};
 
 macro_rules! msrv_aliases {
     ($($major:literal,$minor:literal,$patch:literal {
@@ -19,6 +22,8 @@ macro_rules! msrv_aliases {
 
 // names may refer to stabilized feature flags or library items
 msrv_aliases! {
+    1,87,0 { OS_STR_DISPLAY, INT_MIDPOINT }
+    1,85,0 { UINT_FLOAT_MIDPOINT }
     1,84,0 { CONST_OPTION_AS_SLICE }
     1,83,0 { CONST_EXTERN_FN, CONST_FLOAT_BITS_CONV, CONST_FLOAT_CLASSIFY, CONST_MUT_REFS, CONST_UNWRAP }
     1,82,0 { IS_NONE_OR, REPEAT_N, RAW_REF_OP }
@@ -27,7 +32,7 @@ msrv_aliases! {
     1,77,0 { C_STR_LITERALS }
     1,76,0 { PTR_FROM_REF, OPTION_RESULT_INSPECT }
     1,75,0 { OPTION_AS_SLICE }
-    1,74,0 { REPR_RUST }
+    1,74,0 { REPR_RUST, IO_ERROR_OTHER }
     1,73,0 { MANUAL_DIV_CEIL }
     1,71,0 { TUPLE_ARRAY_CONVERSIONS, BUILD_HASHER_HASH_ONE }
     1,70,0 { OPTION_RESULT_IS_VARIANT_AND, BINARY_HEAP_RETAIN }
@@ -37,10 +42,11 @@ msrv_aliases! {
     1,62,0 { BOOL_THEN_SOME, DEFAULT_ENUM_ATTRIBUTE, CONST_EXTERN_C_FN }
     1,59,0 { THREAD_LOCAL_CONST_INIT }
     1,58,0 { FORMAT_ARGS_CAPTURE, PATTERN_TRAIT_CHAR_ARRAY, CONST_RAW_PTR_DEREF }
+    1,57,0 { MAP_WHILE }
     1,56,0 { CONST_FN_UNION }
     1,55,0 { SEEK_REWIND }
     1,54,0 { INTO_KEYS }
-    1,53,0 { OR_PATTERNS, MANUAL_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
+    1,53,0 { OR_PATTERNS, INTEGER_BITS, BTREE_MAP_RETAIN, BTREE_SET_RETAIN, ARRAY_INTO_ITERATOR }
     1,52,0 { STR_SPLIT_ONCE, REM_EUCLID_CONST }
     1,51,0 { BORROW_AS_PTR, SEEK_FROM_CURRENT, UNSIGNED_ABS }
     1,50,0 { BOOL_THEN, CLAMP, SLICE_FILL }
@@ -57,6 +63,7 @@ msrv_aliases! {
     1,35,0 { OPTION_COPIED, RANGE_CONTAINS }
     1,34,0 { TRY_FROM }
     1,33,0 { UNDERSCORE_IMPORTS }
+    1,31,0 { OPTION_REPLACE }
     1,30,0 { ITERATOR_FIND_MAP, TOOL_ATTRIBUTES }
     1,29,0 { ITER_FLATTEN }
     1,28,0 { FROM_BOOL, REPEAT_WITH }
@@ -69,21 +76,15 @@ msrv_aliases! {
     1,15,0 { MAYBE_BOUND_IN_WHERE }
 }
 
-/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]`
-#[derive(Debug, Clone)]
-pub struct Msrv {
-    stack: SmallVec<[RustcVersion; 2]>,
-}
+/// `#[clippy::msrv]` attributes are rarely used outside of Clippy's test suite, as a basic
+/// optimization we can skip traversing the HIR in [`Msrv::meets`] if we never saw an MSRV attribute
+/// during the early lint passes
+static SEEN_MSRV_ATTR: AtomicBool = AtomicBool::new(false);
 
-impl fmt::Display for Msrv {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        if let Some(msrv) = self.current() {
-            write!(f, "{msrv}")
-        } else {
-            f.write_str("1.0.0")
-        }
-    }
-}
+/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]` in late
+/// lint passes, use [`MsrvStack`] for early passes
+#[derive(Copy, Clone, Debug, Default)]
+pub struct Msrv(Option<RustcVersion>);
 
 impl<'de> Deserialize<'de> for Msrv {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -92,14 +93,36 @@ impl<'de> Deserialize<'de> for Msrv {
     {
         let v = String::deserialize(deserializer)?;
         parse_version(Symbol::intern(&v))
-            .map(|v| Msrv { stack: smallvec![v] })
+            .map(|v| Self(Some(v)))
             .ok_or_else(|| serde::de::Error::custom("not a valid Rust version"))
     }
 }
 
 impl Msrv {
-    pub fn empty() -> Msrv {
-        Msrv { stack: SmallVec::new() }
+    /// Returns the MSRV at the current node
+    ///
+    /// If the crate being linted uses an `#[clippy::msrv]` attribute this will search the parent
+    /// nodes for that attribute, prefer to run this check after cheaper pattern matching operations
+    pub fn current(self, cx: &LateContext<'_>) -> Option<RustcVersion> {
+        if SEEN_MSRV_ATTR.load(Ordering::Relaxed) {
+            let start = cx.last_node_with_lint_attrs;
+            if let Some(msrv_attr) = once(start)
+                .chain(cx.tcx.hir_parent_id_iter(start))
+                .find_map(|id| parse_attrs(cx.tcx.sess, cx.tcx.hir().attrs(id)))
+            {
+                return Some(msrv_attr);
+            }
+        }
+
+        self.0
+    }
+
+    /// Checks if a required version from [this module](self) is met at the current node
+    ///
+    /// If the crate being linted uses an `#[clippy::msrv]` attribute this will search the parent
+    /// nodes for that attribute, prefer to run this check after cheaper pattern matching operations
+    pub fn meets(self, cx: &LateContext<'_>, required: RustcVersion) -> bool {
+        self.current(cx).is_none_or(|msrv| msrv >= required)
     }
 
     pub fn read_cargo(&mut self, sess: &Session) {
@@ -107,8 +130,8 @@ impl Msrv {
             .ok()
             .and_then(|v| parse_version(Symbol::intern(&v)));
 
-        match (self.current(), cargo_msrv) {
-            (None, Some(cargo_msrv)) => self.stack = smallvec![cargo_msrv],
+        match (self.0, cargo_msrv) {
+            (None, Some(cargo_msrv)) => self.0 = Some(cargo_msrv),
             (Some(clippy_msrv), Some(cargo_msrv)) => {
                 if clippy_msrv != cargo_msrv {
                     sess.dcx().warn(format!(
@@ -119,6 +142,21 @@ impl Msrv {
             _ => {},
         }
     }
+}
+
+/// Tracks the current MSRV from `clippy.toml`, `Cargo.toml` or set via `#[clippy::msrv]` in early
+/// lint passes, use [`Msrv`] for late passes
+#[derive(Debug, Clone)]
+pub struct MsrvStack {
+    stack: SmallVec<[RustcVersion; 2]>,
+}
+
+impl MsrvStack {
+    pub fn new(initial: Msrv) -> Self {
+        Self {
+            stack: SmallVec::from_iter(initial.0),
+        }
+    }
 
     pub fn current(&self) -> Option<RustcVersion> {
         self.stack.last().copied()
@@ -128,42 +166,43 @@ impl Msrv {
         self.current().is_none_or(|msrv| msrv >= required)
     }
 
-    fn parse_attr(sess: &Session, attrs: &[impl AttributeExt]) -> Option<RustcVersion> {
-        let sym_msrv = Symbol::intern("msrv");
-        let mut msrv_attrs = attrs.iter().filter(|attr| attr.path_matches(&[sym::clippy, sym_msrv]));
-
-        if let Some(msrv_attr) = msrv_attrs.next() {
-            if let Some(duplicate) = msrv_attrs.next_back() {
-                sess.dcx()
-                    .struct_span_err(duplicate.span(), "`clippy::msrv` is defined multiple times")
-                    .with_span_note(msrv_attr.span(), "first definition found here")
-                    .emit();
-            }
-
-            if let Some(msrv) = msrv_attr.value_str() {
-                if let Some(version) = parse_version(msrv) {
-                    return Some(version);
-                }
-
-                sess.dcx()
-                    .span_err(msrv_attr.span(), format!("`{msrv}` is not a valid Rust version"));
-            } else {
-                sess.dcx().span_err(msrv_attr.span(), "bad clippy attribute");
-            }
-        }
-
-        None
-    }
-
-    pub fn check_attributes(&mut self, sess: &Session, attrs: &[impl AttributeExt]) {
-        if let Some(version) = Self::parse_attr(sess, attrs) {
+    pub fn check_attributes(&mut self, sess: &Session, attrs: &[Attribute]) {
+        if let Some(version) = parse_attrs(sess, attrs) {
+            SEEN_MSRV_ATTR.store(true, Ordering::Relaxed);
             self.stack.push(version);
         }
     }
 
-    pub fn check_attributes_post(&mut self, sess: &Session, attrs: &[impl AttributeExt]) {
-        if Self::parse_attr(sess, attrs).is_some() {
+    pub fn check_attributes_post(&mut self, sess: &Session, attrs: &[Attribute]) {
+        if parse_attrs(sess, attrs).is_some() {
             self.stack.pop();
         }
     }
 }
+
+fn parse_attrs(sess: &Session, attrs: &[impl AttributeExt]) -> Option<RustcVersion> {
+    let sym_msrv = Symbol::intern("msrv");
+    let mut msrv_attrs = attrs.iter().filter(|attr| attr.path_matches(&[sym::clippy, sym_msrv]));
+
+    if let Some(msrv_attr) = msrv_attrs.next() {
+        if let Some(duplicate) = msrv_attrs.next_back() {
+            sess.dcx()
+                .struct_span_err(duplicate.span(), "`clippy::msrv` is defined multiple times")
+                .with_span_note(msrv_attr.span(), "first definition found here")
+                .emit();
+        }
+
+        if let Some(msrv) = msrv_attr.value_str() {
+            if let Some(version) = parse_version(msrv) {
+                return Some(version);
+            }
+
+            sess.dcx()
+                .span_err(msrv_attr.span(), format!("`{msrv}` is not a valid Rust version"));
+        } else {
+            sess.dcx().span_err(msrv_attr.span(), "bad clippy attribute");
+        }
+    }
+
+    None
+}
diff --git a/src/tools/clippy/clippy_utils/src/paths.rs b/src/tools/clippy/clippy_utils/src/paths.rs
index f15fffc09e8d..51d06ad9b1aa 100644
--- a/src/tools/clippy/clippy_utils/src/paths.rs
+++ b/src/tools/clippy/clippy_utils/src/paths.rs
@@ -19,7 +19,6 @@ pub const IDENT: [&str; 3] = ["rustc_span", "symbol", "Ident"];
 pub const IDENT_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Ident", "as_str"];
 pub const KW_MODULE: [&str; 3] = ["rustc_span", "symbol", "kw"];
 pub const LATE_CONTEXT: [&str; 2] = ["rustc_lint", "LateContext"];
-pub const LATE_LINT_PASS: [&str; 3] = ["rustc_lint", "passes", "LateLintPass"];
 pub const LINT: [&str; 2] = ["rustc_lint_defs", "Lint"];
 pub const SYMBOL: [&str; 3] = ["rustc_span", "symbol", "Symbol"];
 pub const SYMBOL_AS_STR: [&str; 4] = ["rustc_span", "symbol", "Symbol", "as_str"];
@@ -28,16 +27,12 @@ pub const SYM_MODULE: [&str; 3] = ["rustc_span", "symbol", "sym"];
 pub const SYNTAX_CONTEXT: [&str; 3] = ["rustc_span", "hygiene", "SyntaxContext"];
 
 // Paths in `core`/`alloc`/`std`. This should be avoided and cleaned up by adding diagnostic items.
-pub const ABORT: [&str; 3] = ["std", "process", "abort"];
-pub const CHILD: [&str; 3] = ["std", "process", "Child"];
-pub const CHILD_ID: [&str; 4] = ["std", "process", "Child", "id"];
-pub const CHILD_KILL: [&str; 4] = ["std", "process", "Child", "kill"];
-pub const PANIC_ANY: [&str; 3] = ["std", "panic", "panic_any"];
 pub const CHAR_IS_ASCII: [&str; 5] = ["core", "char", "methods", "<impl char>", "is_ascii"];
-pub const STDIN: [&str; 4] = ["std", "io", "stdio", "Stdin"];
+pub const IO_ERROR_NEW: [&str; 5] = ["std", "io", "error", "Error", "new"];
+pub const IO_ERRORKIND_OTHER: [&str; 5] = ["std", "io", "error", "ErrorKind", "Other"];
 
 // Paths in clippy itself
-pub const MSRV: [&str; 3] = ["clippy_utils", "msrvs", "Msrv"];
+pub const MSRV_STACK: [&str; 3] = ["clippy_utils", "msrvs", "MsrvStack"];
 
 // Paths in external crates
 #[expect(clippy::invalid_paths)] // internal lints do not know about all external crates
diff --git a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
index c7890f33f27e..8e6f4d4a317e 100644
--- a/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
+++ b/src/tools/clippy/clippy_utils/src/qualify_min_const_fn.rs
@@ -11,6 +11,7 @@ use rustc_hir as hir;
 use rustc_hir::def_id::DefId;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::Obligation;
+use rustc_lint::LateContext;
 use rustc_middle::mir::{
     Body, CastKind, NonDivergingIntrinsic, NullOp, Operand, Place, ProjectionElem, Rvalue, Statement, StatementKind,
     Terminator, TerminatorKind,
@@ -25,16 +26,16 @@ use std::borrow::Cow;
 
 type McfResult = Result<(), (Span, Cow<'static, str>)>;
 
-pub fn is_min_const_fn<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, msrv: &Msrv) -> McfResult {
+pub fn is_min_const_fn<'tcx>(cx: &LateContext<'tcx>, body: &Body<'tcx>, msrv: Msrv) -> McfResult {
     let def_id = body.source.def_id();
 
     for local in &body.local_decls {
-        check_ty(tcx, local.ty, local.source_info.span, msrv)?;
+        check_ty(cx, local.ty, local.source_info.span, msrv)?;
     }
     // impl trait is gone in MIR, so check the return type manually
     check_ty(
-        tcx,
-        tcx.fn_sig(def_id).instantiate_identity().output().skip_binder(),
+        cx,
+        cx.tcx.fn_sig(def_id).instantiate_identity().output().skip_binder(),
         body.local_decls.iter().next().unwrap().source_info.span,
         msrv,
     )?;
@@ -43,16 +44,16 @@ pub fn is_min_const_fn<'tcx>(tcx: TyCtxt<'tcx>, body: &Body<'tcx>, msrv: &Msrv)
         // Cleanup blocks are ignored entirely by const eval, so we can too:
         // https://github.com/rust-lang/rust/blob/1dea922ea6e74f99a0e97de5cdb8174e4dea0444/compiler/rustc_const_eval/src/transform/check_consts/check.rs#L382
         if !bb.is_cleanup {
-            check_terminator(tcx, body, bb.terminator(), msrv)?;
+            check_terminator(cx, body, bb.terminator(), msrv)?;
             for stmt in &bb.statements {
-                check_statement(tcx, body, def_id, stmt, msrv)?;
+                check_statement(cx, body, def_id, stmt, msrv)?;
             }
         }
     }
     Ok(())
 }
 
-fn check_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span, msrv: &Msrv) -> McfResult {
+fn check_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>, span: Span, msrv: Msrv) -> McfResult {
     for arg in ty.walk() {
         let ty = match arg.unpack() {
             GenericArgKind::Type(ty) => ty,
@@ -63,7 +64,7 @@ fn check_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span, msrv: &Msrv) -> M
         };
 
         match ty.kind() {
-            ty::Ref(_, _, hir::Mutability::Mut) if !msrv.meets(msrvs::CONST_MUT_REFS) => {
+            ty::Ref(_, _, hir::Mutability::Mut) if !msrv.meets(cx, msrvs::CONST_MUT_REFS) => {
                 return Err((span, "mutable references in const fn are unstable".into()));
             },
             ty::Alias(ty::Opaque, ..) => return Err((span, "`impl Trait` in const fn is unstable".into())),
@@ -82,7 +83,7 @@ fn check_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span, msrv: &Msrv) -> M
                             ));
                         },
                         ty::ExistentialPredicate::Trait(trait_ref) => {
-                            if Some(trait_ref.def_id) != tcx.lang_items().sized_trait() {
+                            if Some(trait_ref.def_id) != cx.tcx.lang_items().sized_trait() {
                                 return Err((
                                     span,
                                     "trait bounds other than `Sized` \
@@ -101,19 +102,19 @@ fn check_ty<'tcx>(tcx: TyCtxt<'tcx>, ty: Ty<'tcx>, span: Span, msrv: &Msrv) -> M
 }
 
 fn check_rvalue<'tcx>(
-    tcx: TyCtxt<'tcx>,
+    cx: &LateContext<'tcx>,
     body: &Body<'tcx>,
     def_id: DefId,
     rvalue: &Rvalue<'tcx>,
     span: Span,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> McfResult {
     match rvalue {
         Rvalue::ThreadLocalRef(_) => Err((span, "cannot access thread local storage in const fn".into())),
         Rvalue::Len(place) | Rvalue::Discriminant(place) | Rvalue::Ref(_, _, place) | Rvalue::RawPtr(_, place) => {
-            check_place(tcx, *place, span, body, msrv)
+            check_place(cx, *place, span, body, msrv)
         },
-        Rvalue::CopyForDeref(place) => check_place(tcx, *place, span, body, msrv),
+        Rvalue::CopyForDeref(place) => check_place(cx, *place, span, body, msrv),
         Rvalue::Repeat(operand, _)
         | Rvalue::Use(operand)
         | Rvalue::WrapUnsafeBinder(operand, _)
@@ -128,7 +129,7 @@ fn check_rvalue<'tcx>(
             | CastKind::PointerCoercion(PointerCoercion::MutToConstPointer | PointerCoercion::ArrayToPointer, _),
             operand,
             _,
-        ) => check_operand(tcx, operand, span, body, msrv),
+        ) => check_operand(cx, operand, span, body, msrv),
         Rvalue::Cast(
             CastKind::PointerCoercion(
                 PointerCoercion::UnsafeFnPointer
@@ -144,9 +145,11 @@ fn check_rvalue<'tcx>(
                 // We cannot allow this for now.
                 return Err((span, "unsizing casts are only allowed for references right now".into()));
             };
-            let unsized_ty = tcx.struct_tail_for_codegen(pointee_ty, ty::TypingEnv::post_analysis(tcx, def_id));
+            let unsized_ty = cx
+                .tcx
+                .struct_tail_for_codegen(pointee_ty, ty::TypingEnv::post_analysis(cx.tcx, def_id));
             if let ty::Slice(_) | ty::Str = unsized_ty.kind() {
-                check_operand(tcx, op, span, body, msrv)?;
+                check_operand(cx, op, span, body, msrv)?;
                 // Casting/coercing things to slices is fine.
                 Ok(())
             } else {
@@ -167,9 +170,9 @@ fn check_rvalue<'tcx>(
         )),
         // binops are fine on integers
         Rvalue::BinaryOp(_, box (lhs, rhs)) => {
-            check_operand(tcx, lhs, span, body, msrv)?;
-            check_operand(tcx, rhs, span, body, msrv)?;
-            let ty = lhs.ty(body, tcx);
+            check_operand(cx, lhs, span, body, msrv)?;
+            check_operand(cx, rhs, span, body, msrv)?;
+            let ty = lhs.ty(body, cx.tcx);
             if ty.is_integral() || ty.is_bool() || ty.is_char() {
                 Ok(())
             } else {
@@ -185,16 +188,16 @@ fn check_rvalue<'tcx>(
         )
         | Rvalue::ShallowInitBox(_, _) => Ok(()),
         Rvalue::UnaryOp(_, operand) => {
-            let ty = operand.ty(body, tcx);
+            let ty = operand.ty(body, cx.tcx);
             if ty.is_integral() || ty.is_bool() {
-                check_operand(tcx, operand, span, body, msrv)
+                check_operand(cx, operand, span, body, msrv)
             } else {
                 Err((span, "only int and `bool` operations are stable in const fn".into()))
             }
         },
         Rvalue::Aggregate(_, operands) => {
             for operand in operands {
-                check_operand(tcx, operand, span, body, msrv)?;
+                check_operand(cx, operand, span, body, msrv)?;
             }
             Ok(())
         },
@@ -202,33 +205,33 @@ fn check_rvalue<'tcx>(
 }
 
 fn check_statement<'tcx>(
-    tcx: TyCtxt<'tcx>,
+    cx: &LateContext<'tcx>,
     body: &Body<'tcx>,
     def_id: DefId,
     statement: &Statement<'tcx>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> McfResult {
     let span = statement.source_info.span;
     match &statement.kind {
         StatementKind::Assign(box (place, rval)) => {
-            check_place(tcx, *place, span, body, msrv)?;
-            check_rvalue(tcx, body, def_id, rval, span, msrv)
+            check_place(cx, *place, span, body, msrv)?;
+            check_rvalue(cx, body, def_id, rval, span, msrv)
         },
 
-        StatementKind::FakeRead(box (_, place)) => check_place(tcx, *place, span, body, msrv),
+        StatementKind::FakeRead(box (_, place)) => check_place(cx, *place, span, body, msrv),
         // just an assignment
         StatementKind::SetDiscriminant { place, .. } | StatementKind::Deinit(place) => {
-            check_place(tcx, **place, span, body, msrv)
+            check_place(cx, **place, span, body, msrv)
         },
 
-        StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => check_operand(tcx, op, span, body, msrv),
+        StatementKind::Intrinsic(box NonDivergingIntrinsic::Assume(op)) => check_operand(cx, op, span, body, msrv),
 
         StatementKind::Intrinsic(box NonDivergingIntrinsic::CopyNonOverlapping(
             rustc_middle::mir::CopyNonOverlapping { dst, src, count },
         )) => {
-            check_operand(tcx, dst, span, body, msrv)?;
-            check_operand(tcx, src, span, body, msrv)?;
-            check_operand(tcx, count, span, body, msrv)
+            check_operand(cx, dst, span, body, msrv)?;
+            check_operand(cx, src, span, body, msrv)?;
+            check_operand(cx, count, span, body, msrv)
         },
         // These are all NOPs
         StatementKind::StorageLive(_)
@@ -244,16 +247,16 @@ fn check_statement<'tcx>(
 }
 
 fn check_operand<'tcx>(
-    tcx: TyCtxt<'tcx>,
+    cx: &LateContext<'tcx>,
     operand: &Operand<'tcx>,
     span: Span,
     body: &Body<'tcx>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> McfResult {
     match operand {
         Operand::Move(place) => {
             if !place.projection.as_ref().is_empty()
-                && !is_ty_const_destruct(tcx, place.ty(&body.local_decls, tcx).ty, body)
+                && !is_ty_const_destruct(cx.tcx, place.ty(&body.local_decls, cx.tcx).ty, body)
             {
                 return Err((
                     span,
@@ -261,29 +264,35 @@ fn check_operand<'tcx>(
                 ));
             }
 
-            check_place(tcx, *place, span, body, msrv)
+            check_place(cx, *place, span, body, msrv)
         },
-        Operand::Copy(place) => check_place(tcx, *place, span, body, msrv),
-        Operand::Constant(c) => match c.check_static_ptr(tcx) {
+        Operand::Copy(place) => check_place(cx, *place, span, body, msrv),
+        Operand::Constant(c) => match c.check_static_ptr(cx.tcx) {
             Some(_) => Err((span, "cannot access `static` items in const fn".into())),
             None => Ok(()),
         },
     }
 }
 
-fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &Body<'tcx>, msrv: &Msrv) -> McfResult {
+fn check_place<'tcx>(
+    cx: &LateContext<'tcx>,
+    place: Place<'tcx>,
+    span: Span,
+    body: &Body<'tcx>,
+    msrv: Msrv,
+) -> McfResult {
     for (base, elem) in place.as_ref().iter_projections() {
         match elem {
             ProjectionElem::Field(..) => {
-                if base.ty(body, tcx).ty.is_union() && !msrv.meets(msrvs::CONST_FN_UNION) {
+                if base.ty(body, cx.tcx).ty.is_union() && !msrv.meets(cx, msrvs::CONST_FN_UNION) {
                     return Err((span, "accessing union fields is unstable".into()));
                 }
             },
-            ProjectionElem::Deref => match base.ty(body, tcx).ty.kind() {
+            ProjectionElem::Deref => match base.ty(body, cx.tcx).ty.kind() {
                 ty::RawPtr(_, hir::Mutability::Mut) => {
                     return Err((span, "dereferencing raw mut pointer in const fn is unstable".into()));
                 },
-                ty::RawPtr(_, hir::Mutability::Not) if !msrv.meets(msrvs::CONST_RAW_PTR_DEREF) => {
+                ty::RawPtr(_, hir::Mutability::Not) if !msrv.meets(cx, msrvs::CONST_RAW_PTR_DEREF) => {
                     return Err((span, "dereferencing raw const pointer in const fn is unstable".into()));
                 },
                 _ => (),
@@ -302,10 +311,10 @@ fn check_place<'tcx>(tcx: TyCtxt<'tcx>, place: Place<'tcx>, span: Span, body: &B
 }
 
 fn check_terminator<'tcx>(
-    tcx: TyCtxt<'tcx>,
+    cx: &LateContext<'tcx>,
     body: &Body<'tcx>,
     terminator: &Terminator<'tcx>,
-    msrv: &Msrv,
+    msrv: Msrv,
 ) -> McfResult {
     let span = terminator.source_info.span;
     match &terminator.kind {
@@ -317,7 +326,7 @@ fn check_terminator<'tcx>(
         | TerminatorKind::UnwindTerminate(_)
         | TerminatorKind::Unreachable => Ok(()),
         TerminatorKind::Drop { place, .. } => {
-            if !is_ty_const_destruct(tcx, place.ty(&body.local_decls, tcx).ty, body) {
+            if !is_ty_const_destruct(cx.tcx, place.ty(&body.local_decls, cx.tcx).ty, body) {
                 return Err((
                     span,
                     "cannot drop locals with a non constant destructor in const fn".into(),
@@ -325,7 +334,7 @@ fn check_terminator<'tcx>(
             }
             Ok(())
         },
-        TerminatorKind::SwitchInt { discr, targets: _ } => check_operand(tcx, discr, span, body, msrv),
+        TerminatorKind::SwitchInt { discr, targets: _ } => check_operand(cx, discr, span, body, msrv),
         TerminatorKind::CoroutineDrop | TerminatorKind::Yield { .. } => {
             Err((span, "const fn coroutines are unstable".into()))
         },
@@ -339,9 +348,9 @@ fn check_terminator<'tcx>(
             fn_span: _,
         }
         | TerminatorKind::TailCall { func, args, fn_span: _ } => {
-            let fn_ty = func.ty(body, tcx);
+            let fn_ty = func.ty(body, cx.tcx);
             if let ty::FnDef(fn_def_id, _) = *fn_ty.kind() {
-                if !is_stable_const_fn(tcx, fn_def_id, msrv) {
+                if !is_stable_const_fn(cx, fn_def_id, msrv) {
                     return Err((
                         span,
                         format!(
@@ -356,17 +365,17 @@ fn check_terminator<'tcx>(
                 // within const fns. `transmute` is allowed in all other const contexts.
                 // This won't really scale to more intrinsics or functions. Let's allow const
                 // transmutes in const fn before we add more hacks to this.
-                if tcx.is_intrinsic(fn_def_id, sym::transmute) {
+                if cx.tcx.is_intrinsic(fn_def_id, sym::transmute) {
                     return Err((
                         span,
                         "can only call `transmute` from const items, not `const fn`".into(),
                     ));
                 }
 
-                check_operand(tcx, func, span, body, msrv)?;
+                check_operand(cx, func, span, body, msrv)?;
 
                 for arg in args {
-                    check_operand(tcx, &arg.node, span, body, msrv)?;
+                    check_operand(cx, &arg.node, span, body, msrv)?;
                 }
                 Ok(())
             } else {
@@ -379,14 +388,14 @@ fn check_terminator<'tcx>(
             msg: _,
             target: _,
             unwind: _,
-        } => check_operand(tcx, cond, span, body, msrv),
+        } => check_operand(cx, cond, span, body, msrv),
         TerminatorKind::InlineAsm { .. } => Err((span, "cannot use inline assembly in const fn".into())),
     }
 }
 
-fn is_stable_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: &Msrv) -> bool {
-    tcx.is_const_fn(def_id)
-        && tcx.lookup_const_stability(def_id).is_none_or(|const_stab| {
+fn is_stable_const_fn(cx: &LateContext<'_>, def_id: DefId, msrv: Msrv) -> bool {
+    cx.tcx.is_const_fn(def_id)
+        && cx.tcx.lookup_const_stability(def_id).is_none_or(|const_stab| {
             if let rustc_attr_parsing::StabilityLevel::Stable { since, .. } = const_stab.level {
                 // Checking MSRV is manually necessary because `rustc` has no such concept. This entire
                 // function could be removed if `rustc` provided a MSRV-aware version of `is_stable_const_fn`.
@@ -398,10 +407,10 @@ fn is_stable_const_fn(tcx: TyCtxt<'_>, def_id: DefId, msrv: &Msrv) -> bool {
                     StableSince::Err => return false,
                 };
 
-                msrv.meets(const_stab_rust_version)
+                msrv.meets(cx, const_stab_rust_version)
             } else {
                 // Unstable const fn, check if the feature is enabled.
-                tcx.features().enabled(const_stab.feature) && msrv.current().is_none()
+                cx.tcx.features().enabled(const_stab.feature) && msrv.current(cx).is_none()
             }
         })
 }
diff --git a/src/tools/clippy/clippy_utils/src/source.rs b/src/tools/clippy/clippy_utils/src/source.rs
index c6a038f7e0cf..80066e9702d3 100644
--- a/src/tools/clippy/clippy_utils/src/source.rs
+++ b/src/tools/clippy/clippy_utils/src/source.rs
@@ -294,7 +294,7 @@ impl SourceFileRange {
     }
 }
 
-/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block`.
+/// Like `snippet_block`, but add braces if the expr is not an `ExprKind::Block` with no label.
 pub fn expr_block(
     sess: &impl HasSession,
     expr: &Expr<'_>,
@@ -305,10 +305,10 @@ pub fn expr_block(
 ) -> String {
     let (code, from_macro) = snippet_block_with_context(sess, expr.span, outer, default, indent_relative_to, app);
     if !from_macro
-        && let ExprKind::Block(block, _) = expr.kind
+        && let ExprKind::Block(block, None) = expr.kind
         && block.rules != BlockCheckMode::UnsafeBlock(UnsafeSource::UserProvided)
     {
-        format!("{code}")
+        code
     } else {
         // FIXME: add extra indent for the unsafe blocks:
         //     original code:   unsafe { ... }
@@ -421,11 +421,10 @@ pub fn position_before_rarrow(s: &str) -> Option<usize> {
 }
 
 /// Reindent a multiline string with possibility of ignoring the first line.
-#[expect(clippy::needless_pass_by_value)]
-pub fn reindent_multiline(s: Cow<'_, str>, ignore_first: bool, indent: Option<usize>) -> Cow<'_, str> {
-    let s_space = reindent_multiline_inner(&s, ignore_first, indent, ' ');
+pub fn reindent_multiline(s: &str, ignore_first: bool, indent: Option<usize>) -> String {
+    let s_space = reindent_multiline_inner(s, ignore_first, indent, ' ');
     let s_tab = reindent_multiline_inner(&s_space, ignore_first, indent, '\t');
-    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ').into()
+    reindent_multiline_inner(&s_tab, ignore_first, indent, ' ')
 }
 
 fn reindent_multiline_inner(s: &str, ignore_first: bool, indent: Option<usize>, ch: char) -> String {
@@ -553,42 +552,37 @@ pub fn snippet_opt(sess: &impl HasSession, span: Span) -> Option<String> {
 ///     } // aligned with `if`
 /// ```
 /// Note that the first line of the snippet always has 0 indentation.
-pub fn snippet_block<'a>(
-    sess: &impl HasSession,
-    span: Span,
-    default: &'a str,
-    indent_relative_to: Option<Span>,
-) -> Cow<'a, str> {
+pub fn snippet_block(sess: &impl HasSession, span: Span, default: &str, indent_relative_to: Option<Span>) -> String {
     let snip = snippet(sess, span, default);
     let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
-    reindent_multiline(snip, true, indent)
+    reindent_multiline(&snip, true, indent)
 }
 
 /// Same as `snippet_block`, but adapts the applicability level by the rules of
 /// `snippet_with_applicability`.
-pub fn snippet_block_with_applicability<'a>(
+pub fn snippet_block_with_applicability(
     sess: &impl HasSession,
     span: Span,
-    default: &'a str,
+    default: &str,
     indent_relative_to: Option<Span>,
     applicability: &mut Applicability,
-) -> Cow<'a, str> {
+) -> String {
     let snip = snippet_with_applicability(sess, span, default, applicability);
     let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
-    reindent_multiline(snip, true, indent)
+    reindent_multiline(&snip, true, indent)
 }
 
-pub fn snippet_block_with_context<'a>(
+pub fn snippet_block_with_context(
     sess: &impl HasSession,
     span: Span,
     outer: SyntaxContext,
-    default: &'a str,
+    default: &str,
     indent_relative_to: Option<Span>,
     app: &mut Applicability,
-) -> (Cow<'a, str>, bool) {
+) -> (String, bool) {
     let (snip, from_macro) = snippet_with_context(sess, span, outer, default, app);
     let indent = indent_relative_to.and_then(|s| indent_of(sess, s));
-    (reindent_multiline(snip, true, indent), from_macro)
+    (reindent_multiline(&snip, true, indent), from_macro)
 }
 
 /// Same as `snippet_with_applicability`, but first walks the span up to the given context.
@@ -749,11 +743,11 @@ mod test {
 
     #[test]
     fn test_reindent_multiline_single_line() {
-        assert_eq!("", reindent_multiline("".into(), false, None));
-        assert_eq!("...", reindent_multiline("...".into(), false, None));
-        assert_eq!("...", reindent_multiline("    ...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t...".into(), false, None));
-        assert_eq!("...", reindent_multiline("\t\t...".into(), false, None));
+        assert_eq!("", reindent_multiline("", false, None));
+        assert_eq!("...", reindent_multiline("...", false, None));
+        assert_eq!("...", reindent_multiline("    ...", false, None));
+        assert_eq!("...", reindent_multiline("\t...", false, None));
+        assert_eq!("...", reindent_multiline("\t\t...", false, None));
     }
 
     #[test]
@@ -768,7 +762,7 @@ mod test {
             y
         } else {
             z
-        }".into(), false, None));
+        }", false, None));
         assert_eq!("\
     if x {
     \ty
@@ -778,7 +772,7 @@ mod test {
         \ty
         } else {
         \tz
-        }".into(), false, None));
+        }", false, None));
     }
 
     #[test]
@@ -795,7 +789,7 @@ mod test {
 
         } else {
             z
-        }".into(), false, None));
+        }", false, None));
     }
 
     #[test]
@@ -811,6 +805,6 @@ mod test {
         y
     } else {
         z
-    }".into(), true, Some(8)));
+    }", true, Some(8)));
     }
 }
diff --git a/src/tools/clippy/clippy_utils/src/sugg.rs b/src/tools/clippy/clippy_utils/src/sugg.rs
index d5e0e2e3436e..4a9ab17d4a60 100644
--- a/src/tools/clippy/clippy_utils/src/sugg.rs
+++ b/src/tools/clippy/clippy_utils/src/sugg.rs
@@ -5,8 +5,7 @@ use crate::source::{snippet, snippet_opt, snippet_with_applicability, snippet_wi
 use crate::ty::expr_sig;
 use crate::{get_parent_expr_for_hir, higher};
 use rustc_ast::util::parser::AssocOp;
-use rustc_ast::{ast, token};
-use rustc_ast_pretty::pprust::token_kind_to_string;
+use rustc_ast::ast;
 use rustc_errors::Applicability;
 use rustc_hir as hir;
 use rustc_hir::{Closure, ExprKind, HirId, MutTy, TyKind};
@@ -114,10 +113,7 @@ impl<'a> Sugg<'a> {
     /// function variants of `Sugg`, since these use different snippet functions.
     fn hir_from_snippet(expr: &hir::Expr<'_>, mut get_snippet: impl FnMut(Span) -> Cow<'a, str>) -> Self {
         if let Some(range) = higher::Range::hir(expr) {
-            let op = match range.limits {
-                ast::RangeLimits::HalfOpen => AssocOp::DotDot,
-                ast::RangeLimits::Closed => AssocOp::DotDotEq,
-            };
+            let op = AssocOp::Range(range.limits);
             let start = range.start.map_or("".into(), |expr| get_snippet(expr.span));
             let end = range.end.map_or("".into(), |expr| get_snippet(expr.span));
 
@@ -158,16 +154,16 @@ impl<'a> Sugg<'a> {
                 Sugg::BinOp(AssocOp::Assign, get_snippet(lhs.span), get_snippet(rhs.span))
             },
             ExprKind::AssignOp(op, lhs, rhs) => {
-                Sugg::BinOp(hirbinop2assignop(op), get_snippet(lhs.span), get_snippet(rhs.span))
+                Sugg::BinOp(AssocOp::AssignOp(op.node), get_snippet(lhs.span), get_snippet(rhs.span))
             },
             ExprKind::Binary(op, lhs, rhs) => Sugg::BinOp(
-                AssocOp::from_ast_binop(op.node),
+                AssocOp::Binary(op.node),
                 get_snippet(lhs.span),
                 get_snippet(rhs.span),
             ),
             ExprKind::Cast(lhs, ty) |
             //FIXME(chenyukang), remove this after type ascription is removed from AST
-            ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::As, get_snippet(lhs.span), get_snippet(ty.span)),
+            ExprKind::Type(lhs, ty) => Sugg::BinOp(AssocOp::Cast, get_snippet(lhs.span), get_snippet(ty.span)),
         }
     }
 
@@ -179,8 +175,6 @@ impl<'a> Sugg<'a> {
         ctxt: SyntaxContext,
         app: &mut Applicability,
     ) -> Self {
-        use rustc_ast::ast::RangeLimits;
-
         let mut snippet = |span: Span| snippet_with_context(cx, span, ctxt, default, app).0;
 
         match expr.kind {
@@ -229,13 +223,8 @@ impl<'a> Sugg<'a> {
             | ast::ExprKind::Err(_)
             | ast::ExprKind::Dummy
             | ast::ExprKind::UnsafeBinderCast(..) => Sugg::NonParen(snippet(expr.span)),
-            ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::HalfOpen) => Sugg::BinOp(
-                AssocOp::DotDot,
-                lhs.as_ref().map_or("".into(), |lhs| snippet(lhs.span)),
-                rhs.as_ref().map_or("".into(), |rhs| snippet(rhs.span)),
-            ),
-            ast::ExprKind::Range(ref lhs, ref rhs, RangeLimits::Closed) => Sugg::BinOp(
-                AssocOp::DotDotEq,
+            ast::ExprKind::Range(ref lhs, ref rhs, limits) => Sugg::BinOp(
+                AssocOp::Range(limits),
                 lhs.as_ref().map_or("".into(), |lhs| snippet(lhs.span)),
                 rhs.as_ref().map_or("".into(), |rhs| snippet(rhs.span)),
             ),
@@ -245,19 +234,19 @@ impl<'a> Sugg<'a> {
                 snippet(rhs.span),
             ),
             ast::ExprKind::AssignOp(op, ref lhs, ref rhs) => Sugg::BinOp(
-                astbinop2assignop(op),
+                AssocOp::AssignOp(op.node),
                 snippet(lhs.span),
                 snippet(rhs.span),
             ),
             ast::ExprKind::Binary(op, ref lhs, ref rhs) => Sugg::BinOp(
-                AssocOp::from_ast_binop(op.node),
+                AssocOp::Binary(op.node),
                 snippet(lhs.span),
                 snippet(rhs.span),
             ),
             ast::ExprKind::Cast(ref lhs, ref ty) |
             //FIXME(chenyukang), remove this after type ascription is removed from AST
             ast::ExprKind::Type(ref lhs, ref ty) => Sugg::BinOp(
-                AssocOp::As,
+                AssocOp::Cast,
                 snippet(lhs.span),
                 snippet(ty.span),
             ),
@@ -276,7 +265,7 @@ impl<'a> Sugg<'a> {
 
     /// Convenience method to create the `<lhs> as <rhs>` suggestion.
     pub fn as_ty<R: Display>(self, rhs: R) -> Sugg<'static> {
-        make_assoc(AssocOp::As, &self, &Sugg::NonParen(rhs.to_string().into()))
+        make_assoc(AssocOp::Cast, &self, &Sugg::NonParen(rhs.to_string().into()))
     }
 
     /// Convenience method to create the `&<expr>` suggestion.
@@ -327,11 +316,8 @@ impl<'a> Sugg<'a> {
 
     /// Convenience method to create the `<lhs>..<rhs>` or `<lhs>...<rhs>`
     /// suggestion.
-    pub fn range(self, end: &Self, limit: ast::RangeLimits) -> Sugg<'static> {
-        match limit {
-            ast::RangeLimits::HalfOpen => make_assoc(AssocOp::DotDot, &self, end),
-            ast::RangeLimits::Closed => make_assoc(AssocOp::DotDotEq, &self, end),
-        }
+    pub fn range(self, end: &Self, limits: ast::RangeLimits) -> Sugg<'static> {
+        make_assoc(AssocOp::Range(limits), &self, end)
     }
 
     /// Adds parentheses to any expression that might need them. Suitable to the
@@ -367,33 +353,11 @@ impl<'a> Sugg<'a> {
 /// Generates a string from the operator and both sides.
 fn binop_to_string(op: AssocOp, lhs: &str, rhs: &str) -> String {
     match op {
-        AssocOp::Add
-        | AssocOp::Subtract
-        | AssocOp::Multiply
-        | AssocOp::Divide
-        | AssocOp::Modulus
-        | AssocOp::LAnd
-        | AssocOp::LOr
-        | AssocOp::BitXor
-        | AssocOp::BitAnd
-        | AssocOp::BitOr
-        | AssocOp::ShiftLeft
-        | AssocOp::ShiftRight
-        | AssocOp::Equal
-        | AssocOp::Less
-        | AssocOp::LessEqual
-        | AssocOp::NotEqual
-        | AssocOp::Greater
-        | AssocOp::GreaterEqual => {
-            format!("{lhs} {} {rhs}", op.to_ast_binop().expect("Those are AST ops").as_str())
-        },
+        AssocOp::Binary(op) => format!("{lhs} {} {rhs}", op.as_str()),
         AssocOp::Assign => format!("{lhs} = {rhs}"),
-        AssocOp::AssignOp(op) => {
-            format!("{lhs} {}= {rhs}", token_kind_to_string(&token::BinOp(op)))
-        },
-        AssocOp::As => format!("{lhs} as {rhs}"),
-        AssocOp::DotDot => format!("{lhs}..{rhs}"),
-        AssocOp::DotDotEq => format!("{lhs}..={rhs}"),
+        AssocOp::AssignOp(op) => format!("{lhs} {}= {rhs}", op.as_str()),
+        AssocOp::Cast => format!("{lhs} as {rhs}"),
+        AssocOp::Range(limits) => format!("{lhs}{}{rhs}", limits.as_str()),
     }
 }
 
@@ -468,7 +432,7 @@ impl Neg for Sugg<'_> {
     type Output = Sugg<'static>;
     fn neg(self) -> Sugg<'static> {
         match &self {
-            Self::BinOp(AssocOp::As, ..) => Sugg::MaybeParen(format!("-({self})").into()),
+            Self::BinOp(AssocOp::Cast, ..) => Sugg::MaybeParen(format!("-({self})").into()),
             _ => make_unop("-", self),
         }
     }
@@ -477,16 +441,17 @@ impl Neg for Sugg<'_> {
 impl<'a> Not for Sugg<'a> {
     type Output = Sugg<'a>;
     fn not(self) -> Sugg<'a> {
-        use AssocOp::{Equal, Greater, GreaterEqual, Less, LessEqual, NotEqual};
+        use AssocOp::Binary;
+        use ast::BinOpKind::{Eq, Gt, Ge, Lt, Le, Ne};
 
         if let Sugg::BinOp(op, lhs, rhs) = self {
             let to_op = match op {
-                Equal => NotEqual,
-                NotEqual => Equal,
-                Less => GreaterEqual,
-                GreaterEqual => Less,
-                Greater => LessEqual,
-                LessEqual => Greater,
+                Binary(Eq) => Binary(Ne),
+                Binary(Ne) => Binary(Eq),
+                Binary(Lt) => Binary(Ge),
+                Binary(Ge) => Binary(Lt),
+                Binary(Gt) => Binary(Le),
+                Binary(Le) => Binary(Gt),
                 _ => return make_unop("!", Sugg::BinOp(op, lhs, rhs)),
             };
             Sugg::BinOp(to_op, lhs, rhs)
@@ -538,7 +503,7 @@ pub fn make_unop(op: &str, expr: Sugg<'_>) -> Sugg<'static> {
 pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
     /// Returns `true` if the operator is a shift operator `<<` or `>>`.
     fn is_shift(op: AssocOp) -> bool {
-        matches!(op, AssocOp::ShiftLeft | AssocOp::ShiftRight)
+        matches!(op, AssocOp::Binary(ast::BinOpKind::Shl | ast::BinOpKind::Shr))
     }
 
     /// Returns `true` if the operator is an arithmetic operator
@@ -546,7 +511,13 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static>
     fn is_arith(op: AssocOp) -> bool {
         matches!(
             op,
-            AssocOp::Add | AssocOp::Subtract | AssocOp::Multiply | AssocOp::Divide | AssocOp::Modulus
+            AssocOp::Binary(
+                ast::BinOpKind::Add
+                | ast::BinOpKind::Sub
+                | ast::BinOpKind::Mul
+                | ast::BinOpKind::Div
+                | ast::BinOpKind::Rem
+            )
         )
     }
 
@@ -578,9 +549,9 @@ pub fn make_assoc(op: AssocOp, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static>
     Sugg::BinOp(op, lhs.into(), rhs.into())
 }
 
-/// Convenience wrapper around `make_assoc` and `AssocOp::from_ast_binop`.
+/// Convenience wrapper around `make_assoc` and `AssocOp::Binary`.
 pub fn make_binop(op: ast::BinOpKind, lhs: &Sugg<'_>, rhs: &Sugg<'_>) -> Sugg<'static> {
-    make_assoc(AssocOp::from_ast_binop(op), lhs, rhs)
+    make_assoc(AssocOp::Binary(op), lhs, rhs)
 }
 
 #[derive(PartialEq, Eq, Clone, Copy)]
@@ -605,69 +576,19 @@ enum Associativity {
 /// associative.
 #[must_use]
 fn associativity(op: AssocOp) -> Associativity {
-    use rustc_ast::util::parser::AssocOp::{
-        Add, As, Assign, AssignOp, BitAnd, BitOr, BitXor, Divide, DotDot, DotDotEq, Equal, Greater, GreaterEqual, LAnd,
-        LOr, Less, LessEqual, Modulus, Multiply, NotEqual, ShiftLeft, ShiftRight, Subtract,
+    use rustc_ast::util::parser::AssocOp::{Assign, AssignOp, Binary, Cast, Range};
+    use ast::BinOpKind::{
+        Add, BitAnd, BitOr, BitXor, Div, Eq, Gt, Ge, And, Or, Lt, Le, Rem, Mul, Ne, Shl, Shr, Sub,
     };
 
     match op {
         Assign | AssignOp(_) => Associativity::Right,
-        Add | BitAnd | BitOr | BitXor | LAnd | LOr | Multiply | As => Associativity::Both,
-        Divide | Equal | Greater | GreaterEqual | Less | LessEqual | Modulus | NotEqual | ShiftLeft | ShiftRight
-        | Subtract => Associativity::Left,
-        DotDot | DotDotEq => Associativity::None,
+        Binary(Add | BitAnd | BitOr | BitXor | And | Or | Mul) | Cast => Associativity::Both,
+        Binary(Div | Eq | Gt | Ge | Lt | Le | Rem | Ne | Shl | Shr | Sub) => Associativity::Left,
+        Range(_) => Associativity::None,
     }
 }
 
-/// Converts a `hir::BinOp` to the corresponding assigning binary operator.
-fn hirbinop2assignop(op: hir::BinOp) -> AssocOp {
-    use rustc_ast::token::BinOpToken::{And, Caret, Minus, Or, Percent, Plus, Shl, Shr, Slash, Star};
-
-    AssocOp::AssignOp(match op.node {
-        hir::BinOpKind::Add => Plus,
-        hir::BinOpKind::BitAnd => And,
-        hir::BinOpKind::BitOr => Or,
-        hir::BinOpKind::BitXor => Caret,
-        hir::BinOpKind::Div => Slash,
-        hir::BinOpKind::Mul => Star,
-        hir::BinOpKind::Rem => Percent,
-        hir::BinOpKind::Shl => Shl,
-        hir::BinOpKind::Shr => Shr,
-        hir::BinOpKind::Sub => Minus,
-
-        hir::BinOpKind::And
-        | hir::BinOpKind::Eq
-        | hir::BinOpKind::Ge
-        | hir::BinOpKind::Gt
-        | hir::BinOpKind::Le
-        | hir::BinOpKind::Lt
-        | hir::BinOpKind::Ne
-        | hir::BinOpKind::Or => panic!("This operator does not exist"),
-    })
-}
-
-/// Converts an `ast::BinOp` to the corresponding assigning binary operator.
-fn astbinop2assignop(op: ast::BinOp) -> AssocOp {
-    use rustc_ast::ast::BinOpKind::{
-        Add, And, BitAnd, BitOr, BitXor, Div, Eq, Ge, Gt, Le, Lt, Mul, Ne, Or, Rem, Shl, Shr, Sub,
-    };
-    use rustc_ast::token::BinOpToken;
-
-    AssocOp::AssignOp(match op.node {
-        Add => BinOpToken::Plus,
-        BitAnd => BinOpToken::And,
-        BitOr => BinOpToken::Or,
-        BitXor => BinOpToken::Caret,
-        Div => BinOpToken::Slash,
-        Mul => BinOpToken::Star,
-        Rem => BinOpToken::Percent,
-        Shl => BinOpToken::Shl,
-        Shr => BinOpToken::Shr,
-        Sub => BinOpToken::Minus,
-        And | Eq | Ge | Gt | Le | Lt | Ne | Or => panic!("This operator does not exist"),
-    })
-}
-
 /// Returns the indentation before `span` if there are nothing but `[ \t]`
 /// before it on its line.
 fn indentation<T: LintContext>(cx: &T, span: Span) -> Option<String> {
diff --git a/src/tools/clippy/clippy_utils/src/ty/mod.rs b/src/tools/clippy/clippy_utils/src/ty/mod.rs
index 8eef6a7f57ed..6fdf4c244f8d 100644
--- a/src/tools/clippy/clippy_utils/src/ty/mod.rs
+++ b/src/tools/clippy/clippy_utils/src/ty/mod.rs
@@ -11,6 +11,7 @@ use rustc_hir as hir;
 use rustc_hir::def::{CtorKind, CtorOf, DefKind, Res};
 use rustc_hir::def_id::DefId;
 use rustc_hir::{Expr, FnDecl, LangItem, TyKind};
+use rustc_hir_analysis::lower_ty;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_lint::LateContext;
 use rustc_middle::mir::ConstValue;
@@ -36,6 +37,19 @@ use crate::{def_path_def_ids, match_def_path, path_res};
 mod type_certainty;
 pub use type_certainty::expr_type_is_certain;
 
+/// Lower a [`hir::Ty`] to a [`rustc_middle::ty::Ty`].
+pub fn ty_from_hir_ty<'tcx>(cx: &LateContext<'tcx>, hir_ty: &hir::Ty<'tcx>) -> Ty<'tcx> {
+    cx.maybe_typeck_results()
+        .and_then(|results| {
+            if results.hir_owner == hir_ty.hir_id.owner {
+                results.node_type_opt(hir_ty.hir_id)
+            } else {
+                None
+            }
+        })
+        .unwrap_or_else(|| lower_ty(cx.tcx, hir_ty))
+}
+
 /// Checks if the given type implements copy.
 pub fn is_copy<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
     cx.type_is_copy_modulo_regions(ty)
@@ -351,20 +365,26 @@ pub fn is_must_use_ty<'tcx>(cx: &LateContext<'tcx>, ty: Ty<'tcx>) -> bool {
 /// Checks if `Ty` is normalizable. This function is useful
 /// to avoid crashes on `layout_of`.
 pub fn is_normalizable<'tcx>(cx: &LateContext<'tcx>, param_env: ParamEnv<'tcx>, ty: Ty<'tcx>) -> bool {
-    is_normalizable_helper(cx, param_env, ty, &mut FxHashMap::default())
+    is_normalizable_helper(cx, param_env, ty, 0, &mut FxHashMap::default())
 }
 
 fn is_normalizable_helper<'tcx>(
     cx: &LateContext<'tcx>,
     param_env: ParamEnv<'tcx>,
     ty: Ty<'tcx>,
+    depth: usize,
     cache: &mut FxHashMap<Ty<'tcx>, bool>,
 ) -> bool {
     if let Some(&cached_result) = cache.get(&ty) {
         return cached_result;
     }
-    // prevent recursive loops, false-negative is better than endless loop leading to stack overflow
-    cache.insert(ty, false);
+    if !cx.tcx.recursion_limit().value_within_limit(depth) {
+        return false;
+    }
+    // Prevent recursive loops by answering `true` to recursive requests with the same
+    // type. This will be adjusted when the outermost call analyzes all the type
+    // components.
+    cache.insert(ty, true);
     let infcx = cx.tcx.infer_ctxt().build(cx.typing_mode());
     let cause = ObligationCause::dummy();
     let result = if infcx.at(&cause, param_env).query_normalize(ty).is_ok() {
@@ -373,11 +393,11 @@ fn is_normalizable_helper<'tcx>(
                 variant
                     .fields
                     .iter()
-                    .all(|field| is_normalizable_helper(cx, param_env, field.ty(cx.tcx, args), cache))
+                    .all(|field| is_normalizable_helper(cx, param_env, field.ty(cx.tcx, args), depth + 1, cache))
             }),
             _ => ty.walk().all(|generic_arg| match generic_arg.unpack() {
                 GenericArgKind::Type(inner_ty) if inner_ty != ty => {
-                    is_normalizable_helper(cx, param_env, inner_ty, cache)
+                    is_normalizable_helper(cx, param_env, inner_ty, depth + 1, cache)
                 },
                 _ => true, // if inner_ty == ty, we've already checked it
             }),
@@ -1227,6 +1247,10 @@ impl<'tcx> InteriorMut<'tcx> {
                         .find_map(|f| self.interior_mut_ty_chain(cx, f.ty(cx.tcx, args)))
                 }
             },
+            ty::Alias(ty::Projection, _) => match cx.tcx.try_normalize_erasing_regions(cx.typing_env(), ty) {
+                Ok(normalized_ty) if ty != normalized_ty => self.interior_mut_ty_chain(cx, normalized_ty),
+                _ => None,
+            },
             _ => None,
         };
 
diff --git a/src/tools/clippy/lintcheck/src/input.rs b/src/tools/clippy/lintcheck/src/input.rs
index 3383d50fa02c..83eb0a577d6b 100644
--- a/src/tools/clippy/lintcheck/src/input.rs
+++ b/src/tools/clippy/lintcheck/src/input.rs
@@ -288,11 +288,11 @@ impl CrateWithSource {
                 // as a result of this filter.
                 let dest_crate_root = PathBuf::from(LINTCHECK_SOURCES).join(name);
                 if dest_crate_root.exists() {
-                    println!("Deleting existing directory at {dest_crate_root:?}");
+                    println!("Deleting existing directory at `{}`", dest_crate_root.display());
                     fs::remove_dir_all(&dest_crate_root).unwrap();
                 }
 
-                println!("Copying {path:?} to {dest_crate_root:?}");
+                println!("Copying `{}` to `{}`", path.display(), dest_crate_root.display());
 
                 for entry in WalkDir::new(path).into_iter().filter_entry(|e| !is_cache_dir(e)) {
                     let entry = entry.unwrap();
diff --git a/src/tools/clippy/rust-toolchain b/src/tools/clippy/rust-toolchain
index ab760287e83a..a4931499c802 100644
--- a/src/tools/clippy/rust-toolchain
+++ b/src/tools/clippy/rust-toolchain
@@ -1,6 +1,6 @@
 [toolchain]
 # begin autogenerated nightly
-channel = "nightly-2025-02-06"
+channel = "nightly-2025-02-27"
 # end autogenerated nightly
 components = ["cargo", "llvm-tools", "rust-src", "rust-std", "rustc", "rustc-dev", "rustfmt"]
 profile = "minimal"
diff --git a/src/tools/clippy/rustc_tools_util/Cargo.toml b/src/tools/clippy/rustc_tools_util/Cargo.toml
index cba025639482..716b1ed61443 100644
--- a/src/tools/clippy/rustc_tools_util/Cargo.toml
+++ b/src/tools/clippy/rustc_tools_util/Cargo.toml
@@ -1,12 +1,12 @@
 [package]
 name = "rustc_tools_util"
-version = "0.4.0"
+version = "0.4.2"
 description = "small helper to generate version information for git packages"
 repository = "https://github.com/rust-lang/rust-clippy"
 readme = "README.md"
 license = "MIT OR Apache-2.0"
 keywords = ["rustc", "tool", "git", "version", "hash"]
 categories = ["development-tools"]
-edition = "2024"
+edition = "2021" # Keep this, for this crate's MSRV to stay low
 
 [dependencies]
diff --git a/src/tools/clippy/rustc_tools_util/README.md b/src/tools/clippy/rustc_tools_util/README.md
index 1b11dfe06191..ff4ca6f830e6 100644
--- a/src/tools/clippy/rustc_tools_util/README.md
+++ b/src/tools/clippy/rustc_tools_util/README.md
@@ -13,10 +13,10 @@ build = "build.rs"
 List rustc_tools_util as regular AND build dependency.
 ````toml
 [dependencies]
-rustc_tools_util = "0.4.0"
+rustc_tools_util = "0.4.2"
 
 [build-dependencies]
-rustc_tools_util = "0.4.0"
+rustc_tools_util = "0.4.2"
 ````
 
 In `build.rs`, generate the data in your `main()`
diff --git a/src/tools/clippy/rustc_tools_util/src/lib.rs b/src/tools/clippy/rustc_tools_util/src/lib.rs
index 16be02f4a40f..423154a69fa0 100644
--- a/src/tools/clippy/rustc_tools_util/src/lib.rs
+++ b/src/tools/clippy/rustc_tools_util/src/lib.rs
@@ -28,9 +28,8 @@ macro_rules! get_version_info {
     }};
 }
 
-/// This macro can be used in `build.rs` to automatically set the needed
-/// environment values, namely `GIT_HASH`, `COMMIT_DATE` and
-/// `RUSTC_RELEASE_CHANNEL`
+/// This macro can be used in `build.rs` to automatically set the needed environment values, namely
+/// `GIT_HASH`, `COMMIT_DATE`  and `RUSTC_RELEASE_CHANNEL`
 #[macro_export]
 macro_rules! setup_version_info {
     () => {{
@@ -43,7 +42,11 @@ macro_rules! setup_version_info {
             "cargo:rustc-env=COMMIT_DATE={}",
             $crate::get_commit_date().unwrap_or_default()
         );
-        println!("cargo:rustc-env=RUSTC_RELEASE_CHANNEL={}", $crate::get_channel());
+        let compiler_version = $crate::get_compiler_version();
+        println!(
+            "cargo:rustc-env=RUSTC_RELEASE_CHANNEL={}",
+            $crate::get_channel(compiler_version)
+        );
     }};
 }
 
@@ -87,16 +90,17 @@ impl std::fmt::Debug for VersionInfo {
             "VersionInfo {{ crate_name: \"{}\", major: {}, minor: {}, patch: {}",
             self.crate_name, self.major, self.minor, self.patch,
         )?;
-        if self.commit_hash.is_some() {
-            write!(
-                f,
-                ", commit_hash: \"{}\", commit_date: \"{}\" }}",
-                self.commit_hash.clone().unwrap_or_default().trim(),
-                self.commit_date.clone().unwrap_or_default().trim()
-            )?;
-        } else {
-            write!(f, " }}")?;
+        if let Some(ref commit_hash) = self.commit_hash {
+            write!(f, ", commit_hash: \"{}\"", commit_hash.trim(),)?;
         }
+        if let Some(ref commit_date) = self.commit_date {
+            write!(f, ", commit_date: \"{}\"", commit_date.trim())?;
+        }
+        if let Some(ref host_compiler) = self.host_compiler {
+            write!(f, ", host_compiler: \"{}\"", host_compiler.trim())?;
+        }
+
+        write!(f, " }}")?;
 
         Ok(())
     }
@@ -152,22 +156,27 @@ pub fn get_commit_date() -> Option<String> {
 }
 
 #[must_use]
-pub fn get_channel() -> String {
+pub fn get_compiler_version() -> Option<String> {
+    get_output("rustc", &["-V"])
+}
+
+#[must_use]
+pub fn get_channel(compiler_version: Option<String>) -> String {
     if let Ok(channel) = std::env::var("CFG_RELEASE_CHANNEL") {
         return channel;
     }
 
     // if that failed, try to ask rustc -V, do some parsing and find out
-    if let Some(rustc_output) = get_output("rustc", &["-V"]) {
+    if let Some(rustc_output) = compiler_version {
         if rustc_output.contains("beta") {
             return String::from("beta");
-        } else if rustc_output.contains("stable") {
-            return String::from("stable");
+        } else if rustc_output.contains("nightly") {
+            return String::from("nightly");
         }
     }
 
-    // default to nightly
-    String::from("nightly")
+    // default to stable
+    String::from("stable")
 }
 
 #[cfg(test)]
@@ -179,17 +188,19 @@ mod test {
         let vi = get_version_info!();
         assert_eq!(vi.major, 0);
         assert_eq!(vi.minor, 4);
-        assert_eq!(vi.patch, 0);
+        assert_eq!(vi.patch, 2);
         assert_eq!(vi.crate_name, "rustc_tools_util");
         // hard to make positive tests for these since they will always change
         assert!(vi.commit_hash.is_none());
         assert!(vi.commit_date.is_none());
+
+        assert!(vi.host_compiler.is_none());
     }
 
     #[test]
     fn test_display_local() {
         let vi = get_version_info!();
-        assert_eq!(vi.to_string(), "rustc_tools_util 0.4.0");
+        assert_eq!(vi.to_string(), "rustc_tools_util 0.4.2");
     }
 
     #[test]
@@ -198,7 +209,7 @@ mod test {
         let s = format!("{vi:?}");
         assert_eq!(
             s,
-            "VersionInfo { crate_name: \"rustc_tools_util\", major: 0, minor: 4, patch: 0 }"
+            "VersionInfo { crate_name: \"rustc_tools_util\", major: 0, minor: 4, patch: 2 }"
         );
     }
 }
diff --git a/src/tools/clippy/tests/compile-test.rs b/src/tools/clippy/tests/compile-test.rs
index d1b1a1d23232..f44cf7a7c25a 100644
--- a/src/tools/clippy/tests/compile-test.rs
+++ b/src/tools/clippy/tests/compile-test.rs
@@ -139,7 +139,7 @@ impl TestContext {
         }
     }
 
-    fn base_config(&self, test_dir: &str) -> Config {
+    fn base_config(&self, test_dir: &str, mandatory_annotations: bool) -> Config {
         let target_dir = PathBuf::from(var_os("CARGO_TARGET_DIR").unwrap_or_else(|| "target".into()));
         let mut config = Config {
             output_conflict_handling: OutputConflictHandling::Error,
@@ -153,7 +153,11 @@ impl TestContext {
         };
         let defaults = config.comment_defaults.base();
         defaults.exit_status = None.into();
-        defaults.require_annotations = None.into();
+        if mandatory_annotations {
+            defaults.require_annotations = Some(Spanned::dummy(true)).into();
+        } else {
+            defaults.require_annotations = None.into();
+        }
         defaults.diagnostic_code_prefix = Some(Spanned::dummy("clippy::".into())).into();
         defaults.set_custom("rustfix", RustfixMode::Everything);
         if let Some(collector) = self.diagnostic_collector.clone() {
@@ -197,7 +201,7 @@ impl TestContext {
 }
 
 fn run_ui(cx: &TestContext) {
-    let mut config = cx.base_config("ui");
+    let mut config = cx.base_config("ui", true);
     config
         .program
         .envs
@@ -216,7 +220,7 @@ fn run_internal_tests(cx: &TestContext) {
     if !RUN_INTERNAL_TESTS {
         return;
     }
-    let mut config = cx.base_config("ui-internal");
+    let mut config = cx.base_config("ui-internal", false);
     config.bless_command = Some("cargo uitest --features internal -- -- --bless".into());
 
     ui_test::run_tests_generic(
@@ -229,7 +233,7 @@ fn run_internal_tests(cx: &TestContext) {
 }
 
 fn run_ui_toml(cx: &TestContext) {
-    let mut config = cx.base_config("ui-toml");
+    let mut config = cx.base_config("ui-toml", true);
 
     config
         .comment_defaults
@@ -259,7 +263,7 @@ fn run_ui_cargo(cx: &TestContext) {
         return;
     }
 
-    let mut config = cx.base_config("ui-cargo");
+    let mut config = cx.base_config("ui-cargo", false);
     config.program.input_file_flag = CommandBuilder::cargo().input_file_flag;
     config.program.out_dir_flag = CommandBuilder::cargo().out_dir_flag;
     config.program.args = vec!["clippy".into(), "--color".into(), "never".into(), "--quiet".into()];
@@ -379,13 +383,15 @@ fn ui_cargo_toml_metadata() {
                 .map(|component| component.as_os_str().to_string_lossy().replace('-', "_"))
                 .any(|s| *s == name)
                 || path.starts_with(&cargo_common_metadata_path),
-            "{path:?} has incorrect package name"
+            "`{}` has incorrect package name",
+            path.display(),
         );
 
         let publish = package.get("publish").and_then(toml::Value::as_bool).unwrap_or(true);
         assert!(
             !publish || publish_exceptions.contains(&path.parent().unwrap().to_path_buf()),
-            "{path:?} lacks `publish = false`"
+            "`{}` lacks `publish = false`",
+            path.display(),
         );
     }
 }
diff --git a/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr b/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
index 4fe7f6f7a9ed..059427d8ee0f 100644
--- a/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
+++ b/src/tools/clippy/tests/ui-cargo/lint_groups_priority/fail/Cargo.stderr
@@ -11,8 +11,9 @@ error: lint group `rust_2018_idioms` has the same priority (0) as a lint
    = note: `#[deny(clippy::lint_groups_priority)]` on by default
 help: to have lints override the group set `rust_2018_idioms` to a lower priority
    |
-7  | rust_2018_idioms = { level = "warn", priority = -1 }
-   |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+7  - rust_2018_idioms = "warn"
+7  + rust_2018_idioms = { level = "warn", priority = -1 }
+   |
 
 error: lint group `unused` has the same priority (0) as a lint
   --> Cargo.toml:10:1
@@ -27,7 +28,7 @@ error: lint group `unused` has the same priority (0) as a lint
 help: to have lints override the group set `unused` to a lower priority
    |
 10 | unused = { level = "deny", priority = -1 }
-   |          ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+   |                          +++++++++++++++
 
 error: lint group `pedantic` has the same priority (-1) as a lint
   --> Cargo.toml:15:1
@@ -40,8 +41,9 @@ error: lint group `pedantic` has the same priority (-1) as a lint
    = note: the order of the lints in the table is ignored by Cargo
 help: to have lints override the group set `pedantic` to a lower priority
    |
-15 | pedantic = { level = "warn", priority = -2 }
-   |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+15 - pedantic = { level = "warn", priority = -1 }
+15 + pedantic = { level = "warn", priority = -2 }
+   |
 
 error: lint group `rust_2018_idioms` has the same priority (0) as a lint
   --> Cargo.toml:19:1
@@ -54,8 +56,9 @@ error: lint group `rust_2018_idioms` has the same priority (0) as a lint
    = note: the order of the lints in the table is ignored by Cargo
 help: to have lints override the group set `rust_2018_idioms` to a lower priority
    |
-19 | rust_2018_idioms = { level = "warn", priority = -1 }
-   |                    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+19 - rust_2018_idioms = "warn"
+19 + rust_2018_idioms = { level = "warn", priority = -1 }
+   |
 
 error: lint group `pedantic` has the same priority (0) as a lint
   --> Cargo.toml:23:1
@@ -68,7 +71,8 @@ error: lint group `pedantic` has the same priority (0) as a lint
    = note: the order of the lints in the table is ignored by Cargo
 help: to have lints override the group set `pedantic` to a lower priority
    |
-23 | pedantic = { level = "warn", priority = -1 }
-   |            ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+23 - pedantic = "warn"
+23 + pedantic = { level = "warn", priority = -1 }
+   |
 
 error: could not compile `fail` (lib) due to 5 previous errors
diff --git a/src/tools/clippy/tests/ui-internal/custom_ice_message.stderr b/src/tools/clippy/tests/ui-internal/custom_ice_message.stderr
index ae5d8ef1d0b5..801b0f340de9 100644
--- a/src/tools/clippy/tests/ui-internal/custom_ice_message.stderr
+++ b/src/tools/clippy/tests/ui-internal/custom_ice_message.stderr
@@ -14,7 +14,7 @@ note: rustc <version> running on <target>
 note: compiler flags: -Z ui-testing -Z deduplicate-diagnostics=no
 
 query stack during panic:
-#0 [early_lint_checks] perform lints prior to macro expansion
+#0 [early_lint_checks] perform lints prior to AST lowering
 #1 [hir_crate] getting the crate HIR
 ... and 3 other queries... use `env RUST_BACKTRACE=1` to see the full query stack
 note: Clippy version: foo
diff --git a/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.fixed b/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.fixed
index 928596d08091..7011ef518f20 100644
--- a/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.fixed
+++ b/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.fixed
@@ -9,7 +9,7 @@ extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_session;
 use clippy_utils::extract_msrv_attr;
-use clippy_utils::msrvs::Msrv;
+use clippy_utils::msrvs::MsrvStack;
 use rustc_hir::Expr;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 
@@ -20,18 +20,13 @@ declare_lint! {
 }
 
 struct Pass {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 
 impl_lint_pass!(Pass => [TEST_LINT]);
 
-impl LateLintPass<'_> for Pass {
-    extract_msrv_attr!(LateContext);
-    fn check_expr(&mut self, _: &LateContext<'_>, _: &Expr<'_>) {}
-}
-
 impl EarlyLintPass for Pass {
-    extract_msrv_attr!(EarlyContext);
+    extract_msrv_attr!();
     fn check_expr(&mut self, _: &EarlyContext<'_>, _: &rustc_ast::Expr) {}
 }
 
diff --git a/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.rs b/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.rs
index 50b28648ccc9..323061decd23 100644
--- a/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.rs
+++ b/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.rs
@@ -9,7 +9,7 @@ extern crate rustc_middle;
 #[macro_use]
 extern crate rustc_session;
 use clippy_utils::extract_msrv_attr;
-use clippy_utils::msrvs::Msrv;
+use clippy_utils::msrvs::MsrvStack;
 use rustc_hir::Expr;
 use rustc_lint::{EarlyContext, EarlyLintPass, LateContext, LateLintPass};
 
@@ -20,15 +20,11 @@ declare_lint! {
 }
 
 struct Pass {
-    msrv: Msrv,
+    msrv: MsrvStack,
 }
 
 impl_lint_pass!(Pass => [TEST_LINT]);
 
-impl LateLintPass<'_> for Pass {
-    fn check_expr(&mut self, _: &LateContext<'_>, _: &Expr<'_>) {}
-}
-
 impl EarlyLintPass for Pass {
     fn check_expr(&mut self, _: &EarlyContext<'_>, _: &rustc_ast::Expr) {}
 }
diff --git a/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.stderr b/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.stderr
index aa649c627a16..0a7636313eff 100644
--- a/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.stderr
+++ b/src/tools/clippy/tests/ui-internal/invalid_msrv_attr_impl.stderr
@@ -1,8 +1,8 @@
-error: `extract_msrv_attr!` macro missing from `LateLintPass` implementation
+error: `extract_msrv_attr!` macro missing from `EarlyLintPass` implementation
   --> tests/ui-internal/invalid_msrv_attr_impl.rs:28:1
    |
-LL | impl LateLintPass<'_> for Pass {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | impl EarlyLintPass for Pass {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
   --> tests/ui-internal/invalid_msrv_attr_impl.rs:1:9
@@ -10,23 +10,11 @@ note: the lint level is defined here
 LL | #![deny(clippy::internal)]
    |         ^^^^^^^^^^^^^^^^
    = note: `#[deny(clippy::missing_msrv_attr_impl)]` implied by `#[deny(clippy::internal)]`
-help: add `extract_msrv_attr!(LateContext)` to the `LateLintPass` implementation
+help: add `extract_msrv_attr!()` to the `EarlyLintPass` implementation
    |
-LL + impl LateLintPass<'_> for Pass {
-LL +     extract_msrv_attr!(LateContext);
+LL ~ impl EarlyLintPass for Pass {
+LL +     extract_msrv_attr!();
    |
 
-error: `extract_msrv_attr!` macro missing from `EarlyLintPass` implementation
-  --> tests/ui-internal/invalid_msrv_attr_impl.rs:32:1
-   |
-LL | impl EarlyLintPass for Pass {
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: add `extract_msrv_attr!(EarlyContext)` to the `EarlyLintPass` implementation
-   |
-LL + impl EarlyLintPass for Pass {
-LL +     extract_msrv_attr!(EarlyContext);
-   |
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr b/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr
index 6fc495f01808..b946514454aa 100644
--- a/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr
+++ b/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.default.stderr
@@ -1,11 +1,11 @@
 error: consider bringing this path into scope with the `use` keyword
-  --> tests/ui-toml/absolute_paths/absolute_paths_2015.rs:15:13
+  --> tests/ui-toml/absolute_paths/absolute_paths_2015.rs:16:13
    |
 LL |     let _ = ::m1::m2::X;
    |             ^^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> tests/ui-toml/absolute_paths/absolute_paths_2015.rs:6:9
+  --> tests/ui-toml/absolute_paths/absolute_paths_2015.rs:7:9
    |
 LL | #![deny(clippy::absolute_paths)]
    |         ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.rs b/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.rs
index 033c47809191..86981f979556 100644
--- a/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.rs
+++ b/src/tools/clippy/tests/ui-toml/absolute_paths/absolute_paths_2015.rs
@@ -1,6 +1,7 @@
 //@revisions: default allow_crates
 //@[default]rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/default
 //@[allow_crates]rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/absolute_paths/allow_crates
+//@[allow_crates]check-pass
 //@edition:2015
 
 #![deny(clippy::absolute_paths)]
diff --git a/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed b/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
index c04543da94b9..e12a94a4b205 100644
--- a/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
+++ b/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.fixed
@@ -7,8 +7,14 @@ fn main() {
     let local_opt: Option<i32> = Some(3);
 
     println!("val='{local_i32}'");
+    //~^ uninlined_format_args
     println!("Hello x is {local_f64:.local_i32$}");
+    //~^ uninlined_format_args
+    //~| print_literal
     println!("Hello {local_i32} is {local_f64:.*}", 5);
+    //~^ uninlined_format_args
     println!("Hello {local_i32} is {local_f64:.*}", 5);
+    //~^ uninlined_format_args
     println!("{local_i32}, {}", local_opt.unwrap());
+    //~^ uninlined_format_args
 }
diff --git a/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs b/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
index 813830d80b83..ad5aec133e91 100644
--- a/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
+++ b/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs
@@ -7,8 +7,14 @@ fn main() {
     let local_opt: Option<i32> = Some(3);
 
     println!("val='{}'", local_i32);
+    //~^ uninlined_format_args
     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
+    //~^ uninlined_format_args
+    //~| print_literal
     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
+    //~^ uninlined_format_args
     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
+    //~^ uninlined_format_args
     println!("{}, {}", local_i32, local_opt.unwrap());
+    //~^ uninlined_format_args
 }
diff --git a/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr b/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
index 73ef620bd12e..3ffe61b8ed72 100644
--- a/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
+++ b/src/tools/clippy/tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.stderr
@@ -13,7 +13,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:10:5
+  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:11:5
    |
 LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     println!("Hello {} is {local_f64:.local_i32$}", "x");
    |
 
 error: literal with an empty format string
-  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:10:35
+  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:11:35
    |
 LL |     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
    |                                   ^^^
@@ -39,7 +39,7 @@ LL +     println!("Hello x is {:.*}", local_i32, local_f64);
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:11:5
+  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:14:5
    |
 LL |     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:12:5
+  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:16:5
    |
 LL |     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -63,7 +63,7 @@ LL +     println!("Hello {local_i32} is {local_f64:.*}", 5);
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:13:5
+  --> tests/ui-toml/allow_mixed_uninlined_format_args/uninlined_format_args.rs:18:5
    |
 LL |     println!("{}, {}", local_i32, local_opt.unwrap());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good.rs b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good.rs
index e9bcc30c15e0..05eb40506db4 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good.rs
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good.rs
@@ -5,6 +5,11 @@
 //@[bad_conf_1] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/arbitrary_source_item_ordering/bad_conf_1
 //@[bad_conf_2] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/arbitrary_source_item_ordering/bad_conf_2
 //@[bad_conf_3] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/arbitrary_source_item_ordering/bad_conf_3
+//@[default] check-pass
+//@[default_exp] check-pass
+//@[bad_conf_1] error-in-other-file:
+//@[bad_conf_2] error-in-other-file:
+//@[bad_conf_3] error-in-other-file:
 
 #![allow(dead_code)]
 #![warn(clippy::arbitrary_source_item_ordering)]
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good_var_1.rs b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good_var_1.rs
index 0fccbd4790bc..fb2d2e64bcea 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good_var_1.rs
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_good_var_1.rs
@@ -1,6 +1,7 @@
 //@aux-build:../../ui/auxiliary/proc_macros.rs
 //@revisions: var_1
 //@[var_1] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/arbitrary_source_item_ordering/var_1
+//@check-pass
 
 #![allow(dead_code)]
 #![warn(clippy::arbitrary_source_item_ordering)]
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr
index ee2868869deb..3605952bddc9 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.default.stderr
@@ -1,11 +1,11 @@
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:21:14
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:22:14
    |
 LL | use std::rc::Weak;
    |              ^^^^
    |
 note: should be placed before `SNAKE_CASE`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:19:7
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:20:7
    |
 LL | const SNAKE_CASE: &str = "zzzzzzzz";
    |       ^^^^^^^^^^
@@ -13,18 +13,18 @@ LL | const SNAKE_CASE: &str = "zzzzzzzz";
    = help: to override `-D warnings` add `#[allow(clippy::arbitrary_source_item_ordering)]`
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:64:1
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:67:1
    |
 LL | / impl CloneSelf for StructOrdered {
+LL | |
 LL | |     fn clone_self(&self) -> Self {
 LL | |         Self {
-LL | |             a: true,
 ...  |
 LL | | }
    | |_^
    |
 note: should be placed before the following item
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:54:1
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:57:1
    |
 LL | / impl Default for StructOrdered {
 LL | |     fn default() -> Self {
@@ -35,55 +35,54 @@ LL | | }
    | |_^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:136:7
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:145:7
    |
 LL | const ZIS_SHOULD_BE_REALLY_EARLY: () = ();
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: should be placed before `TraitUnorderedItemKinds`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:124:7
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:132:7
    |
 LL | trait TraitUnorderedItemKinds {
    |       ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:151:1
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:163:1
    |
 LL | impl BasicEmptyTrait for StructOrdered {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: should be placed before the following item
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:138:1
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:148:1
    |
 LL | / impl TraitUnordered for StructUnordered {
 LL | |     const A: bool = false;
 LL | |     const C: bool = false;
 LL | |     const B: bool = false;
 ...  |
-LL | |     fn b() {}
 LL | | }
    | |_^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:170:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:184:5
    |
 LL | mod this_is_in_the_wrong_position {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: should be placed before `main`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:165:4
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:179:4
    |
 LL | fn main() {
    |    ^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:178:7
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:194:7
    |
 LL | const ZIS_SHOULD_BE_EVEN_EARLIER: () = ();
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: should be placed before `ZisShouldBeBeforeZeMainFn`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:176:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:192:8
    |
 LL | struct ZisShouldBeBeforeZeMainFn;
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -101,121 +100,121 @@ LL |     const BEFORE: i8 = 0;
    |           ^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:38:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:40:5
    |
 LL |     B,
    |     ^
    |
 note: should be placed before `C`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:37:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:39:5
    |
 LL |     C,
    |     ^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:88:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:92:5
    |
 LL |     b: bool,
    |     ^
    |
 note: should be placed before `c`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:87:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:91:5
    |
 LL |     c: bool,
    |     ^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:96:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:101:5
    |
 LL |     b: bool,
    |     ^
    |
 note: should be placed before `c`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:95:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:100:5
    |
 LL |     c: bool,
    |     ^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:115:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:121:11
    |
 LL |     const B: bool;
    |           ^
    |
 note: should be placed before `C`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:114:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:120:11
    |
 LL |     const C: bool;
    |           ^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:121:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:128:8
    |
 LL |     fn b();
    |        ^
    |
 note: should be placed before `c`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:120:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:127:8
    |
 LL |     fn c();
    |        ^
 
 error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:127:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:135:5
    |
 LL |     const A: bool;
    |     ^^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:125:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:133:5
    |
 LL |     type SomeType;
    |     ^^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:141:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:151:11
    |
 LL |     const B: bool = false;
    |           ^
    |
 note: should be placed before `C`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:140:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:150:11
    |
 LL |     const C: bool = false;
    |           ^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:147:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:158:8
    |
 LL |     fn b() {}
    |        ^
    |
 note: should be placed before `c`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:146:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:157:8
    |
 LL |     fn c() {}
    |        ^
 
 error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:156:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:169:5
    |
 LL |     const A: bool = false;
    |     ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:154:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:167:5
    |
 LL |     type SomeType = ();
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:172:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:187:11
    |
 LL |     const A: i8 = 1;
    |           ^
    |
 note: should be placed before `C`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:171:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs:186:11
    |
 LL |     const C: i8 = 0;
    |           ^
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs
index 2765bf935b7c..9e65a9cca0da 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed.rs
@@ -10,6 +10,7 @@ mod i_am_just_right {
     const BEFORE: i8 = 0;
 
     const AFTER: i8 = 0;
+    //~^ arbitrary_source_item_ordering
 }
 
 // Use statements should not be linted internally - this is normally auto-sorted using rustfmt.
@@ -19,6 +20,7 @@ use std::sync::{Arc, Barrier, RwLock};
 const SNAKE_CASE: &str = "zzzzzzzz";
 
 use std::rc::Weak;
+//~^ arbitrary_source_item_ordering
 
 trait BasicEmptyTrait {}
 
@@ -36,6 +38,7 @@ enum EnumUnordered {
     A,
     C,
     B,
+    //~^ arbitrary_source_item_ordering
 }
 
 #[allow(clippy::arbitrary_source_item_ordering)]
@@ -62,6 +65,7 @@ impl Default for StructOrdered {
 }
 
 impl CloneSelf for StructOrdered {
+    //~^ arbitrary_source_item_ordering
     fn clone_self(&self) -> Self {
         Self {
             a: true,
@@ -86,6 +90,7 @@ struct StructUnordered {
     a: bool,
     c: bool,
     b: bool,
+    //~^ arbitrary_source_item_ordering
     d: bool,
 }
 
@@ -94,6 +99,7 @@ struct StructUnorderedGeneric<T> {
     a: bool,
     c: bool,
     b: bool,
+    //~^ arbitrary_source_item_ordering
     d: bool,
 }
 
@@ -113,18 +119,21 @@ trait TraitUnordered {
     const A: bool;
     const C: bool;
     const B: bool;
+    //~^ arbitrary_source_item_ordering
 
     type SomeType;
 
     fn a();
     fn c();
     fn b();
+    //~^ arbitrary_source_item_ordering
 }
 
 trait TraitUnorderedItemKinds {
     type SomeType;
 
     const A: bool;
+    //~^ arbitrary_source_item_ordering
     const B: bool;
     const C: bool;
 
@@ -134,26 +143,31 @@ trait TraitUnorderedItemKinds {
 }
 
 const ZIS_SHOULD_BE_REALLY_EARLY: () = ();
+//~^ arbitrary_source_item_ordering
 
 impl TraitUnordered for StructUnordered {
     const A: bool = false;
     const C: bool = false;
     const B: bool = false;
+    //~^ arbitrary_source_item_ordering
 
     type SomeType = ();
 
     fn a() {}
     fn c() {}
     fn b() {}
+    //~^ arbitrary_source_item_ordering
 }
 
 // Trait impls should be located just after the type they implement it for.
 impl BasicEmptyTrait for StructOrdered {}
+//~^ arbitrary_source_item_ordering
 
 impl TraitUnorderedItemKinds for StructUnordered {
     type SomeType = ();
 
     const A: bool = false;
+    //~^ arbitrary_source_item_ordering
     const B: bool = false;
     const C: bool = false;
 
@@ -168,14 +182,17 @@ fn main() {
 
 /// Note that the linting pass is stopped before recursing into this module.
 mod this_is_in_the_wrong_position {
+    //~^ arbitrary_source_item_ordering
     const C: i8 = 0;
     const A: i8 = 1;
+    //~^ arbitrary_source_item_ordering
 }
 
 #[derive(Default, std::clone::Clone)]
 struct ZisShouldBeBeforeZeMainFn;
 
 const ZIS_SHOULD_BE_EVEN_EARLIER: () = ();
+//~^ arbitrary_source_item_ordering
 
 #[cfg(test)]
 mod test {
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs
index 44902336573c..96b2fb16f8f5 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs
@@ -103,20 +103,24 @@ impl TraitUnordered for StructUnordered {
     fn a() {}
     fn c() {}
     fn b() {}
+    //~^ arbitrary_source_item_ordering
 
     type SomeType = ();
 
     const A: bool = false;
     const C: bool = false;
     const B: bool = false;
+    //~^ arbitrary_source_item_ordering
 }
 
 impl TraitUnorderedItemKinds for StructUnordered {
     const A: bool = false;
 
     type SomeType = ();
+    //~^ arbitrary_source_item_ordering
 
     fn a() {}
+    //~^ arbitrary_source_item_ordering
 }
 
 struct StructUnorderedGeneric<T> {
@@ -143,20 +147,24 @@ trait TraitUnordered {
     fn a();
     fn c();
     fn b();
+    //~^ arbitrary_source_item_ordering
 
     type SomeType;
 
     const A: bool;
     const C: bool;
     const B: bool;
+    //~^ arbitrary_source_item_ordering
 }
 
 trait TraitUnorderedItemKinds {
     const A: bool;
 
     type SomeType;
+    //~^ arbitrary_source_item_ordering
 
     fn a();
+    //~^ arbitrary_source_item_ordering
 }
 
 #[derive(std::clone::Clone, Default)]
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr
index f31f7f68c17e..730f12c38a0d 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.var_1.stderr
@@ -13,85 +13,85 @@ LL |     fn c() {}
    = help: to override `-D warnings` add `#[allow(clippy::arbitrary_source_item_ordering)]`
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:111:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:112:11
    |
 LL |     const B: bool = false;
    |           ^
    |
 note: should be placed before `C`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:110:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:111:11
    |
 LL |     const C: bool = false;
    |           ^
 
 error: incorrect ordering of impl items (defined order: [Fn, Type, Const])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:117:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:119:5
    |
 LL |     type SomeType = ();
    |     ^^^^^^^^^^^^^^^^^^^
    |
 note: should be placed before `A`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:115:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:117:5
    |
 LL |     const A: bool = false;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: incorrect ordering of impl items (defined order: [Fn, Type, Const])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:119:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:122:5
    |
 LL |     fn a() {}
    |     ^^^^^^^^^
    |
 note: should be placed before `SomeType`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:117:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:119:5
    |
 LL |     type SomeType = ();
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:145:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:149:8
    |
 LL |     fn b();
    |        ^
    |
 note: should be placed before `c`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:144:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:148:8
    |
 LL |     fn c();
    |        ^
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:151:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:156:11
    |
 LL |     const B: bool;
    |           ^
    |
 note: should be placed before `C`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:150:11
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:155:11
    |
 LL |     const C: bool;
    |           ^
 
 error: incorrect ordering of trait items (defined order: [Fn, Type, Const])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:157:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:163:5
    |
 LL |     type SomeType;
    |     ^^^^^^^^^^^^^^
    |
 note: should be placed before `A`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:155:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:161:5
    |
 LL |     const A: bool;
    |     ^^^^^^^^^^^^^^
 
 error: incorrect ordering of trait items (defined order: [Fn, Type, Const])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:159:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:166:5
    |
 LL |     fn a();
    |     ^^^^^^^
    |
 note: should be placed before `SomeType`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:157:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_mixed_var_1.rs:163:5
    |
 LL |     type SomeType;
    |     ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_enum.rs b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_enum.rs
index e8002c4a1633..4e8ed5e550a3 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_enum.rs
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_enum.rs
@@ -20,6 +20,7 @@ enum EnumOrdered {
 enum EnumUnordered {
     B,
     A,
+    //~^ arbitrary_source_item_ordering
 }
 
 trait TraitUnordered {
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr
index 40348ecbdae1..77596ba23946 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.only_impl.stderr
@@ -13,7 +13,7 @@ LL |     fn b() {}
    = help: to override `-D warnings` add `#[allow(clippy::arbitrary_source_item_ordering)]`
 
 error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:45:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:46:5
    |
 LL |     type SomeType = i8;
    |     ^^^^^^^^^^^^^^^^^^^
@@ -25,13 +25,13 @@ LL |     fn a() {}
    |     ^^^^^^^^^
 
 error: incorrect ordering of impl items (defined order: [Const, Type, Fn])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:47:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:49:5
    |
 LL |     const A: bool = true;
    |     ^^^^^^^^^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:45:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs:46:5
    |
 LL |     type SomeType = i8;
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs
index bd969c865b5a..56e2e188be6a 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_impl.rs
@@ -41,10 +41,13 @@ trait TraitUnordered {
 impl BasicTrait for StructUnordered {
     fn b() {}
     fn a() {}
+    //~^ arbitrary_source_item_ordering
 
     type SomeType = i8;
+    //~^ arbitrary_source_item_ordering
 
     const A: bool = true;
+    //~^ arbitrary_source_item_ordering
 }
 
 trait TraitUnorderedItemKinds {
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr
index 9b86ebd48e3d..3d903330be8f 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.only_trait.stderr
@@ -13,25 +13,25 @@ LL |     const B: bool;
    = help: to override `-D warnings` add `#[allow(clippy::arbitrary_source_item_ordering)]`
 
 error: incorrect ordering of items (must be alphabetically ordered)
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:37:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:38:8
    |
 LL |     fn a();
    |        ^
    |
 note: should be placed before `b`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:36:8
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:37:8
    |
 LL |     fn b();
    |        ^
 
 error: incorrect ordering of trait items (defined order: [Const, Type, Fn])
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:43:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:45:5
    |
 LL |     const A: bool;
    |     ^^^^^^^^^^^^^^
    |
 note: should be placed before `SomeType`
-  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:41:5
+  --> tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs:43:5
    |
 LL |     type SomeType;
    |     ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs
index 979a52ecb100..d885a20ca50a 100644
--- a/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs
+++ b/src/tools/clippy/tests/ui-toml/arbitrary_source_item_ordering/ordering_only_trait.rs
@@ -30,17 +30,20 @@ enum EnumUnordered {
 trait TraitUnordered {
     const B: bool;
     const A: bool;
+    //~^ arbitrary_source_item_ordering
 
     type SomeType;
 
     fn b();
     fn a();
+    //~^ arbitrary_source_item_ordering
 }
 
 trait TraitUnorderedItemKinds {
     type SomeType;
 
     const A: bool;
+    //~^ arbitrary_source_item_ordering
 
     fn a();
 }
diff --git a/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs b/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
index 33f7c8ba8042..01a84a526c09 100644
--- a/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
+++ b/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs
@@ -67,6 +67,7 @@ fn lhs_and_rhs_are_equal() {
     let _ = Bar + Bar;
     // not on the list
     let _ = Baz + Baz;
+    //~^ arithmetic_side_effects
 }
 
 fn lhs_is_different() {
@@ -78,13 +79,16 @@ fn lhs_is_different() {
     let _ = 1i32 + Bar;
     // not on the list
     let _ = 1i32 + Baz;
+    //~^ arithmetic_side_effects
 
     // not on the list
     let _ = 1i64 + Foo;
+    //~^ arithmetic_side_effects
     // is implicitly on the list
     let _ = 1i64 + Bar;
     // not on the list
     let _ = 1i64 + Baz;
+    //~^ arithmetic_side_effects
 }
 
 fn rhs_is_different() {
@@ -96,13 +100,16 @@ fn rhs_is_different() {
     let _ = Bar + 1i32;
     // not on the list
     let _ = Baz + 1i32;
+    //~^ arithmetic_side_effects
 
     // not on the list
     let _ = Foo + 1i64;
+    //~^ arithmetic_side_effects
     // is implicitly on the list
     let _ = Bar + 1i64;
     // not on the list
     let _ = Baz + 1i64;
+    //~^ arithmetic_side_effects
 }
 
 fn unary() {
@@ -112,8 +119,10 @@ fn unary() {
     let _ = -Foo;
     // not on the list
     let _ = -Bar;
+    //~^ arithmetic_side_effects
     // not on the list
     let _ = -Baz;
+    //~^ arithmetic_side_effects
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr b/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr
index 3c5216023b54..93efcc01c88f 100644
--- a/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr
+++ b/src/tools/clippy/tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.stderr
@@ -8,49 +8,49 @@ LL |     let _ = Baz + Baz;
    = help: to override `-D warnings` add `#[allow(clippy::arithmetic_side_effects)]`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:80:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:81:13
    |
 LL |     let _ = 1i32 + Baz;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:83:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:85:13
    |
 LL |     let _ = 1i64 + Foo;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:87:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:90:13
    |
 LL |     let _ = 1i64 + Baz;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:98:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:102:13
    |
 LL |     let _ = Baz + 1i32;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:101:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:106:13
    |
 LL |     let _ = Foo + 1i64;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:105:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:111:13
    |
 LL |     let _ = Baz + 1i64;
    |             ^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:114:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:121:13
    |
 LL |     let _ = -Bar;
    |             ^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:116:13
+  --> tests/ui-toml/arithmetic_side_effects_allowed/arithmetic_side_effects_allowed.rs:124:13
    |
 LL |     let _ = -Baz;
    |             ^^^^
diff --git a/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.rs b/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.rs
index d36159e12639..b8652137378e 100644
--- a/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.rs
+++ b/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.rs
@@ -2,9 +2,11 @@
 #![warn(clippy::large_const_arrays, clippy::large_stack_arrays)]
 //@no-rustfix
 const ABOVE: [u8; 11] = [0; 11];
+//~^ large_const_arrays
 const BELOW: [u8; 10] = [0; 10];
 
 fn main() {
     let above = [0u8; 11];
+    //~^ large_stack_arrays
     let below = [0u8; 10];
 }
diff --git a/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.stderr b/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.stderr
index 41cb85b67df8..c962e8094076 100644
--- a/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.stderr
+++ b/src/tools/clippy/tests/ui-toml/array_size_threshold/array_size_threshold.stderr
@@ -10,7 +10,7 @@ LL | const ABOVE: [u8; 11] = [0; 11];
    = help: to override `-D warnings` add `#[allow(clippy::large_const_arrays)]`
 
 error: allocating a local array larger than 10 bytes
-  --> tests/ui-toml/array_size_threshold/array_size_threshold.rs:8:17
+  --> tests/ui-toml/array_size_threshold/array_size_threshold.rs:9:17
    |
 LL |     let above = [0u8; 11];
    |                 ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs
index 868cf00a8d46..6a9a49324db9 100644
--- a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs
+++ b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs
@@ -3,11 +3,13 @@ use std::net::Ipv4Addr;
 
 async fn bad() -> u32 {
     let _x = String::from("hello");
+    //~^ await_holding_invalid_type
     baz().await
 }
 
 async fn bad_reason() -> u32 {
     let x = Ipv4Addr::new(127, 0, 0, 1);
+    //~^ await_holding_invalid_type
     let y = baz().await;
     let _x = x;
     y
@@ -31,6 +33,7 @@ async fn baz() -> u32 {
 fn block_bad() -> impl std::future::Future<Output = u32> {
     async move {
         let _x = String::from("hi!");
+        //~^ await_holding_invalid_type
         baz().await
     }
 }
diff --git a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
index 39b8634be109..deb7f49db9e1 100644
--- a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
+++ b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.stderr
@@ -9,13 +9,13 @@ LL |     let _x = String::from("hello");
    = help: to override `-D warnings` add `#[allow(clippy::await_holding_invalid_type)]`
 
 error: holding a disallowed type across an await point `std::net::Ipv4Addr`
-  --> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:10:9
+  --> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:11:9
    |
 LL |     let x = Ipv4Addr::new(127, 0, 0, 1);
    |         ^
 
 error: holding a disallowed type across an await point `std::string::String`
-  --> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:33:13
+  --> tests/ui-toml/await_holding_invalid_type/await_holding_invalid_type.rs:35:13
    |
 LL |         let _x = String::from("hi!");
    |             ^^
diff --git a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/await_holding_invalid_type.rs b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/await_holding_invalid_type.rs
new file mode 100644
index 000000000000..b5a1f3def61e
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/await_holding_invalid_type.rs
@@ -0,0 +1,2 @@
+//@error-in-other-file:
+fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/await_holding_invalid_type.stderr b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/await_holding_invalid_type.stderr
new file mode 100644
index 000000000000..86e30409af06
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/await_holding_invalid_type.stderr
@@ -0,0 +1,11 @@
+error: error reading Clippy's configuration file: replacement not allowed for this configuration
+  --> $DIR/tests/ui-toml/await_holding_invalid_type_with_replacement/clippy.toml:1:31
+   |
+LL |   await-holding-invalid-types = [
+   |  _______________________________^
+LL | |     { path = "std::string::String", replacement = "std::net::Ipv4Addr" },
+LL | | ]
+   | |_^
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/clippy.toml b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/clippy.toml
new file mode 100644
index 000000000000..f6bc59672ed7
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/await_holding_invalid_type_with_replacement/clippy.toml
@@ -0,0 +1,3 @@
+await-holding-invalid-types = [
+    { path = "std::string::String", replacement = "std::net::Ipv4Addr" },
+]
diff --git a/src/tools/clippy/tests/ui-toml/borrow_interior_mutable_const/ignore.rs b/src/tools/clippy/tests/ui-toml/borrow_interior_mutable_const/ignore.rs
index 79c7cef6ce1b..0514419fd189 100644
--- a/src/tools/clippy/tests/ui-toml/borrow_interior_mutable_const/ignore.rs
+++ b/src/tools/clippy/tests/ui-toml/borrow_interior_mutable_const/ignore.rs
@@ -1,4 +1,5 @@
 //@compile-flags: --crate-name borrow_interior_mutable_const_ignore
+//@check-pass
 
 #![warn(clippy::borrow_interior_mutable_const)]
 #![allow(clippy::declare_interior_mutable_const)]
diff --git a/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.default.stderr b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.default.stderr
new file mode 100644
index 000000000000..2a6170b0bcdc
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.default.stderr
@@ -0,0 +1,11 @@
+error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.4.0`
+  --> tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.rs:14:5
+   |
+LL |     sleep(Duration::new(1, 0))
+   |     ^^^^^
+   |
+   = note: `-D clippy::incompatible-msrv` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::incompatible_msrv)]`
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.enabled.stderr b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.enabled.stderr
new file mode 100644
index 000000000000..8a85d38fba3c
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.enabled.stderr
@@ -0,0 +1,23 @@
+error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.4.0`
+  --> tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.rs:14:5
+   |
+LL |     sleep(Duration::new(1, 0))
+   |     ^^^^^
+   |
+   = note: `-D clippy::incompatible-msrv` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::incompatible_msrv)]`
+
+error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.4.0`
+  --> tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.rs:20:5
+   |
+LL |     sleep(Duration::new(1, 0));
+   |     ^^^^^
+
+error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.4.0`
+  --> tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.rs:28:9
+   |
+LL |         sleep(Duration::new(1, 0));
+   |         ^^^^^
+
+error: aborting due to 3 previous errors
+
diff --git a/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.rs b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.rs
new file mode 100644
index 000000000000..fed5f350b722
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/check_incompatible_msrv_in_tests.rs
@@ -0,0 +1,31 @@
+//@compile-flags: --test
+//@revisions: default enabled
+//@[enabled] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/check_incompatible_msrv_in_tests/enabled
+//@[default] rustc-env:CLIPPY_CONF_DIR=tests/ui-toml/check_incompatible_msrv_in_tests/default
+
+#![warn(clippy::incompatible_msrv)]
+#![feature(custom_inner_attributes)]
+#![clippy::msrv = "1.3.0"]
+
+use std::thread::sleep;
+use std::time::Duration;
+
+fn main() {
+    sleep(Duration::new(1, 0))
+    //~^ incompatible_msrv
+}
+
+#[test]
+fn test() {
+    sleep(Duration::new(1, 0));
+    //~[enabled]^ incompatible_msrv
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    fn helper() {
+        sleep(Duration::new(1, 0));
+        //~[enabled]^ incompatible_msrv
+    }
+}
diff --git a/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/default/clippy.toml b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/default/clippy.toml
new file mode 100644
index 000000000000..1d13759aceb7
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/default/clippy.toml
@@ -0,0 +1 @@
+# default config has check-incompatible-msrv-in-tests as false
diff --git a/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/enabled/clippy.toml b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/enabled/clippy.toml
new file mode 100644
index 000000000000..c56af6c82186
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/check_incompatible_msrv_in_tests/enabled/clippy.toml
@@ -0,0 +1 @@
+check-incompatible-msrv-in-tests = true
diff --git a/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs b/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
index 7f1c512d7c97..ecb43dc34a8a 100644
--- a/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
+++ b/src/tools/clippy/tests/ui-toml/conf_deprecated_key/conf_deprecated_key.rs
@@ -4,6 +4,7 @@ fn main() {}
 
 #[warn(clippy::cognitive_complexity)]
 fn cognitive_complexity() {
+    //~^ cognitive_complexity
     let x = vec![1, 2, 3];
     for i in x {
         if i == 1 {
diff --git a/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.fixed b/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.fixed
index d42b29ba21a6..a91414559324 100644
--- a/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.fixed
+++ b/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.fixed
@@ -4,20 +4,27 @@
 
 fn foo(n: u32) -> u32 {
     if let Some(n) = n.checked_sub(4) { n } else { n }
+    //~^ dbg_macro
 }
 
 fn factorial(n: u32) -> u32 {
     if n <= 1 {
+        //~^ dbg_macro
         1
+        //~^ dbg_macro
     } else {
         n * factorial(n - 1)
+        //~^ dbg_macro
     }
 }
 
 fn main() {
     42;
+    //~^ dbg_macro
     foo(3) + factorial(4);
+    //~^ dbg_macro
     (1, 2, 3, 4, 5);
+    //~^ dbg_macro
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.rs b/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.rs
index bd189b1576f9..6565f2e3cf7c 100644
--- a/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.rs
+++ b/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.rs
@@ -4,20 +4,27 @@
 
 fn foo(n: u32) -> u32 {
     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
+    //~^ dbg_macro
 }
 
 fn factorial(n: u32) -> u32 {
     if dbg!(n <= 1) {
+        //~^ dbg_macro
         dbg!(1)
+        //~^ dbg_macro
     } else {
         dbg!(n * factorial(n - 1))
+        //~^ dbg_macro
     }
 }
 
 fn main() {
     dbg!(42);
+    //~^ dbg_macro
     foo(3) + dbg!(factorial(4));
+    //~^ dbg_macro
     dbg!(1, 2, 3, 4, 5);
+    //~^ dbg_macro
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.stderr b/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.stderr
index f0d7104a57dd..4587d28c3f34 100644
--- a/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.stderr
+++ b/src/tools/clippy/tests/ui-toml/dbg_macro/dbg_macro.stderr
@@ -13,7 +13,7 @@ LL +     if let Some(n) = n.checked_sub(4) { n } else { n }
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui-toml/dbg_macro/dbg_macro.rs:10:8
+  --> tests/ui-toml/dbg_macro/dbg_macro.rs:11:8
    |
 LL |     if dbg!(n <= 1) {
    |        ^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     if n <= 1 {
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui-toml/dbg_macro/dbg_macro.rs:11:9
+  --> tests/ui-toml/dbg_macro/dbg_macro.rs:13:9
    |
 LL |         dbg!(1)
    |         ^^^^^^^
@@ -37,7 +37,7 @@ LL +         1
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui-toml/dbg_macro/dbg_macro.rs:13:9
+  --> tests/ui-toml/dbg_macro/dbg_macro.rs:16:9
    |
 LL |         dbg!(n * factorial(n - 1))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +         n * factorial(n - 1)
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui-toml/dbg_macro/dbg_macro.rs:18:5
+  --> tests/ui-toml/dbg_macro/dbg_macro.rs:22:5
    |
 LL |     dbg!(42);
    |     ^^^^^^^^
@@ -61,7 +61,7 @@ LL +     42;
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui-toml/dbg_macro/dbg_macro.rs:19:14
+  --> tests/ui-toml/dbg_macro/dbg_macro.rs:24:14
    |
 LL |     foo(3) + dbg!(factorial(4));
    |              ^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     foo(3) + factorial(4);
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui-toml/dbg_macro/dbg_macro.rs:20:5
+  --> tests/ui-toml/dbg_macro/dbg_macro.rs:26:5
    |
 LL |     dbg!(1, 2, 3, 4, 5);
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/declare_interior_mutable_const/ignore.rs b/src/tools/clippy/tests/ui-toml/declare_interior_mutable_const/ignore.rs
index 6385cf4f852f..49ffc7a939de 100644
--- a/src/tools/clippy/tests/ui-toml/declare_interior_mutable_const/ignore.rs
+++ b/src/tools/clippy/tests/ui-toml/declare_interior_mutable_const/ignore.rs
@@ -1,4 +1,5 @@
 //@compile-flags: --crate-name declare_interior_mutable_const_ignore
+//@check-pass
 
 #![warn(clippy::declare_interior_mutable_const)]
 #![allow(clippy::borrow_interior_mutable_const)]
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.rs b/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.rs
index e63a99e74cbb..cfe19606ef4a 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.rs
+++ b/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.rs
@@ -11,38 +11,54 @@ use serde::Serialize;
 
 fn main() {
     println!("one");
+    //~^ disallowed_macros
     println!("two");
+    //~^ disallowed_macros
     cfg!(unix);
+    //~^ disallowed_macros
     vec![1, 2, 3];
+    //~^ disallowed_macros
 
     #[derive(Serialize)]
+    //~^ disallowed_macros
     struct Derive;
 
     let _ = macros::expr!();
+    //~^ disallowed_macros
     macros::stmt!();
+    //~^ disallowed_macros
     let macros::pat!() = 1;
+    //~^ disallowed_macros
     let _: macros::ty!() = "";
+    //~^ disallowed_macros
     macros::item!();
+    //~^ disallowed_macros
     let _ = macros::binop!(1);
+    //~^ disallowed_macros
 
     eprintln!("allowed");
 }
 
 macros::attr! {
+//~^ disallowed_macros
     struct S;
 }
 
 impl S {
     macros::item!();
+    //~^ disallowed_macros
 }
 
 trait Y {
     macros::item!();
+    //~^ disallowed_macros
 }
 
 impl Y for S {
     macros::item!();
+    //~^ disallowed_macros
 }
 
 #[derive(Derive)]
+//~^ disallowed_macros
 struct Foo;
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr b/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
index 6a6c6168a1f5..589995fa87d9 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
+++ b/src/tools/clippy/tests/ui-toml/disallowed_macros/disallowed_macros.stderr
@@ -1,5 +1,5 @@
 error: use of a disallowed macro `serde::Serialize`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:18:14
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:22:14
    |
 LL |     #[derive(Serialize)]
    |              ^^^^^^^^^
@@ -9,15 +9,16 @@ LL |     #[derive(Serialize)]
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_macros)]`
 
 error: use of a disallowed macro `macros::attr`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:31:1
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:42:1
    |
 LL | / macros::attr! {
+LL | |
 LL | |     struct S;
 LL | | }
    | |_^
 
 error: use of a disallowed macro `proc_macros::Derive`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:47:10
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:62:10
    |
 LL | #[derive(Derive)]
    |          ^^^^^^
@@ -29,73 +30,73 @@ LL |     println!("one");
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `std::println`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:14:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:15:5
    |
 LL |     println!("two");
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `std::cfg`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:15:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:17:5
    |
 LL |     cfg!(unix);
    |     ^^^^^^^^^^
 
 error: use of a disallowed macro `std::vec`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:16:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:19:5
    |
 LL |     vec![1, 2, 3];
    |     ^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::expr`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:21:13
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:26:13
    |
 LL |     let _ = macros::expr!();
    |             ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::stmt`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:22:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:28:5
    |
 LL |     macros::stmt!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::pat`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:23:9
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:30:9
    |
 LL |     let macros::pat!() = 1;
    |         ^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::ty`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:24:12
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:32:12
    |
 LL |     let _: macros::ty!() = "";
    |            ^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:25:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:34:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::binop`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:26:13
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:36:13
    |
 LL |     let _ = macros::binop!(1);
    |             ^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:36:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:48:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:40:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:53:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
 
 error: use of a disallowed macro `macros::item`
-  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:44:5
+  --> tests/ui-toml/disallowed_macros/disallowed_macros.rs:58:5
    |
 LL |     macros::item!();
    |     ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.rs b/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.rs
index 61ae8de8e335..ea7e31a119dc 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.rs
+++ b/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.rs
@@ -3,8 +3,10 @@
 fn main() {
     // `foo` is part of the default configuration
     let foo = "bar";
+    //~^ disallowed_names
     // `ducks` was unrightfully disallowed
     let ducks = ["quack", "quack"];
+    //~^ disallowed_names
     // `fox` is okay
     let fox = ["what", "does", "the", "fox", "say", "?"];
 }
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.stderr b/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
index e6481c9cc63b..6b7a3fbd8c8d 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
+++ b/src/tools/clippy/tests/ui-toml/disallowed_names_append/disallowed_names.stderr
@@ -8,7 +8,7 @@ LL |     let foo = "bar";
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_names)]`
 
 error: use of a disallowed/placeholder name `ducks`
-  --> tests/ui-toml/disallowed_names_append/disallowed_names.rs:7:9
+  --> tests/ui-toml/disallowed_names_append/disallowed_names.rs:8:9
    |
 LL |     let ducks = ["quack", "quack"];
    |         ^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.rs b/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
index 61ae8de8e335..dd79795d76a2 100644
--- a/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
+++ b/src/tools/clippy/tests/ui-toml/disallowed_names_replace/disallowed_names.rs
@@ -5,6 +5,7 @@ fn main() {
     let foo = "bar";
     // `ducks` was unrightfully disallowed
     let ducks = ["quack", "quack"];
+    //~^ disallowed_names
     // `fox` is okay
     let fox = ["what", "does", "the", "fox", "say", "?"];
 }
diff --git a/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.fixed b/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.fixed
index f16e138da2be..e295712e85f4 100644
--- a/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.fixed
+++ b/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.fixed
@@ -7,6 +7,7 @@ fn allowed_name() {}
 fn default_name() {}
 
 /// `TestItemThingyOfCoolness` might sound cool but is not on the list and should be linted.
+//~^ doc_markdown
 fn unknown_name() {}
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.rs b/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.rs
index 327a592e9cad..192652a7f65b 100644
--- a/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.rs
+++ b/src/tools/clippy/tests/ui-toml/doc_valid_idents_append/doc_markdown.rs
@@ -7,6 +7,7 @@ fn allowed_name() {}
 fn default_name() {}
 
 /// TestItemThingyOfCoolness might sound cool but is not on the list and should be linted.
+//~^ doc_markdown
 fn unknown_name() {}
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.fixed b/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.fixed
index af6ec675e81b..48a6f5fe61e6 100644
--- a/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.fixed
+++ b/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.fixed
@@ -4,9 +4,12 @@
 fn allowed_name() {}
 
 /// `OAuth` and `LaTeX` are inside Clippy's default list.
+//~^ doc_markdown
+//~| doc_markdown
 fn default_name() {}
 
 /// `TestItemThingyOfCoolness` might sound cool but is not on the list and should be linted.
+//~^ doc_markdown
 fn unknown_name() {}
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs b/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs
index 327a592e9cad..f700c1ab0336 100644
--- a/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs
+++ b/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs
@@ -4,9 +4,12 @@
 fn allowed_name() {}
 
 /// OAuth and LaTeX are inside Clippy's default list.
+//~^ doc_markdown
+//~| doc_markdown
 fn default_name() {}
 
 /// TestItemThingyOfCoolness might sound cool but is not on the list and should be linted.
+//~^ doc_markdown
 fn unknown_name() {}
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr b/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr
index 9f2d7cf54e0d..e06b958a1b37 100644
--- a/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr
+++ b/src/tools/clippy/tests/ui-toml/doc_valid_idents_replace/doc_markdown.stderr
@@ -25,7 +25,7 @@ LL + /// OAuth and `LaTeX` are inside Clippy's default list.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs:9:5
+  --> tests/ui-toml/doc_valid_idents_replace/doc_markdown.rs:11:5
    |
 LL | /// TestItemThingyOfCoolness might sound cool but is not on the list and should be linted.
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs
index f328e4d9d04c..b5a1f3def61e 100644
--- a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs
+++ b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated/duplicated_keys.rs
@@ -1 +1,2 @@
+//@error-in-other-file:
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs
index f328e4d9d04c..b5a1f3def61e 100644
--- a/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs
+++ b/src/tools/clippy/tests/ui-toml/duplicated_keys_deprecated_2/duplicated_keys.rs
@@ -1 +1,2 @@
+//@error-in-other-file:
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs
index 858aab528a91..205cd8ba4ee8 100644
--- a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs
+++ b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.rs
@@ -23,6 +23,7 @@ static X: u32 = {
         let y = {
             let z = {
                 let w = { 3 };
+                //~^ excessive_nesting
                 w
             };
             z
@@ -69,6 +70,7 @@ impl A {
                 struct C;
 
                 impl C {
+                //~^ excessive_nesting
                     pub fn c() {}
                 }
             }
@@ -83,6 +85,7 @@ trait Lol {
         fn bb() {
             fn cc() {
                 let x = { 1 }; // not a warning, but cc is
+                //~^ excessive_nesting
             }
 
             let x = { 1 }; // warning
@@ -100,6 +103,7 @@ pub mod a {
         pub mod c {
             pub mod d {
                 pub mod e {
+                //~^ excessive_nesting
                     pub mod f {}
                 } // not here
             } // only warning should be here
@@ -113,13 +117,17 @@ fn main() {
     let a = A;
 
     a_but_not({{{{{{{{0}}}}}}}});
+    //~^ excessive_nesting
     a.a({{{{{{{{{0}}}}}}}}});
+    //~^ excessive_nesting
     (0, {{{{{{{1}}}}}}});
+    //~^ excessive_nesting
 
     if true {
         if true {
             if true {
                 if true {
+                //~^ excessive_nesting
                     if true {
 
                     }
@@ -132,6 +140,7 @@ fn main() {
         let x = (|| {
             let y = (|| {
                 let z = (|| {
+                //~^ excessive_nesting
                     let w = { 3 };
                     w
                 })();
@@ -151,38 +160,64 @@ fn main() {
     // this is a mess, but that's intentional
     let mut y = 1;
     y += {{{{{5}}}}};
+    //~^ excessive_nesting
     let z = y + {{{{{{{{{5}}}}}}}}};
+    //~^ excessive_nesting
     [0, {{{{{{{{{{0}}}}}}}}}}];
+    //~^ excessive_nesting
     let mut xx = [0; {{{{{{{{100}}}}}}}}];
+    //~^ excessive_nesting
     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
+    //~^ excessive_nesting
     &mut {{{{{{{{{{y}}}}}}}}}};
+    //~^ excessive_nesting
 
     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
+    //~^ excessive_nesting
+    //~| excessive_nesting
 
     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
+    //~^ excessive_nesting
+    //~| excessive_nesting
 
     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
+    //~^ excessive_nesting
+    //~| excessive_nesting
 
     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
+    //~^ excessive_nesting
 
     {{{{1;}}}}..{{{{{{3}}}}}};
+    //~^ excessive_nesting
+    //~| excessive_nesting
     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
+    //~^ excessive_nesting
+    //~| excessive_nesting
     ..{{{{{{{5}}}}}}};
+    //~^ excessive_nesting
     ..={{{{{3}}}}};
+    //~^ excessive_nesting
     {{{{{1;}}}}}..;
+    //~^ excessive_nesting
 
     loop { break {{{{1}}}} };
+    //~^ excessive_nesting
     loop {{{{{{}}}}}}
+    //~^ excessive_nesting
 
     match {{{{{{true}}}}}} {
+    //~^ excessive_nesting
         true => {{{{}}}},
+        //~^ excessive_nesting
         false => {{{{}}}},
+        //~^ excessive_nesting
     }
 
     {
         {
             {
                 {
+                //~^ excessive_nesting
                     println!("warning! :)");
                 }
             }
@@ -192,10 +227,12 @@ fn main() {
 
 async fn b() -> u32 {
     async fn c() -> u32 {{{{{{{0}}}}}}}
+    //~^ excessive_nesting
 
     c().await
 }
 
 async fn a() {
     {{{{b().await}}}};
+    //~^ excessive_nesting
 }
diff --git a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
index 9cf6fc66757d..bc2c4b8612ec 100644
--- a/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
+++ b/src/tools/clippy/tests/ui-toml/excessive_nesting/excessive_nesting.stderr
@@ -9,9 +9,10 @@ LL |                 let w = { 3 };
    = help: to override `-D warnings` add `#[allow(clippy::excessive_nesting)]`
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:71:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:72:17
    |
 LL | /                 impl C {
+LL | |
 LL | |                     pub fn c() {}
 LL | |                 }
    | |_________________^
@@ -19,7 +20,7 @@ LL | |                 }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:85:25
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:87:25
    |
 LL |                 let x = { 1 }; // not a warning, but cc is
    |                         ^^^^^
@@ -27,9 +28,10 @@ LL |                 let x = { 1 }; // not a warning, but cc is
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:102:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:105:17
    |
 LL | /                 pub mod e {
+LL | |
 LL | |                     pub mod f {}
 LL | |                 } // not here
    | |_________________^
@@ -37,7 +39,7 @@ LL | |                 } // not here
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:115:18
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:119:18
    |
 LL |     a_but_not({{{{{{{{0}}}}}}}});
    |                  ^^^^^^^^^^^
@@ -45,7 +47,7 @@ LL |     a_but_not({{{{{{{{0}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:116:12
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:121:12
    |
 LL |     a.a({{{{{{{{{0}}}}}}}}});
    |            ^^^^^^^^^^^^^
@@ -53,7 +55,7 @@ LL |     a.a({{{{{{{{{0}}}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:117:12
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:123:12
    |
 LL |     (0, {{{{{{{1}}}}}}});
    |            ^^^^^^^^^
@@ -61,10 +63,11 @@ LL |     (0, {{{{{{{1}}}}}}});
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:122:25
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:129:25
    |
 LL |                   if true {
    |  _________________________^
+LL | |
 LL | |                     if true {
 ...  |
 LL | |                 }
@@ -73,10 +76,11 @@ LL | |                 }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:134:29
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:142:29
    |
 LL |                   let z = (|| {
    |  _____________________________^
+LL | |
 LL | |                     let w = { 3 };
 LL | |                     w
 LL | |                 })();
@@ -85,7 +89,7 @@ LL | |                 })();
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:153:13
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:13
    |
 LL |     y += {{{{{5}}}}};
    |             ^^^^^
@@ -93,7 +97,7 @@ LL |     y += {{{{{5}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:154:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:20
    |
 LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    |                    ^^^^^^^^^^^^^
@@ -101,7 +105,7 @@ LL |     let z = y + {{{{{{{{{5}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:155:12
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:166:12
    |
 LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    |            ^^^^^^^^^^^^^^^
@@ -109,7 +113,7 @@ LL |     [0, {{{{{{{{{{0}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:156:25
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:25
    |
 LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    |                         ^^^^^^^^^^^^^
@@ -117,7 +121,7 @@ LL |     let mut xx = [0; {{{{{{{{100}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:157:11
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:170:11
    |
 LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -125,7 +129,7 @@ LL |     xx[{{{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}}}];
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:158:13
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:172:13
    |
 LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    |             ^^^^^^^^^^^^^^^
@@ -133,7 +137,7 @@ LL |     &mut {{{{{{{{{{y}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:175:17
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                 ^^^^
@@ -141,7 +145,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:160:28
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:175:28
    |
 LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    |                            ^^^^^^^^^^
@@ -149,7 +153,7 @@ LL |     for i in {{{{xx}}}} {{{{{{{{}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:28
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:179:28
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                            ^^^^^^^^^^^^^
@@ -157,7 +161,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:162:48
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:179:48
    |
 LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    |                                                ^^^^^^^^
@@ -165,7 +169,7 @@ LL |     while let Some(i) = {{{{{{Some(1)}}}}}} {{{{{{{}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:14
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:183:14
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |              ^^^^^^^^^^^^^^
@@ -173,7 +177,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:164:35
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:183:35
    |
 LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    |                                   ^^^^^^^^^^^^
@@ -181,7 +185,7 @@ LL |     while {{{{{{{{true}}}}}}}} {{{{{{{{{}}}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:166:23
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:187:23
    |
 LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -189,7 +193,7 @@ LL |     let d = D { d: {{{{{{{{{{{{{{{{{{{{{{{3}}}}}}}}}}}}}}}}}}}}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:190:8
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |        ^^^^
@@ -197,7 +201,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:168:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:190:20
    |
 LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    |                    ^^^^^^^
@@ -205,7 +209,7 @@ LL |     {{{{1;}}}}..{{{{{{3}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:169:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:193:8
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |        ^^^^
@@ -213,7 +217,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:169:21
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:193:21
    |
 LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -221,7 +225,7 @@ LL |     {{{{1;}}}}..={{{{{{{{{{{{{{{{{{{{{{{{{{6}}}}}}}}}}}}}}}}}}}}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:170:10
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:196:10
    |
 LL |     ..{{{{{{{5}}}}}}};
    |          ^^^^^^^^^
@@ -229,7 +233,7 @@ LL |     ..{{{{{{{5}}}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:171:11
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:198:11
    |
 LL |     ..={{{{{3}}}}};
    |           ^^^^^
@@ -237,7 +241,7 @@ LL |     ..={{{{{3}}}}};
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:172:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:200:8
    |
 LL |     {{{{{1;}}}}}..;
    |        ^^^^^^
@@ -245,7 +249,7 @@ LL |     {{{{{1;}}}}}..;
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:174:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:203:20
    |
 LL |     loop { break {{{{1}}}} };
    |                    ^^^^^
@@ -253,7 +257,7 @@ LL |     loop { break {{{{1}}}} };
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:175:13
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:205:13
    |
 LL |     loop {{{{{{}}}}}}
    |             ^^^^^^
@@ -261,7 +265,7 @@ LL |     loop {{{{{{}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:177:14
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:208:14
    |
 LL |     match {{{{{{true}}}}}} {
    |              ^^^^^^^^^^
@@ -269,7 +273,7 @@ LL |     match {{{{{{true}}}}}} {
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:178:20
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:210:20
    |
 LL |         true => {{{{}}}},
    |                    ^^
@@ -277,7 +281,7 @@ LL |         true => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:179:21
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:212:21
    |
 LL |         false => {{{{}}}},
    |                     ^^
@@ -285,9 +289,10 @@ LL |         false => {{{{}}}},
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:185:17
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:219:17
    |
 LL | /                 {
+LL | |
 LL | |                     println!("warning! :)");
 LL | |                 }
    | |_________________^
@@ -295,7 +300,7 @@ LL | |                 }
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:194:28
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:229:28
    |
 LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    |                            ^^^^^^^^^
@@ -303,7 +308,7 @@ LL |     async fn c() -> u32 {{{{{{{0}}}}}}}
    = help: try refactoring your code to minimize nesting
 
 error: this block is too nested
-  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:200:8
+  --> tests/ui-toml/excessive_nesting/excessive_nesting.rs:236:8
    |
 LL |     {{{{b().await}}}};
    |        ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/expect_used/clippy.toml b/src/tools/clippy/tests/ui-toml/expect_used/clippy.toml
index 6933b8164195..895de8357cf7 100644
--- a/src/tools/clippy/tests/ui-toml/expect_used/clippy.toml
+++ b/src/tools/clippy/tests/ui-toml/expect_used/clippy.toml
@@ -1 +1,2 @@
+allow-expect-in-consts = false
 allow-expect-in-tests = true
diff --git a/src/tools/clippy/tests/ui-toml/expect_used/expect_used.rs b/src/tools/clippy/tests/ui-toml/expect_used/expect_used.rs
index 206788e19f02..9955c9b6baa1 100644
--- a/src/tools/clippy/tests/ui-toml/expect_used/expect_used.rs
+++ b/src/tools/clippy/tests/ui-toml/expect_used/expect_used.rs
@@ -1,20 +1,31 @@
 //@compile-flags: --test
+//@no-rustfix
 #![warn(clippy::expect_used)]
 #![allow(clippy::unnecessary_literal_unwrap)]
 
 fn expect_option() {
     let opt = Some(0);
     let _ = opt.expect("");
+    //~^ expect_used
 }
 
 fn expect_result() {
     let res: Result<u8, ()> = Ok(0);
     let _ = res.expect("");
+    //~^ expect_used
 }
 
 fn main() {
     expect_option();
     expect_result();
+
+    const SOME: Option<i32> = Some(3);
+    const UNWRAPPED: i32 = SOME.expect("Not three?");
+    //~^ expect_used
+    const {
+        SOME.expect("Still not three?");
+        //~^ expect_used
+    }
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui-toml/expect_used/expect_used.stderr b/src/tools/clippy/tests/ui-toml/expect_used/expect_used.stderr
index 81691f8ac6c0..3bb471e6dfcc 100644
--- a/src/tools/clippy/tests/ui-toml/expect_used/expect_used.stderr
+++ b/src/tools/clippy/tests/ui-toml/expect_used/expect_used.stderr
@@ -1,5 +1,5 @@
 error: used `expect()` on an `Option` value
-  --> tests/ui-toml/expect_used/expect_used.rs:7:13
+  --> tests/ui-toml/expect_used/expect_used.rs:8:13
    |
 LL |     let _ = opt.expect("");
    |             ^^^^^^^^^^^^^^
@@ -9,12 +9,28 @@ LL |     let _ = opt.expect("");
    = help: to override `-D warnings` add `#[allow(clippy::expect_used)]`
 
 error: used `expect()` on a `Result` value
-  --> tests/ui-toml/expect_used/expect_used.rs:12:13
+  --> tests/ui-toml/expect_used/expect_used.rs:14:13
    |
 LL |     let _ = res.expect("");
    |             ^^^^^^^^^^^^^^
    |
    = note: if this value is an `Err`, it will panic
 
-error: aborting due to 2 previous errors
+error: used `expect()` on an `Option` value
+  --> tests/ui-toml/expect_used/expect_used.rs:23:28
+   |
+LL |     const UNWRAPPED: i32 = SOME.expect("Not three?");
+   |                            ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: if this value is `None`, it will panic
+
+error: used `expect()` on an `Option` value
+  --> tests/ui-toml/expect_used/expect_used.rs:26:9
+   |
+LL |         SOME.expect("Still not three?");
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: if this value is `None`, it will panic
+
+error: aborting due to 4 previous errors
 
diff --git a/src/tools/clippy/tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs b/src/tools/clippy/tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs
index 5655232455cb..1256c93c0fa1 100644
--- a/src/tools/clippy/tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs
+++ b/src/tools/clippy/tests/ui-toml/extra_unused_type_parameters/extra_unused_type_parameters.rs
@@ -1,3 +1,4 @@
+//@check-pass
 pub struct S;
 
 impl S {
diff --git a/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.rs b/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.rs
index 42897b389edf..af8b8a7991ab 100644
--- a/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.rs
+++ b/src/tools/clippy/tests/ui-toml/fn_params_excessive_bools/test.rs
@@ -2,5 +2,6 @@
 
 fn f(_: bool) {}
 fn g(_: bool, _: bool) {}
+//~^ fn_params_excessive_bools
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/functions_maxlines/test.rs b/src/tools/clippy/tests/ui-toml/functions_maxlines/test.rs
index 4ac0378544c7..09d76a9b2657 100644
--- a/src/tools/clippy/tests/ui-toml/functions_maxlines/test.rs
+++ b/src/tools/clippy/tests/ui-toml/functions_maxlines/test.rs
@@ -17,18 +17,21 @@ fn many_comments_but_one_line_of_code() {
 
 // This should be considered two and a fail.
 fn too_many_lines() {
+    //~^ too_many_lines
     println!("This is bad.");
     println!("This is bad.");
 }
 
 // This should only fail once (#7517).
 async fn async_too_many_lines() {
+    //~^ too_many_lines
     println!("This is bad.");
     println!("This is bad.");
 }
 
 // This should fail only once, without failing on the closure.
 fn closure_too_many_lines() {
+    //~^ too_many_lines
     let _ = {
         println!("This is bad.");
         println!("This is bad.");
@@ -51,6 +54,7 @@ fn comment_after_code() {
 // This should fail since it is technically two lines.
 #[rustfmt::skip]
 fn comment_before_code() {
+//~^ too_many_lines
     let _ = "test";
     /* This comment extends to the front of
     the code but this line should still count. */ let _ = 5;
diff --git a/src/tools/clippy/tests/ui-toml/functions_maxlines/test.stderr b/src/tools/clippy/tests/ui-toml/functions_maxlines/test.stderr
index cb188a868c44..14a49cb76c1c 100644
--- a/src/tools/clippy/tests/ui-toml/functions_maxlines/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/functions_maxlines/test.stderr
@@ -2,6 +2,7 @@ error: this function has too many lines (2/1)
   --> tests/ui-toml/functions_maxlines/test.rs:19:1
    |
 LL | / fn too_many_lines() {
+LL | |
 LL | |     println!("This is bad.");
 LL | |     println!("This is bad.");
 LL | | }
@@ -11,18 +12,20 @@ LL | | }
    = help: to override `-D warnings` add `#[allow(clippy::too_many_lines)]`
 
 error: this function has too many lines (4/1)
-  --> tests/ui-toml/functions_maxlines/test.rs:25:1
+  --> tests/ui-toml/functions_maxlines/test.rs:26:1
    |
 LL | / async fn async_too_many_lines() {
+LL | |
 LL | |     println!("This is bad.");
 LL | |     println!("This is bad.");
 LL | | }
    | |_^
 
 error: this function has too many lines (4/1)
-  --> tests/ui-toml/functions_maxlines/test.rs:31:1
+  --> tests/ui-toml/functions_maxlines/test.rs:33:1
    |
 LL | / fn closure_too_many_lines() {
+LL | |
 LL | |     let _ = {
 LL | |         println!("This is bad.");
 LL | |         println!("This is bad.");
@@ -31,9 +34,10 @@ LL | | }
    | |_^
 
 error: this function has too many lines (2/1)
-  --> tests/ui-toml/functions_maxlines/test.rs:53:1
+  --> tests/ui-toml/functions_maxlines/test.rs:56:1
    |
 LL | / fn comment_before_code() {
+LL | |
 LL | |     let _ = "test";
 LL | |     /* This comment extends to the front of
 LL | |     the code but this line should still count. */ let _ = 5;
diff --git a/src/tools/clippy/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs b/src/tools/clippy/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs
index f328e4d9d04c..9763a0977801 100644
--- a/src/tools/clippy/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs
+++ b/src/tools/clippy/tests/ui-toml/good_toml_no_false_negatives/conf_no_false_negatives.rs
@@ -1 +1,2 @@
+//@check-pass
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs b/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
index 4882416c414a..e953a2a4e90b 100644
--- a/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
+++ b/src/tools/clippy/tests/ui-toml/ifs_same_cond/ifs_same_cond.rs
@@ -13,6 +13,7 @@ fn issue10272() {
     if x.get() {
     } else if !x.take() {
     } else if x.get() {
+        //~^ ifs_same_cond
     } else {
     }
 }
diff --git a/src/tools/clippy/tests/ui-toml/indexing_slicing/indexing_slicing.rs b/src/tools/clippy/tests/ui-toml/indexing_slicing/indexing_slicing.rs
index 0a0da88ea1fa..dd741be91d29 100644
--- a/src/tools/clippy/tests/ui-toml/indexing_slicing/indexing_slicing.rs
+++ b/src/tools/clippy/tests/ui-toml/indexing_slicing/indexing_slicing.rs
@@ -6,6 +6,7 @@ fn main() {
     let x = [1, 2, 3, 4];
     let index: usize = 1;
     &x[index..];
+    //~^ indexing_slicing
 }
 
 #[cfg(test)]
diff --git a/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes/item_name_repetitions.rs b/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes/item_name_repetitions.rs
index 2ae673a6def0..d6b0a3017920 100644
--- a/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes/item_name_repetitions.rs
+++ b/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes/item_name_repetitions.rs
@@ -7,6 +7,7 @@ pub mod foo {
 
     // this line should produce a warning:
     pub fn to_foo() {}
+    //~^ module_name_repetitions
 
     // but this line shouldn't
     pub fn bar_foo() {}
diff --git a/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes_extend/item_name_repetitions.rs b/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes_extend/item_name_repetitions.rs
index dbd61992c0d6..347430f3d2f9 100644
--- a/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes_extend/item_name_repetitions.rs
+++ b/src/tools/clippy/tests/ui-toml/item_name_repetitions/allowed_prefixes_extend/item_name_repetitions.rs
@@ -7,6 +7,7 @@ pub mod foo {
 
     // this line should produce a warning:
     pub fn something_foo() {}
+    //~^ module_name_repetitions
 
     // but none of the following should:
     pub fn bar_foo() {}
diff --git a/src/tools/clippy/tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs b/src/tools/clippy/tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs
index b633dcbd19e4..f05e2410f7e2 100644
--- a/src/tools/clippy/tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs
+++ b/src/tools/clippy/tests/ui-toml/item_name_repetitions/threshold0/item_name_repetitions.rs
@@ -1,3 +1,5 @@
+//@check-pass
+
 struct Data {}
 
 enum Actions {}
diff --git a/src/tools/clippy/tests/ui-toml/large_futures/large_futures.fixed b/src/tools/clippy/tests/ui-toml/large_futures/large_futures.fixed
index 7dea9fb95b4b..17d6553a283b 100644
--- a/src/tools/clippy/tests/ui-toml/large_futures/large_futures.fixed
+++ b/src/tools/clippy/tests/ui-toml/large_futures/large_futures.fixed
@@ -16,6 +16,7 @@ pub async fn should_not_warn() {
 
 pub async fn bar() {
     Box::pin(should_warn()).await;
+    //~^ large_futures
 
     async {
         let x = [0u8; 1024];
diff --git a/src/tools/clippy/tests/ui-toml/large_futures/large_futures.rs b/src/tools/clippy/tests/ui-toml/large_futures/large_futures.rs
index 4158df8b5ff5..bc601227e562 100644
--- a/src/tools/clippy/tests/ui-toml/large_futures/large_futures.rs
+++ b/src/tools/clippy/tests/ui-toml/large_futures/large_futures.rs
@@ -16,6 +16,7 @@ pub async fn should_not_warn() {
 
 pub async fn bar() {
     should_warn().await;
+    //~^ large_futures
 
     async {
         let x = [0u8; 1024];
diff --git a/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.rs b/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.rs
index 184c6d17ba41..685ef1689e72 100644
--- a/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.rs
+++ b/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.rs
@@ -2,7 +2,7 @@
 #![allow(clippy::literal_string_with_formatting_args)]
 
 // Good
-const GOOD_INCLUDE_BYTES: &[u8; 68] = include_bytes!("../../ui/author.rs");
+const GOOD_INCLUDE_BYTES: &[u8; 84] = include_bytes!("../../ui/author.rs");
 const GOOD_INCLUDE_STR: &str = include_str!("../../ui/author.rs");
 
 #[allow(clippy::large_include_file)]
diff --git a/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.stderr b/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.stderr
index 82b926cc53ba..c9f0e661dbd1 100644
--- a/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.stderr
+++ b/src/tools/clippy/tests/ui-toml/large_include_file/large_include_file.stderr
@@ -1,3 +1,13 @@
+error: attempted to include a large file
+  --> tests/ui-toml/large_include_file/large_include_file.rs:19:1
+   |
+LL | #[doc = include_str!("too_big.txt")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the configuration allows a maximum size of 600 bytes
+   = note: `-D clippy::large-include-file` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::large_include_file)]`
+
 error: attempted to include a large file
   --> tests/ui-toml/large_include_file/large_include_file.rs:14:43
    |
@@ -5,8 +15,6 @@ LL | const TOO_BIG_INCLUDE_BYTES: &[u8; 654] = include_bytes!("too_big.txt");
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = note: the configuration allows a maximum size of 600 bytes
-   = note: `-D clippy::large-include-file` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::large_include_file)]`
 
 error: attempted to include a large file
   --> tests/ui-toml/large_include_file/large_include_file.rs:16:35
@@ -16,13 +24,5 @@ LL | const TOO_BIG_INCLUDE_STR: &str = include_str!("too_big.txt");
    |
    = note: the configuration allows a maximum size of 600 bytes
 
-error: attempted to include a large file
-  --> tests/ui-toml/large_include_file/large_include_file.rs:19:1
-   |
-LL | #[doc = include_str!("too_big.txt")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-   = note: the configuration allows a maximum size of 600 bytes
-
 error: aborting due to 3 previous errors
 
diff --git a/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.fixed b/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.fixed
index f013153f5166..2d76824128bf 100644
--- a/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.fixed
+++ b/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.fixed
@@ -17,7 +17,9 @@ fn main() {
 
     // due to clippy::inconsistent-digit-grouping
     let _fail1 = 100_200_300.123_456_789;
+    //~^ inconsistent_digit_grouping
 
     // fail due to the integer part
     let _fail2 = 100_200_300.300_200_100;
+    //~^ unreadable_literal
 }
diff --git a/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.rs b/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.rs
index bd5110138c8c..b42e31085217 100644
--- a/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.rs
+++ b/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.rs
@@ -17,7 +17,9 @@ fn main() {
 
     // due to clippy::inconsistent-digit-grouping
     let _fail1 = 100_200_300.123456789;
+    //~^ inconsistent_digit_grouping
 
     // fail due to the integer part
     let _fail2 = 100200300.300200100;
+    //~^ unreadable_literal
 }
diff --git a/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.stderr b/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.stderr
index 766722d35ab7..c4e164c67ed8 100644
--- a/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/lint_decimal_readability/test.stderr
@@ -8,7 +8,7 @@ LL |     let _fail1 = 100_200_300.123456789;
    = help: to override `-D warnings` add `#[allow(clippy::inconsistent_digit_grouping)]`
 
 error: long literal lacking separators
-  --> tests/ui-toml/lint_decimal_readability/test.rs:22:18
+  --> tests/ui-toml/lint_decimal_readability/test.rs:23:18
    |
 LL |     let _fail2 = 100200300.300200100;
    |                  ^^^^^^^^^^^^^^^^^^^ help: consider: `100_200_300.300_200_100`
diff --git a/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
index 3dafea56514d..2465fe45645f 100644
--- a/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
+++ b/src/tools/clippy/tests/ui-toml/macro_metavars_in_unsafe/default/test.rs
@@ -17,7 +17,7 @@ macro_rules! allow_works {
 macro_rules! simple {
     ($v:expr) => {
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+            //~^ macro_metavars_in_unsafe
             dbg!($v);
         }
     };
@@ -28,7 +28,7 @@ macro_rules! simple {
 macro_rules! raw_symbol {
     ($r#mod:expr, $r#unsafe:expr) => {
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+        //~^ macro_metavars_in_unsafe
             $r#mod;
         }
         $r#unsafe;
@@ -40,7 +40,7 @@ macro_rules! multilevel_unsafe {
     ($v:expr) => {
         unsafe {
             unsafe {
-                //~^ ERROR: this macro expands metavariables in an unsafe block
+                //~^ macro_metavars_in_unsafe
                 $v;
             }
         }
@@ -65,7 +65,7 @@ macro_rules! in_function_with_unsafe {
         unsafe {
             fn f() {
                 unsafe {
-                    //~^ ERROR: this macro expands metavariables in an unsafe block
+                    //~^ macro_metavars_in_unsafe
                     $v;
                 }
             }
@@ -93,7 +93,7 @@ macro_rules! const_generic_in_struct {
                 const M: i32 = {
                     1;
                     unsafe { $inside_unsafe }
-                    //~^ ERROR: this macro expands metavariables in an unsafe block
+                    //~^ macro_metavars_in_unsafe
                 },
                 const N: i32 = { $outside_unsafe },
             >;
@@ -108,7 +108,7 @@ macro_rules! fn_with_const_generic {
             fn f<const N: usize>() {
                 $outside_unsafe;
                 unsafe {
-                    //~^ ERROR: this macro expands metavariables in an unsafe block
+                    //~^ macro_metavars_in_unsafe
                     $inside_unsafe;
                 }
             }
@@ -120,7 +120,7 @@ macro_rules! fn_with_const_generic {
 macro_rules! variables {
     ($inside_unsafe:expr, $outside_unsafe:expr) => {
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+            //~^ macro_metavars_in_unsafe
             $inside_unsafe;
             let inside_unsafe = 1;
             inside_unsafe;
@@ -135,7 +135,7 @@ macro_rules! variables {
 macro_rules! multiple_matchers {
     ($inside_unsafe:expr, $outside_unsafe:expr) => {
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+        //~^ macro_metavars_in_unsafe
             $inside_unsafe;
         }
         $outside_unsafe;
@@ -144,7 +144,7 @@ macro_rules! multiple_matchers {
         $(
             $v;
             unsafe {
-                //~^ ERROR: this macro expands metavariables in an unsafe block
+            //~^ macro_metavars_in_unsafe
                 $x;
             }
         );+
@@ -156,11 +156,11 @@ macro_rules! multiple_unsafe_blocks {
     ($w:expr, $x:expr, $y:expr) => {
         $w;
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+            //~^ macro_metavars_in_unsafe
             $x;
         }
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+            //~^ macro_metavars_in_unsafe
             $x;
             $y;
         }
@@ -169,7 +169,7 @@ macro_rules! multiple_unsafe_blocks {
 
 pub macro macro2_0($v:expr) {
     unsafe {
-        //~^ ERROR: this macro expands metavariables in an unsafe block
+        //~^ macro_metavars_in_unsafe
         $v;
     }
 }
@@ -220,7 +220,7 @@ macro_rules! unsafe_from_root_ctxt {
 macro_rules! nested_macro_helper {
     ($v:expr) => {{
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+            //~^ macro_metavars_in_unsafe
             $v;
         }
     }};
@@ -230,7 +230,7 @@ macro_rules! nested_macro_helper {
 macro_rules! nested_macros {
     ($v:expr, $v2:expr) => {{
         unsafe {
-            //~^ ERROR: this macro expands metavariables in an unsafe block
+            //~^ macro_metavars_in_unsafe
             nested_macro_helper!($v);
             $v;
         }
@@ -243,6 +243,7 @@ pub mod issue13219 {
         ($e:expr) => {
             // Metavariable in a block tail expression
             unsafe { $e }
+            //~^ macro_metavars_in_unsafe
         };
     }
     pub fn f(p: *const i32) -> i32 {
diff --git a/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.rs b/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.rs
index ded3c72c3e04..385e23d69bcd 100644
--- a/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.rs
+++ b/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.rs
@@ -4,19 +4,27 @@
 
 extern crate extern_types;
 use extern_types::{Aaa, LONGER, M, N as W};
+//~^ min_ident_chars
 
 pub const N: u32 = 0;
+//~^ min_ident_chars
 pub const LONG: u32 = 32;
 
 struct Owo {
     Uwu: u128,
     aaa: Aaa,
+    //~^ min_ident_chars
 }
 
 fn main() {
     let wha = 1;
     let vvv = 1;
+    //~^ min_ident_chars
     let uuu = 1;
+    //~^ min_ident_chars
     let (mut a, mut b) = (1, 2);
+    //~^ min_ident_chars
+    //~| min_ident_chars
     for i in 0..1000 {}
+    //~^ min_ident_chars
 }
diff --git a/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.stderr b/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
index 63a057aca279..be795f4daff2 100644
--- a/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
+++ b/src/tools/clippy/tests/ui-toml/min_ident_chars/min_ident_chars.stderr
@@ -8,43 +8,43 @@ LL | use extern_types::{Aaa, LONGER, M, N as W};
    = help: to override `-D warnings` add `#[allow(clippy::min_ident_chars)]`
 
 error: this ident is too short (1 <= 3)
-  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:8:11
+  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:9:11
    |
 LL | pub const N: u32 = 0;
    |           ^
 
 error: this ident is too short (3 <= 3)
-  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:13:5
+  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:15:5
    |
 LL |     aaa: Aaa,
    |     ^^^
 
 error: this ident is too short (3 <= 3)
-  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:18:9
+  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:21:9
    |
 LL |     let vvv = 1;
    |         ^^^
 
 error: this ident is too short (3 <= 3)
-  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:19:9
+  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:23:9
    |
 LL |     let uuu = 1;
    |         ^^^
 
 error: this ident is too short (1 <= 3)
-  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:20:14
+  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:25:14
    |
 LL |     let (mut a, mut b) = (1, 2);
    |              ^
 
 error: this ident is too short (1 <= 3)
-  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:20:21
+  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:25:21
    |
 LL |     let (mut a, mut b) = (1, 2);
    |                     ^
 
 error: this ident is too short (1 <= 3)
-  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:21:9
+  --> tests/ui-toml/min_ident_chars/min_ident_chars.rs:28:9
    |
 LL |     for i in 0..1000 {}
    |         ^
diff --git a/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.fixed b/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.fixed
index 497f783087a1..685f77b7efe8 100644
--- a/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.fixed
+++ b/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.fixed
@@ -72,6 +72,7 @@ fn check_index_refutable_slice() {
 fn map_clone_suggest_copied() {
     // This should still trigger the lint but suggest `cloned()` instead of `copied()`
     let _: Option<u64> = Some(&16).cloned();
+    //~^ map_clone
 }
 
 fn borrow_as_ptr() {
diff --git a/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.rs b/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.rs
index 6e7874108a34..0bf073af8903 100644
--- a/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.rs
+++ b/src/tools/clippy/tests/ui-toml/min_rust_version/min_rust_version.rs
@@ -72,6 +72,7 @@ fn check_index_refutable_slice() {
 fn map_clone_suggest_copied() {
     // This should still trigger the lint but suggest `cloned()` instead of `copied()`
     let _: Option<u64> = Some(&16).map(|b| *b);
+    //~^ map_clone
 }
 
 fn borrow_as_ptr() {
diff --git a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed
index a6072111dc06..3e882f496985 100644
--- a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed
+++ b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.fixed
@@ -3,14 +3,20 @@
 use std::alloc as colla;
 use std::option::Option as Maybe;
 use std::process::{Child as Kid, exit as goodbye};
+//~^ missing_enforced_import_renames
 use std::thread::sleep as thread_sleep;
+//~^ missing_enforced_import_renames
 #[rustfmt::skip]
 use std::{
     any::{type_name as ident, Any},
+    //~^ missing_enforced_import_renames
     clone as foo,
+    //~^ missing_enforced_import_renames
     sync :: Mutex as StdMutie,
+    //~^ missing_enforced_import_renames
 };
 
 fn main() {
     use std::collections::BTreeMap as Map;
+    //~^ missing_enforced_import_renames
 }
diff --git a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
index c2b61aab5b3c..32255af5117f 100644
--- a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
+++ b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs
@@ -3,14 +3,20 @@
 use std::alloc as colla;
 use std::option::Option as Maybe;
 use std::process::{Child as Kid, exit as wrong_exit};
+//~^ missing_enforced_import_renames
 use std::thread::sleep;
+//~^ missing_enforced_import_renames
 #[rustfmt::skip]
 use std::{
     any::{type_name, Any},
+    //~^ missing_enforced_import_renames
     clone,
+    //~^ missing_enforced_import_renames
     sync :: Mutex,
+    //~^ missing_enforced_import_renames
 };
 
 fn main() {
     use std::collections::BTreeMap as OopsWrongRename;
+    //~^ missing_enforced_import_renames
 }
diff --git a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
index d3bb07ec47fd..982b144eb872 100644
--- a/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
+++ b/src/tools/clippy/tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.stderr
@@ -8,31 +8,31 @@ LL | use std::process::{Child as Kid, exit as wrong_exit};
    = help: to override `-D warnings` add `#[allow(clippy::missing_enforced_import_renames)]`
 
 error: this import should be renamed
-  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:6:1
+  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:7:1
    |
 LL | use std::thread::sleep;
    | ^^^^^^^^^^^^^^^^^^^^^^ help: try: `use std::thread::sleep as thread_sleep`
 
 error: this import should be renamed
-  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:9:11
+  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:11:11
    |
 LL |     any::{type_name, Any},
    |           ^^^^^^^^^ help: try: `type_name as ident`
 
 error: this import should be renamed
-  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:10:5
+  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:13:5
    |
 LL |     clone,
    |     ^^^^^ help: try: `clone as foo`
 
 error: this import should be renamed
-  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:11:5
+  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:15:5
    |
 LL |     sync :: Mutex,
    |     ^^^^^^^^^^^^^ help: try: `sync :: Mutex as StdMutie`
 
 error: this import should be renamed
-  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:15:5
+  --> tests/ui-toml/missing_enforced_import_rename/conf_missing_enforced_import_rename.rs:20:5
    |
 LL |     use std::collections::BTreeMap as OopsWrongRename;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `use std::collections::BTreeMap as Map`
diff --git a/src/tools/clippy/tests/ui-toml/module_inception/module_inception.rs b/src/tools/clippy/tests/ui-toml/module_inception/module_inception.rs
index cd495c884a43..94866a7e81bf 100644
--- a/src/tools/clippy/tests/ui-toml/module_inception/module_inception.rs
+++ b/src/tools/clippy/tests/ui-toml/module_inception/module_inception.rs
@@ -4,11 +4,13 @@
 pub mod foo2 {
     pub mod bar2 {
         pub mod bar2 {
+            //~^ module_inception
             pub mod foo2 {}
         }
         pub mod foo2 {}
     }
     pub mod foo2 {
+        //~^ module_inception
         pub mod bar2 {}
     }
 }
diff --git a/src/tools/clippy/tests/ui-toml/module_inception/module_inception.stderr b/src/tools/clippy/tests/ui-toml/module_inception/module_inception.stderr
index 75e78c829226..efef1d010233 100644
--- a/src/tools/clippy/tests/ui-toml/module_inception/module_inception.stderr
+++ b/src/tools/clippy/tests/ui-toml/module_inception/module_inception.stderr
@@ -2,6 +2,7 @@ error: module has the same name as its containing module
   --> tests/ui-toml/module_inception/module_inception.rs:6:9
    |
 LL | /         pub mod bar2 {
+LL | |
 LL | |             pub mod foo2 {}
 LL | |         }
    | |_________^
@@ -10,9 +11,10 @@ LL | |         }
    = help: to override `-D warnings` add `#[allow(clippy::module_inception)]`
 
 error: module has the same name as its containing module
-  --> tests/ui-toml/module_inception/module_inception.rs:11:5
+  --> tests/ui-toml/module_inception/module_inception.rs:12:5
    |
 LL | /     pub mod foo2 {
+LL | |
 LL | |         pub mod bar2 {}
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs b/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs
index 27d27564baf3..7e42f095cbba 100644
--- a/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs
+++ b/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs
@@ -4,7 +4,11 @@ fn main() {
     let a = -1;
     let b = 2;
     let c = a % b == 0;
+    //~^ modulo_arithmetic
     let c = a % b != 0;
+    //~^ modulo_arithmetic
     let c = 0 == a % b;
+    //~^ modulo_arithmetic
     let c = 0 != a % b;
+    //~^ modulo_arithmetic
 }
diff --git a/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr b/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr
index 8d01b66522c6..02286f66f4d1 100644
--- a/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr
+++ b/src/tools/clippy/tests/ui-toml/modulo_arithmetic/modulo_arithmetic.stderr
@@ -10,7 +10,7 @@ LL |     let c = a % b == 0;
    = help: to override `-D warnings` add `#[allow(clippy::modulo_arithmetic)]`
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs:7:13
+  --> tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs:8:13
    |
 LL |     let c = a % b != 0;
    |             ^^^^^
@@ -19,7 +19,7 @@ LL |     let c = a % b != 0;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs:8:18
+  --> tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs:10:18
    |
 LL |     let c = 0 == a % b;
    |                  ^^^^^
@@ -28,7 +28,7 @@ LL |     let c = 0 == a % b;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs:9:18
+  --> tests/ui-toml/modulo_arithmetic/modulo_arithmetic.rs:12:18
    |
 LL |     let c = 0 != a % b;
    |                  ^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/mut_key/mut_key.rs b/src/tools/clippy/tests/ui-toml/mut_key/mut_key.rs
index 3a8e3741e20c..b23c2340b7d6 100644
--- a/src/tools/clippy/tests/ui-toml/mut_key/mut_key.rs
+++ b/src/tools/clippy/tests/ui-toml/mut_key/mut_key.rs
@@ -1,4 +1,5 @@
 //@compile-flags: --crate-name mut_key
+//@check-pass
 
 #![warn(clippy::mutable_key_type)]
 
diff --git a/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.fixed b/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.fixed
index fd20bdff6e25..6b386046efa7 100644
--- a/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.fixed
+++ b/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.fixed
@@ -4,6 +4,9 @@
 fn main() {
     r#"\aaa"#;
     r#"\aaa"#;
+    //~^ needless_raw_string_hashes
     r#"Hello "world"!"#;
+    //~^ needless_raw_string_hashes
     r####" "### "## "# "####;
+    //~^ needless_raw_string_hashes
 }
diff --git a/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs b/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs
index 3c6c24637006..f928e590d45c 100644
--- a/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs
+++ b/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs
@@ -4,6 +4,9 @@
 fn main() {
     r#"\aaa"#;
     r##"\aaa"##;
+    //~^ needless_raw_string_hashes
     r##"Hello "world"!"##;
+    //~^ needless_raw_string_hashes
     r######" "### "## "# "######;
+    //~^ needless_raw_string_hashes
 }
diff --git a/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.stderr b/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.stderr
index 421ad66e4c96..43d02837c6cc 100644
--- a/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.stderr
+++ b/src/tools/clippy/tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.stderr
@@ -13,7 +13,7 @@ LL +     r#"\aaa"#;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs:7:5
+  --> tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs:8:5
    |
 LL |     r##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     r#"Hello "world"!"#;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs:8:5
+  --> tests/ui-toml/needless_raw_string_hashes_one_allowed/needless_raw_string_hashes.rs:10:5
    |
 LL |     r######" "### "## "# "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed b/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
index 673106f0b12d..8da607ec6584 100644
--- a/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
+++ b/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.fixed
@@ -16,6 +16,7 @@ proc_macro_derive::foo_bar!();
 macro_rules! test {
     () => {
         vec![0, 0, 0]
+        //~^ nonstandard_macro_braces
     };
 }
 
@@ -41,10 +42,15 @@ macro_rules! printlnfoo {
 #[rustfmt::skip]
 fn main() {
     let _ = vec![1, 2, 3];
+    //~^ nonstandard_macro_braces
     let _ = format!("ugh {} stop being such a good compiler", "hello");
+    //~^ nonstandard_macro_braces
     let _ = matches!({}, ());
+    //~^ nonstandard_macro_braces
     let _ = quote!{let x = 1;};
+    //~^ nonstandard_macro_braces
     let _ = quote::quote!{match match match};
+    //~^ nonstandard_macro_braces
     let _ = test!(); // trigger when macro def is inside our own crate
     let _ = vec![1,2,3];
 
@@ -54,8 +60,10 @@ fn main() {
     let _ = test2!["{}{}{}", 1, 2, 3];
 
     let _: type_pos![usize] = vec![];
+    //~^ nonstandard_macro_braces
 
     eprint!["test if user config overrides defaults"];
+    //~^ nonstandard_macro_braces
 
     printlnfoo!["test if printlnfoo is triggered by println"];
 }
diff --git a/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs b/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
index b9c69037be07..e35844a209fa 100644
--- a/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
+++ b/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs
@@ -16,6 +16,7 @@ proc_macro_derive::foo_bar!();
 macro_rules! test {
     () => {
         vec!{0, 0, 0}
+        //~^ nonstandard_macro_braces
     };
 }
 
@@ -41,10 +42,15 @@ macro_rules! printlnfoo {
 #[rustfmt::skip]
 fn main() {
     let _ = vec! {1, 2, 3};
+    //~^ nonstandard_macro_braces
     let _ = format!["ugh {} stop being such a good compiler", "hello"];
+    //~^ nonstandard_macro_braces
     let _ = matches!{{}, ()};
+    //~^ nonstandard_macro_braces
     let _ = quote!(let x = 1;);
+    //~^ nonstandard_macro_braces
     let _ = quote::quote!(match match match);
+    //~^ nonstandard_macro_braces
     let _ = test!(); // trigger when macro def is inside our own crate
     let _ = vec![1,2,3];
 
@@ -54,8 +60,10 @@ fn main() {
     let _ = test2!["{}{}{}", 1, 2, 3];
 
     let _: type_pos!(usize) = vec![];
+    //~^ nonstandard_macro_braces
 
     eprint!("test if user config overrides defaults");
+    //~^ nonstandard_macro_braces
 
     printlnfoo!["test if printlnfoo is triggered by println"];
 }
diff --git a/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr b/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
index c2c76e444cfe..fda6addc7aa3 100644
--- a/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
+++ b/src/tools/clippy/tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.stderr
@@ -1,5 +1,5 @@
 error: use of irregular braces for `vec!` macro
-  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:43:13
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:44:13
    |
 LL |     let _ = vec! {1, 2, 3};
    |             ^^^^^^^^^^^^^^ help: consider writing: `vec![1, 2, 3]`
@@ -8,25 +8,25 @@ LL |     let _ = vec! {1, 2, 3};
    = help: to override `-D warnings` add `#[allow(clippy::nonstandard_macro_braces)]`
 
 error: use of irregular braces for `format!` macro
-  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:44:13
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:46:13
    |
 LL |     let _ = format!["ugh {} stop being such a good compiler", "hello"];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `format!("ugh {} stop being such a good compiler", "hello")`
 
 error: use of irregular braces for `matches!` macro
-  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:45:13
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:48:13
    |
 LL |     let _ = matches!{{}, ()};
    |             ^^^^^^^^^^^^^^^^ help: consider writing: `matches!({}, ())`
 
 error: use of irregular braces for `quote!` macro
-  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:46:13
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:50:13
    |
 LL |     let _ = quote!(let x = 1;);
    |             ^^^^^^^^^^^^^^^^^^ help: consider writing: `quote!{let x = 1;}`
 
 error: use of irregular braces for `quote::quote!` macro
-  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:47:13
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:52:13
    |
 LL |     let _ = quote::quote!(match match match);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `quote::quote!{match match match}`
@@ -43,13 +43,13 @@ LL |     let _ = test!(); // trigger when macro def is inside our own crate
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: use of irregular braces for `type_pos!` macro
-  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:56:12
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:62:12
    |
 LL |     let _: type_pos!(usize) = vec![];
    |            ^^^^^^^^^^^^^^^^ help: consider writing: `type_pos![usize]`
 
 error: use of irregular braces for `eprint!` macro
-  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:58:5
+  --> tests/ui-toml/nonstandard_macro_braces/conf_nonstandard_macro_braces.rs:65:5
    |
 LL |     eprint!("test if user config overrides defaults");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `eprint!["test if user config overrides defaults"]`
diff --git a/src/tools/clippy/tests/ui-toml/panic/panic.rs b/src/tools/clippy/tests/ui-toml/panic/panic.rs
index b6264c950e45..7bdc896453d8 100644
--- a/src/tools/clippy/tests/ui-toml/panic/panic.rs
+++ b/src/tools/clippy/tests/ui-toml/panic/panic.rs
@@ -10,11 +10,13 @@ fn main() {
     match a {
         Enam::A => {},
         _ => panic!(""),
+        //~^ panic
     }
 }
 
 fn issue_13292() {
     panic_any("should lint")
+    //~^ panic
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui-toml/panic/panic.stderr b/src/tools/clippy/tests/ui-toml/panic/panic.stderr
index a034207d919f..5dfecfe51ddb 100644
--- a/src/tools/clippy/tests/ui-toml/panic/panic.stderr
+++ b/src/tools/clippy/tests/ui-toml/panic/panic.stderr
@@ -8,7 +8,7 @@ LL |         _ => panic!(""),
    = help: to override `-D warnings` add `#[allow(clippy::panic)]`
 
 error: `panic_any` should not be present in production code
-  --> tests/ui-toml/panic/panic.rs:17:5
+  --> tests/ui-toml/panic/panic.rs:18:5
    |
 LL |     panic_any("should lint")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/path_ends_with_ext/path_ends_with_ext.rs b/src/tools/clippy/tests/ui-toml/path_ends_with_ext/path_ends_with_ext.rs
index a34b15f4ac9a..455623cec43e 100644
--- a/src/tools/clippy/tests/ui-toml/path_ends_with_ext/path_ends_with_ext.rs
+++ b/src/tools/clippy/tests/ui-toml/path_ends_with_ext/path_ends_with_ext.rs
@@ -1,3 +1,5 @@
+//@check-pass
+
 #![warn(clippy::path_ends_with_ext)]
 
 use std::path::Path;
diff --git a/src/tools/clippy/tests/ui-toml/print_macro/print_macro.rs b/src/tools/clippy/tests/ui-toml/print_macro/print_macro.rs
index 3a8b30cca36a..74f3ba7e7fa9 100644
--- a/src/tools/clippy/tests/ui-toml/print_macro/print_macro.rs
+++ b/src/tools/clippy/tests/ui-toml/print_macro/print_macro.rs
@@ -4,7 +4,9 @@
 
 fn foo(n: u32) {
     print!("{n}");
+    //~^ print_stdout
     eprint!("{n}");
+    //~^ print_stderr
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui-toml/print_macro/print_macro.stderr b/src/tools/clippy/tests/ui-toml/print_macro/print_macro.stderr
index fea11107c7ca..835af7ef8c72 100644
--- a/src/tools/clippy/tests/ui-toml/print_macro/print_macro.stderr
+++ b/src/tools/clippy/tests/ui-toml/print_macro/print_macro.stderr
@@ -8,7 +8,7 @@ LL |     print!("{n}");
    = help: to override `-D warnings` add `#[allow(clippy::print_stdout)]`
 
 error: use of `eprint!`
-  --> tests/ui-toml/print_macro/print_macro.rs:7:5
+  --> tests/ui-toml/print_macro/print_macro.rs:8:5
    |
 LL |     eprint!("{n}");
    |     ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs b/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
index cd53f5044599..6a1d2b51abc8 100644
--- a/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
+++ b/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs
@@ -11,9 +11,11 @@ mod my_mod {
     /// some docs
     pub(crate) fn crate_with_docs() {}
     pub(crate) fn crate_no_docs() {}
+    //~^ missing_docs_in_private_items
     /// some docs
     pub(super) fn super_with_docs() {}
     pub(super) fn super_no_docs() {}
+    //~^ missing_docs_in_private_items
 
     mod my_sub {
         /// some docs
@@ -22,6 +24,7 @@ mod my_mod {
         /// some docs
         pub(crate) fn sub_crate_with_docs() {}
         pub(crate) fn sub_crate_no_docs() {}
+        //~^ missing_docs_in_private_items
         /// some docs
         pub(super) fn sub_super_with_docs() {}
         pub(super) fn sub_super_no_docs() {}
@@ -32,15 +35,18 @@ mod my_mod {
         /// some docs
         pub(crate) crate_field_with_docs: (),
         pub(crate) crate_field_no_docs: (),
+        //~^ missing_docs_in_private_items
         /// some docs
         priv_field_with_docs: (),
         priv_field_no_docs: (),
     }
 
     pub(crate) struct CrateStructNoDocs {
+        //~^ missing_docs_in_private_items
         /// some docs
         pub(crate) crate_field_with_docs: (),
         pub(crate) crate_field_no_docs: (),
+        //~^ missing_docs_in_private_items
         /// some docs
         priv_field_with_docs: (),
         priv_field_no_docs: (),
@@ -50,6 +56,7 @@ mod my_mod {
 /// some docs
 type CrateTypedefWithDocs = String;
 type CrateTypedefNoDocs = String;
+//~^ missing_docs_in_private_items
 /// some docs
 pub type PubTypedefWithDocs = String;
 pub type PubTypedefNoDocs = String;
diff --git a/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr b/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
index 9cf79fccb60b..0d70276de42d 100644
--- a/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
+++ b/src/tools/clippy/tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.stderr
@@ -8,43 +8,43 @@ LL |     pub(crate) fn crate_no_docs() {}
    = help: to override `-D warnings` add `#[allow(clippy::missing_docs_in_private_items)]`
 
 error: missing documentation for a function
-  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:16:5
+  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:17:5
    |
 LL |     pub(super) fn super_no_docs() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a function
-  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:24:9
+  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:26:9
    |
 LL |         pub(crate) fn sub_crate_no_docs() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a struct field
-  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:34:9
+  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:37:9
    |
 LL |         pub(crate) crate_field_no_docs: (),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a struct
-  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:40:5
+  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:44:5
    |
 LL | /     pub(crate) struct CrateStructNoDocs {
+LL | |
 LL | |         /// some docs
 LL | |         pub(crate) crate_field_with_docs: (),
-LL | |         pub(crate) crate_field_no_docs: (),
 ...  |
 LL | |         priv_field_no_docs: (),
 LL | |     }
    | |_____^
 
 error: missing documentation for a struct field
-  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:43:9
+  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:48:9
    |
 LL |         pub(crate) crate_field_no_docs: (),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a type alias
-  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:52:1
+  --> tests/ui-toml/pub_crate_missing_docs/pub_crate_missing_doc.rs:58:1
    |
 LL | type CrateTypedefNoDocs = String;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr b/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr
index dd1035e53fa9..335ff403d062 100644
--- a/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr
+++ b/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.all_pub_fields.stderr
@@ -9,7 +9,7 @@ LL |         pub _b: u8,
    = help: to override `-D warnings` add `#[allow(clippy::pub_underscore_fields)]`
 
 error: field marked as public but also inferred as unused because it's prefixed with `_`
-  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:23:13
+  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:24:13
    |
 LL |             pub(in crate::inner) _f: Option<()>,
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |             pub(in crate::inner) _f: Option<()>,
    = help: consider removing the underscore, or making the field private
 
 error: field marked as public but also inferred as unused because it's prefixed with `_`
-  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:27:13
+  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:29:13
    |
 LL |             pub _g: String,
    |             ^^^^^^
@@ -25,7 +25,7 @@ LL |             pub _g: String,
    = help: consider removing the underscore, or making the field private
 
 error: field marked as public but also inferred as unused because it's prefixed with `_`
-  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:34:9
+  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:37:9
    |
 LL |         pub _a: usize,
    |         ^^^^^^
@@ -33,7 +33,7 @@ LL |         pub _a: usize,
    = help: consider removing the underscore, or making the field private
 
 error: field marked as public but also inferred as unused because it's prefixed with `_`
-  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:41:9
+  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:45:9
    |
 LL |         pub _c: i64,
    |         ^^^^^^
@@ -41,7 +41,7 @@ LL |         pub _c: i64,
    = help: consider removing the underscore, or making the field private
 
 error: field marked as public but also inferred as unused because it's prefixed with `_`
-  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:44:9
+  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:49:9
    |
 LL |         pub _e: Option<u8>,
    |         ^^^^^^
@@ -49,7 +49,7 @@ LL |         pub _e: Option<u8>,
    = help: consider removing the underscore, or making the field private
 
 error: field marked as public but also inferred as unused because it's prefixed with `_`
-  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:57:9
+  --> tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs:63:9
    |
 LL |         pub(crate) _b: Option<String>,
    |         ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs b/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
index 4ee8dbb88347..2c1d3cf23647 100644
--- a/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
+++ b/src/tools/clippy/tests/ui-toml/pub_underscore_fields/pub_underscore_fields.rs
@@ -13,6 +13,7 @@ pub mod inner {
     pub struct PubSuper {
         pub(super) a: usize,
         pub _b: u8,
+        //~^ pub_underscore_fields
         _c: i32,
         pub _mark: marker::PhantomData<u8>,
     }
@@ -21,10 +22,12 @@ pub mod inner {
         pub struct PubModVisibility {
             pub(in crate::inner) e: bool,
             pub(in crate::inner) _f: Option<()>,
+            //~[all_pub_fields]^ pub_underscore_fields
         }
 
         struct PrivateStructPubField {
             pub _g: String,
+            //~[all_pub_fields]^ pub_underscore_fields
         }
     }
 }
@@ -32,6 +35,7 @@ pub mod inner {
 fn main() {
     pub struct StructWithOneViolation {
         pub _a: usize,
+        //~[all_pub_fields]^ pub_underscore_fields
     }
 
     // should handle structs with multiple violations
@@ -39,9 +43,11 @@ fn main() {
         a: u8,
         _b: usize,
         pub _c: i64,
+        //~[all_pub_fields]^ pub_underscore_fields
         #[doc(hidden)]
         pub d: String,
         pub _e: Option<u8>,
+        //~[all_pub_fields]^ pub_underscore_fields
     }
 
     // shouldn't warn on anonymous fields
@@ -55,6 +61,7 @@ fn main() {
     pub struct PubCrate {
         pub(crate) a: String,
         pub(crate) _b: Option<String>,
+        //~[all_pub_fields]^ pub_underscore_fields
     }
 
     // shouldn't warn on fields named pub
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.default.stderr b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.default.stderr
index de9f17520ff7..7fdaa4420450 100644
--- a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.default.stderr
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.default.stderr
@@ -20,13 +20,13 @@ LL |     fn foo(&self, i_dont_wanna_use_your_name: u8) {} // only lint in `exten
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the default name: `val`
 
 error: renamed function parameter of trait impl
-  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:55:31
+  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:57:31
    |
 LL |     fn hash<H: Hasher>(&self, states: &mut H) {
    |                               ^^^^^^ help: consider using the default name: `state`
 
 error: renamed function parameters of trait impl
-  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:59:30
+  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:61:30
    |
 LL |     fn hash_slice<H: Hasher>(date: &[Self], states: &mut H) {
    |                              ^^^^           ^^^^^^
@@ -38,7 +38,7 @@ LL +     fn hash_slice<H: Hasher>(data: &[Self], state: &mut H) {
    |
 
 error: renamed function parameter of trait impl
-  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:80:18
+  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:82:18
    |
 LL |     fn add(self, b: B) -> C {
    |                  ^ help: consider using the default name: `rhs`
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.extend.stderr b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.extend.stderr
index bdc4eeaad80f..d670026b5411 100644
--- a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.extend.stderr
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.extend.stderr
@@ -14,13 +14,13 @@ LL |     fn ne(&self, rhs: &Self) -> bool {
    |                  ^^^ help: consider using the default name: `other`
 
 error: renamed function parameter of trait impl
-  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:55:31
+  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:57:31
    |
 LL |     fn hash<H: Hasher>(&self, states: &mut H) {
    |                               ^^^^^^ help: consider using the default name: `state`
 
 error: renamed function parameters of trait impl
-  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:59:30
+  --> tests/ui-toml/renamed_function_params/renamed_function_params.rs:61:30
    |
 LL |     fn hash_slice<H: Hasher>(date: &[Self], states: &mut H) {
    |                              ^^^^           ^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.rs b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.rs
index f3eb910abbd6..26ca1d860947 100644
--- a/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.rs
+++ b/src/tools/clippy/tests/ui-toml/renamed_function_params/renamed_function_params.rs
@@ -28,11 +28,11 @@ impl std::convert::From<B> for String {
 }
 impl PartialEq for B {
     fn eq(&self, rhs: &Self) -> bool {
-        //~^ ERROR: renamed function parameter of trait impl
+        //~^ renamed_function_params
         self.0 == rhs.0
     }
     fn ne(&self, rhs: &Self) -> bool {
-        //~^ ERROR: renamed function parameter of trait impl
+        //~^ renamed_function_params
         self.0 != rhs.0
     }
 }
@@ -46,6 +46,8 @@ trait MyTrait {
 
 impl MyTrait for B {
     fn foo(&self, i_dont_wanna_use_your_name: u8) {} // only lint in `extend`
+    //
+    //~[default]^^ renamed_function_params
     fn bar(_a: u8, _: u8) {}
     fn baz(self, val: u8) {}
     fn quz(&self, val: u8) {}
@@ -53,11 +55,11 @@ impl MyTrait for B {
 
 impl Hash for B {
     fn hash<H: Hasher>(&self, states: &mut H) {
-        //~^ ERROR: renamed function parameter of trait impl
+        //~^ renamed_function_params
         self.0.hash(states);
     }
     fn hash_slice<H: Hasher>(date: &[Self], states: &mut H) {
-        //~^ ERROR: renamed function parameters of trait impl
+        //~^ renamed_function_params
         for d in date {
             d.hash(states);
         }
@@ -78,6 +80,7 @@ enum C {
 impl std::ops::Add<B> for C {
     type Output = C;
     fn add(self, b: B) -> C {
+        //~[default]^ renamed_function_params
         // only lint in `extend`
         C::B(b.0)
     }
diff --git a/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/clippy.toml b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/clippy.toml
new file mode 100644
index 000000000000..a08a2f00f506
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/clippy.toml
@@ -0,0 +1,3 @@
+disallowed-types = [
+    { path = "std::string::String", replacement = "wrapper::String" },
+]
diff --git a/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.fixed b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.fixed
new file mode 100644
index 000000000000..f0dab64d78c6
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.fixed
@@ -0,0 +1,17 @@
+#![warn(clippy::disallowed_types)]
+
+#[allow(clippy::disallowed_types)]
+mod wrapper {
+    pub struct String(std::string::String);
+
+    impl From<&str> for String {
+        fn from(value: &str) -> Self {
+            Self(std::string::String::from(value))
+        }
+    }
+}
+
+fn main() {
+    let _ = wrapper::String::from("x");
+    //~^ disallowed_types
+}
diff --git a/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.rs b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.rs
new file mode 100644
index 000000000000..2585e6f90fc4
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.rs
@@ -0,0 +1,17 @@
+#![warn(clippy::disallowed_types)]
+
+#[allow(clippy::disallowed_types)]
+mod wrapper {
+    pub struct String(std::string::String);
+
+    impl From<&str> for String {
+        fn from(value: &str) -> Self {
+            Self(std::string::String::from(value))
+        }
+    }
+}
+
+fn main() {
+    let _ = String::from("x");
+    //~^ disallowed_types
+}
diff --git a/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.stderr b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.stderr
new file mode 100644
index 000000000000..bb63e6970a16
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.stderr
@@ -0,0 +1,11 @@
+error: use of a disallowed type `std::string::String`
+  --> tests/ui-toml/replaceable_disallowed_types/replaceable_disallowed_types.rs:15:13
+   |
+LL |     let _ = String::from("x");
+   |             ^^^^^^ help: use: `wrapper::String`
+   |
+   = note: `-D clippy::disallowed-types` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::disallowed_types)]`
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/both.fixed b/src/tools/clippy/tests/ui-toml/semicolon_block/both.fixed
index 306cd23c8239..33f490fad6e8 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/both.fixed
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/both.fixed
@@ -40,12 +40,15 @@ fn main() {
     unsafe { unit_fn_block() };
 
     { unit_fn_block() };
+    //~^ semicolon_outside_block
     unsafe { unit_fn_block() };
+    //~^ semicolon_outside_block
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
 
     {
+    //~^ semicolon_inside_block
         unit_fn_block();
         unit_fn_block();
     }
@@ -60,6 +63,7 @@ fn main() {
 
     { m!(()) };
     { m!(()) };
+    //~^ semicolon_outside_block
     { m!(()); };
     m!(0);
     m!(1);
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/both.rs b/src/tools/clippy/tests/ui-toml/semicolon_block/both.rs
index b9f012cfbb0d..8e650979e6c9 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/both.rs
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/both.rs
@@ -40,12 +40,15 @@ fn main() {
     unsafe { unit_fn_block() };
 
     { unit_fn_block(); }
+    //~^ semicolon_outside_block
     unsafe { unit_fn_block(); }
+    //~^ semicolon_outside_block
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
 
     {
+    //~^ semicolon_inside_block
         unit_fn_block();
         unit_fn_block()
     };
@@ -60,6 +63,7 @@ fn main() {
 
     { m!(()) };
     { m!(()); }
+    //~^ semicolon_outside_block
     { m!(()); };
     m!(0);
     m!(1);
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/both.stderr b/src/tools/clippy/tests/ui-toml/semicolon_block/both.stderr
index 7d7749b282f0..c2aad39b6832 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/both.stderr
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/both.stderr
@@ -13,7 +13,7 @@ LL +     { unit_fn_block() };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui-toml/semicolon_block/both.rs:43:5
+  --> tests/ui-toml/semicolon_block/both.rs:44:5
    |
 LL |     unsafe { unit_fn_block(); }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,9 +25,10 @@ LL +     unsafe { unit_fn_block() };
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui-toml/semicolon_block/both.rs:48:5
+  --> tests/ui-toml/semicolon_block/both.rs:50:5
    |
 LL | /     {
+LL | |
 LL | |         unit_fn_block();
 LL | |         unit_fn_block()
 LL | |     };
@@ -42,7 +43,7 @@ LL ~     }
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui-toml/semicolon_block/both.rs:62:5
+  --> tests/ui-toml/semicolon_block/both.rs:65:5
    |
 LL |     { m!(()); }
    |     ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.fixed b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.fixed
index 5b7f8e00c7a0..7b1af090e933 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.fixed
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.fixed
@@ -45,6 +45,7 @@ fn main() {
     unsafe { unit_fn_block(); };
 
     {
+    //~^ semicolon_inside_block
         unit_fn_block();
         unit_fn_block();
     }
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.rs b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.rs
index 3a81661cd16f..e243d4514da2 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.rs
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.rs
@@ -45,6 +45,7 @@ fn main() {
     unsafe { unit_fn_block(); };
 
     {
+    //~^ semicolon_inside_block
         unit_fn_block();
         unit_fn_block()
     };
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
index b1638e40206d..4d4e43f6b9c1 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_inside_block.stderr
@@ -2,6 +2,7 @@ error: consider moving the `;` inside the block for consistent formatting
   --> tests/ui-toml/semicolon_block/semicolon_inside_block.rs:47:5
    |
 LL | /     {
+LL | |
 LL | |         unit_fn_block();
 LL | |         unit_fn_block()
 LL | |     };
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.fixed b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.fixed
index 14604eaea7e4..f6aa49fc8868 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.fixed
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.fixed
@@ -39,7 +39,9 @@ fn main() {
     unsafe { unit_fn_block() };
 
     { unit_fn_block() };
+    //~^ semicolon_outside_block
     unsafe { unit_fn_block() };
+    //~^ semicolon_outside_block
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
@@ -59,6 +61,7 @@ fn main() {
 
     { m!(()) };
     { m!(()) };
+    //~^ semicolon_outside_block
     { m!(()); };
     m!(0);
     m!(1);
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.rs b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.rs
index c767201469ab..0d25a29627fb 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.rs
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.rs
@@ -39,7 +39,9 @@ fn main() {
     unsafe { unit_fn_block() };
 
     { unit_fn_block(); }
+    //~^ semicolon_outside_block
     unsafe { unit_fn_block(); }
+    //~^ semicolon_outside_block
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
@@ -59,6 +61,7 @@ fn main() {
 
     { m!(()) };
     { m!(()); }
+    //~^ semicolon_outside_block
     { m!(()); };
     m!(0);
     m!(1);
diff --git a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.stderr b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.stderr
index 7bcb63a6abbb..18400da07a89 100644
--- a/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.stderr
+++ b/src/tools/clippy/tests/ui-toml/semicolon_block/semicolon_outside_block.stderr
@@ -13,7 +13,7 @@ LL +     { unit_fn_block() };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui-toml/semicolon_block/semicolon_outside_block.rs:42:5
+  --> tests/ui-toml/semicolon_block/semicolon_outside_block.rs:43:5
    |
 LL |     unsafe { unit_fn_block(); }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     unsafe { unit_fn_block() };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui-toml/semicolon_block/semicolon_outside_block.rs:61:5
+  --> tests/ui-toml/semicolon_block/semicolon_outside_block.rs:63:5
    |
 LL |     { m!(()); }
    |     ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs b/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs
index 90c2439dc34f..08a8e1186d5c 100644
--- a/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs
+++ b/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs
@@ -9,6 +9,7 @@ pub struct NoGeneric {
 }
 
 unsafe impl Send for NoGeneric {}
+//~^ non_send_fields_in_send_ty
 
 pub struct MultiField<T> {
     field1: T,
@@ -17,6 +18,7 @@ pub struct MultiField<T> {
 }
 
 unsafe impl<T> Send for MultiField<T> {}
+//~^ non_send_fields_in_send_ty
 
 pub enum MyOption<T> {
     MySome(T),
@@ -24,6 +26,7 @@ pub enum MyOption<T> {
 }
 
 unsafe impl<T> Send for MyOption<T> {}
+//~^ non_send_fields_in_send_ty
 
 // All fields are disallowed when raw pointer heuristic is off
 extern "C" {
@@ -39,5 +42,6 @@ pub struct HeuristicTest {
 }
 
 unsafe impl Send for HeuristicTest {}
+//~^ non_send_fields_in_send_ty
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr b/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
index bd1b75458fd1..cdb4a2f44513 100644
--- a/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/strict_non_send_fields_in_send_ty/test.stderr
@@ -14,75 +14,75 @@ LL |     rc_is_not_send: Rc<String>,
    = help: to override `-D warnings` add `#[allow(clippy::non_send_fields_in_send_ty)]`
 
 error: some fields in `MultiField<T>` are not safe to be sent to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:19:1
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:20:1
    |
 LL | unsafe impl<T> Send for MultiField<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: it is not safe to send field `field1` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:14:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:15:5
    |
 LL |     field1: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 note: it is not safe to send field `field2` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:15:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:16:5
    |
 LL |     field2: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 note: it is not safe to send field `field3` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:16:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:17:5
    |
 LL |     field3: T,
    |     ^^^^^^^^^
    = help: add `T: Send` bound in `Send` impl
 
 error: some fields in `MyOption<T>` are not safe to be sent to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:26:1
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:28:1
    |
 LL | unsafe impl<T> Send for MyOption<T> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: it is not safe to send field `0` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:22:12
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:24:12
    |
 LL |     MySome(T),
    |            ^
    = help: add `T: Send` bound in `Send` impl
 
 error: some fields in `HeuristicTest` are not safe to be sent to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:41:1
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:44:1
    |
 LL | unsafe impl Send for HeuristicTest {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: it is not safe to send field `field1` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:34:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:37:5
    |
 LL |     field1: Vec<*const NonSend>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 note: it is not safe to send field `field2` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:35:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:38:5
    |
 LL |     field2: [*const NonSend; 3],
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 note: it is not safe to send field `field3` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:36:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:39:5
    |
 LL |     field3: (*const NonSend, *const NonSend, *const NonSend),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 note: it is not safe to send field `field4` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:37:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:40:5
    |
 LL |     field4: (*const NonSend, Rc<u8>),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = help: use a thread-safe type that implements `Send`
 note: it is not safe to send field `field5` to another thread
-  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:38:5
+  --> tests/ui-toml/strict_non_send_fields_in_send_ty/test.rs:41:5
    |
 LL |     field5: Vec<Vec<*const NonSend>>,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.rs b/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.rs
index 32dd80246fab..590cd6eeaa47 100644
--- a/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.rs
+++ b/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::struct_excessive_bools)]
 
 struct S {
+    //~^ struct_excessive_bools
     a: bool,
 }
 
diff --git a/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr b/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr
index ddf8ec0e5217..d70c76055df8 100644
--- a/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/struct_excessive_bools/test.stderr
@@ -2,6 +2,7 @@ error: more than 0 bools in a struct
   --> tests/ui-toml/struct_excessive_bools/test.rs:3:1
    |
 LL | / struct S {
+LL | |
 LL | |     a: bool,
 LL | | }
    | |_^
diff --git a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs
index 4613a74b85d8..b077b848837a 100644
--- a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs
+++ b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.rs
@@ -25,6 +25,7 @@ fn main() {
     let x = [1, 2, 3, 4];
     let index: usize = 1;
     x[index];
+    //~^ indexing_slicing
     x[4]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
     x[1 << 3]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
 
@@ -40,15 +41,20 @@ fn main() {
 
     let v = vec![0; 5];
     v[0];
+    //~^ indexing_slicing
     v[10];
+    //~^ indexing_slicing
     v[1 << 3];
+    //~^ indexing_slicing
 
     const N: usize = 15; // Out of bounds
     const M: usize = 3; // In bounds
     x[N]; // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
     x[M]; // Ok, should not produce stderr.
     v[N];
+    //~^ indexing_slicing
     v[M];
+    //~^ indexing_slicing
 }
 
 /// An opaque integer representation
diff --git a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr
index 120f5c35cb03..4c78a6b924cf 100644
--- a/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/suppress_lint_in_const/test.stderr
@@ -9,7 +9,7 @@ LL |     x[index];
    = help: to override `-D warnings` add `#[allow(clippy::indexing_slicing)]`
 
 error: indexing may panic
-  --> tests/ui-toml/suppress_lint_in_const/test.rs:42:5
+  --> tests/ui-toml/suppress_lint_in_const/test.rs:43:5
    |
 LL |     v[0];
    |     ^^^^
@@ -17,7 +17,7 @@ LL |     v[0];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui-toml/suppress_lint_in_const/test.rs:43:5
+  --> tests/ui-toml/suppress_lint_in_const/test.rs:45:5
    |
 LL |     v[10];
    |     ^^^^^
@@ -25,7 +25,7 @@ LL |     v[10];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui-toml/suppress_lint_in_const/test.rs:44:5
+  --> tests/ui-toml/suppress_lint_in_const/test.rs:47:5
    |
 LL |     v[1 << 3];
    |     ^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     v[1 << 3];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui-toml/suppress_lint_in_const/test.rs:50:5
+  --> tests/ui-toml/suppress_lint_in_const/test.rs:54:5
    |
 LL |     v[N];
    |     ^^^^
@@ -41,7 +41,7 @@ LL |     v[N];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui-toml/suppress_lint_in_const/test.rs:51:5
+  --> tests/ui-toml/suppress_lint_in_const/test.rs:56:5
    |
 LL |     v[M];
    |     ^^^^
diff --git a/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs b/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
index 2f86b3eda4c5..6555e4291959 100644
--- a/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
+++ b/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs
@@ -4,17 +4,24 @@
 #![warn(clippy::disallowed_names)]
 
 fn test(toto: ()) {}
+//~^ disallowed_names
 
 fn main() {
     let toto = 42;
+    //~^ disallowed_names
     let tata = 42;
+    //~^ disallowed_names
     let titi = 42;
+    //~^ disallowed_names
 
     let tatab = 42;
     let tatatataic = 42;
 
     match (42, Some(1337), Some(0)) {
         (toto, Some(tata), titi @ Some(_)) => (),
+        //~^ disallowed_names
+        //~| disallowed_names
+        //~| disallowed_names
         _ => (),
     }
 }
diff --git a/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr b/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
index 6cd0f9b0d7cb..9096ffca2796 100644
--- a/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
+++ b/src/tools/clippy/tests/ui-toml/toml_disallow/conf_french_disallowed_name.stderr
@@ -8,37 +8,37 @@ LL | fn test(toto: ()) {}
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_names)]`
 
 error: use of a disallowed/placeholder name `toto`
-  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:9:9
+  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:10:9
    |
 LL |     let toto = 42;
    |         ^^^^
 
 error: use of a disallowed/placeholder name `tata`
-  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:10:9
+  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:12:9
    |
 LL |     let tata = 42;
    |         ^^^^
 
 error: use of a disallowed/placeholder name `titi`
-  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:11:9
+  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:14:9
    |
 LL |     let titi = 42;
    |         ^^^^
 
 error: use of a disallowed/placeholder name `toto`
-  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:17:10
+  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:21:10
    |
 LL |         (toto, Some(tata), titi @ Some(_)) => (),
    |          ^^^^
 
 error: use of a disallowed/placeholder name `tata`
-  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:17:21
+  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:21:21
    |
 LL |         (toto, Some(tata), titi @ Some(_)) => (),
    |                     ^^^^
 
 error: use of a disallowed/placeholder name `titi`
-  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:17:28
+  --> tests/ui-toml/toml_disallow/conf_french_disallowed_name.rs:21:28
    |
 LL |         (toto, Some(tata), titi @ Some(_)) => (),
    |                            ^^^^
diff --git a/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs b/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
index 17fceae01780..dd170d6baf85 100644
--- a/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
+++ b/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs
@@ -1,5 +1,3 @@
-//@compile-flags: --crate-name conf_disallowed_methods
-
 #![allow(clippy::needless_raw_strings)]
 #![warn(clippy::disallowed_methods)]
 #![allow(clippy::useless_vec)]
@@ -33,30 +31,44 @@ mod local_mod {
 
 fn main() {
     let re = Regex::new(r"ab.*c").unwrap();
+    //~^ disallowed_methods
     re.is_match("abc");
+    //~^ disallowed_methods
 
     let mut a = vec![1, 2, 3, 4];
     a.iter().sum::<i32>();
+    //~^ disallowed_methods
 
     a.sort_unstable();
+    //~^ disallowed_methods
 
     // FIXME(f16_f128): add a clamp test once the function is available
     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
+    //~^ disallowed_methods
     let _ = 2.0f64.clamp(3.0f64, 4.0f64);
 
     let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
+    //~^ disallowed_methods
     let re = indirect(".").unwrap();
 
     let in_call = Box::new(f32::clamp);
+    //~^ disallowed_methods
     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
+    //~^ disallowed_methods
 
     // resolve ambiguity between `futures::stream::select_all` the module and the function
     let same_name_as_module = select_all(vec![empty::<()>()]);
+    //~^ disallowed_methods
 
     local_fn();
+    //~^ disallowed_methods
     local_mod::f();
+    //~^ disallowed_methods
     let s = Struct;
     s.method();
+    //~^ disallowed_methods
     s.provided_method();
+    //~^ disallowed_methods
     s.implemented_method();
+    //~^ disallowed_methods
 }
diff --git a/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr b/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
index e77b2b959497..f7dda81eb936 100644
--- a/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
+++ b/src/tools/clippy/tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.stderr
@@ -1,5 +1,5 @@
 error: use of a disallowed method `regex::Regex::new`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:35:14
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:33:14
    |
 LL |     let re = Regex::new(r"ab.*c").unwrap();
    |              ^^^^^^^^^^
@@ -8,7 +8,7 @@ LL |     let re = Regex::new(r"ab.*c").unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_methods)]`
 
 error: use of a disallowed method `regex::Regex::is_match`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:36:8
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:35:8
    |
 LL |     re.is_match("abc");
    |        ^^^^^^^^
@@ -22,67 +22,67 @@ LL |     a.iter().sum::<i32>();
    |              ^^^
 
 error: use of a disallowed method `slice::sort_unstable`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:41:7
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:42:7
    |
 LL |     a.sort_unstable();
    |       ^^^^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:44:20
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:46:20
    |
 LL |     let _ = 2.0f32.clamp(3.0f32, 4.0f32);
    |                    ^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:47:61
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:50:61
    |
 LL |     let indirect: fn(&str) -> Result<Regex, regex::Error> = Regex::new;
    |                                                             ^^^^^^^^^^
 
 error: use of a disallowed method `f32::clamp`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:50:28
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:54:28
    |
 LL |     let in_call = Box::new(f32::clamp);
    |                            ^^^^^^^^^^
 
 error: use of a disallowed method `regex::Regex::new`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:51:53
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:56:53
    |
 LL |     let in_method_call = ["^", "$"].into_iter().map(Regex::new);
    |                                                     ^^^^^^^^^^
 
 error: use of a disallowed method `futures::stream::select_all`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:54:31
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:60:31
    |
 LL |     let same_name_as_module = select_all(vec![empty::<()>()]);
    |                               ^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::local_fn`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:56:5
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:63:5
    |
 LL |     local_fn();
    |     ^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::local_mod::f`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:57:5
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:65:5
    |
 LL |     local_mod::f();
    |     ^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Struct::method`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:59:7
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:68:7
    |
 LL |     s.method();
    |       ^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Trait::provided_method`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:60:7
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:70:7
    |
 LL |     s.provided_method();
    |       ^^^^^^^^^^^^^^^
 
 error: use of a disallowed method `conf_disallowed_methods::Trait::implemented_method`
-  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:61:7
+  --> tests/ui-toml/toml_disallowed_methods/conf_disallowed_methods.rs:72:7
    |
 LL |     s.implemented_method();
    |       ^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs b/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
index f02bd07cfe7b..82c9abe8beb4 100644
--- a/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
+++ b/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs
@@ -5,40 +5,61 @@ extern crate syn;
 
 use std::sync as foo;
 use std::sync::atomic::AtomicU32;
+//~^ disallowed_types
 use std::time::Instant as Sneaky;
+//~^ disallowed_types
 
 struct HashMap;
 
 fn bad_return_type() -> fn() -> Sneaky {
+    //~^ disallowed_types
     todo!()
 }
 
 fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
+//~^ disallowed_types
+//~| disallowed_types
 
 fn trait_obj(_: &dyn std::io::Read) {}
+//~^ disallowed_types
 
 fn full_and_single_path_prim(_: usize, _: bool) {}
+//~^ disallowed_types
+//~| disallowed_types
 
 fn const_generics<const C: usize>() {}
+//~^ disallowed_types
 
 struct GenArg<const U: usize>([u8; U]);
+//~^ disallowed_types
 
 static BAD: foo::atomic::AtomicPtr<()> = foo::atomic::AtomicPtr::new(std::ptr::null_mut());
 
 fn ip(_: std::net::Ipv4Addr) {}
+//~^ disallowed_types
 
 fn listener(_: std::net::TcpListener) {}
+//~^ disallowed_types
 
 #[allow(clippy::diverging_sub_expression)]
 fn main() {
     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
+    //~^ disallowed_types
+    //~| disallowed_types
     let _ = Sneaky::now();
+    //~^ disallowed_types
     let _ = foo::atomic::AtomicU32::new(0);
+    //~^ disallowed_types
     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
+    //~^ disallowed_types
+    //~| disallowed_types
     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
+    //~^ disallowed_types
     let _ = syn::Ident::new("", todo!());
+    //~^ disallowed_types
     let _ = HashMap;
     let _: usize = 64_usize;
+    //~^ disallowed_types
 }
 
 mod useless_attribute {
diff --git a/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr b/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr
index 322cde15526a..18bc36ca1e33 100644
--- a/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr
+++ b/src/tools/clippy/tests/ui-toml/toml_disallowed_types/conf_disallowed_types.stderr
@@ -8,61 +8,61 @@ LL | use std::sync::atomic::AtomicU32;
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_types)]`
 
 error: use of a disallowed type `std::time::Instant`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:8:1
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:9:1
    |
 LL | use std::time::Instant as Sneaky;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::time::Instant`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:12:33
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:14:33
    |
 LL | fn bad_return_type() -> fn() -> Sneaky {
    |                                 ^^^^^^
 
 error: use of a disallowed type `std::time::Instant`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:16:28
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:19:28
    |
 LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
    |                            ^^^^^^
 
 error: use of a disallowed type `std::sync::atomic::AtomicU32`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:16:39
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:19:39
    |
 LL | fn bad_arg_type(_: impl Fn(Sneaky) -> foo::atomic::AtomicU32) {}
    |                                       ^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::io::Read`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:18:22
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:23:22
    |
 LL | fn trait_obj(_: &dyn std::io::Read) {}
    |                      ^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::primitive::usize`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:20:33
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:26:33
    |
 LL | fn full_and_single_path_prim(_: usize, _: bool) {}
    |                                 ^^^^^
 
 error: use of a disallowed type `bool`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:20:43
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:26:43
    |
 LL | fn full_and_single_path_prim(_: usize, _: bool) {}
    |                                           ^^^^
 
 error: use of a disallowed type `std::primitive::usize`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:22:28
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:30:28
    |
 LL | fn const_generics<const C: usize>() {}
    |                            ^^^^^
 
 error: use of a disallowed type `std::primitive::usize`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:24:24
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:33:24
    |
 LL | struct GenArg<const U: usize>([u8; U]);
    |                        ^^^^^
 
 error: use of a disallowed type `std::net::Ipv4Addr`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:28:10
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:38:10
    |
 LL | fn ip(_: std::net::Ipv4Addr) {}
    |          ^^^^^^^^^^^^^^^^^^
@@ -70,61 +70,61 @@ LL | fn ip(_: std::net::Ipv4Addr) {}
    = note: no IPv4 allowed
 
 error: use of a disallowed type `std::net::TcpListener`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:30:16
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:41:16
    |
 LL | fn listener(_: std::net::TcpListener) {}
    |                ^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::collections::HashMap`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:34:48
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:46:48
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
    |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::collections::HashMap`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:34:12
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:46:12
    |
 LL |     let _: std::collections::HashMap<(), ()> = std::collections::HashMap::new();
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::time::Instant`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:35:13
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:49:13
    |
 LL |     let _ = Sneaky::now();
    |             ^^^^^^
 
 error: use of a disallowed type `std::sync::atomic::AtomicU32`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:36:13
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:51:13
    |
 LL |     let _ = foo::atomic::AtomicU32::new(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::sync::atomic::AtomicU32`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:37:17
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:53:17
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `std::sync::atomic::AtomicU32`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:37:48
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:53:48
    |
 LL |     static FOO: std::sync::atomic::AtomicU32 = foo::atomic::AtomicU32::new(1);
    |                                                ^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of a disallowed type `syn::TypePath`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:38:43
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:56:43
    |
 LL |     let _: std::collections::BTreeMap<(), syn::TypePath> = Default::default();
    |                                           ^^^^^^^^^^^^^
 
 error: use of a disallowed type `proc_macro2::Ident`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:39:13
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:58:13
    |
 LL |     let _ = syn::Ident::new("", todo!());
    |             ^^^^^^^^^^
 
 error: use of a disallowed type `std::primitive::usize`
-  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:41:12
+  --> tests/ui-toml/toml_disallowed_types/conf_disallowed_types.rs:61:12
    |
 LL |     let _: usize = 64_usize;
    |            ^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.fixed b/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.fixed
index 8092e40ff9f1..d44f5fb84bd5 100644
--- a/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.fixed
+++ b/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.fixed
@@ -16,9 +16,11 @@ fn main() {
     let z = 1;
 
     Foo { x, y, z: z };
+    //~^ inconsistent_struct_constructor
 
     Foo {
         x,
+        //~^ inconsistent_struct_constructor
         z: z,
         ..Default::default()
     };
@@ -35,6 +37,7 @@ mod field_attributes {
         BodyVisitor {
             macro_unsafe_blocks: Vec::new(),
             #[expect(clippy::bool_to_int_with_if)] // obfuscates the meaning
+            //~^ inconsistent_struct_constructor
             expn_depth: if condition { 1 } else { 0 },
         };
     }
@@ -53,6 +56,7 @@ mod cfgs_between_fields {
         }
         let s = S {
             a: 3,
+            //~^ inconsistent_struct_constructor
             b: 2,
             #[cfg(all())]
             c: 1,
@@ -70,6 +74,7 @@ mod cfgs_between_fields {
         }
         let s = S {
             a: 3,
+            //~^ inconsistent_struct_constructor
             #[cfg(any())]
             c: 1,
             b: 2,
diff --git a/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs b/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs
index cd1aff966528..77ac2b4e7c11 100644
--- a/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs
+++ b/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs
@@ -16,9 +16,11 @@ fn main() {
     let z = 1;
 
     Foo { y, x, z: z };
+    //~^ inconsistent_struct_constructor
 
     Foo {
         z: z,
+        //~^ inconsistent_struct_constructor
         x,
         ..Default::default()
     };
@@ -34,6 +36,7 @@ mod field_attributes {
     fn check_body(condition: bool) {
         BodyVisitor {
             #[expect(clippy::bool_to_int_with_if)] // obfuscates the meaning
+            //~^ inconsistent_struct_constructor
             expn_depth: if condition { 1 } else { 0 },
             macro_unsafe_blocks: Vec::new(),
         };
@@ -53,6 +56,7 @@ mod cfgs_between_fields {
         }
         let s = S {
             d: 0,
+            //~^ inconsistent_struct_constructor
             #[cfg(all())]
             c: 1,
             b: 2,
@@ -70,6 +74,7 @@ mod cfgs_between_fields {
         }
         let s = S {
             d: 0,
+            //~^ inconsistent_struct_constructor
             #[cfg(any())]
             c: 1,
             b: 2,
diff --git a/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.stderr b/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.stderr
index d2533960b84c..be85fa574480 100644
--- a/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.stderr
+++ b/src/tools/clippy/tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.stderr
@@ -8,22 +8,25 @@ LL |     Foo { y, x, z: z };
    = help: to override `-D warnings` add `#[allow(clippy::inconsistent_struct_constructor)]`
 
 error: struct constructor field order is inconsistent with struct definition field order
-  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:21:9
+  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:22:9
    |
 LL | /         z: z,
+LL | |
 LL | |         x,
    | |_________^
    |
 help: if the field evaluation order doesn't matter, try
    |
 LL ~         x,
+LL +
 LL ~         z: z,
    |
 
 error: struct constructor field order is inconsistent with struct definition field order
-  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:36:13
+  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:38:13
    |
 LL | /             #[expect(clippy::bool_to_int_with_if)] // obfuscates the meaning
+LL | |
 LL | |             expn_depth: if condition { 1 } else { 0 },
 LL | |             macro_unsafe_blocks: Vec::new(),
    | |___________________________________________^
@@ -32,13 +35,15 @@ help: if the field evaluation order doesn't matter, try
    |
 LL ~             macro_unsafe_blocks: Vec::new(),
 LL +             #[expect(clippy::bool_to_int_with_if)] // obfuscates the meaning
+LL +
 LL ~             expn_depth: if condition { 1 } else { 0 },
    |
 
 error: struct constructor field order is inconsistent with struct definition field order
-  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:55:13
+  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:58:13
    |
 LL | /             d: 0,
+LL | |
 LL | |             #[cfg(all())]
 LL | |             c: 1,
 LL | |             b: 2,
@@ -48,6 +53,7 @@ LL | |             a: 3,
 help: if the field evaluation order doesn't matter, try
    |
 LL ~             a: 3,
+LL +
 LL +             b: 2,
 LL +             #[cfg(all())]
 LL +             c: 1,
@@ -55,9 +61,10 @@ LL ~             d: 0,
    |
 
 error: struct constructor field order is inconsistent with struct definition field order
-  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:72:13
+  --> tests/ui-toml/toml_inconsistent_struct_constructor/conf_inconsistent_struct_constructor.rs:76:13
    |
 LL | /             d: 0,
+LL | |
 LL | |             #[cfg(any())]
 LL | |             c: 1,
 LL | |             b: 2,
@@ -67,6 +74,7 @@ LL | |             a: 3,
 help: if the field evaluation order doesn't matter, try
    |
 LL ~             a: 3,
+LL +
 LL +             #[cfg(any())]
 LL +             c: 1,
 LL +             b: 2,
diff --git a/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/clippy.toml b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/clippy.toml
new file mode 100644
index 000000000000..dc393f1355b5
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/clippy.toml
@@ -0,0 +1,4 @@
+disallowed-methods = [
+    { path = "replaceable_disallowed_methods::bad", replacement = "good" },
+    { path = "replaceable_disallowed_methods::questionable", replacement = "good", reason = "a better function exists" },
+]
diff --git a/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.fixed b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.fixed
new file mode 100644
index 000000000000..df28e0bc94be
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.fixed
@@ -0,0 +1,10 @@
+fn bad() {}
+fn questionable() {}
+fn good() {}
+
+fn main() {
+    good();
+    //~^ disallowed_methods
+    good();
+    //~^ disallowed_methods
+}
diff --git a/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.rs b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.rs
new file mode 100644
index 000000000000..9257f0e3e1a7
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.rs
@@ -0,0 +1,10 @@
+fn bad() {}
+fn questionable() {}
+fn good() {}
+
+fn main() {
+    bad();
+    //~^ disallowed_methods
+    questionable();
+    //~^ disallowed_methods
+}
diff --git a/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.stderr b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.stderr
new file mode 100644
index 000000000000..6f70b4ae6a9e
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.stderr
@@ -0,0 +1,17 @@
+error: use of a disallowed method `replaceable_disallowed_methods::bad`
+  --> tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.rs:6:5
+   |
+LL |     bad();
+   |     ^^^ help: use: `good`
+   |
+   = note: `-D clippy::disallowed-methods` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::disallowed_methods)]`
+
+error: use of a disallowed method `replaceable_disallowed_methods::questionable`
+  --> tests/ui-toml/toml_replaceable_disallowed_methods/replaceable_disallowed_methods.rs:8:5
+   |
+LL |     questionable();
+   |     ^^^^^^^^^^^^ help: a better function exists: `good`
+
+error: aborting due to 2 previous errors
+
diff --git a/src/tools/clippy/tests/ui-toml/toml_trivially_copy/test.rs b/src/tools/clippy/tests/ui-toml/toml_trivially_copy/test.rs
index 145a2ce441d3..46f21eef9740 100644
--- a/src/tools/clippy/tests/ui-toml/toml_trivially_copy/test.rs
+++ b/src/tools/clippy/tests/ui-toml/toml_trivially_copy/test.rs
@@ -13,6 +13,8 @@ struct Bar(u32);
 fn good(a: &mut u32, b: u32, c: &Bar, d: &u32) {}
 
 fn bad(x: &u16, y: &Foo) {}
+//~^ trivially_copy_pass_by_ref
+//~| trivially_copy_pass_by_ref
 
 fn main() {
     let (mut a, b, c, d, x, y) = (0, 0, Bar(0), 0, 0, Foo(0));
diff --git a/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs b/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
index 49139b60a9f4..8d02924c9d93 100644
--- a/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
+++ b/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.rs
@@ -1,4 +1,6 @@
 //@no-rustfix
-//@error-in-other-file: unknown field `foobar`, expected one of
+//@error-in-other-file: unknown field
+//@error-in-other-file: error reading Clippy
+//@error-in-other-file: error reading Clippy
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr b/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
index 01e9f5c26a37..acfe739277cc 100644
--- a/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
+++ b/src/tools/clippy/tests/ui-toml/toml_unknown_key/conf_unknown_key.stderr
@@ -5,6 +5,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            accept-comment-above-statement
            allow-comparison-to-zero
            allow-dbg-in-tests
+           allow-expect-in-consts
            allow-expect-in-tests
            allow-indexing-slicing-in-tests
            allow-mixed-uninlined-format-args
@@ -13,6 +14,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-renamed-params-for
+           allow-unwrap-in-consts
            allow-unwrap-in-tests
            allow-useless-vec-in-tests
            allowed-dotfiles
@@ -29,6 +31,7 @@ error: error reading Clippy's configuration file: unknown field `foobar`, expect
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-incompatible-msrv-in-tests
            check-private-items
            cognitive-complexity-threshold
            cyclomatic-complexity-threshold
@@ -94,6 +97,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            accept-comment-above-statement
            allow-comparison-to-zero
            allow-dbg-in-tests
+           allow-expect-in-consts
            allow-expect-in-tests
            allow-indexing-slicing-in-tests
            allow-mixed-uninlined-format-args
@@ -102,6 +106,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            allow-print-in-tests
            allow-private-module-inception
            allow-renamed-params-for
+           allow-unwrap-in-consts
            allow-unwrap-in-tests
            allow-useless-vec-in-tests
            allowed-dotfiles
@@ -118,6 +123,7 @@ error: error reading Clippy's configuration file: unknown field `barfoo`, expect
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-incompatible-msrv-in-tests
            check-private-items
            cognitive-complexity-threshold
            cyclomatic-complexity-threshold
@@ -183,6 +189,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            accept-comment-above-statement
            allow-comparison-to-zero
            allow-dbg-in-tests
+           allow-expect-in-consts
            allow-expect-in-tests
            allow-indexing-slicing-in-tests
            allow-mixed-uninlined-format-args
@@ -191,6 +198,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            allow-print-in-tests
            allow-private-module-inception
            allow-renamed-params-for
+           allow-unwrap-in-consts
            allow-unwrap-in-tests
            allow-useless-vec-in-tests
            allowed-dotfiles
@@ -207,6 +215,7 @@ error: error reading Clippy's configuration file: unknown field `allow_mixed_uni
            await-holding-invalid-types
            blacklisted-names
            cargo-ignore-publish
+           check-incompatible-msrv-in-tests
            check-private-items
            cognitive-complexity-threshold
            cyclomatic-complexity-threshold
diff --git a/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr b/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
index 9677beeb2c24..32ed78151d23 100644
--- a/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
+++ b/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.default.stderr
@@ -9,7 +9,7 @@ LL |     /* Safety: */ unsafe {}
    = help: to override `-D warnings` add `#[allow(clippy::undocumented_unsafe_blocks)]`
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:274:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:275:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:278:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:280:14
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |              ^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:278:29
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:280:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                             ^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:278:48
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:280:48
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                                                ^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:282:18
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:287:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                  ^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:282:37
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:287:37
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                                     ^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:286:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:293:14
    |
 LL |     let _ = *unsafe { &42 };
    |              ^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     let _ = *unsafe { &42 };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:291:19
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:299:19
    |
 LL |     let _ = match unsafe {} {
    |                   ^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     let _ = match unsafe {} {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:297:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:306:14
    |
 LL |     let _ = &unsafe {};
    |              ^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     let _ = &unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:301:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:311:14
    |
 LL |     let _ = [unsafe {}; 5];
    |              ^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     let _ = [unsafe {}; 5];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:305:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:316:13
    |
 LL |     let _ = unsafe {};
    |             ^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     let _ = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:315:8
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:327:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     t!(unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:321:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:334:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -117,7 +117,7 @@ LL |     t!();
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:329:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:343:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
@@ -125,7 +125,7 @@ LL |     unsafe {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:333:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:349:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -133,7 +133,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:343:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:360:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
@@ -141,7 +141,7 @@ LL |     unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:347:20
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:365:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -149,7 +149,7 @@ LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:354:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:373:5
    |
 LL |     unsafe impl A for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL |     unsafe impl A for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:361:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:381:9
    |
 LL |         unsafe impl B for (u32) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL |         unsafe impl B for (u32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:382:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:403:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -177,7 +177,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:407:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:429:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -189,7 +189,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:415:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:439:5
    |
 LL |     unsafe impl T for (i32) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -197,7 +197,7 @@ LL |     unsafe impl T for (i32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:407:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:429:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -209,7 +209,7 @@ LL |     no_safety_comment!(u32);
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:421:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:446:5
    |
 LL |     unsafe impl T for (bool) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL |     unsafe impl T for (bool) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:467:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:493:5
    |
 LL |     unsafe impl NoComment for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -225,7 +225,7 @@ LL |     unsafe impl NoComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:471:19
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:498:19
    |
 LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -233,7 +233,7 @@ LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:475:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:503:5
    |
 LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,13 +241,13 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: constant item has unnecessary safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:479:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:508:5
    |
 LL |     const BIG_NUMBER: i32 = 1000000;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider removing the safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:478:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:507:5
    |
 LL |     // SAFETY:
    |     ^^^^^^^^^^
@@ -255,7 +255,7 @@ LL |     // SAFETY:
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:480:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:510:5
    |
 LL |     unsafe impl Interference for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -263,7 +263,7 @@ LL |     unsafe impl Interference for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:487:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:518:5
    |
 LL |     unsafe impl ImplInFn for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -271,7 +271,7 @@ LL |     unsafe impl ImplInFn for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:496:1
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:528:1
    |
 LL | unsafe impl CrateRoot for () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -279,24 +279,23 @@ LL | unsafe impl CrateRoot for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: statement has unnecessary safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:509:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:543:5
    |
 LL | /     let _ = {
+LL | |
 LL | |         if unsafe { true } {
-LL | |             todo!();
-LL | |         } else {
 ...  |
 LL | |     };
    | |______^
    |
 help: consider removing the safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:508:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:542:5
    |
 LL |     // SAFETY: this is more than one level away, so it should warn
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:510:12
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:545:12
    |
 LL |         if unsafe { true } {
    |            ^^^^^^^^^^^^^^^
@@ -304,7 +303,7 @@ LL |         if unsafe { true } {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:513:23
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:549:23
    |
 LL |             let bar = unsafe {};
    |                       ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr b/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
index 0eccdd428008..83a6986addf2 100644
--- a/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
+++ b/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.disabled.stderr
@@ -9,7 +9,7 @@ LL |     /* Safety: */ unsafe {}
    = help: to override `-D warnings` add `#[allow(clippy::undocumented_unsafe_blocks)]`
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:274:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:275:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:278:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:280:14
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |              ^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:278:29
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:280:29
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                             ^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:278:48
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:280:48
    |
 LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    |                                                ^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:282:18
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:287:18
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                  ^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:282:37
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:287:37
    |
 LL |     let _ = (42, unsafe {}, "test", unsafe {});
    |                                     ^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     let _ = (42, unsafe {}, "test", unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:286:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:293:14
    |
 LL |     let _ = *unsafe { &42 };
    |              ^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     let _ = *unsafe { &42 };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:291:19
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:299:19
    |
 LL |     let _ = match unsafe {} {
    |                   ^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     let _ = match unsafe {} {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:297:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:306:14
    |
 LL |     let _ = &unsafe {};
    |              ^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     let _ = &unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:301:14
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:311:14
    |
 LL |     let _ = [unsafe {}; 5];
    |              ^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     let _ = [unsafe {}; 5];
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:305:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:316:13
    |
 LL |     let _ = unsafe {};
    |             ^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     let _ = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:315:8
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:327:8
    |
 LL |     t!(unsafe {});
    |        ^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     t!(unsafe {});
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:321:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:334:13
    |
 LL |             unsafe {}
    |             ^^^^^^^^^
@@ -117,7 +117,7 @@ LL |     t!();
    = note: this error originates in the macro `t` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:329:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:343:5
    |
 LL |     unsafe {} // SAFETY:
    |     ^^^^^^^^^
@@ -125,7 +125,7 @@ LL |     unsafe {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:333:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:349:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -133,7 +133,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:343:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:360:5
    |
 LL |     unsafe {};
    |     ^^^^^^^^^
@@ -141,7 +141,7 @@ LL |     unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:347:20
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:365:20
    |
 LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -149,7 +149,7 @@ LL |     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:354:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:373:5
    |
 LL |     unsafe impl A for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL |     unsafe impl A for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:361:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:381:9
    |
 LL |         unsafe impl B for (u32) {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL |         unsafe impl B for (u32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:382:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:403:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -177,7 +177,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:407:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:429:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -189,7 +189,7 @@ LL |     no_safety_comment!(());
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:415:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:439:5
    |
 LL |     unsafe impl T for (i32) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -197,7 +197,7 @@ LL |     unsafe impl T for (i32) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:407:13
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:429:13
    |
 LL |             unsafe impl T for $t {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -209,7 +209,7 @@ LL |     no_safety_comment!(u32);
    = note: this error originates in the macro `no_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:421:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:446:5
    |
 LL |     unsafe impl T for (bool) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL |     unsafe impl T for (bool) {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:467:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:493:5
    |
 LL |     unsafe impl NoComment for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -225,7 +225,7 @@ LL |     unsafe impl NoComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:471:19
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:498:19
    |
 LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -233,7 +233,7 @@ LL |     /* SAFETY: */ unsafe impl InlineComment for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:475:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:503:5
    |
 LL |     unsafe impl TrailingComment for () {} // SAFETY:
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,13 +241,13 @@ LL |     unsafe impl TrailingComment for () {} // SAFETY:
    = help: consider adding a safety comment on the preceding line
 
 error: constant item has unnecessary safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:479:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:508:5
    |
 LL |     const BIG_NUMBER: i32 = 1000000;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider removing the safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:478:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:507:5
    |
 LL |     // SAFETY:
    |     ^^^^^^^^^^
@@ -255,7 +255,7 @@ LL |     // SAFETY:
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:480:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:510:5
    |
 LL |     unsafe impl Interference for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -263,7 +263,7 @@ LL |     unsafe impl Interference for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:487:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:518:5
    |
 LL |     unsafe impl ImplInFn for () {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -271,7 +271,7 @@ LL |     unsafe impl ImplInFn for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe impl missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:496:1
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:528:1
    |
 LL | unsafe impl CrateRoot for () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -279,7 +279,7 @@ LL | unsafe impl CrateRoot for () {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:506:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:539:9
    |
 LL |         unsafe {};
    |         ^^^^^^^^^
@@ -287,24 +287,23 @@ LL |         unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: statement has unnecessary safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:509:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:543:5
    |
 LL | /     let _ = {
+LL | |
 LL | |         if unsafe { true } {
-LL | |             todo!();
-LL | |         } else {
 ...  |
 LL | |     };
    | |______^
    |
 help: consider removing the safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:508:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:542:5
    |
 LL |     // SAFETY: this is more than one level away, so it should warn
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:510:12
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:545:12
    |
 LL |         if unsafe { true } {
    |            ^^^^^^^^^^^^^^^
@@ -312,7 +311,7 @@ LL |         if unsafe { true } {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:513:23
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:549:23
    |
 LL |             let bar = unsafe {};
    |                       ^^^^^^^^^
@@ -320,7 +319,7 @@ LL |             let bar = unsafe {};
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:531:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:568:9
    |
 LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -328,7 +327,7 @@ LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:535:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:573:9
    |
 LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -336,7 +335,7 @@ LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line()
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:539:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:578:9
    |
 LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -344,7 +343,7 @@ LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line()
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:545:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:585:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
@@ -352,7 +351,7 @@ LL |     unsafe {}
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:549:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:590:5
    |
 LL |     unsafe {
    |     ^^^^^^^^
@@ -360,7 +359,7 @@ LL |     unsafe {
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:556:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:598:9
    |
 LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -368,7 +367,7 @@ LL |         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:561:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:604:9
    |
 LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -376,7 +375,7 @@ LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line()
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:567:9
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:611:9
    |
 LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -384,7 +383,7 @@ LL |         unsafe { a_const_function_with_a_very_long_name_to_break_the_line()
    = help: consider adding a safety comment on the preceding line
 
 error: unsafe block missing a safety comment
-  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:572:5
+  --> tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs:617:5
    |
 LL |     unsafe {}
    |     ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs b/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
index 02170e1f7402..6a3fda3df5c3 100644
--- a/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
+++ b/src/tools/clippy/tests/ui-toml/undocumented_unsafe_blocks/undocumented_unsafe_blocks.rs
@@ -268,41 +268,53 @@ fn in_closure(x: *const u32) {
 #[rustfmt::skip]
 fn inline_block_comment() {
     /* Safety: */ unsafe {}
+    //~^ undocumented_unsafe_blocks
 }
 
 fn no_comment() {
     unsafe {}
+    //~^ undocumented_unsafe_blocks
 }
 
 fn no_comment_array() {
     let _ = [unsafe { 14 }, unsafe { 15 }, 42, unsafe { 16 }];
+    //~^ undocumented_unsafe_blocks
+    //~| undocumented_unsafe_blocks
+    //~| undocumented_unsafe_blocks
 }
 
 fn no_comment_tuple() {
     let _ = (42, unsafe {}, "test", unsafe {});
+    //~^ undocumented_unsafe_blocks
+    //~| undocumented_unsafe_blocks
 }
 
 fn no_comment_unary() {
     let _ = *unsafe { &42 };
+    //~^ undocumented_unsafe_blocks
 }
 
 #[allow(clippy::match_single_binding)]
 fn no_comment_match() {
     let _ = match unsafe {} {
+        //~^ undocumented_unsafe_blocks
         _ => {},
     };
 }
 
 fn no_comment_addr_of() {
     let _ = &unsafe {};
+    //~^ undocumented_unsafe_blocks
 }
 
 fn no_comment_repeat() {
     let _ = [unsafe {}; 5];
+    //~^ undocumented_unsafe_blocks
 }
 
 fn local_no_comment() {
     let _ = unsafe {};
+    //~^ undocumented_unsafe_blocks
 }
 
 fn no_comment_macro_call() {
@@ -313,12 +325,14 @@ fn no_comment_macro_call() {
     }
 
     t!(unsafe {});
+    //~^ undocumented_unsafe_blocks
 }
 
 fn no_comment_macro_def() {
     macro_rules! t {
         () => {
             unsafe {}
+            //~^ undocumented_unsafe_blocks
         };
     }
 
@@ -327,10 +341,13 @@ fn no_comment_macro_def() {
 
 fn trailing_comment() {
     unsafe {} // SAFETY:
+    //
+    //~^^ undocumented_unsafe_blocks
 }
 
 fn internal_comment() {
     unsafe {
+        //~^ undocumented_unsafe_blocks
         // SAFETY:
     }
 }
@@ -341,10 +358,12 @@ fn interference() {
     let _ = 42;
 
     unsafe {};
+    //~^ undocumented_unsafe_blocks
 }
 
 pub fn print_binary_tree() {
     println!("{}", unsafe { String::from_utf8_unchecked(vec![]) });
+    //~^ undocumented_unsafe_blocks
 }
 
 mod unsafe_impl_smoke_test {
@@ -352,6 +371,7 @@ mod unsafe_impl_smoke_test {
 
     // error: no safety comment
     unsafe impl A for () {}
+    //~^ undocumented_unsafe_blocks
 
     // Safety: ok
     unsafe impl A for (i32) {}
@@ -359,6 +379,7 @@ mod unsafe_impl_smoke_test {
     mod sub_mod {
         // error:
         unsafe impl B for (u32) {}
+        //~^ undocumented_unsafe_blocks
         unsafe trait B {}
     }
 
@@ -380,6 +401,7 @@ mod unsafe_impl_from_macro {
     macro_rules! no_safety_comment {
         ($t:ty) => {
             unsafe impl T for $t {}
+            //~^ undocumented_unsafe_blocks
         };
     }
 
@@ -405,6 +427,8 @@ mod unsafe_impl_macro_and_not_macro {
     macro_rules! no_safety_comment {
         ($t:ty) => {
             unsafe impl T for $t {}
+            //~^ undocumented_unsafe_blocks
+            //~| undocumented_unsafe_blocks
         };
     }
 
@@ -413,12 +437,14 @@ mod unsafe_impl_macro_and_not_macro {
 
     // error
     unsafe impl T for (i32) {}
+    //~^ undocumented_unsafe_blocks
 
     // ok
     no_safety_comment!(u32);
 
     // error
     unsafe impl T for (bool) {}
+    //~^ undocumented_unsafe_blocks
 }
 
 #[rustfmt::skip]
@@ -465,19 +491,24 @@ mod unsafe_impl_invalid_comment {
     unsafe trait NoComment {}
 
     unsafe impl NoComment for () {}
+    //~^ undocumented_unsafe_blocks
 
     unsafe trait InlineComment {}
 
     /* SAFETY: */ unsafe impl InlineComment for () {}
+    //~^ undocumented_unsafe_blocks
 
     unsafe trait TrailingComment {}
 
     unsafe impl TrailingComment for () {} // SAFETY:
+    //~^ undocumented_unsafe_blocks
 
     unsafe trait Interference {}
     // SAFETY:
     const BIG_NUMBER: i32 = 1000000;
+    //~^ unnecessary_safety_comment
     unsafe impl Interference for () {}
+    //~^ undocumented_unsafe_blocks
 }
 
 unsafe trait ImplInFn {}
@@ -485,6 +516,7 @@ unsafe trait ImplInFn {}
 fn impl_in_fn() {
     // error
     unsafe impl ImplInFn for () {}
+    //~^ undocumented_unsafe_blocks
 
     // SAFETY: ok
     unsafe impl ImplInFn for (i32) {}
@@ -494,6 +526,7 @@ unsafe trait CrateRoot {}
 
 // error
 unsafe impl CrateRoot for () {}
+//~^ undocumented_unsafe_blocks
 
 // SAFETY: ok
 unsafe impl CrateRoot for (i32) {}
@@ -504,13 +537,17 @@ fn nested_block_separation_issue_9142() {
         // we need this comment to avoid rustfmt putting
         // it all on one line
         unsafe {};
+    //~[disabled]^ undocumented_unsafe_blocks
 
     // SAFETY: this is more than one level away, so it should warn
     let _ = {
+        //~^ unnecessary_safety_comment
         if unsafe { true } {
+            //~^ undocumented_unsafe_blocks
             todo!();
         } else {
             let bar = unsafe {};
+            //~^ undocumented_unsafe_blocks
             todo!();
             bar
         }
@@ -529,24 +566,29 @@ fn separate_line_from_let_issue_10832() {
     // SAFETY: fail ONLY if `accept-comment-above-statement = false`
     let _some_variable_with_a_very_long_name_to_break_the_line =
         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+    //~[disabled]^ undocumented_unsafe_blocks
 
     // SAFETY: fail ONLY if `accept-comment-above-statement = false`
     const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+    //~[disabled]^ undocumented_unsafe_blocks
 
     // SAFETY: fail ONLY if `accept-comment-above-statement = false`
     static _SOME_STATIC_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+    //~[disabled]^ undocumented_unsafe_blocks
 }
 
 fn above_expr_attribute_issue_8679<T: Copy>() {
     // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[allow(unsafe_code)]
     unsafe {}
+    //~[disabled]^ undocumented_unsafe_blocks
 
     // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[expect(unsafe_code, reason = "totally safe")]
     unsafe {
+        //~[disabled]^ undocumented_unsafe_blocks
         *std::ptr::null::<T>()
     };
 
@@ -554,22 +596,26 @@ fn above_expr_attribute_issue_8679<T: Copy>() {
     #[allow(unsafe_code)]
     let _some_variable_with_a_very_long_name_to_break_the_line =
         unsafe { a_function_with_a_very_long_name_to_break_the_line() };
+    //~[disabled]^ undocumented_unsafe_blocks
 
     // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[allow(unsafe_code)]
     const _SOME_CONST_WITH_A_VERY_LONG_NAME_TO_BREAK_THE_LINE: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+    //~[disabled]^ undocumented_unsafe_blocks
 
     // SAFETY: fail ONLY if `accept-comment-above-attribute = false`
     #[allow(unsafe_code)]
     #[allow(non_upper_case_globals)]
     static _some_static_with_a_very_long_name_to_break_the_line: u32 =
         unsafe { a_const_function_with_a_very_long_name_to_break_the_line() };
+    //~[disabled]^ undocumented_unsafe_blocks
 
     // SAFETY:
     #[allow(unsafe_code)]
     // This shouldn't work either
     unsafe {}
+    //~[disabled]^ undocumented_unsafe_blocks
 }
 
 mod issue_11246 {
diff --git a/src/tools/clippy/tests/ui-toml/unwrap_used/clippy.toml b/src/tools/clippy/tests/ui-toml/unwrap_used/clippy.toml
index 154626ef4e81..6fd1eb6f8d0d 100644
--- a/src/tools/clippy/tests/ui-toml/unwrap_used/clippy.toml
+++ b/src/tools/clippy/tests/ui-toml/unwrap_used/clippy.toml
@@ -1 +1,2 @@
+allow-unwrap-in-consts = false
 allow-unwrap-in-tests = true
diff --git a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.fixed b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.fixed
index cdb8fa0454cd..9b4eaa208eb2 100644
--- a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.fixed
+++ b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.fixed
@@ -36,23 +36,45 @@ fn main() {
     {
         // Test `get().unwrap()`
         let _ = &boxed_slice[1];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_slice[0];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_vec[0];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_vecdeque[0];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_hashmap[&1];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_btreemap[&1];
+        //~^ get_unwrap
+        //~| unwrap_used
         #[allow(clippy::unwrap_used)]
         let _ = false_positive.get(0).unwrap();
         // Test with deref
         let _: u8 = boxed_slice[1];
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 
     {
         // Test `get_mut().unwrap()`
         boxed_slice[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         some_slice[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         some_vec[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         some_vecdeque[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         // Check false positives
         #[allow(clippy::unwrap_used)]
         {
@@ -65,7 +87,11 @@ fn main() {
     {
         // Test `get().unwrap().foo()` and `get_mut().unwrap().bar()`
         let _ = some_vec[0..1].to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vec[0..1].to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 }
 
@@ -73,6 +99,7 @@ fn main() {
 fn test() {
     let boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
     let _ = &boxed_slice[1];
+    //~^ get_unwrap
 }
 
 #[cfg(test)]
@@ -92,5 +119,6 @@ mod issue9612 {
         let _a: u8 = 5.try_into().expect("");
         // should still warn
         let _ = &Box::new([0])[1];
+        //~^ get_unwrap
     }
 }
diff --git a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.rs b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.rs
index e53d53db5f7a..4845efa68733 100644
--- a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.rs
+++ b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.rs
@@ -36,23 +36,45 @@ fn main() {
     {
         // Test `get().unwrap()`
         let _ = boxed_slice.get(1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_slice.get(0).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vec.get(0).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vecdeque.get(0).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_hashmap.get(&1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_btreemap.get(&1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         #[allow(clippy::unwrap_used)]
         let _ = false_positive.get(0).unwrap();
         // Test with deref
         let _: u8 = *boxed_slice.get(1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 
     {
         // Test `get_mut().unwrap()`
         *boxed_slice.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         *some_slice.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         *some_vec.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         *some_vecdeque.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         // Check false positives
         #[allow(clippy::unwrap_used)]
         {
@@ -65,7 +87,11 @@ fn main() {
     {
         // Test `get().unwrap().foo()` and `get_mut().unwrap().bar()`
         let _ = some_vec.get(0..1).unwrap().to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 }
 
@@ -73,6 +99,7 @@ fn main() {
 fn test() {
     let boxed_slice: Box<[u8]> = Box::new([0, 1, 2, 3]);
     let _ = boxed_slice.get(1).unwrap();
+    //~^ get_unwrap
 }
 
 #[cfg(test)]
@@ -92,5 +119,6 @@ mod issue9612 {
         let _a: u8 = 5.try_into().expect("");
         // should still warn
         let _ = Box::new([0]).get(1).unwrap();
+        //~^ get_unwrap
     }
 }
diff --git a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr
index 2aff276a4a12..135e35323fdb 100644
--- a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr
+++ b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used.stderr
@@ -24,7 +24,7 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:39:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL +         let _ = &some_slice[0];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:39:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |         let _ = some_slice.get(0).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:40:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:44:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL +         let _ = &some_vec[0];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:40:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:44:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |         let _ = some_vec.get(0).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:47:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -78,7 +78,7 @@ LL +         let _ = &some_vecdeque[0];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:41:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:47:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -87,7 +87,7 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:42:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:50:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -99,7 +99,7 @@ LL +         let _ = &some_hashmap[&1];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:42:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:50:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:43:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:53:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL +         let _ = &some_btreemap[&1];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:43:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:53:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:47:21
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:59:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -141,7 +141,7 @@ LL +         let _: u8 = boxed_slice[1];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:47:22
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:59:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -150,7 +150,7 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:52:9
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:66:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -162,7 +162,7 @@ LL +         boxed_slice[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:52:10
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:66:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -171,7 +171,7 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:53:9
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:69:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -183,7 +183,7 @@ LL +         some_slice[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:53:10
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:69:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -192,7 +192,7 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:54:9
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:72:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -204,7 +204,7 @@ LL +         some_vec[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:54:10
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:72:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -213,7 +213,7 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:55:9
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:75:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -225,7 +225,7 @@ LL +         some_vecdeque[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:55:10
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:75:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -234,7 +234,7 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:67:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:89:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -246,7 +246,7 @@ LL +         let _ = some_vec[0..1].to_vec();
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:67:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:89:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -255,7 +255,7 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:68:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:92:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -267,7 +267,7 @@ LL +         let _ = some_vec[0..1].to_vec();
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:68:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:92:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -276,7 +276,7 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:75:13
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:101:13
    |
 LL |     let _ = boxed_slice.get(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -288,7 +288,7 @@ LL +     let _ = &boxed_slice[1];
    |
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui-toml/unwrap_used/unwrap_used.rs:94:17
+  --> tests/ui-toml/unwrap_used/unwrap_used.rs:121:17
    |
 LL |         let _ = Box::new([0]).get(1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used_const.rs b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used_const.rs
new file mode 100644
index 000000000000..c7d8e8c1ffb5
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used_const.rs
@@ -0,0 +1,11 @@
+#![warn(clippy::unwrap_used)]
+
+fn main() {
+    const SOME: Option<i32> = Some(3);
+    const UNWRAPPED: i32 = SOME.unwrap();
+    //~^ ERROR: used `unwrap()` on an `Option` value
+    const {
+        SOME.unwrap();
+        //~^ ERROR: used `unwrap()` on an `Option` value
+    }
+}
diff --git a/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used_const.stderr b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used_const.stderr
new file mode 100644
index 000000000000..362b41bc1bff
--- /dev/null
+++ b/src/tools/clippy/tests/ui-toml/unwrap_used/unwrap_used_const.stderr
@@ -0,0 +1,22 @@
+error: used `unwrap()` on an `Option` value
+  --> tests/ui-toml/unwrap_used/unwrap_used_const.rs:5:28
+   |
+LL |     const UNWRAPPED: i32 = SOME.unwrap();
+   |                            ^^^^^^^^^^^^^
+   |
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
+   = note: `-D clippy::unwrap-used` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
+
+error: used `unwrap()` on an `Option` value
+  --> tests/ui-toml/unwrap_used/unwrap_used_const.rs:8:9
+   |
+LL |         SOME.unwrap();
+   |         ^^^^^^^^^^^^^
+   |
+   = note: if this value is `None`, it will panic
+   = help: consider using `expect()` to provide a better panic message
+
+error: aborting due to 2 previous errors
+
diff --git a/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.fixed b/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.fixed
index afb889f157f0..4f1f9ca07273 100644
--- a/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.fixed
+++ b/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.fixed
@@ -1,24 +1,35 @@
 #![warn(clippy::upper_case_acronyms)]
 
 struct HttpResponse; // not linted by default, but with cfg option
+//~^ upper_case_acronyms
 
 struct CString; // not linted
 
 enum Flags {
     Ns, // not linted
+    //~^ upper_case_acronyms
     Cwr,
+    //~^ upper_case_acronyms
     Ece,
+    //~^ upper_case_acronyms
     Urg,
+    //~^ upper_case_acronyms
     Ack,
+    //~^ upper_case_acronyms
     Psh,
+    //~^ upper_case_acronyms
     Rst,
+    //~^ upper_case_acronyms
     Syn,
+    //~^ upper_case_acronyms
     Fin,
+    //~^ upper_case_acronyms
 }
 
 // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
 // `GccLlvmSomething`
 struct GccllvmSomething;
+//~^ upper_case_acronyms
 
 // don't warn on public items
 pub struct MIXEDCapital;
@@ -36,7 +47,9 @@ pub enum ParseError<T> {
 // private, do lint here
 enum ParseErrorPrivate<T> {
     Wasd(u8),
+    //~^ upper_case_acronyms
     WasdMixed(String),
+    //~^ upper_case_acronyms
     Utf8(std::string::FromUtf8Error),
     Parse(T, String),
 }
diff --git a/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs b/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
index 1a5cf1b1947c..da522aadfdd7 100644
--- a/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
+++ b/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs
@@ -1,24 +1,35 @@
 #![warn(clippy::upper_case_acronyms)]
 
 struct HTTPResponse; // not linted by default, but with cfg option
+//~^ upper_case_acronyms
 
 struct CString; // not linted
 
 enum Flags {
     NS, // not linted
+    //~^ upper_case_acronyms
     CWR,
+    //~^ upper_case_acronyms
     ECE,
+    //~^ upper_case_acronyms
     URG,
+    //~^ upper_case_acronyms
     ACK,
+    //~^ upper_case_acronyms
     PSH,
+    //~^ upper_case_acronyms
     RST,
+    //~^ upper_case_acronyms
     SYN,
+    //~^ upper_case_acronyms
     FIN,
+    //~^ upper_case_acronyms
 }
 
 // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
 // `GccLlvmSomething`
 struct GCCLLVMSomething;
+//~^ upper_case_acronyms
 
 // don't warn on public items
 pub struct MIXEDCapital;
@@ -36,7 +47,9 @@ pub enum ParseError<T> {
 // private, do lint here
 enum ParseErrorPrivate<T> {
     WASD(u8),
+    //~^ upper_case_acronyms
     WASDMixed(String),
+    //~^ upper_case_acronyms
     Utf8(std::string::FromUtf8Error),
     Parse(T, String),
 }
diff --git a/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr b/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
index 88917603ff8c..e1706b7472c0 100644
--- a/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
+++ b/src/tools/clippy/tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.stderr
@@ -8,73 +8,73 @@ LL | struct HTTPResponse; // not linted by default, but with cfg option
    = help: to override `-D warnings` add `#[allow(clippy::upper_case_acronyms)]`
 
 error: name `NS` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:8:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:9:5
    |
 LL |     NS, // not linted
    |     ^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ns`
 
 error: name `CWR` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:9:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:11:5
    |
 LL |     CWR,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Cwr`
 
 error: name `ECE` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:10:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:13:5
    |
 LL |     ECE,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Ece`
 
 error: name `URG` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:11:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:15:5
    |
 LL |     URG,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Urg`
 
 error: name `ACK` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:12:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:17:5
    |
 LL |     ACK,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ack`
 
 error: name `PSH` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:13:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:19:5
    |
 LL |     PSH,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Psh`
 
 error: name `RST` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:14:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:21:5
    |
 LL |     RST,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Rst`
 
 error: name `SYN` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:15:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:23:5
    |
 LL |     SYN,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Syn`
 
 error: name `FIN` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:16:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:25:5
    |
 LL |     FIN,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
 
 error: name `GCCLLVMSomething` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:21:8
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:31:8
    |
 LL | struct GCCLLVMSomething;
    |        ^^^^^^^^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `GccllvmSomething`
 
 error: name `WASD` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:38:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:49:5
    |
 LL |     WASD(u8),
    |     ^^^^ help: consider making the acronym lowercase, except the initial letter: `Wasd`
 
 error: name `WASDMixed` contains a capitalized acronym
-  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:39:5
+  --> tests/ui-toml/upper_case_acronyms_aggressive/upper_case_acronyms.rs:51:5
    |
 LL |     WASDMixed(String),
    |     ^^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `WasdMixed`
diff --git a/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.fixed b/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.fixed
index 08323a0dcc90..6181abc6ea57 100644
--- a/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.fixed
+++ b/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.fixed
@@ -6,6 +6,7 @@ fn foo(_: &[u32]) {}
 
 fn main() {
     foo(&[1_u32]);
+    //~^ useless_vec
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.rs b/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.rs
index 1f4b27c53429..bffdcc59752b 100644
--- a/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.rs
+++ b/src/tools/clippy/tests/ui-toml/useless_vec/useless_vec.rs
@@ -6,6 +6,7 @@ fn foo(_: &[u32]) {}
 
 fn main() {
     foo(&vec![1_u32]);
+    //~^ useless_vec
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui-toml/vec_box_sized/test.fixed b/src/tools/clippy/tests/ui-toml/vec_box_sized/test.fixed
index bb4936401ceb..423c761f1b17 100644
--- a/src/tools/clippy/tests/ui-toml/vec_box_sized/test.fixed
+++ b/src/tools/clippy/tests/ui-toml/vec_box_sized/test.fixed
@@ -7,10 +7,13 @@ struct C {
 }
 
 struct Foo(Vec<u8>);
+//~^ vec_box
 struct Bar(Vec<u16>);
+//~^ vec_box
 struct Quux(Vec<Box<u32>>);
 struct Baz(Vec<Box<(u16, u16)>>);
 struct BarBaz(Vec<Box<S>>);
 struct FooBarBaz(Vec<C>);
+//~^ vec_box
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/vec_box_sized/test.rs b/src/tools/clippy/tests/ui-toml/vec_box_sized/test.rs
index 4c46deb585b6..fd9a13430021 100644
--- a/src/tools/clippy/tests/ui-toml/vec_box_sized/test.rs
+++ b/src/tools/clippy/tests/ui-toml/vec_box_sized/test.rs
@@ -7,10 +7,13 @@ struct C {
 }
 
 struct Foo(Vec<Box<u8>>);
+//~^ vec_box
 struct Bar(Vec<Box<u16>>);
+//~^ vec_box
 struct Quux(Vec<Box<u32>>);
 struct Baz(Vec<Box<(u16, u16)>>);
 struct BarBaz(Vec<Box<S>>);
 struct FooBarBaz(Vec<Box<C>>);
+//~^ vec_box
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui-toml/vec_box_sized/test.stderr b/src/tools/clippy/tests/ui-toml/vec_box_sized/test.stderr
index 8c0750d86663..b80b9492c3ca 100644
--- a/src/tools/clippy/tests/ui-toml/vec_box_sized/test.stderr
+++ b/src/tools/clippy/tests/ui-toml/vec_box_sized/test.stderr
@@ -8,13 +8,13 @@ LL | struct Foo(Vec<Box<u8>>);
    = help: to override `-D warnings` add `#[allow(clippy::vec_box)]`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui-toml/vec_box_sized/test.rs:10:12
+  --> tests/ui-toml/vec_box_sized/test.rs:11:12
    |
 LL | struct Bar(Vec<Box<u16>>);
    |            ^^^^^^^^^^^^^ help: try: `Vec<u16>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui-toml/vec_box_sized/test.rs:14:18
+  --> tests/ui-toml/vec_box_sized/test.rs:16:18
    |
 LL | struct FooBarBaz(Vec<Box<C>>);
    |                  ^^^^^^^^^^^ help: try: `Vec<C>`
diff --git a/src/tools/clippy/tests/ui-toml/zero_single_char_names/zero_single_char_names.rs b/src/tools/clippy/tests/ui-toml/zero_single_char_names/zero_single_char_names.rs
index 22aaa242b9b9..d335b12d41ec 100644
--- a/src/tools/clippy/tests/ui-toml/zero_single_char_names/zero_single_char_names.rs
+++ b/src/tools/clippy/tests/ui-toml/zero_single_char_names/zero_single_char_names.rs
@@ -1,3 +1,4 @@
+//@check-pass
 #![warn(clippy::many_single_char_names)]
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/absurd-extreme-comparisons.rs b/src/tools/clippy/tests/ui/absurd-extreme-comparisons.rs
index 60f2ba4abcff..793961d30f0d 100644
--- a/src/tools/clippy/tests/ui/absurd-extreme-comparisons.rs
+++ b/src/tools/clippy/tests/ui/absurd-extreme-comparisons.rs
@@ -12,46 +12,64 @@ fn main() {
     const Z: u32 = 0;
     let u: u32 = 42;
     u <= 0;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u <= Z;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u < Z;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     Z >= u;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     Z > u;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u > u32::MAX;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u >= u32::MAX;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u32::MAX < u;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u32::MAX <= u;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     1-1 > u;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u >= !0;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u <= 12 - 2*6;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     let i: i8 = 0;
     i < -127 - 1;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     i8::MAX >= i;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     3-7 < i32::MIN;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     let b = false;
     b >= true;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     false > b;
-    //~^ ERROR: this comparison involving the minimum or maximum element for this type con
+    //~^ absurd_extreme_comparisons
+
     u > 0; // ok
     // this is handled by clippy::unit_cmp
     () < {};
-    //~^ ERROR: <-comparison of unit values detected. This will always be false
-    //~| NOTE: `#[deny(clippy::unit_cmp)]` on by default
+    //~^ unit_cmp
+
+
 }
 
 use std::cmp::{Ordering, PartialEq, PartialOrd};
diff --git a/src/tools/clippy/tests/ui/absurd-extreme-comparisons.stderr b/src/tools/clippy/tests/ui/absurd-extreme-comparisons.stderr
index f98114c0000a..6df50c15e8cd 100644
--- a/src/tools/clippy/tests/ui/absurd-extreme-comparisons.stderr
+++ b/src/tools/clippy/tests/ui/absurd-extreme-comparisons.stderr
@@ -9,7 +9,7 @@ LL |     u <= 0;
    = help: to override `-D warnings` add `#[allow(clippy::absurd_extreme_comparisons)]`
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:16:5
+  --> tests/ui/absurd-extreme-comparisons.rs:17:5
    |
 LL |     u <= Z;
    |     ^^^^^^
@@ -17,7 +17,7 @@ LL |     u <= Z;
    = help: because `Z` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == Z` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:18:5
+  --> tests/ui/absurd-extreme-comparisons.rs:20:5
    |
 LL |     u < Z;
    |     ^^^^^
@@ -25,7 +25,7 @@ LL |     u < Z;
    = help: because `Z` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:20:5
+  --> tests/ui/absurd-extreme-comparisons.rs:23:5
    |
 LL |     Z >= u;
    |     ^^^^^^
@@ -33,7 +33,7 @@ LL |     Z >= u;
    = help: because `Z` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `Z == u` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:22:5
+  --> tests/ui/absurd-extreme-comparisons.rs:26:5
    |
 LL |     Z > u;
    |     ^^^^^
@@ -41,7 +41,7 @@ LL |     Z > u;
    = help: because `Z` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:24:5
+  --> tests/ui/absurd-extreme-comparisons.rs:29:5
    |
 LL |     u > u32::MAX;
    |     ^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     u > u32::MAX;
    = help: because `u32::MAX` is the maximum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:26:5
+  --> tests/ui/absurd-extreme-comparisons.rs:32:5
    |
 LL |     u >= u32::MAX;
    |     ^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     u >= u32::MAX;
    = help: because `u32::MAX` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `u == u32::MAX` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:28:5
+  --> tests/ui/absurd-extreme-comparisons.rs:35:5
    |
 LL |     u32::MAX < u;
    |     ^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     u32::MAX < u;
    = help: because `u32::MAX` is the maximum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:30:5
+  --> tests/ui/absurd-extreme-comparisons.rs:38:5
    |
 LL |     u32::MAX <= u;
    |     ^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     u32::MAX <= u;
    = help: because `u32::MAX` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `u32::MAX == u` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:32:5
+  --> tests/ui/absurd-extreme-comparisons.rs:41:5
    |
 LL |     1-1 > u;
    |     ^^^^^^^
@@ -81,7 +81,7 @@ LL |     1-1 > u;
    = help: because `1-1` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:34:5
+  --> tests/ui/absurd-extreme-comparisons.rs:44:5
    |
 LL |     u >= !0;
    |     ^^^^^^^
@@ -89,7 +89,7 @@ LL |     u >= !0;
    = help: because `!0` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `u == !0` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:36:5
+  --> tests/ui/absurd-extreme-comparisons.rs:47:5
    |
 LL |     u <= 12 - 2*6;
    |     ^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     u <= 12 - 2*6;
    = help: because `12 - 2*6` is the minimum value for this type, the case where the two sides are not equal never occurs, consider using `u == 12 - 2*6` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:39:5
+  --> tests/ui/absurd-extreme-comparisons.rs:51:5
    |
 LL |     i < -127 - 1;
    |     ^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     i < -127 - 1;
    = help: because `-127 - 1` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:41:5
+  --> tests/ui/absurd-extreme-comparisons.rs:54:5
    |
 LL |     i8::MAX >= i;
    |     ^^^^^^^^^^^^
@@ -113,7 +113,7 @@ LL |     i8::MAX >= i;
    = help: because `i8::MAX` is the maximum value for this type, this comparison is always true
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:43:5
+  --> tests/ui/absurd-extreme-comparisons.rs:57:5
    |
 LL |     3-7 < i32::MIN;
    |     ^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     3-7 < i32::MIN;
    = help: because `i32::MIN` is the minimum value for this type, this comparison is always false
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:46:5
+  --> tests/ui/absurd-extreme-comparisons.rs:61:5
    |
 LL |     b >= true;
    |     ^^^^^^^^^
@@ -129,7 +129,7 @@ LL |     b >= true;
    = help: because `true` is the maximum value for this type, the case where the two sides are not equal never occurs, consider using `b == true` instead
 
 error: this comparison involving the minimum or maximum element for this type contains a case that is always true or always false
-  --> tests/ui/absurd-extreme-comparisons.rs:48:5
+  --> tests/ui/absurd-extreme-comparisons.rs:64:5
    |
 LL |     false > b;
    |     ^^^^^^^^^
@@ -137,7 +137,7 @@ LL |     false > b;
    = help: because `false` is the minimum value for this type, this comparison is always false
 
 error: <-comparison of unit values detected. This will always be false
-  --> tests/ui/absurd-extreme-comparisons.rs:52:5
+  --> tests/ui/absurd-extreme-comparisons.rs:69:5
    |
 LL |     () < {};
    |     ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/allow_attributes.fixed b/src/tools/clippy/tests/ui/allow_attributes.fixed
index 8f6c962e2f5b..56a98cca3404 100644
--- a/src/tools/clippy/tests/ui/allow_attributes.fixed
+++ b/src/tools/clippy/tests/ui/allow_attributes.fixed
@@ -11,6 +11,7 @@ use proc_macros::{external, with_span};
 
 // Should lint
 #[expect(dead_code)]
+//~^ allow_attributes
 struct T1;
 
 struct T2; // Should not lint
@@ -20,6 +21,7 @@ struct T3;
 struct T4;
 // `panic = "unwind"` should always be true
 #[cfg_attr(panic = "unwind", expect(dead_code))]
+//~^ allow_attributes
 struct CfgT;
 
 #[allow(clippy::allow_attributes, unused)]
@@ -51,6 +53,7 @@ fn ignore_inner_attr() {
 #[clippy::msrv = "1.81"]
 fn msrv_1_81() {
     #[expect(unused)]
+    //~^ allow_attributes
     let x = 1;
 }
 
diff --git a/src/tools/clippy/tests/ui/allow_attributes.rs b/src/tools/clippy/tests/ui/allow_attributes.rs
index cb6c4dcf7158..65a0a6b5a108 100644
--- a/src/tools/clippy/tests/ui/allow_attributes.rs
+++ b/src/tools/clippy/tests/ui/allow_attributes.rs
@@ -11,6 +11,7 @@ use proc_macros::{external, with_span};
 
 // Should lint
 #[allow(dead_code)]
+//~^ allow_attributes
 struct T1;
 
 struct T2; // Should not lint
@@ -20,6 +21,7 @@ struct T3;
 struct T4;
 // `panic = "unwind"` should always be true
 #[cfg_attr(panic = "unwind", allow(dead_code))]
+//~^ allow_attributes
 struct CfgT;
 
 #[allow(clippy::allow_attributes, unused)]
@@ -51,6 +53,7 @@ fn ignore_inner_attr() {
 #[clippy::msrv = "1.81"]
 fn msrv_1_81() {
     #[allow(unused)]
+    //~^ allow_attributes
     let x = 1;
 }
 
diff --git a/src/tools/clippy/tests/ui/allow_attributes.stderr b/src/tools/clippy/tests/ui/allow_attributes.stderr
index 5a4ff287acd2..dd5fb21ffeaf 100644
--- a/src/tools/clippy/tests/ui/allow_attributes.stderr
+++ b/src/tools/clippy/tests/ui/allow_attributes.stderr
@@ -8,13 +8,13 @@ LL | #[allow(dead_code)]
    = help: to override `-D warnings` add `#[allow(clippy::allow_attributes)]`
 
 error: #[allow] attribute found
-  --> tests/ui/allow_attributes.rs:22:30
+  --> tests/ui/allow_attributes.rs:23:30
    |
 LL | #[cfg_attr(panic = "unwind", allow(dead_code))]
    |                              ^^^^^ help: replace it with: `expect`
 
 error: #[allow] attribute found
-  --> tests/ui/allow_attributes.rs:53:7
+  --> tests/ui/allow_attributes.rs:55:7
    |
 LL |     #[allow(unused)]
    |       ^^^^^ help: replace it with: `expect`
diff --git a/src/tools/clippy/tests/ui/allow_attributes_without_reason.rs b/src/tools/clippy/tests/ui/allow_attributes_without_reason.rs
index 334e7ddd9d23..ea89511ebb46 100644
--- a/src/tools/clippy/tests/ui/allow_attributes_without_reason.rs
+++ b/src/tools/clippy/tests/ui/allow_attributes_without_reason.rs
@@ -1,14 +1,18 @@
 //@aux-build:proc_macros.rs
 #![deny(clippy::allow_attributes_without_reason)]
 #![allow(unfulfilled_lint_expectations, clippy::duplicated_attributes)]
+//~^ allow_attributes_without_reason
 
 extern crate proc_macros;
 use proc_macros::{external, with_span};
 
 // These should trigger the lint
 #[allow(dead_code)]
+//~^ allow_attributes_without_reason
 #[allow(dead_code, deprecated)]
+//~^ allow_attributes_without_reason
 #[expect(dead_code)]
+//~^ allow_attributes_without_reason
 // These should be fine
 #[allow(dead_code, reason = "This should be allowed")]
 #[warn(dyn_drop, reason = "Warnings can also have reasons")]
@@ -44,6 +48,7 @@ pub fn trigger_fp_result() -> Result<(), &'static str> {
 #[clippy::msrv = "1.81"]
 fn msrv_1_81() {
     #[allow(unused)]
+    //~^ allow_attributes_without_reason
     let _ = 1;
 }
 
diff --git a/src/tools/clippy/tests/ui/allow_attributes_without_reason.stderr b/src/tools/clippy/tests/ui/allow_attributes_without_reason.stderr
index 9c1ac5af91b0..07e74839b769 100644
--- a/src/tools/clippy/tests/ui/allow_attributes_without_reason.stderr
+++ b/src/tools/clippy/tests/ui/allow_attributes_without_reason.stderr
@@ -12,7 +12,7 @@ LL | #![deny(clippy::allow_attributes_without_reason)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `allow` attribute without specifying a reason
-  --> tests/ui/allow_attributes_without_reason.rs:9:1
+  --> tests/ui/allow_attributes_without_reason.rs:10:1
    |
 LL | #[allow(dead_code)]
    | ^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL | #[allow(dead_code)]
    = help: try adding a reason at the end with `, reason = ".."`
 
 error: `allow` attribute without specifying a reason
-  --> tests/ui/allow_attributes_without_reason.rs:10:1
+  --> tests/ui/allow_attributes_without_reason.rs:12:1
    |
 LL | #[allow(dead_code, deprecated)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL | #[allow(dead_code, deprecated)]
    = help: try adding a reason at the end with `, reason = ".."`
 
 error: `expect` attribute without specifying a reason
-  --> tests/ui/allow_attributes_without_reason.rs:11:1
+  --> tests/ui/allow_attributes_without_reason.rs:14:1
    |
 LL | #[expect(dead_code)]
    | ^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL | #[expect(dead_code)]
    = help: try adding a reason at the end with `, reason = ".."`
 
 error: `allow` attribute without specifying a reason
-  --> tests/ui/allow_attributes_without_reason.rs:46:5
+  --> tests/ui/allow_attributes_without_reason.rs:50:5
    |
 LL |     #[allow(unused)]
    |     ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/almost_complete_range.fixed b/src/tools/clippy/tests/ui/almost_complete_range.fixed
index 6c2b2f117437..7591508b8350 100644
--- a/src/tools/clippy/tests/ui/almost_complete_range.fixed
+++ b/src/tools/clippy/tests/ui/almost_complete_range.fixed
@@ -15,8 +15,11 @@ fn main() {
     #[rustfmt::skip]
     {
         let _ = ('a') ..='z';
+        //~^ almost_complete_range
         let _ = 'A' ..= ('Z');
+        //~^ almost_complete_range
         let _ = ((('0'))) ..= ('9');
+        //~^ almost_complete_range
     }
 
     let _ = 'b'..'z';
@@ -24,21 +27,30 @@ fn main() {
     let _ = '1'..'9';
 
     let _ = (b'a')..=(b'z');
+    //~^ almost_complete_range
     let _ = b'A'..=b'Z';
+    //~^ almost_complete_range
     let _ = b'0'..=b'9';
+    //~^ almost_complete_range
 
     let _ = b'b'..b'z';
     let _ = b'B'..b'Z';
     let _ = b'1'..b'9';
 
     let _ = inline!('a')..='z';
+    //~^ almost_complete_range
     let _ = inline!('A')..='Z';
+    //~^ almost_complete_range
     let _ = inline!('0')..='9';
+    //~^ almost_complete_range
 
     let _ = match 0u8 {
         b'a'..=b'z' if true => 1,
+        //~^ almost_complete_range
         b'A'..=b'Z' if true => 2,
+        //~^ almost_complete_range
         b'0'..=b'9' if true => 3,
+        //~^ almost_complete_range
         b'b'..b'z' => 4,
         b'B'..b'Z' => 5,
         b'1'..b'9' => 6,
@@ -47,8 +59,11 @@ fn main() {
 
     let _ = match 'x' {
         'a'..='z' if true => 1,
+        //~^ almost_complete_range
         'A'..='Z' if true => 2,
+        //~^ almost_complete_range
         '0'..='9' if true => 3,
+        //~^ almost_complete_range
         'b'..'z' => 4,
         'B'..'Z' => 5,
         '1'..'9' => 6,
@@ -62,8 +77,11 @@ fn main() {
     );
     inline!(
         let _ = 'a'..='z';
+        //~^ almost_complete_range
         let _ = 'A'..='Z';
+        //~^ almost_complete_range
         let _ = '0'..='9';
+        //~^ almost_complete_range
     );
 }
 
@@ -71,8 +89,11 @@ fn main() {
 fn _under_msrv() {
     let _ = match 'a' {
         'a'...'z' => 1,
+        //~^ almost_complete_range
         'A'...'Z' => 2,
+        //~^ almost_complete_range
         '0'...'9' => 3,
+        //~^ almost_complete_range
         _ => 4,
     };
 }
@@ -80,12 +101,18 @@ fn _under_msrv() {
 #[clippy::msrv = "1.26"]
 fn _meets_msrv() {
     let _ = 'a'..='z';
+    //~^ almost_complete_range
     let _ = 'A'..='Z';
+    //~^ almost_complete_range
     let _ = '0'..='9';
+    //~^ almost_complete_range
     let _ = match 'a' {
         'a'..='z' => 1,
+        //~^ almost_complete_range
         'A'..='Z' => 1,
+        //~^ almost_complete_range
         '0'..='9' => 3,
+        //~^ almost_complete_range
         _ => 4,
     };
 }
diff --git a/src/tools/clippy/tests/ui/almost_complete_range.rs b/src/tools/clippy/tests/ui/almost_complete_range.rs
index 813668a53096..907f70bd8156 100644
--- a/src/tools/clippy/tests/ui/almost_complete_range.rs
+++ b/src/tools/clippy/tests/ui/almost_complete_range.rs
@@ -15,8 +15,11 @@ fn main() {
     #[rustfmt::skip]
     {
         let _ = ('a') ..'z';
+        //~^ almost_complete_range
         let _ = 'A' .. ('Z');
+        //~^ almost_complete_range
         let _ = ((('0'))) .. ('9');
+        //~^ almost_complete_range
     }
 
     let _ = 'b'..'z';
@@ -24,21 +27,30 @@ fn main() {
     let _ = '1'..'9';
 
     let _ = (b'a')..(b'z');
+    //~^ almost_complete_range
     let _ = b'A'..b'Z';
+    //~^ almost_complete_range
     let _ = b'0'..b'9';
+    //~^ almost_complete_range
 
     let _ = b'b'..b'z';
     let _ = b'B'..b'Z';
     let _ = b'1'..b'9';
 
     let _ = inline!('a')..'z';
+    //~^ almost_complete_range
     let _ = inline!('A')..'Z';
+    //~^ almost_complete_range
     let _ = inline!('0')..'9';
+    //~^ almost_complete_range
 
     let _ = match 0u8 {
         b'a'..b'z' if true => 1,
+        //~^ almost_complete_range
         b'A'..b'Z' if true => 2,
+        //~^ almost_complete_range
         b'0'..b'9' if true => 3,
+        //~^ almost_complete_range
         b'b'..b'z' => 4,
         b'B'..b'Z' => 5,
         b'1'..b'9' => 6,
@@ -47,8 +59,11 @@ fn main() {
 
     let _ = match 'x' {
         'a'..'z' if true => 1,
+        //~^ almost_complete_range
         'A'..'Z' if true => 2,
+        //~^ almost_complete_range
         '0'..'9' if true => 3,
+        //~^ almost_complete_range
         'b'..'z' => 4,
         'B'..'Z' => 5,
         '1'..'9' => 6,
@@ -62,8 +77,11 @@ fn main() {
     );
     inline!(
         let _ = 'a'..'z';
+        //~^ almost_complete_range
         let _ = 'A'..'Z';
+        //~^ almost_complete_range
         let _ = '0'..'9';
+        //~^ almost_complete_range
     );
 }
 
@@ -71,8 +89,11 @@ fn main() {
 fn _under_msrv() {
     let _ = match 'a' {
         'a'..'z' => 1,
+        //~^ almost_complete_range
         'A'..'Z' => 2,
+        //~^ almost_complete_range
         '0'..'9' => 3,
+        //~^ almost_complete_range
         _ => 4,
     };
 }
@@ -80,12 +101,18 @@ fn _under_msrv() {
 #[clippy::msrv = "1.26"]
 fn _meets_msrv() {
     let _ = 'a'..'z';
+    //~^ almost_complete_range
     let _ = 'A'..'Z';
+    //~^ almost_complete_range
     let _ = '0'..'9';
+    //~^ almost_complete_range
     let _ = match 'a' {
         'a'..'z' => 1,
+        //~^ almost_complete_range
         'A'..'Z' => 1,
+        //~^ almost_complete_range
         '0'..'9' => 3,
+        //~^ almost_complete_range
         _ => 4,
     };
 }
diff --git a/src/tools/clippy/tests/ui/almost_complete_range.stderr b/src/tools/clippy/tests/ui/almost_complete_range.stderr
index bfc2beb07d85..217df7f4883f 100644
--- a/src/tools/clippy/tests/ui/almost_complete_range.stderr
+++ b/src/tools/clippy/tests/ui/almost_complete_range.stderr
@@ -10,7 +10,7 @@ LL |         let _ = ('a') ..'z';
    = help: to override `-D warnings` add `#[allow(clippy::almost_complete_range)]`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:18:17
+  --> tests/ui/almost_complete_range.rs:19:17
    |
 LL |         let _ = 'A' .. ('Z');
    |                 ^^^^--^^^^^^
@@ -18,7 +18,7 @@ LL |         let _ = 'A' .. ('Z');
    |                     help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:19:17
+  --> tests/ui/almost_complete_range.rs:21:17
    |
 LL |         let _ = ((('0'))) .. ('9');
    |                 ^^^^^^^^^^--^^^^^^
@@ -26,7 +26,7 @@ LL |         let _ = ((('0'))) .. ('9');
    |                           help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:26:13
+  --> tests/ui/almost_complete_range.rs:29:13
    |
 LL |     let _ = (b'a')..(b'z');
    |             ^^^^^^--^^^^^^
@@ -34,7 +34,7 @@ LL |     let _ = (b'a')..(b'z');
    |                   help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:27:13
+  --> tests/ui/almost_complete_range.rs:31:13
    |
 LL |     let _ = b'A'..b'Z';
    |             ^^^^--^^^^
@@ -42,7 +42,7 @@ LL |     let _ = b'A'..b'Z';
    |                 help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:28:13
+  --> tests/ui/almost_complete_range.rs:33:13
    |
 LL |     let _ = b'0'..b'9';
    |             ^^^^--^^^^
@@ -50,7 +50,7 @@ LL |     let _ = b'0'..b'9';
    |                 help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:34:13
+  --> tests/ui/almost_complete_range.rs:40:13
    |
 LL |     let _ = inline!('a')..'z';
    |             ^^^^^^^^^^^^--^^^
@@ -58,7 +58,7 @@ LL |     let _ = inline!('a')..'z';
    |                         help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:35:13
+  --> tests/ui/almost_complete_range.rs:42:13
    |
 LL |     let _ = inline!('A')..'Z';
    |             ^^^^^^^^^^^^--^^^
@@ -66,7 +66,7 @@ LL |     let _ = inline!('A')..'Z';
    |                         help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:36:13
+  --> tests/ui/almost_complete_range.rs:44:13
    |
 LL |     let _ = inline!('0')..'9';
    |             ^^^^^^^^^^^^--^^^
@@ -74,7 +74,7 @@ LL |     let _ = inline!('0')..'9';
    |                         help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:39:9
+  --> tests/ui/almost_complete_range.rs:48:9
    |
 LL |         b'a'..b'z' if true => 1,
    |         ^^^^--^^^^
@@ -82,7 +82,7 @@ LL |         b'a'..b'z' if true => 1,
    |             help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:40:9
+  --> tests/ui/almost_complete_range.rs:50:9
    |
 LL |         b'A'..b'Z' if true => 2,
    |         ^^^^--^^^^
@@ -90,7 +90,7 @@ LL |         b'A'..b'Z' if true => 2,
    |             help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:41:9
+  --> tests/ui/almost_complete_range.rs:52:9
    |
 LL |         b'0'..b'9' if true => 3,
    |         ^^^^--^^^^
@@ -98,7 +98,7 @@ LL |         b'0'..b'9' if true => 3,
    |             help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:49:9
+  --> tests/ui/almost_complete_range.rs:61:9
    |
 LL |         'a'..'z' if true => 1,
    |         ^^^--^^^
@@ -106,7 +106,7 @@ LL |         'a'..'z' if true => 1,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:50:9
+  --> tests/ui/almost_complete_range.rs:63:9
    |
 LL |         'A'..'Z' if true => 2,
    |         ^^^--^^^
@@ -114,7 +114,7 @@ LL |         'A'..'Z' if true => 2,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:51:9
+  --> tests/ui/almost_complete_range.rs:65:9
    |
 LL |         '0'..'9' if true => 3,
    |         ^^^--^^^
@@ -122,7 +122,7 @@ LL |         '0'..'9' if true => 3,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:64:17
+  --> tests/ui/almost_complete_range.rs:79:17
    |
 LL |         let _ = 'a'..'z';
    |                 ^^^--^^^
@@ -132,7 +132,7 @@ LL |         let _ = 'a'..'z';
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:65:17
+  --> tests/ui/almost_complete_range.rs:81:17
    |
 LL |         let _ = 'A'..'Z';
    |                 ^^^--^^^
@@ -142,7 +142,7 @@ LL |         let _ = 'A'..'Z';
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:66:17
+  --> tests/ui/almost_complete_range.rs:83:17
    |
 LL |         let _ = '0'..'9';
    |                 ^^^--^^^
@@ -152,7 +152,7 @@ LL |         let _ = '0'..'9';
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:73:9
+  --> tests/ui/almost_complete_range.rs:91:9
    |
 LL |         'a'..'z' => 1,
    |         ^^^--^^^
@@ -160,7 +160,7 @@ LL |         'a'..'z' => 1,
    |            help: use an inclusive range: `...`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:74:9
+  --> tests/ui/almost_complete_range.rs:93:9
    |
 LL |         'A'..'Z' => 2,
    |         ^^^--^^^
@@ -168,7 +168,7 @@ LL |         'A'..'Z' => 2,
    |            help: use an inclusive range: `...`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:75:9
+  --> tests/ui/almost_complete_range.rs:95:9
    |
 LL |         '0'..'9' => 3,
    |         ^^^--^^^
@@ -176,7 +176,7 @@ LL |         '0'..'9' => 3,
    |            help: use an inclusive range: `...`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:82:13
+  --> tests/ui/almost_complete_range.rs:103:13
    |
 LL |     let _ = 'a'..'z';
    |             ^^^--^^^
@@ -184,7 +184,7 @@ LL |     let _ = 'a'..'z';
    |                help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:83:13
+  --> tests/ui/almost_complete_range.rs:105:13
    |
 LL |     let _ = 'A'..'Z';
    |             ^^^--^^^
@@ -192,7 +192,7 @@ LL |     let _ = 'A'..'Z';
    |                help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:84:13
+  --> tests/ui/almost_complete_range.rs:107:13
    |
 LL |     let _ = '0'..'9';
    |             ^^^--^^^
@@ -200,7 +200,7 @@ LL |     let _ = '0'..'9';
    |                help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:86:9
+  --> tests/ui/almost_complete_range.rs:110:9
    |
 LL |         'a'..'z' => 1,
    |         ^^^--^^^
@@ -208,7 +208,7 @@ LL |         'a'..'z' => 1,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:87:9
+  --> tests/ui/almost_complete_range.rs:112:9
    |
 LL |         'A'..'Z' => 1,
    |         ^^^--^^^
@@ -216,7 +216,7 @@ LL |         'A'..'Z' => 1,
    |            help: use an inclusive range: `..=`
 
 error: almost complete ascii range
-  --> tests/ui/almost_complete_range.rs:88:9
+  --> tests/ui/almost_complete_range.rs:114:9
    |
 LL |         '0'..'9' => 3,
    |         ^^^--^^^
diff --git a/src/tools/clippy/tests/ui/approx_const.rs b/src/tools/clippy/tests/ui/approx_const.rs
index 3c4ed0367894..6461666be8f5 100644
--- a/src/tools/clippy/tests/ui/approx_const.rs
+++ b/src/tools/clippy/tests/ui/approx_const.rs
@@ -1,86 +1,109 @@
 #[warn(clippy::approx_constant)]
 fn main() {
     let my_e = 2.7182;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::E` found
+    //~^ approx_constant
+
     let almost_e = 2.718;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::E` found
+    //~^ approx_constant
+
     let no_e = 2.71;
 
     let my_1_frac_pi = 0.3183;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_1_PI` found
+    //~^ approx_constant
+
     let no_1_frac_pi = 0.31;
 
     let my_frac_1_sqrt_2 = 0.70710678;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
+    //~^ approx_constant
+
     let almost_frac_1_sqrt_2 = 0.70711;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
+    //~^ approx_constant
+
     let my_frac_1_sqrt_2 = 0.707;
 
     let my_frac_2_pi = 0.63661977;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_2_PI` found
+    //~^ approx_constant
+
     let no_frac_2_pi = 0.636;
 
     let my_frac_2_sq_pi = 1.128379;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_2_SQRT_PI` found
+    //~^ approx_constant
+
     let no_frac_2_sq_pi = 1.128;
 
     let my_frac_pi_2 = 1.57079632679;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_PI_2` found
+    //~^ approx_constant
+
     let no_frac_pi_2 = 1.5705;
 
     let my_frac_pi_3 = 1.04719755119;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_PI_3` found
+    //~^ approx_constant
+
     let no_frac_pi_3 = 1.047;
 
     let my_frac_pi_4 = 0.785398163397;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_PI_4` found
+    //~^ approx_constant
+
     let no_frac_pi_4 = 0.785;
 
     let my_frac_pi_6 = 0.523598775598;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_PI_6` found
+    //~^ approx_constant
+
     let no_frac_pi_6 = 0.523;
 
     let my_frac_pi_8 = 0.3926990816987;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::FRAC_PI_8` found
+    //~^ approx_constant
+
     let no_frac_pi_8 = 0.392;
 
     let my_ln_10 = 2.302585092994046;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LN_10` found
+    //~^ approx_constant
+
     let no_ln_10 = 2.303;
 
     let my_ln_2 = 0.6931471805599453;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LN_2` found
+    //~^ approx_constant
+
     let no_ln_2 = 0.693;
 
     let my_log10_e = 0.4342944819032518;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG10_E` found
+    //~^ approx_constant
+
     let no_log10_e = 0.434;
 
     let my_log2_e = 1.4426950408889634;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_E` found
+    //~^ approx_constant
+
     let no_log2_e = 1.442;
 
     let log2_10 = 3.321928094887362;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_10` found
+    //~^ approx_constant
+
     let no_log2_10 = 3.321;
 
     let log10_2 = 0.301029995663981;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG10_2` found
+    //~^ approx_constant
+
     let no_log10_2 = 0.301;
 
     let my_pi = 3.1415;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::PI` found
+    //~^ approx_constant
+
     let almost_pi = 3.14;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::PI` found
+    //~^ approx_constant
+
     let no_pi = 3.15;
 
     let my_sq2 = 1.4142;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::SQRT_2` found
+    //~^ approx_constant
+
     let no_sq2 = 1.414;
 
     let my_tau = 6.2832;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::TAU` found
+    //~^ approx_constant
+
     let almost_tau = 6.28;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::TAU` found
+    //~^ approx_constant
+
     let no_tau = 6.3;
 }
diff --git a/src/tools/clippy/tests/ui/approx_const.stderr b/src/tools/clippy/tests/ui/approx_const.stderr
index 5e82d51edf20..f7bda0468cbd 100644
--- a/src/tools/clippy/tests/ui/approx_const.stderr
+++ b/src/tools/clippy/tests/ui/approx_const.stderr
@@ -9,7 +9,7 @@ LL |     let my_e = 2.7182;
    = help: to override `-D warnings` add `#[allow(clippy::approx_constant)]`
 
 error: approximate value of `f{32, 64}::consts::E` found
-  --> tests/ui/approx_const.rs:5:20
+  --> tests/ui/approx_const.rs:6:20
    |
 LL |     let almost_e = 2.718;
    |                    ^^^^^
@@ -17,7 +17,7 @@ LL |     let almost_e = 2.718;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_1_PI` found
-  --> tests/ui/approx_const.rs:9:24
+  --> tests/ui/approx_const.rs:11:24
    |
 LL |     let my_1_frac_pi = 0.3183;
    |                        ^^^^^^
@@ -25,7 +25,7 @@ LL |     let my_1_frac_pi = 0.3183;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
-  --> tests/ui/approx_const.rs:13:28
+  --> tests/ui/approx_const.rs:16:28
    |
 LL |     let my_frac_1_sqrt_2 = 0.70710678;
    |                            ^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     let my_frac_1_sqrt_2 = 0.70710678;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_1_SQRT_2` found
-  --> tests/ui/approx_const.rs:15:32
+  --> tests/ui/approx_const.rs:19:32
    |
 LL |     let almost_frac_1_sqrt_2 = 0.70711;
    |                                ^^^^^^^
@@ -41,7 +41,7 @@ LL |     let almost_frac_1_sqrt_2 = 0.70711;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_2_PI` found
-  --> tests/ui/approx_const.rs:19:24
+  --> tests/ui/approx_const.rs:24:24
    |
 LL |     let my_frac_2_pi = 0.63661977;
    |                        ^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     let my_frac_2_pi = 0.63661977;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_2_SQRT_PI` found
-  --> tests/ui/approx_const.rs:23:27
+  --> tests/ui/approx_const.rs:29:27
    |
 LL |     let my_frac_2_sq_pi = 1.128379;
    |                           ^^^^^^^^
@@ -57,7 +57,7 @@ LL |     let my_frac_2_sq_pi = 1.128379;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_2` found
-  --> tests/ui/approx_const.rs:27:24
+  --> tests/ui/approx_const.rs:34:24
    |
 LL |     let my_frac_pi_2 = 1.57079632679;
    |                        ^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     let my_frac_pi_2 = 1.57079632679;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_3` found
-  --> tests/ui/approx_const.rs:31:24
+  --> tests/ui/approx_const.rs:39:24
    |
 LL |     let my_frac_pi_3 = 1.04719755119;
    |                        ^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     let my_frac_pi_3 = 1.04719755119;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_4` found
-  --> tests/ui/approx_const.rs:35:24
+  --> tests/ui/approx_const.rs:44:24
    |
 LL |     let my_frac_pi_4 = 0.785398163397;
    |                        ^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     let my_frac_pi_4 = 0.785398163397;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_6` found
-  --> tests/ui/approx_const.rs:39:24
+  --> tests/ui/approx_const.rs:49:24
    |
 LL |     let my_frac_pi_6 = 0.523598775598;
    |                        ^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     let my_frac_pi_6 = 0.523598775598;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::FRAC_PI_8` found
-  --> tests/ui/approx_const.rs:43:24
+  --> tests/ui/approx_const.rs:54:24
    |
 LL |     let my_frac_pi_8 = 0.3926990816987;
    |                        ^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     let my_frac_pi_8 = 0.3926990816987;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LN_10` found
-  --> tests/ui/approx_const.rs:47:20
+  --> tests/ui/approx_const.rs:59:20
    |
 LL |     let my_ln_10 = 2.302585092994046;
    |                    ^^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     let my_ln_10 = 2.302585092994046;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LN_2` found
-  --> tests/ui/approx_const.rs:51:19
+  --> tests/ui/approx_const.rs:64:19
    |
 LL |     let my_ln_2 = 0.6931471805599453;
    |                   ^^^^^^^^^^^^^^^^^^
@@ -113,7 +113,7 @@ LL |     let my_ln_2 = 0.6931471805599453;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG10_E` found
-  --> tests/ui/approx_const.rs:55:22
+  --> tests/ui/approx_const.rs:69:22
    |
 LL |     let my_log10_e = 0.4342944819032518;
    |                      ^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     let my_log10_e = 0.4342944819032518;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG2_E` found
-  --> tests/ui/approx_const.rs:59:21
+  --> tests/ui/approx_const.rs:74:21
    |
 LL |     let my_log2_e = 1.4426950408889634;
    |                     ^^^^^^^^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL |     let my_log2_e = 1.4426950408889634;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG2_10` found
-  --> tests/ui/approx_const.rs:63:19
+  --> tests/ui/approx_const.rs:79:19
    |
 LL |     let log2_10 = 3.321928094887362;
    |                   ^^^^^^^^^^^^^^^^^
@@ -137,7 +137,7 @@ LL |     let log2_10 = 3.321928094887362;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::LOG10_2` found
-  --> tests/ui/approx_const.rs:67:19
+  --> tests/ui/approx_const.rs:84:19
    |
 LL |     let log10_2 = 0.301029995663981;
    |                   ^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL |     let log10_2 = 0.301029995663981;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::PI` found
-  --> tests/ui/approx_const.rs:71:17
+  --> tests/ui/approx_const.rs:89:17
    |
 LL |     let my_pi = 3.1415;
    |                 ^^^^^^
@@ -153,7 +153,7 @@ LL |     let my_pi = 3.1415;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::PI` found
-  --> tests/ui/approx_const.rs:73:21
+  --> tests/ui/approx_const.rs:92:21
    |
 LL |     let almost_pi = 3.14;
    |                     ^^^^
@@ -161,7 +161,7 @@ LL |     let almost_pi = 3.14;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::SQRT_2` found
-  --> tests/ui/approx_const.rs:77:18
+  --> tests/ui/approx_const.rs:97:18
    |
 LL |     let my_sq2 = 1.4142;
    |                  ^^^^^^
@@ -169,7 +169,7 @@ LL |     let my_sq2 = 1.4142;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::TAU` found
-  --> tests/ui/approx_const.rs:81:18
+  --> tests/ui/approx_const.rs:102:18
    |
 LL |     let my_tau = 6.2832;
    |                  ^^^^^^
@@ -177,7 +177,7 @@ LL |     let my_tau = 6.2832;
    = help: consider using the constant directly
 
 error: approximate value of `f{32, 64}::consts::TAU` found
-  --> tests/ui/approx_const.rs:83:22
+  --> tests/ui/approx_const.rs:105:22
    |
 LL |     let almost_tau = 6.28;
    |                      ^^^^
diff --git a/src/tools/clippy/tests/ui/arc_with_non_send_sync.rs b/src/tools/clippy/tests/ui/arc_with_non_send_sync.rs
index c287480bb1fd..07025ccc42fd 100644
--- a/src/tools/clippy/tests/ui/arc_with_non_send_sync.rs
+++ b/src/tools/clippy/tests/ui/arc_with_non_send_sync.rs
@@ -33,9 +33,12 @@ fn main() {
     let _ = Arc::new(42);
 
     let _ = Arc::new(RefCell::new(42));
+    //~^ arc_with_non_send_sync
 
     let mutex = Mutex::new(1);
     let _ = Arc::new(mutex.lock().unwrap());
+    //~^ arc_with_non_send_sync
 
     let _ = Arc::new(&42 as *const i32);
+    //~^ arc_with_non_send_sync
 }
diff --git a/src/tools/clippy/tests/ui/arc_with_non_send_sync.stderr b/src/tools/clippy/tests/ui/arc_with_non_send_sync.stderr
index da363a3ebdd9..5556b0df88c9 100644
--- a/src/tools/clippy/tests/ui/arc_with_non_send_sync.stderr
+++ b/src/tools/clippy/tests/ui/arc_with_non_send_sync.stderr
@@ -11,7 +11,7 @@ LL |     let _ = Arc::new(RefCell::new(42));
    = help: to override `-D warnings` add `#[allow(clippy::arc_with_non_send_sync)]`
 
 error: usage of an `Arc` that is not `Send` and `Sync`
-  --> tests/ui/arc_with_non_send_sync.rs:38:13
+  --> tests/ui/arc_with_non_send_sync.rs:39:13
    |
 LL |     let _ = Arc::new(mutex.lock().unwrap());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -21,7 +21,7 @@ LL |     let _ = Arc::new(mutex.lock().unwrap());
    = help: otherwise make `MutexGuard<'_, i32>` `Send` and `Sync` or consider a wrapper type such as `Mutex`
 
 error: usage of an `Arc` that is not `Send` and `Sync`
-  --> tests/ui/arc_with_non_send_sync.rs:40:13
+  --> tests/ui/arc_with_non_send_sync.rs:42:13
    |
 LL |     let _ = Arc::new(&42 as *const i32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/arithmetic_side_effects.rs b/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
index f09106773c7e..21be2af201f0 100644
--- a/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
+++ b/src/tools/clippy/tests/ui/arithmetic_side_effects.rs
@@ -164,13 +164,16 @@ pub fn association_with_structures_should_not_trigger_the_lint() {
 
 pub fn hard_coded_allowed() {
     let _ = 1f16 + 1f16;
+    //~^ arithmetic_side_effects
     let _ = 1f32 + 1f32;
     let _ = 1f64 + 1f64;
     let _ = 1f128 + 1f128;
+    //~^ arithmetic_side_effects
 
     let _ = Saturating(0u32) + Saturating(0u32);
     let _ = String::new() + "";
     let _ = String::new() + &String::new();
+    //~^ arithmetic_side_effects
     let _ = Wrapping(0u32) + Wrapping(0u32);
 
     let saturating: Saturating<u32> = Saturating(0u32);
@@ -306,117 +309,221 @@ pub fn unknown_ops_or_runtime_ops_that_can_overflow() {
 
     // Assign
     _n += 1;
+    //~^ arithmetic_side_effects
     _n += &1;
+    //~^ arithmetic_side_effects
     _n -= 1;
+    //~^ arithmetic_side_effects
     _n -= &1;
+    //~^ arithmetic_side_effects
     _n /= 0;
+    //~^ arithmetic_side_effects
     _n /= &0;
+    //~^ arithmetic_side_effects
     _n %= 0;
+    //~^ arithmetic_side_effects
     _n %= &0;
+    //~^ arithmetic_side_effects
     _n *= 2;
+    //~^ arithmetic_side_effects
     _n *= &2;
+    //~^ arithmetic_side_effects
     _n += -1;
+    //~^ arithmetic_side_effects
     _n += &-1;
+    //~^ arithmetic_side_effects
     _n -= -1;
+    //~^ arithmetic_side_effects
     _n -= &-1;
+    //~^ arithmetic_side_effects
     _n /= -0;
+    //~^ arithmetic_side_effects
     _n /= &-0;
+    //~^ arithmetic_side_effects
     _n %= -0;
+    //~^ arithmetic_side_effects
     _n %= &-0;
+    //~^ arithmetic_side_effects
     _n *= -2;
+    //~^ arithmetic_side_effects
     _n *= &-2;
+    //~^ arithmetic_side_effects
     _custom += Custom;
+    //~^ arithmetic_side_effects
     _custom += &Custom;
+    //~^ arithmetic_side_effects
     _custom -= Custom;
+    //~^ arithmetic_side_effects
     _custom -= &Custom;
+    //~^ arithmetic_side_effects
     _custom /= Custom;
+    //~^ arithmetic_side_effects
     _custom /= &Custom;
+    //~^ arithmetic_side_effects
     _custom %= Custom;
+    //~^ arithmetic_side_effects
     _custom %= &Custom;
+    //~^ arithmetic_side_effects
     _custom *= Custom;
+    //~^ arithmetic_side_effects
     _custom *= &Custom;
+    //~^ arithmetic_side_effects
     _custom >>= Custom;
+    //~^ arithmetic_side_effects
     _custom >>= &Custom;
+    //~^ arithmetic_side_effects
     _custom <<= Custom;
+    //~^ arithmetic_side_effects
     _custom <<= &Custom;
+    //~^ arithmetic_side_effects
     _custom += -Custom;
+    //~^ arithmetic_side_effects
     _custom += &-Custom;
+    //~^ arithmetic_side_effects
     _custom -= -Custom;
+    //~^ arithmetic_side_effects
     _custom -= &-Custom;
+    //~^ arithmetic_side_effects
     _custom /= -Custom;
+    //~^ arithmetic_side_effects
     _custom /= &-Custom;
+    //~^ arithmetic_side_effects
     _custom %= -Custom;
+    //~^ arithmetic_side_effects
     _custom %= &-Custom;
+    //~^ arithmetic_side_effects
     _custom *= -Custom;
+    //~^ arithmetic_side_effects
     _custom *= &-Custom;
+    //~^ arithmetic_side_effects
     _custom >>= -Custom;
+    //~^ arithmetic_side_effects
     _custom >>= &-Custom;
+    //~^ arithmetic_side_effects
     _custom <<= -Custom;
+    //~^ arithmetic_side_effects
     _custom <<= &-Custom;
+    //~^ arithmetic_side_effects
 
     // Binary
     _n = _n + 1;
+    //~^ arithmetic_side_effects
     _n = _n + &1;
+    //~^ arithmetic_side_effects
     _n = 1 + _n;
+    //~^ arithmetic_side_effects
     _n = &1 + _n;
+    //~^ arithmetic_side_effects
     _n = _n - 1;
+    //~^ arithmetic_side_effects
     _n = _n - &1;
+    //~^ arithmetic_side_effects
     _n = 1 - _n;
+    //~^ arithmetic_side_effects
     _n = &1 - _n;
+    //~^ arithmetic_side_effects
     _n = _n / 0;
+    //~^ arithmetic_side_effects
     _n = _n / &0;
+    //~^ arithmetic_side_effects
     _n = _n % 0;
+    //~^ arithmetic_side_effects
     _n = _n % &0;
+    //~^ arithmetic_side_effects
     _n = _n * 2;
+    //~^ arithmetic_side_effects
     _n = _n * &2;
+    //~^ arithmetic_side_effects
     _n = 2 * _n;
+    //~^ arithmetic_side_effects
     _n = &2 * _n;
+    //~^ arithmetic_side_effects
     _n = 23 + &85;
+    //~^ arithmetic_side_effects
     _n = &23 + 85;
+    //~^ arithmetic_side_effects
     _n = &23 + &85;
+    //~^ arithmetic_side_effects
     _custom = _custom + _custom;
+    //~^ arithmetic_side_effects
     _custom = _custom + &_custom;
+    //~^ arithmetic_side_effects
     _custom = Custom + _custom;
+    //~^ arithmetic_side_effects
     _custom = &Custom + _custom;
+    //~^ arithmetic_side_effects
     _custom = _custom - Custom;
+    //~^ arithmetic_side_effects
     _custom = _custom - &Custom;
+    //~^ arithmetic_side_effects
     _custom = Custom - _custom;
+    //~^ arithmetic_side_effects
     _custom = &Custom - _custom;
+    //~^ arithmetic_side_effects
     _custom = _custom / Custom;
+    //~^ arithmetic_side_effects
     _custom = _custom / &Custom;
+    //~^ arithmetic_side_effects
     _custom = _custom % Custom;
+    //~^ arithmetic_side_effects
     _custom = _custom % &Custom;
+    //~^ arithmetic_side_effects
     _custom = _custom * Custom;
+    //~^ arithmetic_side_effects
     _custom = _custom * &Custom;
+    //~^ arithmetic_side_effects
     _custom = Custom * _custom;
+    //~^ arithmetic_side_effects
     _custom = &Custom * _custom;
+    //~^ arithmetic_side_effects
     _custom = Custom + &Custom;
+    //~^ arithmetic_side_effects
     _custom = &Custom + Custom;
+    //~^ arithmetic_side_effects
     _custom = &Custom + &Custom;
+    //~^ arithmetic_side_effects
     _custom = _custom >> _custom;
+    //~^ arithmetic_side_effects
     _custom = _custom >> &_custom;
+    //~^ arithmetic_side_effects
     _custom = Custom << _custom;
+    //~^ arithmetic_side_effects
     _custom = &Custom << _custom;
+    //~^ arithmetic_side_effects
 
     // Method
     _n.saturating_div(0);
+    //~^ arithmetic_side_effects
     _n.wrapping_div(0);
+    //~^ arithmetic_side_effects
     _n.wrapping_rem(0);
+    //~^ arithmetic_side_effects
     _n.wrapping_rem_euclid(0);
+    //~^ arithmetic_side_effects
 
     _n.saturating_div(_n);
+    //~^ arithmetic_side_effects
     _n.wrapping_div(_n);
+    //~^ arithmetic_side_effects
     _n.wrapping_rem(_n);
+    //~^ arithmetic_side_effects
     _n.wrapping_rem_euclid(_n);
+    //~^ arithmetic_side_effects
 
     _n.saturating_div(*Box::new(_n));
+    //~^ arithmetic_side_effects
 
     // Unary
     _n = -_n;
+    //~^ arithmetic_side_effects
     _n = -&_n;
+    //~^ arithmetic_side_effects
     _custom = -_custom;
+    //~^ arithmetic_side_effects
     _custom = -&_custom;
+    //~^ arithmetic_side_effects
     _ = -*Box::new(_n);
+    //~^ arithmetic_side_effects
 }
 
 // Copied and pasted from the `integer_arithmetic` lint for comparison.
@@ -426,10 +533,15 @@ pub fn integer_arithmetic() {
     let mut var2 = -1i32;
 
     1 + i;
+    //~^ arithmetic_side_effects
     i * 2;
+    //~^ arithmetic_side_effects
     1 % i / 2;
+    //~^ arithmetic_side_effects
     i - 2 + 2 - i;
+    //~^ arithmetic_side_effects
     -i;
+    //~^ arithmetic_side_effects
     i >> 1;
     i << 1;
 
@@ -441,18 +553,27 @@ pub fn integer_arithmetic() {
     i ^ 1;
 
     i += 1;
+    //~^ arithmetic_side_effects
     i -= 1;
+    //~^ arithmetic_side_effects
     i *= 2;
+    //~^ arithmetic_side_effects
     i /= 2;
     i /= 0;
+    //~^ arithmetic_side_effects
     i /= -1;
     i /= var1;
+    //~^ arithmetic_side_effects
     i /= var2;
+    //~^ arithmetic_side_effects
     i %= 2;
     i %= 0;
+    //~^ arithmetic_side_effects
     i %= -1;
     i %= var1;
+    //~^ arithmetic_side_effects
     i %= var2;
+    //~^ arithmetic_side_effects
     i <<= 3;
     i >>= 2;
 
@@ -463,6 +584,7 @@ pub fn integer_arithmetic() {
 
 pub fn issue_10583(a: u16) -> u16 {
     10 / a
+    //~^ arithmetic_side_effects
 }
 
 pub fn issue_10767() {
@@ -517,10 +639,12 @@ pub fn issue_11392() {
 pub fn issue_11393() {
     fn example_div(x: Wrapping<i32>, maybe_zero: Wrapping<i32>) -> Wrapping<i32> {
         x / maybe_zero
+        //~^ arithmetic_side_effects
     }
 
     fn example_rem(x: Wrapping<i32>, maybe_zero: Wrapping<i32>) -> Wrapping<i32> {
         x % maybe_zero
+        //~^ arithmetic_side_effects
     }
 
     let [x, maybe_zero] = [1, 0].map(Wrapping);
@@ -532,17 +656,21 @@ pub fn issue_12318() {
     use core::ops::{AddAssign, DivAssign, MulAssign, RemAssign, SubAssign};
     let mut one: i32 = 1;
     one.add_assign(1);
+    //~^ arithmetic_side_effects
     one.div_assign(1);
     one.mul_assign(1);
     one.rem_assign(1);
     one.sub_assign(1);
+    //~^ arithmetic_side_effects
 }
 
 pub fn explicit_methods() {
     use core::ops::Add;
     let one: i32 = 1;
     one.add(&one);
+    //~^ arithmetic_side_effects
     Box::new(one).add(one);
+    //~^ arithmetic_side_effects
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/arithmetic_side_effects.stderr b/src/tools/clippy/tests/ui/arithmetic_side_effects.stderr
index 9b4cfb83fbb2..e15fb612be5e 100644
--- a/src/tools/clippy/tests/ui/arithmetic_side_effects.stderr
+++ b/src/tools/clippy/tests/ui/arithmetic_side_effects.stderr
@@ -8,763 +8,763 @@ LL |     let _ = 1f16 + 1f16;
    = help: to override `-D warnings` add `#[allow(clippy::arithmetic_side_effects)]`
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:169:13
+  --> tests/ui/arithmetic_side_effects.rs:170:13
    |
 LL |     let _ = 1f128 + 1f128;
    |             ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:173:13
+  --> tests/ui/arithmetic_side_effects.rs:175:13
    |
 LL |     let _ = String::new() + &String::new();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:308:5
+  --> tests/ui/arithmetic_side_effects.rs:311:5
    |
 LL |     _n += 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:309:5
+  --> tests/ui/arithmetic_side_effects.rs:313:5
    |
 LL |     _n += &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:310:5
+  --> tests/ui/arithmetic_side_effects.rs:315:5
    |
 LL |     _n -= 1;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:311:5
+  --> tests/ui/arithmetic_side_effects.rs:317:5
    |
 LL |     _n -= &1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:312:5
+  --> tests/ui/arithmetic_side_effects.rs:319:5
    |
 LL |     _n /= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:313:5
+  --> tests/ui/arithmetic_side_effects.rs:321:5
    |
 LL |     _n /= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:314:5
+  --> tests/ui/arithmetic_side_effects.rs:323:5
    |
 LL |     _n %= 0;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:315:5
+  --> tests/ui/arithmetic_side_effects.rs:325:5
    |
 LL |     _n %= &0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:316:5
+  --> tests/ui/arithmetic_side_effects.rs:327:5
    |
 LL |     _n *= 2;
    |     ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:317:5
+  --> tests/ui/arithmetic_side_effects.rs:329:5
    |
 LL |     _n *= &2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:318:5
+  --> tests/ui/arithmetic_side_effects.rs:331:5
    |
 LL |     _n += -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:319:5
+  --> tests/ui/arithmetic_side_effects.rs:333:5
    |
 LL |     _n += &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:320:5
+  --> tests/ui/arithmetic_side_effects.rs:335:5
    |
 LL |     _n -= -1;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:321:5
+  --> tests/ui/arithmetic_side_effects.rs:337:5
    |
 LL |     _n -= &-1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:322:5
+  --> tests/ui/arithmetic_side_effects.rs:339:5
    |
 LL |     _n /= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:323:5
+  --> tests/ui/arithmetic_side_effects.rs:341:5
    |
 LL |     _n /= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:324:5
+  --> tests/ui/arithmetic_side_effects.rs:343:5
    |
 LL |     _n %= -0;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:325:5
+  --> tests/ui/arithmetic_side_effects.rs:345:5
    |
 LL |     _n %= &-0;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:326:5
+  --> tests/ui/arithmetic_side_effects.rs:347:5
    |
 LL |     _n *= -2;
    |     ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:327:5
+  --> tests/ui/arithmetic_side_effects.rs:349:5
    |
 LL |     _n *= &-2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:328:5
+  --> tests/ui/arithmetic_side_effects.rs:351:5
    |
 LL |     _custom += Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:329:5
+  --> tests/ui/arithmetic_side_effects.rs:353:5
    |
 LL |     _custom += &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:330:5
+  --> tests/ui/arithmetic_side_effects.rs:355:5
    |
 LL |     _custom -= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:331:5
+  --> tests/ui/arithmetic_side_effects.rs:357:5
    |
 LL |     _custom -= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:332:5
+  --> tests/ui/arithmetic_side_effects.rs:359:5
    |
 LL |     _custom /= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:333:5
+  --> tests/ui/arithmetic_side_effects.rs:361:5
    |
 LL |     _custom /= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:334:5
+  --> tests/ui/arithmetic_side_effects.rs:363:5
    |
 LL |     _custom %= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:335:5
+  --> tests/ui/arithmetic_side_effects.rs:365:5
    |
 LL |     _custom %= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:336:5
+  --> tests/ui/arithmetic_side_effects.rs:367:5
    |
 LL |     _custom *= Custom;
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:337:5
+  --> tests/ui/arithmetic_side_effects.rs:369:5
    |
 LL |     _custom *= &Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:338:5
+  --> tests/ui/arithmetic_side_effects.rs:371:5
    |
 LL |     _custom >>= Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:339:5
+  --> tests/ui/arithmetic_side_effects.rs:373:5
    |
 LL |     _custom >>= &Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:340:5
+  --> tests/ui/arithmetic_side_effects.rs:375:5
    |
 LL |     _custom <<= Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:341:5
+  --> tests/ui/arithmetic_side_effects.rs:377:5
    |
 LL |     _custom <<= &Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:342:5
+  --> tests/ui/arithmetic_side_effects.rs:379:5
    |
 LL |     _custom += -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:343:5
+  --> tests/ui/arithmetic_side_effects.rs:381:5
    |
 LL |     _custom += &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:344:5
+  --> tests/ui/arithmetic_side_effects.rs:383:5
    |
 LL |     _custom -= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:345:5
+  --> tests/ui/arithmetic_side_effects.rs:385:5
    |
 LL |     _custom -= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:346:5
+  --> tests/ui/arithmetic_side_effects.rs:387:5
    |
 LL |     _custom /= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:347:5
+  --> tests/ui/arithmetic_side_effects.rs:389:5
    |
 LL |     _custom /= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:348:5
+  --> tests/ui/arithmetic_side_effects.rs:391:5
    |
 LL |     _custom %= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:349:5
+  --> tests/ui/arithmetic_side_effects.rs:393:5
    |
 LL |     _custom %= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:350:5
+  --> tests/ui/arithmetic_side_effects.rs:395:5
    |
 LL |     _custom *= -Custom;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:351:5
+  --> tests/ui/arithmetic_side_effects.rs:397:5
    |
 LL |     _custom *= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:352:5
+  --> tests/ui/arithmetic_side_effects.rs:399:5
    |
 LL |     _custom >>= -Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:353:5
+  --> tests/ui/arithmetic_side_effects.rs:401:5
    |
 LL |     _custom >>= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:354:5
+  --> tests/ui/arithmetic_side_effects.rs:403:5
    |
 LL |     _custom <<= -Custom;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:355:5
+  --> tests/ui/arithmetic_side_effects.rs:405:5
    |
 LL |     _custom <<= &-Custom;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:358:10
+  --> tests/ui/arithmetic_side_effects.rs:409:10
    |
 LL |     _n = _n + 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:359:10
+  --> tests/ui/arithmetic_side_effects.rs:411:10
    |
 LL |     _n = _n + &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:360:10
+  --> tests/ui/arithmetic_side_effects.rs:413:10
    |
 LL |     _n = 1 + _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:361:10
+  --> tests/ui/arithmetic_side_effects.rs:415:10
    |
 LL |     _n = &1 + _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:362:10
+  --> tests/ui/arithmetic_side_effects.rs:417:10
    |
 LL |     _n = _n - 1;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:363:10
+  --> tests/ui/arithmetic_side_effects.rs:419:10
    |
 LL |     _n = _n - &1;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:364:10
+  --> tests/ui/arithmetic_side_effects.rs:421:10
    |
 LL |     _n = 1 - _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:365:10
+  --> tests/ui/arithmetic_side_effects.rs:423:10
    |
 LL |     _n = &1 - _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:366:10
+  --> tests/ui/arithmetic_side_effects.rs:425:10
    |
 LL |     _n = _n / 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:367:10
+  --> tests/ui/arithmetic_side_effects.rs:427:10
    |
 LL |     _n = _n / &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:368:10
+  --> tests/ui/arithmetic_side_effects.rs:429:10
    |
 LL |     _n = _n % 0;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:369:10
+  --> tests/ui/arithmetic_side_effects.rs:431:10
    |
 LL |     _n = _n % &0;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:370:10
+  --> tests/ui/arithmetic_side_effects.rs:433:10
    |
 LL |     _n = _n * 2;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:371:10
+  --> tests/ui/arithmetic_side_effects.rs:435:10
    |
 LL |     _n = _n * &2;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:372:10
+  --> tests/ui/arithmetic_side_effects.rs:437:10
    |
 LL |     _n = 2 * _n;
    |          ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:373:10
+  --> tests/ui/arithmetic_side_effects.rs:439:10
    |
 LL |     _n = &2 * _n;
    |          ^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:374:10
+  --> tests/ui/arithmetic_side_effects.rs:441:10
    |
 LL |     _n = 23 + &85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:375:10
+  --> tests/ui/arithmetic_side_effects.rs:443:10
    |
 LL |     _n = &23 + 85;
    |          ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:376:10
+  --> tests/ui/arithmetic_side_effects.rs:445:10
    |
 LL |     _n = &23 + &85;
    |          ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:377:15
+  --> tests/ui/arithmetic_side_effects.rs:447:15
    |
 LL |     _custom = _custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:378:15
+  --> tests/ui/arithmetic_side_effects.rs:449:15
    |
 LL |     _custom = _custom + &_custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:379:15
+  --> tests/ui/arithmetic_side_effects.rs:451:15
    |
 LL |     _custom = Custom + _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:380:15
+  --> tests/ui/arithmetic_side_effects.rs:453:15
    |
 LL |     _custom = &Custom + _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:381:15
+  --> tests/ui/arithmetic_side_effects.rs:455:15
    |
 LL |     _custom = _custom - Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:382:15
+  --> tests/ui/arithmetic_side_effects.rs:457:15
    |
 LL |     _custom = _custom - &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:383:15
+  --> tests/ui/arithmetic_side_effects.rs:459:15
    |
 LL |     _custom = Custom - _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:384:15
+  --> tests/ui/arithmetic_side_effects.rs:461:15
    |
 LL |     _custom = &Custom - _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:385:15
+  --> tests/ui/arithmetic_side_effects.rs:463:15
    |
 LL |     _custom = _custom / Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:386:15
+  --> tests/ui/arithmetic_side_effects.rs:465:15
    |
 LL |     _custom = _custom / &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:387:15
+  --> tests/ui/arithmetic_side_effects.rs:467:15
    |
 LL |     _custom = _custom % Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:388:15
+  --> tests/ui/arithmetic_side_effects.rs:469:15
    |
 LL |     _custom = _custom % &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:389:15
+  --> tests/ui/arithmetic_side_effects.rs:471:15
    |
 LL |     _custom = _custom * Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:390:15
+  --> tests/ui/arithmetic_side_effects.rs:473:15
    |
 LL |     _custom = _custom * &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:391:15
+  --> tests/ui/arithmetic_side_effects.rs:475:15
    |
 LL |     _custom = Custom * _custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:392:15
+  --> tests/ui/arithmetic_side_effects.rs:477:15
    |
 LL |     _custom = &Custom * _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:393:15
+  --> tests/ui/arithmetic_side_effects.rs:479:15
    |
 LL |     _custom = Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:394:15
+  --> tests/ui/arithmetic_side_effects.rs:481:15
    |
 LL |     _custom = &Custom + Custom;
    |               ^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:395:15
+  --> tests/ui/arithmetic_side_effects.rs:483:15
    |
 LL |     _custom = &Custom + &Custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:396:15
+  --> tests/ui/arithmetic_side_effects.rs:485:15
    |
 LL |     _custom = _custom >> _custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:397:15
+  --> tests/ui/arithmetic_side_effects.rs:487:15
    |
 LL |     _custom = _custom >> &_custom;
    |               ^^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:398:15
+  --> tests/ui/arithmetic_side_effects.rs:489:15
    |
 LL |     _custom = Custom << _custom;
    |               ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:399:15
+  --> tests/ui/arithmetic_side_effects.rs:491:15
    |
 LL |     _custom = &Custom << _custom;
    |               ^^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:402:23
+  --> tests/ui/arithmetic_side_effects.rs:495:23
    |
 LL |     _n.saturating_div(0);
    |                       ^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:403:21
+  --> tests/ui/arithmetic_side_effects.rs:497:21
    |
 LL |     _n.wrapping_div(0);
    |                     ^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:404:21
+  --> tests/ui/arithmetic_side_effects.rs:499:21
    |
 LL |     _n.wrapping_rem(0);
    |                     ^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:405:28
+  --> tests/ui/arithmetic_side_effects.rs:501:28
    |
 LL |     _n.wrapping_rem_euclid(0);
    |                            ^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:407:23
+  --> tests/ui/arithmetic_side_effects.rs:504:23
    |
 LL |     _n.saturating_div(_n);
    |                       ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:408:21
+  --> tests/ui/arithmetic_side_effects.rs:506:21
    |
 LL |     _n.wrapping_div(_n);
    |                     ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:409:21
+  --> tests/ui/arithmetic_side_effects.rs:508:21
    |
 LL |     _n.wrapping_rem(_n);
    |                     ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:410:28
+  --> tests/ui/arithmetic_side_effects.rs:510:28
    |
 LL |     _n.wrapping_rem_euclid(_n);
    |                            ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:412:23
+  --> tests/ui/arithmetic_side_effects.rs:513:23
    |
 LL |     _n.saturating_div(*Box::new(_n));
    |                       ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:415:10
+  --> tests/ui/arithmetic_side_effects.rs:517:10
    |
 LL |     _n = -_n;
    |          ^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:416:10
+  --> tests/ui/arithmetic_side_effects.rs:519:10
    |
 LL |     _n = -&_n;
    |          ^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:417:15
+  --> tests/ui/arithmetic_side_effects.rs:521:15
    |
 LL |     _custom = -_custom;
    |               ^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:418:15
+  --> tests/ui/arithmetic_side_effects.rs:523:15
    |
 LL |     _custom = -&_custom;
    |               ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:419:9
+  --> tests/ui/arithmetic_side_effects.rs:525:9
    |
 LL |     _ = -*Box::new(_n);
    |         ^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:428:5
+  --> tests/ui/arithmetic_side_effects.rs:535:5
    |
 LL |     1 + i;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:429:5
+  --> tests/ui/arithmetic_side_effects.rs:537:5
    |
 LL |     i * 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:430:5
+  --> tests/ui/arithmetic_side_effects.rs:539:5
    |
 LL |     1 % i / 2;
    |     ^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:431:5
+  --> tests/ui/arithmetic_side_effects.rs:541:5
    |
 LL |     i - 2 + 2 - i;
    |     ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:432:5
+  --> tests/ui/arithmetic_side_effects.rs:543:5
    |
 LL |     -i;
    |     ^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:443:5
+  --> tests/ui/arithmetic_side_effects.rs:555:5
    |
 LL |     i += 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:444:5
+  --> tests/ui/arithmetic_side_effects.rs:557:5
    |
 LL |     i -= 1;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:445:5
+  --> tests/ui/arithmetic_side_effects.rs:559:5
    |
 LL |     i *= 2;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:447:5
+  --> tests/ui/arithmetic_side_effects.rs:562:5
    |
 LL |     i /= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:449:5
+  --> tests/ui/arithmetic_side_effects.rs:565:5
    |
 LL |     i /= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:450:5
+  --> tests/ui/arithmetic_side_effects.rs:567:5
    |
 LL |     i /= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:452:5
+  --> tests/ui/arithmetic_side_effects.rs:570:5
    |
 LL |     i %= 0;
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:454:5
+  --> tests/ui/arithmetic_side_effects.rs:573:5
    |
 LL |     i %= var1;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:455:5
+  --> tests/ui/arithmetic_side_effects.rs:575:5
    |
 LL |     i %= var2;
    |     ^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:465:5
+  --> tests/ui/arithmetic_side_effects.rs:586:5
    |
 LL |     10 / a
    |     ^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:519:9
+  --> tests/ui/arithmetic_side_effects.rs:641:9
    |
 LL |         x / maybe_zero
    |         ^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:523:9
+  --> tests/ui/arithmetic_side_effects.rs:646:9
    |
 LL |         x % maybe_zero
    |         ^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:534:5
+  --> tests/ui/arithmetic_side_effects.rs:658:5
    |
 LL |     one.add_assign(1);
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:538:5
+  --> tests/ui/arithmetic_side_effects.rs:663:5
    |
 LL |     one.sub_assign(1);
    |     ^^^^^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:544:5
+  --> tests/ui/arithmetic_side_effects.rs:670:5
    |
 LL |     one.add(&one);
    |     ^^^^^^^^^^^^^
 
 error: arithmetic operation that can potentially result in unexpected side-effects
-  --> tests/ui/arithmetic_side_effects.rs:545:5
+  --> tests/ui/arithmetic_side_effects.rs:672:5
    |
 LL |     Box::new(one).add(one);
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/as_conversions.rs b/src/tools/clippy/tests/ui/as_conversions.rs
index 8499c0ac5a0f..fba8913a2097 100644
--- a/src/tools/clippy/tests/ui/as_conversions.rs
+++ b/src/tools/clippy/tests/ui/as_conversions.rs
@@ -7,9 +7,11 @@ extern crate proc_macros;
 use proc_macros::{external, with_span};
 
 fn main() {
-    let i = 0u32 as u64;
+    let i = 0u32 as u64; //~ as_conversions
 
     let j = &i as *const u64 as *mut u64;
+    //~^ as_conversions
+    //~| as_conversions
 
     external!(0u32 as u64);
 }
diff --git a/src/tools/clippy/tests/ui/as_pointer_underscore.fixed b/src/tools/clippy/tests/ui/as_pointer_underscore.fixed
index db06486ecb04..93daae6bc668 100644
--- a/src/tools/clippy/tests/ui/as_pointer_underscore.fixed
+++ b/src/tools/clippy/tests/ui/as_pointer_underscore.fixed
@@ -6,10 +6,10 @@ struct S;
 
 fn f(s: &S) -> usize {
     &s as *const &S as usize
-    //~^ ERROR: using inferred pointer cast
+    //~^ as_pointer_underscore
 }
 
 fn g(s: &mut S) -> usize {
     s as *mut S as usize
-    //~^ ERROR: using inferred pointer cast
+    //~^ as_pointer_underscore
 }
diff --git a/src/tools/clippy/tests/ui/as_pointer_underscore.rs b/src/tools/clippy/tests/ui/as_pointer_underscore.rs
index 955c702ccc99..56f1a8935255 100644
--- a/src/tools/clippy/tests/ui/as_pointer_underscore.rs
+++ b/src/tools/clippy/tests/ui/as_pointer_underscore.rs
@@ -6,10 +6,10 @@ struct S;
 
 fn f(s: &S) -> usize {
     &s as *const _ as usize
-    //~^ ERROR: using inferred pointer cast
+    //~^ as_pointer_underscore
 }
 
 fn g(s: &mut S) -> usize {
     s as *mut _ as usize
-    //~^ ERROR: using inferred pointer cast
+    //~^ as_pointer_underscore
 }
diff --git a/src/tools/clippy/tests/ui/as_ptr_cast_mut.rs b/src/tools/clippy/tests/ui/as_ptr_cast_mut.rs
index 9e862320f4ef..baf7279adc4a 100644
--- a/src/tools/clippy/tests/ui/as_ptr_cast_mut.rs
+++ b/src/tools/clippy/tests/ui/as_ptr_cast_mut.rs
@@ -20,10 +20,11 @@ impl<T> Covariant<T> {
 fn main() {
     let mut string = String::new();
     let _ = string.as_ptr() as *mut u8;
-    //~^ ERROR: casting the result of `as_ptr` to *mut u8
-    //~| NOTE: `-D clippy::as-ptr-cast-mut` implied by `-D warnings`
+    //~^ as_ptr_cast_mut
+
     let _: *mut i8 = string.as_ptr() as *mut _;
-    //~^ ERROR: casting the result of `as_ptr` to *mut i8
+    //~^ as_ptr_cast_mut
+
     let _ = string.as_ptr() as *const i8;
     let _ = string.as_mut_ptr();
     let _ = string.as_mut_ptr() as *mut u8;
diff --git a/src/tools/clippy/tests/ui/as_underscore.fixed b/src/tools/clippy/tests/ui/as_underscore.fixed
index c7f26e64cce7..ca2a7f043286 100644
--- a/src/tools/clippy/tests/ui/as_underscore.fixed
+++ b/src/tools/clippy/tests/ui/as_underscore.fixed
@@ -5,7 +5,9 @@ fn foo(_n: usize) {}
 fn main() {
     let n: u16 = 256;
     foo(n as usize);
+    //~^ as_underscore
 
     let n = 0_u128;
     let _n: u8 = n as u8;
+    //~^ as_underscore
 }
diff --git a/src/tools/clippy/tests/ui/as_underscore.rs b/src/tools/clippy/tests/ui/as_underscore.rs
index 70f3b386631c..df500c4c4df1 100644
--- a/src/tools/clippy/tests/ui/as_underscore.rs
+++ b/src/tools/clippy/tests/ui/as_underscore.rs
@@ -5,7 +5,9 @@ fn foo(_n: usize) {}
 fn main() {
     let n: u16 = 256;
     foo(n as _);
+    //~^ as_underscore
 
     let n = 0_u128;
     let _n: u8 = n as _;
+    //~^ as_underscore
 }
diff --git a/src/tools/clippy/tests/ui/as_underscore.stderr b/src/tools/clippy/tests/ui/as_underscore.stderr
index dba56a2a8af3..02c10feb78eb 100644
--- a/src/tools/clippy/tests/ui/as_underscore.stderr
+++ b/src/tools/clippy/tests/ui/as_underscore.stderr
@@ -10,7 +10,7 @@ LL |     foo(n as _);
    = help: to override `-D warnings` add `#[allow(clippy::as_underscore)]`
 
 error: using `as _` conversion
-  --> tests/ui/as_underscore.rs:10:18
+  --> tests/ui/as_underscore.rs:11:18
    |
 LL |     let _n: u8 = n as _;
    |                  ^^^^^-
diff --git a/src/tools/clippy/tests/ui/asm_syntax_not_x86.rs b/src/tools/clippy/tests/ui/asm_syntax_not_x86.rs
index a7d29cc239e5..edcd5247f18c 100644
--- a/src/tools/clippy/tests/ui/asm_syntax_not_x86.rs
+++ b/src/tools/clippy/tests/ui/asm_syntax_not_x86.rs
@@ -1,5 +1,6 @@
 //@ignore-target: i686 x86
 //@needs-asm-support
+//@check-pass
 
 #[warn(clippy::inline_asm_x86_intel_syntax)]
 #[warn(clippy::inline_asm_x86_att_syntax)]
diff --git a/src/tools/clippy/tests/ui/asm_syntax_x86.rs b/src/tools/clippy/tests/ui/asm_syntax_x86.rs
index 5ceaceb7527b..4e91f27cd318 100644
--- a/src/tools/clippy/tests/ui/asm_syntax_x86.rs
+++ b/src/tools/clippy/tests/ui/asm_syntax_x86.rs
@@ -6,19 +6,24 @@ mod warn_intel {
 
     pub(super) unsafe fn use_asm() {
         asm!("");
-        //~^ ERROR: Intel x86 assembly syntax used
+        //~^ inline_asm_x86_intel_syntax
+
         asm!("", options());
-        //~^ ERROR: Intel x86 assembly syntax used
+        //~^ inline_asm_x86_intel_syntax
+
         asm!("", options(nostack));
-        //~^ ERROR: Intel x86 assembly syntax used
+        //~^ inline_asm_x86_intel_syntax
+
         asm!("", options(att_syntax));
         asm!("", options(nostack, att_syntax));
     }
 
     global_asm!("");
-    //~^ ERROR: Intel x86 assembly syntax used
+    //~^ inline_asm_x86_intel_syntax
+
     global_asm!("", options());
-    //~^ ERROR: Intel x86 assembly syntax used
+    //~^ inline_asm_x86_intel_syntax
+
     global_asm!("", options(att_syntax));
 }
 
@@ -31,15 +36,16 @@ mod warn_att {
         asm!("", options());
         asm!("", options(nostack));
         asm!("", options(att_syntax));
-        //~^ ERROR: AT&T x86 assembly syntax used
+        //~^ inline_asm_x86_att_syntax
+
         asm!("", options(nostack, att_syntax));
-        //~^ ERROR: AT&T x86 assembly syntax used
+        //~^ inline_asm_x86_att_syntax
     }
 
     global_asm!("");
     global_asm!("", options());
     global_asm!("", options(att_syntax));
-    //~^ ERROR: AT&T x86 assembly syntax used
+    //~^ inline_asm_x86_att_syntax
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/asm_syntax_x86.stderr b/src/tools/clippy/tests/ui/asm_syntax_x86.stderr
index 1911ef66e239..2dcd955f0347 100644
--- a/src/tools/clippy/tests/ui/asm_syntax_x86.stderr
+++ b/src/tools/clippy/tests/ui/asm_syntax_x86.stderr
@@ -9,7 +9,7 @@ LL |         asm!("");
    = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_intel_syntax)]`
 
 error: Intel x86 assembly syntax used
-  --> tests/ui/asm_syntax_x86.rs:10:9
+  --> tests/ui/asm_syntax_x86.rs:11:9
    |
 LL |         asm!("", options());
    |         ^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |         asm!("", options());
    = help: use AT&T x86 assembly syntax
 
 error: Intel x86 assembly syntax used
-  --> tests/ui/asm_syntax_x86.rs:12:9
+  --> tests/ui/asm_syntax_x86.rs:14:9
    |
 LL |         asm!("", options(nostack));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |         asm!("", options(nostack));
    = help: use AT&T x86 assembly syntax
 
 error: Intel x86 assembly syntax used
-  --> tests/ui/asm_syntax_x86.rs:18:5
+  --> tests/ui/asm_syntax_x86.rs:21:5
    |
 LL |     global_asm!("");
    |     ^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     global_asm!("");
    = help: use AT&T x86 assembly syntax
 
 error: Intel x86 assembly syntax used
-  --> tests/ui/asm_syntax_x86.rs:20:5
+  --> tests/ui/asm_syntax_x86.rs:24:5
    |
 LL |     global_asm!("", options());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     global_asm!("", options());
    = help: use AT&T x86 assembly syntax
 
 error: AT&T x86 assembly syntax used
-  --> tests/ui/asm_syntax_x86.rs:33:9
+  --> tests/ui/asm_syntax_x86.rs:38:9
    |
 LL |         asm!("", options(att_syntax));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL |         asm!("", options(att_syntax));
    = help: to override `-D warnings` add `#[allow(clippy::inline_asm_x86_att_syntax)]`
 
 error: AT&T x86 assembly syntax used
-  --> tests/ui/asm_syntax_x86.rs:35:9
+  --> tests/ui/asm_syntax_x86.rs:41:9
    |
 LL |         asm!("", options(nostack, att_syntax));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL |         asm!("", options(nostack, att_syntax));
    = help: use Intel x86 assembly syntax
 
 error: AT&T x86 assembly syntax used
-  --> tests/ui/asm_syntax_x86.rs:41:5
+  --> tests/ui/asm_syntax_x86.rs:47:5
    |
 LL |     global_asm!("", options(att_syntax));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/assertions_on_constants.rs b/src/tools/clippy/tests/ui/assertions_on_constants.rs
index 957154e60dec..c2516c541475 100644
--- a/src/tools/clippy/tests/ui/assertions_on_constants.rs
+++ b/src/tools/clippy/tests/ui/assertions_on_constants.rs
@@ -8,30 +8,35 @@ macro_rules! assert_const {
 }
 fn main() {
     assert!(true);
-    //~^ ERROR: `assert!(true)` will be optimized out by the compiler
+    //~^ assertions_on_constants
+
     assert!(false);
-    //~^ ERROR: `assert!(false)` should probably be replaced
+    //~^ assertions_on_constants
+
     assert!(true, "true message");
-    //~^ ERROR: `assert!(true)` will be optimized out by the compiler
+    //~^ assertions_on_constants
+
     assert!(false, "false message");
-    //~^ ERROR: `assert!(false, ..)` should probably be replaced
+    //~^ assertions_on_constants
 
     let msg = "panic message";
     assert!(false, "{}", msg.to_uppercase());
-    //~^ ERROR: `assert!(false, ..)` should probably be replaced
+    //~^ assertions_on_constants
 
     const B: bool = true;
     assert!(B);
-    //~^ ERROR: `assert!(true)` will be optimized out by the compiler
+    //~^ assertions_on_constants
 
     const C: bool = false;
     assert!(C);
-    //~^ ERROR: `assert!(false)` should probably be replaced
+    //~^ assertions_on_constants
+
     assert!(C, "C message");
-    //~^ ERROR: `assert!(false, ..)` should probably be replaced
+    //~^ assertions_on_constants
 
     debug_assert!(true);
-    //~^ ERROR: `debug_assert!(true)` will be optimized out by the compiler
+    //~^ assertions_on_constants
+
     // Don't lint this, since there is no better way for expressing "Only panic in debug mode".
     debug_assert!(false); // #3948
     assert_const!(3);
@@ -47,10 +52,10 @@ fn main() {
     assert!(!CFG_FLAG);
 
     const _: () = assert!(true);
-    //~^ ERROR: `assert!(true)` will be optimized out by the compiler
+    //~^ assertions_on_constants
 
     assert!(8 == (7 + 1));
-    //~^ ERROR: `assert!(true)` will be optimized out by the compiler
+    //~^ assertions_on_constants
 
     // Don't lint if the value is dependent on a defined constant:
     const N: usize = 1024;
@@ -59,6 +64,7 @@ fn main() {
 
 const _: () = {
     assert!(true);
-    //~^ ERROR: `assert!(true)` will be optimized out by the compiler
+    //~^ assertions_on_constants
+
     assert!(8 == (7 + 1));
 };
diff --git a/src/tools/clippy/tests/ui/assertions_on_constants.stderr b/src/tools/clippy/tests/ui/assertions_on_constants.stderr
index e164a999c43e..8b7440ec4832 100644
--- a/src/tools/clippy/tests/ui/assertions_on_constants.stderr
+++ b/src/tools/clippy/tests/ui/assertions_on_constants.stderr
@@ -9,7 +9,7 @@ LL |     assert!(true);
    = help: to override `-D warnings` add `#[allow(clippy::assertions_on_constants)]`
 
 error: `assert!(false)` should probably be replaced
-  --> tests/ui/assertions_on_constants.rs:12:5
+  --> tests/ui/assertions_on_constants.rs:13:5
    |
 LL |     assert!(false);
    |     ^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     assert!(false);
    = help: use `panic!()` or `unreachable!()`
 
 error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:14:5
+  --> tests/ui/assertions_on_constants.rs:16:5
    |
 LL |     assert!(true, "true message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     assert!(true, "true message");
    = help: remove it
 
 error: `assert!(false, ..)` should probably be replaced
-  --> tests/ui/assertions_on_constants.rs:16:5
+  --> tests/ui/assertions_on_constants.rs:19:5
    |
 LL |     assert!(false, "false message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     assert!(false, "false message");
    = help: use `panic!(..)` or `unreachable!(..)`
 
 error: `assert!(false, ..)` should probably be replaced
-  --> tests/ui/assertions_on_constants.rs:20:5
+  --> tests/ui/assertions_on_constants.rs:23:5
    |
 LL |     assert!(false, "{}", msg.to_uppercase());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     assert!(false, "{}", msg.to_uppercase());
    = help: use `panic!(..)` or `unreachable!(..)`
 
 error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:24:5
+  --> tests/ui/assertions_on_constants.rs:27:5
    |
 LL |     assert!(B);
    |     ^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     assert!(B);
    = help: remove it
 
 error: `assert!(false)` should probably be replaced
-  --> tests/ui/assertions_on_constants.rs:28:5
+  --> tests/ui/assertions_on_constants.rs:31:5
    |
 LL |     assert!(C);
    |     ^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     assert!(C);
    = help: use `panic!()` or `unreachable!()`
 
 error: `assert!(false, ..)` should probably be replaced
-  --> tests/ui/assertions_on_constants.rs:30:5
+  --> tests/ui/assertions_on_constants.rs:34:5
    |
 LL |     assert!(C, "C message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     assert!(C, "C message");
    = help: use `panic!(..)` or `unreachable!(..)`
 
 error: `debug_assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:33:5
+  --> tests/ui/assertions_on_constants.rs:37:5
    |
 LL |     debug_assert!(true);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     debug_assert!(true);
    = help: remove it
 
 error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:49:19
+  --> tests/ui/assertions_on_constants.rs:54:19
    |
 LL |     const _: () = assert!(true);
    |                   ^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     const _: () = assert!(true);
    = help: remove it
 
 error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:52:5
+  --> tests/ui/assertions_on_constants.rs:57:5
    |
 LL |     assert!(8 == (7 + 1));
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     assert!(8 == (7 + 1));
    = help: remove it
 
 error: `assert!(true)` will be optimized out by the compiler
-  --> tests/ui/assertions_on_constants.rs:61:5
+  --> tests/ui/assertions_on_constants.rs:66:5
    |
 LL |     assert!(true);
    |     ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/assertions_on_result_states.fixed b/src/tools/clippy/tests/ui/assertions_on_result_states.fixed
index 14d9b8b99d5e..09c1a8d0ed1d 100644
--- a/src/tools/clippy/tests/ui/assertions_on_result_states.fixed
+++ b/src/tools/clippy/tests/ui/assertions_on_result_states.fixed
@@ -22,6 +22,7 @@ fn main() {
     let r: Result<Foo, DebugFoo> = Ok(Foo);
     debug_assert!(r.is_ok());
     r.unwrap();
+    //~^ assertions_on_result_states
 
     // test ok with non-debug error type
     let r: Result<Foo, Foo> = Ok(Foo);
@@ -40,9 +41,11 @@ fn main() {
         Ok(Foo)
     }
     get_ok().unwrap();
+    //~^ assertions_on_result_states
 
     // test macro ok
     get_ok_macro!().unwrap();
+    //~^ assertions_on_result_states
 
     // test ok that shouldn't be moved
     let r: Result<CopyFoo, DebugFoo> = Ok(CopyFoo);
@@ -56,12 +59,14 @@ fn main() {
     // test ok that is copied
     let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
     r.unwrap();
+    //~^ assertions_on_result_states
     r.unwrap();
 
     // test reference to ok
     let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
     fn test_ref_copy_ok(r: &Result<CopyFoo, CopyFoo>) {
         r.unwrap();
+        //~^ assertions_on_result_states
     }
     test_ref_copy_ok(&r);
     r.unwrap();
@@ -70,6 +75,7 @@ fn main() {
     let r: Result<DebugFoo, Foo> = Err(Foo);
     debug_assert!(r.is_err());
     r.unwrap_err();
+    //~^ assertions_on_result_states
 
     // test err with non-debug value type
     let r: Result<Foo, Foo> = Err(Foo);
@@ -80,4 +86,5 @@ fn main() {
 fn issue9450() {
     let res: Result<i32, i32> = Ok(1);
     res.unwrap_err();
+    //~^ assertions_on_result_states
 }
diff --git a/src/tools/clippy/tests/ui/assertions_on_result_states.rs b/src/tools/clippy/tests/ui/assertions_on_result_states.rs
index ac1911d87c93..c63c2502b537 100644
--- a/src/tools/clippy/tests/ui/assertions_on_result_states.rs
+++ b/src/tools/clippy/tests/ui/assertions_on_result_states.rs
@@ -22,6 +22,7 @@ fn main() {
     let r: Result<Foo, DebugFoo> = Ok(Foo);
     debug_assert!(r.is_ok());
     assert!(r.is_ok());
+    //~^ assertions_on_result_states
 
     // test ok with non-debug error type
     let r: Result<Foo, Foo> = Ok(Foo);
@@ -40,9 +41,11 @@ fn main() {
         Ok(Foo)
     }
     assert!(get_ok().is_ok());
+    //~^ assertions_on_result_states
 
     // test macro ok
     assert!(get_ok_macro!().is_ok());
+    //~^ assertions_on_result_states
 
     // test ok that shouldn't be moved
     let r: Result<CopyFoo, DebugFoo> = Ok(CopyFoo);
@@ -56,12 +59,14 @@ fn main() {
     // test ok that is copied
     let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
     assert!(r.is_ok());
+    //~^ assertions_on_result_states
     r.unwrap();
 
     // test reference to ok
     let r: Result<CopyFoo, CopyFoo> = Ok(CopyFoo);
     fn test_ref_copy_ok(r: &Result<CopyFoo, CopyFoo>) {
         assert!(r.is_ok());
+        //~^ assertions_on_result_states
     }
     test_ref_copy_ok(&r);
     r.unwrap();
@@ -70,6 +75,7 @@ fn main() {
     let r: Result<DebugFoo, Foo> = Err(Foo);
     debug_assert!(r.is_err());
     assert!(r.is_err());
+    //~^ assertions_on_result_states
 
     // test err with non-debug value type
     let r: Result<Foo, Foo> = Err(Foo);
@@ -80,4 +86,5 @@ fn main() {
 fn issue9450() {
     let res: Result<i32, i32> = Ok(1);
     assert!(res.is_err())
+    //~^ assertions_on_result_states
 }
diff --git a/src/tools/clippy/tests/ui/assertions_on_result_states.stderr b/src/tools/clippy/tests/ui/assertions_on_result_states.stderr
index a2bddc7025a9..3bf811588c69 100644
--- a/src/tools/clippy/tests/ui/assertions_on_result_states.stderr
+++ b/src/tools/clippy/tests/ui/assertions_on_result_states.stderr
@@ -8,37 +8,37 @@ LL |     assert!(r.is_ok());
    = help: to override `-D warnings` add `#[allow(clippy::assertions_on_result_states)]`
 
 error: called `assert!` with `Result::is_ok`
-  --> tests/ui/assertions_on_result_states.rs:42:5
+  --> tests/ui/assertions_on_result_states.rs:43:5
    |
 LL |     assert!(get_ok().is_ok());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get_ok().unwrap()`
 
 error: called `assert!` with `Result::is_ok`
-  --> tests/ui/assertions_on_result_states.rs:45:5
+  --> tests/ui/assertions_on_result_states.rs:47:5
    |
 LL |     assert!(get_ok_macro!().is_ok());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `get_ok_macro!().unwrap()`
 
 error: called `assert!` with `Result::is_ok`
-  --> tests/ui/assertions_on_result_states.rs:58:5
+  --> tests/ui/assertions_on_result_states.rs:61:5
    |
 LL |     assert!(r.is_ok());
    |     ^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap()`
 
 error: called `assert!` with `Result::is_ok`
-  --> tests/ui/assertions_on_result_states.rs:64:9
+  --> tests/ui/assertions_on_result_states.rs:68:9
    |
 LL |         assert!(r.is_ok());
    |         ^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap()`
 
 error: called `assert!` with `Result::is_err`
-  --> tests/ui/assertions_on_result_states.rs:72:5
+  --> tests/ui/assertions_on_result_states.rs:77:5
    |
 LL |     assert!(r.is_err());
    |     ^^^^^^^^^^^^^^^^^^^ help: replace with: `r.unwrap_err()`
 
 error: called `assert!` with `Result::is_err`
-  --> tests/ui/assertions_on_result_states.rs:82:5
+  --> tests/ui/assertions_on_result_states.rs:88:5
    |
 LL |     assert!(res.is_err())
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with: `res.unwrap_err();`
diff --git a/src/tools/clippy/tests/ui/assign_ops.fixed b/src/tools/clippy/tests/ui/assign_ops.fixed
index 2bd0807f4262..18f0e04a8807 100644
--- a/src/tools/clippy/tests/ui/assign_ops.fixed
+++ b/src/tools/clippy/tests/ui/assign_ops.fixed
@@ -5,25 +5,36 @@ use core::num::Wrapping;
 fn main() {
     let mut a = 5;
     a += 1;
+    //~^ assign_op_pattern
     a += 1;
+    //~^ assign_op_pattern
     a -= 1;
+    //~^ assign_op_pattern
     a *= 99;
+    //~^ assign_op_pattern
     a *= 42;
+    //~^ assign_op_pattern
     a /= 2;
+    //~^ assign_op_pattern
     a %= 5;
+    //~^ assign_op_pattern
     a &= 1;
+    //~^ assign_op_pattern
     a = 1 - a;
     a = 5 / a;
     a = 42 % a;
     a = 6 << a;
     let mut s = String::new();
     s += "bla";
+    //~^ assign_op_pattern
 
     // Issue #9180
     let mut a = Wrapping(0u32);
     a += Wrapping(1u32);
+    //~^ assign_op_pattern
     let mut v = vec![0u32, 1u32];
     v[0] += v[1];
+    //~^ assign_op_pattern
     let mut v = vec![Wrapping(0u32), Wrapping(1u32)];
     v[0] = v[0] + v[1];
     let _ = || v[0] = v[0] + v[1];
diff --git a/src/tools/clippy/tests/ui/assign_ops.rs b/src/tools/clippy/tests/ui/assign_ops.rs
index be3491a44c7e..8b05c74d8604 100644
--- a/src/tools/clippy/tests/ui/assign_ops.rs
+++ b/src/tools/clippy/tests/ui/assign_ops.rs
@@ -5,25 +5,36 @@ use core::num::Wrapping;
 fn main() {
     let mut a = 5;
     a = a + 1;
+    //~^ assign_op_pattern
     a = 1 + a;
+    //~^ assign_op_pattern
     a = a - 1;
+    //~^ assign_op_pattern
     a = a * 99;
+    //~^ assign_op_pattern
     a = 42 * a;
+    //~^ assign_op_pattern
     a = a / 2;
+    //~^ assign_op_pattern
     a = a % 5;
+    //~^ assign_op_pattern
     a = a & 1;
+    //~^ assign_op_pattern
     a = 1 - a;
     a = 5 / a;
     a = 42 % a;
     a = 6 << a;
     let mut s = String::new();
     s = s + "bla";
+    //~^ assign_op_pattern
 
     // Issue #9180
     let mut a = Wrapping(0u32);
     a = a + Wrapping(1u32);
+    //~^ assign_op_pattern
     let mut v = vec![0u32, 1u32];
     v[0] = v[0] + v[1];
+    //~^ assign_op_pattern
     let mut v = vec![Wrapping(0u32), Wrapping(1u32)];
     v[0] = v[0] + v[1];
     let _ = || v[0] = v[0] + v[1];
diff --git a/src/tools/clippy/tests/ui/assign_ops.stderr b/src/tools/clippy/tests/ui/assign_ops.stderr
index 4975ac5911fd..17f216ee4a07 100644
--- a/src/tools/clippy/tests/ui/assign_ops.stderr
+++ b/src/tools/clippy/tests/ui/assign_ops.stderr
@@ -8,61 +8,61 @@ LL |     a = a + 1;
    = help: to override `-D warnings` add `#[allow(clippy::assign_op_pattern)]`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:8:5
+  --> tests/ui/assign_ops.rs:9:5
    |
 LL |     a = 1 + a;
    |     ^^^^^^^^^ help: replace it with: `a += 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:9:5
+  --> tests/ui/assign_ops.rs:11:5
    |
 LL |     a = a - 1;
    |     ^^^^^^^^^ help: replace it with: `a -= 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:10:5
+  --> tests/ui/assign_ops.rs:13:5
    |
 LL |     a = a * 99;
    |     ^^^^^^^^^^ help: replace it with: `a *= 99`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:11:5
+  --> tests/ui/assign_ops.rs:15:5
    |
 LL |     a = 42 * a;
    |     ^^^^^^^^^^ help: replace it with: `a *= 42`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:12:5
+  --> tests/ui/assign_ops.rs:17:5
    |
 LL |     a = a / 2;
    |     ^^^^^^^^^ help: replace it with: `a /= 2`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:13:5
+  --> tests/ui/assign_ops.rs:19:5
    |
 LL |     a = a % 5;
    |     ^^^^^^^^^ help: replace it with: `a %= 5`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:14:5
+  --> tests/ui/assign_ops.rs:21:5
    |
 LL |     a = a & 1;
    |     ^^^^^^^^^ help: replace it with: `a &= 1`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:20:5
+  --> tests/ui/assign_ops.rs:28:5
    |
 LL |     s = s + "bla";
    |     ^^^^^^^^^^^^^ help: replace it with: `s += "bla"`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:24:5
+  --> tests/ui/assign_ops.rs:33:5
    |
 LL |     a = a + Wrapping(1u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a += Wrapping(1u32)`
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops.rs:26:5
+  --> tests/ui/assign_ops.rs:36:5
    |
 LL |     v[0] = v[0] + v[1];
    |     ^^^^^^^^^^^^^^^^^^ help: replace it with: `v[0] += v[1]`
diff --git a/src/tools/clippy/tests/ui/assign_ops2.rs b/src/tools/clippy/tests/ui/assign_ops2.rs
index a53556425849..51867fa6962c 100644
--- a/src/tools/clippy/tests/ui/assign_ops2.rs
+++ b/src/tools/clippy/tests/ui/assign_ops2.rs
@@ -6,24 +6,32 @@
 fn main() {
     let mut a = 5;
     a += a + 1;
-    //~^ ERROR: variable appears on both sides of an assignment operation
-    //~| NOTE: `-D clippy::misrefactored-assign-op` implied by `-D warnings`
+    //~^ misrefactored_assign_op
+
     a += 1 + a;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a -= a - 1;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a *= a * 99;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a *= 42 * a;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a /= a / 2;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a %= a % 5;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a &= a & 1;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a *= a * a;
-    //~^ ERROR: variable appears on both sides of an assignment operation
+    //~^ misrefactored_assign_op
+
     a = a * a * a;
     a = a * 42 * a;
     a = a * 2 + a;
@@ -61,8 +69,7 @@ fn cow_add_assign() {
 
     // this can be linted
     buf = buf + cows.clone();
-    //~^ ERROR: manual implementation of an assign operation
-    //~| NOTE: `-D clippy::assign-op-pattern` implied by `-D warnings`
+    //~^ assign_op_pattern
 
     // this should not as cow<str> Add is not commutative
     buf = cows + buf;
diff --git a/src/tools/clippy/tests/ui/assign_ops2.stderr b/src/tools/clippy/tests/ui/assign_ops2.stderr
index 09b101b216a5..d9ecd3f8b230 100644
--- a/src/tools/clippy/tests/ui/assign_ops2.stderr
+++ b/src/tools/clippy/tests/ui/assign_ops2.stderr
@@ -35,7 +35,7 @@ LL +     a = a + 1 + a;
    |
 
 error: variable appears on both sides of an assignment operation
-  --> tests/ui/assign_ops2.rs:13:5
+  --> tests/ui/assign_ops2.rs:14:5
    |
 LL |     a -= a - 1;
    |     ^^^^^^^^^^
@@ -52,7 +52,7 @@ LL +     a = a - (a - 1);
    |
 
 error: variable appears on both sides of an assignment operation
-  --> tests/ui/assign_ops2.rs:15:5
+  --> tests/ui/assign_ops2.rs:17:5
    |
 LL |     a *= a * 99;
    |     ^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL +     a = a * a * 99;
    |
 
 error: variable appears on both sides of an assignment operation
-  --> tests/ui/assign_ops2.rs:17:5
+  --> tests/ui/assign_ops2.rs:20:5
    |
 LL |     a *= 42 * a;
    |     ^^^^^^^^^^^
@@ -86,7 +86,7 @@ LL +     a = a * 42 * a;
    |
 
 error: variable appears on both sides of an assignment operation
-  --> tests/ui/assign_ops2.rs:19:5
+  --> tests/ui/assign_ops2.rs:23:5
    |
 LL |     a /= a / 2;
    |     ^^^^^^^^^^
@@ -103,7 +103,7 @@ LL +     a = a / (a / 2);
    |
 
 error: variable appears on both sides of an assignment operation
-  --> tests/ui/assign_ops2.rs:21:5
+  --> tests/ui/assign_ops2.rs:26:5
    |
 LL |     a %= a % 5;
    |     ^^^^^^^^^^
@@ -120,7 +120,7 @@ LL +     a = a % (a % 5);
    |
 
 error: variable appears on both sides of an assignment operation
-  --> tests/ui/assign_ops2.rs:23:5
+  --> tests/ui/assign_ops2.rs:29:5
    |
 LL |     a &= a & 1;
    |     ^^^^^^^^^^
@@ -137,7 +137,7 @@ LL +     a = a & a & 1;
    |
 
 error: variable appears on both sides of an assignment operation
-  --> tests/ui/assign_ops2.rs:25:5
+  --> tests/ui/assign_ops2.rs:32:5
    |
 LL |     a *= a * a;
    |     ^^^^^^^^^^
@@ -154,7 +154,7 @@ LL +     a = a * a * a;
    |
 
 error: manual implementation of an assign operation
-  --> tests/ui/assign_ops2.rs:63:5
+  --> tests/ui/assign_ops2.rs:71:5
    |
 LL |     buf = buf + cows.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `buf += cows.clone()`
diff --git a/src/tools/clippy/tests/ui/assigning_clones.fixed b/src/tools/clippy/tests/ui/assigning_clones.fixed
index 09732d1a50ce..9e44008e6fab 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.fixed
+++ b/src/tools/clippy/tests/ui/assigning_clones.fixed
@@ -23,60 +23,73 @@ impl Clone for HasCloneFrom {
 
 fn clone_method_rhs_val(mut_thing: &mut HasCloneFrom, value_thing: HasCloneFrom) {
     mut_thing.clone_from(&value_thing);
+    //~^ assigning_clones
 }
 
 fn clone_method_rhs_ref(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     mut_thing.clone_from(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_method_lhs_val(mut mut_thing: HasCloneFrom, ref_thing: &HasCloneFrom) {
     mut_thing.clone_from(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_lhs_mut_ref(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     Clone::clone_from(mut_thing, ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_lhs_val(mut mut_thing: HasCloneFrom, ref_thing: &HasCloneFrom) {
     Clone::clone_from(&mut mut_thing, ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_through_trait(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     Clone::clone_from(mut_thing, ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_through_type(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     Clone::clone_from(mut_thing, ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_fully_qualified(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     Clone::clone_from(mut_thing, ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_method_lhs_complex(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     // These parens should be kept as necessary for a receiver
     (mut_thing + &mut HasCloneFrom).clone_from(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_method_rhs_complex(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     // These parens should be removed since they are not needed in a function argument
     mut_thing.clone_from(ref_thing + ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_method_macro() {
     let mut s = String::from("");
     s.clone_from(&format!("{} {}", "hello", "world"));
+    //~^ assigning_clones
 }
 
 fn clone_function_macro() {
     let mut s = String::from("");
     Clone::clone_from(&mut s, &format!("{} {}", "hello", "world"));
+    //~^ assigning_clones
 }
 
 fn assign_to_init_mut_var(b: HasCloneFrom) -> HasCloneFrom {
     let mut a = HasCloneFrom;
     for _ in 1..10 {
         a.clone_from(&b);
+        //~^ assigning_clones
     }
     a
 }
@@ -148,6 +161,7 @@ fn ignore_generic_clone<T: Clone>(a: &mut T, b: &T) {
 #[clippy::msrv = "1.62"]
 fn msrv_1_62(mut a: String, b: String, c: &str) {
     a.clone_from(&b);
+    //~^ assigning_clones
     // Should not be linted, as clone_into wasn't stabilized until 1.63
     a = c.to_owned();
 }
@@ -155,7 +169,9 @@ fn msrv_1_62(mut a: String, b: String, c: &str) {
 #[clippy::msrv = "1.63"]
 fn msrv_1_63(mut a: String, b: String, c: &str) {
     a.clone_from(&b);
+    //~^ assigning_clones
     c.clone_into(&mut a);
+    //~^ assigning_clones
 }
 
 macro_rules! clone_inside {
@@ -186,35 +202,43 @@ impl Clone for AvoidRecursiveCloneFrom {
 // Deref handling
 fn clone_into_deref_method(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
     (*a).clone_from(&b);
+    //~^ assigning_clones
 }
 
 fn clone_into_deref_with_clone_method(mut a: DerefWrapperWithClone<HasCloneFrom>, b: HasCloneFrom) {
     (*a).clone_from(&b);
+    //~^ assigning_clones
 }
 
 fn clone_into_box_method(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
     (*a).clone_from(&b);
+    //~^ assigning_clones
 }
 
 fn clone_into_self_deref_method(a: &mut DerefWrapperWithClone<HasCloneFrom>, b: DerefWrapperWithClone<HasCloneFrom>) {
     a.clone_from(&b);
+    //~^ assigning_clones
 }
 
 fn clone_into_deref_function(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
     Clone::clone_from(&mut *a, &b);
+    //~^ assigning_clones
 }
 
 fn clone_into_box_function(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
     Clone::clone_from(&mut *a, &b);
+    //~^ assigning_clones
 }
 
 // ToOwned
 fn owned_method_mut_ref(mut_string: &mut String, ref_str: &str) {
     ref_str.clone_into(mut_string);
+    //~^ assigning_clones
 }
 
 fn owned_method_val(mut mut_string: String, ref_str: &str) {
     ref_str.clone_into(&mut mut_string);
+    //~^ assigning_clones
 }
 
 struct HasDeref {
@@ -236,28 +260,34 @@ impl DerefMut for HasDeref {
 
 fn owned_method_box(mut_box_string: &mut Box<String>, ref_str: &str) {
     ref_str.clone_into(&mut (*mut_box_string));
+    //~^ assigning_clones
 }
 
 fn owned_method_deref(mut_box_string: &mut HasDeref, ref_str: &str) {
     ref_str.clone_into(&mut (*mut_box_string));
+    //~^ assigning_clones
 }
 
 fn owned_function_mut_ref(mut_thing: &mut String, ref_str: &str) {
     ToOwned::clone_into(ref_str, mut_thing);
+    //~^ assigning_clones
 }
 
 fn owned_function_val(mut mut_thing: String, ref_str: &str) {
     ToOwned::clone_into(ref_str, &mut mut_thing);
+    //~^ assigning_clones
 }
 
 fn owned_method_macro() {
     let mut s = String::from("");
     format!("{} {}", "hello", "world").clone_into(&mut s);
+    //~^ assigning_clones
 }
 
 fn owned_function_macro() {
     let mut s = String::from("");
     ToOwned::clone_into(&format!("{} {}", "hello", "world"), &mut s);
+    //~^ assigning_clones
 }
 
 struct FakeToOwned;
diff --git a/src/tools/clippy/tests/ui/assigning_clones.rs b/src/tools/clippy/tests/ui/assigning_clones.rs
index 6be25ae17a55..8ae8abfed367 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.rs
+++ b/src/tools/clippy/tests/ui/assigning_clones.rs
@@ -23,60 +23,73 @@ impl Clone for HasCloneFrom {
 
 fn clone_method_rhs_val(mut_thing: &mut HasCloneFrom, value_thing: HasCloneFrom) {
     *mut_thing = value_thing.clone();
+    //~^ assigning_clones
 }
 
 fn clone_method_rhs_ref(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     *mut_thing = ref_thing.clone();
+    //~^ assigning_clones
 }
 
 fn clone_method_lhs_val(mut mut_thing: HasCloneFrom, ref_thing: &HasCloneFrom) {
     mut_thing = ref_thing.clone();
+    //~^ assigning_clones
 }
 
 fn clone_function_lhs_mut_ref(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     *mut_thing = Clone::clone(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_lhs_val(mut mut_thing: HasCloneFrom, ref_thing: &HasCloneFrom) {
     mut_thing = Clone::clone(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_through_trait(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     *mut_thing = Clone::clone(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_through_type(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     *mut_thing = HasCloneFrom::clone(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_function_fully_qualified(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     *mut_thing = <HasCloneFrom as Clone>::clone(ref_thing);
+    //~^ assigning_clones
 }
 
 fn clone_method_lhs_complex(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     // These parens should be kept as necessary for a receiver
     *(mut_thing + &mut HasCloneFrom) = ref_thing.clone();
+    //~^ assigning_clones
 }
 
 fn clone_method_rhs_complex(mut_thing: &mut HasCloneFrom, ref_thing: &HasCloneFrom) {
     // These parens should be removed since they are not needed in a function argument
     *mut_thing = (ref_thing + ref_thing).clone();
+    //~^ assigning_clones
 }
 
 fn clone_method_macro() {
     let mut s = String::from("");
     s = format!("{} {}", "hello", "world").clone();
+    //~^ assigning_clones
 }
 
 fn clone_function_macro() {
     let mut s = String::from("");
     s = Clone::clone(&format!("{} {}", "hello", "world"));
+    //~^ assigning_clones
 }
 
 fn assign_to_init_mut_var(b: HasCloneFrom) -> HasCloneFrom {
     let mut a = HasCloneFrom;
     for _ in 1..10 {
         a = b.clone();
+        //~^ assigning_clones
     }
     a
 }
@@ -148,6 +161,7 @@ fn ignore_generic_clone<T: Clone>(a: &mut T, b: &T) {
 #[clippy::msrv = "1.62"]
 fn msrv_1_62(mut a: String, b: String, c: &str) {
     a = b.clone();
+    //~^ assigning_clones
     // Should not be linted, as clone_into wasn't stabilized until 1.63
     a = c.to_owned();
 }
@@ -155,7 +169,9 @@ fn msrv_1_62(mut a: String, b: String, c: &str) {
 #[clippy::msrv = "1.63"]
 fn msrv_1_63(mut a: String, b: String, c: &str) {
     a = b.clone();
+    //~^ assigning_clones
     a = c.to_owned();
+    //~^ assigning_clones
 }
 
 macro_rules! clone_inside {
@@ -186,35 +202,43 @@ impl Clone for AvoidRecursiveCloneFrom {
 // Deref handling
 fn clone_into_deref_method(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
     *a = b.clone();
+    //~^ assigning_clones
 }
 
 fn clone_into_deref_with_clone_method(mut a: DerefWrapperWithClone<HasCloneFrom>, b: HasCloneFrom) {
     *a = b.clone();
+    //~^ assigning_clones
 }
 
 fn clone_into_box_method(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
     *a = b.clone();
+    //~^ assigning_clones
 }
 
 fn clone_into_self_deref_method(a: &mut DerefWrapperWithClone<HasCloneFrom>, b: DerefWrapperWithClone<HasCloneFrom>) {
     *a = b.clone();
+    //~^ assigning_clones
 }
 
 fn clone_into_deref_function(mut a: DerefWrapper<HasCloneFrom>, b: HasCloneFrom) {
     *a = Clone::clone(&b);
+    //~^ assigning_clones
 }
 
 fn clone_into_box_function(mut a: Box<HasCloneFrom>, b: HasCloneFrom) {
     *a = Clone::clone(&b);
+    //~^ assigning_clones
 }
 
 // ToOwned
 fn owned_method_mut_ref(mut_string: &mut String, ref_str: &str) {
     *mut_string = ref_str.to_owned();
+    //~^ assigning_clones
 }
 
 fn owned_method_val(mut mut_string: String, ref_str: &str) {
     mut_string = ref_str.to_owned();
+    //~^ assigning_clones
 }
 
 struct HasDeref {
@@ -236,28 +260,34 @@ impl DerefMut for HasDeref {
 
 fn owned_method_box(mut_box_string: &mut Box<String>, ref_str: &str) {
     **mut_box_string = ref_str.to_owned();
+    //~^ assigning_clones
 }
 
 fn owned_method_deref(mut_box_string: &mut HasDeref, ref_str: &str) {
     **mut_box_string = ref_str.to_owned();
+    //~^ assigning_clones
 }
 
 fn owned_function_mut_ref(mut_thing: &mut String, ref_str: &str) {
     *mut_thing = ToOwned::to_owned(ref_str);
+    //~^ assigning_clones
 }
 
 fn owned_function_val(mut mut_thing: String, ref_str: &str) {
     mut_thing = ToOwned::to_owned(ref_str);
+    //~^ assigning_clones
 }
 
 fn owned_method_macro() {
     let mut s = String::from("");
     s = format!("{} {}", "hello", "world").to_owned();
+    //~^ assigning_clones
 }
 
 fn owned_function_macro() {
     let mut s = String::from("");
     s = ToOwned::to_owned(&format!("{} {}", "hello", "world"));
+    //~^ assigning_clones
 }
 
 struct FakeToOwned;
diff --git a/src/tools/clippy/tests/ui/assigning_clones.stderr b/src/tools/clippy/tests/ui/assigning_clones.stderr
index 19724a6d4ec2..2714d599b28a 100644
--- a/src/tools/clippy/tests/ui/assigning_clones.stderr
+++ b/src/tools/clippy/tests/ui/assigning_clones.stderr
@@ -8,175 +8,175 @@ LL |     *mut_thing = value_thing.clone();
    = help: to override `-D warnings` add `#[allow(clippy::assigning_clones)]`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:29:5
+  --> tests/ui/assigning_clones.rs:30:5
    |
 LL |     *mut_thing = ref_thing.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:33:5
+  --> tests/ui/assigning_clones.rs:35:5
    |
 LL |     mut_thing = ref_thing.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:37:5
+  --> tests/ui/assigning_clones.rs:40:5
    |
 LL |     *mut_thing = Clone::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:41:5
+  --> tests/ui/assigning_clones.rs:45:5
    |
 LL |     mut_thing = Clone::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:45:5
+  --> tests/ui/assigning_clones.rs:50:5
    |
 LL |     *mut_thing = Clone::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:49:5
+  --> tests/ui/assigning_clones.rs:55:5
    |
 LL |     *mut_thing = HasCloneFrom::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:53:5
+  --> tests/ui/assigning_clones.rs:60:5
    |
 LL |     *mut_thing = <HasCloneFrom as Clone>::clone(ref_thing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(mut_thing, ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:58:5
+  --> tests/ui/assigning_clones.rs:66:5
    |
 LL |     *(mut_thing + &mut HasCloneFrom) = ref_thing.clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `(mut_thing + &mut HasCloneFrom).clone_from(ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:63:5
+  --> tests/ui/assigning_clones.rs:72:5
    |
 LL |     *mut_thing = (ref_thing + ref_thing).clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `mut_thing.clone_from(ref_thing + ref_thing)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:68:5
+  --> tests/ui/assigning_clones.rs:78:5
    |
 LL |     s = format!("{} {}", "hello", "world").clone();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `s.clone_from(&format!("{} {}", "hello", "world"))`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:73:5
+  --> tests/ui/assigning_clones.rs:84:5
    |
 LL |     s = Clone::clone(&format!("{} {}", "hello", "world"));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut s, &format!("{} {}", "hello", "world"))`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:79:9
+  --> tests/ui/assigning_clones.rs:91:9
    |
 LL |         a = b.clone();
    |         ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:150:5
+  --> tests/ui/assigning_clones.rs:163:5
    |
 LL |     a = b.clone();
    |     ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:157:5
+  --> tests/ui/assigning_clones.rs:171:5
    |
 LL |     a = b.clone();
    |     ^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:158:5
+  --> tests/ui/assigning_clones.rs:173:5
    |
 LL |     a = c.to_owned();
    |     ^^^^^^^^^^^^^^^^ help: use `clone_into()`: `c.clone_into(&mut a)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:188:5
+  --> tests/ui/assigning_clones.rs:204:5
    |
 LL |     *a = b.clone();
    |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:192:5
+  --> tests/ui/assigning_clones.rs:209:5
    |
 LL |     *a = b.clone();
    |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:196:5
+  --> tests/ui/assigning_clones.rs:214:5
    |
 LL |     *a = b.clone();
    |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `(*a).clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:200:5
+  --> tests/ui/assigning_clones.rs:219:5
    |
 LL |     *a = b.clone();
    |     ^^^^^^^^^^^^^^ help: use `clone_from()`: `a.clone_from(&b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:204:5
+  --> tests/ui/assigning_clones.rs:224:5
    |
 LL |     *a = Clone::clone(&b);
    |     ^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut *a, &b)`
 
 error: assigning the result of `Clone::clone()` may be inefficient
-  --> tests/ui/assigning_clones.rs:208:5
+  --> tests/ui/assigning_clones.rs:229:5
    |
 LL |     *a = Clone::clone(&b);
    |     ^^^^^^^^^^^^^^^^^^^^^ help: use `clone_from()`: `Clone::clone_from(&mut *a, &b)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:213:5
+  --> tests/ui/assigning_clones.rs:235:5
    |
 LL |     *mut_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(mut_string)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:217:5
+  --> tests/ui/assigning_clones.rs:240:5
    |
 LL |     mut_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut mut_string)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:238:5
+  --> tests/ui/assigning_clones.rs:262:5
    |
 LL |     **mut_box_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:242:5
+  --> tests/ui/assigning_clones.rs:267:5
    |
 LL |     **mut_box_string = ref_str.to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ref_str.clone_into(&mut (*mut_box_string))`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:246:5
+  --> tests/ui/assigning_clones.rs:272:5
    |
 LL |     *mut_thing = ToOwned::to_owned(ref_str);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, mut_thing)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:250:5
+  --> tests/ui/assigning_clones.rs:277:5
    |
 LL |     mut_thing = ToOwned::to_owned(ref_str);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(ref_str, &mut mut_thing)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:255:5
+  --> tests/ui/assigning_clones.rs:283:5
    |
 LL |     s = format!("{} {}", "hello", "world").to_owned();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `format!("{} {}", "hello", "world").clone_into(&mut s)`
 
 error: assigning the result of `ToOwned::to_owned()` may be inefficient
-  --> tests/ui/assigning_clones.rs:260:5
+  --> tests/ui/assigning_clones.rs:289:5
    |
 LL |     s = ToOwned::to_owned(&format!("{} {}", "hello", "world"));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `clone_into()`: `ToOwned::clone_into(&format!("{} {}", "hello", "world"), &mut s)`
diff --git a/src/tools/clippy/tests/ui/async_yields_async.fixed b/src/tools/clippy/tests/ui/async_yields_async.fixed
index 48402164a827..93c573d30863 100644
--- a/src/tools/clippy/tests/ui/async_yields_async.fixed
+++ b/src/tools/clippy/tests/ui/async_yields_async.fixed
@@ -38,9 +38,11 @@ fn main() {
             3
         }.await
     };
+    //~^^^^ async_yields_async
     let _i = async {
         CustomFutureType.await
     };
+    //~^^ async_yields_async
     let _i = async || {
         3
     };
@@ -49,10 +51,13 @@ fn main() {
             3
         }.await
     };
+    //~^^^^ async_yields_async
     let _k = async || {
         CustomFutureType.await
     };
+    //~^^ async_yields_async
     let _l = async || CustomFutureType.await;
+    //~^ async_yields_async
     let _m = async || {
         println!("I'm bored");
         // Some more stuff
@@ -60,6 +65,7 @@ fn main() {
         // Finally something to await
         CustomFutureType.await
     };
+    //~^^ async_yields_async
     let _n = async || custom_future_type_ctor();
     let _o = async || f();
 }
diff --git a/src/tools/clippy/tests/ui/async_yields_async.rs b/src/tools/clippy/tests/ui/async_yields_async.rs
index 8ad016b6bb4e..166d522e1c04 100644
--- a/src/tools/clippy/tests/ui/async_yields_async.rs
+++ b/src/tools/clippy/tests/ui/async_yields_async.rs
@@ -38,9 +38,11 @@ fn main() {
             3
         }
     };
+    //~^^^^ async_yields_async
     let _i = async {
         CustomFutureType
     };
+    //~^^ async_yields_async
     let _i = async || {
         3
     };
@@ -49,10 +51,13 @@ fn main() {
             3
         }
     };
+    //~^^^^ async_yields_async
     let _k = async || {
         CustomFutureType
     };
+    //~^^ async_yields_async
     let _l = async || CustomFutureType;
+    //~^ async_yields_async
     let _m = async || {
         println!("I'm bored");
         // Some more stuff
@@ -60,6 +65,7 @@ fn main() {
         // Finally something to await
         CustomFutureType
     };
+    //~^^ async_yields_async
     let _n = async || custom_future_type_ctor();
     let _o = async || f();
 }
diff --git a/src/tools/clippy/tests/ui/async_yields_async.stderr b/src/tools/clippy/tests/ui/async_yields_async.stderr
index 8c023d0d61f4..17a35076fa3f 100644
--- a/src/tools/clippy/tests/ui/async_yields_async.stderr
+++ b/src/tools/clippy/tests/ui/async_yields_async.stderr
@@ -20,7 +20,7 @@ LL ~         }.await
    |
 
 error: an async construct yields a type which is itself awaitable
-  --> tests/ui/async_yields_async.rs:42:9
+  --> tests/ui/async_yields_async.rs:43:9
    |
 LL |       let _i = async {
    |  ____________________-
@@ -33,7 +33,7 @@ LL | |     };
    | |_____- outer async construct
 
 error: an async construct yields a type which is itself awaitable
-  --> tests/ui/async_yields_async.rs:48:9
+  --> tests/ui/async_yields_async.rs:50:9
    |
 LL |        let _j = async || {
    |  ________________________-
@@ -52,7 +52,7 @@ LL ~         }.await
    |
 
 error: an async construct yields a type which is itself awaitable
-  --> tests/ui/async_yields_async.rs:53:9
+  --> tests/ui/async_yields_async.rs:56:9
    |
 LL |       let _k = async || {
    |  _______________________-
@@ -65,7 +65,7 @@ LL | |     };
    | |_____- outer async construct
 
 error: an async construct yields a type which is itself awaitable
-  --> tests/ui/async_yields_async.rs:55:23
+  --> tests/ui/async_yields_async.rs:59:23
    |
 LL |     let _l = async || CustomFutureType;
    |                       ^^^^^^^^^^^^^^^^
@@ -75,7 +75,7 @@ LL |     let _l = async || CustomFutureType;
    |                       help: consider awaiting this value: `CustomFutureType.await`
 
 error: an async construct yields a type which is itself awaitable
-  --> tests/ui/async_yields_async.rs:61:9
+  --> tests/ui/async_yields_async.rs:66:9
    |
 LL |       let _m = async || {
    |  _______________________-
diff --git a/src/tools/clippy/tests/ui/attrs.rs b/src/tools/clippy/tests/ui/attrs.rs
index da96eabede17..f60c71837d5e 100644
--- a/src/tools/clippy/tests/ui/attrs.rs
+++ b/src/tools/clippy/tests/ui/attrs.rs
@@ -3,8 +3,7 @@
 #![allow(clippy::missing_docs_in_private_items, clippy::panic, clippy::unreachable)]
 
 #[inline(always)]
-//~^ ERROR: you have declared `#[inline(always)]` on `test_attr_lint`. This is usually a b
-//~| NOTE: `-D clippy::inline-always` implied by `-D warnings`
+//~^ inline_always
 fn test_attr_lint() {
     assert!(true)
 }
@@ -25,12 +24,11 @@ fn empty_and_false_positive_stmt() {
 }
 
 #[deprecated(since = "forever")]
-//~^ ERROR: the since field must contain a semver-compliant version
-//~| NOTE: `-D clippy::deprecated-semver` implied by `-D warnings`
+//~^ deprecated_semver
 pub const SOME_CONST: u8 = 42;
 
 #[deprecated(since = "1")]
-//~^ ERROR: the since field must contain a semver-compliant version
+//~^ deprecated_semver
 pub const ANOTHER_CONST: u8 = 23;
 
 #[deprecated(since = "0.1.1")]
diff --git a/src/tools/clippy/tests/ui/attrs.stderr b/src/tools/clippy/tests/ui/attrs.stderr
index a7fdceaba6f3..85b318cc0fdb 100644
--- a/src/tools/clippy/tests/ui/attrs.stderr
+++ b/src/tools/clippy/tests/ui/attrs.stderr
@@ -1,5 +1,5 @@
 error: the since field must contain a semver-compliant version
-  --> tests/ui/attrs.rs:27:14
+  --> tests/ui/attrs.rs:26:14
    |
 LL | #[deprecated(since = "forever")]
    |              ^^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | #[deprecated(since = "forever")]
    = help: to override `-D warnings` add `#[allow(clippy::deprecated_semver)]`
 
 error: the since field must contain a semver-compliant version
-  --> tests/ui/attrs.rs:32:14
+  --> tests/ui/attrs.rs:30:14
    |
 LL | #[deprecated(since = "1")]
    |              ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/author.rs b/src/tools/clippy/tests/ui/author.rs
index 0a1be3568967..faab114852fb 100644
--- a/src/tools/clippy/tests/ui/author.rs
+++ b/src/tools/clippy/tests/ui/author.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn main() {
     #[clippy::author]
     let x: char = 0x45 as char;
diff --git a/src/tools/clippy/tests/ui/author/blocks.rs b/src/tools/clippy/tests/ui/author/blocks.rs
index e9db611a2aa9..73e921e4c75d 100644
--- a/src/tools/clippy/tests/ui/author/blocks.rs
+++ b/src/tools/clippy/tests/ui/author/blocks.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@edition:2018
 
 #![allow(redundant_semicolons, clippy::no_effect)]
diff --git a/src/tools/clippy/tests/ui/author/call.rs b/src/tools/clippy/tests/ui/author/call.rs
index e99c3c41dc4e..8d48eb7bd3e3 100644
--- a/src/tools/clippy/tests/ui/author/call.rs
+++ b/src/tools/clippy/tests/ui/author/call.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn main() {
     #[clippy::author]
     let _ = ::std::cmp::min(3, 4);
diff --git a/src/tools/clippy/tests/ui/author/if.rs b/src/tools/clippy/tests/ui/author/if.rs
index 946088ab3461..59bc9f5bfa5c 100644
--- a/src/tools/clippy/tests/ui/author/if.rs
+++ b/src/tools/clippy/tests/ui/author/if.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #[allow(clippy::all)]
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/author/issue_3849.rs b/src/tools/clippy/tests/ui/author/issue_3849.rs
index 5f65746d71f2..dbd63b21af29 100644
--- a/src/tools/clippy/tests/ui/author/issue_3849.rs
+++ b/src/tools/clippy/tests/ui/author/issue_3849.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code)]
 #![allow(clippy::zero_ptr)]
 #![allow(clippy::transmute_ptr_to_ref)]
diff --git a/src/tools/clippy/tests/ui/author/loop.rs b/src/tools/clippy/tests/ui/author/loop.rs
index ff5b61001179..dcf6fbd72027 100644
--- a/src/tools/clippy/tests/ui/author/loop.rs
+++ b/src/tools/clippy/tests/ui/author/loop.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![feature(stmt_expr_attributes)]
 #![allow(
     clippy::never_loop,
diff --git a/src/tools/clippy/tests/ui/author/macro_in_closure.rs b/src/tools/clippy/tests/ui/author/macro_in_closure.rs
index 444e6a12165d..8a02f38fad87 100644
--- a/src/tools/clippy/tests/ui/author/macro_in_closure.rs
+++ b/src/tools/clippy/tests/ui/author/macro_in_closure.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn main() {
     #[clippy::author]
     let print_text = |x| println!("{}", x);
diff --git a/src/tools/clippy/tests/ui/author/macro_in_loop.rs b/src/tools/clippy/tests/ui/author/macro_in_loop.rs
index 8a520501f8dd..84ffe416e839 100644
--- a/src/tools/clippy/tests/ui/author/macro_in_loop.rs
+++ b/src/tools/clippy/tests/ui/author/macro_in_loop.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![feature(stmt_expr_attributes)]
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/author/matches.rs b/src/tools/clippy/tests/ui/author/matches.rs
index 674e07ec2d3d..e80d9c51023a 100644
--- a/src/tools/clippy/tests/ui/author/matches.rs
+++ b/src/tools/clippy/tests/ui/author/matches.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::let_and_return)]
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/author/repeat.rs b/src/tools/clippy/tests/ui/author/repeat.rs
index d8e9d589e689..872f99844a01 100644
--- a/src/tools/clippy/tests/ui/author/repeat.rs
+++ b/src/tools/clippy/tests/ui/author/repeat.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #[allow(clippy::no_effect)]
 fn main() {
     #[clippy::author]
diff --git a/src/tools/clippy/tests/ui/author/struct.rs b/src/tools/clippy/tests/ui/author/struct.rs
index a99bdfc13137..73db44b73319 100644
--- a/src/tools/clippy/tests/ui/author/struct.rs
+++ b/src/tools/clippy/tests/ui/author/struct.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(
     clippy::unnecessary_operation,
     clippy::single_match,
diff --git a/src/tools/clippy/tests/ui/await_holding_refcell_ref.rs b/src/tools/clippy/tests/ui/await_holding_refcell_ref.rs
index b0c92d8c1f6e..e1db2e387497 100644
--- a/src/tools/clippy/tests/ui/await_holding_refcell_ref.rs
+++ b/src/tools/clippy/tests/ui/await_holding_refcell_ref.rs
@@ -4,13 +4,15 @@ use std::cell::RefCell;
 
 async fn bad(x: &RefCell<u32>) -> u32 {
     let b = x.borrow();
-    //~^ ERROR: this `RefCell` reference is held across an await point
+    //~^ await_holding_refcell_ref
+
     baz().await
 }
 
 async fn bad_mut(x: &RefCell<u32>) -> u32 {
     let b = x.borrow_mut();
-    //~^ ERROR: this `RefCell` reference is held across an await point
+    //~^ await_holding_refcell_ref
+
     baz().await
 }
 
@@ -32,7 +34,7 @@ async fn also_bad(x: &RefCell<u32>) -> u32 {
     let first = baz().await;
 
     let b = x.borrow_mut();
-    //~^ ERROR: this `RefCell` reference is held across an await point
+    //~^ await_holding_refcell_ref
 
     let second = baz().await;
 
@@ -45,7 +47,7 @@ async fn less_bad(x: &RefCell<u32>) -> u32 {
     let first = baz().await;
 
     let b = x.borrow_mut();
-    //~^ ERROR: this `RefCell` reference is held across an await point
+    //~^ await_holding_refcell_ref
 
     let second = baz().await;
 
@@ -61,7 +63,8 @@ async fn not_good(x: &RefCell<u32>) -> u32 {
 
     let second = {
         let b = x.borrow_mut();
-        //~^ ERROR: this `RefCell` reference is held across an await point
+        //~^ await_holding_refcell_ref
+
         baz().await
     };
 
@@ -74,7 +77,8 @@ async fn not_good(x: &RefCell<u32>) -> u32 {
 fn block_bad(x: &RefCell<u32>) -> impl std::future::Future<Output = u32> + '_ {
     async move {
         let b = x.borrow_mut();
-        //~^ ERROR: this `RefCell` reference is held across an await point
+        //~^ await_holding_refcell_ref
+
         baz().await
     }
 }
diff --git a/src/tools/clippy/tests/ui/await_holding_refcell_ref.stderr b/src/tools/clippy/tests/ui/await_holding_refcell_ref.stderr
index 6c7209c9ff9e..ed8aa747bd07 100644
--- a/src/tools/clippy/tests/ui/await_holding_refcell_ref.stderr
+++ b/src/tools/clippy/tests/ui/await_holding_refcell_ref.stderr
@@ -6,7 +6,7 @@ LL |     let b = x.borrow();
    |
    = help: ensure the reference is dropped before calling `await`
 note: these are all the await points this reference is held through
-  --> tests/ui/await_holding_refcell_ref.rs:8:11
+  --> tests/ui/await_holding_refcell_ref.rs:9:11
    |
 LL |     baz().await
    |           ^^^^^
@@ -14,27 +14,27 @@ LL |     baz().await
    = help: to override `-D warnings` add `#[allow(clippy::await_holding_refcell_ref)]`
 
 error: this `RefCell` reference is held across an await point
-  --> tests/ui/await_holding_refcell_ref.rs:12:9
+  --> tests/ui/await_holding_refcell_ref.rs:13:9
    |
 LL |     let b = x.borrow_mut();
    |         ^
    |
    = help: ensure the reference is dropped before calling `await`
 note: these are all the await points this reference is held through
-  --> tests/ui/await_holding_refcell_ref.rs:14:11
+  --> tests/ui/await_holding_refcell_ref.rs:16:11
    |
 LL |     baz().await
    |           ^^^^^
 
 error: this `RefCell` reference is held across an await point
-  --> tests/ui/await_holding_refcell_ref.rs:34:9
+  --> tests/ui/await_holding_refcell_ref.rs:36:9
    |
 LL |     let b = x.borrow_mut();
    |         ^
    |
    = help: ensure the reference is dropped before calling `await`
 note: these are all the await points this reference is held through
-  --> tests/ui/await_holding_refcell_ref.rs:37:24
+  --> tests/ui/await_holding_refcell_ref.rs:39:24
    |
 LL |     let second = baz().await;
    |                        ^^^^^
@@ -43,40 +43,40 @@ LL |     let third = baz().await;
    |                       ^^^^^
 
 error: this `RefCell` reference is held across an await point
-  --> tests/ui/await_holding_refcell_ref.rs:47:9
+  --> tests/ui/await_holding_refcell_ref.rs:49:9
    |
 LL |     let b = x.borrow_mut();
    |         ^
    |
    = help: ensure the reference is dropped before calling `await`
 note: these are all the await points this reference is held through
-  --> tests/ui/await_holding_refcell_ref.rs:50:24
+  --> tests/ui/await_holding_refcell_ref.rs:52:24
    |
 LL |     let second = baz().await;
    |                        ^^^^^
 
 error: this `RefCell` reference is held across an await point
-  --> tests/ui/await_holding_refcell_ref.rs:63:13
+  --> tests/ui/await_holding_refcell_ref.rs:65:13
    |
 LL |         let b = x.borrow_mut();
    |             ^
    |
    = help: ensure the reference is dropped before calling `await`
 note: these are all the await points this reference is held through
-  --> tests/ui/await_holding_refcell_ref.rs:65:15
+  --> tests/ui/await_holding_refcell_ref.rs:68:15
    |
 LL |         baz().await
    |               ^^^^^
 
 error: this `RefCell` reference is held across an await point
-  --> tests/ui/await_holding_refcell_ref.rs:76:13
+  --> tests/ui/await_holding_refcell_ref.rs:79:13
    |
 LL |         let b = x.borrow_mut();
    |             ^
    |
    = help: ensure the reference is dropped before calling `await`
 note: these are all the await points this reference is held through
-  --> tests/ui/await_holding_refcell_ref.rs:78:15
+  --> tests/ui/await_holding_refcell_ref.rs:82:15
    |
 LL |         baz().await
    |               ^^^^^
diff --git a/src/tools/clippy/tests/ui/bind_instead_of_map.fixed b/src/tools/clippy/tests/ui/bind_instead_of_map.fixed
index 910cec2f203d..80e010e2dfd7 100644
--- a/src/tools/clippy/tests/ui/bind_instead_of_map.fixed
+++ b/src/tools/clippy/tests/ui/bind_instead_of_map.fixed
@@ -6,13 +6,16 @@ pub fn main() {
     let x = Some(5);
     // the easiest cases
     let _ = x;
+    //~^ bind_instead_of_map
     let _ = x.map(|o| o + 1);
+    //~^ bind_instead_of_map
     // and an easy counter-example
     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
 
     // Different type
     let x: Result<u32, &str> = Ok(1);
     let _ = x;
+    //~^ bind_instead_of_map
 }
 
 pub fn foo() -> Option<String> {
diff --git a/src/tools/clippy/tests/ui/bind_instead_of_map.rs b/src/tools/clippy/tests/ui/bind_instead_of_map.rs
index 6d66f659ba78..09aa8480cbd9 100644
--- a/src/tools/clippy/tests/ui/bind_instead_of_map.rs
+++ b/src/tools/clippy/tests/ui/bind_instead_of_map.rs
@@ -6,13 +6,16 @@ pub fn main() {
     let x = Some(5);
     // the easiest cases
     let _ = x.and_then(Some);
+    //~^ bind_instead_of_map
     let _ = x.and_then(|o| Some(o + 1));
+    //~^ bind_instead_of_map
     // and an easy counter-example
     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
 
     // Different type
     let x: Result<u32, &str> = Ok(1);
     let _ = x.and_then(Ok);
+    //~^ bind_instead_of_map
 }
 
 pub fn foo() -> Option<String> {
diff --git a/src/tools/clippy/tests/ui/bind_instead_of_map.stderr b/src/tools/clippy/tests/ui/bind_instead_of_map.stderr
index 57e0e4fb8475..08f85fb58549 100644
--- a/src/tools/clippy/tests/ui/bind_instead_of_map.stderr
+++ b/src/tools/clippy/tests/ui/bind_instead_of_map.stderr
@@ -11,13 +11,13 @@ LL | #![deny(clippy::bind_instead_of_map)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
-  --> tests/ui/bind_instead_of_map.rs:9:13
+  --> tests/ui/bind_instead_of_map.rs:10:13
    |
 LL |     let _ = x.and_then(|o| Some(o + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.map(|o| o + 1)`
 
 error: using `Result.and_then(Ok)`, which is a no-op
-  --> tests/ui/bind_instead_of_map.rs:15:13
+  --> tests/ui/bind_instead_of_map.rs:17:13
    |
 LL |     let _ = x.and_then(Ok);
    |             ^^^^^^^^^^^^^^ help: use the expression directly: `x`
diff --git a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.fixed b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.fixed
index 8c77039b3c01..b61ce97fe8e6 100644
--- a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.fixed
+++ b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.fixed
@@ -3,12 +3,15 @@
 
 pub fn main() {
     let _ = Some("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
+    //~^ bind_instead_of_map
     let _ = Some("42").and_then(|s| if s.len() < 42 { None } else { Some(s.len()) });
 
     let _ = Ok::<_, ()>("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
+    //~^ bind_instead_of_map
     let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Err(()) } else { Ok(s.len()) });
 
     let _ = Err::<(), _>("42").map_err(|s| if s.len() < 42 { s.len() + 20 } else { s.len() });
+    //~^ bind_instead_of_map
     let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Ok(()) } else { Err(s.len()) });
 
     hard_example();
@@ -17,6 +20,7 @@ pub fn main() {
 
 fn hard_example() {
     Some("42").map(|s| {
+        //~^ bind_instead_of_map
         if {
             if s == "43" {
                 return 43;
@@ -58,4 +62,5 @@ macro_rules! m {
 fn macro_example() {
     let _ = Some("").and_then(|s| if s.len() == 20 { m!() } else { Some(20) });
     let _ = Some("").map(|s| if s.len() == 20 { m!() } else { Some(20) });
+    //~^ bind_instead_of_map
 }
diff --git a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.rs b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.rs
index 44257f3a4698..37f406def197 100644
--- a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.rs
+++ b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.rs
@@ -3,12 +3,15 @@
 
 pub fn main() {
     let _ = Some("42").and_then(|s| if s.len() < 42 { Some(0) } else { Some(s.len()) });
+    //~^ bind_instead_of_map
     let _ = Some("42").and_then(|s| if s.len() < 42 { None } else { Some(s.len()) });
 
     let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Ok(0) } else { Ok(s.len()) });
+    //~^ bind_instead_of_map
     let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Err(()) } else { Ok(s.len()) });
 
     let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Err(s.len() + 20) } else { Err(s.len()) });
+    //~^ bind_instead_of_map
     let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Ok(()) } else { Err(s.len()) });
 
     hard_example();
@@ -17,6 +20,7 @@ pub fn main() {
 
 fn hard_example() {
     Some("42").and_then(|s| {
+        //~^ bind_instead_of_map
         if {
             if s == "43" {
                 return Some(43);
@@ -58,4 +62,5 @@ macro_rules! m {
 fn macro_example() {
     let _ = Some("").and_then(|s| if s.len() == 20 { m!() } else { Some(20) });
     let _ = Some("").and_then(|s| if s.len() == 20 { Some(m!()) } else { Some(Some(20)) });
+    //~^ bind_instead_of_map
 }
diff --git a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr
index 7c5882d4296e..3ae11422357c 100644
--- a/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr
+++ b/src/tools/clippy/tests/ui/bind_instead_of_map_multipart.stderr
@@ -16,7 +16,7 @@ LL +     let _ = Some("42").map(|s| if s.len() < 42 { 0 } else { s.len() });
    |
 
 error: using `Result.and_then(|x| Ok(y))`, which is more succinctly expressed as `map(|x| y)`
-  --> tests/ui/bind_instead_of_map_multipart.rs:8:13
+  --> tests/ui/bind_instead_of_map_multipart.rs:9:13
    |
 LL |     let _ = Ok::<_, ()>("42").and_then(|s| if s.len() < 42 { Ok(0) } else { Ok(s.len()) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL +     let _ = Ok::<_, ()>("42").map(|s| if s.len() < 42 { 0 } else { s.len()
    |
 
 error: using `Result.or_else(|x| Err(y))`, which is more succinctly expressed as `map_err(|x| y)`
-  --> tests/ui/bind_instead_of_map_multipart.rs:11:13
+  --> tests/ui/bind_instead_of_map_multipart.rs:13:13
    |
 LL |     let _ = Err::<(), _>("42").or_else(|s| if s.len() < 42 { Err(s.len() + 20) } else { Err(s.len()) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,12 +40,12 @@ LL +     let _ = Err::<(), _>("42").map_err(|s| if s.len() < 42 { s.len() + 20 }
    |
 
 error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
-  --> tests/ui/bind_instead_of_map_multipart.rs:19:5
+  --> tests/ui/bind_instead_of_map_multipart.rs:22:5
    |
 LL | /     Some("42").and_then(|s| {
+LL | |
 LL | |         if {
 LL | |             if s == "43" {
-LL | |                 return Some(43);
 ...  |
 LL | |     });
    | |______^
@@ -53,6 +53,7 @@ LL | |     });
 help: use `map` instead
    |
 LL ~     Some("42").map(|s| {
+LL |
 LL |         if {
 LL |             if s == "43" {
 LL ~                 return 43;
@@ -79,7 +80,7 @@ LL ~             _ => 1,
    |
 
 error: using `Option.and_then(|x| Some(y))`, which is more succinctly expressed as `map(|x| y)`
-  --> tests/ui/bind_instead_of_map_multipart.rs:60:13
+  --> tests/ui/bind_instead_of_map_multipart.rs:64:13
    |
 LL |     let _ = Some("").and_then(|s| if s.len() == 20 { Some(m!()) } else { Some(Some(20)) });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/bit_masks.rs b/src/tools/clippy/tests/ui/bit_masks.rs
index 8e1d066c25e4..87dcdb3084d0 100644
--- a/src/tools/clippy/tests/ui/bit_masks.rs
+++ b/src/tools/clippy/tests/ui/bit_masks.rs
@@ -12,27 +12,29 @@ fn main() {
     let x = 5;
 
     x & 0 == 0;
-    //~^ ERROR: &-masking with zero
-    //~| NOTE: `-D clippy::bad-bit-mask` implied by `-D warnings`
-    //~| ERROR: this operation will always return zero. This is likely not the intended ou
-    //~| NOTE: `#[deny(clippy::erasing_op)]` on by default
+    //~^ bad_bit_mask
+    //~| erasing_op
+
     x & 1 == 1; //ok, distinguishes bit 0
     x & 1 == 0; //ok, compared with zero
     x & 2 == 1;
-    //~^ ERROR: incompatible bit mask: `_ & 2` can never be equal to `1`
+    //~^ bad_bit_mask
+
     x | 0 == 0; //ok, equals x == 0 (maybe warn?)
     x | 1 == 3; //ok, equals x == 2 || x == 3
     x | 3 == 3; //ok, equals x <= 3
     x | 3 == 2;
-    //~^ ERROR: incompatible bit mask: `_ | 3` can never be equal to `2`
+    //~^ bad_bit_mask
 
     x & 1 > 1;
-    //~^ ERROR: incompatible bit mask: `_ & 1` will never be higher than `1`
+    //~^ bad_bit_mask
+
     x & 2 > 1; // ok, distinguishes x & 2 == 2 from x & 2 == 0
     x & 2 < 1; // ok, distinguishes x & 2 == 2 from x & 2 == 0
     x | 1 > 1; // ok (if a bit silly), equals x > 1
     x | 2 > 1;
-    //~^ ERROR: incompatible bit mask: `_ | 2` will always be higher than `1`
+    //~^ bad_bit_mask
+
     x | 2 <= 2; // ok (if a bit silly), equals x <= 2
 
     x & 192 == 128; // ok, tests for bit 7 and not bit 6
@@ -40,22 +42,26 @@ fn main() {
 
     // this also now works with constants
     x & THREE_BITS == 8;
-    //~^ ERROR: incompatible bit mask: `_ & 7` can never be equal to `8`
+    //~^ bad_bit_mask
+
     x | EVEN_MORE_REDIRECTION < 7;
-    //~^ ERROR: incompatible bit mask: `_ | 7` will never be lower than `7`
+    //~^ bad_bit_mask
 
     0 & x == 0;
-    //~^ ERROR: &-masking with zero
-    //~| ERROR: this operation will always return zero. This is likely not the intended ou
+    //~^ bad_bit_mask
+    //~| erasing_op
+
     1 | x > 1;
 
     // and should now also match uncommon usage
     1 < 2 | x;
-    //~^ ERROR: incompatible bit mask: `_ | 2` will always be higher than `1`
+    //~^ bad_bit_mask
+
     2 == 3 | x;
-    //~^ ERROR: incompatible bit mask: `_ | 3` can never be equal to `2`
+    //~^ bad_bit_mask
+
     1 == x & 2;
-    //~^ ERROR: incompatible bit mask: `_ & 2` can never be equal to `1`
+    //~^ bad_bit_mask
 
     x | 1 > 2; // no error, because we allowed ineffective bit masks
     ineffective();
@@ -67,14 +73,16 @@ fn ineffective() {
     let x = 5;
 
     x | 1 > 3;
-    //~^ ERROR: ineffective bit mask: `x | 1` compared to `3`, is the same as x compared d
-    //~| NOTE: `-D clippy::ineffective-bit-mask` implied by `-D warnings`
+    //~^ ineffective_bit_mask
+
     x | 1 < 4;
-    //~^ ERROR: ineffective bit mask: `x | 1` compared to `4`, is the same as x compared d
+    //~^ ineffective_bit_mask
+
     x | 1 <= 3;
-    //~^ ERROR: ineffective bit mask: `x | 1` compared to `3`, is the same as x compared d
+    //~^ ineffective_bit_mask
+
     x | 1 >= 8;
-    //~^ ERROR: ineffective bit mask: `x | 1` compared to `8`, is the same as x compared d
+    //~^ ineffective_bit_mask
 
     x | 1 > 2; // not an error (yet), better written as x >= 2
     x | 1 >= 7; // not an error (yet), better written as x >= 6
diff --git a/src/tools/clippy/tests/ui/bit_masks.stderr b/src/tools/clippy/tests/ui/bit_masks.stderr
index 004f6ad94841..666ad671edee 100644
--- a/src/tools/clippy/tests/ui/bit_masks.stderr
+++ b/src/tools/clippy/tests/ui/bit_masks.stderr
@@ -16,7 +16,7 @@ LL |     x & 0 == 0;
    = note: `#[deny(clippy::erasing_op)]` on by default
 
 error: incompatible bit mask: `_ & 2` can never be equal to `1`
-  --> tests/ui/bit_masks.rs:21:5
+  --> tests/ui/bit_masks.rs:20:5
    |
 LL |     x & 2 == 1;
    |     ^^^^^^^^^^
@@ -34,55 +34,55 @@ LL |     x & 1 > 1;
    |     ^^^^^^^^^
 
 error: incompatible bit mask: `_ | 2` will always be higher than `1`
-  --> tests/ui/bit_masks.rs:34:5
+  --> tests/ui/bit_masks.rs:35:5
    |
 LL |     x | 2 > 1;
    |     ^^^^^^^^^
 
 error: incompatible bit mask: `_ & 7` can never be equal to `8`
-  --> tests/ui/bit_masks.rs:42:5
+  --> tests/ui/bit_masks.rs:44:5
    |
 LL |     x & THREE_BITS == 8;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: incompatible bit mask: `_ | 7` will never be lower than `7`
-  --> tests/ui/bit_masks.rs:44:5
+  --> tests/ui/bit_masks.rs:47:5
    |
 LL |     x | EVEN_MORE_REDIRECTION < 7;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: &-masking with zero
-  --> tests/ui/bit_masks.rs:47:5
+  --> tests/ui/bit_masks.rs:50:5
    |
 LL |     0 & x == 0;
    |     ^^^^^^^^^^
 
 error: this operation will always return zero. This is likely not the intended outcome
-  --> tests/ui/bit_masks.rs:47:5
+  --> tests/ui/bit_masks.rs:50:5
    |
 LL |     0 & x == 0;
    |     ^^^^^
 
 error: incompatible bit mask: `_ | 2` will always be higher than `1`
-  --> tests/ui/bit_masks.rs:53:5
+  --> tests/ui/bit_masks.rs:57:5
    |
 LL |     1 < 2 | x;
    |     ^^^^^^^^^
 
 error: incompatible bit mask: `_ | 3` can never be equal to `2`
-  --> tests/ui/bit_masks.rs:55:5
+  --> tests/ui/bit_masks.rs:60:5
    |
 LL |     2 == 3 | x;
    |     ^^^^^^^^^^
 
 error: incompatible bit mask: `_ & 2` can never be equal to `1`
-  --> tests/ui/bit_masks.rs:57:5
+  --> tests/ui/bit_masks.rs:63:5
    |
 LL |     1 == x & 2;
    |     ^^^^^^^^^^
 
 error: ineffective bit mask: `x | 1` compared to `3`, is the same as x compared directly
-  --> tests/ui/bit_masks.rs:69:5
+  --> tests/ui/bit_masks.rs:75:5
    |
 LL |     x | 1 > 3;
    |     ^^^^^^^^^
@@ -91,19 +91,19 @@ LL |     x | 1 > 3;
    = help: to override `-D warnings` add `#[allow(clippy::ineffective_bit_mask)]`
 
 error: ineffective bit mask: `x | 1` compared to `4`, is the same as x compared directly
-  --> tests/ui/bit_masks.rs:72:5
+  --> tests/ui/bit_masks.rs:78:5
    |
 LL |     x | 1 < 4;
    |     ^^^^^^^^^
 
 error: ineffective bit mask: `x | 1` compared to `3`, is the same as x compared directly
-  --> tests/ui/bit_masks.rs:74:5
+  --> tests/ui/bit_masks.rs:81:5
    |
 LL |     x | 1 <= 3;
    |     ^^^^^^^^^^
 
 error: ineffective bit mask: `x | 1` compared to `8`, is the same as x compared directly
-  --> tests/ui/bit_masks.rs:76:5
+  --> tests/ui/bit_masks.rs:84:5
    |
 LL |     x | 1 >= 8;
    |     ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.rs b/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.rs
index 2bfaadf8df94..de699309b16d 100644
--- a/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.rs
+++ b/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.rs
@@ -1,13 +1,14 @@
 //@compile-flags: -W clippy::restriction
+//@error-in-other-file: restriction
 
 #![warn(clippy::blanket_clippy_restriction_lints)]
 
 //! Test that the whole restriction group is not enabled
 #![warn(clippy::restriction)]
-//~^ ERROR: `clippy::restriction` is not meant to be enabled as a group
+//~^ blanket_clippy_restriction_lints
 #![deny(clippy::restriction)]
-//~^ ERROR: `clippy::restriction` is not meant to be enabled as a group
+//~^ blanket_clippy_restriction_lints
 #![forbid(clippy::restriction)]
-//~^ ERROR: `clippy::restriction` is not meant to be enabled as a group
+//~^ blanket_clippy_restriction_lints
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.stderr b/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.stderr
index 1bad259b09a3..ff3a7cfc3931 100644
--- a/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.stderr
+++ b/src/tools/clippy/tests/ui/blanket_clippy_restriction_lints.stderr
@@ -6,7 +6,7 @@ error: `clippy::restriction` is not meant to be enabled as a group
    = help: to override `-D warnings` add `#[allow(clippy::blanket_clippy_restriction_lints)]`
 
 error: `clippy::restriction` is not meant to be enabled as a group
-  --> tests/ui/blanket_clippy_restriction_lints.rs:6:9
+  --> tests/ui/blanket_clippy_restriction_lints.rs:7:9
    |
 LL | #![warn(clippy::restriction)]
    |         ^^^^^^^^^^^^^^^^^^^
@@ -14,7 +14,7 @@ LL | #![warn(clippy::restriction)]
    = help: enable the restriction lints you need individually
 
 error: `clippy::restriction` is not meant to be enabled as a group
-  --> tests/ui/blanket_clippy_restriction_lints.rs:8:9
+  --> tests/ui/blanket_clippy_restriction_lints.rs:9:9
    |
 LL | #![deny(clippy::restriction)]
    |         ^^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL | #![deny(clippy::restriction)]
    = help: enable the restriction lints you need individually
 
 error: `clippy::restriction` is not meant to be enabled as a group
-  --> tests/ui/blanket_clippy_restriction_lints.rs:10:11
+  --> tests/ui/blanket_clippy_restriction_lints.rs:11:11
    |
 LL | #![forbid(clippy::restriction)]
    |           ^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/blocks_in_conditions.fixed b/src/tools/clippy/tests/ui/blocks_in_conditions.fixed
index af8e65270d09..df375e370573 100644
--- a/src/tools/clippy/tests/ui/blocks_in_conditions.fixed
+++ b/src/tools/clippy/tests/ui/blocks_in_conditions.fixed
@@ -46,6 +46,7 @@ fn condition_has_block_with_single_expression() -> i32 {
 fn condition_is_normal() -> i32 {
     let x = 3;
     if x == 3 { 6 } else { 10 }
+    //~^ nonminimal_bool
 }
 
 fn condition_is_unsafe_block() {
diff --git a/src/tools/clippy/tests/ui/blocks_in_conditions.rs b/src/tools/clippy/tests/ui/blocks_in_conditions.rs
index 6adae951a290..1d9c9dd42460 100644
--- a/src/tools/clippy/tests/ui/blocks_in_conditions.rs
+++ b/src/tools/clippy/tests/ui/blocks_in_conditions.rs
@@ -46,6 +46,7 @@ fn condition_has_block_with_single_expression() -> i32 {
 fn condition_is_normal() -> i32 {
     let x = 3;
     if true && x == 3 { 6 } else { 10 }
+    //~^ nonminimal_bool
 }
 
 fn condition_is_unsafe_block() {
diff --git a/src/tools/clippy/tests/ui/blocks_in_conditions.stderr b/src/tools/clippy/tests/ui/blocks_in_conditions.stderr
index a55e1efb575e..da21344a8428 100644
--- a/src/tools/clippy/tests/ui/blocks_in_conditions.stderr
+++ b/src/tools/clippy/tests/ui/blocks_in_conditions.stderr
@@ -35,7 +35,7 @@ LL |     if true && x == 3 { 6 } else { 10 }
    = help: to override `-D warnings` add `#[allow(clippy::nonminimal_bool)]`
 
 error: in a `match` scrutinee, avoid complex blocks or closures with blocks; instead, move the block or closure higher and bind it with a `let`
-  --> tests/ui/blocks_in_conditions.rs:75:5
+  --> tests/ui/blocks_in_conditions.rs:76:5
    |
 LL | /     match {
 LL | |
diff --git a/src/tools/clippy/tests/ui/bool_assert_comparison.fixed b/src/tools/clippy/tests/ui/bool_assert_comparison.fixed
index b05166a055ee..721d8b2c2dcd 100644
--- a/src/tools/clippy/tests/ui/bool_assert_comparison.fixed
+++ b/src/tools/clippy/tests/ui/bool_assert_comparison.fixed
@@ -85,65 +85,90 @@ fn main() {
 
     assert_eq!("a".len(), 1);
     assert!(!"a".is_empty());
+    //~^ bool_assert_comparison
     assert!("".is_empty());
+    //~^ bool_assert_comparison
     assert!("".is_empty());
+    //~^ bool_assert_comparison
     assert_eq!(a!(), b!());
     assert_eq!(a!(), "".is_empty());
     assert_eq!("".is_empty(), b!());
     assert_eq!(a, true);
     assert!(b);
+    //~^ bool_assert_comparison
 
     assert_ne!("a".len(), 1);
     assert!("a".is_empty());
+    //~^ bool_assert_comparison
     assert!(!"".is_empty());
+    //~^ bool_assert_comparison
     assert!(!"".is_empty());
+    //~^ bool_assert_comparison
     assert_ne!(a!(), b!());
     assert_ne!(a!(), "".is_empty());
     assert_ne!("".is_empty(), b!());
     assert_ne!(a, true);
     assert!(!b);
+    //~^ bool_assert_comparison
 
     debug_assert_eq!("a".len(), 1);
     debug_assert!(!"a".is_empty());
+    //~^ bool_assert_comparison
     debug_assert!("".is_empty());
+    //~^ bool_assert_comparison
     debug_assert!("".is_empty());
+    //~^ bool_assert_comparison
     debug_assert_eq!(a!(), b!());
     debug_assert_eq!(a!(), "".is_empty());
     debug_assert_eq!("".is_empty(), b!());
     debug_assert_eq!(a, true);
     debug_assert!(b);
+    //~^ bool_assert_comparison
 
     debug_assert_ne!("a".len(), 1);
     debug_assert!("a".is_empty());
+    //~^ bool_assert_comparison
     debug_assert!(!"".is_empty());
+    //~^ bool_assert_comparison
     debug_assert!(!"".is_empty());
+    //~^ bool_assert_comparison
     debug_assert_ne!(a!(), b!());
     debug_assert_ne!(a!(), "".is_empty());
     debug_assert_ne!("".is_empty(), b!());
     debug_assert_ne!(a, true);
     debug_assert!(!b);
+    //~^ bool_assert_comparison
 
     // assert with error messages
     assert_eq!("a".len(), 1, "tadam {}", 1);
     assert_eq!("a".len(), 1, "tadam {}", true);
     assert!(!"a".is_empty(), "tadam {}", 1);
+    //~^ bool_assert_comparison
     assert!(!"a".is_empty(), "tadam {}", true);
+    //~^ bool_assert_comparison
     assert!(!"a".is_empty(), "tadam {}", true);
+    //~^ bool_assert_comparison
     assert_eq!(a, true, "tadam {}", false);
 
     debug_assert_eq!("a".len(), 1, "tadam {}", 1);
     debug_assert_eq!("a".len(), 1, "tadam {}", true);
     debug_assert!(!"a".is_empty(), "tadam {}", 1);
+    //~^ bool_assert_comparison
     debug_assert!(!"a".is_empty(), "tadam {}", true);
+    //~^ bool_assert_comparison
     debug_assert!(!"a".is_empty(), "tadam {}", true);
+    //~^ bool_assert_comparison
     debug_assert_eq!(a, true, "tadam {}", false);
 
     assert!(a!());
+    //~^ bool_assert_comparison
     assert!(b!());
+    //~^ bool_assert_comparison
 
     use debug_assert_eq as renamed;
     renamed!(a, true);
     debug_assert!(b);
+    //~^ bool_assert_comparison
 
     let non_copy = NonCopy;
     assert_eq!(non_copy, true);
@@ -158,12 +183,20 @@ fn main() {
     in_macro!(a);
 
     assert!("".is_empty());
+    //~^ bool_assert_comparison
     assert!("".is_empty());
+    //~^ bool_assert_comparison
     assert!(!"requires negation".is_empty());
+    //~^ bool_assert_comparison
     assert!(!"requires negation".is_empty());
+    //~^ bool_assert_comparison
 
     debug_assert!("".is_empty());
+    //~^ bool_assert_comparison
     debug_assert!("".is_empty());
+    //~^ bool_assert_comparison
     debug_assert!(!"requires negation".is_empty());
+    //~^ bool_assert_comparison
     debug_assert!(!"requires negation".is_empty());
+    //~^ bool_assert_comparison
 }
diff --git a/src/tools/clippy/tests/ui/bool_assert_comparison.rs b/src/tools/clippy/tests/ui/bool_assert_comparison.rs
index dc51fcf1d36b..5ab4f475b063 100644
--- a/src/tools/clippy/tests/ui/bool_assert_comparison.rs
+++ b/src/tools/clippy/tests/ui/bool_assert_comparison.rs
@@ -85,65 +85,90 @@ fn main() {
 
     assert_eq!("a".len(), 1);
     assert_eq!("a".is_empty(), false);
+    //~^ bool_assert_comparison
     assert_eq!("".is_empty(), true);
+    //~^ bool_assert_comparison
     assert_eq!(true, "".is_empty());
+    //~^ bool_assert_comparison
     assert_eq!(a!(), b!());
     assert_eq!(a!(), "".is_empty());
     assert_eq!("".is_empty(), b!());
     assert_eq!(a, true);
     assert_eq!(b, true);
+    //~^ bool_assert_comparison
 
     assert_ne!("a".len(), 1);
     assert_ne!("a".is_empty(), false);
+    //~^ bool_assert_comparison
     assert_ne!("".is_empty(), true);
+    //~^ bool_assert_comparison
     assert_ne!(true, "".is_empty());
+    //~^ bool_assert_comparison
     assert_ne!(a!(), b!());
     assert_ne!(a!(), "".is_empty());
     assert_ne!("".is_empty(), b!());
     assert_ne!(a, true);
     assert_ne!(b, true);
+    //~^ bool_assert_comparison
 
     debug_assert_eq!("a".len(), 1);
     debug_assert_eq!("a".is_empty(), false);
+    //~^ bool_assert_comparison
     debug_assert_eq!("".is_empty(), true);
+    //~^ bool_assert_comparison
     debug_assert_eq!(true, "".is_empty());
+    //~^ bool_assert_comparison
     debug_assert_eq!(a!(), b!());
     debug_assert_eq!(a!(), "".is_empty());
     debug_assert_eq!("".is_empty(), b!());
     debug_assert_eq!(a, true);
     debug_assert_eq!(b, true);
+    //~^ bool_assert_comparison
 
     debug_assert_ne!("a".len(), 1);
     debug_assert_ne!("a".is_empty(), false);
+    //~^ bool_assert_comparison
     debug_assert_ne!("".is_empty(), true);
+    //~^ bool_assert_comparison
     debug_assert_ne!(true, "".is_empty());
+    //~^ bool_assert_comparison
     debug_assert_ne!(a!(), b!());
     debug_assert_ne!(a!(), "".is_empty());
     debug_assert_ne!("".is_empty(), b!());
     debug_assert_ne!(a, true);
     debug_assert_ne!(b, true);
+    //~^ bool_assert_comparison
 
     // assert with error messages
     assert_eq!("a".len(), 1, "tadam {}", 1);
     assert_eq!("a".len(), 1, "tadam {}", true);
     assert_eq!("a".is_empty(), false, "tadam {}", 1);
+    //~^ bool_assert_comparison
     assert_eq!("a".is_empty(), false, "tadam {}", true);
+    //~^ bool_assert_comparison
     assert_eq!(false, "a".is_empty(), "tadam {}", true);
+    //~^ bool_assert_comparison
     assert_eq!(a, true, "tadam {}", false);
 
     debug_assert_eq!("a".len(), 1, "tadam {}", 1);
     debug_assert_eq!("a".len(), 1, "tadam {}", true);
     debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
+    //~^ bool_assert_comparison
     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
+    //~^ bool_assert_comparison
     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
+    //~^ bool_assert_comparison
     debug_assert_eq!(a, true, "tadam {}", false);
 
     assert_eq!(a!(), true);
+    //~^ bool_assert_comparison
     assert_eq!(true, b!());
+    //~^ bool_assert_comparison
 
     use debug_assert_eq as renamed;
     renamed!(a, true);
     renamed!(b, true);
+    //~^ bool_assert_comparison
 
     let non_copy = NonCopy;
     assert_eq!(non_copy, true);
@@ -158,12 +183,20 @@ fn main() {
     in_macro!(a);
 
     assert_eq!("".is_empty(), true);
+    //~^ bool_assert_comparison
     assert_ne!("".is_empty(), false);
+    //~^ bool_assert_comparison
     assert_ne!("requires negation".is_empty(), true);
+    //~^ bool_assert_comparison
     assert_eq!("requires negation".is_empty(), false);
+    //~^ bool_assert_comparison
 
     debug_assert_eq!("".is_empty(), true);
+    //~^ bool_assert_comparison
     debug_assert_ne!("".is_empty(), false);
+    //~^ bool_assert_comparison
     debug_assert_ne!("requires negation".is_empty(), true);
+    //~^ bool_assert_comparison
     debug_assert_eq!("requires negation".is_empty(), false);
+    //~^ bool_assert_comparison
 }
diff --git a/src/tools/clippy/tests/ui/bool_assert_comparison.stderr b/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
index 41183c61ee01..a1d0af543617 100644
--- a/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
+++ b/src/tools/clippy/tests/ui/bool_assert_comparison.stderr
@@ -13,7 +13,7 @@ LL +     assert!(!"a".is_empty());
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:88:5
+  --> tests/ui/bool_assert_comparison.rs:89:5
    |
 LL |     assert_eq!("".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     assert!("".is_empty());
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:89:5
+  --> tests/ui/bool_assert_comparison.rs:91:5
    |
 LL |     assert_eq!(true, "".is_empty());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     assert!("".is_empty());
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:94:5
+  --> tests/ui/bool_assert_comparison.rs:97:5
    |
 LL |     assert_eq!(b, true);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     assert!(b);
    |
 
 error: used `assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:97:5
+  --> tests/ui/bool_assert_comparison.rs:101:5
    |
 LL |     assert_ne!("a".is_empty(), false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     assert!("a".is_empty());
    |
 
 error: used `assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:98:5
+  --> tests/ui/bool_assert_comparison.rs:103:5
    |
 LL |     assert_ne!("".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     assert!(!"".is_empty());
    |
 
 error: used `assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:99:5
+  --> tests/ui/bool_assert_comparison.rs:105:5
    |
 LL |     assert_ne!(true, "".is_empty());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     assert!(!"".is_empty());
    |
 
 error: used `assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:104:5
+  --> tests/ui/bool_assert_comparison.rs:111:5
    |
 LL |     assert_ne!(b, true);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     assert!(!b);
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:107:5
+  --> tests/ui/bool_assert_comparison.rs:115:5
    |
 LL |     debug_assert_eq!("a".is_empty(), false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     debug_assert!(!"a".is_empty());
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:108:5
+  --> tests/ui/bool_assert_comparison.rs:117:5
    |
 LL |     debug_assert_eq!("".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     debug_assert!("".is_empty());
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:109:5
+  --> tests/ui/bool_assert_comparison.rs:119:5
    |
 LL |     debug_assert_eq!(true, "".is_empty());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     debug_assert!("".is_empty());
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:114:5
+  --> tests/ui/bool_assert_comparison.rs:125:5
    |
 LL |     debug_assert_eq!(b, true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     debug_assert!(b);
    |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:117:5
+  --> tests/ui/bool_assert_comparison.rs:129:5
    |
 LL |     debug_assert_ne!("a".is_empty(), false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     debug_assert!("a".is_empty());
    |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:118:5
+  --> tests/ui/bool_assert_comparison.rs:131:5
    |
 LL |     debug_assert_ne!("".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     debug_assert!(!"".is_empty());
    |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:119:5
+  --> tests/ui/bool_assert_comparison.rs:133:5
    |
 LL |     debug_assert_ne!(true, "".is_empty());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     debug_assert!(!"".is_empty());
    |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:124:5
+  --> tests/ui/bool_assert_comparison.rs:139:5
    |
 LL |     debug_assert_ne!(b, true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     debug_assert!(!b);
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:129:5
+  --> tests/ui/bool_assert_comparison.rs:145:5
    |
 LL |     assert_eq!("a".is_empty(), false, "tadam {}", 1);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL +     assert!(!"a".is_empty(), "tadam {}", 1);
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:130:5
+  --> tests/ui/bool_assert_comparison.rs:147:5
    |
 LL |     assert_eq!("a".is_empty(), false, "tadam {}", true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL +     assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:131:5
+  --> tests/ui/bool_assert_comparison.rs:149:5
    |
 LL |     assert_eq!(false, "a".is_empty(), "tadam {}", true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL +     assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:136:5
+  --> tests/ui/bool_assert_comparison.rs:155:5
    |
 LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", 1);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL +     debug_assert!(!"a".is_empty(), "tadam {}", 1);
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:137:5
+  --> tests/ui/bool_assert_comparison.rs:157:5
    |
 LL |     debug_assert_eq!("a".is_empty(), false, "tadam {}", true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL +     debug_assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:138:5
+  --> tests/ui/bool_assert_comparison.rs:159:5
    |
 LL |     debug_assert_eq!(false, "a".is_empty(), "tadam {}", true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -265,7 +265,7 @@ LL +     debug_assert!(!"a".is_empty(), "tadam {}", true);
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:141:5
+  --> tests/ui/bool_assert_comparison.rs:163:5
    |
 LL |     assert_eq!(a!(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL +     assert!(a!());
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:142:5
+  --> tests/ui/bool_assert_comparison.rs:165:5
    |
 LL |     assert_eq!(true, b!());
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -289,7 +289,7 @@ LL +     assert!(b!());
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:146:5
+  --> tests/ui/bool_assert_comparison.rs:170:5
    |
 LL |     renamed!(b, true);
    |     ^^^^^^^^^^^^^^^^^
@@ -301,7 +301,7 @@ LL +     debug_assert!(b);
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:160:5
+  --> tests/ui/bool_assert_comparison.rs:185:5
    |
 LL |     assert_eq!("".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL +     assert!("".is_empty());
    |
 
 error: used `assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:161:5
+  --> tests/ui/bool_assert_comparison.rs:187:5
    |
 LL |     assert_ne!("".is_empty(), false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL +     assert!("".is_empty());
    |
 
 error: used `assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:162:5
+  --> tests/ui/bool_assert_comparison.rs:189:5
    |
 LL |     assert_ne!("requires negation".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL +     assert!(!"requires negation".is_empty());
    |
 
 error: used `assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:163:5
+  --> tests/ui/bool_assert_comparison.rs:191:5
    |
 LL |     assert_eq!("requires negation".is_empty(), false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -349,7 +349,7 @@ LL +     assert!(!"requires negation".is_empty());
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:165:5
+  --> tests/ui/bool_assert_comparison.rs:194:5
    |
 LL |     debug_assert_eq!("".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -361,7 +361,7 @@ LL +     debug_assert!("".is_empty());
    |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:166:5
+  --> tests/ui/bool_assert_comparison.rs:196:5
    |
 LL |     debug_assert_ne!("".is_empty(), false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -373,7 +373,7 @@ LL +     debug_assert!("".is_empty());
    |
 
 error: used `debug_assert_ne!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:167:5
+  --> tests/ui/bool_assert_comparison.rs:198:5
    |
 LL |     debug_assert_ne!("requires negation".is_empty(), true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -385,7 +385,7 @@ LL +     debug_assert!(!"requires negation".is_empty());
    |
 
 error: used `debug_assert_eq!` with a literal bool
-  --> tests/ui/bool_assert_comparison.rs:168:5
+  --> tests/ui/bool_assert_comparison.rs:200:5
    |
 LL |     debug_assert_eq!("requires negation".is_empty(), false);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/bool_comparison.fixed b/src/tools/clippy/tests/ui/bool_comparison.fixed
index 3db91eec8fa7..166abbe549c3 100644
--- a/src/tools/clippy/tests/ui/bool_comparison.fixed
+++ b/src/tools/clippy/tests/ui/bool_comparison.fixed
@@ -5,72 +5,86 @@
 fn main() {
     let x = true;
     if x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if !x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if !x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if !x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if !x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if !x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if !x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     let y = true;
     if !x & y {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x & !y {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
@@ -119,12 +133,16 @@ fn issue4983() {
     let b = false;
 
     if a != b {};
+    //~^ bool_comparison
     if a != b {};
+    //~^ bool_comparison
     if a == b {};
     if !a == !b {};
 
     if b != a {};
+    //~^ bool_comparison
     if b != a {};
+    //~^ bool_comparison
     if b == a {};
     if !b == !a {};
 }
@@ -149,9 +167,13 @@ fn issue3973() {
 
     // lint, could be simplified
     if !m!(func) {}
+    //~^ bool_comparison
     if !m!(func) {}
+    //~^ bool_comparison
     if m!(func) {}
+    //~^ bool_comparison
     if m!(func) {}
+    //~^ bool_comparison
 
     // no lint with a variable
     let is_debug = false;
@@ -169,8 +191,11 @@ fn issue3973() {
 #[allow(clippy::unnecessary_cast)]
 fn issue9907() {
     let _ = (1 >= 2) as usize;
+    //~^ bool_comparison
     let _ = (!m!(func)) as usize;
+    //~^ bool_comparison
     // This is not part of the issue, but an unexpected found when fixing the issue,
     // the provided span was inside of macro rather than the macro callsite.
     let _ = ((1 < 2) != m!(func)) as usize;
+    //~^ bool_comparison
 }
diff --git a/src/tools/clippy/tests/ui/bool_comparison.rs b/src/tools/clippy/tests/ui/bool_comparison.rs
index fbcfb1cee7bf..7265c2b4c5a6 100644
--- a/src/tools/clippy/tests/ui/bool_comparison.rs
+++ b/src/tools/clippy/tests/ui/bool_comparison.rs
@@ -5,72 +5,86 @@
 fn main() {
     let x = true;
     if x == true {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x == false {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if true == x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if false == x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x != true {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x != false {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if true != x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if false != x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x < true {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if false < x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x > false {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if true > x {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     let y = true;
     if x < y {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
     };
     if x > y {
+        //~^ bool_comparison
         "yes"
     } else {
         "no"
@@ -119,12 +133,16 @@ fn issue4983() {
     let b = false;
 
     if a == !b {};
+    //~^ bool_comparison
     if !a == b {};
+    //~^ bool_comparison
     if a == b {};
     if !a == !b {};
 
     if b == !a {};
+    //~^ bool_comparison
     if !b == a {};
+    //~^ bool_comparison
     if b == a {};
     if !b == !a {};
 }
@@ -149,9 +167,13 @@ fn issue3973() {
 
     // lint, could be simplified
     if false == m!(func) {}
+    //~^ bool_comparison
     if m!(func) == false {}
+    //~^ bool_comparison
     if true == m!(func) {}
+    //~^ bool_comparison
     if m!(func) == true {}
+    //~^ bool_comparison
 
     // no lint with a variable
     let is_debug = false;
@@ -169,8 +191,11 @@ fn issue3973() {
 #[allow(clippy::unnecessary_cast)]
 fn issue9907() {
     let _ = ((1 < 2) == false) as usize;
+    //~^ bool_comparison
     let _ = (false == m!(func)) as usize;
+    //~^ bool_comparison
     // This is not part of the issue, but an unexpected found when fixing the issue,
     // the provided span was inside of macro rather than the macro callsite.
     let _ = ((1 < 2) == !m!(func)) as usize;
+    //~^ bool_comparison
 }
diff --git a/src/tools/clippy/tests/ui/bool_comparison.stderr b/src/tools/clippy/tests/ui/bool_comparison.stderr
index 7c8b906221fa..ddbb9ff78edb 100644
--- a/src/tools/clippy/tests/ui/bool_comparison.stderr
+++ b/src/tools/clippy/tests/ui/bool_comparison.stderr
@@ -8,145 +8,145 @@ LL |     if x == true {
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:12:8
+  --> tests/ui/bool_comparison.rs:13:8
    |
 LL |     if x == false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:17:8
+  --> tests/ui/bool_comparison.rs:19:8
    |
 LL |     if true == x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:22:8
+  --> tests/ui/bool_comparison.rs:25:8
    |
 LL |     if false == x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:27:8
+  --> tests/ui/bool_comparison.rs:31:8
    |
 LL |     if x != true {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:32:8
+  --> tests/ui/bool_comparison.rs:37:8
    |
 LL |     if x != false {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:37:8
+  --> tests/ui/bool_comparison.rs:43:8
    |
 LL |     if true != x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: inequality checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:42:8
+  --> tests/ui/bool_comparison.rs:49:8
    |
 LL |     if false != x {
    |        ^^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:47:8
+  --> tests/ui/bool_comparison.rs:55:8
    |
 LL |     if x < true {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: greater than checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:52:8
+  --> tests/ui/bool_comparison.rs:61:8
    |
 LL |     if false < x {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: greater than checks against false are unnecessary
-  --> tests/ui/bool_comparison.rs:57:8
+  --> tests/ui/bool_comparison.rs:67:8
    |
 LL |     if x > false {
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: less than comparison against true can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:62:8
+  --> tests/ui/bool_comparison.rs:73:8
    |
 LL |     if true > x {
    |        ^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:68:8
+  --> tests/ui/bool_comparison.rs:80:8
    |
 LL |     if x < y {
    |        ^^^^^ help: try simplifying it as shown: `!x & y`
 
 error: order comparisons between booleans can be simplified
-  --> tests/ui/bool_comparison.rs:73:8
+  --> tests/ui/bool_comparison.rs:86:8
    |
 LL |     if x > y {
    |        ^^^^^ help: try simplifying it as shown: `x & !y`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:121:8
+  --> tests/ui/bool_comparison.rs:135:8
    |
 LL |     if a == !b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:122:8
+  --> tests/ui/bool_comparison.rs:137:8
    |
 LL |     if !a == b {};
    |        ^^^^^^^ help: try simplifying it as shown: `a != b`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:126:8
+  --> tests/ui/bool_comparison.rs:142:8
    |
 LL |     if b == !a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:127:8
+  --> tests/ui/bool_comparison.rs:144:8
    |
 LL |     if !b == a {};
    |        ^^^^^^^ help: try simplifying it as shown: `b != a`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:151:8
+  --> tests/ui/bool_comparison.rs:169:8
    |
 LL |     if false == m!(func) {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:152:8
+  --> tests/ui/bool_comparison.rs:171:8
    |
 LL |     if m!(func) == false {}
    |        ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:153:8
+  --> tests/ui/bool_comparison.rs:173:8
    |
 LL |     if true == m!(func) {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/bool_comparison.rs:154:8
+  --> tests/ui/bool_comparison.rs:175:8
    |
 LL |     if m!(func) == true {}
    |        ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `m!(func)`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:171:14
+  --> tests/ui/bool_comparison.rs:193:14
    |
 LL |     let _ = ((1 < 2) == false) as usize;
    |              ^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `1 >= 2`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/bool_comparison.rs:172:14
+  --> tests/ui/bool_comparison.rs:195:14
    |
 LL |     let _ = (false == m!(func)) as usize;
    |              ^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `!m!(func)`
 
 error: this comparison might be written more concisely
-  --> tests/ui/bool_comparison.rs:175:14
+  --> tests/ui/bool_comparison.rs:199:14
    |
 LL |     let _ = ((1 < 2) == !m!(func)) as usize;
    |              ^^^^^^^^^^^^^^^^^^^^ help: try simplifying it as shown: `(1 < 2) != m!(func)`
diff --git a/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed b/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed
index f7dad28b0369..0080801d46b7 100644
--- a/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed
+++ b/src/tools/clippy/tests/ui/bool_to_int_with_if.fixed
@@ -88,6 +88,7 @@ fn main() {
 // Lint returns and type inference
 fn some_fn(a: bool) -> u8 {
     u8::from(a)
+    //~^ bool_to_int_with_if
 }
 
 fn side_effect() {}
diff --git a/src/tools/clippy/tests/ui/bool_to_int_with_if.rs b/src/tools/clippy/tests/ui/bool_to_int_with_if.rs
index d22871d2c8f2..72c7e2c71c56 100644
--- a/src/tools/clippy/tests/ui/bool_to_int_with_if.rs
+++ b/src/tools/clippy/tests/ui/bool_to_int_with_if.rs
@@ -12,31 +12,37 @@ fn main() {
     // Should lint
     // precedence
     if a {
+        //~^ bool_to_int_with_if
         1
     } else {
         0
     };
     if a {
+        //~^ bool_to_int_with_if
         0
     } else {
         1
     };
     if !a {
+        //~^ bool_to_int_with_if
         1
     } else {
         0
     };
     if a || b {
+        //~^ bool_to_int_with_if
         1
     } else {
         0
     };
     if cond(a, b) {
+        //~^ bool_to_int_with_if
         1
     } else {
         0
     };
     if x + y < 4 {
+        //~^ bool_to_int_with_if
         1
     } else {
         0
@@ -46,6 +52,7 @@ fn main() {
     if a {
         123
     } else if b {
+        //~^ bool_to_int_with_if
         1
     } else {
         0
@@ -55,6 +62,7 @@ fn main() {
     if a {
         123
     } else if b {
+        //~^ bool_to_int_with_if
         0
     } else {
         1
@@ -120,6 +128,7 @@ fn main() {
 // Lint returns and type inference
 fn some_fn(a: bool) -> u8 {
     if a { 1 } else { 0 }
+    //~^ bool_to_int_with_if
 }
 
 fn side_effect() {}
diff --git a/src/tools/clippy/tests/ui/bool_to_int_with_if.stderr b/src/tools/clippy/tests/ui/bool_to_int_with_if.stderr
index 1e4a843071a1..415e80f8d73d 100644
--- a/src/tools/clippy/tests/ui/bool_to_int_with_if.stderr
+++ b/src/tools/clippy/tests/ui/bool_to_int_with_if.stderr
@@ -2,6 +2,7 @@ error: boolean to int conversion using if
   --> tests/ui/bool_to_int_with_if.rs:14:5
    |
 LL | /     if a {
+LL | |
 LL | |         1
 LL | |     } else {
 LL | |         0
@@ -13,9 +14,10 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::bool_to_int_with_if)]`
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:19:5
+  --> tests/ui/bool_to_int_with_if.rs:20:5
    |
 LL | /     if a {
+LL | |
 LL | |         0
 LL | |     } else {
 LL | |         1
@@ -25,9 +27,10 @@ LL | |     };
    = note: `!a as i32` or `(!a).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:24:5
+  --> tests/ui/bool_to_int_with_if.rs:26:5
    |
 LL | /     if !a {
+LL | |
 LL | |         1
 LL | |     } else {
 LL | |         0
@@ -37,9 +40,10 @@ LL | |     };
    = note: `!a as i32` or `(!a).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:29:5
+  --> tests/ui/bool_to_int_with_if.rs:32:5
    |
 LL | /     if a || b {
+LL | |
 LL | |         1
 LL | |     } else {
 LL | |         0
@@ -49,9 +53,10 @@ LL | |     };
    = note: `(a || b) as i32` or `(a || b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:34:5
+  --> tests/ui/bool_to_int_with_if.rs:38:5
    |
 LL | /     if cond(a, b) {
+LL | |
 LL | |         1
 LL | |     } else {
 LL | |         0
@@ -61,9 +66,10 @@ LL | |     };
    = note: `cond(a, b) as i32` or `cond(a, b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:39:5
+  --> tests/ui/bool_to_int_with_if.rs:44:5
    |
 LL | /     if x + y < 4 {
+LL | |
 LL | |         1
 LL | |     } else {
 LL | |         0
@@ -73,10 +79,11 @@ LL | |     };
    = note: `(x + y < 4) as i32` or `(x + y < 4).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:48:12
+  --> tests/ui/bool_to_int_with_if.rs:54:12
    |
 LL |       } else if b {
    |  ____________^
+LL | |
 LL | |         1
 LL | |     } else {
 LL | |         0
@@ -86,10 +93,11 @@ LL | |     };
    = note: `b as i32` or `b.into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:57:12
+  --> tests/ui/bool_to_int_with_if.rs:64:12
    |
 LL |       } else if b {
    |  ____________^
+LL | |
 LL | |         0
 LL | |     } else {
 LL | |         1
@@ -99,7 +107,7 @@ LL | |     };
    = note: `!b as i32` or `(!b).into()` can also be valid options
 
 error: boolean to int conversion using if
-  --> tests/ui/bool_to_int_with_if.rs:122:5
+  --> tests/ui/bool_to_int_with_if.rs:130:5
    |
 LL |     if a { 1 } else { 0 }
    |     ^^^^^^^^^^^^^^^^^^^^^ help: replace with from: `u8::from(a)`
diff --git a/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.fixed b/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.fixed
index 2950b158deb6..b7ee4c6165a7 100644
--- a/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.fixed
+++ b/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.fixed
@@ -7,5 +7,7 @@ fn f<T>(_: T) {}
 fn main() {
     let mut val = 0;
     f(&raw const val);
+    //~^ borrow_as_ptr
     f(&raw mut val);
+    //~^ borrow_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.rs b/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.rs
index 19eb8f292337..d16ed5aa7b29 100644
--- a/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.rs
+++ b/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.rs
@@ -7,5 +7,7 @@ fn f<T>(_: T) {}
 fn main() {
     let mut val = 0;
     f(&val as *const _);
+    //~^ borrow_as_ptr
     f(&mut val as *mut i32);
+    //~^ borrow_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.stderr b/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.stderr
index 82a27af303c2..e02f3d8bed97 100644
--- a/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.stderr
+++ b/src/tools/clippy/tests/ui/borrow_and_ref_as_ptr.stderr
@@ -8,7 +8,7 @@ LL |     f(&val as *const _);
    = help: to override `-D warnings` add `#[allow(clippy::borrow_as_ptr)]`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_and_ref_as_ptr.rs:10:7
+  --> tests/ui/borrow_and_ref_as_ptr.rs:11:7
    |
 LL |     f(&mut val as *mut i32);
    |       ^^^^^^^^^^^^^^^^^^^^ help: try: `&raw mut val`
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr.fixed b/src/tools/clippy/tests/ui/borrow_as_ptr.fixed
index 5365f3dd443c..3dca06fce4b8 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr.fixed
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr.fixed
@@ -9,6 +9,7 @@ fn a() -> i32 {
 fn main() {
     let val = 1;
     let _p = std::ptr::addr_of!(val);
+    //~^ borrow_as_ptr
     let _p = &0 as *const i32;
     let _p = &a() as *const i32;
     let vec = vec![1];
@@ -16,12 +17,15 @@ fn main() {
 
     let mut val_mut = 1;
     let _p_mut = std::ptr::addr_of_mut!(val_mut);
+    //~^ borrow_as_ptr
 
     let mut x: [i32; 2] = [42, 43];
     let _raw = std::ptr::addr_of_mut!(x[1]).wrapping_offset(-1);
+    //~^ borrow_as_ptr
 }
 
 fn issue_13882() {
     let mut x: [i32; 2] = [42, 43];
     let _raw = (&raw mut x[1]).wrapping_offset(-1);
+    //~^ borrow_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr.rs b/src/tools/clippy/tests/ui/borrow_as_ptr.rs
index 261894f1341c..3559dc23d018 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr.rs
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr.rs
@@ -9,6 +9,7 @@ fn a() -> i32 {
 fn main() {
     let val = 1;
     let _p = &val as *const i32;
+    //~^ borrow_as_ptr
     let _p = &0 as *const i32;
     let _p = &a() as *const i32;
     let vec = vec![1];
@@ -16,12 +17,15 @@ fn main() {
 
     let mut val_mut = 1;
     let _p_mut = &mut val_mut as *mut i32;
+    //~^ borrow_as_ptr
 
     let mut x: [i32; 2] = [42, 43];
     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
+    //~^ borrow_as_ptr
 }
 
 fn issue_13882() {
     let mut x: [i32; 2] = [42, 43];
     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
+    //~^ borrow_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr.stderr b/src/tools/clippy/tests/ui/borrow_as_ptr.stderr
index 4595fa4f2487..4a9f2ed4aa00 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr.stderr
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr.stderr
@@ -8,19 +8,19 @@ LL |     let _p = &val as *const i32;
    = help: to override `-D warnings` add `#[allow(clippy::borrow_as_ptr)]`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:18:18
+  --> tests/ui/borrow_as_ptr.rs:19:18
    |
 LL |     let _p_mut = &mut val_mut as *mut i32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of_mut!(val_mut)`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:21:16
+  --> tests/ui/borrow_as_ptr.rs:23:16
    |
 LL |     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::addr_of_mut!(x[1])`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr.rs:26:17
+  --> tests/ui/borrow_as_ptr.rs:29:17
    |
 LL |     let _raw = (&mut x[1] as *mut i32).wrapping_offset(-1);
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: try: `&raw mut x[1]`
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.fixed b/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.fixed
index 26c6a5033d16..8972fc0a5e0d 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.fixed
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.fixed
@@ -6,8 +6,10 @@
 pub fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let val = 1;
     let _p = core::ptr::addr_of!(val);
+    //~^ borrow_as_ptr
 
     let mut val_mut = 1;
     let _p_mut = core::ptr::addr_of_mut!(val_mut);
+    //~^ borrow_as_ptr
     0
 }
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.rs b/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.rs
index d8d8b4c380ce..6b4c732dc56e 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.rs
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.rs
@@ -6,8 +6,10 @@
 pub fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let val = 1;
     let _p = &val as *const i32;
+    //~^ borrow_as_ptr
 
     let mut val_mut = 1;
     let _p_mut = &mut val_mut as *mut i32;
+    //~^ borrow_as_ptr
     0
 }
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.stderr b/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.stderr
index 488e0bd96776..6012577559d0 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.stderr
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr_no_std.stderr
@@ -8,7 +8,7 @@ LL |     let _p = &val as *const i32;
    = help: to override `-D warnings` add `#[allow(clippy::borrow_as_ptr)]`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr_no_std.rs:11:18
+  --> tests/ui/borrow_as_ptr_no_std.rs:12:18
    |
 LL |     let _p_mut = &mut val_mut as *mut i32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `core::ptr::addr_of_mut!(val_mut)`
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.fixed b/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.fixed
index d6842e60a3e9..7fbb942b5bc7 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.fixed
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.fixed
@@ -9,6 +9,7 @@ fn a() -> i32 {
 fn main() {
     let val = 1;
     let _p = &raw const val;
+    //~^ borrow_as_ptr
     let _p = &0 as *const i32;
     let _p = &a() as *const i32;
     let vec = vec![1];
@@ -16,4 +17,5 @@ fn main() {
 
     let mut val_mut = 1;
     let _p_mut = &raw mut val_mut;
+    //~^ borrow_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.rs b/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.rs
index 3c9daed18f15..9cbf2e5c266d 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.rs
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.rs
@@ -9,6 +9,7 @@ fn a() -> i32 {
 fn main() {
     let val = 1;
     let _p = &val as *const i32;
+    //~^ borrow_as_ptr
     let _p = &0 as *const i32;
     let _p = &a() as *const i32;
     let vec = vec![1];
@@ -16,4 +17,5 @@ fn main() {
 
     let mut val_mut = 1;
     let _p_mut = &mut val_mut as *mut i32;
+    //~^ borrow_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.stderr b/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.stderr
index 5611fcae8d4b..e5c8aec77986 100644
--- a/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.stderr
+++ b/src/tools/clippy/tests/ui/borrow_as_ptr_raw_ref.stderr
@@ -8,7 +8,7 @@ LL |     let _p = &val as *const i32;
    = help: to override `-D warnings` add `#[allow(clippy::borrow_as_ptr)]`
 
 error: borrow as raw pointer
-  --> tests/ui/borrow_as_ptr_raw_ref.rs:18:18
+  --> tests/ui/borrow_as_ptr_raw_ref.rs:19:18
    |
 LL |     let _p_mut = &mut val_mut as *mut i32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&raw mut val_mut`
diff --git a/src/tools/clippy/tests/ui/borrow_box.fixed b/src/tools/clippy/tests/ui/borrow_box.fixed
index 08ea60583ea4..e6e7f74af7cf 100644
--- a/src/tools/clippy/tests/ui/borrow_box.fixed
+++ b/src/tools/clippy/tests/ui/borrow_box.fixed
@@ -23,17 +23,17 @@ pub fn test1(foo: &mut Box<bool>) {
 
 pub fn test2() {
     let foo: &bool;
-    //~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+    //~^ borrowed_box
 }
 
 struct Test3<'a> {
     foo: &'a bool,
-    //~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+    //~^ borrowed_box
 }
 
 trait Test4 {
     fn test4(a: &bool);
-    //~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+    //~^ borrowed_box
 }
 
 use std::any::Any;
@@ -94,24 +94,28 @@ pub fn test13(boxed_slice: &mut Box<[i32]>) {
 
 // The suggestion should include proper parentheses to avoid a syntax error.
 pub fn test14(_display: &dyn Display) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test15(_display: &(dyn Display + Send)) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test16<'a>(_display: &'a (dyn Display + 'a)) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
 
 pub fn test17(_display: &impl Display) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test18(_display: &(impl Display + Send)) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test19<'a>(_display: &'a (impl Display + 'a)) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
 
 // This exists only to check what happens when parentheses are already present.
 // Even though the current implementation doesn't put extra parentheses,
 // it's fine that unnecessary parentheses appear in the future for some reason.
 pub fn test20(_display: &(dyn Display + Send)) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
 
 #[allow(clippy::borrowed_box)]
 trait Trait {
diff --git a/src/tools/clippy/tests/ui/borrow_box.rs b/src/tools/clippy/tests/ui/borrow_box.rs
index b55de1701daa..43cf809306b3 100644
--- a/src/tools/clippy/tests/ui/borrow_box.rs
+++ b/src/tools/clippy/tests/ui/borrow_box.rs
@@ -23,17 +23,17 @@ pub fn test1(foo: &mut Box<bool>) {
 
 pub fn test2() {
     let foo: &Box<bool>;
-    //~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+    //~^ borrowed_box
 }
 
 struct Test3<'a> {
     foo: &'a Box<bool>,
-    //~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+    //~^ borrowed_box
 }
 
 trait Test4 {
     fn test4(a: &Box<bool>);
-    //~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+    //~^ borrowed_box
 }
 
 use std::any::Any;
@@ -94,24 +94,28 @@ pub fn test13(boxed_slice: &mut Box<[i32]>) {
 
 // The suggestion should include proper parentheses to avoid a syntax error.
 pub fn test14(_display: &Box<dyn Display>) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test15(_display: &Box<dyn Display + Send>) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
 
 pub fn test17(_display: &Box<impl Display>) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test18(_display: &Box<impl Display + Send>) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
+
 pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
 
 // This exists only to check what happens when parentheses are already present.
 // Even though the current implementation doesn't put extra parentheses,
 // it's fine that unnecessary parentheses appear in the future for some reason.
 pub fn test20(_display: &Box<(dyn Display + Send)>) {}
-//~^ ERROR: you seem to be trying to use `&Box<T>`. Consider using just `&T`
+//~^ borrowed_box
 
 #[allow(clippy::borrowed_box)]
 trait Trait {
diff --git a/src/tools/clippy/tests/ui/borrow_box.stderr b/src/tools/clippy/tests/ui/borrow_box.stderr
index 6f80f86c3b3d..dbe3757dd435 100644
--- a/src/tools/clippy/tests/ui/borrow_box.stderr
+++ b/src/tools/clippy/tests/ui/borrow_box.stderr
@@ -29,37 +29,37 @@ LL | pub fn test14(_display: &Box<dyn Display>) {}
    |                         ^^^^^^^^^^^^^^^^^ help: try: `&dyn Display`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> tests/ui/borrow_box.rs:98:25
+  --> tests/ui/borrow_box.rs:99:25
    |
 LL | pub fn test15(_display: &Box<dyn Display + Send>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> tests/ui/borrow_box.rs:100:29
+  --> tests/ui/borrow_box.rs:102:29
    |
 LL | pub fn test16<'a>(_display: &'a Box<dyn Display + 'a>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (dyn Display + 'a)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> tests/ui/borrow_box.rs:103:25
+  --> tests/ui/borrow_box.rs:105:25
    |
 LL | pub fn test17(_display: &Box<impl Display>) {}
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `&impl Display`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> tests/ui/borrow_box.rs:105:25
+  --> tests/ui/borrow_box.rs:108:25
    |
 LL | pub fn test18(_display: &Box<impl Display + Send>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(impl Display + Send)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> tests/ui/borrow_box.rs:107:29
+  --> tests/ui/borrow_box.rs:111:29
    |
 LL | pub fn test19<'a>(_display: &'a Box<impl Display + 'a>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&'a (impl Display + 'a)`
 
 error: you seem to be trying to use `&Box<T>`. Consider using just `&T`
-  --> tests/ui/borrow_box.rs:113:25
+  --> tests/ui/borrow_box.rs:117:25
    |
 LL | pub fn test20(_display: &Box<(dyn Display + Send)>) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&(dyn Display + Send)`
diff --git a/src/tools/clippy/tests/ui/borrow_deref_ref.fixed b/src/tools/clippy/tests/ui/borrow_deref_ref.fixed
index 22e984c46d24..17c224f10bfe 100644
--- a/src/tools/clippy/tests/ui/borrow_deref_ref.fixed
+++ b/src/tools/clippy/tests/ui/borrow_deref_ref.fixed
@@ -11,8 +11,10 @@ mod should_lint {
     fn one_help() {
         let a = &12;
         let b = a;
+        //~^ borrow_deref_ref
 
         let b = &mut bar(&12);
+        //~^ borrow_deref_ref
     }
 
     fn bar(x: &u32) -> &u32 {
@@ -67,6 +69,8 @@ mod false_negative {
         let x = &12;
         let addr_x = &x as *const _ as usize;
         let addr_y = &x as *const _ as usize; // assert ok
+        //
+        //~^^ borrow_deref_ref
         // let addr_y = &x as *const _ as usize; // assert fail
         assert_ne!(addr_x, addr_y);
     }
diff --git a/src/tools/clippy/tests/ui/borrow_deref_ref.rs b/src/tools/clippy/tests/ui/borrow_deref_ref.rs
index 61d89193f42f..130ed2903dc6 100644
--- a/src/tools/clippy/tests/ui/borrow_deref_ref.rs
+++ b/src/tools/clippy/tests/ui/borrow_deref_ref.rs
@@ -11,8 +11,10 @@ mod should_lint {
     fn one_help() {
         let a = &12;
         let b = &*a;
+        //~^ borrow_deref_ref
 
         let b = &mut &*bar(&12);
+        //~^ borrow_deref_ref
     }
 
     fn bar(x: &u32) -> &u32 {
@@ -67,6 +69,8 @@ mod false_negative {
         let x = &12;
         let addr_x = &x as *const _ as usize;
         let addr_y = &&*x as *const _ as usize; // assert ok
+        //
+        //~^^ borrow_deref_ref
         // let addr_y = &x as *const _ as usize; // assert fail
         assert_ne!(addr_x, addr_y);
     }
diff --git a/src/tools/clippy/tests/ui/borrow_deref_ref.stderr b/src/tools/clippy/tests/ui/borrow_deref_ref.stderr
index 7fa43ef49cf7..f5868aa87490 100644
--- a/src/tools/clippy/tests/ui/borrow_deref_ref.stderr
+++ b/src/tools/clippy/tests/ui/borrow_deref_ref.stderr
@@ -8,13 +8,13 @@ LL |         let b = &*a;
    = help: to override `-D warnings` add `#[allow(clippy::borrow_deref_ref)]`
 
 error: deref on an immutable reference
-  --> tests/ui/borrow_deref_ref.rs:15:22
+  --> tests/ui/borrow_deref_ref.rs:16:22
    |
 LL |         let b = &mut &*bar(&12);
    |                      ^^^^^^^^^^ help: if you would like to reborrow, try removing `&*`: `bar(&12)`
 
 error: deref on an immutable reference
-  --> tests/ui/borrow_deref_ref.rs:69:23
+  --> tests/ui/borrow_deref_ref.rs:71:23
    |
 LL |         let addr_y = &&*x as *const _ as usize; // assert ok
    |                       ^^^ help: if you would like to reborrow, try removing `&*`: `x`
diff --git a/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.rs b/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.rs
index be9887339597..f05a90d2c1fa 100644
--- a/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.rs
+++ b/src/tools/clippy/tests/ui/borrow_deref_ref_unfixable.rs
@@ -7,7 +7,6 @@ mod should_lint {
     fn two_helps() {
         let s = &String::new();
         let x: &str = &*s;
-        //~^ ERROR: deref on an immutable reference
-        //~| NOTE: `-D clippy::borrow-deref-ref` implied by `-D warnings`
+        //~^ borrow_deref_ref
     }
 }
diff --git a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.rs b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.rs
index a49d53fbbd38..fa729b62d7f5 100644
--- a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.rs
+++ b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.rs
@@ -62,14 +62,20 @@ mod issue12979 {
 const CELL_REF: StaticRef<(UnsafeCell<u32>,)> = unsafe { StaticRef::new(std::ptr::null()) };
 
 fn main() {
-    ATOMIC.store(1, Ordering::SeqCst); //~ ERROR: interior mutability
-    assert_eq!(ATOMIC.load(Ordering::SeqCst), 5); //~ ERROR: interior mutability
+    ATOMIC.store(1, Ordering::SeqCst);
+    //~^ borrow_interior_mutable_const
+    assert_eq!(ATOMIC.load(Ordering::SeqCst), 5);
+    //~^ borrow_interior_mutable_const
 
     let _once = ONCE_INIT;
-    let _once_ref = &ONCE_INIT; //~ ERROR: interior mutability
-    let _once_ref_2 = &&ONCE_INIT; //~ ERROR: interior mutability
-    let _once_ref_4 = &&&&ONCE_INIT; //~ ERROR: interior mutability
-    let _once_mut = &mut ONCE_INIT; //~ ERROR: interior mutability
+    let _once_ref = &ONCE_INIT;
+    //~^ borrow_interior_mutable_const
+    let _once_ref_2 = &&ONCE_INIT;
+    //~^ borrow_interior_mutable_const
+    let _once_ref_4 = &&&&ONCE_INIT;
+    //~^ borrow_interior_mutable_const
+    let _once_mut = &mut ONCE_INIT;
+    //~^ borrow_interior_mutable_const
     let _atomic_into_inner = ATOMIC.into_inner();
     // these should be all fine.
     let _twice = (ONCE_INIT, ONCE_INIT);
@@ -80,22 +86,30 @@ fn main() {
     let _ref_array_once = &[ONCE_INIT, ONCE_INIT][0];
 
     // referencing projection is still bad.
-    let _ = &ATOMIC_TUPLE; //~ ERROR: interior mutability
-    let _ = &ATOMIC_TUPLE.0; //~ ERROR: interior mutability
-    let _ = &(&&&&ATOMIC_TUPLE).0; //~ ERROR: interior mutability
-    let _ = &ATOMIC_TUPLE.0[0]; //~ ERROR: interior mutability
-    let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst); //~ ERROR: interior mutability
+    let _ = &ATOMIC_TUPLE;
+    //~^ borrow_interior_mutable_const
+    let _ = &ATOMIC_TUPLE.0;
+    //~^ borrow_interior_mutable_const
+    let _ = &(&&&&ATOMIC_TUPLE).0;
+    //~^ borrow_interior_mutable_const
+    let _ = &ATOMIC_TUPLE.0[0];
+    //~^ borrow_interior_mutable_const
+    let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst);
+    //~^ borrow_interior_mutable_const
     let _ = &ATOMIC_TUPLE.2;
     let _ = (&&&&ATOMIC_TUPLE).0;
     let _ = (&&&&ATOMIC_TUPLE).2;
     let _ = ATOMIC_TUPLE.0;
-    let _ = ATOMIC_TUPLE.0[0]; //~ ERROR: interior mutability
+    let _ = ATOMIC_TUPLE.0[0];
+    //~^ borrow_interior_mutable_const
     let _ = ATOMIC_TUPLE.1.into_iter();
     let _ = ATOMIC_TUPLE.2;
     let _ = &{ ATOMIC_TUPLE };
 
-    CELL.set(2); //~ ERROR: interior mutability
-    assert_eq!(CELL.get(), 6); //~ ERROR: interior mutability
+    CELL.set(2);
+    //~^ borrow_interior_mutable_const
+    assert_eq!(CELL.get(), 6);
+    //~^ borrow_interior_mutable_const
 
     assert_eq!(INTEGER, 8);
     assert!(STRING.is_empty());
diff --git a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.stderr b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.stderr
index 4cefcc28008d..decea153f717 100644
--- a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.stderr
+++ b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/others.stderr
@@ -12,7 +12,7 @@ LL | #![deny(clippy::borrow_interior_mutable_const)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:66:16
+  --> tests/ui/borrow_interior_mutable_const/others.rs:67:16
    |
 LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5);
    |                ^^^^^^
@@ -20,7 +20,7 @@ LL |     assert_eq!(ATOMIC.load(Ordering::SeqCst), 5);
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:69:22
+  --> tests/ui/borrow_interior_mutable_const/others.rs:71:22
    |
 LL |     let _once_ref = &ONCE_INIT;
    |                      ^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     let _once_ref = &ONCE_INIT;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:70:25
+  --> tests/ui/borrow_interior_mutable_const/others.rs:73:25
    |
 LL |     let _once_ref_2 = &&ONCE_INIT;
    |                         ^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     let _once_ref_2 = &&ONCE_INIT;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:71:27
+  --> tests/ui/borrow_interior_mutable_const/others.rs:75:27
    |
 LL |     let _once_ref_4 = &&&&ONCE_INIT;
    |                           ^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     let _once_ref_4 = &&&&ONCE_INIT;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:72:26
+  --> tests/ui/borrow_interior_mutable_const/others.rs:77:26
    |
 LL |     let _once_mut = &mut ONCE_INIT;
    |                          ^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     let _once_mut = &mut ONCE_INIT;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:83:14
+  --> tests/ui/borrow_interior_mutable_const/others.rs:89:14
    |
 LL |     let _ = &ATOMIC_TUPLE;
    |              ^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL |     let _ = &ATOMIC_TUPLE;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:84:14
+  --> tests/ui/borrow_interior_mutable_const/others.rs:91:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0;
    |              ^^^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |     let _ = &ATOMIC_TUPLE.0;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:85:19
+  --> tests/ui/borrow_interior_mutable_const/others.rs:93:19
    |
 LL |     let _ = &(&&&&ATOMIC_TUPLE).0;
    |                   ^^^^^^^^^^^^
@@ -76,7 +76,7 @@ LL |     let _ = &(&&&&ATOMIC_TUPLE).0;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:86:14
+  --> tests/ui/borrow_interior_mutable_const/others.rs:95:14
    |
 LL |     let _ = &ATOMIC_TUPLE.0[0];
    |              ^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL |     let _ = &ATOMIC_TUPLE.0[0];
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:87:13
+  --> tests/ui/borrow_interior_mutable_const/others.rs:97:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst);
    |             ^^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0].load(Ordering::SeqCst);
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:92:13
+  --> tests/ui/borrow_interior_mutable_const/others.rs:103:13
    |
 LL |     let _ = ATOMIC_TUPLE.0[0];
    |             ^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     let _ = ATOMIC_TUPLE.0[0];
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:97:5
+  --> tests/ui/borrow_interior_mutable_const/others.rs:109:5
    |
 LL |     CELL.set(2);
    |     ^^^^
@@ -108,7 +108,7 @@ LL |     CELL.set(2);
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/others.rs:98:16
+  --> tests/ui/borrow_interior_mutable_const/others.rs:111:16
    |
 LL |     assert_eq!(CELL.get(), 6);
    |                ^^^^
diff --git a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/projections.rs b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/projections.rs
new file mode 100644
index 000000000000..bbe5538fbe12
--- /dev/null
+++ b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/projections.rs
@@ -0,0 +1,42 @@
+#![deny(clippy::borrow_interior_mutable_const)]
+#![deny(clippy::declare_interior_mutable_const)]
+
+// Inspired by https://github.com/rust-lang/rust/pull/130543#issuecomment-2364828139
+
+use std::cell::UnsafeCell;
+
+trait Trait {
+    type Assoc;
+}
+
+type Assoc<T> = <T as Trait>::Assoc;
+
+impl Trait for u8 {
+    type Assoc = UnsafeCell<u8>;
+}
+
+impl Trait for () {
+    type Assoc = ();
+}
+
+enum MaybeMutable {
+    Mutable(Assoc<u8>),
+    Immutable(Assoc<()>),
+}
+
+const CELL: Assoc<u8> = UnsafeCell::new(0); //~ ERROR: interior mutable
+const UNIT: Assoc<()> = ();
+const MUTABLE: MaybeMutable = MaybeMutable::Mutable(CELL); //~ ERROR: interior mutable
+const IMMUTABLE: MaybeMutable = MaybeMutable::Immutable(UNIT);
+
+fn print_ref<T>(t: &T) {
+    let p: *const T = t;
+    println!("{p:p}")
+}
+
+fn main() {
+    print_ref(&CELL); //~ ERROR: interior mutability
+    print_ref(&UNIT);
+    print_ref(&MUTABLE); //~ ERROR: interior mutability
+    print_ref(&IMMUTABLE);
+}
diff --git a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/projections.stderr b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/projections.stderr
new file mode 100644
index 000000000000..eabaf66560ad
--- /dev/null
+++ b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/projections.stderr
@@ -0,0 +1,44 @@
+error: a `const` item should not be interior mutable
+  --> tests/ui/borrow_interior_mutable_const/projections.rs:27:1
+   |
+LL | const CELL: Assoc<u8> = UnsafeCell::new(0);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider making this `Sync` so that it can go in a static item or using a `thread_local`
+note: the lint level is defined here
+  --> tests/ui/borrow_interior_mutable_const/projections.rs:2:9
+   |
+LL | #![deny(clippy::declare_interior_mutable_const)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item should not be interior mutable
+  --> tests/ui/borrow_interior_mutable_const/projections.rs:29:1
+   |
+LL | const MUTABLE: MaybeMutable = MaybeMutable::Mutable(CELL);
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider making this `Sync` so that it can go in a static item or using a `thread_local`
+
+error: a `const` item with interior mutability should not be borrowed
+  --> tests/ui/borrow_interior_mutable_const/projections.rs:38:16
+   |
+LL |     print_ref(&CELL);
+   |                ^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+note: the lint level is defined here
+  --> tests/ui/borrow_interior_mutable_const/projections.rs:1:9
+   |
+LL | #![deny(clippy::borrow_interior_mutable_const)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: a `const` item with interior mutability should not be borrowed
+  --> tests/ui/borrow_interior_mutable_const/projections.rs:40:16
+   |
+LL |     print_ref(&MUTABLE);
+   |                ^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: aborting due to 4 previous errors
+
diff --git a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.rs b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.rs
index 5570e7cd6d2e..c4878dbe57b2 100644
--- a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.rs
+++ b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.rs
@@ -12,7 +12,8 @@ trait ConcreteTypes {
     const STRING: String;
 
     fn function() {
-        let _ = &Self::ATOMIC; //~ ERROR: interior mutability
+        let _ = &Self::ATOMIC;
+        //~^ borrow_interior_mutable_const
         let _ = &Self::STRING;
     }
 }
@@ -23,7 +24,8 @@ impl ConcreteTypes for u64 {
 
     fn function() {
         // Lint this again since implementers can choose not to borrow it.
-        let _ = &Self::ATOMIC; //~ ERROR: interior mutability
+        let _ = &Self::ATOMIC;
+        //~^ borrow_interior_mutable_const
         let _ = &Self::STRING;
     }
 }
@@ -48,7 +50,8 @@ impl<T: ConstDefault> GenericTypes<T, AtomicUsize> for Vec<T> {
 
     fn function() {
         let _ = &Self::TO_REMAIN_GENERIC;
-        let _ = &Self::TO_BE_CONCRETE; //~ ERROR: interior mutability
+        let _ = &Self::TO_BE_CONCRETE;
+        //~^ borrow_interior_mutable_const
     }
 }
 
@@ -83,8 +86,10 @@ impl<T: ConstDefault> AssocTypes for Vec<T> {
 
     fn function() {
         let _ = &Self::TO_BE_FROZEN;
-        let _ = &Self::TO_BE_UNFROZEN; //~ ERROR: interior mutability
-        let _ = &Self::WRAPPED_TO_BE_UNFROZEN; //~ ERROR: interior mutability
+        let _ = &Self::TO_BE_UNFROZEN;
+        //~^ borrow_interior_mutable_const
+        let _ = &Self::WRAPPED_TO_BE_UNFROZEN;
+        //~^ borrow_interior_mutable_const
         let _ = &Self::WRAPPED_TO_BE_GENERIC_PARAM;
     }
 }
@@ -106,7 +111,8 @@ where
 
     fn function() {
         let _ = &Self::NOT_BOUNDED;
-        let _ = &Self::BOUNDED; //~ ERROR: interior mutability
+        let _ = &Self::BOUNDED;
+        //~^ borrow_interior_mutable_const
     }
 }
 
@@ -119,7 +125,8 @@ where
 
     fn function() {
         let _ = &Self::NOT_BOUNDED;
-        let _ = &Self::BOUNDED; //~ ERROR: interior mutability
+        let _ = &Self::BOUNDED;
+        //~^ borrow_interior_mutable_const
     }
 }
 
@@ -148,8 +155,10 @@ impl SelfType for AtomicUsize {
     const WRAPPED_SELF: Option<Self> = Some(AtomicUsize::new(21));
 
     fn function() {
-        let _ = &Self::SELF; //~ ERROR: interior mutability
-        let _ = &Self::WRAPPED_SELF; //~ ERROR: interior mutability
+        let _ = &Self::SELF;
+        //~^ borrow_interior_mutable_const
+        let _ = &Self::WRAPPED_SELF;
+        //~^ borrow_interior_mutable_const
     }
 }
 
@@ -158,8 +167,10 @@ trait BothOfCellAndGeneric<T> {
     const INDIRECT: Cell<*const T>;
 
     fn function() {
-        let _ = &Self::DIRECT; //~ ERROR: interior mutability
-        let _ = &Self::INDIRECT; //~ ERROR: interior mutability
+        let _ = &Self::DIRECT;
+        //~^ borrow_interior_mutable_const
+        let _ = &Self::INDIRECT;
+        //~^ borrow_interior_mutable_const
     }
 }
 
@@ -168,8 +179,10 @@ impl<T: ConstDefault> BothOfCellAndGeneric<T> for Vec<T> {
     const INDIRECT: Cell<*const T> = Cell::new(std::ptr::null());
 
     fn function() {
-        let _ = &Self::DIRECT; //~ ERROR: interior mutability
-        let _ = &Self::INDIRECT; //~ ERROR: interior mutability
+        let _ = &Self::DIRECT;
+        //~^ borrow_interior_mutable_const
+        let _ = &Self::INDIRECT;
+        //~^ borrow_interior_mutable_const
     }
 }
 
@@ -188,15 +201,19 @@ where
     const BOUNDED_ASSOC_TYPE: T::ToBeBounded = AtomicUsize::new(19);
 
     fn function() {
-        let _ = &Self::ATOMIC; //~ ERROR: interior mutability
+        let _ = &Self::ATOMIC;
+        //~^ borrow_interior_mutable_const
         let _ = &Self::COW;
         let _ = &Self::GENERIC_TYPE;
         let _ = &Self::ASSOC_TYPE;
-        let _ = &Self::BOUNDED_ASSOC_TYPE; //~ ERROR: interior mutability
+        let _ = &Self::BOUNDED_ASSOC_TYPE;
+        //~^ borrow_interior_mutable_const
     }
 }
 
 fn main() {
-    u64::ATOMIC.store(5, Ordering::SeqCst); //~ ERROR: interior mutability
-    assert_eq!(u64::ATOMIC.load(Ordering::SeqCst), 9); //~ ERROR: interior mutability
+    u64::ATOMIC.store(5, Ordering::SeqCst);
+    //~^ borrow_interior_mutable_const
+    assert_eq!(u64::ATOMIC.load(Ordering::SeqCst), 9);
+    //~^ borrow_interior_mutable_const
 }
diff --git a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.stderr b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.stderr
index 8602b46b0dcf..cad68ca9260c 100644
--- a/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.stderr
+++ b/src/tools/clippy/tests/ui/borrow_interior_mutable_const/traits.stderr
@@ -12,7 +12,7 @@ LL | #![deny(clippy::borrow_interior_mutable_const)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:26:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:27:18
    |
 LL |         let _ = &Self::ATOMIC;
    |                  ^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |         let _ = &Self::ATOMIC;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:51:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:53:18
    |
 LL |         let _ = &Self::TO_BE_CONCRETE;
    |                  ^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |         let _ = &Self::TO_BE_CONCRETE;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:86:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:89:18
    |
 LL |         let _ = &Self::TO_BE_UNFROZEN;
    |                  ^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |         let _ = &Self::TO_BE_UNFROZEN;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:87:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:91:18
    |
 LL |         let _ = &Self::WRAPPED_TO_BE_UNFROZEN;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |         let _ = &Self::WRAPPED_TO_BE_UNFROZEN;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:109:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:114:18
    |
 LL |         let _ = &Self::BOUNDED;
    |                  ^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |         let _ = &Self::BOUNDED;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:122:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:128:18
    |
 LL |         let _ = &Self::BOUNDED;
    |                  ^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL |         let _ = &Self::BOUNDED;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:151:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:158:18
    |
 LL |         let _ = &Self::SELF;
    |                  ^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |         let _ = &Self::SELF;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:152:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:160:18
    |
 LL |         let _ = &Self::WRAPPED_SELF;
    |                  ^^^^^^^^^^^^^^^^^^
@@ -76,23 +76,7 @@ LL |         let _ = &Self::WRAPPED_SELF;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:161:18
-   |
-LL |         let _ = &Self::DIRECT;
-   |                  ^^^^^^^^^^^^
-   |
-   = help: assign this const to a local or static variable, and use the variable here
-
-error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:162:18
-   |
-LL |         let _ = &Self::INDIRECT;
-   |                  ^^^^^^^^^^^^^^
-   |
-   = help: assign this const to a local or static variable, and use the variable here
-
-error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:171:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:170:18
    |
 LL |         let _ = &Self::DIRECT;
    |                  ^^^^^^^^^^^^
@@ -108,7 +92,23 @@ LL |         let _ = &Self::INDIRECT;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:191:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:182:18
+   |
+LL |         let _ = &Self::DIRECT;
+   |                  ^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:184:18
+   |
+LL |         let _ = &Self::INDIRECT;
+   |                  ^^^^^^^^^^^^^^
+   |
+   = help: assign this const to a local or static variable, and use the variable here
+
+error: a `const` item with interior mutability should not be borrowed
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:204:18
    |
 LL |         let _ = &Self::ATOMIC;
    |                  ^^^^^^^^^^^^
@@ -116,7 +116,7 @@ LL |         let _ = &Self::ATOMIC;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:195:18
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:209:18
    |
 LL |         let _ = &Self::BOUNDED_ASSOC_TYPE;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -124,7 +124,7 @@ LL |         let _ = &Self::BOUNDED_ASSOC_TYPE;
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:200:5
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:215:5
    |
 LL |     u64::ATOMIC.store(5, Ordering::SeqCst);
    |     ^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     u64::ATOMIC.store(5, Ordering::SeqCst);
    = help: assign this const to a local or static variable, and use the variable here
 
 error: a `const` item with interior mutability should not be borrowed
-  --> tests/ui/borrow_interior_mutable_const/traits.rs:201:16
+  --> tests/ui/borrow_interior_mutable_const/traits.rs:217:16
    |
 LL |     assert_eq!(u64::ATOMIC.load(Ordering::SeqCst), 9);
    |                ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/box_collection.rs b/src/tools/clippy/tests/ui/box_collection.rs
index 499625ea9c31..0f7d3c74ddd0 100644
--- a/src/tools/clippy/tests/ui/box_collection.rs
+++ b/src/tools/clippy/tests/ui/box_collection.rs
@@ -19,7 +19,7 @@ fn test_macro() {
 }
 
 fn test1(foo: Box<Vec<bool>>) {}
-//~^ ERROR: you seem to be trying to use `Box<Vec<..>>`. Consider using just `Vec<..>`
+//~^ box_collection
 
 fn test2(foo: Box<dyn Fn(Vec<u32>)>) {
     // pass if #31 is fixed
@@ -27,28 +27,28 @@ fn test2(foo: Box<dyn Fn(Vec<u32>)>) {
 }
 
 fn test3(foo: Box<String>) {}
-//~^ ERROR: you seem to be trying to use `Box<String>`. Consider using just `String`
+//~^ box_collection
 
 fn test4(foo: Box<HashMap<String, String>>) {}
-//~^ ERROR: you seem to be trying to use `Box<HashMap<..>>`. Consider using just `HashMap<
+//~^ box_collection
 
 fn test5(foo: Box<HashSet<i64>>) {}
-//~^ ERROR: you seem to be trying to use `Box<HashSet<..>>`. Consider using just `HashSet<
+//~^ box_collection
 
 fn test6(foo: Box<VecDeque<i32>>) {}
-//~^ ERROR: you seem to be trying to use `Box<VecDeque<..>>`. Consider using just `VecDequ
+//~^ box_collection
 
 fn test7(foo: Box<LinkedList<i16>>) {}
-//~^ ERROR: you seem to be trying to use `Box<LinkedList<..>>`. Consider using just `Linke
+//~^ box_collection
 
 fn test8(foo: Box<BTreeMap<i8, String>>) {}
-//~^ ERROR: you seem to be trying to use `Box<BTreeMap<..>>`. Consider using just `BTreeMa
+//~^ box_collection
 
 fn test9(foo: Box<BTreeSet<u64>>) {}
-//~^ ERROR: you seem to be trying to use `Box<BTreeSet<..>>`. Consider using just `BTreeSe
+//~^ box_collection
 
 fn test10(foo: Box<BinaryHeap<u32>>) {}
-//~^ ERROR: you seem to be trying to use `Box<BinaryHeap<..>>`. Consider using just `Binar
+//~^ box_collection
 
 fn test_local_not_linted() {
     let _: Box<Vec<bool>>;
diff --git a/src/tools/clippy/tests/ui/box_default.fixed b/src/tools/clippy/tests/ui/box_default.fixed
index 1f2f57c2507d..80000f5de4fd 100644
--- a/src/tools/clippy/tests/ui/box_default.fixed
+++ b/src/tools/clippy/tests/ui/box_default.fixed
@@ -32,14 +32,22 @@ macro_rules! box_new {
 
 fn main() {
     let string1: Box<String> = Box::default();
+    //~^ box_default
     let string2: Box<String> = Box::default();
+    //~^ box_default
     let impl1: Box<ImplementsDefault> = Box::default();
+    //~^ box_default
     let vec: Box<Vec<u8>> = Box::default();
+    //~^ box_default
     let byte: Box<u8> = Box::default();
+    //~^ box_default
     let vec2: Box<Vec<ImplementsDefault>> = Box::default();
+    //~^ box_default
     let vec3: Box<Vec<bool>> = Box::default();
+    //~^ box_default
 
     let plain_default = Box::default();
+    //~^ box_default
     let _: Box<String> = plain_default;
 
     let _: Box<String> = Box::new(default!());
@@ -57,6 +65,7 @@ fn main() {
     let vec4: Box<_> = Box::new(Vec::from([false; 0]));
     let more = ret_ty_fn();
     call_ty_fn(Box::default());
+    //~^ box_default
     issue_10381();
 
     // `Box::<Option<_>>::default()` would be valid here, but not `Box::default()` or
@@ -84,6 +93,7 @@ impl<T: Default> X<T> {
 
     fn same_generic_param() {
         Self::x(Box::default());
+        //~^ box_default
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/box_default.rs b/src/tools/clippy/tests/ui/box_default.rs
index addfebc24f58..4681016d7cd3 100644
--- a/src/tools/clippy/tests/ui/box_default.rs
+++ b/src/tools/clippy/tests/ui/box_default.rs
@@ -32,14 +32,22 @@ macro_rules! box_new {
 
 fn main() {
     let string1: Box<String> = Box::new(Default::default());
+    //~^ box_default
     let string2: Box<String> = Box::new(String::new());
+    //~^ box_default
     let impl1: Box<ImplementsDefault> = Box::new(Default::default());
+    //~^ box_default
     let vec: Box<Vec<u8>> = Box::new(Vec::new());
+    //~^ box_default
     let byte: Box<u8> = Box::new(u8::default());
+    //~^ box_default
     let vec2: Box<Vec<ImplementsDefault>> = Box::new(vec![]);
+    //~^ box_default
     let vec3: Box<Vec<bool>> = Box::new(Vec::from([]));
+    //~^ box_default
 
     let plain_default = Box::new(Default::default());
+    //~^ box_default
     let _: Box<String> = plain_default;
 
     let _: Box<String> = Box::new(default!());
@@ -57,6 +65,7 @@ fn main() {
     let vec4: Box<_> = Box::new(Vec::from([false; 0]));
     let more = ret_ty_fn();
     call_ty_fn(Box::new(u8::default()));
+    //~^ box_default
     issue_10381();
 
     // `Box::<Option<_>>::default()` would be valid here, but not `Box::default()` or
@@ -84,6 +93,7 @@ impl<T: Default> X<T> {
 
     fn same_generic_param() {
         Self::x(Box::new(T::default()));
+        //~^ box_default
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/box_default.stderr b/src/tools/clippy/tests/ui/box_default.stderr
index 39fd0d29bbf9..f63d97665b34 100644
--- a/src/tools/clippy/tests/ui/box_default.stderr
+++ b/src/tools/clippy/tests/ui/box_default.stderr
@@ -8,55 +8,55 @@ LL |     let string1: Box<String> = Box::new(Default::default());
    = help: to override `-D warnings` add `#[allow(clippy::box_default)]`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:35:32
+  --> tests/ui/box_default.rs:36:32
    |
 LL |     let string2: Box<String> = Box::new(String::new());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:36:41
+  --> tests/ui/box_default.rs:38:41
    |
 LL |     let impl1: Box<ImplementsDefault> = Box::new(Default::default());
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:37:29
+  --> tests/ui/box_default.rs:40:29
    |
 LL |     let vec: Box<Vec<u8>> = Box::new(Vec::new());
    |                             ^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:38:25
+  --> tests/ui/box_default.rs:42:25
    |
 LL |     let byte: Box<u8> = Box::new(u8::default());
    |                         ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:39:45
+  --> tests/ui/box_default.rs:44:45
    |
 LL |     let vec2: Box<Vec<ImplementsDefault>> = Box::new(vec![]);
    |                                             ^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:40:32
+  --> tests/ui/box_default.rs:46:32
    |
 LL |     let vec3: Box<Vec<bool>> = Box::new(Vec::from([]));
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:42:25
+  --> tests/ui/box_default.rs:49:25
    |
 LL |     let plain_default = Box::new(Default::default());
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:59:16
+  --> tests/ui/box_default.rs:67:16
    |
 LL |     call_ty_fn(Box::new(u8::default()));
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
 
 error: `Box::new(_)` of default value
-  --> tests/ui/box_default.rs:86:17
+  --> tests/ui/box_default.rs:95:17
    |
 LL |         Self::x(Box::new(T::default()));
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `Box::default()`
diff --git a/src/tools/clippy/tests/ui/box_default_no_std.rs b/src/tools/clippy/tests/ui/box_default_no_std.rs
index edb701fcd084..2881caf0c185 100644
--- a/src/tools/clippy/tests/ui/box_default_no_std.rs
+++ b/src/tools/clippy/tests/ui/box_default_no_std.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::box_default)]
 #![no_std]
 #![crate_type = "lib"]
diff --git a/src/tools/clippy/tests/ui/boxed_local.rs b/src/tools/clippy/tests/ui/boxed_local.rs
index 4f361f5162be..3fb685aa36c1 100644
--- a/src/tools/clippy/tests/ui/boxed_local.rs
+++ b/src/tools/clippy/tests/ui/boxed_local.rs
@@ -38,8 +38,8 @@ fn warn_call() {
 }
 
 fn warn_arg(x: Box<A>) {
-    //~^ ERROR: local variable doesn't need to be boxed here
-    //~| NOTE: `-D clippy::boxed-local` implied by `-D warnings`
+    //~^ boxed_local
+
     x.foo();
 }
 
@@ -121,7 +121,7 @@ pub struct PeekableSeekable<I: Foo> {
 }
 
 pub fn new(_needs_name: Box<PeekableSeekable<&()>>) -> () {}
-//~^ ERROR: local variable doesn't need to be boxed here
+//~^ boxed_local
 
 /// Regression for #916, #1123
 ///
@@ -187,7 +187,8 @@ mod issue4804 {
 
         // warn on `x: Box<u32>`
         fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
-            //~^ ERROR: local variable doesn't need to be boxed here
+            //~^ boxed_local
+
             4
         }
     }
@@ -195,7 +196,7 @@ mod issue4804 {
     trait WarnTrait {
         // warn on `x: Box<u32>`
         fn foo(x: Box<u32>) {}
-        //~^ ERROR: local variable doesn't need to be boxed here
+        //~^ boxed_local
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/boxed_local.stderr b/src/tools/clippy/tests/ui/boxed_local.stderr
index 08fe375afb23..81ebc4fde498 100644
--- a/src/tools/clippy/tests/ui/boxed_local.stderr
+++ b/src/tools/clippy/tests/ui/boxed_local.stderr
@@ -20,7 +20,7 @@ LL |         fn default_impl_x(self: Box<Self>, x: Box<u32>) -> u32 {
    |                                            ^
 
 error: local variable doesn't need to be boxed here
-  --> tests/ui/boxed_local.rs:197:16
+  --> tests/ui/boxed_local.rs:198:16
    |
 LL |         fn foo(x: Box<u32>) {}
    |                ^
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/false_positives.rs b/src/tools/clippy/tests/ui/branches_sharing_code/false_positives.rs
index 5e3a1a29693f..49496e631fb1 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/false_positives.rs
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/false_positives.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code)]
 #![deny(clippy::if_same_then_else, clippy::branches_sharing_code)]
 
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.rs b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.rs
index 549908b8770e..06472a4f5d57 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.rs
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.rs
@@ -33,8 +33,8 @@ fn simple_examples() {
 
         // The rest is self contained and moveable => Only lint the rest
         let result = false;
-        //~^ ERROR: all if blocks contain the same code at the end
-        //~| NOTE: the end suggestion probably needs some adjustments to use the expressio
+        //~^ branches_sharing_code
+
         println!("Block end!");
         result
     };
@@ -53,7 +53,7 @@ fn simple_examples() {
     } else {
         println!("This is also eq with the else block");
         println!("Same end of block");
-        //~^ ERROR: all if blocks contain the same code at the end
+        //~^ branches_sharing_code
     }
 
     // Use of outer scope value
@@ -71,7 +71,7 @@ fn simple_examples() {
         println!("I'm a local because I use the value `z`: `{}`", z);
 
         println!(
-            //~^ ERROR: all if blocks contain the same code at the end
+            //~^ branches_sharing_code
             "I'm moveable because I know: `outer_scope_value`: '{}'",
             outer_scope_value
         );
@@ -84,7 +84,7 @@ fn simple_examples() {
             println!("Hello World");
         } else {
             println!("Hello World");
-            //~^ ERROR: all if blocks contain the same code at the end
+            //~^ branches_sharing_code
         }
     }
 }
@@ -101,7 +101,8 @@ fn simple_but_suggestion_is_invalid() {
         println!("{}", later_used_value);
     } else {
         let later_used_value = "A string value";
-        //~^ ERROR: all if blocks contain the same code at the end
+        //~^ branches_sharing_code
+
         println!("{}", later_used_value);
         // I'm expecting a note about this
     }
@@ -115,7 +116,8 @@ fn simple_but_suggestion_is_invalid() {
         println!("Separator print statement");
 
         let simple_examples = "I now identify as a &str :)";
-        //~^ ERROR: all if blocks contain the same code at the end
+        //~^ branches_sharing_code
+
         println!("This is the new simple_example: {}", simple_examples);
     }
     simple_examples();
@@ -181,8 +183,7 @@ fn added_note_for_expression_use() -> u32 {
     } else {
         let _ = 6;
         x << 2
-        //~^ ERROR: all if blocks contain the same code at the end
-        //~| NOTE: the end suggestion probably needs some adjustments to use the expressio
+        //~^ branches_sharing_code
     };
 
     if x == 9 {
@@ -190,8 +191,7 @@ fn added_note_for_expression_use() -> u32 {
     } else {
         let _ = 17;
         x * 4
-        //~^ ERROR: all if blocks contain the same code at the end
-        //~| NOTE: the end suggestion probably needs some adjustments to use the expressio
+        //~^ branches_sharing_code
     }
 }
 
@@ -204,7 +204,8 @@ fn test_suggestion_with_weird_formatting() {
     // The error message still looks weird tbh but this is the best I can do
     // for weird formatting
     if x == 17 { b = 1; a = 0x99; } else { a = 0x99; }
-    //~^ ERROR: all if blocks contain the same code at the end
+    //~^ branches_sharing_code
+
 }
 
 fn fp_test() {
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.stderr b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.stderr
index 36b177739732..648a99c65ed2 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.stderr
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_bottom.stderr
@@ -20,7 +20,7 @@ help: consider moving these statements after the if
 LL ~     }
 LL +     let result = false;
 LL +
-LL +
+LL + 
 LL +     println!("Block end!");
 LL ~     result;
    |
@@ -79,6 +79,7 @@ error: all if blocks contain the same code at the end
    |
 LL | /         let later_used_value = "A string value";
 LL | |
+LL | |
 LL | |         println!("{}", later_used_value);
 LL | |         // I'm expecting a note about this
 LL | |     }
@@ -90,14 +91,16 @@ help: consider moving these statements after the if
 LL ~     }
 LL +     let later_used_value = "A string value";
 LL +
+LL + 
 LL +     println!("{}", later_used_value);
    |
 
 error: all if blocks contain the same code at the end
-  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:117:5
+  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:118:5
    |
 LL | /         let simple_examples = "I now identify as a &str :)";
 LL | |
+LL | |
 LL | |         println!("This is the new simple_example: {}", simple_examples);
 LL | |     }
    | |_____^
@@ -108,14 +111,15 @@ help: consider moving these statements after the if
 LL ~     }
 LL +     let simple_examples = "I now identify as a &str :)";
 LL +
+LL + 
 LL +     println!("This is the new simple_example: {}", simple_examples);
    |
 
 error: all if blocks contain the same code at the end
-  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:183:5
+  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:185:5
    |
 LL | /         x << 2
-...  |
+LL | |
 LL | |     };
    | |_____^
    |
@@ -127,10 +131,10 @@ LL ~     x << 2;
    |
 
 error: all if blocks contain the same code at the end
-  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:192:5
+  --> tests/ui/branches_sharing_code/shared_at_bottom.rs:193:5
    |
 LL | /         x * 4
-...  |
+LL | |
 LL | |     }
    | |_____^
    |
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.rs b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.rs
index 9af81f6f7cdd..694c67d4c85b 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.rs
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.rs
@@ -9,16 +9,17 @@ fn simple_examples() {
 
     // Simple
     if true {
+        //~^ branches_sharing_code
         println!("Hello World!");
         println!("I'm branch nr: 1");
     } else {
         println!("Hello World!");
         println!("I'm branch nr: 2");
     }
-    //~^^^^^^^ ERROR: all if blocks contain the same code at the start
 
     // Else if
     if x == 0 {
+        //~^ branches_sharing_code
         let y = 9;
         println!("The value y was set to: `{}`", y);
         let _z = y;
@@ -37,11 +38,11 @@ fn simple_examples() {
 
         println!("Ha, Pascal allows you to start the array where you want")
     }
-    //~^^^^^^^^^^^^^^^^^^^ ERROR: all if blocks contain the same code at the start
 
     // Return a value
     let _ = if x == 7 {
-        //~^ ERROR: all if blocks contain the same code at the start
+        //~^ branches_sharing_code
+
         let y = 16;
         println!("What can I say except: \"you're welcome?\"");
         let _ = y;
@@ -60,6 +61,7 @@ fn simple_but_suggestion_is_invalid() {
     // Can't be automatically moved because used_value_name is getting used again
     let used_value_name = 19;
     if x == 10 {
+        //~^ branches_sharing_code
         let used_value_name = "Different type";
         println!("Str: {}", used_value_name);
         let _ = 1;
@@ -68,14 +70,15 @@ fn simple_but_suggestion_is_invalid() {
         println!("Str: {}", used_value_name);
         let _ = 2;
     }
-    //~^^^^^^^^^ ERROR: all if blocks contain the same code at the start
+
     let _ = used_value_name;
 
     // This can be automatically moved as `can_be_overridden` is not used again
     let can_be_overridden = 8;
     let _ = can_be_overridden;
     if x == 11 {
-        //~^ ERROR: all if blocks contain the same code at the start
+        //~^ branches_sharing_code
+
         let can_be_overridden = "Move me";
         println!("I'm also moveable");
         let _ = 111;
@@ -92,7 +95,8 @@ fn check_if_same_than_else_mask() {
 
     #[allow(clippy::if_same_then_else)]
     if x == 2020 {
-        //~^ ERROR: all if blocks contain the same code at the start
+        //~^ branches_sharing_code
+
         println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
         println!("Because `IF_SAME_THEN_ELSE` is allowed here");
     } else {
@@ -105,7 +109,7 @@ fn check_if_same_than_else_mask() {
     } else {
         println!("This should trigger `IS_SAME_THAN_ELSE` as usual");
     }
-    //~^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^ if_same_then_else
 }
 
 #[allow(clippy::vec_init_then_push)]
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.stderr b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.stderr
index 0d4e19be1f52..d28e9c7af296 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.stderr
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top.stderr
@@ -2,6 +2,7 @@ error: all if blocks contain the same code at the start
   --> tests/ui/branches_sharing_code/shared_at_top.rs:11:5
    |
 LL | /     if true {
+LL | |
 LL | |         println!("Hello World!");
    | |_________________________________^
    |
@@ -20,6 +21,7 @@ error: all if blocks contain the same code at the start
   --> tests/ui/branches_sharing_code/shared_at_top.rs:21:5
    |
 LL | /     if x == 0 {
+LL | |
 LL | |         let y = 9;
 LL | |         println!("The value y was set to: `{}`", y);
 LL | |         let _z = y;
@@ -38,7 +40,7 @@ error: all if blocks contain the same code at the start
   --> tests/ui/branches_sharing_code/shared_at_top.rs:43:5
    |
 LL | /     let _ = if x == 7 {
-LL | |
+...  |
 LL | |         let y = 16;
    | |___________________^
    |
@@ -49,9 +51,10 @@ LL +     let _ = if x == 7 {
    |
 
 error: all if blocks contain the same code at the start
-  --> tests/ui/branches_sharing_code/shared_at_top.rs:62:5
+  --> tests/ui/branches_sharing_code/shared_at_top.rs:63:5
    |
 LL | /     if x == 10 {
+LL | |
 LL | |         let used_value_name = "Different type";
 LL | |         println!("Str: {}", used_value_name);
    | |_____________________________________________^
@@ -65,10 +68,11 @@ LL +     if x == 10 {
    |
 
 error: all if blocks contain the same code at the start
-  --> tests/ui/branches_sharing_code/shared_at_top.rs:77:5
+  --> tests/ui/branches_sharing_code/shared_at_top.rs:79:5
    |
 LL | /     if x == 11 {
 LL | |
+LL | |
 LL | |         let can_be_overridden = "Move me";
 LL | |         println!("I'm also moveable");
    | |______________________________________^
@@ -82,10 +86,11 @@ LL +     if x == 11 {
    |
 
 error: all if blocks contain the same code at the start
-  --> tests/ui/branches_sharing_code/shared_at_top.rs:94:5
+  --> tests/ui/branches_sharing_code/shared_at_top.rs:97:5
    |
 LL | /     if x == 2020 {
 LL | |
+LL | |
 LL | |         println!("This should trigger the `SHARED_CODE_IN_IF_BLOCKS` lint.");
 LL | |         println!("Because `IF_SAME_THEN_ELSE` is allowed here");
    | |________________________________________________________________^
@@ -98,7 +103,7 @@ LL +     if x == 2020 {
    |
 
 error: this `if` has identical blocks
-  --> tests/ui/branches_sharing_code/shared_at_top.rs:103:18
+  --> tests/ui/branches_sharing_code/shared_at_top.rs:107:18
    |
 LL |       if x == 2019 {
    |  __________________^
@@ -107,7 +112,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> tests/ui/branches_sharing_code/shared_at_top.rs:105:12
+  --> tests/ui/branches_sharing_code/shared_at_top.rs:109:12
    |
 LL |       } else {
    |  ____________^
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
index 36620ee1a9bf..75334f70f1f6 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs
@@ -15,7 +15,8 @@ fn overlapping_eq_regions() {
 
     // Overlap with separator
     if x == 7 {
-        //~^ ERROR: all if blocks contain the same code at both the start and the end
+        //~^ branches_sharing_code
+
         let t = 7;
         let _overlap_start = t * 2;
         let _overlap_end = 2 * t;
@@ -32,7 +33,8 @@ fn overlapping_eq_regions() {
 
     // Overlap with separator
     if x == 99 {
-        //~^ ERROR: all if blocks contain the same code at both the start and the end
+        //~^ branches_sharing_code
+
         let r = 7;
         let _overlap_start = r;
         let _overlap_middle = r * r;
@@ -62,7 +64,8 @@ fn complexer_example() {
     let x = 8;
     let y = 9;
     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
-        //~^ ERROR: all if blocks contain the same code at both the start and the end
+        //~^ branches_sharing_code
+
         let a = 0xcafe;
         let b = 0xffff00ff;
         let e_id = gen_id(a, b);
@@ -96,7 +99,8 @@ fn added_note_for_expression_use() -> u32 {
     let x = 9;
 
     let _ = if x == 7 {
-        //~^ ERROR: all if blocks contain the same code at both the start and the end
+        //~^ branches_sharing_code
+
         let _ = 19;
 
         let _splitter = 6;
@@ -109,7 +113,8 @@ fn added_note_for_expression_use() -> u32 {
     };
 
     if x == 9 {
-        //~^ ERROR: all if blocks contain the same code at both the start and the end
+        //~^ branches_sharing_code
+
         let _ = 17;
 
         let _splitter = 6;
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
index b79307f96778..2200ab450890 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/shared_at_top_and_bottom.stderr
@@ -3,13 +3,14 @@ error: all if blocks contain the same code at both the start and the end
    |
 LL | /     if x == 7 {
 LL | |
+LL | |
 LL | |         let t = 7;
 LL | |         let _overlap_start = t * 2;
 LL | |         let _overlap_end = 2 * t;
    | |_________________________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:30:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:31:5
    |
 LL | /         let _u = 9;
 LL | |     }
@@ -33,17 +34,18 @@ LL +     let _u = 9;
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:34:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:35:5
    |
 LL | /     if x == 99 {
 LL | |
+LL | |
 LL | |         let r = 7;
 LL | |         let _overlap_start = r;
 LL | |         let _overlap_middle = r * r;
    | |____________________________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:46:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:48:5
    |
 LL | /         let _overlap_end = r * r * r;
 LL | |         let z = "end";
@@ -65,17 +67,18 @@ LL +     let z = "end";
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:64:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:66:5
    |
 LL | /     if (x > 7 && y < 13) || (x + y) % 2 == 1 {
 LL | |
+LL | |
 LL | |         let a = 0xcafe;
 LL | |         let b = 0xffff00ff;
 LL | |         let e_id = gen_id(a, b);
    | |________________________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:85:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:88:5
    |
 LL | /         let pack = DataPack {
 LL | |             id: e_id,
@@ -105,15 +108,15 @@ LL +     process_data(pack);
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:98:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:101:5
    |
 LL | /     let _ = if x == 7 {
-LL | |
+...  |
 LL | |         let _ = 19;
    | |___________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:108:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:112:5
    |
 LL | /         x << 2
 LL | |     };
@@ -131,15 +134,15 @@ LL ~     x << 2;
    |
 
 error: all if blocks contain the same code at both the start and the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:111:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:115:5
    |
 LL | /     if x == 9 {
-LL | |
+...  |
 LL | |         let _ = 17;
    | |___________________^
    |
 note: this code is shared at the end
-  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:121:5
+  --> tests/ui/branches_sharing_code/shared_at_top_and_bottom.rs:126:5
    |
 LL | /         x * 4
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/branches_sharing_code/valid_if_blocks.rs b/src/tools/clippy/tests/ui/branches_sharing_code/valid_if_blocks.rs
index b63819d7c393..d72c5eef87ad 100644
--- a/src/tools/clippy/tests/ui/branches_sharing_code/valid_if_blocks.rs
+++ b/src/tools/clippy/tests/ui/branches_sharing_code/valid_if_blocks.rs
@@ -109,7 +109,7 @@ fn valid_examples() {
     if false {
     } else {
     }
-    //~^^^ ERROR: this `if` has identical blocks
+    //~^^^ if_same_then_else
 }
 
 /// This makes sure that the `if_same_then_else` masks the `shared_code_in_if_blocks` lint
@@ -127,11 +127,11 @@ fn trigger_other_lint() {
         println!("How are u today?");
         let _ = "This is a string";
     }
-    //~^^^^^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^^^^^ if_same_then_else
 
     // Only same expression
     let _ = if x == 6 { 7 } else { 7 };
-    //~^ ERROR: this `if` has identical blocks
+    //~^ if_same_then_else
 
     // Same in else if block
     let _ = if x == 67 {
@@ -146,7 +146,7 @@ fn trigger_other_lint() {
 
         if y == 90 { "=^.^=" } else { ":D" }
     };
-    //~^^^^^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^^^^^ if_same_then_else
 
     if x == 0 {
         println!("I'm single");
@@ -155,7 +155,7 @@ fn trigger_other_lint() {
     } else {
         println!("I'm a doppelgänger");
     }
-    //~^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^ if_same_then_else
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/builtin_type_shadow.rs b/src/tools/clippy/tests/ui/builtin_type_shadow.rs
index c5addd53434c..eda22b7c38ef 100644
--- a/src/tools/clippy/tests/ui/builtin_type_shadow.rs
+++ b/src/tools/clippy/tests/ui/builtin_type_shadow.rs
@@ -2,8 +2,8 @@
 #![allow(non_camel_case_types)]
 
 fn foo<u32>(a: u32) -> u32 {
-    42
-    //~^ ERROR: mismatched types
+    //~^ builtin_type_shadow
+    42 //~ ERROR: mismatched type
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/builtin_type_shadow.stderr b/src/tools/clippy/tests/ui/builtin_type_shadow.stderr
index 033204af9255..a62b41d5c271 100644
--- a/src/tools/clippy/tests/ui/builtin_type_shadow.stderr
+++ b/src/tools/clippy/tests/ui/builtin_type_shadow.stderr
@@ -8,12 +8,13 @@ LL | fn foo<u32>(a: u32) -> u32 {
    = help: to override `-D warnings` add `#[allow(clippy::builtin_type_shadow)]`
 
 error[E0308]: mismatched types
-  --> tests/ui/builtin_type_shadow.rs:5:5
+  --> tests/ui/builtin_type_shadow.rs:6:5
    |
 LL | fn foo<u32>(a: u32) -> u32 {
    |        ---             --- expected `u32` because of return type
    |        |
    |        expected this type parameter
+LL |
 LL |     42
    |     ^^ expected type parameter `u32`, found integer
    |
diff --git a/src/tools/clippy/tests/ui/byte_char_slices.fixed b/src/tools/clippy/tests/ui/byte_char_slices.fixed
index d1db58f9363e..b0c1b1f034b4 100644
--- a/src/tools/clippy/tests/ui/byte_char_slices.fixed
+++ b/src/tools/clippy/tests/ui/byte_char_slices.fixed
@@ -3,11 +3,16 @@
 
 fn main() {
     let bad = b"abc";
+    //~^ byte_char_slices
     let quotes = b"\"Hi";
+    //~^ byte_char_slices
     let quotes = b"'Sup";
+    //~^ byte_char_slices
     let escapes = b"\x42Esc";
+    //~^ byte_char_slices
 
     let good = &[b'a', 0x42];
     let good = [b'a', b'a'];
+    //~^ useless_vec
     let good: u8 = [b'a', b'c'].into_iter().sum();
 }
diff --git a/src/tools/clippy/tests/ui/byte_char_slices.rs b/src/tools/clippy/tests/ui/byte_char_slices.rs
index 18648fffceb4..0d6953dda97e 100644
--- a/src/tools/clippy/tests/ui/byte_char_slices.rs
+++ b/src/tools/clippy/tests/ui/byte_char_slices.rs
@@ -3,11 +3,16 @@
 
 fn main() {
     let bad = &[b'a', b'b', b'c'];
+    //~^ byte_char_slices
     let quotes = &[b'"', b'H', b'i'];
+    //~^ byte_char_slices
     let quotes = &[b'\'', b'S', b'u', b'p'];
+    //~^ byte_char_slices
     let escapes = &[b'\x42', b'E', b's', b'c'];
+    //~^ byte_char_slices
 
     let good = &[b'a', 0x42];
     let good = vec![b'a', b'a'];
+    //~^ useless_vec
     let good: u8 = [b'a', b'c'].into_iter().sum();
 }
diff --git a/src/tools/clippy/tests/ui/byte_char_slices.stderr b/src/tools/clippy/tests/ui/byte_char_slices.stderr
index 4e2b5d8a7329..2556aa9c0f76 100644
--- a/src/tools/clippy/tests/ui/byte_char_slices.stderr
+++ b/src/tools/clippy/tests/ui/byte_char_slices.stderr
@@ -8,25 +8,25 @@ LL |     let bad = &[b'a', b'b', b'c'];
    = help: to override `-D warnings` add `#[allow(clippy::byte_char_slices)]`
 
 error: can be more succinctly written as a byte str
-  --> tests/ui/byte_char_slices.rs:6:18
+  --> tests/ui/byte_char_slices.rs:7:18
    |
 LL |     let quotes = &[b'"', b'H', b'i'];
    |                  ^^^^^^^^^^^^^^^^^^^ help: try: `b"\"Hi"`
 
 error: can be more succinctly written as a byte str
-  --> tests/ui/byte_char_slices.rs:7:18
+  --> tests/ui/byte_char_slices.rs:9:18
    |
 LL |     let quotes = &[b'\'', b'S', b'u', b'p'];
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b"'Sup"`
 
 error: can be more succinctly written as a byte str
-  --> tests/ui/byte_char_slices.rs:8:19
+  --> tests/ui/byte_char_slices.rs:11:19
    |
 LL |     let escapes = &[b'\x42', b'E', b's', b'c'];
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b"\x42Esc"`
 
 error: useless use of `vec!`
-  --> tests/ui/byte_char_slices.rs:11:16
+  --> tests/ui/byte_char_slices.rs:15:16
    |
 LL |     let good = vec![b'a', b'a'];
    |                ^^^^^^^^^^^^^^^^ help: you can use an array directly: `[b'a', b'a']`
diff --git a/src/tools/clippy/tests/ui/bytecount.rs b/src/tools/clippy/tests/ui/bytecount.rs
index f3b02fda8a81..f03f99177d54 100644
--- a/src/tools/clippy/tests/ui/bytecount.rs
+++ b/src/tools/clippy/tests/ui/bytecount.rs
@@ -8,11 +8,11 @@ fn main() {
 
     // naive byte count
     let _ = x.iter().filter(|&&a| a == 0).count();
-    //~^ ERROR: you appear to be counting bytes the naive way
+    //~^ naive_bytecount
 
     // naive byte count
     let _ = (&x[..]).iter().filter(|&a| *a == 0).count();
-    //~^ ERROR: you appear to be counting bytes the naive way
+    //~^ naive_bytecount
 
     // not an equality count, OK.
     let _ = x.iter().filter(|a| **a > 0).count();
@@ -30,7 +30,7 @@ fn main() {
 
     // naive byte count
     let _ = x.iter().filter(|a| b + 1 == **a).count();
-    //~^ ERROR: you appear to be counting bytes the naive way
+    //~^ naive_bytecount
 
     let y = vec![0_u16; 3];
 
diff --git a/src/tools/clippy/tests/ui/bytes_count_to_len.fixed b/src/tools/clippy/tests/ui/bytes_count_to_len.fixed
index d20af22535a0..aa0484a83110 100644
--- a/src/tools/clippy/tests/ui/bytes_count_to_len.fixed
+++ b/src/tools/clippy/tests/ui/bytes_count_to_len.fixed
@@ -1,19 +1,23 @@
 #![warn(clippy::bytes_count_to_len)]
 use std::fs::File;
-use std::io::Read;
+use std::io::{BufReader, Read};
 
 fn main() {
     // should fix, because type is String
     let _ = String::from("foo").len();
+    //~^ bytes_count_to_len
 
     let s1 = String::from("foo");
     let _ = s1.len();
+    //~^ bytes_count_to_len
 
     // should fix, because type is &str
     let _ = "foo".len();
+    //~^ bytes_count_to_len
 
     let s2 = "foo";
     let _ = s2.len();
+    //~^ bytes_count_to_len
 
     // make sure using count() normally doesn't trigger warning
     let vector = [0, 1, 2];
@@ -26,8 +30,8 @@ fn main() {
     bytes.bytes().count();
 
     // The type is File, so should not fix
-    let _ = File::open("foobar").unwrap().bytes().count();
+    let _ = BufReader::new(File::open("foobar").unwrap()).bytes().count();
 
-    let f = File::open("foobar").unwrap();
+    let f = BufReader::new(File::open("foobar").unwrap());
     let _ = f.bytes().count();
 }
diff --git a/src/tools/clippy/tests/ui/bytes_count_to_len.rs b/src/tools/clippy/tests/ui/bytes_count_to_len.rs
index 340e6b412556..7e38858bf783 100644
--- a/src/tools/clippy/tests/ui/bytes_count_to_len.rs
+++ b/src/tools/clippy/tests/ui/bytes_count_to_len.rs
@@ -1,19 +1,23 @@
 #![warn(clippy::bytes_count_to_len)]
 use std::fs::File;
-use std::io::Read;
+use std::io::{BufReader, Read};
 
 fn main() {
     // should fix, because type is String
     let _ = String::from("foo").bytes().count();
+    //~^ bytes_count_to_len
 
     let s1 = String::from("foo");
     let _ = s1.bytes().count();
+    //~^ bytes_count_to_len
 
     // should fix, because type is &str
     let _ = "foo".bytes().count();
+    //~^ bytes_count_to_len
 
     let s2 = "foo";
     let _ = s2.bytes().count();
+    //~^ bytes_count_to_len
 
     // make sure using count() normally doesn't trigger warning
     let vector = [0, 1, 2];
@@ -26,8 +30,8 @@ fn main() {
     bytes.bytes().count();
 
     // The type is File, so should not fix
-    let _ = File::open("foobar").unwrap().bytes().count();
+    let _ = BufReader::new(File::open("foobar").unwrap()).bytes().count();
 
-    let f = File::open("foobar").unwrap();
+    let f = BufReader::new(File::open("foobar").unwrap());
     let _ = f.bytes().count();
 }
diff --git a/src/tools/clippy/tests/ui/bytes_count_to_len.stderr b/src/tools/clippy/tests/ui/bytes_count_to_len.stderr
index b80f3af18f78..999da9ca1365 100644
--- a/src/tools/clippy/tests/ui/bytes_count_to_len.stderr
+++ b/src/tools/clippy/tests/ui/bytes_count_to_len.stderr
@@ -8,19 +8,19 @@ LL |     let _ = String::from("foo").bytes().count();
    = help: to override `-D warnings` add `#[allow(clippy::bytes_count_to_len)]`
 
 error: using long and hard to read `.bytes().count()`
-  --> tests/ui/bytes_count_to_len.rs:10:13
+  --> tests/ui/bytes_count_to_len.rs:11:13
    |
 LL |     let _ = s1.bytes().count();
    |             ^^^^^^^^^^^^^^^^^^ help: consider calling `.len()` instead: `s1.len()`
 
 error: using long and hard to read `.bytes().count()`
-  --> tests/ui/bytes_count_to_len.rs:13:13
+  --> tests/ui/bytes_count_to_len.rs:15:13
    |
 LL |     let _ = "foo".bytes().count();
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.len()` instead: `"foo".len()`
 
 error: using long and hard to read `.bytes().count()`
-  --> tests/ui/bytes_count_to_len.rs:16:13
+  --> tests/ui/bytes_count_to_len.rs:19:13
    |
 LL |     let _ = s2.bytes().count();
    |             ^^^^^^^^^^^^^^^^^^ help: consider calling `.len()` instead: `s2.len()`
diff --git a/src/tools/clippy/tests/ui/bytes_nth.fixed b/src/tools/clippy/tests/ui/bytes_nth.fixed
index da35fcb55e5a..6f4c2e7116e9 100644
--- a/src/tools/clippy/tests/ui/bytes_nth.fixed
+++ b/src/tools/clippy/tests/ui/bytes_nth.fixed
@@ -5,6 +5,9 @@
 fn main() {
     let s = String::from("String");
     let _ = s.as_bytes().get(3).copied();
+    //~^ bytes_nth
     let _ = &s.as_bytes()[3];
+    //~^ bytes_nth
     let _ = s[..].as_bytes().get(3).copied();
+    //~^ bytes_nth
 }
diff --git a/src/tools/clippy/tests/ui/bytes_nth.rs b/src/tools/clippy/tests/ui/bytes_nth.rs
index 5dbe84ecec8b..27655bebb264 100644
--- a/src/tools/clippy/tests/ui/bytes_nth.rs
+++ b/src/tools/clippy/tests/ui/bytes_nth.rs
@@ -5,6 +5,9 @@
 fn main() {
     let s = String::from("String");
     let _ = s.bytes().nth(3);
+    //~^ bytes_nth
     let _ = &s.bytes().nth(3).unwrap();
+    //~^ bytes_nth
     let _ = s[..].bytes().nth(3);
+    //~^ bytes_nth
 }
diff --git a/src/tools/clippy/tests/ui/bytes_nth.stderr b/src/tools/clippy/tests/ui/bytes_nth.stderr
index c5f341cb37f6..c421839ff3f5 100644
--- a/src/tools/clippy/tests/ui/bytes_nth.stderr
+++ b/src/tools/clippy/tests/ui/bytes_nth.stderr
@@ -8,13 +8,13 @@ LL |     let _ = s.bytes().nth(3);
    = help: to override `-D warnings` add `#[allow(clippy::bytes_nth)]`
 
 error: called `.bytes().nth().unwrap()` on a `String`
-  --> tests/ui/bytes_nth.rs:8:14
+  --> tests/ui/bytes_nth.rs:9:14
    |
 LL |     let _ = &s.bytes().nth(3).unwrap();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.as_bytes()[3]`
 
 error: called `.bytes().nth()` on a `str`
-  --> tests/ui/bytes_nth.rs:9:13
+  --> tests/ui/bytes_nth.rs:11:13
    |
 LL |     let _ = s[..].bytes().nth(3);
    |             ^^^^^^^^^^^^^^^^^^^^ help: try: `s[..].as_bytes().get(3).copied()`
diff --git a/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.fixed b/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.fixed
index c4d77f24f126..bf7635fdf09b 100644
--- a/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.fixed
+++ b/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.fixed
@@ -14,6 +14,7 @@ fn is_rust_file(filename: &str) -> bool {
     std::path::Path::new(filename)
         .extension()
         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
+    //~^ case_sensitive_file_extension_comparisons
 }
 
 fn main() {
@@ -21,15 +22,18 @@ fn main() {
     let _ = std::path::Path::new(&String::new())
         .extension()
         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+    //~^ case_sensitive_file_extension_comparisons
     let _ = std::path::Path::new("str")
         .extension()
         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+    //~^ case_sensitive_file_extension_comparisons
 
     // The fixup should preserve the indentation level
     {
         let _ = std::path::Path::new("str")
             .extension()
             .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
+        //~^ case_sensitive_file_extension_comparisons
     }
 
     // The test struct should not trigger the lint failure with .ext12
@@ -39,9 +43,11 @@ fn main() {
     let _ = std::path::Path::new(&String::new())
         .extension()
         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+    //~^ case_sensitive_file_extension_comparisons
     let _ = std::path::Path::new("str")
         .extension()
         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
+    //~^ case_sensitive_file_extension_comparisons
 
     // Should not trigger the lint failure because of the calls to to_lowercase and to_uppercase
     let _ = String::new().to_lowercase().ends_with(".EXT12");
diff --git a/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.rs b/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.rs
index 690e93c2639a..0c4070a42d4b 100644
--- a/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.rs
+++ b/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.rs
@@ -12,16 +12,20 @@ impl TestStruct {
 #[allow(dead_code)]
 fn is_rust_file(filename: &str) -> bool {
     filename.ends_with(".rs")
+    //~^ case_sensitive_file_extension_comparisons
 }
 
 fn main() {
     // std::string::String and &str should trigger the lint failure with .ext12
     let _ = String::new().ends_with(".ext12");
+    //~^ case_sensitive_file_extension_comparisons
     let _ = "str".ends_with(".ext12");
+    //~^ case_sensitive_file_extension_comparisons
 
     // The fixup should preserve the indentation level
     {
         let _ = "str".ends_with(".ext12");
+        //~^ case_sensitive_file_extension_comparisons
     }
 
     // The test struct should not trigger the lint failure with .ext12
@@ -29,7 +33,9 @@ fn main() {
 
     // std::string::String and &str should trigger the lint failure with .EXT12
     let _ = String::new().ends_with(".EXT12");
+    //~^ case_sensitive_file_extension_comparisons
     let _ = "str".ends_with(".EXT12");
+    //~^ case_sensitive_file_extension_comparisons
 
     // Should not trigger the lint failure because of the calls to to_lowercase and to_uppercase
     let _ = String::new().to_lowercase().ends_with(".EXT12");
diff --git a/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.stderr b/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.stderr
index e21815f251b7..e035534d2699 100644
--- a/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.stderr
+++ b/src/tools/clippy/tests/ui/case_sensitive_file_extension_comparisons.stderr
@@ -15,7 +15,7 @@ LL +         .map_or(false, |ext| ext.eq_ignore_ascii_case("rs"))
    |
 
 error: case-sensitive file extension comparison
-  --> tests/ui/case_sensitive_file_extension_comparisons.rs:19:13
+  --> tests/ui/case_sensitive_file_extension_comparisons.rs:20:13
    |
 LL |     let _ = String::new().ends_with(".ext12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
    |
 
 error: case-sensitive file extension comparison
-  --> tests/ui/case_sensitive_file_extension_comparisons.rs:20:13
+  --> tests/ui/case_sensitive_file_extension_comparisons.rs:22:13
    |
 LL |     let _ = "str".ends_with(".ext12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -43,7 +43,7 @@ LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
    |
 
 error: case-sensitive file extension comparison
-  --> tests/ui/case_sensitive_file_extension_comparisons.rs:24:17
+  --> tests/ui/case_sensitive_file_extension_comparisons.rs:27:17
    |
 LL |         let _ = "str".ends_with(".ext12");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL ~             .map_or(false, |ext| ext.eq_ignore_ascii_case("ext12"));
    |
 
 error: case-sensitive file extension comparison
-  --> tests/ui/case_sensitive_file_extension_comparisons.rs:31:13
+  --> tests/ui/case_sensitive_file_extension_comparisons.rs:35:13
    |
 LL |     let _ = String::new().ends_with(".EXT12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL ~         .map_or(false, |ext| ext.eq_ignore_ascii_case("EXT12"));
    |
 
 error: case-sensitive file extension comparison
-  --> tests/ui/case_sensitive_file_extension_comparisons.rs:32:13
+  --> tests/ui/case_sensitive_file_extension_comparisons.rs:37:13
    |
 LL |     let _ = "str".ends_with(".EXT12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast.rs b/src/tools/clippy/tests/ui/cast.rs
index 0de53a75c623..88c2549f4dc5 100644
--- a/src/tools/clippy/tests/ui/cast.rs
+++ b/src/tools/clippy/tests/ui/cast.rs
@@ -23,101 +23,127 @@ fn main() {
     // Test clippy::cast_precision_loss
     let x0 = 1i32;
     x0 as f32;
-    //~^ ERROR: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide,
-    //~| NOTE: `-D clippy::cast-precision-loss` implied by `-D warnings`
+    //~^ cast_precision_loss
+
     let x1 = 1i64;
     x1 as f32;
-    //~^ ERROR: casting `i64` to `f32` causes a loss of precision (`i64` is 64 bits wide,
+    //~^ cast_precision_loss
+
     x1 as f64;
-    //~^ ERROR: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide,
+    //~^ cast_precision_loss
+
     let x2 = 1u32;
     x2 as f32;
-    //~^ ERROR: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide,
+    //~^ cast_precision_loss
+
     let x3 = 1u64;
     x3 as f32;
-    //~^ ERROR: casting `u64` to `f32` causes a loss of precision (`u64` is 64 bits wide,
+    //~^ cast_precision_loss
+
     x3 as f64;
-    //~^ ERROR: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide,
+    //~^ cast_precision_loss
+
     // Test clippy::cast_possible_truncation
     1f32 as i32;
-    //~^ ERROR: casting `f32` to `i32` may truncate the value
+    //~^ cast_possible_truncation
+
     1f32 as u32;
-    //~^ ERROR: casting `f32` to `u32` may truncate the value
-    //~| ERROR: casting `f32` to `u32` may lose the sign of the value
-    //~| NOTE: `-D clippy::cast-sign-loss` implied by `-D warnings`
+    //~^ cast_possible_truncation
+    //~| cast_sign_loss
+
     1f64 as f32;
-    //~^ ERROR: casting `f64` to `f32` may truncate the value
+    //~^ cast_possible_truncation
+
     1i32 as i8;
-    //~^ ERROR: casting `i32` to `i8` may truncate the value
+    //~^ cast_possible_truncation
+
     1i32 as u8;
-    //~^ ERROR: casting `i32` to `u8` may truncate the value
+    //~^ cast_possible_truncation
+
     1f64 as isize;
-    //~^ ERROR: casting `f64` to `isize` may truncate the value
+    //~^ cast_possible_truncation
+
     1f64 as usize;
-    //~^ ERROR: casting `f64` to `usize` may truncate the value
-    //~| ERROR: casting `f64` to `usize` may lose the sign of the value
+    //~^ cast_possible_truncation
+    //~| cast_sign_loss
+
     1f32 as u32 as u16;
-    //~^ ERROR: casting `u32` to `u16` may truncate the value
-    //~| ERROR: casting `f32` to `u32` may truncate the value
-    //~| ERROR: casting `f32` to `u32` may lose the sign of the value
+    //~^ cast_possible_truncation
+    //~| cast_possible_truncation
+    //~| cast_sign_loss
+
     {
         let _x: i8 = 1i32 as _;
-        //~^ ERROR: casting `i32` to `i8` may truncate the value
+        //~^ cast_possible_truncation
+
         1f32 as i32;
-        //~^ ERROR: casting `f32` to `i32` may truncate the value
+        //~^ cast_possible_truncation
+
         1f64 as i32;
-        //~^ ERROR: casting `f64` to `i32` may truncate the value
+        //~^ cast_possible_truncation
+
         1f32 as u8;
-        //~^ ERROR: casting `f32` to `u8` may truncate the value
-        //~| ERROR: casting `f32` to `u8` may lose the sign of the value
+        //~^ cast_possible_truncation
+        //~| cast_sign_loss
     }
     // Test clippy::cast_possible_wrap
     1u8 as i8;
-    //~^ ERROR: casting `u8` to `i8` may wrap around the value
-    //~| NOTE: `-D clippy::cast-possible-wrap` implied by `-D warnings`
+    //~^ cast_possible_wrap
+
     1u16 as i16;
-    //~^ ERROR: casting `u16` to `i16` may wrap around the value
+    //~^ cast_possible_wrap
+
     1u32 as i32;
-    //~^ ERROR: casting `u32` to `i32` may wrap around the value
+    //~^ cast_possible_wrap
+
     1u64 as i64;
-    //~^ ERROR: casting `u64` to `i64` may wrap around the value
+    //~^ cast_possible_wrap
+
     1usize as isize;
-    //~^ ERROR: casting `usize` to `isize` may wrap around the value
+    //~^ cast_possible_wrap
+
     // should not wrap, usize is never 8 bits
     1usize as i8;
-    //~^ ERROR: casting `usize` to `i8` may truncate the value
+    //~^ cast_possible_truncation
+
     // wraps on 16 bit ptr size
     1usize as i16;
-    //~^ ERROR: casting `usize` to `i16` may truncate the value
-    //~| ERROR: casting `usize` to `i16` may wrap around the value on targets with 16-bit
-    //~| NOTE: `usize` and `isize` may be as small as 16 bits on some platforms
+    //~^ cast_possible_truncation
+    //~| cast_possible_wrap
+
     // wraps on 32 bit ptr size
     1usize as i32;
-    //~^ ERROR: casting `usize` to `i32` may truncate the value on targets with 64-bit wid
-    //~| ERROR: casting `usize` to `i32` may wrap around the value on targets with 32-bit
+    //~^ cast_possible_truncation
+    //~| cast_possible_wrap
+
     // wraps on 64 bit ptr size
     1usize as i64;
-    //~^ ERROR: casting `usize` to `i64` may wrap around the value on targets with 64-bit
+    //~^ cast_possible_wrap
+
     // should not wrap, isize is never 8 bits
     1u8 as isize;
     // wraps on 16 bit ptr size
     1u16 as isize;
-    //~^ ERROR: casting `u16` to `isize` may wrap around the value on targets with 16-bit
-    //~| NOTE: `usize` and `isize` may be as small as 16 bits on some platforms
+    //~^ cast_possible_wrap
+
     // wraps on 32 bit ptr size
     1u32 as isize;
-    //~^ ERROR: casting `u32` to `isize` may wrap around the value on targets with 32-bit
+    //~^ cast_possible_wrap
+
     // wraps on 64 bit ptr size
     1u64 as isize;
-    //~^ ERROR: casting `u64` to `isize` may truncate the value on targets with 32-bit wid
-    //~| ERROR: casting `u64` to `isize` may wrap around the value on targets with 64-bit
+    //~^ cast_possible_truncation
+    //~| cast_possible_wrap
+
     // Test clippy::cast_sign_loss
     1i32 as u32;
     -1i32 as u32;
-    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+    //~^ cast_sign_loss
+
     1isize as usize;
     -1isize as usize;
-    //~^ ERROR: casting `isize` to `usize` may lose the sign of the value
+    //~^ cast_sign_loss
+
     0i8 as u8;
     i8::MAX as u8;
     i16::MAX as u16;
@@ -128,11 +154,14 @@ fn main() {
     (-1i8).saturating_abs() as u8;
     // abs() can return a negative value in release builds
     (i8::MIN).abs() as u8;
-    //~^ ERROR: casting `i8` to `u8` may lose the sign of the value
+    //~^ cast_sign_loss
+
     (-1i16).saturating_abs() as u16;
     (-1i32).saturating_abs() as u32;
     (-1i64).abs() as u64;
+    //~^ cast_sign_loss
     (-1isize).abs() as usize;
+    //~^ cast_sign_loss
 
     (-1i8).checked_abs().unwrap() as u8;
     (i8::MIN).checked_abs().unwrap() as u8;
@@ -140,6 +169,7 @@ fn main() {
     (-1i32).checked_abs().unwrap() as u32;
     // SAFETY: -1 is a small number which will always return Some
     (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
+    //~^ cast_sign_loss
     (-1isize).checked_abs().expect("-1 is a small number") as usize;
 
     (-1i8).isqrt() as u8;
@@ -155,6 +185,7 @@ fn main() {
     (-1i32).checked_isqrt().unwrap() as u32;
     // SAFETY: -1 is a small number which will always return Some
     (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
+    //~^ cast_sign_loss
     (-1isize).checked_isqrt().expect("-1 is a small number") as usize;
 
     (-1i8).rem_euclid(1i8) as u8;
@@ -206,7 +237,7 @@ fn main() {
     // Test for signed min
     // should be linted because signed
     (-99999999999i64).min(1) as i8;
-    //~^ ERROR: casting `i64` to `i8` may truncate the value
+    //~^ cast_possible_truncation
 
     // Test for various operations that remove enough bits for the result to fit
     (999999u64 & 1) as u8;
@@ -220,7 +251,7 @@ fn main() {
     999999u64.clamp(0, 255) as u8;
     // should still be linted
     999999u64.clamp(0, 256) as u8;
-    //~^ ERROR: casting `u64` to `u8` may truncate the value
+    //~^ cast_possible_truncation
 
     #[derive(Clone, Copy)]
     enum E1 {
@@ -243,10 +274,11 @@ fn main() {
     impl E2 {
         fn test(self) {
             let _ = self as u8;
-            //~^ ERROR: casting `main::E2` to `u8` may truncate the value
+            //~^ cast_possible_truncation
+
             let _ = Self::B as u8;
-            //~^ ERROR: casting `main::E2::B` to `u8` will truncate the value
-            //~| NOTE: `-D clippy::cast-enum-truncation` implied by `-D warnings`
+            //~^ cast_enum_truncation
+
             // Don't lint. `255..=256` fits in i16
             let _ = self as i16;
             // Don't lint.
@@ -287,9 +319,11 @@ fn main() {
     impl E5 {
         fn test(self) {
             let _ = self as i8;
-            //~^ ERROR: casting `main::E5` to `i8` may truncate the value
+            //~^ cast_possible_truncation
+
             let _ = Self::A as i8;
-            //~^ ERROR: casting `main::E5::A` to `i8` will truncate the value
+            //~^ cast_enum_truncation
+
             // Don't lint. `-129..=127` fits in i16
             let _ = self as i16;
             // Don't lint.
@@ -306,7 +340,8 @@ fn main() {
     impl E6 {
         fn test(self) {
             let _ = self as i16;
-            //~^ ERROR: casting `main::E6` to `i16` may truncate the value
+            //~^ cast_possible_truncation
+
             // Don't lint. `2^16-1` fits in u16
             let _ = Self::A as u16;
             // Don't lint. `2^16-1..=2^16` fits in u32
@@ -325,7 +360,8 @@ fn main() {
     impl E7 {
         fn test(self) {
             let _ = self as usize;
-            //~^ ERROR: casting `main::E7` to `usize` may truncate the value on targets wi
+            //~^ cast_possible_truncation
+
             // Don't lint.
             let _ = Self::A as usize;
             // Don't lint. `2^32-1..=2^32` fits in u64
@@ -372,7 +408,8 @@ fn main() {
     impl E10 {
         fn test(self) {
             let _ = self as u16;
-            //~^ ERROR: casting `main::E10` to `u16` may truncate the value
+            //~^ cast_possible_truncation
+
             // Don't lint.
             let _ = Self::B as u32;
             // Don't lint.
@@ -383,11 +420,13 @@ fn main() {
 
 fn avoid_subtract_overflow(q: u32) {
     let c = (q >> 16) as u8;
-    //~^ ERROR: casting `u32` to `u8` may truncate the value
+    //~^ cast_possible_truncation
+
     c as usize;
 
     let c = (q / 1000) as u8;
-    //~^ ERROR: casting `u32` to `u8` may truncate the value
+    //~^ cast_possible_truncation
+
     c as usize;
 }
 
@@ -399,70 +438,93 @@ fn issue11642() {
     fn square(x: i16) -> u32 {
         let x = x as i32;
         (x * x) as u32;
+        //~^ cast_sign_loss
         x.pow(2) as u32;
         (-2_i32).saturating_pow(2) as u32
     }
 
     let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
+    //~^ cast_sign_loss
 
     (2_i32).checked_pow(3).unwrap() as u32;
+    //~^ cast_sign_loss
     (-2_i32).pow(3) as u32;
-    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+    //~^ cast_sign_loss
 
     (3_i32 % 2) as u32;
     (3_i32 % -2) as u32;
     (-5_i32 % 2) as u32;
-    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+    //~^ cast_sign_loss
+
     (-5_i32 % -2) as u32;
-    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+    //~^ cast_sign_loss
+
     (2_i32 >> 1) as u32;
     (-2_i32 >> 1) as u32;
-    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+    //~^ cast_sign_loss
 
     let x: i32 = 10;
     (x * x) as u32;
+    //~^ cast_sign_loss
     (x * x * x) as u32;
-    //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+    //~^ cast_sign_loss
 
     let y: i16 = -2;
     (y * y * y * y * -2) as u16;
-    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    //~^ cast_sign_loss
+
     (y * y * y / y * 2) as u16;
+    //~^ cast_sign_loss
     (y * y / y * 2) as u16;
-    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    //~^ cast_sign_loss
+
     (y / y * y * -2) as u16;
-    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    //~^ cast_sign_loss
+    //~| eq_op
 
     (y + y + y + -2) as u16;
-    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    //~^ cast_sign_loss
+
     (y + y + y + 2) as u16;
-    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    //~^ cast_sign_loss
 
     let z: i16 = 2;
     (z + -2) as u16;
-    //~^ ERROR: casting `i16` to `u16` may lose the sign of the value
+    //~^ cast_sign_loss
+
     (z + z + 2) as u16;
+    //~^ cast_sign_loss
 
     fn foo(a: i32, b: i32, c: i32) -> u32 {
         (a * a * b * b * c * c) as u32;
+        //~^ cast_sign_loss
         (a * b * c) as u32;
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
+
         (a * -b * c) as u32;
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
+
         (a * b * c * c) as u32;
+        //~^ cast_sign_loss
         (a * -2) as u32;
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
+
         (a * b * c * -2) as u32;
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
+
         (a / b) as u32;
+        //~^ cast_sign_loss
         (a / b * c) as u32;
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
+
         (a / b + b * c) as u32;
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
+
         a.saturating_pow(3) as u32;
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
+
         (a.abs() * b.pow(2) / c.abs()) as u32
-        //~^ ERROR: casting `i32` to `u32` may lose the sign of the value
+        //~^ cast_sign_loss
     }
 }
 
@@ -470,8 +532,14 @@ fn issue11738() {
     macro_rules! m {
         () => {
             let _ = i32::MIN as u32; // cast_sign_loss
+            //
+            //~^^ cast_sign_loss
             let _ = u32::MAX as u8; // cast_possible_truncation
+            //
+            //~^^ cast_possible_truncation
             let _ = std::f64::consts::PI as f32; // cast_possible_truncation
+            //
+            //~^^ cast_possible_truncation
             let _ = 0i8 as i32; // cast_lossless
         };
     }
@@ -481,6 +549,8 @@ fn issue11738() {
 fn issue12506() -> usize {
     let bar: Result<Option<i64>, u32> = Ok(Some(10));
     bar.unwrap().unwrap() as usize
+    //~^ cast_possible_truncation
+    //~| cast_sign_loss
 }
 
 fn issue12721() {
@@ -496,7 +566,8 @@ fn issue12721() {
     let _ = (999999 & (x() & 255)) as u8;
 
     (256 & 999999u64) as u8;
-    //~^ ERROR: casting `u64` to `u8` may truncate the value
+    //~^ cast_possible_truncation
+
     (255 % 999999u64) as u8;
-    //~^ ERROR: casting `u64` to `u8` may truncate the value
+    //~^ cast_possible_truncation
 }
diff --git a/src/tools/clippy/tests/ui/cast.stderr b/src/tools/clippy/tests/ui/cast.stderr
index 901447c738ed..4d03282f6676 100644
--- a/src/tools/clippy/tests/ui/cast.stderr
+++ b/src/tools/clippy/tests/ui/cast.stderr
@@ -14,31 +14,31 @@ LL |     x1 as f32;
    |     ^^^^^^^^^
 
 error: casting `i64` to `f64` causes a loss of precision (`i64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast.rs:31:5
+  --> tests/ui/cast.rs:32:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^
 
 error: casting `u32` to `f32` causes a loss of precision (`u32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast.rs:34:5
+  --> tests/ui/cast.rs:36:5
    |
 LL |     x2 as f32;
    |     ^^^^^^^^^
 
 error: casting `u64` to `f32` causes a loss of precision (`u64` is 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast.rs:37:5
+  --> tests/ui/cast.rs:40:5
    |
 LL |     x3 as f32;
    |     ^^^^^^^^^
 
 error: casting `u64` to `f64` causes a loss of precision (`u64` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast.rs:39:5
+  --> tests/ui/cast.rs:43:5
    |
 LL |     x3 as f64;
    |     ^^^^^^^^^
 
 error: casting `f32` to `i32` may truncate the value
-  --> tests/ui/cast.rs:42:5
+  --> tests/ui/cast.rs:47:5
    |
 LL |     1f32 as i32;
    |     ^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |     1f32 as i32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_truncation)]`
 
 error: casting `f32` to `u32` may truncate the value
-  --> tests/ui/cast.rs:44:5
+  --> tests/ui/cast.rs:50:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     1f32 as u32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:44:5
+  --> tests/ui/cast.rs:50:5
    |
 LL |     1f32 as u32;
    |     ^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     1f32 as u32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_sign_loss)]`
 
 error: casting `f64` to `f32` may truncate the value
-  --> tests/ui/cast.rs:48:5
+  --> tests/ui/cast.rs:54:5
    |
 LL |     1f64 as f32;
    |     ^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     1f64 as f32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `i32` to `i8` may truncate the value
-  --> tests/ui/cast.rs:50:5
+  --> tests/ui/cast.rs:57:5
    |
 LL |     1i32 as i8;
    |     ^^^^^^^^^^
@@ -86,7 +86,7 @@ LL +     i8::try_from(1i32);
    |
 
 error: casting `i32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:52:5
+  --> tests/ui/cast.rs:60:5
    |
 LL |     1i32 as u8;
    |     ^^^^^^^^^^
@@ -99,7 +99,7 @@ LL +     u8::try_from(1i32);
    |
 
 error: casting `f64` to `isize` may truncate the value
-  --> tests/ui/cast.rs:54:5
+  --> tests/ui/cast.rs:63:5
    |
 LL |     1f64 as isize;
    |     ^^^^^^^^^^^^^
@@ -107,7 +107,7 @@ LL |     1f64 as isize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f64` to `usize` may truncate the value
-  --> tests/ui/cast.rs:56:5
+  --> tests/ui/cast.rs:66:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
@@ -115,13 +115,13 @@ LL |     1f64 as usize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f64` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:56:5
+  --> tests/ui/cast.rs:66:5
    |
 LL |     1f64 as usize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u32` to `u16` may truncate the value
-  --> tests/ui/cast.rs:59:5
+  --> tests/ui/cast.rs:70:5
    |
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^^^^^^^^
@@ -134,7 +134,7 @@ LL +     u16::try_from(1f32 as u32);
    |
 
 error: casting `f32` to `u32` may truncate the value
-  --> tests/ui/cast.rs:59:5
+  --> tests/ui/cast.rs:70:5
    |
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^
@@ -142,13 +142,13 @@ LL |     1f32 as u32 as u16;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:59:5
+  --> tests/ui/cast.rs:70:5
    |
 LL |     1f32 as u32 as u16;
    |     ^^^^^^^^^^^
 
 error: casting `i32` to `i8` may truncate the value
-  --> tests/ui/cast.rs:64:22
+  --> tests/ui/cast.rs:76:22
    |
 LL |         let _x: i8 = 1i32 as _;
    |                      ^^^^^^^^^
@@ -161,7 +161,7 @@ LL +         let _x: i8 = 1i32.try_into();
    |
 
 error: casting `f32` to `i32` may truncate the value
-  --> tests/ui/cast.rs:66:9
+  --> tests/ui/cast.rs:79:9
    |
 LL |         1f32 as i32;
    |         ^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL |         1f32 as i32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f64` to `i32` may truncate the value
-  --> tests/ui/cast.rs:68:9
+  --> tests/ui/cast.rs:82:9
    |
 LL |         1f64 as i32;
    |         ^^^^^^^^^^^
@@ -177,7 +177,7 @@ LL |         1f64 as i32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:70:9
+  --> tests/ui/cast.rs:85:9
    |
 LL |         1f32 as u8;
    |         ^^^^^^^^^^
@@ -185,13 +185,13 @@ LL |         1f32 as u8;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 
 error: casting `f32` to `u8` may lose the sign of the value
-  --> tests/ui/cast.rs:70:9
+  --> tests/ui/cast.rs:85:9
    |
 LL |         1f32 as u8;
    |         ^^^^^^^^^^
 
 error: casting `u8` to `i8` may wrap around the value
-  --> tests/ui/cast.rs:75:5
+  --> tests/ui/cast.rs:90:5
    |
 LL |     1u8 as i8;
    |     ^^^^^^^^^
@@ -200,31 +200,31 @@ LL |     1u8 as i8;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
 
 error: casting `u16` to `i16` may wrap around the value
-  --> tests/ui/cast.rs:78:5
+  --> tests/ui/cast.rs:93:5
    |
 LL |     1u16 as i16;
    |     ^^^^^^^^^^^
 
 error: casting `u32` to `i32` may wrap around the value
-  --> tests/ui/cast.rs:80:5
+  --> tests/ui/cast.rs:96:5
    |
 LL |     1u32 as i32;
    |     ^^^^^^^^^^^
 
 error: casting `u64` to `i64` may wrap around the value
-  --> tests/ui/cast.rs:82:5
+  --> tests/ui/cast.rs:99:5
    |
 LL |     1u64 as i64;
    |     ^^^^^^^^^^^
 
 error: casting `usize` to `isize` may wrap around the value
-  --> tests/ui/cast.rs:84:5
+  --> tests/ui/cast.rs:102:5
    |
 LL |     1usize as isize;
    |     ^^^^^^^^^^^^^^^
 
 error: casting `usize` to `i8` may truncate the value
-  --> tests/ui/cast.rs:87:5
+  --> tests/ui/cast.rs:106:5
    |
 LL |     1usize as i8;
    |     ^^^^^^^^^^^^
@@ -237,7 +237,7 @@ LL +     i8::try_from(1usize);
    |
 
 error: casting `usize` to `i16` may truncate the value
-  --> tests/ui/cast.rs:90:5
+  --> tests/ui/cast.rs:110:5
    |
 LL |     1usize as i16;
    |     ^^^^^^^^^^^^^
@@ -250,7 +250,7 @@ LL +     i16::try_from(1usize);
    |
 
 error: casting `usize` to `i16` may wrap around the value on targets with 16-bit wide pointers
-  --> tests/ui/cast.rs:90:5
+  --> tests/ui/cast.rs:110:5
    |
 LL |     1usize as i16;
    |     ^^^^^^^^^^^^^
@@ -259,7 +259,7 @@ LL |     1usize as i16;
    = note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast.rs:95:5
+  --> tests/ui/cast.rs:115:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -272,19 +272,19 @@ LL +     i32::try_from(1usize);
    |
 
 error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:95:5
+  --> tests/ui/cast.rs:115:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
 
 error: casting `usize` to `i64` may wrap around the value on targets with 64-bit wide pointers
-  --> tests/ui/cast.rs:99:5
+  --> tests/ui/cast.rs:120:5
    |
 LL |     1usize as i64;
    |     ^^^^^^^^^^^^^
 
 error: casting `u16` to `isize` may wrap around the value on targets with 16-bit wide pointers
-  --> tests/ui/cast.rs:104:5
+  --> tests/ui/cast.rs:126:5
    |
 LL |     1u16 as isize;
    |     ^^^^^^^^^^^^^
@@ -293,13 +293,13 @@ LL |     1u16 as isize;
    = note: for more information see https://doc.rust-lang.org/reference/types/numeric.html#machine-dependent-integer-types
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:108:5
+  --> tests/ui/cast.rs:130:5
    |
 LL |     1u32 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:111:5
+  --> tests/ui/cast.rs:134:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
@@ -312,55 +312,55 @@ LL +     isize::try_from(1u64);
    |
 
 error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
-  --> tests/ui/cast.rs:111:5
+  --> tests/ui/cast.rs:134:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:116:5
+  --> tests/ui/cast.rs:140:5
    |
 LL |     -1i32 as u32;
    |     ^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:119:5
+  --> tests/ui/cast.rs:144:5
    |
 LL |     -1isize as usize;
    |     ^^^^^^^^^^^^^^^^
 
 error: casting `i8` to `u8` may lose the sign of the value
-  --> tests/ui/cast.rs:130:5
+  --> tests/ui/cast.rs:156:5
    |
 LL |     (i8::MIN).abs() as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `u64` may lose the sign of the value
-  --> tests/ui/cast.rs:134:5
+  --> tests/ui/cast.rs:161:5
    |
 LL |     (-1i64).abs() as u64;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: casting `isize` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:135:5
+  --> tests/ui/cast.rs:163:5
    |
 LL |     (-1isize).abs() as usize;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `u64` may lose the sign of the value
-  --> tests/ui/cast.rs:142:5
+  --> tests/ui/cast.rs:171:5
    |
 LL |     (unsafe { (-1i64).checked_abs().unwrap_unchecked() }) as u64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `u64` may lose the sign of the value
-  --> tests/ui/cast.rs:157:5
+  --> tests/ui/cast.rs:187:5
    |
 LL |     (unsafe { (-1i64).checked_isqrt().unwrap_unchecked() }) as u64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i64` to `i8` may truncate the value
-  --> tests/ui/cast.rs:208:5
+  --> tests/ui/cast.rs:239:5
    |
 LL |     (-99999999999i64).min(1) as i8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -373,7 +373,7 @@ LL +     i8::try_from((-99999999999i64).min(1));
    |
 
 error: casting `u64` to `u8` may truncate the value
-  --> tests/ui/cast.rs:222:5
+  --> tests/ui/cast.rs:253:5
    |
 LL |     999999u64.clamp(0, 256) as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -386,7 +386,7 @@ LL +     u8::try_from(999999u64.clamp(0, 256));
    |
 
 error: casting `main::E2` to `u8` may truncate the value
-  --> tests/ui/cast.rs:245:21
+  --> tests/ui/cast.rs:276:21
    |
 LL |             let _ = self as u8;
    |                     ^^^^^^^^^^
@@ -399,7 +399,7 @@ LL +             let _ = u8::try_from(self);
    |
 
 error: casting `main::E2::B` to `u8` will truncate the value
-  --> tests/ui/cast.rs:247:21
+  --> tests/ui/cast.rs:279:21
    |
 LL |             let _ = Self::B as u8;
    |                     ^^^^^^^^^^^^^
@@ -408,7 +408,7 @@ LL |             let _ = Self::B as u8;
    = help: to override `-D warnings` add `#[allow(clippy::cast_enum_truncation)]`
 
 error: casting `main::E5` to `i8` may truncate the value
-  --> tests/ui/cast.rs:289:21
+  --> tests/ui/cast.rs:321:21
    |
 LL |             let _ = self as i8;
    |                     ^^^^^^^^^^
@@ -421,13 +421,13 @@ LL +             let _ = i8::try_from(self);
    |
 
 error: casting `main::E5::A` to `i8` will truncate the value
-  --> tests/ui/cast.rs:291:21
+  --> tests/ui/cast.rs:324:21
    |
 LL |             let _ = Self::A as i8;
    |                     ^^^^^^^^^^^^^
 
 error: casting `main::E6` to `i16` may truncate the value
-  --> tests/ui/cast.rs:308:21
+  --> tests/ui/cast.rs:342:21
    |
 LL |             let _ = self as i16;
    |                     ^^^^^^^^^^^
@@ -440,7 +440,7 @@ LL +             let _ = i16::try_from(self);
    |
 
 error: casting `main::E7` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:327:21
+  --> tests/ui/cast.rs:362:21
    |
 LL |             let _ = self as usize;
    |                     ^^^^^^^^^^^^^
@@ -453,7 +453,7 @@ LL +             let _ = usize::try_from(self);
    |
 
 error: casting `main::E10` to `u16` may truncate the value
-  --> tests/ui/cast.rs:374:21
+  --> tests/ui/cast.rs:410:21
    |
 LL |             let _ = self as u16;
    |                     ^^^^^^^^^^^
@@ -466,7 +466,7 @@ LL +             let _ = u16::try_from(self);
    |
 
 error: casting `u32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:385:13
+  --> tests/ui/cast.rs:422:13
    |
 LL |     let c = (q >> 16) as u8;
    |             ^^^^^^^^^^^^^^^
@@ -479,7 +479,7 @@ LL +     let c = u8::try_from(q >> 16);
    |
 
 error: casting `u32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:389:13
+  --> tests/ui/cast.rs:427:13
    |
 LL |     let c = (q / 1000) as u8;
    |             ^^^^^^^^^^^^^^^^
@@ -492,85 +492,85 @@ LL +     let c = u8::try_from(q / 1000);
    |
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:401:9
+  --> tests/ui/cast.rs:440:9
    |
 LL |         (x * x) as u32;
    |         ^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:406:32
+  --> tests/ui/cast.rs:446:32
    |
 LL |     let _a = |x: i32| -> u32 { (x * x * x * x) as u32 };
    |                                ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:408:5
+  --> tests/ui/cast.rs:449:5
    |
 LL |     (2_i32).checked_pow(3).unwrap() as u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:409:5
+  --> tests/ui/cast.rs:451:5
    |
 LL |     (-2_i32).pow(3) as u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:414:5
+  --> tests/ui/cast.rs:456:5
    |
 LL |     (-5_i32 % 2) as u32;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:416:5
+  --> tests/ui/cast.rs:459:5
    |
 LL |     (-5_i32 % -2) as u32;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:419:5
+  --> tests/ui/cast.rs:463:5
    |
 LL |     (-2_i32 >> 1) as u32;
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:423:5
+  --> tests/ui/cast.rs:467:5
    |
 LL |     (x * x) as u32;
    |     ^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:424:5
+  --> tests/ui/cast.rs:469:5
    |
 LL |     (x * x * x) as u32;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:428:5
+  --> tests/ui/cast.rs:473:5
    |
 LL |     (y * y * y * y * -2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:430:5
+  --> tests/ui/cast.rs:476:5
    |
 LL |     (y * y * y / y * 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:431:5
+  --> tests/ui/cast.rs:478:5
    |
 LL |     (y * y / y * 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:433:5
+  --> tests/ui/cast.rs:481:5
    |
 LL |     (y / y * y * -2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `/`
-  --> tests/ui/cast.rs:433:6
+  --> tests/ui/cast.rs:481:6
    |
 LL |     (y / y * y * -2) as u16;
    |      ^^^^^
@@ -578,97 +578,97 @@ LL |     (y / y * y * -2) as u16;
    = note: `#[deny(clippy::eq_op)]` on by default
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:436:5
+  --> tests/ui/cast.rs:485:5
    |
 LL |     (y + y + y + -2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:438:5
+  --> tests/ui/cast.rs:488:5
    |
 LL |     (y + y + y + 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:442:5
+  --> tests/ui/cast.rs:492:5
    |
 LL |     (z + -2) as u16;
    |     ^^^^^^^^^^^^^^^
 
 error: casting `i16` to `u16` may lose the sign of the value
-  --> tests/ui/cast.rs:444:5
+  --> tests/ui/cast.rs:495:5
    |
 LL |     (z + z + 2) as u16;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:447:9
+  --> tests/ui/cast.rs:499:9
    |
 LL |         (a * a * b * b * c * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:448:9
+  --> tests/ui/cast.rs:501:9
    |
 LL |         (a * b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:450:9
+  --> tests/ui/cast.rs:504:9
    |
 LL |         (a * -b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:452:9
+  --> tests/ui/cast.rs:507:9
    |
 LL |         (a * b * c * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:453:9
+  --> tests/ui/cast.rs:509:9
    |
 LL |         (a * -2) as u32;
    |         ^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:455:9
+  --> tests/ui/cast.rs:512:9
    |
 LL |         (a * b * c * -2) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:457:9
+  --> tests/ui/cast.rs:515:9
    |
 LL |         (a / b) as u32;
    |         ^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:458:9
+  --> tests/ui/cast.rs:517:9
    |
 LL |         (a / b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:460:9
+  --> tests/ui/cast.rs:520:9
    |
 LL |         (a / b + b * c) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:462:9
+  --> tests/ui/cast.rs:523:9
    |
 LL |         a.saturating_pow(3) as u32;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:464:9
+  --> tests/ui/cast.rs:526:9
    |
 LL |         (a.abs() * b.pow(2) / c.abs()) as u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `i32` to `u32` may lose the sign of the value
-  --> tests/ui/cast.rs:472:21
+  --> tests/ui/cast.rs:534:21
    |
 LL |             let _ = i32::MIN as u32; // cast_sign_loss
    |                     ^^^^^^^^^^^^^^^
@@ -679,7 +679,7 @@ LL |     m!();
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: casting `u32` to `u8` may truncate the value
-  --> tests/ui/cast.rs:473:21
+  --> tests/ui/cast.rs:537:21
    |
 LL |             let _ = u32::MAX as u8; // cast_possible_truncation
    |                     ^^^^^^^^^^^^^^
@@ -696,7 +696,7 @@ LL +             let _ = u8::try_from(u32::MAX); // cast_possible_truncation
    |
 
 error: casting `f64` to `f32` may truncate the value
-  --> tests/ui/cast.rs:474:21
+  --> tests/ui/cast.rs:540:21
    |
 LL |             let _ = std::f64::consts::PI as f32; // cast_possible_truncation
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -708,7 +708,7 @@ LL |     m!();
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast.rs:483:5
+  --> tests/ui/cast.rs:551:5
    |
 LL |     bar.unwrap().unwrap() as usize
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -721,13 +721,13 @@ LL +     usize::try_from(bar.unwrap().unwrap())
    |
 
 error: casting `i64` to `usize` may lose the sign of the value
-  --> tests/ui/cast.rs:483:5
+  --> tests/ui/cast.rs:551:5
    |
 LL |     bar.unwrap().unwrap() as usize
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting `u64` to `u8` may truncate the value
-  --> tests/ui/cast.rs:498:5
+  --> tests/ui/cast.rs:568:5
    |
 LL |     (256 & 999999u64) as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -740,7 +740,7 @@ LL +     u8::try_from(256 & 999999u64);
    |
 
 error: casting `u64` to `u8` may truncate the value
-  --> tests/ui/cast.rs:500:5
+  --> tests/ui/cast.rs:571:5
    |
 LL |     (255 % 999999u64) as u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_abs_to_unsigned.fixed b/src/tools/clippy/tests/ui/cast_abs_to_unsigned.fixed
index 6ca01b7cc367..b55c22f5ca83 100644
--- a/src/tools/clippy/tests/ui/cast_abs_to_unsigned.fixed
+++ b/src/tools/clippy/tests/ui/cast_abs_to_unsigned.fixed
@@ -4,30 +4,47 @@
 fn main() {
     let x: i32 = -42;
     let y: u32 = x.unsigned_abs();
+    //~^ cast_abs_to_unsigned
     println!("The absolute value of {} is {}", x, y);
 
     let a: i32 = -3;
     let _: usize = a.unsigned_abs() as usize;
+    //~^ cast_abs_to_unsigned
     let _: usize = a.unsigned_abs() as _;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as usize;
+    //~^ cast_abs_to_unsigned
 
     let a: i64 = -3;
     let _ = a.unsigned_abs() as usize;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u8;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u16;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u32;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs();
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u128;
+    //~^ cast_abs_to_unsigned
 
     let a: isize = -3;
     let _ = a.unsigned_abs();
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u8;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u16;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u32;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u64;
+    //~^ cast_abs_to_unsigned
     let _ = a.unsigned_abs() as u128;
+    //~^ cast_abs_to_unsigned
 
     let _ = (x as i64 - y as i64).unsigned_abs() as u32;
+    //~^ cast_abs_to_unsigned
 }
 
 #[clippy::msrv = "1.50"]
@@ -40,4 +57,5 @@ fn msrv_1_50() {
 fn msrv_1_51() {
     let x: i32 = 10;
     assert_eq!(10u32, x.unsigned_abs());
+    //~^ cast_abs_to_unsigned
 }
diff --git a/src/tools/clippy/tests/ui/cast_abs_to_unsigned.rs b/src/tools/clippy/tests/ui/cast_abs_to_unsigned.rs
index 190a77c10232..466aa6aeb1fb 100644
--- a/src/tools/clippy/tests/ui/cast_abs_to_unsigned.rs
+++ b/src/tools/clippy/tests/ui/cast_abs_to_unsigned.rs
@@ -4,30 +4,47 @@
 fn main() {
     let x: i32 = -42;
     let y: u32 = x.abs() as u32;
+    //~^ cast_abs_to_unsigned
     println!("The absolute value of {} is {}", x, y);
 
     let a: i32 = -3;
     let _: usize = a.abs() as usize;
+    //~^ cast_abs_to_unsigned
     let _: usize = a.abs() as _;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as usize;
+    //~^ cast_abs_to_unsigned
 
     let a: i64 = -3;
     let _ = a.abs() as usize;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u8;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u16;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u32;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u64;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u128;
+    //~^ cast_abs_to_unsigned
 
     let a: isize = -3;
     let _ = a.abs() as usize;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u8;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u16;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u32;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u64;
+    //~^ cast_abs_to_unsigned
     let _ = a.abs() as u128;
+    //~^ cast_abs_to_unsigned
 
     let _ = (x as i64 - y as i64).abs() as u32;
+    //~^ cast_abs_to_unsigned
 }
 
 #[clippy::msrv = "1.50"]
@@ -40,4 +57,5 @@ fn msrv_1_50() {
 fn msrv_1_51() {
     let x: i32 = 10;
     assert_eq!(10u32, x.abs() as u32);
+    //~^ cast_abs_to_unsigned
 }
diff --git a/src/tools/clippy/tests/ui/cast_abs_to_unsigned.stderr b/src/tools/clippy/tests/ui/cast_abs_to_unsigned.stderr
index 96e5c1724a51..26220693969c 100644
--- a/src/tools/clippy/tests/ui/cast_abs_to_unsigned.stderr
+++ b/src/tools/clippy/tests/ui/cast_abs_to_unsigned.stderr
@@ -8,103 +8,103 @@ LL |     let y: u32 = x.abs() as u32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_abs_to_unsigned)]`
 
 error: casting the result of `i32::abs()` to usize
-  --> tests/ui/cast_abs_to_unsigned.rs:10:20
+  --> tests/ui/cast_abs_to_unsigned.rs:11:20
    |
 LL |     let _: usize = a.abs() as usize;
    |                    ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `i32::abs()` to usize
-  --> tests/ui/cast_abs_to_unsigned.rs:11:20
+  --> tests/ui/cast_abs_to_unsigned.rs:13:20
    |
 LL |     let _: usize = a.abs() as _;
    |                    ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `i32::abs()` to usize
-  --> tests/ui/cast_abs_to_unsigned.rs:12:13
-   |
-LL |     let _ = a.abs() as usize;
-   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
-
-error: casting the result of `i64::abs()` to usize
   --> tests/ui/cast_abs_to_unsigned.rs:15:13
    |
 LL |     let _ = a.abs() as usize;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
+error: casting the result of `i64::abs()` to usize
+  --> tests/ui/cast_abs_to_unsigned.rs:19:13
+   |
+LL |     let _ = a.abs() as usize;
+   |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
+
 error: casting the result of `i64::abs()` to u8
-  --> tests/ui/cast_abs_to_unsigned.rs:16:13
+  --> tests/ui/cast_abs_to_unsigned.rs:21:13
    |
 LL |     let _ = a.abs() as u8;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `i64::abs()` to u16
-  --> tests/ui/cast_abs_to_unsigned.rs:17:13
+  --> tests/ui/cast_abs_to_unsigned.rs:23:13
    |
 LL |     let _ = a.abs() as u16;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `i64::abs()` to u32
-  --> tests/ui/cast_abs_to_unsigned.rs:18:13
+  --> tests/ui/cast_abs_to_unsigned.rs:25:13
    |
 LL |     let _ = a.abs() as u32;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `i64::abs()` to u64
-  --> tests/ui/cast_abs_to_unsigned.rs:19:13
+  --> tests/ui/cast_abs_to_unsigned.rs:27:13
    |
 LL |     let _ = a.abs() as u64;
    |             ^^^^^^^^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `i64::abs()` to u128
-  --> tests/ui/cast_abs_to_unsigned.rs:20:13
+  --> tests/ui/cast_abs_to_unsigned.rs:29:13
    |
 LL |     let _ = a.abs() as u128;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `isize::abs()` to usize
-  --> tests/ui/cast_abs_to_unsigned.rs:23:13
+  --> tests/ui/cast_abs_to_unsigned.rs:33:13
    |
 LL |     let _ = a.abs() as usize;
    |             ^^^^^^^^^^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `isize::abs()` to u8
-  --> tests/ui/cast_abs_to_unsigned.rs:24:13
+  --> tests/ui/cast_abs_to_unsigned.rs:35:13
    |
 LL |     let _ = a.abs() as u8;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `isize::abs()` to u16
-  --> tests/ui/cast_abs_to_unsigned.rs:25:13
+  --> tests/ui/cast_abs_to_unsigned.rs:37:13
    |
 LL |     let _ = a.abs() as u16;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `isize::abs()` to u32
-  --> tests/ui/cast_abs_to_unsigned.rs:26:13
+  --> tests/ui/cast_abs_to_unsigned.rs:39:13
    |
 LL |     let _ = a.abs() as u32;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `isize::abs()` to u64
-  --> tests/ui/cast_abs_to_unsigned.rs:27:13
+  --> tests/ui/cast_abs_to_unsigned.rs:41:13
    |
 LL |     let _ = a.abs() as u64;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `isize::abs()` to u128
-  --> tests/ui/cast_abs_to_unsigned.rs:28:13
+  --> tests/ui/cast_abs_to_unsigned.rs:43:13
    |
 LL |     let _ = a.abs() as u128;
    |             ^^^^^^^ help: replace with: `a.unsigned_abs()`
 
 error: casting the result of `i64::abs()` to u32
-  --> tests/ui/cast_abs_to_unsigned.rs:30:13
+  --> tests/ui/cast_abs_to_unsigned.rs:46:13
    |
 LL |     let _ = (x as i64 - y as i64).abs() as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `(x as i64 - y as i64).unsigned_abs()`
 
 error: casting the result of `i32::abs()` to u32
-  --> tests/ui/cast_abs_to_unsigned.rs:42:23
+  --> tests/ui/cast_abs_to_unsigned.rs:59:23
    |
 LL |     assert_eq!(10u32, x.abs() as u32);
    |                       ^^^^^^^^^^^^^^ help: replace with: `x.unsigned_abs()`
diff --git a/src/tools/clippy/tests/ui/cast_alignment.rs b/src/tools/clippy/tests/ui/cast_alignment.rs
index 72f5d4268cc1..5773ffddb917 100644
--- a/src/tools/clippy/tests/ui/cast_alignment.rs
+++ b/src/tools/clippy/tests/ui/cast_alignment.rs
@@ -17,16 +17,17 @@ fn main() {
 
     // cast to more-strictly-aligned type
     (&1u8 as *const u8) as *const u16;
-    //~^ ERROR: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`)
-    //~| NOTE: `-D clippy::cast-ptr-alignment` implied by `-D warnings`
+    //~^ cast_ptr_alignment
+
     (&mut 1u8 as *mut u8) as *mut u16;
-    //~^ ERROR: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1
+    //~^ cast_ptr_alignment
 
     // cast to more-strictly-aligned type, but with the `pointer::cast` function.
     (&1u8 as *const u8).cast::<u16>();
-    //~^ ERROR: casting from `*const u8` to a more-strictly-aligned pointer (`*const u16`)
+    //~^ cast_ptr_alignment
+
     (&mut 1u8 as *mut u8).cast::<u16>();
-    //~^ ERROR: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1
+    //~^ cast_ptr_alignment
 
     /* These should be ok */
 
diff --git a/src/tools/clippy/tests/ui/cast_alignment.stderr b/src/tools/clippy/tests/ui/cast_alignment.stderr
index b32624f958fc..6d9a81f0ecfd 100644
--- a/src/tools/clippy/tests/ui/cast_alignment.stderr
+++ b/src/tools/clippy/tests/ui/cast_alignment.stderr
@@ -20,7 +20,7 @@ LL |     (&1u8 as *const u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: casting from `*mut u8` to a more-strictly-aligned pointer (`*mut u16`) (1 < 2 bytes)
-  --> tests/ui/cast_alignment.rs:28:5
+  --> tests/ui/cast_alignment.rs:29:5
    |
 LL |     (&mut 1u8 as *mut u8).cast::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_enum_constructor.rs b/src/tools/clippy/tests/ui/cast_enum_constructor.rs
index 3226f487b3af..eecf56f71a33 100644
--- a/src/tools/clippy/tests/ui/cast_enum_constructor.rs
+++ b/src/tools/clippy/tests/ui/cast_enum_constructor.rs
@@ -11,10 +11,11 @@ fn main() {
     }
 
     let _ = Foo::Y as usize;
-    //~^ ERROR: cast of an enum tuple constructor to an integer
-    //~| NOTE: `-D clippy::cast-enum-constructor` implied by `-D warnings`
+    //~^ cast_enum_constructor
+
     let _ = Foo::Y as isize;
-    //~^ ERROR: cast of an enum tuple constructor to an integer
+    //~^ cast_enum_constructor
+
     let _ = Foo::Y as fn(u32) -> Foo;
     let _ = Bar::X as usize;
 }
diff --git a/src/tools/clippy/tests/ui/cast_lossless_bool.fixed b/src/tools/clippy/tests/ui/cast_lossless_bool.fixed
index 51a38a60cf6b..21dc280a5864 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_bool.fixed
+++ b/src/tools/clippy/tests/ui/cast_lossless_bool.fixed
@@ -6,23 +6,37 @@ type U8 = u8;
 fn main() {
     // Test clippy::cast_lossless with casts to integer types
     let _ = u8::from(true);
+    //~^ cast_lossless
     let _ = u16::from(true);
+    //~^ cast_lossless
     let _ = u32::from(true);
+    //~^ cast_lossless
     let _ = u64::from(true);
+    //~^ cast_lossless
     let _ = u128::from(true);
+    //~^ cast_lossless
     let _ = usize::from(true);
+    //~^ cast_lossless
 
     let _ = i8::from(true);
+    //~^ cast_lossless
     let _ = i16::from(true);
+    //~^ cast_lossless
     let _ = i32::from(true);
+    //~^ cast_lossless
     let _ = i64::from(true);
+    //~^ cast_lossless
     let _ = i128::from(true);
+    //~^ cast_lossless
     let _ = isize::from(true);
+    //~^ cast_lossless
 
     // Test with an expression wrapped in parens
     let _ = u16::from(true | false);
+    //~^ cast_lossless
 
     let _ = U8::from(true);
+    //~^ cast_lossless
 }
 
 // The lint would suggest using `u32::from(input)` here but the `XX::from` function is not const,
@@ -51,4 +65,5 @@ fn msrv_1_27() {
 #[clippy::msrv = "1.28"]
 fn msrv_1_28() {
     let _ = u8::from(true);
+    //~^ cast_lossless
 }
diff --git a/src/tools/clippy/tests/ui/cast_lossless_bool.rs b/src/tools/clippy/tests/ui/cast_lossless_bool.rs
index cb307bd68e43..d03badd9a7bc 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_bool.rs
+++ b/src/tools/clippy/tests/ui/cast_lossless_bool.rs
@@ -6,23 +6,37 @@ type U8 = u8;
 fn main() {
     // Test clippy::cast_lossless with casts to integer types
     let _ = true as u8;
+    //~^ cast_lossless
     let _ = true as u16;
+    //~^ cast_lossless
     let _ = true as u32;
+    //~^ cast_lossless
     let _ = true as u64;
+    //~^ cast_lossless
     let _ = true as u128;
+    //~^ cast_lossless
     let _ = true as usize;
+    //~^ cast_lossless
 
     let _ = true as i8;
+    //~^ cast_lossless
     let _ = true as i16;
+    //~^ cast_lossless
     let _ = true as i32;
+    //~^ cast_lossless
     let _ = true as i64;
+    //~^ cast_lossless
     let _ = true as i128;
+    //~^ cast_lossless
     let _ = true as isize;
+    //~^ cast_lossless
 
     // Test with an expression wrapped in parens
     let _ = (true | false) as u16;
+    //~^ cast_lossless
 
     let _ = true as U8;
+    //~^ cast_lossless
 }
 
 // The lint would suggest using `u32::from(input)` here but the `XX::from` function is not const,
@@ -51,4 +65,5 @@ fn msrv_1_27() {
 #[clippy::msrv = "1.28"]
 fn msrv_1_28() {
     let _ = true as u8;
+    //~^ cast_lossless
 }
diff --git a/src/tools/clippy/tests/ui/cast_lossless_bool.stderr b/src/tools/clippy/tests/ui/cast_lossless_bool.stderr
index 689922717623..802eeaebbbdd 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_bool.stderr
+++ b/src/tools/clippy/tests/ui/cast_lossless_bool.stderr
@@ -14,7 +14,7 @@ LL +     let _ = u8::from(true);
    |
 
 error: casts from `bool` to `u16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:9:13
+  --> tests/ui/cast_lossless_bool.rs:10:13
    |
 LL |     let _ = true as u16;
    |             ^^^^^^^^^^^
@@ -27,7 +27,7 @@ LL +     let _ = u16::from(true);
    |
 
 error: casts from `bool` to `u32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:10:13
+  --> tests/ui/cast_lossless_bool.rs:12:13
    |
 LL |     let _ = true as u32;
    |             ^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL +     let _ = u32::from(true);
    |
 
 error: casts from `bool` to `u64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:11:13
+  --> tests/ui/cast_lossless_bool.rs:14:13
    |
 LL |     let _ = true as u64;
    |             ^^^^^^^^^^^
@@ -53,7 +53,7 @@ LL +     let _ = u64::from(true);
    |
 
 error: casts from `bool` to `u128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:12:13
+  --> tests/ui/cast_lossless_bool.rs:16:13
    |
 LL |     let _ = true as u128;
    |             ^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL +     let _ = u128::from(true);
    |
 
 error: casts from `bool` to `usize` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:13:13
+  --> tests/ui/cast_lossless_bool.rs:18:13
    |
 LL |     let _ = true as usize;
    |             ^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ LL +     let _ = usize::from(true);
    |
 
 error: casts from `bool` to `i8` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:15:13
+  --> tests/ui/cast_lossless_bool.rs:21:13
    |
 LL |     let _ = true as i8;
    |             ^^^^^^^^^^
@@ -92,7 +92,7 @@ LL +     let _ = i8::from(true);
    |
 
 error: casts from `bool` to `i16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:16:13
+  --> tests/ui/cast_lossless_bool.rs:23:13
    |
 LL |     let _ = true as i16;
    |             ^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL +     let _ = i16::from(true);
    |
 
 error: casts from `bool` to `i32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:17:13
+  --> tests/ui/cast_lossless_bool.rs:25:13
    |
 LL |     let _ = true as i32;
    |             ^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL +     let _ = i32::from(true);
    |
 
 error: casts from `bool` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:18:13
+  --> tests/ui/cast_lossless_bool.rs:27:13
    |
 LL |     let _ = true as i64;
    |             ^^^^^^^^^^^
@@ -131,7 +131,7 @@ LL +     let _ = i64::from(true);
    |
 
 error: casts from `bool` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:19:13
+  --> tests/ui/cast_lossless_bool.rs:29:13
    |
 LL |     let _ = true as i128;
    |             ^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL +     let _ = i128::from(true);
    |
 
 error: casts from `bool` to `isize` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:20:13
+  --> tests/ui/cast_lossless_bool.rs:31:13
    |
 LL |     let _ = true as isize;
    |             ^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let _ = isize::from(true);
    |
 
 error: casts from `bool` to `u16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:23:13
+  --> tests/ui/cast_lossless_bool.rs:35:13
    |
 LL |     let _ = (true | false) as u16;
    |             ^^^^^^^^^^^^^^^^^^^^^
@@ -170,7 +170,7 @@ LL +     let _ = u16::from(true | false);
    |
 
 error: casts from `bool` to `u8` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:25:13
+  --> tests/ui/cast_lossless_bool.rs:38:13
    |
 LL |     let _ = true as U8;
    |             ^^^^^^^^^^
@@ -183,7 +183,7 @@ LL +     let _ = U8::from(true);
    |
 
 error: casts from `bool` to `u8` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_bool.rs:53:13
+  --> tests/ui/cast_lossless_bool.rs:67:13
    |
 LL |     let _ = true as u8;
    |             ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_lossless_float.fixed b/src/tools/clippy/tests/ui/cast_lossless_float.fixed
index 163432631e13..6ddd5f10a2ca 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_float.fixed
+++ b/src/tools/clippy/tests/ui/cast_lossless_float.fixed
@@ -10,25 +10,38 @@ fn main() {
     // Test clippy::cast_lossless with casts to floating-point types
     let x0 = 1i8;
     let _ = f32::from(x0);
+    //~^ cast_lossless
     let _ = f64::from(x0);
+    //~^ cast_lossless
     let _ = F32::from(x0);
+    //~^ cast_lossless
     let _ = F64::from(x0);
+    //~^ cast_lossless
     let x1 = 1u8;
     let _ = f32::from(x1);
+    //~^ cast_lossless
     let _ = f64::from(x1);
+    //~^ cast_lossless
     let x2 = 1i16;
     let _ = f32::from(x2);
+    //~^ cast_lossless
     let _ = f64::from(x2);
+    //~^ cast_lossless
     let x3 = 1u16;
     let _ = f32::from(x3);
+    //~^ cast_lossless
     let _ = f64::from(x3);
+    //~^ cast_lossless
     let x4 = 1i32;
     let _ = f64::from(x4);
+    //~^ cast_lossless
     let x5 = 1u32;
     let _ = f64::from(x5);
+    //~^ cast_lossless
 
     // Test with casts from floating-point types
     let _ = f64::from(1.0f32);
+    //~^ cast_lossless
 }
 
 // The lint would suggest using `f64::from(input)` here but the `XX::from` function is not const,
diff --git a/src/tools/clippy/tests/ui/cast_lossless_float.rs b/src/tools/clippy/tests/ui/cast_lossless_float.rs
index afb2a3d890ee..fe5a90544538 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_float.rs
+++ b/src/tools/clippy/tests/ui/cast_lossless_float.rs
@@ -10,25 +10,38 @@ fn main() {
     // Test clippy::cast_lossless with casts to floating-point types
     let x0 = 1i8;
     let _ = x0 as f32;
+    //~^ cast_lossless
     let _ = x0 as f64;
+    //~^ cast_lossless
     let _ = x0 as F32;
+    //~^ cast_lossless
     let _ = x0 as F64;
+    //~^ cast_lossless
     let x1 = 1u8;
     let _ = x1 as f32;
+    //~^ cast_lossless
     let _ = x1 as f64;
+    //~^ cast_lossless
     let x2 = 1i16;
     let _ = x2 as f32;
+    //~^ cast_lossless
     let _ = x2 as f64;
+    //~^ cast_lossless
     let x3 = 1u16;
     let _ = x3 as f32;
+    //~^ cast_lossless
     let _ = x3 as f64;
+    //~^ cast_lossless
     let x4 = 1i32;
     let _ = x4 as f64;
+    //~^ cast_lossless
     let x5 = 1u32;
     let _ = x5 as f64;
+    //~^ cast_lossless
 
     // Test with casts from floating-point types
     let _ = 1.0f32 as f64;
+    //~^ cast_lossless
 }
 
 // The lint would suggest using `f64::from(input)` here but the `XX::from` function is not const,
diff --git a/src/tools/clippy/tests/ui/cast_lossless_float.stderr b/src/tools/clippy/tests/ui/cast_lossless_float.stderr
index 3f405e3f402f..35ae38b1d36a 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_float.stderr
+++ b/src/tools/clippy/tests/ui/cast_lossless_float.stderr
@@ -14,7 +14,7 @@ LL +     let _ = f32::from(x0);
    |
 
 error: casts from `i8` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:13:13
+  --> tests/ui/cast_lossless_float.rs:14:13
    |
 LL |     let _ = x0 as f64;
    |             ^^^^^^^^^
@@ -27,7 +27,7 @@ LL +     let _ = f64::from(x0);
    |
 
 error: casts from `i8` to `f32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:14:13
+  --> tests/ui/cast_lossless_float.rs:16:13
    |
 LL |     let _ = x0 as F32;
    |             ^^^^^^^^^
@@ -40,7 +40,7 @@ LL +     let _ = F32::from(x0);
    |
 
 error: casts from `i8` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:15:13
+  --> tests/ui/cast_lossless_float.rs:18:13
    |
 LL |     let _ = x0 as F64;
    |             ^^^^^^^^^
@@ -53,7 +53,7 @@ LL +     let _ = F64::from(x0);
    |
 
 error: casts from `u8` to `f32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:17:13
+  --> tests/ui/cast_lossless_float.rs:21:13
    |
 LL |     let _ = x1 as f32;
    |             ^^^^^^^^^
@@ -66,7 +66,7 @@ LL +     let _ = f32::from(x1);
    |
 
 error: casts from `u8` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:18:13
+  --> tests/ui/cast_lossless_float.rs:23:13
    |
 LL |     let _ = x1 as f64;
    |             ^^^^^^^^^
@@ -79,7 +79,7 @@ LL +     let _ = f64::from(x1);
    |
 
 error: casts from `i16` to `f32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:20:13
+  --> tests/ui/cast_lossless_float.rs:26:13
    |
 LL |     let _ = x2 as f32;
    |             ^^^^^^^^^
@@ -92,7 +92,7 @@ LL +     let _ = f32::from(x2);
    |
 
 error: casts from `i16` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:21:13
+  --> tests/ui/cast_lossless_float.rs:28:13
    |
 LL |     let _ = x2 as f64;
    |             ^^^^^^^^^
@@ -105,7 +105,7 @@ LL +     let _ = f64::from(x2);
    |
 
 error: casts from `u16` to `f32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:23:13
+  --> tests/ui/cast_lossless_float.rs:31:13
    |
 LL |     let _ = x3 as f32;
    |             ^^^^^^^^^
@@ -118,7 +118,7 @@ LL +     let _ = f32::from(x3);
    |
 
 error: casts from `u16` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:24:13
+  --> tests/ui/cast_lossless_float.rs:33:13
    |
 LL |     let _ = x3 as f64;
    |             ^^^^^^^^^
@@ -131,7 +131,7 @@ LL +     let _ = f64::from(x3);
    |
 
 error: casts from `i32` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:26:13
+  --> tests/ui/cast_lossless_float.rs:36:13
    |
 LL |     let _ = x4 as f64;
    |             ^^^^^^^^^
@@ -144,7 +144,7 @@ LL +     let _ = f64::from(x4);
    |
 
 error: casts from `u32` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:28:13
+  --> tests/ui/cast_lossless_float.rs:39:13
    |
 LL |     let _ = x5 as f64;
    |             ^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let _ = f64::from(x5);
    |
 
 error: casts from `f32` to `f64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_float.rs:31:13
+  --> tests/ui/cast_lossless_float.rs:43:13
    |
 LL |     let _ = 1.0f32 as f64;
    |             ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_lossless_integer.fixed b/src/tools/clippy/tests/ui/cast_lossless_integer.fixed
index cdb065678368..2af2dbd1282d 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_integer.fixed
+++ b/src/tools/clippy/tests/ui/cast_lossless_integer.fixed
@@ -7,66 +7,88 @@ fn main() {
     // Test clippy::cast_lossless with casts to integer types
     u16::from(0u8);
     //~^ cast_lossless
+
     i16::from(0u8);
     //~^ cast_lossless
+
     u32::from(0u8);
     //~^ cast_lossless
+
     i32::from(0u8);
     //~^ cast_lossless
+
     u64::from(0u8);
     //~^ cast_lossless
+
     i64::from(0u8);
     //~^ cast_lossless
+
     u128::from(0u8);
     //~^ cast_lossless
+
     i128::from(0u8);
     //~^ cast_lossless
 
     u32::from(0u16);
     //~^ cast_lossless
+
     i32::from(0u16);
     //~^ cast_lossless
+
     u64::from(0u16);
     //~^ cast_lossless
+
     i64::from(0u16);
     //~^ cast_lossless
+
     u128::from(0u16);
     //~^ cast_lossless
+
     i128::from(0u16);
     //~^ cast_lossless
 
     u64::from(0u32);
     //~^ cast_lossless
+
     i64::from(0u32);
     //~^ cast_lossless
+
     u128::from(0u32);
     //~^ cast_lossless
+
     i128::from(0u32);
     //~^ cast_lossless
 
     u128::from(0u64);
     //~^ cast_lossless
+
     i128::from(0u64);
     //~^ cast_lossless
 
     i16::from(0i8);
     //~^ cast_lossless
+
     i32::from(0i8);
     //~^ cast_lossless
+
     i64::from(0i8);
     //~^ cast_lossless
+
     i128::from(0i8);
     //~^ cast_lossless
 
     i32::from(0i16);
     //~^ cast_lossless
+
     i64::from(0i16);
     //~^ cast_lossless
+
     i128::from(0i16);
     //~^ cast_lossless
 
     i64::from(0i32);
     //~^ cast_lossless
+
     i128::from(0i32);
     //~^ cast_lossless
 
@@ -82,10 +104,13 @@ fn main() {
 
     let _: u16 = 0u8.into();
     //~^ cast_lossless
+
     let _: i16 = (-1i8).into();
     //~^ cast_lossless
+
     let _: u16 = (1u8 + 2).into();
     //~^ cast_lossless
+
     let _: u32 = (1i8 as u16).into();
     //~^ cast_lossless
 }
@@ -123,6 +148,7 @@ fn issue11458() {
     let x = 10_u128;
     let _ = i32::from(sign_cast!(x, u8, i8));
     //~^ cast_lossless
+
     let _ = i32::from(sign_cast!(x, u8, i8) + 1);
     //~^ cast_lossless
 }
@@ -146,6 +172,7 @@ fn ty_from_macro() {
     }
 
     let _ = <ty!()>::from(0u8);
+    //~^ cast_lossless
 }
 
 const IN_CONST: u64 = 0u8 as u64;
diff --git a/src/tools/clippy/tests/ui/cast_lossless_integer.rs b/src/tools/clippy/tests/ui/cast_lossless_integer.rs
index 1f510b1a3036..c65b725bb729 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_integer.rs
+++ b/src/tools/clippy/tests/ui/cast_lossless_integer.rs
@@ -7,66 +7,88 @@ fn main() {
     // Test clippy::cast_lossless with casts to integer types
     0u8 as u16;
     //~^ cast_lossless
+
     0u8 as i16;
     //~^ cast_lossless
+
     0u8 as u32;
     //~^ cast_lossless
+
     0u8 as i32;
     //~^ cast_lossless
+
     0u8 as u64;
     //~^ cast_lossless
+
     0u8 as i64;
     //~^ cast_lossless
+
     0u8 as u128;
     //~^ cast_lossless
+
     0u8 as i128;
     //~^ cast_lossless
 
     0u16 as u32;
     //~^ cast_lossless
+
     0u16 as i32;
     //~^ cast_lossless
+
     0u16 as u64;
     //~^ cast_lossless
+
     0u16 as i64;
     //~^ cast_lossless
+
     0u16 as u128;
     //~^ cast_lossless
+
     0u16 as i128;
     //~^ cast_lossless
 
     0u32 as u64;
     //~^ cast_lossless
+
     0u32 as i64;
     //~^ cast_lossless
+
     0u32 as u128;
     //~^ cast_lossless
+
     0u32 as i128;
     //~^ cast_lossless
 
     0u64 as u128;
     //~^ cast_lossless
+
     0u64 as i128;
     //~^ cast_lossless
 
     0i8 as i16;
     //~^ cast_lossless
+
     0i8 as i32;
     //~^ cast_lossless
+
     0i8 as i64;
     //~^ cast_lossless
+
     0i8 as i128;
     //~^ cast_lossless
 
     0i16 as i32;
     //~^ cast_lossless
+
     0i16 as i64;
     //~^ cast_lossless
+
     0i16 as i128;
     //~^ cast_lossless
 
     0i32 as i64;
     //~^ cast_lossless
+
     0i32 as i128;
     //~^ cast_lossless
 
@@ -82,10 +104,13 @@ fn main() {
 
     let _: u16 = 0u8 as _;
     //~^ cast_lossless
+
     let _: i16 = -1i8 as _;
     //~^ cast_lossless
+
     let _: u16 = (1u8 + 2) as _;
     //~^ cast_lossless
+
     let _: u32 = 1i8 as u16 as _;
     //~^ cast_lossless
 }
@@ -123,6 +148,7 @@ fn issue11458() {
     let x = 10_u128;
     let _ = sign_cast!(x, u8, i8) as i32;
     //~^ cast_lossless
+
     let _ = (sign_cast!(x, u8, i8) + 1) as i32;
     //~^ cast_lossless
 }
@@ -146,6 +172,7 @@ fn ty_from_macro() {
     }
 
     let _ = 0u8 as ty!();
+    //~^ cast_lossless
 }
 
 const IN_CONST: u64 = 0u8 as u64;
diff --git a/src/tools/clippy/tests/ui/cast_lossless_integer.stderr b/src/tools/clippy/tests/ui/cast_lossless_integer.stderr
index d2580913bb54..9852eca71279 100644
--- a/src/tools/clippy/tests/ui/cast_lossless_integer.stderr
+++ b/src/tools/clippy/tests/ui/cast_lossless_integer.stderr
@@ -14,7 +14,7 @@ LL +     u16::from(0u8);
    |
 
 error: casts from `u8` to `i16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:10:5
+  --> tests/ui/cast_lossless_integer.rs:11:5
    |
 LL |     0u8 as i16;
    |     ^^^^^^^^^^
@@ -27,7 +27,7 @@ LL +     i16::from(0u8);
    |
 
 error: casts from `u8` to `u32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:12:5
+  --> tests/ui/cast_lossless_integer.rs:14:5
    |
 LL |     0u8 as u32;
    |     ^^^^^^^^^^
@@ -40,7 +40,7 @@ LL +     u32::from(0u8);
    |
 
 error: casts from `u8` to `i32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:14:5
+  --> tests/ui/cast_lossless_integer.rs:17:5
    |
 LL |     0u8 as i32;
    |     ^^^^^^^^^^
@@ -53,7 +53,7 @@ LL +     i32::from(0u8);
    |
 
 error: casts from `u8` to `u64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:16:5
+  --> tests/ui/cast_lossless_integer.rs:20:5
    |
 LL |     0u8 as u64;
    |     ^^^^^^^^^^
@@ -66,7 +66,7 @@ LL +     u64::from(0u8);
    |
 
 error: casts from `u8` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:18:5
+  --> tests/ui/cast_lossless_integer.rs:23:5
    |
 LL |     0u8 as i64;
    |     ^^^^^^^^^^
@@ -79,7 +79,7 @@ LL +     i64::from(0u8);
    |
 
 error: casts from `u8` to `u128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:20:5
+  --> tests/ui/cast_lossless_integer.rs:26:5
    |
 LL |     0u8 as u128;
    |     ^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL +     u128::from(0u8);
    |
 
 error: casts from `u8` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:22:5
+  --> tests/ui/cast_lossless_integer.rs:29:5
    |
 LL |     0u8 as i128;
    |     ^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL +     i128::from(0u8);
    |
 
 error: casts from `u16` to `u32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:25:5
+  --> tests/ui/cast_lossless_integer.rs:32:5
    |
 LL |     0u16 as u32;
    |     ^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL +     u32::from(0u16);
    |
 
 error: casts from `u16` to `i32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:27:5
+  --> tests/ui/cast_lossless_integer.rs:35:5
    |
 LL |     0u16 as i32;
    |     ^^^^^^^^^^^
@@ -131,7 +131,7 @@ LL +     i32::from(0u16);
    |
 
 error: casts from `u16` to `u64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:29:5
+  --> tests/ui/cast_lossless_integer.rs:38:5
    |
 LL |     0u16 as u64;
    |     ^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL +     u64::from(0u16);
    |
 
 error: casts from `u16` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:31:5
+  --> tests/ui/cast_lossless_integer.rs:41:5
    |
 LL |     0u16 as i64;
    |     ^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     i64::from(0u16);
    |
 
 error: casts from `u16` to `u128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:33:5
+  --> tests/ui/cast_lossless_integer.rs:44:5
    |
 LL |     0u16 as u128;
    |     ^^^^^^^^^^^^
@@ -170,7 +170,7 @@ LL +     u128::from(0u16);
    |
 
 error: casts from `u16` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:35:5
+  --> tests/ui/cast_lossless_integer.rs:47:5
    |
 LL |     0u16 as i128;
    |     ^^^^^^^^^^^^
@@ -183,7 +183,7 @@ LL +     i128::from(0u16);
    |
 
 error: casts from `u32` to `u64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:38:5
+  --> tests/ui/cast_lossless_integer.rs:50:5
    |
 LL |     0u32 as u64;
    |     ^^^^^^^^^^^
@@ -196,7 +196,7 @@ LL +     u64::from(0u32);
    |
 
 error: casts from `u32` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:40:5
+  --> tests/ui/cast_lossless_integer.rs:53:5
    |
 LL |     0u32 as i64;
    |     ^^^^^^^^^^^
@@ -209,7 +209,7 @@ LL +     i64::from(0u32);
    |
 
 error: casts from `u32` to `u128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:42:5
+  --> tests/ui/cast_lossless_integer.rs:56:5
    |
 LL |     0u32 as u128;
    |     ^^^^^^^^^^^^
@@ -222,7 +222,7 @@ LL +     u128::from(0u32);
    |
 
 error: casts from `u32` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:44:5
+  --> tests/ui/cast_lossless_integer.rs:59:5
    |
 LL |     0u32 as i128;
    |     ^^^^^^^^^^^^
@@ -235,7 +235,7 @@ LL +     i128::from(0u32);
    |
 
 error: casts from `u64` to `u128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:47:5
+  --> tests/ui/cast_lossless_integer.rs:62:5
    |
 LL |     0u64 as u128;
    |     ^^^^^^^^^^^^
@@ -248,7 +248,7 @@ LL +     u128::from(0u64);
    |
 
 error: casts from `u64` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:49:5
+  --> tests/ui/cast_lossless_integer.rs:65:5
    |
 LL |     0u64 as i128;
    |     ^^^^^^^^^^^^
@@ -261,7 +261,7 @@ LL +     i128::from(0u64);
    |
 
 error: casts from `i8` to `i16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:52:5
+  --> tests/ui/cast_lossless_integer.rs:68:5
    |
 LL |     0i8 as i16;
    |     ^^^^^^^^^^
@@ -274,7 +274,7 @@ LL +     i16::from(0i8);
    |
 
 error: casts from `i8` to `i32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:54:5
+  --> tests/ui/cast_lossless_integer.rs:71:5
    |
 LL |     0i8 as i32;
    |     ^^^^^^^^^^
@@ -287,7 +287,7 @@ LL +     i32::from(0i8);
    |
 
 error: casts from `i8` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:56:5
+  --> tests/ui/cast_lossless_integer.rs:74:5
    |
 LL |     0i8 as i64;
    |     ^^^^^^^^^^
@@ -300,7 +300,7 @@ LL +     i64::from(0i8);
    |
 
 error: casts from `i8` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:58:5
+  --> tests/ui/cast_lossless_integer.rs:77:5
    |
 LL |     0i8 as i128;
    |     ^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL +     i128::from(0i8);
    |
 
 error: casts from `i16` to `i32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:61:5
+  --> tests/ui/cast_lossless_integer.rs:80:5
    |
 LL |     0i16 as i32;
    |     ^^^^^^^^^^^
@@ -326,7 +326,7 @@ LL +     i32::from(0i16);
    |
 
 error: casts from `i16` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:63:5
+  --> tests/ui/cast_lossless_integer.rs:83:5
    |
 LL |     0i16 as i64;
    |     ^^^^^^^^^^^
@@ -339,7 +339,7 @@ LL +     i64::from(0i16);
    |
 
 error: casts from `i16` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:65:5
+  --> tests/ui/cast_lossless_integer.rs:86:5
    |
 LL |     0i16 as i128;
    |     ^^^^^^^^^^^^
@@ -352,7 +352,7 @@ LL +     i128::from(0i16);
    |
 
 error: casts from `i32` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:68:5
+  --> tests/ui/cast_lossless_integer.rs:89:5
    |
 LL |     0i32 as i64;
    |     ^^^^^^^^^^^
@@ -365,7 +365,7 @@ LL +     i64::from(0i32);
    |
 
 error: casts from `i32` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:70:5
+  --> tests/ui/cast_lossless_integer.rs:92:5
    |
 LL |     0i32 as i128;
    |     ^^^^^^^^^^^^
@@ -378,7 +378,7 @@ LL +     i128::from(0i32);
    |
 
 error: casts from `i64` to `i128` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:73:5
+  --> tests/ui/cast_lossless_integer.rs:95:5
    |
 LL |     0i64 as i128;
    |     ^^^^^^^^^^^^
@@ -391,7 +391,7 @@ LL +     i128::from(0i64);
    |
 
 error: casts from `u8` to `u16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:77:13
+  --> tests/ui/cast_lossless_integer.rs:99:13
    |
 LL |     let _ = (1u8 + 1u8) as u16;
    |             ^^^^^^^^^^^^^^^^^^
@@ -404,7 +404,7 @@ LL +     let _ = u16::from(1u8 + 1u8);
    |
 
 error: casts from `i8` to `i64` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:80:13
+  --> tests/ui/cast_lossless_integer.rs:102:13
    |
 LL |     let _ = 1i8 as I64Alias;
    |             ^^^^^^^^^^^^^^^
@@ -417,7 +417,7 @@ LL +     let _ = I64Alias::from(1i8);
    |
 
 error: casts from `u8` to `u16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:83:18
+  --> tests/ui/cast_lossless_integer.rs:105:18
    |
 LL |     let _: u16 = 0u8 as _;
    |                  ^^^^^^^^
@@ -430,7 +430,7 @@ LL +     let _: u16 = 0u8.into();
    |
 
 error: casts from `i8` to `i16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:85:18
+  --> tests/ui/cast_lossless_integer.rs:108:18
    |
 LL |     let _: i16 = -1i8 as _;
    |                  ^^^^^^^^^
@@ -443,7 +443,7 @@ LL +     let _: i16 = (-1i8).into();
    |
 
 error: casts from `u8` to `u16` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:87:18
+  --> tests/ui/cast_lossless_integer.rs:111:18
    |
 LL |     let _: u16 = (1u8 + 2) as _;
    |                  ^^^^^^^^^^^^^^
@@ -456,7 +456,7 @@ LL +     let _: u16 = (1u8 + 2).into();
    |
 
 error: casts from `u16` to `u32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:89:18
+  --> tests/ui/cast_lossless_integer.rs:114:18
    |
 LL |     let _: u32 = 1i8 as u16 as _;
    |                  ^^^^^^^^^^^^^^^
@@ -469,7 +469,7 @@ LL +     let _: u32 = (1i8 as u16).into();
    |
 
 error: casts from `i8` to `i32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:124:13
+  --> tests/ui/cast_lossless_integer.rs:149:13
    |
 LL |     let _ = sign_cast!(x, u8, i8) as i32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -482,7 +482,7 @@ LL +     let _ = i32::from(sign_cast!(x, u8, i8));
    |
 
 error: casts from `i8` to `i32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:126:13
+  --> tests/ui/cast_lossless_integer.rs:152:13
    |
 LL |     let _ = (sign_cast!(x, u8, i8) + 1) as i32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -495,7 +495,7 @@ LL +     let _ = i32::from(sign_cast!(x, u8, i8) + 1);
    |
 
 error: casts from `u8` to `u32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:133:13
+  --> tests/ui/cast_lossless_integer.rs:159:13
    |
 LL |             1u8 as u32
    |             ^^^^^^^^^^
@@ -512,7 +512,7 @@ LL +             u32::from(1u8)
    |
 
 error: casts from `u8` to `u32` can be expressed infallibly using `From`
-  --> tests/ui/cast_lossless_integer.rs:148:13
+  --> tests/ui/cast_lossless_integer.rs:174:13
    |
 LL |     let _ = 0u8 as ty!();
    |             ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_nan_to_int.rs b/src/tools/clippy/tests/ui/cast_nan_to_int.rs
index aee38da9a159..72e61b3542e2 100644
--- a/src/tools/clippy/tests/ui/cast_nan_to_int.rs
+++ b/src/tools/clippy/tests/ui/cast_nan_to_int.rs
@@ -5,24 +5,22 @@
 
 fn main() {
     let _ = (0.0_f32 / -0.0) as usize;
-    //~^ ERROR: casting a known NaN to usize
-    //~| NOTE: this always evaluates to 0
+    //~^ cast_nan_to_int
+
     let _ = (f64::INFINITY * -0.0) as usize;
-    //~^ ERROR: casting a known NaN to usize
-    //~| NOTE: this always evaluates to 0
+    //~^ cast_nan_to_int
+
     let _ = (0.0 * f32::INFINITY) as usize;
-    //~^ ERROR: casting a known NaN to usize
-    //~| NOTE: this always evaluates to 0
+    //~^ cast_nan_to_int
 
     let _ = (f64::INFINITY + f64::NEG_INFINITY) as usize;
-    //~^ ERROR: casting a known NaN to usize
-    //~| NOTE: this always evaluates to 0
+    //~^ cast_nan_to_int
+
     let _ = (f32::INFINITY - f32::INFINITY) as usize;
-    //~^ ERROR: casting a known NaN to usize
-    //~| NOTE: this always evaluates to 0
+    //~^ cast_nan_to_int
+
     let _ = (f32::INFINITY / f32::NEG_INFINITY) as usize;
-    //~^ ERROR: casting a known NaN to usize
-    //~| NOTE: this always evaluates to 0
+    //~^ cast_nan_to_int
 
     // those won't be linted:
     let _ = (1.0_f32 / 0.0) as usize;
diff --git a/src/tools/clippy/tests/ui/cast_nan_to_int.stderr b/src/tools/clippy/tests/ui/cast_nan_to_int.stderr
index 3aeb2d545251..15ca3876ea18 100644
--- a/src/tools/clippy/tests/ui/cast_nan_to_int.stderr
+++ b/src/tools/clippy/tests/ui/cast_nan_to_int.stderr
@@ -25,7 +25,7 @@ LL |     let _ = (0.0 * f32::INFINITY) as usize;
    = note: this always evaluates to 0
 
 error: casting a known NaN to usize
-  --> tests/ui/cast_nan_to_int.rs:17:13
+  --> tests/ui/cast_nan_to_int.rs:16:13
    |
 LL |     let _ = (f64::INFINITY + f64::NEG_INFINITY) as usize;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     let _ = (f64::INFINITY + f64::NEG_INFINITY) as usize;
    = note: this always evaluates to 0
 
 error: casting a known NaN to usize
-  --> tests/ui/cast_nan_to_int.rs:20:13
+  --> tests/ui/cast_nan_to_int.rs:19:13
    |
 LL |     let _ = (f32::INFINITY - f32::INFINITY) as usize;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     let _ = (f32::INFINITY - f32::INFINITY) as usize;
    = note: this always evaluates to 0
 
 error: casting a known NaN to usize
-  --> tests/ui/cast_nan_to_int.rs:23:13
+  --> tests/ui/cast_nan_to_int.rs:22:13
    |
 LL |     let _ = (f32::INFINITY / f32::NEG_INFINITY) as usize;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.fixed b/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.fixed
index e78bd66c3cb5..bddcb0ebf64e 100644
--- a/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.fixed
+++ b/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.fixed
@@ -6,18 +6,25 @@ fn main() {
     let ptr: *const u8 = vec.as_ptr();
     let mptr = vec.as_mut_ptr();
     let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts(ptr, 1) };
+    //~^ cast_slice_from_raw_parts
     let _: *const [u8] = unsafe { core::ptr::slice_from_raw_parts_mut(mptr, 1) };
+    //~^ cast_slice_from_raw_parts
     let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+    //~^ cast_slice_from_raw_parts
     {
         use core::slice;
         let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
         use slice as one;
         let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
     }
     {
         use std::slice;
         let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
         use slice as one;
         let _: *const [u8] = core::ptr::slice_from_raw_parts(ptr, 1);
+        //~^ cast_slice_from_raw_parts
     }
 }
diff --git a/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.rs b/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.rs
index c3d8c7bee989..0a1eb276d5e9 100644
--- a/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.rs
+++ b/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.rs
@@ -6,18 +6,25 @@ fn main() {
     let ptr: *const u8 = vec.as_ptr();
     let mptr = vec.as_mut_ptr();
     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *const [u8] };
+    //~^ cast_slice_from_raw_parts
     let _: *const [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
+    //~^ cast_slice_from_raw_parts
     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) } as *const [u8];
+    //~^ cast_slice_from_raw_parts
     {
         use core::slice;
         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
         use slice as one;
         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
     }
     {
         use std::slice;
         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
         use slice as one;
         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
+        //~^ cast_slice_from_raw_parts
     }
 }
diff --git a/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.stderr b/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.stderr
index 2aedd320a428..60794a988db7 100644
--- a/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.stderr
+++ b/src/tools/clippy/tests/ui/cast_raw_slice_pointer_cast.stderr
@@ -8,37 +8,37 @@ LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) as *co
    = help: to override `-D warnings` add `#[allow(clippy::cast_slice_from_raw_parts)]`
 
 error: casting the result of `from_raw_parts_mut` to *mut [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:9:35
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:10:35
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts_mut(mptr, 1) as *mut [u8] };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts_mut(mptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:10:26
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:12:26
    |
 LL |     let _: *const [u8] = unsafe { std::slice::from_raw_parts(ptr, 1) } as *const [u8];
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:13:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:16:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:15:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:19:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:19:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:24:30
    |
 LL |         let _: *const [u8] = unsafe { slice::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
 
 error: casting the result of `from_raw_parts` to *const [u8]
-  --> tests/ui/cast_raw_slice_pointer_cast.rs:21:30
+  --> tests/ui/cast_raw_slice_pointer_cast.rs:27:30
    |
 LL |         let _: *const [u8] = unsafe { one::from_raw_parts(ptr, 1) } as *const [u8];
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `core::ptr::slice_from_raw_parts(ptr, 1)`
diff --git a/src/tools/clippy/tests/ui/cast_size.32bit.stderr b/src/tools/clippy/tests/ui/cast_size.32bit.stderr
index 8ff3464676c3..cb1620e36a26 100644
--- a/src/tools/clippy/tests/ui/cast_size.32bit.stderr
+++ b/src/tools/clippy/tests/ui/cast_size.32bit.stderr
@@ -1,5 +1,5 @@
 error: casting `isize` to `i8` may truncate the value
-  --> tests/ui/cast_size.rs:15:5
+  --> tests/ui/cast_size.rs:17:5
    |
 LL |     1isize as i8;
    |     ^^^^^^^^^^^^
@@ -9,11 +9,12 @@ LL |     1isize as i8;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_truncation)]`
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     i8::try_from(1isize);
-   |     ~~~~~~~~~~~~~~~~~~~~
+LL -     1isize as i8;
+LL +     i8::try_from(1isize);
+   |
 
 error: casting `isize` to `f32` causes a loss of precision (`isize` is 32 or 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:21:5
+  --> tests/ui/cast_size.rs:24:5
    |
 LL |     x0 as f32;
    |     ^^^^^^^^^
@@ -22,25 +23,25 @@ LL |     x0 as f32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_precision_loss)]`
 
 error: casting `usize` to `f32` causes a loss of precision (`usize` is 32 or 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:22:5
+  --> tests/ui/cast_size.rs:26:5
    |
 LL |     x1 as f32;
    |     ^^^^^^^^^
 
 error: casting `isize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`isize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:23:5
+  --> tests/ui/cast_size.rs:28:5
    |
 LL |     x0 as f64;
    |     ^^^^^^^^^
 
 error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:24:5
+  --> tests/ui/cast_size.rs:30:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^
 
 error: casting `isize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:28:5
+  --> tests/ui/cast_size.rs:35:5
    |
 LL |     1isize as i32;
    |     ^^^^^^^^^^^^^
@@ -48,11 +49,12 @@ LL |     1isize as i32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     i32::try_from(1isize);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1isize as i32;
+LL +     i32::try_from(1isize);
+   |
 
 error: casting `isize` to `u32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:29:5
+  --> tests/ui/cast_size.rs:37:5
    |
 LL |     1isize as u32;
    |     ^^^^^^^^^^^^^
@@ -60,11 +62,12 @@ LL |     1isize as u32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     u32::try_from(1isize);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1isize as u32;
+LL +     u32::try_from(1isize);
+   |
 
 error: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:30:5
+  --> tests/ui/cast_size.rs:39:5
    |
 LL |     1usize as u32;
    |     ^^^^^^^^^^^^^
@@ -72,11 +75,12 @@ LL |     1usize as u32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     u32::try_from(1usize);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1usize as u32;
+LL +     u32::try_from(1usize);
+   |
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:31:5
+  --> tests/ui/cast_size.rs:41:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -84,11 +88,12 @@ LL |     1usize as i32;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     i32::try_from(1usize);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1usize as i32;
+LL +     i32::try_from(1usize);
+   |
 
 error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:31:5
+  --> tests/ui/cast_size.rs:41:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -97,7 +102,7 @@ LL |     1usize as i32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
 
 error: casting `i64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:32:5
+  --> tests/ui/cast_size.rs:44:5
    |
 LL |     1i64 as isize;
    |     ^^^^^^^^^^^^^
@@ -105,11 +110,12 @@ LL |     1i64 as isize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     isize::try_from(1i64);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1i64 as isize;
+LL +     isize::try_from(1i64);
+   |
 
 error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:33:5
+  --> tests/ui/cast_size.rs:46:5
    |
 LL |     1i64 as usize;
    |     ^^^^^^^^^^^^^
@@ -117,11 +123,12 @@ LL |     1i64 as usize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     usize::try_from(1i64);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1i64 as usize;
+LL +     usize::try_from(1i64);
+   |
 
 error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:34:5
+  --> tests/ui/cast_size.rs:48:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
@@ -129,17 +136,18 @@ LL |     1u64 as isize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     isize::try_from(1u64);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1u64 as isize;
+LL +     isize::try_from(1u64);
+   |
 
 error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:34:5
+  --> tests/ui/cast_size.rs:48:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:35:5
+  --> tests/ui/cast_size.rs:51:5
    |
 LL |     1u64 as usize;
    |     ^^^^^^^^^^^^^
@@ -147,29 +155,30 @@ LL |     1u64 as usize;
    = help: if this is intentional allow the lint with `#[allow(clippy::cast_possible_truncation)]` ...
 help: ... or use `try_from` and handle the error accordingly
    |
-LL |     usize::try_from(1u64);
-   |     ~~~~~~~~~~~~~~~~~~~~~
+LL -     1u64 as usize;
+LL +     usize::try_from(1u64);
+   |
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:36:5
+  --> tests/ui/cast_size.rs:53:5
    |
 LL |     1u32 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:43:5
+  --> tests/ui/cast_size.rs:61:5
    |
 LL |     999_999_999 as f32;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:44:5
+  --> tests/ui/cast_size.rs:63:5
    |
 LL |     9_999_999_999_999_999usize as f64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: literal out of range for `usize`
-  --> tests/ui/cast_size.rs:44:5
+  --> tests/ui/cast_size.rs:63:5
    |
 LL |     9_999_999_999_999_999usize as f64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_size.64bit.stderr b/src/tools/clippy/tests/ui/cast_size.64bit.stderr
index 6b9919f8a105..b6000a52abb3 100644
--- a/src/tools/clippy/tests/ui/cast_size.64bit.stderr
+++ b/src/tools/clippy/tests/ui/cast_size.64bit.stderr
@@ -1,5 +1,5 @@
 error: casting `isize` to `i8` may truncate the value
-  --> tests/ui/cast_size.rs:15:5
+  --> tests/ui/cast_size.rs:17:5
    |
 LL |     1isize as i8;
    |     ^^^^^^^^^^^^
@@ -14,7 +14,7 @@ LL +     i8::try_from(1isize);
    |
 
 error: casting `isize` to `f32` causes a loss of precision (`isize` is 32 or 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:21:5
+  --> tests/ui/cast_size.rs:24:5
    |
 LL |     x0 as f32;
    |     ^^^^^^^^^
@@ -23,25 +23,25 @@ LL |     x0 as f32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_precision_loss)]`
 
 error: casting `usize` to `f32` causes a loss of precision (`usize` is 32 or 64 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:22:5
+  --> tests/ui/cast_size.rs:26:5
    |
 LL |     x1 as f32;
    |     ^^^^^^^^^
 
 error: casting `isize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`isize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:23:5
+  --> tests/ui/cast_size.rs:28:5
    |
 LL |     x0 as f64;
    |     ^^^^^^^^^
 
 error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:24:5
+  --> tests/ui/cast_size.rs:30:5
    |
 LL |     x1 as f64;
    |     ^^^^^^^^^
 
 error: casting `isize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:28:5
+  --> tests/ui/cast_size.rs:35:5
    |
 LL |     1isize as i32;
    |     ^^^^^^^^^^^^^
@@ -54,7 +54,7 @@ LL +     i32::try_from(1isize);
    |
 
 error: casting `isize` to `u32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:29:5
+  --> tests/ui/cast_size.rs:37:5
    |
 LL |     1isize as u32;
    |     ^^^^^^^^^^^^^
@@ -67,7 +67,7 @@ LL +     u32::try_from(1isize);
    |
 
 error: casting `usize` to `u32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:30:5
+  --> tests/ui/cast_size.rs:39:5
    |
 LL |     1usize as u32;
    |     ^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL +     u32::try_from(1usize);
    |
 
 error: casting `usize` to `i32` may truncate the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:31:5
+  --> tests/ui/cast_size.rs:41:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -93,7 +93,7 @@ LL +     i32::try_from(1usize);
    |
 
 error: casting `usize` to `i32` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:31:5
+  --> tests/ui/cast_size.rs:41:5
    |
 LL |     1usize as i32;
    |     ^^^^^^^^^^^^^
@@ -102,7 +102,7 @@ LL |     1usize as i32;
    = help: to override `-D warnings` add `#[allow(clippy::cast_possible_wrap)]`
 
 error: casting `i64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:32:5
+  --> tests/ui/cast_size.rs:44:5
    |
 LL |     1i64 as isize;
    |     ^^^^^^^^^^^^^
@@ -115,7 +115,7 @@ LL +     isize::try_from(1i64);
    |
 
 error: casting `i64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:33:5
+  --> tests/ui/cast_size.rs:46:5
    |
 LL |     1i64 as usize;
    |     ^^^^^^^^^^^^^
@@ -128,7 +128,7 @@ LL +     usize::try_from(1i64);
    |
 
 error: casting `u64` to `isize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:34:5
+  --> tests/ui/cast_size.rs:48:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
@@ -141,13 +141,13 @@ LL +     isize::try_from(1u64);
    |
 
 error: casting `u64` to `isize` may wrap around the value on targets with 64-bit wide pointers
-  --> tests/ui/cast_size.rs:34:5
+  --> tests/ui/cast_size.rs:48:5
    |
 LL |     1u64 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `u64` to `usize` may truncate the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:35:5
+  --> tests/ui/cast_size.rs:51:5
    |
 LL |     1u64 as usize;
    |     ^^^^^^^^^^^^^
@@ -160,19 +160,19 @@ LL +     usize::try_from(1u64);
    |
 
 error: casting `u32` to `isize` may wrap around the value on targets with 32-bit wide pointers
-  --> tests/ui/cast_size.rs:36:5
+  --> tests/ui/cast_size.rs:53:5
    |
 LL |     1u32 as isize;
    |     ^^^^^^^^^^^^^
 
 error: casting `i32` to `f32` causes a loss of precision (`i32` is 32 bits wide, but `f32`'s mantissa is only 23 bits wide)
-  --> tests/ui/cast_size.rs:43:5
+  --> tests/ui/cast_size.rs:61:5
    |
 LL |     999_999_999 as f32;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: casting `usize` to `f64` causes a loss of precision on targets with 64-bit wide pointers (`usize` is 64 bits wide, but `f64`'s mantissa is only 52 bits wide)
-  --> tests/ui/cast_size.rs:44:5
+  --> tests/ui/cast_size.rs:63:5
    |
 LL |     9_999_999_999_999_999usize as f64;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cast_size.rs b/src/tools/clippy/tests/ui/cast_size.rs
index d0ed8e57d7ae..e92401808867 100644
--- a/src/tools/clippy/tests/ui/cast_size.rs
+++ b/src/tools/clippy/tests/ui/cast_size.rs
@@ -1,4 +1,6 @@
-//@stderr-per-bitwidth
+//@revisions: 32bit 64bit
+//@[32bit]ignore-bitwidth: 64
+//@[64bit]ignore-bitwidth: 32
 //@no-rustfix
 
 #![warn(
@@ -13,27 +15,43 @@
 fn main() {
     // Casting from *size
     1isize as i8;
+    //~^ cast_possible_truncation
     let x0 = 1isize;
     let x1 = 1usize;
     // FIXME(f16_f128): enable f16 and f128 conversions once const eval supports them
     // x0 as f16;
     // x1 as f16;
     x0 as f32;
+    //~^ cast_precision_loss
     x1 as f32;
+    //~^ cast_precision_loss
     x0 as f64;
+    //~^ cast_precision_loss
     x1 as f64;
+    //~^ cast_precision_loss
     // x0 as f128;
     // x1 as f128;
 
     1isize as i32;
+    //~^ cast_possible_truncation
     1isize as u32;
+    //~^ cast_possible_truncation
     1usize as u32;
+    //~^ cast_possible_truncation
     1usize as i32;
+    //~^ cast_possible_truncation
+    //~| cast_possible_wrap
     1i64 as isize;
+    //~^ cast_possible_truncation
     1i64 as usize;
+    //~^ cast_possible_truncation
     1u64 as isize;
+    //~^ cast_possible_truncation
+    //~| cast_possible_wrap
     1u64 as usize;
+    //~^ cast_possible_truncation
     1u32 as isize;
+    //~^ cast_possible_wrap
     1u32 as usize; // Should not trigger any lint
     1i32 as isize; // Neither should this
     1i32 as usize;
@@ -41,6 +59,9 @@ fn main() {
     // Big integer literal to float
     // 999_999 as f16;
     999_999_999 as f32;
+    //~^ cast_precision_loss
     9_999_999_999_999_999usize as f64;
+    //~^ cast_precision_loss
+    //~[32bit]^^ ERROR: literal out of range for `usize`
     // 999_999_999_999_999_999_999_999_999_999u128 as f128;
 }
diff --git a/src/tools/clippy/tests/ui/cast_slice_different_sizes.rs b/src/tools/clippy/tests/ui/cast_slice_different_sizes.rs
index d8101030a8a2..518ed77ab220 100644
--- a/src/tools/clippy/tests/ui/cast_slice_different_sizes.rs
+++ b/src/tools/clippy/tests/ui/cast_slice_different_sizes.rs
@@ -8,14 +8,14 @@ fn main() {
     // Because it's separate, it does not check the cast back to something of the same size
     let a = r_x as *const [i32];
     let b = a as *const [u8];
-    //~^ ERROR: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (eleme
-    //~| NOTE: `#[deny(clippy::cast_slice_different_sizes)]` on by default
+    //~^ cast_slice_different_sizes
+
     let c = b as *const [u32];
-    //~^ ERROR: casting between raw pointers to `[u8]` (element size 1) and `[u32]` (eleme
+    //~^ cast_slice_different_sizes
 
     // loses data
     let loss = r_x as *const [i32] as *const [u8];
-    //~^ ERROR: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (eleme
+    //~^ cast_slice_different_sizes
 
     // Cast back to same size but different type loses no data, just type conversion
     // This is weird code but there's no reason for this lint specifically to fire *twice* on it
@@ -23,9 +23,11 @@ fn main() {
 
     // Check casting through blocks is detected
     let loss_block_1 = { r_x as *const [i32] } as *const [u8];
-    //~^ ERROR: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (eleme
+    //~^ cast_slice_different_sizes
+
     let loss_block_2 = {
-        //~^ ERROR: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (eleme
+        //~^ cast_slice_different_sizes
+
         let _ = ();
         r_x as *const [i32]
     } as *const [u8];
@@ -43,7 +45,8 @@ fn main() {
 
     // Check that the result of a long chain of casts is detected
     let long_chain_loss = r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8];
-    //~^ ERROR: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (eleme
+    //~^ cast_slice_different_sizes
+
     let long_chain_restore =
         r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8] as *const [u32];
 }
@@ -59,40 +62,47 @@ fn foo2(x: *mut [u8]) -> *mut [u8] {
 
 // Test that casts as part of function returns work
 fn bar(x: *mut [u16]) -> *mut [u8] {
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element s
+    //~^ cast_slice_different_sizes
+
     x as *mut [u8]
 }
 
 fn uwu(x: *mut [u16]) -> *mut [u8] {
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element s
+    //~^ cast_slice_different_sizes
+
     x as *mut _
 }
 
 fn bar2(x: *mut [u16]) -> *mut [u8] {
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element s
+    //~^ cast_slice_different_sizes
+
     x as _
 }
 
 // constify
 fn bar3(x: *mut [u16]) -> *const [u8] {
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element s
+    //~^ cast_slice_different_sizes
+
     x as _
 }
 
 // unconstify
 fn bar4(x: *const [u16]) -> *mut [u8] {
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element s
+    //~^ cast_slice_different_sizes
+
     x as _
 }
 
 // function returns plus blocks
 fn blocks(x: *mut [u16]) -> *mut [u8] {
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element s
+    //~^ cast_slice_different_sizes
+
     ({ x }) as _
 }
 
 fn more_blocks(x: *mut [u16]) -> *mut [u8] {
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element s
+    //~^ cast_slice_different_sizes
+
     { ({ x }) as _ }
-    //~^ ERROR: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (eleme
+    //~^ cast_slice_different_sizes
 }
diff --git a/src/tools/clippy/tests/ui/cast_slice_different_sizes.stderr b/src/tools/clippy/tests/ui/cast_slice_different_sizes.stderr
index 625de4a8359b..307d37ac2ea8 100644
--- a/src/tools/clippy/tests/ui/cast_slice_different_sizes.stderr
+++ b/src/tools/clippy/tests/ui/cast_slice_different_sizes.stderr
@@ -25,11 +25,12 @@ LL |     let loss_block_1 = { r_x as *const [i32] } as *const [u8];
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts({ r_x as *const [i32] } as *const u8, ..)`
 
 error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:27:24
+  --> tests/ui/cast_slice_different_sizes.rs:28:24
    |
 LL |       let loss_block_2 = {
    |  ________________________^
 LL | |
+LL | |
 LL | |         let _ = ();
 LL | |         r_x as *const [i32]
 LL | |     } as *const [u8];
@@ -39,90 +40,98 @@ help: replace with `ptr::slice_from_raw_parts`
    |
 LL ~     let loss_block_2 = core::ptr::slice_from_raw_parts({
 LL +
+LL + 
 LL +         let _ = ();
 LL +         r_x as *const [i32]
 LL ~     } as *const u8, ..);
    |
 
 error: casting between raw pointers to `[i32]` (element size 4) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:45:27
+  --> tests/ui/cast_slice_different_sizes.rs:47:27
    |
 LL |     let long_chain_loss = r_x as *const [i32] as *const [u32] as *const [u16] as *const [i8] as *const [u8];
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(r_x as *const [i32] as *const u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:61:36
+  --> tests/ui/cast_slice_different_sizes.rs:64:36
    |
 LL |   fn bar(x: *mut [u16]) -> *mut [u8] {
    |  ____________________________________^
 LL | |
+LL | |
 LL | |     x as *mut [u8]
 LL | | }
    | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:66:36
+  --> tests/ui/cast_slice_different_sizes.rs:70:36
    |
 LL |   fn uwu(x: *mut [u16]) -> *mut [u8] {
    |  ____________________________________^
 LL | |
+LL | |
 LL | |     x as *mut _
 LL | | }
    | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:71:37
+  --> tests/ui/cast_slice_different_sizes.rs:76:37
    |
 LL |   fn bar2(x: *mut [u16]) -> *mut [u8] {
    |  _____________________________________^
 LL | |
+LL | |
 LL | |     x as _
 LL | | }
    | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:77:39
+  --> tests/ui/cast_slice_different_sizes.rs:83:39
    |
 LL |   fn bar3(x: *mut [u16]) -> *const [u8] {
    |  _______________________________________^
 LL | |
+LL | |
 LL | |     x as _
 LL | | }
    | |_^ help: replace with `ptr::slice_from_raw_parts`: `core::ptr::slice_from_raw_parts(x as *const u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:83:39
+  --> tests/ui/cast_slice_different_sizes.rs:90:39
    |
 LL |   fn bar4(x: *const [u16]) -> *mut [u8] {
    |  _______________________________________^
 LL | |
+LL | |
 LL | |     x as _
 LL | | }
    | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(x as *mut u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:89:39
+  --> tests/ui/cast_slice_different_sizes.rs:97:39
    |
 LL |   fn blocks(x: *mut [u16]) -> *mut [u8] {
    |  _______________________________________^
 LL | |
+LL | |
 LL | |     ({ x }) as _
 LL | | }
    | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:94:44
+  --> tests/ui/cast_slice_different_sizes.rs:103:44
    |
 LL |   fn more_blocks(x: *mut [u16]) -> *mut [u8] {
    |  ____________________________________________^
 LL | |
+LL | |
 LL | |     { ({ x }) as _ }
 LL | |
 LL | | }
    | |_^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut u8, ..)`
 
 error: casting between raw pointers to `[u16]` (element size 2) and `[u8]` (element size 1) does not adjust the count
-  --> tests/ui/cast_slice_different_sizes.rs:96:5
+  --> tests/ui/cast_slice_different_sizes.rs:106:5
    |
 LL |     { ({ x }) as _ }
    |     ^^^^^^^^^^^^^^^^ help: replace with `ptr::slice_from_raw_parts_mut`: `core::ptr::slice_from_raw_parts_mut(({ x }) as *mut u8, ..)`
diff --git a/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.fixed b/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.fixed
index 89815ffe9cbc..f55920db5503 100644
--- a/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.fixed
+++ b/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.fixed
@@ -1,13 +1,20 @@
 #![warn(clippy::deprecated_clippy_cfg_attr)]
 #![allow(clippy::non_minimal_cfg)]
-#![cfg_attr(clippy, doc = "a")] //~ ERROR: `feature = "cargo-clippy"` was
+#![cfg_attr(clippy, doc = "a")]
+//~^ deprecated_clippy_cfg_attr
 
-#[cfg_attr(clippy, derive(Debug))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg_attr(not(clippy), derive(Debug))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(clippy)] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(not(clippy))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(any(clippy))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(all(clippy))] //~ ERROR: `feature = "cargo-clippy"` was
+#[cfg_attr(clippy, derive(Debug))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg_attr(not(clippy), derive(Debug))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(clippy)]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(not(clippy))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(any(clippy))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(all(clippy))]
+//~^ deprecated_clippy_cfg_attr
 pub struct Bar;
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.rs b/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.rs
index 745f8957641e..faf36d98f2b3 100644
--- a/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.rs
+++ b/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.rs
@@ -1,13 +1,20 @@
 #![warn(clippy::deprecated_clippy_cfg_attr)]
 #![allow(clippy::non_minimal_cfg)]
-#![cfg_attr(feature = "cargo-clippy", doc = "a")] //~ ERROR: `feature = "cargo-clippy"` was
+#![cfg_attr(feature = "cargo-clippy", doc = "a")]
+//~^ deprecated_clippy_cfg_attr
 
-#[cfg_attr(feature = "cargo-clippy", derive(Debug))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg_attr(not(feature = "cargo-clippy"), derive(Debug))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(feature = "cargo-clippy")] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(not(feature = "cargo-clippy"))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(any(feature = "cargo-clippy"))] //~ ERROR: `feature = "cargo-clippy"` was
-#[cfg(all(feature = "cargo-clippy"))] //~ ERROR: `feature = "cargo-clippy"` was
+#[cfg_attr(feature = "cargo-clippy", derive(Debug))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg_attr(not(feature = "cargo-clippy"), derive(Debug))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(feature = "cargo-clippy")]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(not(feature = "cargo-clippy"))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(any(feature = "cargo-clippy"))]
+//~^ deprecated_clippy_cfg_attr
+#[cfg(all(feature = "cargo-clippy"))]
+//~^ deprecated_clippy_cfg_attr
 pub struct Bar;
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.stderr b/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.stderr
index 0a358f1a6847..4f5c39b78415 100644
--- a/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.stderr
+++ b/src/tools/clippy/tests/ui/cfg_attr_cargo_clippy.stderr
@@ -8,37 +8,37 @@ LL | #![cfg_attr(feature = "cargo-clippy", doc = "a")]
    = help: to override `-D warnings` add `#[allow(clippy::deprecated_clippy_cfg_attr)]`
 
 error: `feature = "cargo-clippy"` was replaced by `clippy`
-  --> tests/ui/cfg_attr_cargo_clippy.rs:5:12
+  --> tests/ui/cfg_attr_cargo_clippy.rs:6:12
    |
 LL | #[cfg_attr(feature = "cargo-clippy", derive(Debug))]
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `clippy`
 
 error: `feature = "cargo-clippy"` was replaced by `clippy`
-  --> tests/ui/cfg_attr_cargo_clippy.rs:6:16
+  --> tests/ui/cfg_attr_cargo_clippy.rs:8:16
    |
 LL | #[cfg_attr(not(feature = "cargo-clippy"), derive(Debug))]
    |                ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `clippy`
 
 error: `feature = "cargo-clippy"` was replaced by `clippy`
-  --> tests/ui/cfg_attr_cargo_clippy.rs:7:7
+  --> tests/ui/cfg_attr_cargo_clippy.rs:10:7
    |
 LL | #[cfg(feature = "cargo-clippy")]
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `clippy`
 
 error: `feature = "cargo-clippy"` was replaced by `clippy`
-  --> tests/ui/cfg_attr_cargo_clippy.rs:8:11
+  --> tests/ui/cfg_attr_cargo_clippy.rs:12:11
    |
 LL | #[cfg(not(feature = "cargo-clippy"))]
    |           ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `clippy`
 
 error: `feature = "cargo-clippy"` was replaced by `clippy`
-  --> tests/ui/cfg_attr_cargo_clippy.rs:9:11
+  --> tests/ui/cfg_attr_cargo_clippy.rs:14:11
    |
 LL | #[cfg(any(feature = "cargo-clippy"))]
    |           ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `clippy`
 
 error: `feature = "cargo-clippy"` was replaced by `clippy`
-  --> tests/ui/cfg_attr_cargo_clippy.rs:10:11
+  --> tests/ui/cfg_attr_cargo_clippy.rs:16:11
    |
 LL | #[cfg(all(feature = "cargo-clippy"))]
    |           ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `clippy`
diff --git a/src/tools/clippy/tests/ui/cfg_attr_rustfmt.fixed b/src/tools/clippy/tests/ui/cfg_attr_rustfmt.fixed
index 05d5b3d10eaf..401476a9c1fe 100644
--- a/src/tools/clippy/tests/ui/cfg_attr_rustfmt.fixed
+++ b/src/tools/clippy/tests/ui/cfg_attr_rustfmt.fixed
@@ -16,10 +16,12 @@ fn foo(
 
 fn skip_on_statements() {
     #[rustfmt::skip]
+    //~^ deprecated_cfg_attr
     5+3;
 }
 
 #[rustfmt::skip]
+//~^ deprecated_cfg_attr
 fn main() {
     foo::f();
 }
@@ -39,5 +41,6 @@ fn msrv_1_29() {
 #[clippy::msrv = "1.30"]
 fn msrv_1_30() {
     #[rustfmt::skip]
+    //~^ deprecated_cfg_attr
     1+30;
 }
diff --git a/src/tools/clippy/tests/ui/cfg_attr_rustfmt.rs b/src/tools/clippy/tests/ui/cfg_attr_rustfmt.rs
index bc29e20210e8..3cf368129fd8 100644
--- a/src/tools/clippy/tests/ui/cfg_attr_rustfmt.rs
+++ b/src/tools/clippy/tests/ui/cfg_attr_rustfmt.rs
@@ -16,10 +16,12 @@ fn foo(
 
 fn skip_on_statements() {
     #[cfg_attr(rustfmt, rustfmt::skip)]
+    //~^ deprecated_cfg_attr
     5+3;
 }
 
 #[cfg_attr(rustfmt, rustfmt_skip)]
+//~^ deprecated_cfg_attr
 fn main() {
     foo::f();
 }
@@ -39,5 +41,6 @@ fn msrv_1_29() {
 #[clippy::msrv = "1.30"]
 fn msrv_1_30() {
     #[cfg_attr(rustfmt, rustfmt::skip)]
+    //~^ deprecated_cfg_attr
     1+30;
 }
diff --git a/src/tools/clippy/tests/ui/cfg_attr_rustfmt.stderr b/src/tools/clippy/tests/ui/cfg_attr_rustfmt.stderr
index 24b6ed1b0458..d7825f854be5 100644
--- a/src/tools/clippy/tests/ui/cfg_attr_rustfmt.stderr
+++ b/src/tools/clippy/tests/ui/cfg_attr_rustfmt.stderr
@@ -8,13 +8,13 @@ LL |     #[cfg_attr(rustfmt, rustfmt::skip)]
    = help: to override `-D warnings` add `#[allow(clippy::deprecated_cfg_attr)]`
 
 error: `cfg_attr` is deprecated for rustfmt and got replaced by tool attributes
-  --> tests/ui/cfg_attr_rustfmt.rs:22:1
+  --> tests/ui/cfg_attr_rustfmt.rs:23:1
    |
 LL | #[cfg_attr(rustfmt, rustfmt_skip)]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `#[rustfmt::skip]`
 
 error: `cfg_attr` is deprecated for rustfmt and got replaced by tool attributes
-  --> tests/ui/cfg_attr_rustfmt.rs:41:5
+  --> tests/ui/cfg_attr_rustfmt.rs:43:5
    |
 LL |     #[cfg_attr(rustfmt, rustfmt::skip)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `#[rustfmt::skip]`
diff --git a/src/tools/clippy/tests/ui/cfg_not_test.rs b/src/tools/clippy/tests/ui/cfg_not_test.rs
index da3e29d28966..d93e16f3b185 100644
--- a/src/tools/clippy/tests/ui/cfg_not_test.rs
+++ b/src/tools/clippy/tests/ui/cfg_not_test.rs
@@ -6,10 +6,12 @@ fn important_check() {}
 fn main() {
     // Statement
     #[cfg(not(test))]
+    //~^ cfg_not_test
     let answer = 42;
 
     // Expression
     #[cfg(not(test))]
+    //~^ cfg_not_test
     important_check();
 
     // Make sure only not(test) are checked, not other attributes
@@ -22,10 +24,13 @@ struct CfgNotTest;
 
 // Deeply nested `not(test)`
 #[cfg(not(test))]
+//~^ cfg_not_test
 fn foo() {}
 #[cfg(all(debug_assertions, not(test)))]
+//~^ cfg_not_test
 fn bar() {}
 #[cfg(not(any(not(debug_assertions), test)))]
+//~^ cfg_not_test
 fn baz() {}
 
 #[cfg(test)]
diff --git a/src/tools/clippy/tests/ui/cfg_not_test.stderr b/src/tools/clippy/tests/ui/cfg_not_test.stderr
index c1bf626887af..e452ef2b5ab6 100644
--- a/src/tools/clippy/tests/ui/cfg_not_test.stderr
+++ b/src/tools/clippy/tests/ui/cfg_not_test.stderr
@@ -10,7 +10,7 @@ LL |     #[cfg(not(test))]
    = help: to override `-D warnings` add `#[allow(clippy::cfg_not_test)]`
 
 error: code is excluded from test builds
-  --> tests/ui/cfg_not_test.rs:12:5
+  --> tests/ui/cfg_not_test.rs:13:5
    |
 LL |     #[cfg(not(test))]
    |     ^^^^^^^^^^^^^^^^^
@@ -18,7 +18,7 @@ LL |     #[cfg(not(test))]
    = help: consider not excluding any code from test builds
 
 error: code is excluded from test builds
-  --> tests/ui/cfg_not_test.rs:24:1
+  --> tests/ui/cfg_not_test.rs:26:1
    |
 LL | #[cfg(not(test))]
    | ^^^^^^^^^^^^^^^^^
@@ -26,7 +26,7 @@ LL | #[cfg(not(test))]
    = help: consider not excluding any code from test builds
 
 error: code is excluded from test builds
-  --> tests/ui/cfg_not_test.rs:26:1
+  --> tests/ui/cfg_not_test.rs:29:1
    |
 LL | #[cfg(all(debug_assertions, not(test)))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL | #[cfg(all(debug_assertions, not(test)))]
    = help: consider not excluding any code from test builds
 
 error: code is excluded from test builds
-  --> tests/ui/cfg_not_test.rs:28:1
+  --> tests/ui/cfg_not_test.rs:32:1
    |
 LL | #[cfg(not(any(not(debug_assertions), test)))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/char_lit_as_u8.rs b/src/tools/clippy/tests/ui/char_lit_as_u8.rs
index 7bb3daf0f1e7..c8774c7f3091 100644
--- a/src/tools/clippy/tests/ui/char_lit_as_u8.rs
+++ b/src/tools/clippy/tests/ui/char_lit_as_u8.rs
@@ -3,6 +3,5 @@
 fn main() {
     // no suggestion, since a byte literal won't work.
     let _ = '❤' as u8;
-    //~^ ERROR: casting a character literal to `u8` truncates
-    //~| NOTE: `char` is four bytes wide, but `u8` is a single byte
+    //~^ char_lit_as_u8
 }
diff --git a/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.fixed b/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.fixed
index 6f13078a3ae9..64aacedfd36a 100644
--- a/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.fixed
+++ b/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.fixed
@@ -2,7 +2,11 @@
 
 fn main() {
     let _ = b'a';
+    //~^ char_lit_as_u8
     let _ = b'\n';
+    //~^ char_lit_as_u8
     let _ = b'\0';
+    //~^ char_lit_as_u8
     let _ = b'\x01';
+    //~^ char_lit_as_u8
 }
diff --git a/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.rs b/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.rs
index 7737eb5135fb..a8f39e27605e 100644
--- a/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.rs
+++ b/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.rs
@@ -2,7 +2,11 @@
 
 fn main() {
     let _ = 'a' as u8;
+    //~^ char_lit_as_u8
     let _ = '\n' as u8;
+    //~^ char_lit_as_u8
     let _ = '\0' as u8;
+    //~^ char_lit_as_u8
     let _ = '\x01' as u8;
+    //~^ char_lit_as_u8
 }
diff --git a/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.stderr b/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.stderr
index 4826aca42e1c..158dfd6bed26 100644
--- a/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.stderr
+++ b/src/tools/clippy/tests/ui/char_lit_as_u8_suggestions.stderr
@@ -9,7 +9,7 @@ LL |     let _ = 'a' as u8;
    = help: to override `-D warnings` add `#[allow(clippy::char_lit_as_u8)]`
 
 error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8_suggestions.rs:5:13
+  --> tests/ui/char_lit_as_u8_suggestions.rs:6:13
    |
 LL |     let _ = '\n' as u8;
    |             ^^^^^^^^^^ help: use a byte literal instead: `b'\n'`
@@ -17,7 +17,7 @@ LL |     let _ = '\n' as u8;
    = note: `char` is four bytes wide, but `u8` is a single byte
 
 error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8_suggestions.rs:6:13
+  --> tests/ui/char_lit_as_u8_suggestions.rs:8:13
    |
 LL |     let _ = '\0' as u8;
    |             ^^^^^^^^^^ help: use a byte literal instead: `b'\0'`
@@ -25,7 +25,7 @@ LL |     let _ = '\0' as u8;
    = note: `char` is four bytes wide, but `u8` is a single byte
 
 error: casting a character literal to `u8` truncates
-  --> tests/ui/char_lit_as_u8_suggestions.rs:7:13
+  --> tests/ui/char_lit_as_u8_suggestions.rs:10:13
    |
 LL |     let _ = '\x01' as u8;
    |             ^^^^^^^^^^^^ help: use a byte literal instead: `b'\x01'`
diff --git a/src/tools/clippy/tests/ui/checked_conversions.fixed b/src/tools/clippy/tests/ui/checked_conversions.fixed
index 1e8da3316141..279a5b6e1ff8 100644
--- a/src/tools/clippy/tests/ui/checked_conversions.fixed
+++ b/src/tools/clippy/tests/ui/checked_conversions.fixed
@@ -13,46 +13,62 @@
 
 pub fn i64_to_u32(value: i64) {
     let _ = u32::try_from(value).is_ok();
+    //~^ checked_conversions
     let _ = u32::try_from(value).is_ok();
+    //~^ checked_conversions
 }
 
 pub fn i64_to_u16(value: i64) {
     let _ = u16::try_from(value).is_ok();
+    //~^ checked_conversions
     let _ = u16::try_from(value).is_ok();
+    //~^ checked_conversions
 }
 
 pub fn isize_to_u8(value: isize) {
     let _ = u8::try_from(value).is_ok();
+    //~^ checked_conversions
     let _ = u8::try_from(value).is_ok();
+    //~^ checked_conversions
 }
 
 // Signed to signed
 
 pub fn i64_to_i32(value: i64) {
     let _ = i32::try_from(value).is_ok();
+    //~^ checked_conversions
     let _ = i32::try_from(value).is_ok();
+    //~^ checked_conversions
 }
 
 pub fn i64_to_i16(value: i64) {
     let _ = i16::try_from(value).is_ok();
+    //~^ checked_conversions
     let _ = i16::try_from(value).is_ok();
+    //~^ checked_conversions
 }
 
 // Unsigned to X
 
 pub fn u32_to_i32(value: u32) {
     let _ = i32::try_from(value).is_ok();
+    //~^ checked_conversions
     let _ = i32::try_from(value).is_ok();
+    //~^ checked_conversions
 }
 
 pub fn usize_to_isize(value: usize) {
     let _ = isize::try_from(value).is_ok() && value as i32 == 5;
+    //~^ checked_conversions
     let _ = isize::try_from(value).is_ok() && value as i32 == 5;
+    //~^ checked_conversions
 }
 
 pub fn u32_to_u16(value: u32) {
     let _ = u16::try_from(value).is_ok() && value as i32 == 5;
+    //~^ checked_conversions
     let _ = u16::try_from(value).is_ok() && value as i32 == 5;
+    //~^ checked_conversions
 }
 
 // Negative tests
@@ -86,6 +102,7 @@ fn msrv_1_33() {
 fn msrv_1_34() {
     let value: i64 = 34;
     let _ = u32::try_from(value).is_ok();
+    //~^ checked_conversions
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/checked_conversions.rs b/src/tools/clippy/tests/ui/checked_conversions.rs
index 67a9adc049ea..c339bc674bbb 100644
--- a/src/tools/clippy/tests/ui/checked_conversions.rs
+++ b/src/tools/clippy/tests/ui/checked_conversions.rs
@@ -13,46 +13,62 @@
 
 pub fn i64_to_u32(value: i64) {
     let _ = value <= (u32::max_value() as i64) && value >= 0;
+    //~^ checked_conversions
     let _ = value <= (u32::MAX as i64) && value >= 0;
+    //~^ checked_conversions
 }
 
 pub fn i64_to_u16(value: i64) {
     let _ = value <= i64::from(u16::max_value()) && value >= 0;
+    //~^ checked_conversions
     let _ = value <= i64::from(u16::MAX) && value >= 0;
+    //~^ checked_conversions
 }
 
 pub fn isize_to_u8(value: isize) {
     let _ = value <= (u8::max_value() as isize) && value >= 0;
+    //~^ checked_conversions
     let _ = value <= (u8::MAX as isize) && value >= 0;
+    //~^ checked_conversions
 }
 
 // Signed to signed
 
 pub fn i64_to_i32(value: i64) {
     let _ = value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64);
+    //~^ checked_conversions
     let _ = value <= (i32::MAX as i64) && value >= (i32::MIN as i64);
+    //~^ checked_conversions
 }
 
 pub fn i64_to_i16(value: i64) {
     let _ = value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value());
+    //~^ checked_conversions
     let _ = value <= i64::from(i16::MAX) && value >= i64::from(i16::MIN);
+    //~^ checked_conversions
 }
 
 // Unsigned to X
 
 pub fn u32_to_i32(value: u32) {
     let _ = value <= i32::max_value() as u32;
+    //~^ checked_conversions
     let _ = value <= i32::MAX as u32;
+    //~^ checked_conversions
 }
 
 pub fn usize_to_isize(value: usize) {
     let _ = value <= isize::max_value() as usize && value as i32 == 5;
+    //~^ checked_conversions
     let _ = value <= isize::MAX as usize && value as i32 == 5;
+    //~^ checked_conversions
 }
 
 pub fn u32_to_u16(value: u32) {
     let _ = value <= u16::max_value() as u32 && value as i32 == 5;
+    //~^ checked_conversions
     let _ = value <= u16::MAX as u32 && value as i32 == 5;
+    //~^ checked_conversions
 }
 
 // Negative tests
@@ -86,6 +102,7 @@ fn msrv_1_33() {
 fn msrv_1_34() {
     let value: i64 = 34;
     let _ = value <= (u32::MAX as i64) && value >= 0;
+    //~^ checked_conversions
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/checked_conversions.stderr b/src/tools/clippy/tests/ui/checked_conversions.stderr
index 453cd7fcf016..3841b9d5a4dd 100644
--- a/src/tools/clippy/tests/ui/checked_conversions.stderr
+++ b/src/tools/clippy/tests/ui/checked_conversions.stderr
@@ -8,97 +8,97 @@ LL |     let _ = value <= (u32::max_value() as i64) && value >= 0;
    = help: to override `-D warnings` add `#[allow(clippy::checked_conversions)]`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:16:13
+  --> tests/ui/checked_conversions.rs:17:13
    |
 LL |     let _ = value <= (u32::MAX as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:20:13
+  --> tests/ui/checked_conversions.rs:22:13
    |
 LL |     let _ = value <= i64::from(u16::max_value()) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:21:13
+  --> tests/ui/checked_conversions.rs:24:13
    |
 LL |     let _ = value <= i64::from(u16::MAX) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:25:13
+  --> tests/ui/checked_conversions.rs:29:13
    |
 LL |     let _ = value <= (u8::max_value() as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:26:13
+  --> tests/ui/checked_conversions.rs:31:13
    |
 LL |     let _ = value <= (u8::MAX as isize) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u8::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:32:13
+  --> tests/ui/checked_conversions.rs:38:13
    |
 LL |     let _ = value <= (i32::max_value() as i64) && value >= (i32::min_value() as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:33:13
+  --> tests/ui/checked_conversions.rs:40:13
    |
 LL |     let _ = value <= (i32::MAX as i64) && value >= (i32::MIN as i64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:37:13
+  --> tests/ui/checked_conversions.rs:45:13
    |
 LL |     let _ = value <= i64::from(i16::max_value()) && value >= i64::from(i16::min_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:38:13
+  --> tests/ui/checked_conversions.rs:47:13
    |
 LL |     let _ = value <= i64::from(i16::MAX) && value >= i64::from(i16::MIN);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:44:13
+  --> tests/ui/checked_conversions.rs:54:13
    |
 LL |     let _ = value <= i32::max_value() as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:45:13
+  --> tests/ui/checked_conversions.rs:56:13
    |
 LL |     let _ = value <= i32::MAX as u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `i32::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:49:13
+  --> tests/ui/checked_conversions.rs:61:13
    |
 LL |     let _ = value <= isize::max_value() as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:50:13
+  --> tests/ui/checked_conversions.rs:63:13
    |
 LL |     let _ = value <= isize::MAX as usize && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `isize::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:54:13
+  --> tests/ui/checked_conversions.rs:68:13
    |
 LL |     let _ = value <= u16::max_value() as u32 && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:55:13
+  --> tests/ui/checked_conversions.rs:70:13
    |
 LL |     let _ = value <= u16::MAX as u32 && value as i32 == 5;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u16::try_from(value).is_ok()`
 
 error: checked cast can be simplified
-  --> tests/ui/checked_conversions.rs:88:13
+  --> tests/ui/checked_conversions.rs:104:13
    |
 LL |     let _ = value <= (u32::MAX as i64) && value >= 0;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `u32::try_from(value).is_ok()`
diff --git a/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.rs b/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.rs
index 323dae380633..7d0bcc547a42 100644
--- a/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.rs
+++ b/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.rs
@@ -11,16 +11,19 @@ fn test_complex_conditions() {
     if x.is_ok() && y.is_err() {
         // unnecessary
         x.unwrap();
-        //~^ ERROR: called `unwrap` on `x` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // will panic
         x.unwrap_err();
-        //~^ ERROR: this call to `unwrap_err()` will always panic
+        //~^ panicking_unwrap
+
         // will panic
         y.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         y.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `y` after checking its variant with `is_err`
+        //~^ unnecessary_unwrap
     } else {
         // not statically determinable whether any of the following will always succeed or always fail:
         x.unwrap();
@@ -36,37 +39,45 @@ fn test_complex_conditions() {
     } else {
         // will panic
         x.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         x.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `x` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // will panic
         y.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         y.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `y` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
     }
     let z: Result<(), ()> = Ok(());
     if x.is_ok() && !(y.is_ok() || z.is_err()) {
         // unnecessary
         x.unwrap();
-        //~^ ERROR: called `unwrap` on `x` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // will panic
         x.unwrap_err();
-        //~^ ERROR: this call to `unwrap_err()` will always panic
+        //~^ panicking_unwrap
+
         // will panic
         y.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         y.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `y` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // unnecessary
         z.unwrap();
-        //~^ ERROR: called `unwrap` on `z` after checking its variant with `is_err`
+        //~^ unnecessary_unwrap
+
         // will panic
         z.unwrap_err();
-        //~^ ERROR: this call to `unwrap_err()` will always panic
+        //~^ panicking_unwrap
     }
     if x.is_ok() || !(y.is_ok() && z.is_err()) {
         // not statically determinable whether any of the following will always succeed or always fail:
@@ -76,22 +87,27 @@ fn test_complex_conditions() {
     } else {
         // will panic
         x.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         x.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `x` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // unnecessary
         y.unwrap();
-        //~^ ERROR: called `unwrap` on `y` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // will panic
         y.unwrap_err();
-        //~^ ERROR: this call to `unwrap_err()` will always panic
+        //~^ panicking_unwrap
+
         // will panic
         z.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         z.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `z` after checking its variant with `is_err`
+        //~^ unnecessary_unwrap
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.stderr b/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.stderr
index aa72e8cce590..d3905850c970 100644
--- a/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.stderr
+++ b/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals.stderr
@@ -15,7 +15,7 @@ LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap_err()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:16:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:17:9
    |
 LL |     if x.is_ok() && y.is_err() {
    |        --------- because of this check
@@ -30,7 +30,7 @@ LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:19:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:21:9
    |
 LL |     if x.is_ok() && y.is_err() {
    |                     ---------- because of this check
@@ -39,7 +39,7 @@ LL |         y.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `y` after checking its variant with `is_err`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:22:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:25:9
    |
 LL |     if x.is_ok() && y.is_err() {
    |                     ---------- the check is happening here
@@ -50,7 +50,7 @@ LL |         y.unwrap_err();
    = help: try using `if let` or `match`
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:38:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:41:9
    |
 LL |     if x.is_ok() || y.is_ok() {
    |        --------- because of this check
@@ -59,7 +59,7 @@ LL |         x.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `x` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:41:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:45:9
    |
 LL |     if x.is_ok() || y.is_ok() {
    |        --------- the check is happening here
@@ -70,7 +70,7 @@ LL |         x.unwrap_err();
    = help: try using `if let` or `match`
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:44:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:49:9
    |
 LL |     if x.is_ok() || y.is_ok() {
    |                     --------- because of this check
@@ -79,7 +79,7 @@ LL |         y.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `y` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:47:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:53:9
    |
 LL |     if x.is_ok() || y.is_ok() {
    |                     --------- the check is happening here
@@ -90,7 +90,7 @@ LL |         y.unwrap_err();
    = help: try using `if let` or `match`
 
 error: called `unwrap` on `x` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:53:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:59:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
    |        --------- the check is happening here
@@ -101,7 +101,7 @@ LL |         x.unwrap();
    = help: try using `if let` or `match`
 
 error: this call to `unwrap_err()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:56:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:63:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
    |        --------- because of this check
@@ -110,7 +110,7 @@ LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:59:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:67:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
    |                       --------- because of this check
@@ -119,7 +119,7 @@ LL |         y.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `y` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:62:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:71:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
    |                       --------- the check is happening here
@@ -130,7 +130,7 @@ LL |         y.unwrap_err();
    = help: try using `if let` or `match`
 
 error: called `unwrap` on `z` after checking its variant with `is_err`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:65:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:75:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
    |                                    ---------- the check is happening here
@@ -141,7 +141,7 @@ LL |         z.unwrap();
    = help: try using `if let` or `match`
 
 error: this call to `unwrap_err()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:68:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:79:9
    |
 LL |     if x.is_ok() && !(y.is_ok() || z.is_err()) {
    |                                    ---------- because of this check
@@ -150,7 +150,7 @@ LL |         z.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:78:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:89:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
    |        --------- because of this check
@@ -159,7 +159,7 @@ LL |         x.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `x` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:81:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:93:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
    |        --------- the check is happening here
@@ -170,7 +170,7 @@ LL |         x.unwrap_err();
    = help: try using `if let` or `match`
 
 error: called `unwrap` on `y` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:84:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:97:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
    |                       --------- the check is happening here
@@ -181,7 +181,7 @@ LL |         y.unwrap();
    = help: try using `if let` or `match`
 
 error: this call to `unwrap_err()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:87:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:101:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
    |                       --------- because of this check
@@ -190,7 +190,7 @@ LL |         y.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:90:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:105:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
    |                                    ---------- because of this check
@@ -199,7 +199,7 @@ LL |         z.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `z` after checking its variant with `is_err`
-  --> tests/ui/checked_unwrap/complex_conditionals.rs:93:9
+  --> tests/ui/checked_unwrap/complex_conditionals.rs:109:9
    |
 LL |     if x.is_ok() || !(y.is_ok() && z.is_err()) {
    |                                    ---------- the check is happening here
diff --git a/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals_nested.rs b/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals_nested.rs
index 68923793dcdf..145885702a9b 100644
--- a/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals_nested.rs
+++ b/src/tools/clippy/tests/ui/checked_unwrap/complex_conditionals_nested.rs
@@ -11,11 +11,11 @@ fn test_nested() {
         if x.is_some() {
             // unnecessary
             x.unwrap();
-            //~^ ERROR: called `unwrap` on `x` after checking its variant with `is_some`
+            //~^ unnecessary_unwrap
         } else {
             // will panic
             x.unwrap();
-            //~^ ERROR: this call to `unwrap()` will always panic
+            //~^ panicking_unwrap
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs b/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs
index c3c8562edffb..4101897d3800 100644
--- a/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs
+++ b/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.rs
@@ -11,6 +11,7 @@ macro_rules! m {
         if $a.is_some() {
             // unnecessary
             $a.unwrap();
+            //~^ unnecessary_unwrap
         }
     };
 }
@@ -44,26 +45,28 @@ fn main() {
     if x.is_some() {
         // unnecessary
         x.unwrap();
-        //~^ ERROR: called `unwrap` on `x` after checking its variant with `is_some`
+        //~^ unnecessary_unwrap
+
         // unnecessary
         x.expect("an error message");
-        //~^ ERROR: called `expect` on `x` after checking its variant with `is_some`
+        //~^ unnecessary_unwrap
     } else {
         // will panic
         x.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // will panic
         x.expect("an error message");
-        //~^ ERROR: this call to `expect()` will always panic
+        //~^ panicking_unwrap
     }
     if x.is_none() {
         // will panic
         x.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
     } else {
         // unnecessary
         x.unwrap();
-        //~^ ERROR: called `unwrap` on `x` after checking its variant with `is_none`
+        //~^ unnecessary_unwrap
     }
     m!(x);
     // ok
@@ -76,38 +79,44 @@ fn main() {
     if x.is_ok() {
         // unnecessary
         x.unwrap();
-        //~^ ERROR: called `unwrap` on `x` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // unnecessary
         x.expect("an error message");
-        //~^ ERROR: called `expect` on `x` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
+
         // will panic
         x.unwrap_err();
-        //~^ ERROR: this call to `unwrap_err()` will always panic
+        //~^ panicking_unwrap
     } else {
         // will panic
         x.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // will panic
         x.expect("an error message");
-        //~^ ERROR: this call to `expect()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         x.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `x` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
     }
     if x.is_err() {
         // will panic
         x.unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
+
         // unnecessary
         x.unwrap_err();
-        //~^ ERROR: called `unwrap_err` on `x` after checking its variant with `is_err`
+        //~^ unnecessary_unwrap
     } else {
         // unnecessary
         x.unwrap();
-        //~^ ERROR: called `unwrap` on `x` after checking its variant with `is_err`
+        //~^ unnecessary_unwrap
+
         // will panic
         x.unwrap_err();
-        //~^ ERROR: this call to `unwrap_err()` will always panic
+        //~^ panicking_unwrap
     }
     if x.is_ok() {
         x = Err(());
@@ -132,38 +141,38 @@ fn issue11371() {
 
     if option.is_some() {
         option.as_ref().unwrap();
-        //~^ ERROR: called `unwrap` on `option` after checking its variant with `is_some`
+        //~^ unnecessary_unwrap
     } else {
         option.as_ref().unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
     }
 
     let result = Ok::<(), ()>(());
 
     if result.is_ok() {
         result.as_ref().unwrap();
-        //~^ ERROR: called `unwrap` on `result` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
     } else {
         result.as_ref().unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
     }
 
     let mut option = Some(());
     if option.is_some() {
         option.as_mut().unwrap();
-        //~^ ERROR: called `unwrap` on `option` after checking its variant with `is_some`
+        //~^ unnecessary_unwrap
     } else {
         option.as_mut().unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
     }
 
     let mut result = Ok::<(), ()>(());
     if result.is_ok() {
         result.as_mut().unwrap();
-        //~^ ERROR: called `unwrap` on `result` after checking its variant with `is_ok`
+        //~^ unnecessary_unwrap
     } else {
         result.as_mut().unwrap();
-        //~^ ERROR: this call to `unwrap()` will always panic
+        //~^ panicking_unwrap
     }
 
     // This should not lint. Statics are, at the time of writing, not linted on anyway,
@@ -172,6 +181,7 @@ fn issue11371() {
     static mut X: Option<i32> = Some(123);
     unsafe {
         if X.is_some() {
+            //~^ ERROR: creating a shared reference
             X = None;
             X.unwrap();
         }
diff --git a/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.stderr b/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.stderr
index d92c03f48881..c17eaef2326b 100644
--- a/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.stderr
+++ b/src/tools/clippy/tests/ui/checked_unwrap/simple_conditionals.stderr
@@ -1,5 +1,5 @@
 error: called `unwrap` on `x` after checking its variant with `is_some`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:46:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:47:9
    |
 LL |     if x.is_some() {
    |     -------------- help: try: `if let Some(<item>) = x`
@@ -14,7 +14,7 @@ LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: called `expect` on `x` after checking its variant with `is_some`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:49:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:51:9
    |
 LL |     if x.is_some() {
    |     -------------- help: try: `if let Some(<item>) = x`
@@ -23,7 +23,7 @@ LL |         x.expect("an error message");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:53:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:55:9
    |
 LL |     if x.is_some() {
    |        ----------- because of this check
@@ -38,7 +38,7 @@ LL | #![deny(clippy::panicking_unwrap, clippy::unnecessary_unwrap)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `expect()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:56:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:59:9
    |
 LL |     if x.is_some() {
    |        ----------- because of this check
@@ -47,7 +47,7 @@ LL |         x.expect("an error message");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:61:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:64:9
    |
 LL |     if x.is_none() {
    |        ----------- because of this check
@@ -56,7 +56,7 @@ LL |         x.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap` on `x` after checking its variant with `is_none`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:65:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:68:9
    |
 LL |     if x.is_none() {
    |     -------------- help: try: `if let Some(<item>) = x`
@@ -79,7 +79,7 @@ LL |     m!(x);
    = note: this error originates in the macro `m` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: called `unwrap` on `x` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:78:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:81:9
    |
 LL |     if x.is_ok() {
    |     ------------ help: try: `if let Ok(<item>) = x`
@@ -88,7 +88,7 @@ LL |         x.unwrap();
    |         ^^^^^^^^^^
 
 error: called `expect` on `x` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:81:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:85:9
    |
 LL |     if x.is_ok() {
    |     ------------ help: try: `if let Ok(<item>) = x`
@@ -97,7 +97,7 @@ LL |         x.expect("an error message");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap_err()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:84:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:89:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -106,7 +106,7 @@ LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:88:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:93:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -115,7 +115,7 @@ LL |         x.unwrap();
    |         ^^^^^^^^^^
 
 error: this call to `expect()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:91:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:97:9
    |
 LL |     if x.is_ok() {
    |        --------- because of this check
@@ -124,7 +124,7 @@ LL |         x.expect("an error message");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: called `unwrap_err` on `x` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:94:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:101:9
    |
 LL |     if x.is_ok() {
    |     ------------ help: try: `if let Err(<item>) = x`
@@ -133,7 +133,7 @@ LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:99:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:106:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
@@ -142,7 +142,7 @@ LL |         x.unwrap();
    |         ^^^^^^^^^^
 
 error: called `unwrap_err` on `x` after checking its variant with `is_err`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:102:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:110:9
    |
 LL |     if x.is_err() {
    |     ------------- help: try: `if let Err(<item>) = x`
@@ -151,7 +151,7 @@ LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
 error: called `unwrap` on `x` after checking its variant with `is_err`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:106:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:114:9
    |
 LL |     if x.is_err() {
    |     ------------- help: try: `if let Ok(<item>) = x`
@@ -160,7 +160,7 @@ LL |         x.unwrap();
    |         ^^^^^^^^^^
 
 error: this call to `unwrap_err()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:109:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:118:9
    |
 LL |     if x.is_err() {
    |        ---------- because of this check
@@ -169,7 +169,7 @@ LL |         x.unwrap_err();
    |         ^^^^^^^^^^^^^^
 
 error: called `unwrap` on `option` after checking its variant with `is_some`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:134:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:143:9
    |
 LL |     if option.is_some() {
    |     ------------------- help: try: `if let Some(<item>) = &option`
@@ -177,7 +177,7 @@ LL |         option.as_ref().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:137:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:146:9
    |
 LL |     if option.is_some() {
    |        ---------------- because of this check
@@ -186,7 +186,7 @@ LL |         option.as_ref().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: called `unwrap` on `result` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:144:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:153:9
    |
 LL |     if result.is_ok() {
    |     ----------------- help: try: `if let Ok(<item>) = &result`
@@ -194,7 +194,7 @@ LL |         result.as_ref().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:147:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:156:9
    |
 LL |     if result.is_ok() {
    |        -------------- because of this check
@@ -203,7 +203,7 @@ LL |         result.as_ref().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: called `unwrap` on `option` after checking its variant with `is_some`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:153:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:162:9
    |
 LL |     if option.is_some() {
    |     ------------------- help: try: `if let Some(<item>) = &mut option`
@@ -211,7 +211,7 @@ LL |         option.as_mut().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:156:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:165:9
    |
 LL |     if option.is_some() {
    |        ---------------- because of this check
@@ -220,7 +220,7 @@ LL |         option.as_mut().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: called `unwrap` on `result` after checking its variant with `is_ok`
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:162:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:171:9
    |
 LL |     if result.is_ok() {
    |     ----------------- help: try: `if let Ok(<item>) = &mut result`
@@ -228,7 +228,7 @@ LL |         result.as_mut().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `unwrap()` will always panic
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:165:9
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:174:9
    |
 LL |     if result.is_ok() {
    |        -------------- because of this check
@@ -237,7 +237,7 @@ LL |         result.as_mut().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: creating a shared reference to mutable static is discouraged
-  --> tests/ui/checked_unwrap/simple_conditionals.rs:174:12
+  --> tests/ui/checked_unwrap/simple_conditionals.rs:183:12
    |
 LL |         if X.is_some() {
    |            ^^^^^^^^^^^ shared reference to mutable static
diff --git a/src/tools/clippy/tests/ui/clear_with_drain.fixed b/src/tools/clippy/tests/ui/clear_with_drain.fixed
index 15777a4ea5b3..92fd86668b76 100644
--- a/src/tools/clippy/tests/ui/clear_with_drain.fixed
+++ b/src/tools/clippy/tests/ui/clear_with_drain.fixed
@@ -20,10 +20,12 @@ fn vec_range() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.clear();
+    //~^ clear_with_drain
 
     // Do lint
     let mut v = vec![1, 2, 3];
     v.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_range_from() {
@@ -43,10 +45,12 @@ fn vec_range_from() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.clear();
+    //~^ clear_with_drain
 
     // Do lint
     let mut v = vec![1, 2, 3];
     v.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_range_full() {
@@ -63,6 +67,7 @@ fn vec_range_full() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_range_to() {
@@ -80,6 +85,7 @@ fn vec_range_to() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_partial_drains() {
@@ -118,10 +124,12 @@ fn vec_deque_range() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.clear();
+    //~^ clear_with_drain
 
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_deque_range_from() {
@@ -141,10 +149,12 @@ fn vec_deque_range_from() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.clear();
+    //~^ clear_with_drain
 
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_deque_range_full() {
@@ -161,6 +171,7 @@ fn vec_deque_range_full() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_deque_range_to() {
@@ -178,6 +189,7 @@ fn vec_deque_range_to() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.clear();
+    //~^ clear_with_drain
 }
 
 fn vec_deque_partial_drains() {
@@ -216,10 +228,12 @@ fn string_range() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.clear();
+    //~^ clear_with_drain
 
     // Do lint
     let mut s = String::from("Hello, world!");
     s.clear();
+    //~^ clear_with_drain
 }
 
 fn string_range_from() {
@@ -239,10 +253,12 @@ fn string_range_from() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.clear();
+    //~^ clear_with_drain
 
     // Do lint
     let mut s = String::from("Hello, world!");
     s.clear();
+    //~^ clear_with_drain
 }
 
 fn string_range_full() {
@@ -259,6 +275,7 @@ fn string_range_full() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.clear();
+    //~^ clear_with_drain
 }
 
 fn string_range_to() {
@@ -276,6 +293,7 @@ fn string_range_to() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.clear();
+    //~^ clear_with_drain
 }
 
 fn string_partial_drains() {
@@ -314,6 +332,7 @@ fn hash_set() {
     // Do lint
     let mut set = HashSet::from([1, 2, 3]);
     set.clear();
+    //~^ clear_with_drain
 }
 
 fn hash_map() {
@@ -333,6 +352,7 @@ fn hash_map() {
     // Do lint
     let mut map = HashMap::from([(1, "a"), (2, "b")]);
     map.clear();
+    //~^ clear_with_drain
 }
 
 fn binary_heap() {
@@ -352,6 +372,7 @@ fn binary_heap() {
     // Do lint
     let mut heap = BinaryHeap::from([1, 2]);
     heap.clear();
+    //~^ clear_with_drain
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/clear_with_drain.rs b/src/tools/clippy/tests/ui/clear_with_drain.rs
index 1dea7235ef66..28122fcaeded 100644
--- a/src/tools/clippy/tests/ui/clear_with_drain.rs
+++ b/src/tools/clippy/tests/ui/clear_with_drain.rs
@@ -20,10 +20,12 @@ fn vec_range() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.drain(0..v.len());
+    //~^ clear_with_drain
 
     // Do lint
     let mut v = vec![1, 2, 3];
     v.drain(usize::MIN..v.len());
+    //~^ clear_with_drain
 }
 
 fn vec_range_from() {
@@ -43,10 +45,12 @@ fn vec_range_from() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.drain(0..);
+    //~^ clear_with_drain
 
     // Do lint
     let mut v = vec![1, 2, 3];
     v.drain(usize::MIN..);
+    //~^ clear_with_drain
 }
 
 fn vec_range_full() {
@@ -63,6 +67,7 @@ fn vec_range_full() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.drain(..);
+    //~^ clear_with_drain
 }
 
 fn vec_range_to() {
@@ -80,6 +85,7 @@ fn vec_range_to() {
     // Do lint
     let mut v = vec![1, 2, 3];
     v.drain(..v.len());
+    //~^ clear_with_drain
 }
 
 fn vec_partial_drains() {
@@ -118,10 +124,12 @@ fn vec_deque_range() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.drain(0..deque.len());
+    //~^ clear_with_drain
 
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.drain(usize::MIN..deque.len());
+    //~^ clear_with_drain
 }
 
 fn vec_deque_range_from() {
@@ -141,10 +149,12 @@ fn vec_deque_range_from() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.drain(0..);
+    //~^ clear_with_drain
 
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.drain(usize::MIN..);
+    //~^ clear_with_drain
 }
 
 fn vec_deque_range_full() {
@@ -161,6 +171,7 @@ fn vec_deque_range_full() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.drain(..);
+    //~^ clear_with_drain
 }
 
 fn vec_deque_range_to() {
@@ -178,6 +189,7 @@ fn vec_deque_range_to() {
     // Do lint
     let mut deque = VecDeque::from([1, 2, 3]);
     deque.drain(..deque.len());
+    //~^ clear_with_drain
 }
 
 fn vec_deque_partial_drains() {
@@ -216,10 +228,12 @@ fn string_range() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.drain(0..s.len());
+    //~^ clear_with_drain
 
     // Do lint
     let mut s = String::from("Hello, world!");
     s.drain(usize::MIN..s.len());
+    //~^ clear_with_drain
 }
 
 fn string_range_from() {
@@ -239,10 +253,12 @@ fn string_range_from() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.drain(0..);
+    //~^ clear_with_drain
 
     // Do lint
     let mut s = String::from("Hello, world!");
     s.drain(usize::MIN..);
+    //~^ clear_with_drain
 }
 
 fn string_range_full() {
@@ -259,6 +275,7 @@ fn string_range_full() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.drain(..);
+    //~^ clear_with_drain
 }
 
 fn string_range_to() {
@@ -276,6 +293,7 @@ fn string_range_to() {
     // Do lint
     let mut s = String::from("Hello, world!");
     s.drain(..s.len());
+    //~^ clear_with_drain
 }
 
 fn string_partial_drains() {
@@ -314,6 +332,7 @@ fn hash_set() {
     // Do lint
     let mut set = HashSet::from([1, 2, 3]);
     set.drain();
+    //~^ clear_with_drain
 }
 
 fn hash_map() {
@@ -333,6 +352,7 @@ fn hash_map() {
     // Do lint
     let mut map = HashMap::from([(1, "a"), (2, "b")]);
     map.drain();
+    //~^ clear_with_drain
 }
 
 fn binary_heap() {
@@ -352,6 +372,7 @@ fn binary_heap() {
     // Do lint
     let mut heap = BinaryHeap::from([1, 2]);
     heap.drain();
+    //~^ clear_with_drain
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/clear_with_drain.stderr b/src/tools/clippy/tests/ui/clear_with_drain.stderr
index 3c7d22192dc7..0f060fa9dade 100644
--- a/src/tools/clippy/tests/ui/clear_with_drain.stderr
+++ b/src/tools/clippy/tests/ui/clear_with_drain.stderr
@@ -8,121 +8,121 @@ LL |     v.drain(0..v.len());
    = help: to override `-D warnings` add `#[allow(clippy::clear_with_drain)]`
 
 error: `drain` used to clear a `Vec`
-  --> tests/ui/clear_with_drain.rs:26:7
+  --> tests/ui/clear_with_drain.rs:27:7
    |
 LL |     v.drain(usize::MIN..v.len());
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> tests/ui/clear_with_drain.rs:45:7
+  --> tests/ui/clear_with_drain.rs:47:7
    |
 LL |     v.drain(0..);
    |       ^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> tests/ui/clear_with_drain.rs:49:7
+  --> tests/ui/clear_with_drain.rs:52:7
    |
 LL |     v.drain(usize::MIN..);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> tests/ui/clear_with_drain.rs:65:7
+  --> tests/ui/clear_with_drain.rs:69:7
    |
 LL |     v.drain(..);
    |       ^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `Vec`
-  --> tests/ui/clear_with_drain.rs:82:7
+  --> tests/ui/clear_with_drain.rs:87:7
    |
 LL |     v.drain(..v.len());
    |       ^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `VecDeque`
-  --> tests/ui/clear_with_drain.rs:120:11
+  --> tests/ui/clear_with_drain.rs:126:11
    |
 LL |     deque.drain(0..deque.len());
    |           ^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `VecDeque`
-  --> tests/ui/clear_with_drain.rs:124:11
+  --> tests/ui/clear_with_drain.rs:131:11
    |
 LL |     deque.drain(usize::MIN..deque.len());
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `VecDeque`
-  --> tests/ui/clear_with_drain.rs:143:11
+  --> tests/ui/clear_with_drain.rs:151:11
    |
 LL |     deque.drain(0..);
    |           ^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `VecDeque`
-  --> tests/ui/clear_with_drain.rs:147:11
+  --> tests/ui/clear_with_drain.rs:156:11
    |
 LL |     deque.drain(usize::MIN..);
    |           ^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `VecDeque`
-  --> tests/ui/clear_with_drain.rs:163:11
+  --> tests/ui/clear_with_drain.rs:173:11
    |
 LL |     deque.drain(..);
    |           ^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `VecDeque`
-  --> tests/ui/clear_with_drain.rs:180:11
+  --> tests/ui/clear_with_drain.rs:191:11
    |
 LL |     deque.drain(..deque.len());
    |           ^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `String`
-  --> tests/ui/clear_with_drain.rs:218:7
+  --> tests/ui/clear_with_drain.rs:230:7
    |
 LL |     s.drain(0..s.len());
    |       ^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `String`
-  --> tests/ui/clear_with_drain.rs:222:7
+  --> tests/ui/clear_with_drain.rs:235:7
    |
 LL |     s.drain(usize::MIN..s.len());
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `String`
-  --> tests/ui/clear_with_drain.rs:241:7
+  --> tests/ui/clear_with_drain.rs:255:7
    |
 LL |     s.drain(0..);
    |       ^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `String`
-  --> tests/ui/clear_with_drain.rs:245:7
+  --> tests/ui/clear_with_drain.rs:260:7
    |
 LL |     s.drain(usize::MIN..);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `String`
-  --> tests/ui/clear_with_drain.rs:261:7
+  --> tests/ui/clear_with_drain.rs:277:7
    |
 LL |     s.drain(..);
    |       ^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `String`
-  --> tests/ui/clear_with_drain.rs:278:7
+  --> tests/ui/clear_with_drain.rs:295:7
    |
 LL |     s.drain(..s.len());
    |       ^^^^^^^^^^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `HashSet`
-  --> tests/ui/clear_with_drain.rs:316:9
+  --> tests/ui/clear_with_drain.rs:334:9
    |
 LL |     set.drain();
    |         ^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `HashMap`
-  --> tests/ui/clear_with_drain.rs:335:9
+  --> tests/ui/clear_with_drain.rs:354:9
    |
 LL |     map.drain();
    |         ^^^^^^^ help: try: `clear()`
 
 error: `drain` used to clear a `BinaryHeap`
-  --> tests/ui/clear_with_drain.rs:354:10
+  --> tests/ui/clear_with_drain.rs:374:10
    |
 LL |     heap.drain();
    |          ^^^^^^^ help: try: `clear()`
diff --git a/src/tools/clippy/tests/ui/clone_on_copy.fixed b/src/tools/clippy/tests/ui/clone_on_copy.fixed
index 9d9a5bf20f43..2dd8af152515 100644
--- a/src/tools/clippy/tests/ui/clone_on_copy.fixed
+++ b/src/tools/clippy/tests/ui/clone_on_copy.fixed
@@ -21,16 +21,20 @@ fn is_ascii(ch: char) -> bool {
 
 fn clone_on_copy() -> Option<(i32)> {
     42;
+    //~^ clone_on_copy
 
     vec![1].clone(); // ok, not a Copy type
     Some(vec![1]).clone(); // ok, not a Copy type
     *(&42);
+    //~^ clone_on_copy
 
     let rc = RefCell::new(0);
     *rc.borrow();
+    //~^ clone_on_copy
 
     let x = 0u32;
     x.rotate_left(1);
+    //~^ clone_on_copy
 
     #[derive(Clone, Copy)]
     struct Foo;
@@ -45,6 +49,7 @@ fn clone_on_copy() -> Option<(i32)> {
         ($e:expr) => {{ $e }};
     }
     m!(42);
+    //~^ clone_on_copy
 
     struct Wrap([u32; 2]);
     impl core::ops::Deref for Wrap {
@@ -55,6 +60,7 @@ fn clone_on_copy() -> Option<(i32)> {
     }
     let x = Wrap([0, 0]);
     (*x)[0];
+    //~^ clone_on_copy
 
     let x = 42;
     let ref y = x.clone(); // ok, binds by reference
@@ -65,13 +71,17 @@ fn clone_on_copy() -> Option<(i32)> {
     let _ = &x.clone(); // ok, getting a ref
     'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
     is_ascii('z');
+    //~^ clone_on_copy
 
     // Issue #5436
     let mut vec = Vec::new();
     vec.push(42);
+    //~^ clone_on_copy
 
     //  Issue #9277
     let opt: &Option<i32> = &None;
     let value = (*opt)?; // operator precedence needed (*opt)?
+    //
+    //~^^ clone_on_copy
     None
 }
diff --git a/src/tools/clippy/tests/ui/clone_on_copy.rs b/src/tools/clippy/tests/ui/clone_on_copy.rs
index 305bc6816e1b..a371afb04a78 100644
--- a/src/tools/clippy/tests/ui/clone_on_copy.rs
+++ b/src/tools/clippy/tests/ui/clone_on_copy.rs
@@ -21,16 +21,20 @@ fn is_ascii(ch: char) -> bool {
 
 fn clone_on_copy() -> Option<(i32)> {
     42.clone();
+    //~^ clone_on_copy
 
     vec![1].clone(); // ok, not a Copy type
     Some(vec![1]).clone(); // ok, not a Copy type
     (&42).clone();
+    //~^ clone_on_copy
 
     let rc = RefCell::new(0);
     rc.borrow().clone();
+    //~^ clone_on_copy
 
     let x = 0u32;
     x.clone().rotate_left(1);
+    //~^ clone_on_copy
 
     #[derive(Clone, Copy)]
     struct Foo;
@@ -45,6 +49,7 @@ fn clone_on_copy() -> Option<(i32)> {
         ($e:expr) => {{ $e }};
     }
     m!(42).clone();
+    //~^ clone_on_copy
 
     struct Wrap([u32; 2]);
     impl core::ops::Deref for Wrap {
@@ -55,6 +60,7 @@ fn clone_on_copy() -> Option<(i32)> {
     }
     let x = Wrap([0, 0]);
     x.clone()[0];
+    //~^ clone_on_copy
 
     let x = 42;
     let ref y = x.clone(); // ok, binds by reference
@@ -65,13 +71,17 @@ fn clone_on_copy() -> Option<(i32)> {
     let _ = &x.clone(); // ok, getting a ref
     'a'.clone().make_ascii_uppercase(); // ok, clone and then mutate
     is_ascii('z'.clone());
+    //~^ clone_on_copy
 
     // Issue #5436
     let mut vec = Vec::new();
     vec.push(42.clone());
+    //~^ clone_on_copy
 
     //  Issue #9277
     let opt: &Option<i32> = &None;
     let value = opt.clone()?; // operator precedence needed (*opt)?
+    //
+    //~^^ clone_on_copy
     None
 }
diff --git a/src/tools/clippy/tests/ui/clone_on_copy.stderr b/src/tools/clippy/tests/ui/clone_on_copy.stderr
index 314fd13afca4..92cdd635d20a 100644
--- a/src/tools/clippy/tests/ui/clone_on_copy.stderr
+++ b/src/tools/clippy/tests/ui/clone_on_copy.stderr
@@ -8,49 +8,49 @@ LL |     42.clone();
    = help: to override `-D warnings` add `#[allow(clippy::clone_on_copy)]`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:27:5
+  --> tests/ui/clone_on_copy.rs:28:5
    |
 LL |     (&42).clone();
    |     ^^^^^^^^^^^^^ help: try dereferencing it: `*(&42)`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:30:5
+  --> tests/ui/clone_on_copy.rs:32:5
    |
 LL |     rc.borrow().clone();
    |     ^^^^^^^^^^^^^^^^^^^ help: try dereferencing it: `*rc.borrow()`
 
 error: using `clone` on type `u32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:33:5
+  --> tests/ui/clone_on_copy.rs:36:5
    |
 LL |     x.clone().rotate_left(1);
    |     ^^^^^^^^^ help: try removing the `clone` call: `x`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:47:5
+  --> tests/ui/clone_on_copy.rs:51:5
    |
 LL |     m!(42).clone();
    |     ^^^^^^^^^^^^^^ help: try removing the `clone` call: `m!(42)`
 
 error: using `clone` on type `[u32; 2]` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:57:5
+  --> tests/ui/clone_on_copy.rs:62:5
    |
 LL |     x.clone()[0];
    |     ^^^^^^^^^ help: try dereferencing it: `(*x)`
 
 error: using `clone` on type `char` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:67:14
+  --> tests/ui/clone_on_copy.rs:73:14
    |
 LL |     is_ascii('z'.clone());
    |              ^^^^^^^^^^^ help: try removing the `clone` call: `'z'`
 
 error: using `clone` on type `i32` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:71:14
+  --> tests/ui/clone_on_copy.rs:78:14
    |
 LL |     vec.push(42.clone());
    |              ^^^^^^^^^^ help: try removing the `clone` call: `42`
 
 error: using `clone` on type `Option<i32>` which implements the `Copy` trait
-  --> tests/ui/clone_on_copy.rs:75:17
+  --> tests/ui/clone_on_copy.rs:83:17
    |
 LL |     let value = opt.clone()?; // operator precedence needed (*opt)?
    |                 ^^^^^^^^^^^ help: try dereferencing it: `(*opt)`
diff --git a/src/tools/clippy/tests/ui/clone_on_copy_impl.rs b/src/tools/clippy/tests/ui/clone_on_copy_impl.rs
index 2d03544ad8b6..33375aead4d5 100644
--- a/src/tools/clippy/tests/ui/clone_on_copy_impl.rs
+++ b/src/tools/clippy/tests/ui/clone_on_copy_impl.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::non_canonical_clone_impl)]
 
 use std::fmt;
diff --git a/src/tools/clippy/tests/ui/cloned_instead_of_copied.fixed b/src/tools/clippy/tests/ui/cloned_instead_of_copied.fixed
index bc939bb3dbb9..0a1a59ddf9b8 100644
--- a/src/tools/clippy/tests/ui/cloned_instead_of_copied.fixed
+++ b/src/tools/clippy/tests/ui/cloned_instead_of_copied.fixed
@@ -5,10 +5,15 @@
 fn main() {
     // yay
     let _ = [1].iter().copied();
+    //~^ cloned_instead_of_copied
     let _ = vec!["hi"].iter().copied();
+    //~^ cloned_instead_of_copied
     let _ = Some(&1).copied();
+    //~^ cloned_instead_of_copied
     let _ = Box::new([1].iter()).copied();
+    //~^ cloned_instead_of_copied
     let _ = Box::new(Some(&1)).copied();
+    //~^ cloned_instead_of_copied
 
     // nay
     let _ = [String::new()].iter().cloned();
@@ -25,10 +30,15 @@ fn msrv_1_34() {
 fn msrv_1_35() {
     let _ = [1].iter().cloned();
     let _ = Some(&1).copied(); // Option::copied needs 1.35
+    //
+    //~^^ cloned_instead_of_copied
 }
 
 #[clippy::msrv = "1.36"]
 fn msrv_1_36() {
     let _ = [1].iter().copied(); // Iterator::copied needs 1.36
+    //
+    //~^^ cloned_instead_of_copied
     let _ = Some(&1).copied();
+    //~^ cloned_instead_of_copied
 }
diff --git a/src/tools/clippy/tests/ui/cloned_instead_of_copied.rs b/src/tools/clippy/tests/ui/cloned_instead_of_copied.rs
index 27346adbfbf1..c452dd007a1e 100644
--- a/src/tools/clippy/tests/ui/cloned_instead_of_copied.rs
+++ b/src/tools/clippy/tests/ui/cloned_instead_of_copied.rs
@@ -5,10 +5,15 @@
 fn main() {
     // yay
     let _ = [1].iter().cloned();
+    //~^ cloned_instead_of_copied
     let _ = vec!["hi"].iter().cloned();
+    //~^ cloned_instead_of_copied
     let _ = Some(&1).cloned();
+    //~^ cloned_instead_of_copied
     let _ = Box::new([1].iter()).cloned();
+    //~^ cloned_instead_of_copied
     let _ = Box::new(Some(&1)).cloned();
+    //~^ cloned_instead_of_copied
 
     // nay
     let _ = [String::new()].iter().cloned();
@@ -25,10 +30,15 @@ fn msrv_1_34() {
 fn msrv_1_35() {
     let _ = [1].iter().cloned();
     let _ = Some(&1).cloned(); // Option::copied needs 1.35
+    //
+    //~^^ cloned_instead_of_copied
 }
 
 #[clippy::msrv = "1.36"]
 fn msrv_1_36() {
     let _ = [1].iter().cloned(); // Iterator::copied needs 1.36
+    //
+    //~^^ cloned_instead_of_copied
     let _ = Some(&1).cloned();
+    //~^ cloned_instead_of_copied
 }
diff --git a/src/tools/clippy/tests/ui/cloned_instead_of_copied.stderr b/src/tools/clippy/tests/ui/cloned_instead_of_copied.stderr
index ad857c4ef7d0..bd741e41321b 100644
--- a/src/tools/clippy/tests/ui/cloned_instead_of_copied.stderr
+++ b/src/tools/clippy/tests/ui/cloned_instead_of_copied.stderr
@@ -8,43 +8,43 @@ LL |     let _ = [1].iter().cloned();
    = help: to override `-D warnings` add `#[allow(clippy::cloned_instead_of_copied)]`
 
 error: used `cloned` where `copied` could be used instead
-  --> tests/ui/cloned_instead_of_copied.rs:8:31
+  --> tests/ui/cloned_instead_of_copied.rs:9:31
    |
 LL |     let _ = vec!["hi"].iter().cloned();
    |                               ^^^^^^ help: try: `copied`
 
 error: used `cloned` where `copied` could be used instead
-  --> tests/ui/cloned_instead_of_copied.rs:9:22
+  --> tests/ui/cloned_instead_of_copied.rs:11:22
    |
 LL |     let _ = Some(&1).cloned();
    |                      ^^^^^^ help: try: `copied`
 
 error: used `cloned` where `copied` could be used instead
-  --> tests/ui/cloned_instead_of_copied.rs:10:34
+  --> tests/ui/cloned_instead_of_copied.rs:13:34
    |
 LL |     let _ = Box::new([1].iter()).cloned();
    |                                  ^^^^^^ help: try: `copied`
 
 error: used `cloned` where `copied` could be used instead
-  --> tests/ui/cloned_instead_of_copied.rs:11:32
+  --> tests/ui/cloned_instead_of_copied.rs:15:32
    |
 LL |     let _ = Box::new(Some(&1)).cloned();
    |                                ^^^^^^ help: try: `copied`
 
 error: used `cloned` where `copied` could be used instead
-  --> tests/ui/cloned_instead_of_copied.rs:27:22
+  --> tests/ui/cloned_instead_of_copied.rs:32:22
    |
 LL |     let _ = Some(&1).cloned(); // Option::copied needs 1.35
    |                      ^^^^^^ help: try: `copied`
 
 error: used `cloned` where `copied` could be used instead
-  --> tests/ui/cloned_instead_of_copied.rs:32:24
+  --> tests/ui/cloned_instead_of_copied.rs:39:24
    |
 LL |     let _ = [1].iter().cloned(); // Iterator::copied needs 1.36
    |                        ^^^^^^ help: try: `copied`
 
 error: used `cloned` where `copied` could be used instead
-  --> tests/ui/cloned_instead_of_copied.rs:33:22
+  --> tests/ui/cloned_instead_of_copied.rs:42:22
    |
 LL |     let _ = Some(&1).cloned();
    |                      ^^^^^^ help: try: `copied`
diff --git a/src/tools/clippy/tests/ui/cmp_null.fixed b/src/tools/clippy/tests/ui/cmp_null.fixed
index e5ab765bc861..140ddb10aeb8 100644
--- a/src/tools/clippy/tests/ui/cmp_null.fixed
+++ b/src/tools/clippy/tests/ui/cmp_null.fixed
@@ -7,26 +7,29 @@ fn main() {
     let x = 0;
     let p: *const usize = &x;
     if p.is_null() {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
-        //~| NOTE: `-D clippy::cmp-null` implied by `-D warnings`
+        //~^ cmp_null
+
         println!("This is surprising!");
     }
     if p.is_null() {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+        //~^ cmp_null
+
         println!("This is surprising!");
     }
 
     let mut y = 0;
     let mut m: *mut usize = &mut y;
     if m.is_null() {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+        //~^ cmp_null
+
         println!("This is surprising, too!");
     }
     if m.is_null() {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+        //~^ cmp_null
+
         println!("This is surprising, too!");
     }
 
     let _ = (x as *const ()).is_null();
-    //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+    //~^ cmp_null
 }
diff --git a/src/tools/clippy/tests/ui/cmp_null.rs b/src/tools/clippy/tests/ui/cmp_null.rs
index 257f7ba26627..16ed17765dac 100644
--- a/src/tools/clippy/tests/ui/cmp_null.rs
+++ b/src/tools/clippy/tests/ui/cmp_null.rs
@@ -7,26 +7,29 @@ fn main() {
     let x = 0;
     let p: *const usize = &x;
     if p == ptr::null() {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
-        //~| NOTE: `-D clippy::cmp-null` implied by `-D warnings`
+        //~^ cmp_null
+
         println!("This is surprising!");
     }
     if ptr::null() == p {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+        //~^ cmp_null
+
         println!("This is surprising!");
     }
 
     let mut y = 0;
     let mut m: *mut usize = &mut y;
     if m == ptr::null_mut() {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+        //~^ cmp_null
+
         println!("This is surprising, too!");
     }
     if ptr::null_mut() == m {
-        //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+        //~^ cmp_null
+
         println!("This is surprising, too!");
     }
 
     let _ = x as *const () == ptr::null();
-    //~^ ERROR: comparing with null is better expressed by the `.is_null()` method
+    //~^ cmp_null
 }
diff --git a/src/tools/clippy/tests/ui/cmp_null.stderr b/src/tools/clippy/tests/ui/cmp_null.stderr
index f3b35f3afba8..6821846d0466 100644
--- a/src/tools/clippy/tests/ui/cmp_null.stderr
+++ b/src/tools/clippy/tests/ui/cmp_null.stderr
@@ -14,19 +14,19 @@ LL |     if ptr::null() == p {
    |        ^^^^^^^^^^^^^^^^ help: try: `p.is_null()`
 
 error: comparing with null is better expressed by the `.is_null()` method
-  --> tests/ui/cmp_null.rs:21:8
+  --> tests/ui/cmp_null.rs:22:8
    |
 LL |     if m == ptr::null_mut() {
    |        ^^^^^^^^^^^^^^^^^^^^ help: try: `m.is_null()`
 
 error: comparing with null is better expressed by the `.is_null()` method
-  --> tests/ui/cmp_null.rs:25:8
+  --> tests/ui/cmp_null.rs:27:8
    |
 LL |     if ptr::null_mut() == m {
    |        ^^^^^^^^^^^^^^^^^^^^ help: try: `m.is_null()`
 
 error: comparing with null is better expressed by the `.is_null()` method
-  --> tests/ui/cmp_null.rs:30:13
+  --> tests/ui/cmp_null.rs:33:13
    |
 LL |     let _ = x as *const () == ptr::null();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(x as *const ()).is_null()`
diff --git a/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.fixed b/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
index 9fc70ab6f4a0..8d543b042200 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
+++ b/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.fixed
@@ -44,7 +44,9 @@ mod borrowed_eq_owned {
         let borrowed = Borrowed {};
 
         if borrowed == owned {}
+        //~^ cmp_owned
         if borrowed == owned {}
+        //~^ cmp_owned
     }
 }
 
@@ -63,7 +65,9 @@ mod owned_eq_borrowed {
         let borrowed = Borrowed {};
 
         if owned == borrowed {}
+        //~^ cmp_owned
         if owned == borrowed {}
+        //~^ cmp_owned
     }
 }
 
@@ -90,7 +94,9 @@ mod issue_4874 {
         let borrowed = Borrowed {};
 
         if borrowed == "Hi" {}
+        //~^ cmp_owned
         if borrowed == "Hi" {}
+        //~^ cmp_owned
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.rs b/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.rs
index 5cd43ea1d411..6da311c50ee7 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.rs
+++ b/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.rs
@@ -44,7 +44,9 @@ mod borrowed_eq_owned {
         let borrowed = Borrowed {};
 
         if borrowed.to_owned() == owned {}
+        //~^ cmp_owned
         if owned == borrowed.to_owned() {}
+        //~^ cmp_owned
     }
 }
 
@@ -63,7 +65,9 @@ mod owned_eq_borrowed {
         let borrowed = Borrowed {};
 
         if owned == borrowed.to_owned() {}
+        //~^ cmp_owned
         if borrowed.to_owned() == owned {}
+        //~^ cmp_owned
     }
 }
 
@@ -90,7 +94,9 @@ mod issue_4874 {
         let borrowed = Borrowed {};
 
         if "Hi" == borrowed.to_string() {}
+        //~^ cmp_owned
         if borrowed.to_string() == "Hi" {}
+        //~^ cmp_owned
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.stderr b/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
index e230d5f06bb0..1d2645d358f3 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
+++ b/src/tools/clippy/tests/ui/cmp_owned/asymmetric_partial_eq.stderr
@@ -8,7 +8,7 @@ LL |         if borrowed.to_owned() == owned {}
    = help: to override `-D warnings` add `#[allow(clippy::cmp_owned)]`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:47:21
+  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:48:21
    |
 LL |         if owned == borrowed.to_owned() {}
    |            ---------^^^^^^^^^^^^^^^^^^^
@@ -16,13 +16,13 @@ LL |         if owned == borrowed.to_owned() {}
    |            help: try: `borrowed == owned`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:65:21
+  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:67:21
    |
 LL |         if owned == borrowed.to_owned() {}
    |                     ^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:66:12
+  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:69:12
    |
 LL |         if borrowed.to_owned() == owned {}
    |            ^^^^^^^^^^^^^^^^^^^---------
@@ -30,7 +30,7 @@ LL |         if borrowed.to_owned() == owned {}
    |            help: try: `owned == borrowed`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:92:20
+  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:96:20
    |
 LL |         if "Hi" == borrowed.to_string() {}
    |            --------^^^^^^^^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL |         if "Hi" == borrowed.to_string() {}
    |            help: try: `borrowed == "Hi"`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:93:12
+  --> tests/ui/cmp_owned/asymmetric_partial_eq.rs:98:12
    |
 LL |         if borrowed.to_string() == "Hi" {}
    |            ^^^^^^^^^^^^^^^^^^^^ help: try: `borrowed`
diff --git a/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.fixed b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.fixed
index 40d7b5e49fcd..711fbca1c8d2 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.fixed
+++ b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.fixed
@@ -4,10 +4,12 @@ fn main() {
     let a = Foo;
 
     if a != "bar" {
+        //~^ cmp_owned
         println!("foo");
     }
 
     if a != "bar" {
+        //~^ cmp_owned
         println!("foo");
     }
 }
diff --git a/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.rs b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.rs
index 59a945668b2e..ce86bb3f7b5c 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.rs
+++ b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.rs
@@ -4,10 +4,12 @@ fn main() {
     let a = Foo;
 
     if a.to_string() != "bar" {
+        //~^ cmp_owned
         println!("foo");
     }
 
     if "bar" != a.to_string() {
+        //~^ cmp_owned
         println!("foo");
     }
 }
diff --git a/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.stderr b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.stderr
index cfb6978158b3..ca571837039d 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.stderr
+++ b/src/tools/clippy/tests/ui/cmp_owned/comparison_flip.stderr
@@ -8,7 +8,7 @@ LL |     if a.to_string() != "bar" {
    = help: to override `-D warnings` add `#[allow(clippy::cmp_owned)]`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/comparison_flip.rs:10:17
+  --> tests/ui/cmp_owned/comparison_flip.rs:11:17
    |
 LL |     if "bar" != a.to_string() {
    |        ---------^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed
index ab72e096cc7c..eb01633a25fd 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed
+++ b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.fixed
@@ -3,8 +3,10 @@
 fn main() {
     fn with_to_string(x: &str) {
         x != "foo";
+        //~^ cmp_owned
 
         "foo" != x;
+        //~^ cmp_owned
     }
 
     let x = "oh";
@@ -12,14 +14,18 @@ fn main() {
     with_to_string(x);
 
     x != "foo";
+    //~^ cmp_owned
 
     x != "foo";
+    //~^ cmp_owned
 
     42.to_string() == "42";
 
     Foo == Foo;
+    //~^ cmp_owned
 
     "abc".chars().filter(|c| *c != 'X');
+    //~^ cmp_owned
 
     "abc".chars().filter(|c| *c != 'X');
 }
diff --git a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs
index cb5268734d32..82409f27b129 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs
+++ b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.rs
@@ -3,8 +3,10 @@
 fn main() {
     fn with_to_string(x: &str) {
         x != "foo".to_string();
+        //~^ cmp_owned
 
         "foo".to_string() != x;
+        //~^ cmp_owned
     }
 
     let x = "oh";
@@ -12,14 +14,18 @@ fn main() {
     with_to_string(x);
 
     x != "foo".to_owned();
+    //~^ cmp_owned
 
     x != String::from("foo");
+    //~^ cmp_owned
 
     42.to_string() == "42";
 
     Foo.to_owned() == Foo;
+    //~^ cmp_owned
 
     "abc".chars().filter(|c| c.to_owned() != 'X');
+    //~^ cmp_owned
 
     "abc".chars().filter(|c| *c != 'X');
 }
diff --git a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr
index 41448e012003..ca2ab4484727 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr
+++ b/src/tools/clippy/tests/ui/cmp_owned/with_suggestion.stderr
@@ -8,31 +8,31 @@ LL |         x != "foo".to_string();
    = help: to override `-D warnings` add `#[allow(clippy::cmp_owned)]`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/with_suggestion.rs:7:9
+  --> tests/ui/cmp_owned/with_suggestion.rs:8:9
    |
 LL |         "foo".to_string() != x;
    |         ^^^^^^^^^^^^^^^^^ help: try: `"foo"`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/with_suggestion.rs:14:10
+  --> tests/ui/cmp_owned/with_suggestion.rs:16:10
    |
 LL |     x != "foo".to_owned();
    |          ^^^^^^^^^^^^^^^^ help: try: `"foo"`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/with_suggestion.rs:16:10
+  --> tests/ui/cmp_owned/with_suggestion.rs:19:10
    |
 LL |     x != String::from("foo");
    |          ^^^^^^^^^^^^^^^^^^^ help: try: `"foo"`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/with_suggestion.rs:20:5
+  --> tests/ui/cmp_owned/with_suggestion.rs:24:5
    |
 LL |     Foo.to_owned() == Foo;
    |     ^^^^^^^^^^^^^^ help: try: `Foo`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/with_suggestion.rs:22:30
+  --> tests/ui/cmp_owned/with_suggestion.rs:27:30
    |
 LL |     "abc".chars().filter(|c| c.to_owned() != 'X');
    |                              ^^^^^^^^^^^^ help: try: `*c`
diff --git a/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.rs b/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.rs
index 913aab727471..4e14c3054d9f 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.rs
+++ b/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.rs
@@ -5,13 +5,12 @@ fn main() {
     let x = &Baz;
     let y = &Baz;
     y.to_owned() == *x;
-    //~^ ERROR: this creates an owned instance just for comparison
-    //~| NOTE: `-D clippy::cmp-owned` implied by `-D warnings`
+    //~^ cmp_owned
 
     let x = &&Baz;
     let y = &Baz;
     y.to_owned() == **x;
-    //~^ ERROR: this creates an owned instance just for comparison
+    //~^ cmp_owned
 
     let x = 0u32;
     let y = U32Wrapper(x);
@@ -23,7 +22,7 @@ struct Foo;
 impl PartialEq for Foo {
     fn eq(&self, other: &Self) -> bool {
         self.to_owned() == *other
-        //~^ ERROR: this creates an owned instance just for comparison
+        //~^ cmp_owned
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.stderr b/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.stderr
index 13ca699b9fd3..c8e2efab4915 100644
--- a/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.stderr
+++ b/src/tools/clippy/tests/ui/cmp_owned/without_suggestion.stderr
@@ -8,13 +8,13 @@ LL |     y.to_owned() == *x;
    = help: to override `-D warnings` add `#[allow(clippy::cmp_owned)]`
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/without_suggestion.rs:13:5
+  --> tests/ui/cmp_owned/without_suggestion.rs:12:5
    |
 LL |     y.to_owned() == **x;
    |     ^^^^^^^^^^^^^^^^^^^ try implementing the comparison without allocating
 
 error: this creates an owned instance just for comparison
-  --> tests/ui/cmp_owned/without_suggestion.rs:25:9
+  --> tests/ui/cmp_owned/without_suggestion.rs:24:9
    |
 LL |         self.to_owned() == *other
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ try implementing the comparison without allocating
diff --git a/src/tools/clippy/tests/ui/cognitive_complexity.rs b/src/tools/clippy/tests/ui/cognitive_complexity.rs
index e8fd063a98f2..2dbec955f63f 100644
--- a/src/tools/clippy/tests/ui/cognitive_complexity.rs
+++ b/src/tools/clippy/tests/ui/cognitive_complexity.rs
@@ -4,7 +4,8 @@
 
 #[rustfmt::skip]
 fn main() {
-//~^ ERROR: the function has a cognitive complexity of (28/25)
+//~^ cognitive_complexity
+
     if true {
         println!("a");
     }
@@ -90,7 +91,8 @@ fn main() {
 
 #[clippy::cognitive_complexity = "1"]
 fn kaboom() {
-    //~^ ERROR: the function has a cognitive complexity of (7/1)
+    //~^ cognitive_complexity
+
     let n = 0;
     'a: for i in 0..20 {
         'b: for j in i..20 {
@@ -149,9 +151,10 @@ fn lots_of_short_circuits2() -> bool {
 
 #[clippy::cognitive_complexity = "1"]
 fn baa() {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     let x = || match 99 {
-        //~^ ERROR: the function has a cognitive complexity of (2/1)
+        //~^ cognitive_complexity
         0 => 0,
         1 => 1,
         2 => 2,
@@ -169,7 +172,8 @@ fn baa() {
 
 #[clippy::cognitive_complexity = "1"]
 fn bar() {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         _ => println!("bye"),
@@ -181,7 +185,8 @@ fn bar() {
 /// Tests are usually complex but simple at the same time. `clippy::cognitive_complexity` used to
 /// give lots of false-positives in tests.
 fn dont_warn_on_tests() {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         _ => println!("bye"),
@@ -190,7 +195,8 @@ fn dont_warn_on_tests() {
 
 #[clippy::cognitive_complexity = "1"]
 fn barr() {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         1 => println!("bla"),
@@ -201,7 +207,8 @@ fn barr() {
 
 #[clippy::cognitive_complexity = "1"]
 fn barr2() {
-    //~^ ERROR: the function has a cognitive complexity of (3/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         1 => println!("bla"),
@@ -218,7 +225,8 @@ fn barr2() {
 
 #[clippy::cognitive_complexity = "1"]
 fn barrr() {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         1 => panic!("bla"),
@@ -229,7 +237,8 @@ fn barrr() {
 
 #[clippy::cognitive_complexity = "1"]
 fn barrr2() {
-    //~^ ERROR: the function has a cognitive complexity of (3/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         1 => panic!("bla"),
@@ -246,7 +255,8 @@ fn barrr2() {
 
 #[clippy::cognitive_complexity = "1"]
 fn barrrr() {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         1 => println!("bla"),
@@ -257,7 +267,8 @@ fn barrrr() {
 
 #[clippy::cognitive_complexity = "1"]
 fn barrrr2() {
-    //~^ ERROR: the function has a cognitive complexity of (3/1)
+    //~^ cognitive_complexity
+
     match 99 {
         0 => println!("hi"),
         1 => println!("bla"),
@@ -274,7 +285,8 @@ fn barrrr2() {
 
 #[clippy::cognitive_complexity = "1"]
 fn cake() {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     if 4 == 5 {
         println!("yea");
     } else {
@@ -285,7 +297,8 @@ fn cake() {
 
 #[clippy::cognitive_complexity = "1"]
 pub fn read_file(input_path: &str) -> String {
-    //~^ ERROR: the function has a cognitive complexity of (4/1)
+    //~^ cognitive_complexity
+
     use std::fs::File;
     use std::io::{Read, Write};
     use std::path::Path;
@@ -317,7 +330,8 @@ enum Void {}
 
 #[clippy::cognitive_complexity = "1"]
 fn void(void: Void) {
-    //~^ ERROR: the function has a cognitive complexity of (2/1)
+    //~^ cognitive_complexity
+
     if true {
         match void {}
     }
@@ -369,7 +383,8 @@ fn early() -> Result<i32, &'static str> {
 #[rustfmt::skip]
 #[clippy::cognitive_complexity = "1"]
 fn early_ret() -> i32 {
-//~^ ERROR: the function has a cognitive complexity of (8/1)
+//~^ cognitive_complexity
+
     let a = if true { 42 } else { return 0; };
     let a = if a < 99 { 42 } else { return 0; };
     let a = if a < 99 { 42 } else { return 0; };
@@ -391,7 +406,8 @@ fn early_ret() -> i32 {
 #[clippy::cognitive_complexity = "1"]
 fn closures() {
     let x = |a: i32, b: i32| -> i32 {
-        //~^ ERROR: the function has a cognitive complexity of (2/1)
+        //~^ cognitive_complexity
+
         if true {
             println!("moo");
         }
@@ -405,7 +421,8 @@ struct Moo;
 #[clippy::cognitive_complexity = "1"]
 impl Moo {
     fn moo(&self) {
-        //~^ ERROR: the function has a cognitive complexity of (2/1)
+        //~^ cognitive_complexity
+
         if true {
             println!("moo");
         }
@@ -415,7 +432,8 @@ impl Moo {
 #[clippy::cognitive_complexity = "1"]
 mod issue9300 {
     async fn a() {
-        //~^ ERROR: the function has a cognitive complexity of (2/1)
+        //~^ cognitive_complexity
+
         let a = 0;
         if a == 0 {}
     }
@@ -423,7 +441,8 @@ mod issue9300 {
     pub struct S;
     impl S {
         pub async fn async_method() {
-            //~^ ERROR: the function has a cognitive complexity of (2/1)
+            //~^ cognitive_complexity
+
             let a = 0;
             if a == 0 {}
         }
diff --git a/src/tools/clippy/tests/ui/cognitive_complexity.stderr b/src/tools/clippy/tests/ui/cognitive_complexity.stderr
index 1e60247e5f58..52607b87c60e 100644
--- a/src/tools/clippy/tests/ui/cognitive_complexity.stderr
+++ b/src/tools/clippy/tests/ui/cognitive_complexity.stderr
@@ -9,7 +9,7 @@ LL | fn main() {
    = help: to override `-D warnings` add `#[allow(clippy::cognitive_complexity)]`
 
 error: the function has a cognitive complexity of (7/1)
-  --> tests/ui/cognitive_complexity.rs:92:4
+  --> tests/ui/cognitive_complexity.rs:93:4
    |
 LL | fn kaboom() {
    |    ^^^^^^
@@ -17,7 +17,7 @@ LL | fn kaboom() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:151:4
+  --> tests/ui/cognitive_complexity.rs:153:4
    |
 LL | fn baa() {
    |    ^^^
@@ -25,7 +25,7 @@ LL | fn baa() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:153:13
+  --> tests/ui/cognitive_complexity.rs:156:13
    |
 LL |     let x = || match 99 {
    |             ^^
@@ -33,7 +33,7 @@ LL |     let x = || match 99 {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:171:4
+  --> tests/ui/cognitive_complexity.rs:174:4
    |
 LL | fn bar() {
    |    ^^^
@@ -41,7 +41,7 @@ LL | fn bar() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:183:4
+  --> tests/ui/cognitive_complexity.rs:187:4
    |
 LL | fn dont_warn_on_tests() {
    |    ^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL | fn dont_warn_on_tests() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:192:4
+  --> tests/ui/cognitive_complexity.rs:197:4
    |
 LL | fn barr() {
    |    ^^^^
@@ -57,7 +57,7 @@ LL | fn barr() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (3/1)
-  --> tests/ui/cognitive_complexity.rs:203:4
+  --> tests/ui/cognitive_complexity.rs:209:4
    |
 LL | fn barr2() {
    |    ^^^^^
@@ -65,7 +65,7 @@ LL | fn barr2() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:220:4
+  --> tests/ui/cognitive_complexity.rs:227:4
    |
 LL | fn barrr() {
    |    ^^^^^
@@ -73,7 +73,7 @@ LL | fn barrr() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (3/1)
-  --> tests/ui/cognitive_complexity.rs:231:4
+  --> tests/ui/cognitive_complexity.rs:239:4
    |
 LL | fn barrr2() {
    |    ^^^^^^
@@ -81,7 +81,7 @@ LL | fn barrr2() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:248:4
+  --> tests/ui/cognitive_complexity.rs:257:4
    |
 LL | fn barrrr() {
    |    ^^^^^^
@@ -89,7 +89,7 @@ LL | fn barrrr() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (3/1)
-  --> tests/ui/cognitive_complexity.rs:259:4
+  --> tests/ui/cognitive_complexity.rs:269:4
    |
 LL | fn barrrr2() {
    |    ^^^^^^^
@@ -97,7 +97,7 @@ LL | fn barrrr2() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:276:4
+  --> tests/ui/cognitive_complexity.rs:287:4
    |
 LL | fn cake() {
    |    ^^^^
@@ -105,7 +105,7 @@ LL | fn cake() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (4/1)
-  --> tests/ui/cognitive_complexity.rs:287:8
+  --> tests/ui/cognitive_complexity.rs:299:8
    |
 LL | pub fn read_file(input_path: &str) -> String {
    |        ^^^^^^^^^
@@ -113,7 +113,7 @@ LL | pub fn read_file(input_path: &str) -> String {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:319:4
+  --> tests/ui/cognitive_complexity.rs:332:4
    |
 LL | fn void(void: Void) {
    |    ^^^^
@@ -121,7 +121,7 @@ LL | fn void(void: Void) {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (8/1)
-  --> tests/ui/cognitive_complexity.rs:371:4
+  --> tests/ui/cognitive_complexity.rs:385:4
    |
 LL | fn early_ret() -> i32 {
    |    ^^^^^^^^^
@@ -129,7 +129,7 @@ LL | fn early_ret() -> i32 {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:393:13
+  --> tests/ui/cognitive_complexity.rs:408:13
    |
 LL |     let x = |a: i32, b: i32| -> i32 {
    |             ^^^^^^^^^^^^^^^^
@@ -137,7 +137,7 @@ LL |     let x = |a: i32, b: i32| -> i32 {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:407:8
+  --> tests/ui/cognitive_complexity.rs:423:8
    |
 LL |     fn moo(&self) {
    |        ^^^
@@ -145,7 +145,7 @@ LL |     fn moo(&self) {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:417:14
+  --> tests/ui/cognitive_complexity.rs:434:14
    |
 LL |     async fn a() {
    |              ^
@@ -153,7 +153,7 @@ LL |     async fn a() {
    = help: you could split it up into multiple smaller functions
 
 error: the function has a cognitive complexity of (2/1)
-  --> tests/ui/cognitive_complexity.rs:425:22
+  --> tests/ui/cognitive_complexity.rs:443:22
    |
 LL |         pub async fn async_method() {
    |                      ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.rs b/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.rs
index 6f6e89983d2b..a260fdee3cfd 100644
--- a/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.rs
+++ b/src/tools/clippy/tests/ui/cognitive_complexity_attr_used.rs
@@ -7,7 +7,8 @@ fn main() {
 
 #[clippy::cognitive_complexity = "0"]
 fn kaboom() {
-    //~^ ERROR: the function has a cognitive complexity of (3/0)
+    //~^ cognitive_complexity
+
     if 42 == 43 {
         panic!();
     } else if "cake" == "lie" {
diff --git a/src/tools/clippy/tests/ui/collapsible_else_if.fixed b/src/tools/clippy/tests/ui/collapsible_else_if.fixed
index c2d76146c641..9f530ad670a0 100644
--- a/src/tools/clippy/tests/ui/collapsible_else_if.fixed
+++ b/src/tools/clippy/tests/ui/collapsible_else_if.fixed
@@ -11,12 +11,14 @@ fn main() {
     } else if y == "world" {
         println!("world!")
     }
+    //~^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
     } else if let Some(42) = Some(42) {
         println!("world!")
     }
+    //~^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
@@ -26,6 +28,7 @@ fn main() {
     else {
         println!("!")
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
@@ -35,6 +38,7 @@ fn main() {
     else {
         println!("!")
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if let Some(42) = Some(42) {
         print!("Hello ");
@@ -44,6 +48,7 @@ fn main() {
     else {
         println!("!")
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if let Some(42) = Some(42) {
         print!("Hello ");
@@ -53,6 +58,7 @@ fn main() {
     else {
         println!("!")
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if let Some(42) = Some(42) {
         print!("Hello ");
@@ -62,6 +68,7 @@ fn main() {
     else {
         println!("!")
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
@@ -77,4 +84,5 @@ fn main() {
 fn issue_7318() {
     if true { println!("I've been resolved!")
     }else if false {}
+    //~^^^ collapsible_else_if
 }
diff --git a/src/tools/clippy/tests/ui/collapsible_else_if.rs b/src/tools/clippy/tests/ui/collapsible_else_if.rs
index 3579e46cd447..2c646cd1d4da 100644
--- a/src/tools/clippy/tests/ui/collapsible_else_if.rs
+++ b/src/tools/clippy/tests/ui/collapsible_else_if.rs
@@ -13,6 +13,7 @@ fn main() {
             println!("world!")
         }
     }
+    //~^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
@@ -21,6 +22,7 @@ fn main() {
             println!("world!")
         }
     }
+    //~^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
@@ -32,6 +34,7 @@ fn main() {
             println!("!")
         }
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
@@ -43,6 +46,7 @@ fn main() {
             println!("!")
         }
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if let Some(42) = Some(42) {
         print!("Hello ");
@@ -54,6 +58,7 @@ fn main() {
             println!("!")
         }
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if let Some(42) = Some(42) {
         print!("Hello ");
@@ -65,6 +70,7 @@ fn main() {
             println!("!")
         }
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if let Some(42) = Some(42) {
         print!("Hello ");
@@ -76,6 +82,7 @@ fn main() {
             println!("!")
         }
     }
+    //~^^^^^^^^ collapsible_else_if
 
     if x == "hello" {
         print!("Hello ");
@@ -93,4 +100,5 @@ fn issue_7318() {
     }else{
         if false {}
     }
+    //~^^^ collapsible_else_if
 }
diff --git a/src/tools/clippy/tests/ui/collapsible_else_if.stderr b/src/tools/clippy/tests/ui/collapsible_else_if.stderr
index 45566a78bd81..7d80894cadbb 100644
--- a/src/tools/clippy/tests/ui/collapsible_else_if.stderr
+++ b/src/tools/clippy/tests/ui/collapsible_else_if.stderr
@@ -19,7 +19,7 @@ LL +     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:19:12
+  --> tests/ui/collapsible_else_if.rs:20:12
    |
 LL |       } else {
    |  ____________^
@@ -37,7 +37,7 @@ LL +     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:27:12
+  --> tests/ui/collapsible_else_if.rs:29:12
    |
 LL |       } else {
    |  ____________^
@@ -58,7 +58,7 @@ LL +     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:38:12
+  --> tests/ui/collapsible_else_if.rs:41:12
    |
 LL |       } else {
    |  ____________^
@@ -79,7 +79,7 @@ LL +     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:49:12
+  --> tests/ui/collapsible_else_if.rs:53:12
    |
 LL |       } else {
    |  ____________^
@@ -100,7 +100,7 @@ LL +     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:60:12
+  --> tests/ui/collapsible_else_if.rs:65:12
    |
 LL |       } else {
    |  ____________^
@@ -121,7 +121,7 @@ LL +     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:71:12
+  --> tests/ui/collapsible_else_if.rs:77:12
    |
 LL |       } else {
    |  ____________^
@@ -142,7 +142,7 @@ LL +     }
    |
 
 error: this `else { if .. }` block can be collapsed
-  --> tests/ui/collapsible_else_if.rs:93:10
+  --> tests/ui/collapsible_else_if.rs:100:10
    |
 LL |       }else{
    |  __________^
diff --git a/src/tools/clippy/tests/ui/collapsible_if.fixed b/src/tools/clippy/tests/ui/collapsible_if.fixed
index 44b0b6e73915..6e994018aef0 100644
--- a/src/tools/clippy/tests/ui/collapsible_if.fixed
+++ b/src/tools/clippy/tests/ui/collapsible_if.fixed
@@ -15,26 +15,32 @@ fn main() {
     if x == "hello" && y == "world" {
         println!("Hello world!");
     }
+    //~^^^^^ collapsible_if
 
     if (x == "hello" || x == "world") && (y == "world" || y == "hello") {
         println!("Hello world!");
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" && x == "world" && (y == "world" || y == "hello") {
         println!("Hello world!");
     }
+    //~^^^^^ collapsible_if
 
     if (x == "hello" || x == "world") && y == "world" && y == "hello" {
         println!("Hello world!");
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" && x == "world" && y == "world" && y == "hello" {
         println!("Hello world!");
     }
+    //~^^^^^ collapsible_if
 
     if 42 == 1337 && 'a' != 'A' {
         println!("world!")
     }
+    //~^^^^^ collapsible_if
 
     // Works because any if with an else statement cannot be collapsed.
     if x == "hello" {
@@ -89,6 +95,7 @@ fn main() {
     if x == "hello" && y == "world" { // Collapsible
         println!("Hello world!");
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" {
         print!("Hello ");
@@ -144,9 +151,11 @@ fn main() {
 
     // Fix #5962
     if matches!(true, true) && matches!(true, true) {}
+    //~^^^ collapsible_if
 
     // Issue #9375
     if matches!(true, true) && truth() && matches!(true, true) {}
+    //~^^^ collapsible_if
 
     if true {
         #[cfg(not(teehee))]
diff --git a/src/tools/clippy/tests/ui/collapsible_if.rs b/src/tools/clippy/tests/ui/collapsible_if.rs
index 563a273dcddd..5cf591a658c7 100644
--- a/src/tools/clippy/tests/ui/collapsible_if.rs
+++ b/src/tools/clippy/tests/ui/collapsible_if.rs
@@ -17,36 +17,42 @@ fn main() {
             println!("Hello world!");
         }
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" || x == "world" {
         if y == "world" || y == "hello" {
             println!("Hello world!");
         }
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" && x == "world" {
         if y == "world" || y == "hello" {
             println!("Hello world!");
         }
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" || x == "world" {
         if y == "world" && y == "hello" {
             println!("Hello world!");
         }
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" && x == "world" {
         if y == "world" && y == "hello" {
             println!("Hello world!");
         }
     }
+    //~^^^^^ collapsible_if
 
     if 42 == 1337 {
         if 'a' != 'A' {
             println!("world!")
         }
     }
+    //~^^^^^ collapsible_if
 
     // Works because any if with an else statement cannot be collapsed.
     if x == "hello" {
@@ -103,6 +109,7 @@ fn main() {
             println!("Hello world!");
         }
     }
+    //~^^^^^ collapsible_if
 
     if x == "hello" {
         print!("Hello ");
@@ -160,11 +167,13 @@ fn main() {
     if matches!(true, true) {
         if matches!(true, true) {}
     }
+    //~^^^ collapsible_if
 
     // Issue #9375
     if matches!(true, true) && truth() {
         if matches!(true, true) {}
     }
+    //~^^^ collapsible_if
 
     if true {
         #[cfg(not(teehee))]
diff --git a/src/tools/clippy/tests/ui/collapsible_if.stderr b/src/tools/clippy/tests/ui/collapsible_if.stderr
index 5bcbdf2fd08d..3cc3fe5534f2 100644
--- a/src/tools/clippy/tests/ui/collapsible_if.stderr
+++ b/src/tools/clippy/tests/ui/collapsible_if.stderr
@@ -18,7 +18,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:21:5
+  --> tests/ui/collapsible_if.rs:22:5
    |
 LL | /     if x == "hello" || x == "world" {
 LL | |         if y == "world" || y == "hello" {
@@ -35,7 +35,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:27:5
+  --> tests/ui/collapsible_if.rs:29:5
    |
 LL | /     if x == "hello" && x == "world" {
 LL | |         if y == "world" || y == "hello" {
@@ -52,7 +52,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:33:5
+  --> tests/ui/collapsible_if.rs:36:5
    |
 LL | /     if x == "hello" || x == "world" {
 LL | |         if y == "world" && y == "hello" {
@@ -69,7 +69,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:39:5
+  --> tests/ui/collapsible_if.rs:43:5
    |
 LL | /     if x == "hello" && x == "world" {
 LL | |         if y == "world" && y == "hello" {
@@ -86,7 +86,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:45:5
+  --> tests/ui/collapsible_if.rs:50:5
    |
 LL | /     if 42 == 1337 {
 LL | |         if 'a' != 'A' {
@@ -103,7 +103,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:101:5
+  --> tests/ui/collapsible_if.rs:107:5
    |
 LL | /     if x == "hello" {
 LL | |         if y == "world" { // Collapsible
@@ -120,7 +120,7 @@ LL +     }
    |
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:160:5
+  --> tests/ui/collapsible_if.rs:167:5
    |
 LL | /     if matches!(true, true) {
 LL | |         if matches!(true, true) {}
@@ -128,7 +128,7 @@ LL | |     }
    | |_____^ help: collapse nested if block: `if matches!(true, true) && matches!(true, true) {}`
 
 error: this `if` statement can be collapsed
-  --> tests/ui/collapsible_if.rs:165:5
+  --> tests/ui/collapsible_if.rs:173:5
    |
 LL | /     if matches!(true, true) && truth() {
 LL | |         if matches!(true, true) {}
diff --git a/src/tools/clippy/tests/ui/collapsible_match.rs b/src/tools/clippy/tests/ui/collapsible_match.rs
index 2264b560791a..796cabd4b669 100644
--- a/src/tools/clippy/tests/ui/collapsible_match.rs
+++ b/src/tools/clippy/tests/ui/collapsible_match.rs
@@ -12,7 +12,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // match without block
     match res_opt {
         Ok(val) => match val {
-            //~^ ERROR: this `match` can be collapsed into the outer `match`
+            //~^ collapsible_match
             Some(n) => foo(n),
             _ => return,
         },
@@ -22,7 +22,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // match with block
     match res_opt {
         Ok(val) => match val {
-            //~^ ERROR: this `match` can be collapsed into the outer `match`
+            //~^ collapsible_match
             Some(n) => foo(n),
             _ => return,
         },
@@ -32,7 +32,8 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // if let, if let
     if let Ok(val) = res_opt {
         if let Some(n) = val {
-            //~^ ERROR: this `if let` can be collapsed into the outer `if let`
+            //~^ collapsible_match
+
             take(n);
         }
     }
@@ -40,7 +41,8 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // if let else, if let else
     if let Ok(val) = res_opt {
         if let Some(n) = val {
-            //~^ ERROR: this `if let` can be collapsed into the outer `if let`
+            //~^ collapsible_match
+
             take(n);
         } else {
             return;
@@ -52,7 +54,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // if let, match
     if let Ok(val) = res_opt {
         match val {
-            //~^ ERROR: this `match` can be collapsed into the outer `if let`
+            //~^ collapsible_match
             Some(n) => foo(n),
             _ => (),
         }
@@ -62,7 +64,8 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     match res_opt {
         Ok(val) => {
             if let Some(n) = val {
-                //~^ ERROR: this `if let` can be collapsed into the outer `match`
+                //~^ collapsible_match
+
                 take(n);
             }
         },
@@ -72,7 +75,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // if let else, match
     if let Ok(val) = res_opt {
         match val {
-            //~^ ERROR: this `match` can be collapsed into the outer `if let`
+            //~^ collapsible_match
             Some(n) => foo(n),
             _ => return,
         }
@@ -84,7 +87,8 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     match res_opt {
         Ok(val) => {
             if let Some(n) = val {
-                //~^ ERROR: this `if let` can be collapsed into the outer `match`
+                //~^ collapsible_match
+
                 take(n);
             } else {
                 return;
@@ -96,7 +100,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // None in inner match same as outer wild branch
     match res_opt {
         Ok(val) => match val {
-            //~^ ERROR: this `match` can be collapsed into the outer `match`
+            //~^ collapsible_match
             Some(n) => foo(n),
             None => return,
         },
@@ -106,7 +110,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // None in outer match same as inner wild branch
     match opt_opt {
         Some(val) => match val {
-            //~^ ERROR: this `match` can be collapsed into the outer `match`
+            //~^ collapsible_match
             Some(n) => foo(n),
             _ => return,
         },
@@ -250,6 +254,7 @@ fn negative_cases(res_opt: Result<Option<u32>, String>, res_res: Result<Result<u
     #[clippy::msrv = "1.53.0"]
     let _ = match make::<Option<E<u32>>>() {
         Some(val) => match val {
+            //~^ collapsible_match
             E::A(val) | E::B(val) => foo(val),
             _ => return,
         },
@@ -281,7 +286,8 @@ pub enum Issue9647 {
 pub fn test_1(x: Issue9647) {
     if let Issue9647::A { a, .. } = x {
         if let Some(u) = a {
-            //~^ ERROR: this `if let` can be collapsed into the outer `if let`
+            //~^ collapsible_match
+
             println!("{u:?}")
         }
     }
@@ -290,7 +296,8 @@ pub fn test_1(x: Issue9647) {
 pub fn test_2(x: Issue9647) {
     if let Issue9647::A { a: Some(a), .. } = x {
         if let Some(u) = a {
-            //~^ ERROR: this `if let` can be collapsed into the outer `if let`
+            //~^ collapsible_match
+
             println!("{u}")
         }
     }
diff --git a/src/tools/clippy/tests/ui/collapsible_match.stderr b/src/tools/clippy/tests/ui/collapsible_match.stderr
index 1da78b56239c..5294a9d6975d 100644
--- a/src/tools/clippy/tests/ui/collapsible_match.stderr
+++ b/src/tools/clippy/tests/ui/collapsible_match.stderr
@@ -45,6 +45,7 @@ error: this `if let` can be collapsed into the outer `if let`
    |
 LL | /         if let Some(n) = val {
 LL | |
+LL | |
 LL | |             take(n);
 LL | |         }
    | |_________^
@@ -58,10 +59,11 @@ LL |         if let Some(n) = val {
    |                ^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `if let`
-  --> tests/ui/collapsible_match.rs:42:9
+  --> tests/ui/collapsible_match.rs:43:9
    |
 LL | /         if let Some(n) = val {
 LL | |
+LL | |
 LL | |             take(n);
 LL | |         } else {
 LL | |             return;
@@ -69,7 +71,7 @@ LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:41:15
+  --> tests/ui/collapsible_match.rs:42:15
    |
 LL |     if let Ok(val) = res_opt {
    |               ^^^ replace this binding
@@ -77,7 +79,7 @@ LL |         if let Some(n) = val {
    |                ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `if let`
-  --> tests/ui/collapsible_match.rs:54:9
+  --> tests/ui/collapsible_match.rs:56:9
    |
 LL | /         match val {
 LL | |
@@ -87,7 +89,7 @@ LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:53:15
+  --> tests/ui/collapsible_match.rs:55:15
    |
 LL |     if let Ok(val) = res_opt {
    |               ^^^ replace this binding
@@ -96,16 +98,17 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `match`
-  --> tests/ui/collapsible_match.rs:64:13
+  --> tests/ui/collapsible_match.rs:66:13
    |
 LL | /             if let Some(n) = val {
 LL | |
+LL | |
 LL | |                 take(n);
 LL | |             }
    | |_____________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:63:12
+  --> tests/ui/collapsible_match.rs:65:12
    |
 LL |         Ok(val) => {
    |            ^^^ replace this binding
@@ -113,7 +116,7 @@ LL |             if let Some(n) = val {
    |                    ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `if let`
-  --> tests/ui/collapsible_match.rs:74:9
+  --> tests/ui/collapsible_match.rs:77:9
    |
 LL | /         match val {
 LL | |
@@ -123,7 +126,7 @@ LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:73:15
+  --> tests/ui/collapsible_match.rs:76:15
    |
 LL |     if let Ok(val) = res_opt {
    |               ^^^ replace this binding
@@ -132,10 +135,11 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `match`
-  --> tests/ui/collapsible_match.rs:86:13
+  --> tests/ui/collapsible_match.rs:89:13
    |
 LL | /             if let Some(n) = val {
 LL | |
+LL | |
 LL | |                 take(n);
 LL | |             } else {
 LL | |                 return;
@@ -143,7 +147,7 @@ LL | |             }
    | |_____________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:85:12
+  --> tests/ui/collapsible_match.rs:88:12
    |
 LL |         Ok(val) => {
    |            ^^^ replace this binding
@@ -151,7 +155,7 @@ LL |             if let Some(n) = val {
    |                    ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `match`
-  --> tests/ui/collapsible_match.rs:98:20
+  --> tests/ui/collapsible_match.rs:102:20
    |
 LL |           Ok(val) => match val {
    |  ____________________^
@@ -162,7 +166,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:98:12
+  --> tests/ui/collapsible_match.rs:102:12
    |
 LL |         Ok(val) => match val {
    |            ^^^ replace this binding
@@ -171,7 +175,7 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `match`
-  --> tests/ui/collapsible_match.rs:108:22
+  --> tests/ui/collapsible_match.rs:112:22
    |
 LL |           Some(val) => match val {
    |  ______________________^
@@ -182,7 +186,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:108:14
+  --> tests/ui/collapsible_match.rs:112:14
    |
 LL |         Some(val) => match val {
    |              ^^^ replace this binding
@@ -191,34 +195,37 @@ LL |             Some(n) => foo(n),
    |             ^^^^^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `match`
-  --> tests/ui/collapsible_match.rs:252:22
+  --> tests/ui/collapsible_match.rs:256:22
    |
 LL |           Some(val) => match val {
    |  ______________________^
+LL | |
 LL | |             E::A(val) | E::B(val) => foo(val),
 LL | |             _ => return,
 LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:252:14
+  --> tests/ui/collapsible_match.rs:256:14
    |
 LL |         Some(val) => match val {
    |              ^^^ replace this binding
+LL |
 LL |             E::A(val) | E::B(val) => foo(val),
    |             ^^^^^^^^^^^^^^^^^^^^^ with this pattern
 
 error: this `if let` can be collapsed into the outer `if let`
-  --> tests/ui/collapsible_match.rs:283:9
+  --> tests/ui/collapsible_match.rs:288:9
    |
 LL | /         if let Some(u) = a {
 LL | |
+LL | |
 LL | |             println!("{u:?}")
 LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:282:27
+  --> tests/ui/collapsible_match.rs:287:27
    |
 LL |     if let Issue9647::A { a, .. } = x {
    |                           ^ replace this binding
@@ -226,16 +233,17 @@ LL |         if let Some(u) = a {
    |                ^^^^^^^ with this pattern, prefixed by `a`:
 
 error: this `if let` can be collapsed into the outer `if let`
-  --> tests/ui/collapsible_match.rs:292:9
+  --> tests/ui/collapsible_match.rs:298:9
    |
 LL | /         if let Some(u) = a {
 LL | |
+LL | |
 LL | |             println!("{u}")
 LL | |         }
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match.rs:291:35
+  --> tests/ui/collapsible_match.rs:297:35
    |
 LL |     if let Issue9647::A { a: Some(a), .. } = x {
    |                                   ^ replace this binding
diff --git a/src/tools/clippy/tests/ui/collapsible_match2.rs b/src/tools/clippy/tests/ui/collapsible_match2.rs
index 56801f99e454..ba7f2f2720dc 100644
--- a/src/tools/clippy/tests/ui/collapsible_match2.rs
+++ b/src/tools/clippy/tests/ui/collapsible_match2.rs
@@ -11,7 +11,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     {
         match res_opt {
             Ok(val) if make() => match val {
-                //~^ ERROR: this `match` can be collapsed into the outer `match`
+                //~^ collapsible_match
                 Some(n) => foo(n),
                 _ => return,
             },
@@ -19,7 +19,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
         }
         match res_opt {
             Ok(val) => match val {
-                //~^ ERROR: this `match` can be collapsed into the outer `match`
+                //~^ collapsible_match
                 Some(n) => foo(n),
                 _ => return,
             },
@@ -34,6 +34,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
             ($outer:expr => $pat:pat, $e:expr => $inner_pat:pat, $then:expr) => {
                 match $outer {
                     $pat => match $e {
+                        //~^ collapsible_match
                         $inner_pat => $then,
                         _ => return,
                     },
@@ -51,7 +52,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // deref reference value
     match Some(&[1]) {
         Some(s) => match *s {
-            //~^ ERROR: this `match` can be collapsed into the outer `match`
+            //~^ collapsible_match
             [n] => foo(n),
             _ => (),
         },
@@ -61,7 +62,7 @@ fn lint_cases(opt_opt: Option<Option<u32>>, res_opt: Result<Option<u32>, String>
     // ref pattern and deref
     match Some(&[1]) {
         Some(ref s) => match s {
-            //~^ ERROR: this `match` can be collapsed into the outer `match`
+            //~^ collapsible_match
             [n] => foo(n),
             _ => (),
         },
diff --git a/src/tools/clippy/tests/ui/collapsible_match2.stderr b/src/tools/clippy/tests/ui/collapsible_match2.stderr
index 13caa78fbeb5..7b2730637528 100644
--- a/src/tools/clippy/tests/ui/collapsible_match2.stderr
+++ b/src/tools/clippy/tests/ui/collapsible_match2.stderr
@@ -45,6 +45,7 @@ error: this `match` can be collapsed into the outer `match`
    |
 LL |                       $pat => match $e {
    |  _____________________________^
+LL | |
 LL | |                         $inner_pat => $then,
 LL | |                         _ => return,
 LL | |                     },
@@ -54,7 +55,7 @@ LL |           mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |           ------------------------------------------------ in this macro invocation
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match2.rs:48:28
+  --> tests/ui/collapsible_match2.rs:49:28
    |
 LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
    |                            ^^^          ^^^^^^^ with this pattern
@@ -63,7 +64,7 @@ LL |         mac!(res_opt => Ok(val), val => Some(n), foo(n));
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this `match` can be collapsed into the outer `match`
-  --> tests/ui/collapsible_match2.rs:53:20
+  --> tests/ui/collapsible_match2.rs:54:20
    |
 LL |           Some(s) => match *s {
    |  ____________________^
@@ -74,7 +75,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match2.rs:53:14
+  --> tests/ui/collapsible_match2.rs:54:14
    |
 LL |         Some(s) => match *s {
    |              ^ replace this binding
@@ -83,7 +84,7 @@ LL |             [n] => foo(n),
    |             ^^^ with this pattern
 
 error: this `match` can be collapsed into the outer `match`
-  --> tests/ui/collapsible_match2.rs:63:24
+  --> tests/ui/collapsible_match2.rs:64:24
    |
 LL |           Some(ref s) => match s {
    |  ________________________^
@@ -94,7 +95,7 @@ LL | |         },
    | |_________^
    |
 help: the outer pattern can be modified to include the inner pattern
-  --> tests/ui/collapsible_match2.rs:63:14
+  --> tests/ui/collapsible_match2.rs:64:14
    |
 LL |         Some(ref s) => match s {
    |              ^^^^^ replace this binding
diff --git a/src/tools/clippy/tests/ui/collapsible_str_replace.fixed b/src/tools/clippy/tests/ui/collapsible_str_replace.fixed
index 03b393d5a674..e9a7384b761b 100644
--- a/src/tools/clippy/tests/ui/collapsible_str_replace.fixed
+++ b/src/tools/clippy/tests/ui/collapsible_str_replace.fixed
@@ -16,32 +16,44 @@ fn main() {
 
     // LINT CASES
     let _ = "hesuo worpd".replace(['s', 'u'], "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace(['s', 'u'], l);
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace(['s', 'u', 'p'], "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd"
         .replace(['s', 'u', 'p', 'd'], "l");
 
     let _ = "hesuo world".replace([s, 'u'], "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace([s, 'u', 'p'], "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace([s, u, 'p'], "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace([s, u, p], "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worlp".replace(['s', 'u'], "l").replace('p', "d");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace('s', "x").replace(['u', 'p'], "l");
+    //~^ collapsible_str_replace
 
     // Note: Future iterations could lint `replace(|c| matches!(c, "su" | 'd' | 'p'), "l")`
     let _ = "hesudo worpd".replace("su", "l").replace(['d', 'p'], "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesudo worpd".replace([d, 'p'], "l").replace("su", "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo world".replace([get_filter(), 's'], "l");
+    //~^ collapsible_str_replace
 
     // NO LINT CASES
     let _ = "hesuo world".replace('s', "l").replace('u', "p");
@@ -79,4 +91,5 @@ fn msrv_1_57() {
 #[clippy::msrv = "1.58"]
 fn msrv_1_58() {
     let _ = "".replace(['a', 'b'], "1.58");
+    //~^ collapsible_str_replace
 }
diff --git a/src/tools/clippy/tests/ui/collapsible_str_replace.rs b/src/tools/clippy/tests/ui/collapsible_str_replace.rs
index 364e5493b872..4dc12c1b1c6e 100644
--- a/src/tools/clippy/tests/ui/collapsible_str_replace.rs
+++ b/src/tools/clippy/tests/ui/collapsible_str_replace.rs
@@ -16,35 +16,48 @@ fn main() {
 
     // LINT CASES
     let _ = "hesuo worpd".replace('s', "l").replace('u', "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace('s', l).replace('u', l);
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace('s', "l").replace('u', "l").replace('p', "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd"
         .replace('s', "l")
+        //~^ collapsible_str_replace
         .replace('u', "l")
         .replace('p', "l")
         .replace('d', "l");
 
     let _ = "hesuo world".replace(s, "l").replace('u', "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace(s, "l").replace('u', "l").replace('p', "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace('p', "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace(p, "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worlp".replace('s', "l").replace('u', "l").replace('p', "d");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo worpd".replace('s', "x").replace('u', "l").replace('p', "l");
+    //~^ collapsible_str_replace
 
     // Note: Future iterations could lint `replace(|c| matches!(c, "su" | 'd' | 'p'), "l")`
     let _ = "hesudo worpd".replace("su", "l").replace('d', "l").replace('p', "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesudo worpd".replace(d, "l").replace('p', "l").replace("su", "l");
+    //~^ collapsible_str_replace
 
     let _ = "hesuo world".replace(get_filter(), "l").replace('s', "l");
+    //~^ collapsible_str_replace
 
     // NO LINT CASES
     let _ = "hesuo world".replace('s', "l").replace('u', "p");
@@ -82,4 +95,5 @@ fn msrv_1_57() {
 #[clippy::msrv = "1.58"]
 fn msrv_1_58() {
     let _ = "".replace('a', "1.58").replace('b', "1.58");
+    //~^ collapsible_str_replace
 }
diff --git a/src/tools/clippy/tests/ui/collapsible_str_replace.stderr b/src/tools/clippy/tests/ui/collapsible_str_replace.stderr
index da681dffd875..a634b857dd46 100644
--- a/src/tools/clippy/tests/ui/collapsible_str_replace.stderr
+++ b/src/tools/clippy/tests/ui/collapsible_str_replace.stderr
@@ -8,83 +8,84 @@ LL |     let _ = "hesuo worpd".replace('s', "l").replace('u', "l");
    = help: to override `-D warnings` add `#[allow(clippy::collapsible_str_replace)]`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:20:27
+  --> tests/ui/collapsible_str_replace.rs:21:27
    |
 LL |     let _ = "hesuo worpd".replace('s', l).replace('u', l);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], l)`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:22:27
+  --> tests/ui/collapsible_str_replace.rs:24:27
    |
 LL |     let _ = "hesuo worpd".replace('s', "l").replace('u', "l").replace('p', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:25:10
+  --> tests/ui/collapsible_str_replace.rs:28:10
    |
 LL |           .replace('s', "l")
    |  __________^
+LL | |
 LL | |         .replace('u', "l")
 LL | |         .replace('p', "l")
 LL | |         .replace('d', "l");
    | |__________________________^ help: replace with: `replace(['s', 'u', 'p', 'd'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:30:27
+  --> tests/ui/collapsible_str_replace.rs:34:27
    |
 LL |     let _ = "hesuo world".replace(s, "l").replace('u', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, 'u'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:32:27
+  --> tests/ui/collapsible_str_replace.rs:37:27
    |
 LL |     let _ = "hesuo worpd".replace(s, "l").replace('u', "l").replace('p', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, 'u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:34:27
+  --> tests/ui/collapsible_str_replace.rs:40:27
    |
 LL |     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace('p', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, u, 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:36:27
+  --> tests/ui/collapsible_str_replace.rs:43:27
    |
 LL |     let _ = "hesuo worpd".replace(s, "l").replace(u, "l").replace(p, "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([s, u, p], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:38:27
+  --> tests/ui/collapsible_str_replace.rs:46:27
    |
 LL |     let _ = "hesuo worlp".replace('s', "l").replace('u', "l").replace('p', "d");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['s', 'u'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:40:45
+  --> tests/ui/collapsible_str_replace.rs:49:45
    |
 LL |     let _ = "hesuo worpd".replace('s', "x").replace('u', "l").replace('p', "l");
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['u', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:43:47
+  --> tests/ui/collapsible_str_replace.rs:53:47
    |
 LL |     let _ = "hesudo worpd".replace("su", "l").replace('d', "l").replace('p', "l");
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['d', 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:45:28
+  --> tests/ui/collapsible_str_replace.rs:56:28
    |
 LL |     let _ = "hesudo worpd".replace(d, "l").replace('p', "l").replace("su", "l");
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([d, 'p'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:47:27
+  --> tests/ui/collapsible_str_replace.rs:59:27
    |
 LL |     let _ = "hesuo world".replace(get_filter(), "l").replace('s', "l");
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace([get_filter(), 's'], "l")`
 
 error: used consecutive `str::replace` call
-  --> tests/ui/collapsible_str_replace.rs:84:16
+  --> tests/ui/collapsible_str_replace.rs:97:16
    |
 LL |     let _ = "".replace('a', "1.58").replace('b', "1.58");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `replace(['a', 'b'], "1.58")`
diff --git a/src/tools/clippy/tests/ui/collection_is_never_read.rs b/src/tools/clippy/tests/ui/collection_is_never_read.rs
index eeb10da3402a..77cc84fef177 100644
--- a/src/tools/clippy/tests/ui/collection_is_never_read.rs
+++ b/src/tools/clippy/tests/ui/collection_is_never_read.rs
@@ -19,8 +19,8 @@ fn no_access_at_all() {
 fn write_without_read() {
     // The main use case for `collection_is_never_read`.
     let mut x = HashMap::new();
-    //~^ ERROR: collection is never read
-    //~| NOTE: `-D clippy::collection-is-never-read` implied by `-D warnings`
+    //~^ collection_is_never_read
+
     x.insert(1, 2);
 }
 
@@ -60,7 +60,8 @@ fn read_in_closure() {
 
 fn write_in_closure() {
     let mut x = vec![1, 2, 3];
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     let _ = || {
         x.push(4);
     };
@@ -76,13 +77,15 @@ fn shadowing_1() {
     let x = HashMap::<usize, usize>::new(); // Ok
     let _ = x.len();
     let mut x = HashMap::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(1, 2);
 }
 
 fn shadowing_2() {
     let mut x = HashMap::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(1, 2);
     let x = HashMap::<usize, usize>::new(); // Ok
     let _ = x.len();
@@ -91,21 +94,24 @@ fn shadowing_2() {
 #[allow(clippy::let_unit_value)]
 fn fake_read_1() {
     let mut x = vec![1, 2, 3];
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.reverse();
     let _: () = x.clear();
 }
 
 fn fake_read_2() {
     let mut x = vec![1, 2, 3];
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.reverse();
     println!("{:?}", x.push(5));
 }
 
 fn assignment() {
     let mut x = vec![1, 2, 3];
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     let y = vec![4, 5, 6]; // Ok
     x = y;
 }
@@ -113,7 +119,8 @@ fn assignment() {
 #[allow(clippy::self_assignment)]
 fn self_assignment() {
     let mut x = vec![1, 2, 3];
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x = x;
 }
 
@@ -131,7 +138,8 @@ fn method_argument_but_not_target() {
 
 fn insert_is_not_a_read() {
     let mut x = HashSet::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(5);
 }
 
@@ -146,7 +154,8 @@ fn not_read_if_return_value_not_used() {
     // `is_empty` does not modify the set, so it's a query. But since the return value is not used, the
     // lint does not consider it a read here.
     let x = vec![1, 2, 3];
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.is_empty();
 }
 
@@ -182,44 +191,54 @@ fn function_argument() {
 
 fn supported_types() {
     let mut x = std::collections::BTreeMap::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(true, 1);
 
     let mut x = std::collections::BTreeSet::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(1);
 
     let mut x = std::collections::BinaryHeap::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.push(1);
 
     let mut x = std::collections::HashMap::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(1, 2);
 
     let mut x = std::collections::HashSet::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(1);
 
     let mut x = std::collections::LinkedList::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.push_front(1);
 
     let mut x = Some(true);
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.insert(false);
 
     let mut x = String::from("hello");
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.push('!');
 
     let mut x = Vec::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.clear();
     x.push(1);
 
     let mut x = std::collections::VecDeque::new();
-    //~^ ERROR: collection is never read
+    //~^ collection_is_never_read
+
     x.push_front(1);
 }
 
diff --git a/src/tools/clippy/tests/ui/collection_is_never_read.stderr b/src/tools/clippy/tests/ui/collection_is_never_read.stderr
index f91ce07483c3..d92b84c4a652 100644
--- a/src/tools/clippy/tests/ui/collection_is_never_read.stderr
+++ b/src/tools/clippy/tests/ui/collection_is_never_read.stderr
@@ -14,109 +14,109 @@ LL |     let mut x = vec![1, 2, 3];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:78:5
+  --> tests/ui/collection_is_never_read.rs:79:5
    |
 LL |     let mut x = HashMap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:84:5
+  --> tests/ui/collection_is_never_read.rs:86:5
    |
 LL |     let mut x = HashMap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:93:5
+  --> tests/ui/collection_is_never_read.rs:96:5
    |
 LL |     let mut x = vec![1, 2, 3];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:100:5
+  --> tests/ui/collection_is_never_read.rs:104:5
    |
 LL |     let mut x = vec![1, 2, 3];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:107:5
+  --> tests/ui/collection_is_never_read.rs:112:5
    |
 LL |     let mut x = vec![1, 2, 3];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:115:5
+  --> tests/ui/collection_is_never_read.rs:121:5
    |
 LL |     let mut x = vec![1, 2, 3];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:133:5
+  --> tests/ui/collection_is_never_read.rs:140:5
    |
 LL |     let mut x = HashSet::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:148:5
+  --> tests/ui/collection_is_never_read.rs:156:5
    |
 LL |     let x = vec![1, 2, 3];
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:184:5
+  --> tests/ui/collection_is_never_read.rs:193:5
    |
 LL |     let mut x = std::collections::BTreeMap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:188:5
+  --> tests/ui/collection_is_never_read.rs:198:5
    |
 LL |     let mut x = std::collections::BTreeSet::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:192:5
+  --> tests/ui/collection_is_never_read.rs:203:5
    |
 LL |     let mut x = std::collections::BinaryHeap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:196:5
+  --> tests/ui/collection_is_never_read.rs:208:5
    |
 LL |     let mut x = std::collections::HashMap::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:200:5
+  --> tests/ui/collection_is_never_read.rs:213:5
    |
 LL |     let mut x = std::collections::HashSet::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:204:5
+  --> tests/ui/collection_is_never_read.rs:218:5
    |
 LL |     let mut x = std::collections::LinkedList::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:208:5
+  --> tests/ui/collection_is_never_read.rs:223:5
    |
 LL |     let mut x = Some(true);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:212:5
+  --> tests/ui/collection_is_never_read.rs:228:5
    |
 LL |     let mut x = String::from("hello");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:216:5
+  --> tests/ui/collection_is_never_read.rs:233:5
    |
 LL |     let mut x = Vec::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: collection is never read
-  --> tests/ui/collection_is_never_read.rs:221:5
+  --> tests/ui/collection_is_never_read.rs:239:5
    |
 LL |     let mut x = std::collections::VecDeque::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/comparison_chain.rs b/src/tools/clippy/tests/ui/comparison_chain.rs
index cab460d100dd..669690a4d42c 100644
--- a/src/tools/clippy/tests/ui/comparison_chain.rs
+++ b/src/tools/clippy/tests/ui/comparison_chain.rs
@@ -13,7 +13,8 @@ fn f(x: u8, y: u8, z: u8) {
     }
 
     if x > y {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         a()
     } else if x < y {
         b()
@@ -27,7 +28,8 @@ fn f(x: u8, y: u8, z: u8) {
     }
 
     if x > y {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         a()
     } else if x < y {
         b()
@@ -36,7 +38,8 @@ fn f(x: u8, y: u8, z: u8) {
     }
 
     if x > y {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         a()
     } else if y > x {
         b()
@@ -45,7 +48,8 @@ fn f(x: u8, y: u8, z: u8) {
     }
 
     if x > 1 {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         a()
     } else if x < 1 {
         b()
@@ -120,14 +124,16 @@ fn g(x: f64, y: f64, z: f64) {
 
 fn h<T: Ord>(x: T, y: T, z: T) {
     if x > y {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         a()
     } else if x < y {
         b()
     }
 
     if x > y {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         a()
     } else if x < y {
         b()
@@ -136,7 +142,8 @@ fn h<T: Ord>(x: T, y: T, z: T) {
     }
 
     if x > y {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         a()
     } else if y > x {
         b()
@@ -242,7 +249,8 @@ const fn sign_i8(n: i8) -> Sign {
 fn needs_parens() -> &'static str {
     let (x, y) = (1, 2);
     if x + 1 > y * 2 {
-        //~^ ERROR: `if` chain can be rewritten with `match`
+        //~^ comparison_chain
+
         "aa"
     } else if x + 1 < y * 2 {
         "bb"
diff --git a/src/tools/clippy/tests/ui/comparison_chain.stderr b/src/tools/clippy/tests/ui/comparison_chain.stderr
index 814004e3d4b1..0256573d0d90 100644
--- a/src/tools/clippy/tests/ui/comparison_chain.stderr
+++ b/src/tools/clippy/tests/ui/comparison_chain.stderr
@@ -3,6 +3,7 @@ error: `if` chain can be rewritten with `match`
    |
 LL | /     if x > y {
 LL | |
+LL | |
 LL | |         a()
 LL | |     } else if x < y {
 LL | |         b()
@@ -13,46 +14,47 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::comparison_chain)]`
 
 error: `if` chain can be rewritten with `match`
-  --> tests/ui/comparison_chain.rs:29:5
+  --> tests/ui/comparison_chain.rs:30:5
    |
 LL | /     if x > y {
 LL | |
+LL | |
 LL | |         a()
-LL | |     } else if x < y {
 ...  |
 LL | |         c()
 LL | |     }
    | |_____^ help: consider rewriting the `if` chain with `match`: `match x.cmp(&y) {...}`
 
 error: `if` chain can be rewritten with `match`
-  --> tests/ui/comparison_chain.rs:38:5
+  --> tests/ui/comparison_chain.rs:40:5
    |
 LL | /     if x > y {
 LL | |
+LL | |
 LL | |         a()
-LL | |     } else if y > x {
 ...  |
 LL | |         c()
 LL | |     }
    | |_____^ help: consider rewriting the `if` chain with `match`: `match x.cmp(&y) {...}`
 
 error: `if` chain can be rewritten with `match`
-  --> tests/ui/comparison_chain.rs:47:5
+  --> tests/ui/comparison_chain.rs:50:5
    |
 LL | /     if x > 1 {
 LL | |
+LL | |
 LL | |         a()
-LL | |     } else if x < 1 {
 ...  |
 LL | |         c()
 LL | |     }
    | |_____^ help: consider rewriting the `if` chain with `match`: `match x.cmp(&1) {...}`
 
 error: `if` chain can be rewritten with `match`
-  --> tests/ui/comparison_chain.rs:122:5
+  --> tests/ui/comparison_chain.rs:126:5
    |
 LL | /     if x > y {
 LL | |
+LL | |
 LL | |         a()
 LL | |     } else if x < y {
 LL | |         b()
@@ -60,36 +62,36 @@ LL | |     }
    | |_____^ help: consider rewriting the `if` chain with `match`: `match x.cmp(&y) {...}`
 
 error: `if` chain can be rewritten with `match`
-  --> tests/ui/comparison_chain.rs:129:5
+  --> tests/ui/comparison_chain.rs:134:5
    |
 LL | /     if x > y {
 LL | |
+LL | |
 LL | |         a()
-LL | |     } else if x < y {
 ...  |
 LL | |         c()
 LL | |     }
    | |_____^ help: consider rewriting the `if` chain with `match`: `match x.cmp(&y) {...}`
 
 error: `if` chain can be rewritten with `match`
-  --> tests/ui/comparison_chain.rs:138:5
+  --> tests/ui/comparison_chain.rs:144:5
    |
 LL | /     if x > y {
 LL | |
+LL | |
 LL | |         a()
-LL | |     } else if y > x {
 ...  |
 LL | |         c()
 LL | |     }
    | |_____^ help: consider rewriting the `if` chain with `match`: `match x.cmp(&y) {...}`
 
 error: `if` chain can be rewritten with `match`
-  --> tests/ui/comparison_chain.rs:244:5
+  --> tests/ui/comparison_chain.rs:251:5
    |
 LL | /     if x + 1 > y * 2 {
 LL | |
+LL | |
 LL | |         "aa"
-LL | |     } else if x + 1 < y * 2 {
 ...  |
 LL | |         "cc"
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/comparison_to_empty.fixed b/src/tools/clippy/tests/ui/comparison_to_empty.fixed
index a2a3dd9086d4..dfbb61683840 100644
--- a/src/tools/clippy/tests/ui/comparison_to_empty.fixed
+++ b/src/tools/clippy/tests/ui/comparison_to_empty.fixed
@@ -6,17 +6,26 @@ fn main() {
     // Disallow comparisons to empty
     let s = String::new();
     let _ = s.is_empty();
+    //~^ comparison_to_empty
     let _ = !s.is_empty();
+    //~^ comparison_to_empty
 
     let v = vec![0];
     let _ = v.is_empty();
+    //~^ comparison_to_empty
     let _ = !v.is_empty();
+    //~^ comparison_to_empty
     if (*v).is_empty() {}
+    //~^ comparison_to_empty
     let s = [0].as_slice();
     if s.is_empty() {}
+    //~^ comparison_to_empty
     if s.is_empty() {}
+    //~^ comparison_to_empty
     if s.is_empty()
+    //~^ comparison_to_empty
         && s.is_empty()
+    //~^ comparison_to_empty
     {}
 
     // Allow comparisons to non-empty
@@ -37,8 +46,12 @@ fn main() {
     // Also lint the `PartialEq` methods
     let s = String::new();
     let _ = s.is_empty();
+    //~^ comparison_to_empty
     let _ = !s.is_empty();
+    //~^ comparison_to_empty
     let v = vec![0];
     let _ = v.is_empty();
+    //~^ comparison_to_empty
     let _ = !v.is_empty();
+    //~^ comparison_to_empty
 }
diff --git a/src/tools/clippy/tests/ui/comparison_to_empty.rs b/src/tools/clippy/tests/ui/comparison_to_empty.rs
index 7c5689a4bbec..61cdb2bbe9f8 100644
--- a/src/tools/clippy/tests/ui/comparison_to_empty.rs
+++ b/src/tools/clippy/tests/ui/comparison_to_empty.rs
@@ -6,17 +6,26 @@ fn main() {
     // Disallow comparisons to empty
     let s = String::new();
     let _ = s == "";
+    //~^ comparison_to_empty
     let _ = s != "";
+    //~^ comparison_to_empty
 
     let v = vec![0];
     let _ = v == [];
+    //~^ comparison_to_empty
     let _ = v != [];
+    //~^ comparison_to_empty
     if let [] = &*v {}
+    //~^ comparison_to_empty
     let s = [0].as_slice();
     if let [] = s {}
+    //~^ comparison_to_empty
     if let [] = &*s {}
+    //~^ comparison_to_empty
     if let [] = &*s
+    //~^ comparison_to_empty
         && s == []
+    //~^ comparison_to_empty
     {}
 
     // Allow comparisons to non-empty
@@ -37,8 +46,12 @@ fn main() {
     // Also lint the `PartialEq` methods
     let s = String::new();
     let _ = s.eq("");
+    //~^ comparison_to_empty
     let _ = s.ne("");
+    //~^ comparison_to_empty
     let v = vec![0];
     let _ = v.eq(&[]);
+    //~^ comparison_to_empty
     let _ = v.ne(&[]);
+    //~^ comparison_to_empty
 }
diff --git a/src/tools/clippy/tests/ui/comparison_to_empty.stderr b/src/tools/clippy/tests/ui/comparison_to_empty.stderr
index 2ee0efc7dbb1..00a50430a3ee 100644
--- a/src/tools/clippy/tests/ui/comparison_to_empty.stderr
+++ b/src/tools/clippy/tests/ui/comparison_to_empty.stderr
@@ -8,73 +8,73 @@ LL |     let _ = s == "";
    = help: to override `-D warnings` add `#[allow(clippy::comparison_to_empty)]`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:9:13
+  --> tests/ui/comparison_to_empty.rs:10:13
    |
 LL |     let _ = s != "";
    |             ^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!s.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:12:13
+  --> tests/ui/comparison_to_empty.rs:14:13
    |
 LL |     let _ = v == [];
    |             ^^^^^^^ help: using `is_empty` is clearer and more explicit: `v.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:13:13
+  --> tests/ui/comparison_to_empty.rs:16:13
    |
 LL |     let _ = v != [];
    |             ^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!v.is_empty()`
 
 error: comparison to empty slice using `if let`
-  --> tests/ui/comparison_to_empty.rs:14:8
+  --> tests/ui/comparison_to_empty.rs:18:8
    |
 LL |     if let [] = &*v {}
    |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(*v).is_empty()`
 
 error: comparison to empty slice using `if let`
-  --> tests/ui/comparison_to_empty.rs:16:8
+  --> tests/ui/comparison_to_empty.rs:21:8
    |
 LL |     if let [] = s {}
    |        ^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
 
 error: comparison to empty slice using `if let`
-  --> tests/ui/comparison_to_empty.rs:17:8
+  --> tests/ui/comparison_to_empty.rs:23:8
    |
 LL |     if let [] = &*s {}
    |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
 
 error: comparison to empty slice using `if let`
-  --> tests/ui/comparison_to_empty.rs:18:8
+  --> tests/ui/comparison_to_empty.rs:25:8
    |
 LL |     if let [] = &*s
    |        ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:19:12
+  --> tests/ui/comparison_to_empty.rs:27:12
    |
 LL |         && s == []
    |            ^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:39:13
+  --> tests/ui/comparison_to_empty.rs:48:13
    |
 LL |     let _ = s.eq("");
    |             ^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:40:13
+  --> tests/ui/comparison_to_empty.rs:50:13
    |
 LL |     let _ = s.ne("");
    |             ^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!s.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:42:13
+  --> tests/ui/comparison_to_empty.rs:53:13
    |
 LL |     let _ = v.eq(&[]);
    |             ^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `v.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/comparison_to_empty.rs:43:13
+  --> tests/ui/comparison_to_empty.rs:55:13
    |
 LL |     let _ = v.ne(&[]);
    |             ^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!v.is_empty()`
diff --git a/src/tools/clippy/tests/ui/const_comparisons.rs b/src/tools/clippy/tests/ui/const_comparisons.rs
index 0898b4ebd465..b732d7d142fc 100644
--- a/src/tools/clippy/tests/ui/const_comparisons.rs
+++ b/src/tools/clippy/tests/ui/const_comparisons.rs
@@ -43,42 +43,39 @@ fn main() {
     // Correct
     status_code >= 400 && status_code < 500;
     status_code <= 400 && status_code > 500;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `400` < `500`, the expression evaluates to false for any value of `st
+    //~^ impossible_comparisons
+
     status_code > 500 && status_code < 400;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `500` > `400`, the expression evaluates to false for any value of `st
+    //~^ impossible_comparisons
+
     status_code < 500 && status_code > 500;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: `status_code` cannot simultaneously be greater than and less than `500`
+    //~^ impossible_comparisons
 
     // More complex expressions
     status_code < { 400 } && status_code > { 500 };
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any valu
+    //~^ impossible_comparisons
+
     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluate
+    //~^ impossible_comparisons
+
     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to f
+    //~^ impossible_comparisons
+
     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: `status_code` cannot simultaneously be greater than and less than `STATUS_S
+    //~^ impossible_comparisons
 
     // Comparing two different types, via the `impl PartialOrd<u16> for Status`
     status < { 400 } && status > { 500 };
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any valu
+    //~^ impossible_comparisons
+
     status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluate
+    //~^ impossible_comparisons
+
     status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to f
+    //~^ impossible_comparisons
+
     status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: `status` cannot simultaneously be greater than and less than `STATUS_SERVER
+    //~^ impossible_comparisons
 
     // Yoda conditions
     // Correct
@@ -87,12 +84,11 @@ fn main() {
     500 <= status_code && status_code <= 600;
     // Incorrect
     500 >= status_code && 600 < status_code;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `500` < `600`, the expression evaluates to false for any value of `st
+    //~^ impossible_comparisons
+
     // Incorrect
     500 >= status_code && status_code > 600;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `500` < `600`, the expression evaluates to false for any value of `st
+    //~^ impossible_comparisons
 
     // Yoda conditions, comparing two different types
     // Correct
@@ -101,50 +97,49 @@ fn main() {
     500 <= status && status <= 600;
     // Incorrect
     500 >= status && 600 < status;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `500` < `600`, the expression evaluates to false for any value of `st
+    //~^ impossible_comparisons
+
     // Incorrect
     500 >= status && status > 600;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `500` < `600`, the expression evaluates to false for any value of `st
+    //~^ impossible_comparisons
 
     // Expressions where one of the sides has no effect
     status_code < 200 && status_code <= 299;
-    //~^ ERROR: right-hand side of `&&` operator has no effect
+    //~^ redundant_comparisons
+
     status_code > 200 && status_code >= 299;
-    //~^ ERROR: left-hand side of `&&` operator has no effect
+    //~^ redundant_comparisons
 
     // Useless left
     status_code >= 500 && status_code > 500;
-    //~^ ERROR: left-hand side of `&&` operator has no effect
+    //~^ redundant_comparisons
+
     // Useless right
     status_code > 500 && status_code >= 500;
-    //~^ ERROR: right-hand side of `&&` operator has no effect
+    //~^ redundant_comparisons
+
     // Useless left
     status_code <= 500 && status_code < 500;
-    //~^ ERROR: left-hand side of `&&` operator has no effect
+    //~^ redundant_comparisons
+
     // Useless right
     status_code < 500 && status_code <= 500;
-    //~^ ERROR: right-hand side of `&&` operator has no effect
+    //~^ redundant_comparisons
 
     // Other types
     let name = "Steve";
     name < "Jennifer" && name > "Shannon";
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `"Jennifer"` < `"Shannon"`, the expression evaluates to false for any
+    //~^ impossible_comparisons
 
     let numbers = [1, 2];
     numbers < [3, 4] && numbers > [5, 6];
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `[3, 4]` < `[5, 6]`, the expression evaluates to false for any value
+    //~^ impossible_comparisons
 
     let letter = 'a';
     letter < 'b' && letter > 'c';
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `'b'` < `'c'`, the expression evaluates to false for any value of `le
+    //~^ impossible_comparisons
 
     let area = 42.0;
     area < std::f32::consts::E && area > std::f32::consts::PI;
-    //~^ ERROR: boolean expression will never evaluate to 'true'
-    //~| NOTE: since `std::f32::consts::E` < `std::f32::consts::PI`, the expression evalua
+    //~^ impossible_comparisons
 }
diff --git a/src/tools/clippy/tests/ui/const_comparisons.stderr b/src/tools/clippy/tests/ui/const_comparisons.stderr
index 1b8fd9733fae..48a2c6e8d487 100644
--- a/src/tools/clippy/tests/ui/const_comparisons.stderr
+++ b/src/tools/clippy/tests/ui/const_comparisons.stderr
@@ -25,7 +25,7 @@ LL |     status_code < 500 && status_code > 500;
    = note: `status_code` cannot simultaneously be greater than and less than `500`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:56:5
+  --> tests/ui/const_comparisons.rs:55:5
    |
 LL |     status_code < { 400 } && status_code > { 500 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     status_code < { 400 } && status_code > { 500 };
    = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:59:5
+  --> tests/ui/const_comparisons.rs:58:5
    |
 LL |     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     status_code < STATUS_BAD_REQUEST && status_code > STATUS_SERVER_ERROR;
    = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:62:5
+  --> tests/ui/const_comparisons.rs:61:5
    |
 LL |     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     status_code <= u16::MIN + 1 && status_code > STATUS_SERVER_ERROR;
    = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:65:5
+  --> tests/ui/const_comparisons.rs:64:5
    |
 LL |     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     status_code < STATUS_SERVER_ERROR && status_code > STATUS_SERVER_ERROR;
    = note: `status_code` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:70:5
+  --> tests/ui/const_comparisons.rs:68:5
    |
 LL |     status < { 400 } && status > { 500 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     status < { 400 } && status > { 500 };
    = note: since `{ 400 }` < `{ 500 }`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:73:5
+  --> tests/ui/const_comparisons.rs:71:5
    |
 LL |     status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     status < STATUS_BAD_REQUEST && status > STATUS_SERVER_ERROR;
    = note: since `STATUS_BAD_REQUEST` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:76:5
+  --> tests/ui/const_comparisons.rs:74:5
    |
 LL |     status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     status <= u16::MIN + 1 && status > STATUS_SERVER_ERROR;
    = note: since `u16::MIN + 1` < `STATUS_SERVER_ERROR`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:79:5
+  --> tests/ui/const_comparisons.rs:77:5
    |
 LL |     status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     status < STATUS_SERVER_ERROR && status > STATUS_SERVER_ERROR;
    = note: `status` cannot simultaneously be greater than and less than `STATUS_SERVER_ERROR`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:89:5
+  --> tests/ui/const_comparisons.rs:86:5
    |
 LL |     500 >= status_code && 600 < status_code;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     500 >= status_code && 600 < status_code;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:93:5
+  --> tests/ui/const_comparisons.rs:90:5
    |
 LL |     500 >= status_code && status_code > 600;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     500 >= status_code && status_code > 600;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status_code`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:103:5
+  --> tests/ui/const_comparisons.rs:99:5
    |
 LL |     500 >= status && 600 < status;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -113,7 +113,7 @@ LL |     500 >= status && 600 < status;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:107:5
+  --> tests/ui/const_comparisons.rs:103:5
    |
 LL |     500 >= status && status > 600;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,13 +121,13 @@ LL |     500 >= status && status > 600;
    = note: since `500` < `600`, the expression evaluates to false for any value of `status`
 
 error: right-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:112:5
+  --> tests/ui/const_comparisons.rs:107:5
    |
 LL |     status_code < 200 && status_code <= 299;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code < 200` evaluates to true, status_code <= 299` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:112:23
+  --> tests/ui/const_comparisons.rs:107:23
    |
 LL |     status_code < 200 && status_code <= 299;
    |                       ^^^^^^^^^^^^^^^^^^^^^
@@ -135,67 +135,67 @@ LL |     status_code < 200 && status_code <= 299;
    = help: to override `-D warnings` add `#[allow(clippy::redundant_comparisons)]`
 
 error: left-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:114:5
+  --> tests/ui/const_comparisons.rs:110:5
    |
 LL |     status_code > 200 && status_code >= 299;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code >= 299` evaluates to true, status_code > 200` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:114:5
+  --> tests/ui/const_comparisons.rs:110:5
    |
 LL |     status_code > 200 && status_code >= 299;
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: left-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:118:5
+  --> tests/ui/const_comparisons.rs:114:5
    |
 LL |     status_code >= 500 && status_code > 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:118:5
+  --> tests/ui/const_comparisons.rs:114:5
    |
 LL |     status_code >= 500 && status_code > 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: right-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:121:5
+  --> tests/ui/const_comparisons.rs:118:5
    |
 LL |     status_code > 500 && status_code >= 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code > 500` evaluates to true, status_code >= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:121:23
+  --> tests/ui/const_comparisons.rs:118:23
    |
 LL |     status_code > 500 && status_code >= 500;
    |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error: left-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:124:5
+  --> tests/ui/const_comparisons.rs:122:5
    |
 LL |     status_code <= 500 && status_code < 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:124:5
+  --> tests/ui/const_comparisons.rs:122:5
    |
 LL |     status_code <= 500 && status_code < 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: right-hand side of `&&` operator has no effect
-  --> tests/ui/const_comparisons.rs:127:5
+  --> tests/ui/const_comparisons.rs:126:5
    |
 LL |     status_code < 500 && status_code <= 500;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `if `status_code < 500` evaluates to true, status_code <= 500` will always evaluate to true as well
-  --> tests/ui/const_comparisons.rs:127:23
+  --> tests/ui/const_comparisons.rs:126:23
    |
 LL |     status_code < 500 && status_code <= 500;
    |                       ^^^^^^^^^^^^^^^^^^^^^
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:132:5
+  --> tests/ui/const_comparisons.rs:131:5
    |
 LL |     name < "Jennifer" && name > "Shannon";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -203,7 +203,7 @@ LL |     name < "Jennifer" && name > "Shannon";
    = note: since `"Jennifer"` < `"Shannon"`, the expression evaluates to false for any value of `name`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:137:5
+  --> tests/ui/const_comparisons.rs:135:5
    |
 LL |     numbers < [3, 4] && numbers > [5, 6];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -211,7 +211,7 @@ LL |     numbers < [3, 4] && numbers > [5, 6];
    = note: since `[3, 4]` < `[5, 6]`, the expression evaluates to false for any value of `numbers`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:142:5
+  --> tests/ui/const_comparisons.rs:139:5
    |
 LL |     letter < 'b' && letter > 'c';
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ LL |     letter < 'b' && letter > 'c';
    = note: since `'b'` < `'c'`, the expression evaluates to false for any value of `letter`
 
 error: boolean expression will never evaluate to 'true'
-  --> tests/ui/const_comparisons.rs:147:5
+  --> tests/ui/const_comparisons.rs:143:5
    |
 LL |     area < std::f32::consts::E && area > std::f32::consts::PI;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/const_is_empty.rs b/src/tools/clippy/tests/ui/const_is_empty.rs
index b5e27b61548a..8bb4f0e5d975 100644
--- a/src/tools/clippy/tests/ui/const_is_empty.rs
+++ b/src/tools/clippy/tests/ui/const_is_empty.rs
@@ -3,19 +3,19 @@
 
 fn test_literal() {
     if "".is_empty() {
-        //~^ERROR: this expression always evaluates to true
+        //~^ const_is_empty
     }
     if "foobar".is_empty() {
-        //~^ERROR: this expression always evaluates to false
+        //~^ const_is_empty
     }
 }
 
 fn test_byte_literal() {
     if b"".is_empty() {
-        //~^ERROR: this expression always evaluates to true
+        //~^ const_is_empty
     }
     if b"foobar".is_empty() {
-        //~^ERROR: this expression always evaluates to false
+        //~^ const_is_empty
     }
 }
 
@@ -32,10 +32,10 @@ fn test_propagated() {
     let empty2 = empty;
     let non_empty2 = non_empty;
     if empty2.is_empty() {
-        //~^ERROR: this expression always evaluates to true
+        //~^ const_is_empty
     }
     if non_empty2.is_empty() {
-        //~^ERROR: this expression always evaluates to false
+        //~^ const_is_empty
     }
 }
 
@@ -57,48 +57,65 @@ const NON_EMPTY_REF_ARRAY: &[u32; 3] = &[1, 2, 3];
 
 fn test_from_const() {
     let _ = EMPTY_STR.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_STR.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = EMPTY_BSTR.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_BSTR.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = EMPTY_ARRAY.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = EMPTY_ARRAY_REPEAT.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = EMPTY_U8_SLICE.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_U8_SLICE.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_ARRAY.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_ARRAY_REPEAT.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = EMPTY_REF_ARRAY.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_REF_ARRAY.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = EMPTY_SLICE.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_SLICE.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = NON_EMPTY_SLICE_REPEAT.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
 }
 
 fn main() {
     let value = "foobar";
     let _ = value.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let x = value;
     let _ = x.is_empty();
-    //~^ ERROR: this expression always evaluates to false
+    //~^ const_is_empty
+
     let _ = "".is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
+
     let _ = b"".is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
 }
 
 fn str_from_arg(var: &str) {
@@ -152,7 +169,7 @@ fn not_cfg_conditioned() {
     let val = "";
     #[cfg(not(target_os = "inexistent"))]
     let _ = val.is_empty();
-    //~^ ERROR: this expression always evaluates to true
+    //~^ const_is_empty
 }
 
 const fn const_rand() -> &'static str {
@@ -183,5 +200,6 @@ fn issue_13106() {
 
     const {
         EMPTY_STR.is_empty();
+        //~^ const_is_empty
     }
 }
diff --git a/src/tools/clippy/tests/ui/const_is_empty.stderr b/src/tools/clippy/tests/ui/const_is_empty.stderr
index 0afba940d8b4..2ba189058e83 100644
--- a/src/tools/clippy/tests/ui/const_is_empty.stderr
+++ b/src/tools/clippy/tests/ui/const_is_empty.stderr
@@ -44,121 +44,121 @@ LL |     let _ = EMPTY_STR.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:61:13
+  --> tests/ui/const_is_empty.rs:62:13
    |
 LL |     let _ = NON_EMPTY_STR.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:63:13
+  --> tests/ui/const_is_empty.rs:65:13
    |
 LL |     let _ = EMPTY_BSTR.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:65:13
+  --> tests/ui/const_is_empty.rs:68:13
    |
 LL |     let _ = NON_EMPTY_BSTR.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:67:13
+  --> tests/ui/const_is_empty.rs:71:13
    |
 LL |     let _ = EMPTY_ARRAY.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:69:13
+  --> tests/ui/const_is_empty.rs:74:13
    |
 LL |     let _ = EMPTY_ARRAY_REPEAT.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:71:13
+  --> tests/ui/const_is_empty.rs:77:13
    |
 LL |     let _ = EMPTY_U8_SLICE.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:73:13
+  --> tests/ui/const_is_empty.rs:80:13
    |
 LL |     let _ = NON_EMPTY_U8_SLICE.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:75:13
+  --> tests/ui/const_is_empty.rs:83:13
    |
 LL |     let _ = NON_EMPTY_ARRAY.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:77:13
+  --> tests/ui/const_is_empty.rs:86:13
    |
 LL |     let _ = NON_EMPTY_ARRAY_REPEAT.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:79:13
+  --> tests/ui/const_is_empty.rs:89:13
    |
 LL |     let _ = EMPTY_REF_ARRAY.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:81:13
+  --> tests/ui/const_is_empty.rs:92:13
    |
 LL |     let _ = NON_EMPTY_REF_ARRAY.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:83:13
+  --> tests/ui/const_is_empty.rs:95:13
    |
 LL |     let _ = EMPTY_SLICE.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:85:13
+  --> tests/ui/const_is_empty.rs:98:13
    |
 LL |     let _ = NON_EMPTY_SLICE.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:87:13
+  --> tests/ui/const_is_empty.rs:101:13
    |
 LL |     let _ = NON_EMPTY_SLICE_REPEAT.is_empty();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:93:13
+  --> tests/ui/const_is_empty.rs:107:13
    |
 LL |     let _ = value.is_empty();
    |             ^^^^^^^^^^^^^^^^
 
 error: this expression always evaluates to false
-  --> tests/ui/const_is_empty.rs:96:13
+  --> tests/ui/const_is_empty.rs:111:13
    |
 LL |     let _ = x.is_empty();
    |             ^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:98:13
+  --> tests/ui/const_is_empty.rs:114:13
    |
 LL |     let _ = "".is_empty();
    |             ^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:100:13
+  --> tests/ui/const_is_empty.rs:117:13
    |
 LL |     let _ = b"".is_empty();
    |             ^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:154:13
+  --> tests/ui/const_is_empty.rs:171:13
    |
 LL |     let _ = val.is_empty();
    |             ^^^^^^^^^^^^^^
 
 error: this expression always evaluates to true
-  --> tests/ui/const_is_empty.rs:185:9
+  --> tests/ui/const_is_empty.rs:202:9
    |
 LL |         EMPTY_STR.is_empty();
    |         ^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/copy_iterator.rs b/src/tools/clippy/tests/ui/copy_iterator.rs
index ea3a4face93f..5639583289d2 100644
--- a/src/tools/clippy/tests/ui/copy_iterator.rs
+++ b/src/tools/clippy/tests/ui/copy_iterator.rs
@@ -5,8 +5,8 @@
 struct Countdown(u8);
 
 impl Iterator for Countdown {
-    //~^ ERROR: you are implementing `Iterator` on a `Copy` type
-    //~| NOTE: consider implementing `IntoIterator` instead
+    //~^ copy_iterator
+
     type Item = u8;
 
     fn next(&mut self) -> Option<u8> {
diff --git a/src/tools/clippy/tests/ui/crashes/associated-constant-ice.rs b/src/tools/clippy/tests/ui/crashes/associated-constant-ice.rs
index fec16671eeb3..c5767cd656e9 100644
--- a/src/tools/clippy/tests/ui/crashes/associated-constant-ice.rs
+++ b/src/tools/clippy/tests/ui/crashes/associated-constant-ice.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/1698
 
 pub trait Trait {
diff --git a/src/tools/clippy/tests/ui/crashes/cc_seme.rs b/src/tools/clippy/tests/ui/crashes/cc_seme.rs
index 98897d6d7aaf..1d8e635ffe44 100644
--- a/src/tools/clippy/tests/ui/crashes/cc_seme.rs
+++ b/src/tools/clippy/tests/ui/crashes/cc_seme.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/478
 
 enum Baz {
diff --git a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.fixed b/src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.fixed
similarity index 65%
rename from src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.fixed
rename to src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.fixed
index 837069cae6d1..681887314ed5 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.fixed
+++ b/src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.fixed
@@ -1,4 +1,4 @@
-#![deny(clippy::needless_lifetimes)]
+#![deny(clippy::elidable_lifetime_names)]
 #![allow(dead_code)]
 
 trait Foo {}
@@ -10,10 +10,12 @@ struct Baz<'a> {
 }
 
 impl Foo for Baz<'_> {}
+//~^ elidable_lifetime_names
 
 impl Bar {
     fn baz(&self) -> impl Foo + '_ {
-        //~^ ERROR: the following explicit lifetimes could be elided: 'a
+        //~^ elidable_lifetime_names
+
         Baz { bar: self }
     }
 }
diff --git a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.rs b/src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.rs
similarity index 66%
rename from src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.rs
rename to src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.rs
index 06947e3a3513..ed5f95bdca82 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.rs
+++ b/src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.rs
@@ -1,4 +1,4 @@
-#![deny(clippy::needless_lifetimes)]
+#![deny(clippy::elidable_lifetime_names)]
 #![allow(dead_code)]
 
 trait Foo {}
@@ -10,10 +10,12 @@ struct Baz<'a> {
 }
 
 impl<'a> Foo for Baz<'a> {}
+//~^ elidable_lifetime_names
 
 impl Bar {
     fn baz<'a>(&'a self) -> impl Foo + 'a {
-        //~^ ERROR: the following explicit lifetimes could be elided: 'a
+        //~^ elidable_lifetime_names
+
         Baz { bar: self }
     }
 }
diff --git a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.stderr b/src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.stderr
similarity index 67%
rename from src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
rename to src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.stderr
index bed6aab25c4d..ef4b7e0a476e 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_lifetimes_impl_trait.stderr
+++ b/src/tools/clippy/tests/ui/crashes/elidable_lifetime_names_impl_trait.stderr
@@ -1,14 +1,14 @@
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/crashes/needless_lifetimes_impl_trait.rs:12:6
+  --> tests/ui/crashes/elidable_lifetime_names_impl_trait.rs:12:6
    |
 LL | impl<'a> Foo for Baz<'a> {}
    |      ^^              ^^
    |
 note: the lint level is defined here
-  --> tests/ui/crashes/needless_lifetimes_impl_trait.rs:1:9
+  --> tests/ui/crashes/elidable_lifetime_names_impl_trait.rs:1:9
    |
-LL | #![deny(clippy::needless_lifetimes)]
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #![deny(clippy::elidable_lifetime_names)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: elide the lifetimes
    |
 LL - impl<'a> Foo for Baz<'a> {}
@@ -16,7 +16,7 @@ LL + impl Foo for Baz<'_> {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/crashes/needless_lifetimes_impl_trait.rs:15:12
+  --> tests/ui/crashes/elidable_lifetime_names_impl_trait.rs:16:12
    |
 LL |     fn baz<'a>(&'a self) -> impl Foo + 'a {
    |            ^^   ^^                     ^^
diff --git a/src/tools/clippy/tests/ui/crashes/enum-glob-import-crate.rs b/src/tools/clippy/tests/ui/crashes/enum-glob-import-crate.rs
index dca32aa3b561..bbcd599f6d0b 100644
--- a/src/tools/clippy/tests/ui/crashes/enum-glob-import-crate.rs
+++ b/src/tools/clippy/tests/ui/crashes/enum-glob-import-crate.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![deny(clippy::all)]
 #![allow(unused_imports)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-10148.rs b/src/tools/clippy/tests/ui/crashes/ice-10148.rs
index d89d94edbcdb..8baaccd811d7 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-10148.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-10148.rs
@@ -6,4 +6,5 @@ use proc_macros::with_span;
 
 fn main() {
     println!(with_span!(""something ""));
+    //~^ println_empty_string
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-10508a.rs b/src/tools/clippy/tests/ui/crashes/ice-10508a.rs
new file mode 100644
index 000000000000..43da01344555
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-10508a.rs
@@ -0,0 +1,20 @@
+//@ check-pass
+// Used to overflow in `is_normalizable`
+
+use std::marker::PhantomData;
+
+struct Node<T: 'static> {
+    m: PhantomData<&'static T>,
+}
+
+struct Digit<T> {
+    elem: T,
+}
+
+enum FingerTree<T: 'static> {
+    Single(T),
+
+    Deep(Digit<T>, Box<FingerTree<Node<T>>>),
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-10508b.rs b/src/tools/clippy/tests/ui/crashes/ice-10508b.rs
new file mode 100644
index 000000000000..7588419381cf
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-10508b.rs
@@ -0,0 +1,26 @@
+//@ check-pass
+
+use std::marker::PhantomData;
+
+struct Digit<T> {
+    elem: T,
+}
+
+struct Node<T: 'static> {
+    m: PhantomData<&'static T>,
+}
+
+enum FingerTree<T: 'static> {
+    Single(T),
+
+    Deep(Digit<T>, Node<FingerTree<Node<T>>>),
+}
+
+enum Wrapper<T: 'static> {
+    Simple,
+    Other(FingerTree<T>),
+}
+
+fn main() {
+    let w = Some(Wrapper::Simple::<u32>);
+}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-10508c.rs b/src/tools/clippy/tests/ui/crashes/ice-10508c.rs
new file mode 100644
index 000000000000..d207fdb2c87a
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-10508c.rs
@@ -0,0 +1,9 @@
+//@ check-pass
+
+#[derive(Debug)]
+struct S<T> {
+    t: T,
+    s: Box<S<fn(u: T)>>,
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-10972-tait.rs b/src/tools/clippy/tests/ui/crashes/ice-10972-tait.rs
index f3ab9cebb7c2..11ddbfc3a04b 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-10972-tait.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-10972-tait.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // ICE: #10972
 // asked to assemble constituent types of unexpected type: Binder(Foo, [])
 #![feature(type_alias_impl_trait)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11065.rs b/src/tools/clippy/tests/ui/crashes/ice-11065.rs
index a17d7e38e0c3..434f11a2c577 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11065.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-11065.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::useless_conversion)]
 
 use std::option::IntoIter as OptionIter;
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11230.fixed b/src/tools/clippy/tests/ui/crashes/ice-11230.fixed
index 1d4c3dd9dcc4..181e1ebbe5a3 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11230.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-11230.fixed
@@ -6,6 +6,7 @@
 fn main() {
     const A: &[for<'a> fn(&'a ())] = &[];
     for v in A {}
+    //~^ explicit_iter_loop
 }
 
 // needless_collect
@@ -13,4 +14,5 @@ trait Helper<'a>: Iterator<Item = fn()> {}
 
 fn x(w: &mut dyn for<'a> Helper<'a>) {
     w.next().is_none();
+    //~^ needless_collect
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11230.rs b/src/tools/clippy/tests/ui/crashes/ice-11230.rs
index a16fb271497c..fb05dc781bc0 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11230.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-11230.rs
@@ -6,6 +6,7 @@
 fn main() {
     const A: &[for<'a> fn(&'a ())] = &[];
     for v in A.iter() {}
+    //~^ explicit_iter_loop
 }
 
 // needless_collect
@@ -13,4 +14,5 @@ trait Helper<'a>: Iterator<Item = fn()> {}
 
 fn x(w: &mut dyn for<'a> Helper<'a>) {
     w.collect::<Vec<_>>().is_empty();
+    //~^ needless_collect
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11230.stderr b/src/tools/clippy/tests/ui/crashes/ice-11230.stderr
index 7167d90e456e..b4a3f67081ae 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11230.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-11230.stderr
@@ -8,7 +8,7 @@ LL |     for v in A.iter() {}
    = help: to override `-D warnings` add `#[allow(clippy::explicit_iter_loop)]`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/crashes/ice-11230.rs:15:7
+  --> tests/ui/crashes/ice-11230.rs:16:7
    |
 LL |     w.collect::<Vec<_>>().is_empty();
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11337.rs b/src/tools/clippy/tests/ui/crashes/ice-11337.rs
index 0bed4035f6bf..317b7a7083a6 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11337.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-11337.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![feature(trait_alias)]
 
 trait Confusing<F> = Fn(i32) where F: Fn(u32);
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11422.fixed b/src/tools/clippy/tests/ui/crashes/ice-11422.fixed
index d996b1db08a6..be07a9d8c1f9 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11422.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-11422.fixed
@@ -4,6 +4,7 @@ use std::fmt::Debug;
 use std::ops::*;
 
 fn r#gen() -> impl PartialOrd + Debug {}
+//~^ implied_bounds_in_impls
 
 struct Bar {}
 trait Foo<T = Self> {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11422.rs b/src/tools/clippy/tests/ui/crashes/ice-11422.rs
index eb89b7c38f43..43de882caa11 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11422.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-11422.rs
@@ -4,6 +4,7 @@ use std::fmt::Debug;
 use std::ops::*;
 
 fn r#gen() -> impl PartialOrd + PartialEq + Debug {}
+//~^ implied_bounds_in_impls
 
 struct Bar {}
 trait Foo<T = Self> {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11755.rs b/src/tools/clippy/tests/ui/crashes/ice-11755.rs
index 367cb6998578..d6aa1e5183d2 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11755.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-11755.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::unused_enumerate_index)]
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11803.rs b/src/tools/clippy/tests/ui/crashes/ice-11803.rs
index 1bb8bf0c746b..e85f31909388 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11803.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-11803.rs
@@ -3,6 +3,8 @@
 #![warn(clippy::impl_trait_in_params)]
 
 pub fn g<T: IntoIterator<Item = impl Iterator<Item = impl Clone>>>() {
+    //~^ impl_trait_in_params
+    //~| impl_trait_in_params
     extern "C" fn implementation_detail() {}
 }
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-11939.rs b/src/tools/clippy/tests/ui/crashes/ice-11939.rs
index 5e7193b68264..ce7a0de1ac3a 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-11939.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-11939.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::unit_arg, clippy::no_effect)]
 
 const fn v(_: ()) {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-12253.rs b/src/tools/clippy/tests/ui/crashes/ice-12253.rs
index 41f50035144a..58ad7c3bfbf5 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-12253.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-12253.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #[allow(overflowing_literals, unconditional_panic, clippy::no_effect)]
 fn main() {
     let arr: [i32; 5] = [0; 5];
diff --git a/src/tools/clippy/tests/ui/crashes/ice-12491.fixed b/src/tools/clippy/tests/ui/crashes/ice-12491.fixed
index 4ea480b0663c..ab9c61463e92 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-12491.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-12491.fixed
@@ -3,5 +3,6 @@
 fn main() {
     if (true) {
         // anything一些中文
+        //~^^ needless_return
     }
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-12491.rs b/src/tools/clippy/tests/ui/crashes/ice-12491.rs
index 60add6afa2c4..b774bd3788a7 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-12491.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-12491.rs
@@ -4,5 +4,6 @@ fn main() {
     if (true) {
         // anything一些中文
         return;
+        //~^^ needless_return
     }
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-12585.rs b/src/tools/clippy/tests/ui/crashes/ice-12585.rs
index 7928115c0a94..f35e95c6bc34 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-12585.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-12585.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::unit_arg)]
 
 struct One {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-12616.fixed b/src/tools/clippy/tests/ui/crashes/ice-12616.fixed
index a5a5b3d1e78e..b7840cabc6b4 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-12616.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-12616.fixed
@@ -4,4 +4,5 @@
 fn main() {
     let s = std::ptr::null::<()>;
     s().cast::<()>();
+    //~^ ptr_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-12616.rs b/src/tools/clippy/tests/ui/crashes/ice-12616.rs
index 6ee9a5ec08fe..bb37b2e6a679 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-12616.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-12616.rs
@@ -4,4 +4,5 @@
 fn main() {
     let s = std::ptr::null::<()>;
     s() as *const ();
+    //~^ ptr_as_ptr
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-13862.rs b/src/tools/clippy/tests/ui/crashes/ice-13862.rs
index a5f010054b2f..774774e6245b 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-13862.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-13862.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![crate_type = "lib"]
 #![no_std]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-14303.rs b/src/tools/clippy/tests/ui/crashes/ice-14303.rs
new file mode 100644
index 000000000000..e81f29cd7af9
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-14303.rs
@@ -0,0 +1,12 @@
+//@check-pass
+#![warn(clippy::macro_use_imports)]
+
+#[repr(transparent)]
+pub struct X(());
+
+#[repr(u8)]
+pub enum Action {
+    Off = 0,
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-14325.rs b/src/tools/clippy/tests/ui/crashes/ice-14325.rs
new file mode 100644
index 000000000000..d762bd6c9e00
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-14325.rs
@@ -0,0 +1,17 @@
+//@check-pass
+
+#![allow(clippy::redundant_pattern_matching)]
+
+struct S<'a> {
+    s: &'a str,
+}
+
+fn foo() -> Option<S<'static>> {
+    if let Some(_) = Some(0) {
+        Some(S { s: "xyz" })
+    } else {
+        None
+    }
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-1588.rs b/src/tools/clippy/tests/ui/crashes/ice-1588.rs
index 9ec093721c17..3ccd33052cd6 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-1588.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-1588.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::all)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/1588
diff --git a/src/tools/clippy/tests/ui/crashes/ice-1782.rs b/src/tools/clippy/tests/ui/crashes/ice-1782.rs
index 73de5721cbc1..fefdc405cce2 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-1782.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-1782.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code, unused_variables)]
 #![allow(clippy::unnecessary_cast, clippy::missing_transmute_annotations)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-1969.rs b/src/tools/clippy/tests/ui/crashes/ice-1969.rs
index eb901c767294..34ff725d7117 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-1969.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-1969.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::all)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/1969
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2499.rs b/src/tools/clippy/tests/ui/crashes/ice-2499.rs
index 732f331ad145..685c28ff4d6a 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2499.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-2499.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code, clippy::char_lit_as_u8, clippy::needless_bool)]
 
 // Should not trigger an ICE in `SpanlessHash` / `consts::constant`
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2594.rs b/src/tools/clippy/tests/ui/crashes/ice-2594.rs
index dddf860bd178..d4d9e74cc193 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2594.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-2594.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code, unused_variables)]
 
 /// Should not trigger an ICE in `SpanlessHash` / `consts::constant`
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2727.rs b/src/tools/clippy/tests/ui/crashes/ice-2727.rs
index 59fb9b04b86d..92287459424f 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2727.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-2727.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/2727
 
 pub fn f(new: fn()) {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2760.rs b/src/tools/clippy/tests/ui/crashes/ice-2760.rs
index 5f7d91abf995..188d90fcae22 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2760.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-2760.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(
     unused_variables,
     clippy::disallowed_names,
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2774.fixed b/src/tools/clippy/tests/ui/crashes/ice-2774.fixed
index 96cf0d8540cd..35d969441763 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2774.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-2774.fixed
@@ -13,8 +13,8 @@ pub struct Foo;
 #[allow(clippy::implicit_hasher)]
 // This should not cause a "cannot relate bound region" ICE.
 pub fn add_barfoos_to_foos(bars: &HashSet<&Bar>) {
-    //~^ ERROR: the following explicit lifetimes could be elided: 'a
-    //~| NOTE: `-D clippy::needless-lifetimes` implied by `-D warnings`
+    //~^ needless_lifetimes
+
     let mut foos = HashSet::new();
     foos.extend(bars.iter().map(|b| &b.foo));
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2774.rs b/src/tools/clippy/tests/ui/crashes/ice-2774.rs
index 464d7891c9f4..1eb6df0095ed 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2774.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-2774.rs
@@ -13,8 +13,8 @@ pub struct Foo;
 #[allow(clippy::implicit_hasher)]
 // This should not cause a "cannot relate bound region" ICE.
 pub fn add_barfoos_to_foos<'a>(bars: &HashSet<&'a Bar>) {
-    //~^ ERROR: the following explicit lifetimes could be elided: 'a
-    //~| NOTE: `-D clippy::needless-lifetimes` implied by `-D warnings`
+    //~^ needless_lifetimes
+
     let mut foos = HashSet::new();
     foos.extend(bars.iter().map(|b| &b.foo));
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2862.rs b/src/tools/clippy/tests/ui/crashes/ice-2862.rs
index 2573b571f55c..e27bdba04e80 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2862.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-2862.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/2862
 
 pub trait FooMap {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-2865.rs b/src/tools/clippy/tests/ui/crashes/ice-2865.rs
index 28363707acca..681d10a75014 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-2865.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-2865.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code, clippy::extra_unused_lifetimes)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/2865
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3151.rs b/src/tools/clippy/tests/ui/crashes/ice-3151.rs
index f88a26cb4859..f0c57d2f19f4 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3151.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-3151.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/3151
 
 #[derive(Clone)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3462.rs b/src/tools/clippy/tests/ui/crashes/ice-3462.rs
index ccd617e305da..4ce484917ae2 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3462.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-3462.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::all)]
 #![allow(clippy::disallowed_names, clippy::equatable_if_let, clippy::needless_if)]
 #![allow(unused)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-360.rs b/src/tools/clippy/tests/ui/crashes/ice-360.rs
index 0d10932b0987..cb8176a2973f 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-360.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-360.rs
@@ -3,14 +3,14 @@ fn main() {}
 fn no_panic<T>(slice: &[T]) {
     let mut iter = slice.iter();
     loop {
-        //~^ ERROR: this loop never actually loops
-        //~| ERROR: this loop could be written as a `while let` loop
-        //~| NOTE: `-D clippy::while-let-loop` implied by `-D warnings`
+        //~^ never_loop
+        //~| while_let_loop
+
         let _ = match iter.next() {
             Some(ele) => ele,
             None => break,
         };
         loop {}
-        //~^ ERROR: empty `loop {}` wastes CPU cycles
+        //~^ empty_loop
     }
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3717.fixed b/src/tools/clippy/tests/ui/crashes/ice-3717.fixed
index 3f54b326979c..5581b67fa5c4 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3717.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-3717.fixed
@@ -5,7 +5,8 @@ use std::collections::HashSet;
 fn main() {}
 
 pub fn ice_3717<S: ::std::hash::BuildHasher + Default>(_: &HashSet<usize, S>) {
-    //~^ ERROR: parameter of type `HashSet` should be generalized over different hashers
+    //~^ implicit_hasher
+
     let _ = [0u8; 0];
     let _: HashSet<usize> = HashSet::default();
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3717.rs b/src/tools/clippy/tests/ui/crashes/ice-3717.rs
index 2890a9277c71..c612270865c5 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3717.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-3717.rs
@@ -5,7 +5,8 @@ use std::collections::HashSet;
 fn main() {}
 
 pub fn ice_3717(_: &HashSet<usize>) {
-    //~^ ERROR: parameter of type `HashSet` should be generalized over different hashers
+    //~^ implicit_hasher
+
     let _ = [0u8; 0];
     let _: HashSet<usize> = HashSet::new();
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3717.stderr b/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
index aac72c669654..2e53b610922e 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-3717.stderr
@@ -13,6 +13,7 @@ help: add a type parameter for `BuildHasher`
    |
 LL ~ pub fn ice_3717<S: ::std::hash::BuildHasher + Default>(_: &HashSet<usize, S>) {
 LL |
+LL |
 LL |     let _ = [0u8; 0];
 LL ~     let _: HashSet<usize> = HashSet::default();
    |
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3741.rs b/src/tools/clippy/tests/ui/crashes/ice-3741.rs
index 3106a2e72169..d8c02b1ba452 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3741.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-3741.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build:proc_macro_crash.rs
 
 #![warn(clippy::suspicious_else_formatting)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3747.rs b/src/tools/clippy/tests/ui/crashes/ice-3747.rs
index 44b1d7ed1b2e..62c7835ac55c 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3747.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-3747.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/3747
 
 macro_rules! a {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3969.rs b/src/tools/clippy/tests/ui/crashes/ice-3969.rs
index ac09ce08753a..fa3ca6f1d538 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3969.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-3969.rs
@@ -18,13 +18,12 @@ struct Dst<X: ?Sized> {
 struct TwoStrs(str, str)
 where
     str: Sized;
-//~^ ERROR: trait bound str: std::marker::Sized does not depend on any type or lifetime
-//~| NOTE: `-D trivial-bounds` implied by `-D warnings`
+//~^ ERROR: trait bound
 
 fn unsized_local()
 where
     for<'a> Dst<dyn A + 'a>: Sized,
-    //~^ ERROR: trait bound for<'a> Dst<(dyn A + 'a)>: std::marker::Sized does not depend
+    //~^ ERROR: trait bound
 {
     let x: Dst<dyn A> = *(Box::new(Dst { x: 1 }) as Box<Dst<dyn A>>);
 }
@@ -32,7 +31,7 @@ where
 fn return_str() -> str
 where
     str: Sized,
-    //~^ ERROR: trait bound str: std::marker::Sized does not depend on any type or lifetim
+    //~^ ERROR: trait bound
 {
     *"Sized".to_string().into_boxed_str()
 }
@@ -40,7 +39,7 @@ where
 fn use_op(s: String) -> String
 where
     String: ::std::ops::Neg<Output = String>,
-    //~^ ERROR: trait bound std::string::String: std::ops::Neg does not depend on any type
+    //~^ ERROR: trait bound
 {
     -s
 }
@@ -48,7 +47,7 @@ where
 fn use_for()
 where
     i32: Iterator,
-    //~^ ERROR: trait bound i32: std::iter::Iterator does not depend on any type or lifeti
+    //~^ ERROR: trait bound
 {
     for _ in 2i32 {}
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-3969.stderr b/src/tools/clippy/tests/ui/crashes/ice-3969.stderr
index 285efee36bd8..b820ecf7e332 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-3969.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-3969.stderr
@@ -8,25 +8,25 @@ LL |     str: Sized;
    = help: to override `-D warnings` add `#[allow(trivial_bounds)]`
 
 error: trait bound for<'a> Dst<(dyn A + 'a)>: std::marker::Sized does not depend on any type or lifetime parameters
-  --> tests/ui/crashes/ice-3969.rs:26:30
+  --> tests/ui/crashes/ice-3969.rs:25:30
    |
 LL |     for<'a> Dst<dyn A + 'a>: Sized,
    |                              ^^^^^
 
 error: trait bound str: std::marker::Sized does not depend on any type or lifetime parameters
-  --> tests/ui/crashes/ice-3969.rs:34:10
+  --> tests/ui/crashes/ice-3969.rs:33:10
    |
 LL |     str: Sized,
    |          ^^^^^
 
 error: trait bound std::string::String: std::ops::Neg does not depend on any type or lifetime parameters
-  --> tests/ui/crashes/ice-3969.rs:42:13
+  --> tests/ui/crashes/ice-3969.rs:41:13
    |
 LL |     String: ::std::ops::Neg<Output = String>,
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: trait bound i32: std::iter::Iterator does not depend on any type or lifetime parameters
-  --> tests/ui/crashes/ice-3969.rs:50:10
+  --> tests/ui/crashes/ice-3969.rs:49:10
    |
 LL |     i32: Iterator,
    |          ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4121.rs b/src/tools/clippy/tests/ui/crashes/ice-4121.rs
index e1a142fdcb67..a1192b229ecd 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4121.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4121.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 use std::mem;
 
 pub struct Foo<A, B>(A, B);
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4545.rs b/src/tools/clippy/tests/ui/crashes/ice-4545.rs
index d9c9c2096d97..1d7cb53ee7be 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4545.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4545.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn repro() {
     trait Foo {
         type Bar;
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4579.rs b/src/tools/clippy/tests/ui/crashes/ice-4579.rs
index 2e7e279f847d..14c8113e315b 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4579.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4579.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::single_match)]
 
 use std::ptr;
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4671.rs b/src/tools/clippy/tests/ui/crashes/ice-4671.rs
index 64e8e7769412..3309d51302e2 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4671.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4671.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::use_self)]
 
 #[macro_use]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4727.rs b/src/tools/clippy/tests/ui/crashes/ice-4727.rs
index 2a4bc83f58a5..f90c6ca9a679 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4727.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4727.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::use_self)]
 
 #[path = "auxiliary/ice-4727-aux.rs"]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4760.rs b/src/tools/clippy/tests/ui/crashes/ice-4760.rs
index e1265169762f..07387db7b294 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4760.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4760.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(non_local_definitions)]
 
 const COUNT: usize = 2;
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4775.rs b/src/tools/clippy/tests/ui/crashes/ice-4775.rs
index f693aafd1cbb..dd6c6b8de25a 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4775.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4775.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::uninlined_format_args)]
 
 pub struct ArrayWrapper<const N: usize>([usize; N]);
diff --git a/src/tools/clippy/tests/ui/crashes/ice-4968.rs b/src/tools/clippy/tests/ui/crashes/ice-4968.rs
index 50473868005e..542cb63516da 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-4968.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-4968.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/4968
 
 #![warn(clippy::unsound_collection_transmute)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5207.rs b/src/tools/clippy/tests/ui/crashes/ice-5207.rs
index 0df8b88fea2f..6e438bcc2843 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5207.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5207.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Regression test for https://github.com/rust-lang/rust-clippy/issues/5207
 pub async fn bar<'a, T: 'a>(_: T) {}
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5223.rs b/src/tools/clippy/tests/ui/crashes/ice-5223.rs
index e3b3b27a6fc3..c055e551b298 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5223.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5223.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Regression test for #5233
 #![warn(clippy::indexing_slicing, clippy::iter_cloned_collect)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5238.rs b/src/tools/clippy/tests/ui/crashes/ice-5238.rs
index ee2ae4f1a042..1d7dd8c76507 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5238.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5238.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Regression test for #5238 / https://github.com/rust-lang/rust/pull/69562
 
 #![feature(coroutines, coroutine_trait, stmt_expr_attributes)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5389.rs b/src/tools/clippy/tests/ui/crashes/ice-5389.rs
index de262199004b..b54562095a21 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5389.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5389.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::explicit_counter_loop)]
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5579.rs b/src/tools/clippy/tests/ui/crashes/ice-5579.rs
index 8ab36bbf93cb..e3e408a52539 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5579.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5579.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::unnecessary_literal_unwrap)]
 
 trait IsErr {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5835.1.fixed b/src/tools/clippy/tests/ui/crashes/ice-5835.1.fixed
new file mode 100644
index 000000000000..acd61a9bd6c3
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-5835.1.fixed
@@ -0,0 +1,11 @@
+#[rustfmt::skip]
+pub struct Foo {
+    /// 位    
+    //~^ tabs_in_doc_comments
+    //~| empty_line_after_doc_comments
+    ///   ^ Do not remove this tab character.
+    ///   It was required to trigger the ICE.
+    pub bar: u8,
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5835.2.fixed b/src/tools/clippy/tests/ui/crashes/ice-5835.2.fixed
new file mode 100644
index 000000000000..71d2ec0c0018
--- /dev/null
+++ b/src/tools/clippy/tests/ui/crashes/ice-5835.2.fixed
@@ -0,0 +1,13 @@
+#[rustfmt::skip]
+pub struct Foo {
+    // /// 位    
+    //~^ tabs_in_doc_comments
+    //~| empty_line_after_doc_comments
+
+
+    ///   ^ Do not remove this tab character.
+    ///   It was required to trigger the ICE.
+    pub bar: u8,
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5835.fixed b/src/tools/clippy/tests/ui/crashes/ice-5835.fixed
index c0532d685786..e9c24b8e9f09 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5835.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-5835.fixed
@@ -1,8 +1,7 @@
 #[rustfmt::skip]
 pub struct Foo {
+    //~v tabs_in_doc_comments
     /// 位    
-    //~^ ERROR: using tabs in doc comments is not recommended
-    //~| NOTE: `-D clippy::tabs-in-doc-comments` implied by `-D warnings`
     ///   ^ Do not remove this tab character.
     ///   It was required to trigger the ICE.
     pub bar: u8,
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5835.rs b/src/tools/clippy/tests/ui/crashes/ice-5835.rs
index 122bddd6ae67..99858f45933e 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5835.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5835.rs
@@ -1,8 +1,7 @@
 #[rustfmt::skip]
 pub struct Foo {
+    //~v tabs_in_doc_comments
     /// 位	
-    //~^ ERROR: using tabs in doc comments is not recommended
-    //~| NOTE: `-D clippy::tabs-in-doc-comments` implied by `-D warnings`
     ///   ^ Do not remove this tab character.
     ///   It was required to trigger the ICE.
     pub bar: u8,
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5835.stderr b/src/tools/clippy/tests/ui/crashes/ice-5835.stderr
index 45e5e9a4b83d..4ef91e4116b2 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5835.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-5835.stderr
@@ -1,5 +1,5 @@
 error: using tabs in doc comments is not recommended
-  --> tests/ui/crashes/ice-5835.rs:3:10
+  --> tests/ui/crashes/ice-5835.rs:4:10
    |
 LL |     /// 位    
    |           ^^^^ help: consider using four spaces per tab
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5872.fixed b/src/tools/clippy/tests/ui/crashes/ice-5872.fixed
index c8e870c62fbf..521fa15e1846 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5872.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-5872.fixed
@@ -2,6 +2,5 @@
 
 fn main() {
     let _ = vec![1, 2, 3].into_iter().next().is_none();
-    //~^ ERROR: avoid using `collect()` when not needed
-    //~| NOTE: `-D clippy::needless-collect` implied by `-D warnings`
+    //~^ needless_collect
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5872.rs b/src/tools/clippy/tests/ui/crashes/ice-5872.rs
index c6ed31365892..10235ea8ab7f 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5872.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5872.rs
@@ -2,6 +2,5 @@
 
 fn main() {
     let _ = vec![1, 2, 3].into_iter().collect::<Vec<_>>().is_empty();
-    //~^ ERROR: avoid using `collect()` when not needed
-    //~| NOTE: `-D clippy::needless-collect` implied by `-D warnings`
+    //~^ needless_collect
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-5944.rs b/src/tools/clippy/tests/ui/crashes/ice-5944.rs
index ce46bc1acc1b..2a93c5436511 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-5944.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-5944.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::repeat_once)]
 #![allow(clippy::let_unit_value)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6139.rs b/src/tools/clippy/tests/ui/crashes/ice-6139.rs
index f3966e47f5e8..866e13a86592 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6139.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6139.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 trait T<'a> {}
 
 fn foo(_: Vec<Box<dyn T<'_>>>) {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6153.rs b/src/tools/clippy/tests/ui/crashes/ice-6153.rs
index 9f73f39f10d7..84873c2ecf4c 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6153.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6153.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 pub struct S<'a, 'e>(&'a str, &'e str);
 
 pub type T<'a, 'e> = std::collections::HashMap<S<'a, 'e>, ()>;
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6179.rs b/src/tools/clippy/tests/ui/crashes/ice-6179.rs
index 91160eef03df..640b51517f74 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6179.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6179.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //! This is a minimal reproducer for the ICE in https://github.com/rust-lang/rust-clippy/pull/6179.
 //! The ICE is mainly caused by using `lower_ty`. See the discussion in the PR for details.
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6250.rs b/src/tools/clippy/tests/ui/crashes/ice-6250.rs
index 32849f2ca6f0..65cdce793142 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6250.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6250.rs
@@ -10,6 +10,8 @@ pub fn list_data(cache: &Cache, key: usize) {
         if
         /* let */
         Some(reference) = cache.data.get(key) {
+            //~^ ERROR: mismatched types
+            //~| ERROR: mismatched types
             unimplemented!()
         }
     }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6251.rs b/src/tools/clippy/tests/ui/crashes/ice-6251.rs
index 73e919b6dd2e..a58265752ec3 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6251.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6251.rs
@@ -2,5 +2,8 @@
 // assertion failed: `(left == right)` ; different DefIds
 //@no-rustfix
 fn bug<T>() -> impl Iterator<Item = [(); { |x: [u8]| x }]> {
+    //~^ ERROR: the size for values
+    //~| ERROR: the size for values
+    //~| ERROR: mismatched types
     std::iter::empty()
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6252.rs b/src/tools/clippy/tests/ui/crashes/ice-6252.rs
index 67fbb0ff699c..829cb447211c 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6252.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6252.rs
@@ -7,8 +7,11 @@ trait TypeVal<T> {
 struct Five;
 struct Multiply<N, M> {
     _n: PhantomData,
+    //~^ ERROR: cannot find type
 }
 impl<N, M> TypeVal<usize> for Multiply<N, M> where N: TypeVal<VAL> {}
+//~^ ERROR: cannot find type
+//~| ERROR: not all trait items
 
 fn main() {
     [1; <Multiply<Five, Five>>::VAL];
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6252.stderr b/src/tools/clippy/tests/ui/crashes/ice-6252.stderr
index cd2031af1c6d..201a897b2319 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6252.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-6252.stderr
@@ -10,7 +10,7 @@ LL + use std::marker::PhantomData;
    |
 
 error[E0412]: cannot find type `VAL` in this scope
-  --> tests/ui/crashes/ice-6252.rs:11:63
+  --> tests/ui/crashes/ice-6252.rs:12:63
    |
 LL | impl<N, M> TypeVal<usize> for Multiply<N, M> where N: TypeVal<VAL> {}
    |                                                               ^^^ not found in this scope
@@ -21,7 +21,7 @@ LL | impl<N, M, VAL> TypeVal<usize> for Multiply<N, M> where N: TypeVal<VAL> {}
    |          +++++
 
 error[E0046]: not all trait items implemented, missing: `VAL`
-  --> tests/ui/crashes/ice-6252.rs:11:1
+  --> tests/ui/crashes/ice-6252.rs:12:1
    |
 LL |     const VAL: T;
    |     ------------ `VAL` from trait
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6254.rs b/src/tools/clippy/tests/ui/crashes/ice-6254.rs
index aaca32ab2d93..45144fd9e5ec 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6254.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6254.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // originally from ./tests/ui/pattern/usefulness/consts-opaque.rs
 // panicked at 'assertion failed: rows.iter().all(|r| r.len() == v.len())',
 // compiler/rustc_mir_build/src/thir/pattern/_match.rs:2030:5
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6332.rs b/src/tools/clippy/tests/ui/crashes/ice-6332.rs
index 9dc92aa500b2..25660a3ce853 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6332.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6332.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn cmark_check() {
     let mut link_err = false;
     macro_rules! cmark_error {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6539.rs b/src/tools/clippy/tests/ui/crashes/ice-6539.rs
index ac6c3e4aba04..cff0882cbee3 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6539.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6539.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // The test for the ICE 6539: https://github.com/rust-lang/rust-clippy/issues/6539.
 // The cause is that `zero_sized_map_values` used `layout_of` with types from type aliases,
 // which is essentially the same as the ICE 4968.
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6792.rs b/src/tools/clippy/tests/ui/crashes/ice-6792.rs
index 9cbafc716b50..372ce5ac06f3 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6792.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6792.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //! This is a reproducer for the ICE 6792: https://github.com/rust-lang/rust-clippy/issues/6792.
 //! The ICE is caused by using `TyCtxt::type_of(assoc_type_id)`.
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6793.rs b/src/tools/clippy/tests/ui/crashes/ice-6793.rs
index 12a4a0d25ef5..d83a2ee251db 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6793.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6793.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //! This is a reproducer for the ICE 6793: https://github.com/rust-lang/rust-clippy/issues/6793.
 //! The ICE is caused by using `TyCtxt::type_of(assoc_type_id)`, which is the same as the ICE 6792.
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-6840.rs b/src/tools/clippy/tests/ui/crashes/ice-6840.rs
index d789f60c5d5a..94481f248998 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-6840.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-6840.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //! This is a reproducer for the ICE 6840: https://github.com/rust-lang/rust-clippy/issues/6840.
 //! The ICE is caused by `TyCtxt::layout_of` and `is_normalizable` not being strict enough
 #![allow(dead_code)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-700.rs b/src/tools/clippy/tests/ui/crashes/ice-700.rs
index 5e004b94330e..aa3bf493c201 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-700.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-700.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![deny(clippy::all)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/700
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7012.rs b/src/tools/clippy/tests/ui/crashes/ice-7012.rs
index 60bdbc4f124e..d76995adadf1 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7012.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7012.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::all)]
 
 enum _MyOption {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7126.rs b/src/tools/clippy/tests/ui/crashes/ice-7126.rs
index b2dc2248b556..f0c23c7e852d 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7126.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7126.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // This test requires a feature gated const fn and will stop working in the future.
 
 #![feature(const_btree_len)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7169.fixed b/src/tools/clippy/tests/ui/crashes/ice-7169.fixed
index cf4077e4d898..71a40ad7de71 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7169.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-7169.fixed
@@ -8,6 +8,5 @@ struct A<T> {
 
 fn main() {
     if Ok::<_, ()>(A::<String>::default()).is_ok() {}
-    //~^ ERROR: redundant pattern matching, consider using `is_ok()`
-    //~| NOTE: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+    //~^ redundant_pattern_matching
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7169.rs b/src/tools/clippy/tests/ui/crashes/ice-7169.rs
index b09e6f384632..d43e2cc164d7 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7169.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7169.rs
@@ -8,6 +8,5 @@ struct A<T> {
 
 fn main() {
     if let Ok(_) = Ok::<_, ()>(A::<String>::default()) {}
-    //~^ ERROR: redundant pattern matching, consider using `is_ok()`
-    //~| NOTE: `-D clippy::redundant-pattern-matching` implied by `-D warnings`
+    //~^ redundant_pattern_matching
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7231.rs b/src/tools/clippy/tests/ui/crashes/ice-7231.rs
index 4ad0d351372f..873cdbb0516c 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7231.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7231.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::never_loop)]
 
 async fn f() {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7272.rs b/src/tools/clippy/tests/ui/crashes/ice-7272.rs
index e949038c8d0b..e1910096418b 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7272.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7272.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build:ice-7272-aux.rs
 
 #![allow(clippy::no_effect)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7340.rs b/src/tools/clippy/tests/ui/crashes/ice-7340.rs
index 7d2351d606f1..6c71c232fddb 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7340.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7340.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::no_effect)]
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7410.rs b/src/tools/clippy/tests/ui/crashes/ice-7410.rs
index addbca54e80a..71f00fb9aede 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7410.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7410.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@compile-flags: -Clink-arg=-nostartfiles
 //@ignore-target: apple windows
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7423.rs b/src/tools/clippy/tests/ui/crashes/ice-7423.rs
index 31340b012dd0..a03981842fcc 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7423.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7423.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 pub trait Trait {
     fn f();
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7868.rs b/src/tools/clippy/tests/ui/crashes/ice-7868.rs
index c6932164e3bf..727dd41aa322 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7868.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7868.rs
@@ -1,3 +1,4 @@
+//@error-in-other-file:
 #![warn(clippy::undocumented_unsafe_blocks)]
 #![allow(clippy::no_effect)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7869.rs b/src/tools/clippy/tests/ui/crashes/ice-7869.rs
index 774e22f6b4c5..a5b557849aba 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7869.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7869.rs
@@ -1,5 +1,5 @@
 enum Tila {
-    //~^ ERROR: all variants have the same prefix: `Työ`
+    //~^ enum_variant_names
     TyöAlkoi,
     TyöKeskeytyi,
     TyöValmis,
diff --git a/src/tools/clippy/tests/ui/crashes/ice-7934.rs b/src/tools/clippy/tests/ui/crashes/ice-7934.rs
index a4691c4131b3..c7a8d68d63b6 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-7934.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-7934.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::undocumented_unsafe_blocks)]
 #![allow(clippy::no_effect)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8250.fixed b/src/tools/clippy/tests/ui/crashes/ice-8250.fixed
index 984b61258c78..b0c2ddb2450d 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8250.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-8250.fixed
@@ -1,7 +1,7 @@
 fn _f(s: &str) -> Option<()> {
     let _ = s[1..].split('.').next()?;
-    //~^ ERROR: unnecessary use of `splitn`
-    //~| NOTE: `-D clippy::needless-splitn` implied by `-D warnings`
+    //~^ needless_splitn
+
     Some(())
 }
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8250.rs b/src/tools/clippy/tests/ui/crashes/ice-8250.rs
index c1b2e48ba3c0..ee0eb8e1eb1a 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8250.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-8250.rs
@@ -1,7 +1,7 @@
 fn _f(s: &str) -> Option<()> {
     let _ = s[1..].splitn(2, '.').next()?;
-    //~^ ERROR: unnecessary use of `splitn`
-    //~| NOTE: `-D clippy::needless-splitn` implied by `-D warnings`
+    //~^ needless_splitn
+
     Some(())
 }
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8386.rs b/src/tools/clippy/tests/ui/crashes/ice-8386.rs
index 3e38b1408d8c..1c7a809174b6 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8386.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-8386.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn f(x: u32, mut arg: &String) {}
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8681.rs b/src/tools/clippy/tests/ui/crashes/ice-8681.rs
index 607b9caa3249..b7d6c4556bbd 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8681.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-8681.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build: ice-8681-aux.rs
 
 #![warn(clippy::undocumented_unsafe_blocks)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8821.rs b/src/tools/clippy/tests/ui/crashes/ice-8821.rs
index fb87b79aeed8..c9fea3d1ccb8 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8821.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-8821.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::let_unit_value)]
 
 fn f() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8850.fixed b/src/tools/clippy/tests/ui/crashes/ice-8850.fixed
index 4569b9e8793e..0e1d8d5a2aae 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8850.fixed
+++ b/src/tools/clippy/tests/ui/crashes/ice-8850.fixed
@@ -2,15 +2,14 @@ fn fn_pointer_static() -> usize {
     static FN: fn() -> usize = || 1;
     
     FN() + 1
-    //~^ ERROR: returning the result of a `let` binding from a block
-    //~| NOTE: `-D clippy::let-and-return` implied by `-D warnings`
+    //~^ let_and_return
 }
 
 fn fn_pointer_const() -> usize {
     const FN: fn() -> usize = || 1;
     
     FN() + 1
-    //~^ ERROR: returning the result of a `let` binding from a block
+    //~^ let_and_return
 }
 
 fn deref_to_dyn_fn() -> usize {
@@ -25,7 +24,7 @@ fn deref_to_dyn_fn() -> usize {
     static FN: Derefs = Derefs;
     
     FN() + 1
-    //~^ ERROR: returning the result of a `let` binding from a block
+    //~^ let_and_return
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8850.rs b/src/tools/clippy/tests/ui/crashes/ice-8850.rs
index 499756ecefe9..0109911bca68 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8850.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-8850.rs
@@ -2,15 +2,14 @@ fn fn_pointer_static() -> usize {
     static FN: fn() -> usize = || 1;
     let res = FN() + 1;
     res
-    //~^ ERROR: returning the result of a `let` binding from a block
-    //~| NOTE: `-D clippy::let-and-return` implied by `-D warnings`
+    //~^ let_and_return
 }
 
 fn fn_pointer_const() -> usize {
     const FN: fn() -> usize = || 1;
     let res = FN() + 1;
     res
-    //~^ ERROR: returning the result of a `let` binding from a block
+    //~^ let_and_return
 }
 
 fn deref_to_dyn_fn() -> usize {
@@ -25,7 +24,7 @@ fn deref_to_dyn_fn() -> usize {
     static FN: Derefs = Derefs;
     let res = FN() + 1;
     res
-    //~^ ERROR: returning the result of a `let` binding from a block
+    //~^ let_and_return
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-8850.stderr b/src/tools/clippy/tests/ui/crashes/ice-8850.stderr
index 5a8f24ee8c0b..1a44f103beb3 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-8850.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-8850.stderr
@@ -15,7 +15,7 @@ LL ~     FN() + 1
    |
 
 error: returning the result of a `let` binding from a block
-  --> tests/ui/crashes/ice-8850.rs:12:5
+  --> tests/ui/crashes/ice-8850.rs:11:5
    |
 LL |     let res = FN() + 1;
    |     ------------------- unnecessary `let` binding
@@ -29,7 +29,7 @@ LL ~     FN() + 1
    |
 
 error: returning the result of a `let` binding from a block
-  --> tests/ui/crashes/ice-8850.rs:27:5
+  --> tests/ui/crashes/ice-8850.rs:26:5
    |
 LL |     let res = FN() + 1;
    |     ------------------- unnecessary `let` binding
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9041.rs b/src/tools/clippy/tests/ui/crashes/ice-9041.rs
index 727d88f7fbd2..4b2a0f953114 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9041.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9041.rs
@@ -3,8 +3,7 @@ pub struct Thing;
 pub fn has_thing(things: &[Thing]) -> bool {
     let is_thing_ready = |_peer: &Thing| -> bool { todo!() };
     things.iter().find(|p| is_thing_ready(p)).is_some()
-    //~^ ERROR: called `is_some()` after searching an `Iterator` with `find`
-    //~| NOTE: `-D clippy::search-is-some` implied by `-D warnings`
+    //~^ search_is_some
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9238.rs b/src/tools/clippy/tests/ui/crashes/ice-9238.rs
index ee6abd519f16..cbce84305ba8 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9238.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9238.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(incomplete_features)]
 #![feature(generic_const_exprs)]
 #![warn(clippy::branches_sharing_code)]
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9242.rs b/src/tools/clippy/tests/ui/crashes/ice-9242.rs
index 0099e6e2f34b..ac5bbad98c14 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9242.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9242.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 enum E {
     X(),
     Y,
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9405.rs b/src/tools/clippy/tests/ui/crashes/ice-9405.rs
index e2d274aeb044..74a56f4d2ef8 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9405.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9405.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::useless_format)]
 #![allow(clippy::print_literal)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9405.stderr b/src/tools/clippy/tests/ui/crashes/ice-9405.stderr
index e8a73b9e782e..96e0f2ea736a 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9405.stderr
+++ b/src/tools/clippy/tests/ui/crashes/ice-9405.stderr
@@ -1,5 +1,5 @@
 warning: multiple lines skipped by escaped newline
-  --> tests/ui/crashes/ice-9405.rs:6:10
+  --> tests/ui/crashes/ice-9405.rs:8:10
    |
 LL |           "\
    |  __________^
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9414.rs b/src/tools/clippy/tests/ui/crashes/ice-9414.rs
index 02cf5d5c240f..2341c99b2390 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9414.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9414.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::result_large_err)]
 
 trait T {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9445.rs b/src/tools/clippy/tests/ui/crashes/ice-9445.rs
index c67b22f6f8c4..232b8e4a7959 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9445.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9445.rs
@@ -1,3 +1,4 @@
 const UNINIT: core::mem::MaybeUninit<core::cell::Cell<&'static ()>> = core::mem::MaybeUninit::uninit();
+//~^ declare_interior_mutable_const
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9459.rs b/src/tools/clippy/tests/ui/crashes/ice-9459.rs
index 55615124fcf0..43d3264b264d 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9459.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9459.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![feature(unsized_fn_params)]
 
 pub fn f0(_f: dyn FnOnce()) {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9463.rs b/src/tools/clippy/tests/ui/crashes/ice-9463.rs
index fa83d25b3942..93808e0f8923 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9463.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9463.rs
@@ -4,6 +4,5 @@ fn main() {
     //~^ ERROR: this arithmetic operation will overflow
     let _y = 1u32 >> 10000000000000u32;
     //~^ ERROR: this arithmetic operation will overflow
-    //~| ERROR: literal out of range for `u32`
-    //~| NOTE: the literal `10000000000000u32` does not fit into the type `u32` whose rang
+    //~| ERROR: literal out of range
 }
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9625.rs b/src/tools/clippy/tests/ui/crashes/ice-9625.rs
index a765882b5d81..52117883aa7d 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9625.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9625.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn main() {
     let x = &1;
     let _ = &1 < x && x < &10;
diff --git a/src/tools/clippy/tests/ui/crashes/ice-9746.rs b/src/tools/clippy/tests/ui/crashes/ice-9746.rs
index fbd373c70bf2..39fa8ff7a915 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-9746.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-9746.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //! <https://github.com/rust-lang/rust-clippy/issues/9746#issuecomment-1297132880>
 
 trait Trait {}
diff --git a/src/tools/clippy/tests/ui/crashes/ice-rust-107877.rs b/src/tools/clippy/tests/ui/crashes/ice-rust-107877.rs
index 7f5bae60d55d..55fe418bed12 100644
--- a/src/tools/clippy/tests/ui/crashes/ice-rust-107877.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice-rust-107877.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code)]
 
 struct Foo;
diff --git a/src/tools/clippy/tests/ui/crashes/ice_exact_size.rs b/src/tools/clippy/tests/ui/crashes/ice_exact_size.rs
index c0671eaff145..cb4685e78e22 100644
--- a/src/tools/clippy/tests/ui/crashes/ice_exact_size.rs
+++ b/src/tools/clippy/tests/ui/crashes/ice_exact_size.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![deny(clippy::all)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/1336
diff --git a/src/tools/clippy/tests/ui/crashes/if_same_then_else.rs b/src/tools/clippy/tests/ui/crashes/if_same_then_else.rs
index a900fe5e6bc6..58ee751948b5 100644
--- a/src/tools/clippy/tests/ui/crashes/if_same_then_else.rs
+++ b/src/tools/clippy/tests/ui/crashes/if_same_then_else.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::comparison_chain)]
 #![deny(clippy::if_same_then_else)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/implements-trait.rs b/src/tools/clippy/tests/ui/crashes/implements-trait.rs
index 4502b0147a83..0e68c40be999 100644
--- a/src/tools/clippy/tests/ui/crashes/implements-trait.rs
+++ b/src/tools/clippy/tests/ui/crashes/implements-trait.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #[allow(clippy::needless_borrowed_reference)]
 fn main() {
     let mut v = Vec::<String>::new();
diff --git a/src/tools/clippy/tests/ui/crashes/inherent_impl.rs b/src/tools/clippy/tests/ui/crashes/inherent_impl.rs
index 800a5a383f62..87f1347ecfca 100644
--- a/src/tools/clippy/tests/ui/crashes/inherent_impl.rs
+++ b/src/tools/clippy/tests/ui/crashes/inherent_impl.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![deny(clippy::multiple_inherent_impl)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/4578
diff --git a/src/tools/clippy/tests/ui/crashes/issue-825.rs b/src/tools/clippy/tests/ui/crashes/issue-825.rs
index e8b455a0ec67..9bbb86e4c65a 100644
--- a/src/tools/clippy/tests/ui/crashes/issue-825.rs
+++ b/src/tools/clippy/tests/ui/crashes/issue-825.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(warnings)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/825
diff --git a/src/tools/clippy/tests/ui/crashes/issues_loop_mut_cond.rs b/src/tools/clippy/tests/ui/crashes/issues_loop_mut_cond.rs
index bb238c81ebc0..635580c6a6e7 100644
--- a/src/tools/clippy/tests/ui/crashes/issues_loop_mut_cond.rs
+++ b/src/tools/clippy/tests/ui/crashes/issues_loop_mut_cond.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code)]
 
 /// Issue: https://github.com/rust-lang/rust-clippy/issues/2596
diff --git a/src/tools/clippy/tests/ui/crashes/match_same_arms_const.rs b/src/tools/clippy/tests/ui/crashes/match_same_arms_const.rs
index 626179c00155..a70623f0c51f 100644
--- a/src/tools/clippy/tests/ui/crashes/match_same_arms_const.rs
+++ b/src/tools/clippy/tests/ui/crashes/match_same_arms_const.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![deny(clippy::match_same_arms)]
 
 // Test for https://github.com/rust-lang/rust-clippy/issues/2427
diff --git a/src/tools/clippy/tests/ui/crashes/needless_borrow_fp.rs b/src/tools/clippy/tests/ui/crashes/needless_borrow_fp.rs
index 4f61c76828db..68e39531682a 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_borrow_fp.rs
+++ b/src/tools/clippy/tests/ui/crashes/needless_borrow_fp.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #[deny(clippy::all)]
 #[derive(Debug)]
 pub enum Error {
diff --git a/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.fixed b/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.fixed
index 774dea391939..7d7286ceb99a 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.fixed
+++ b/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.fixed
@@ -5,6 +5,6 @@
 struct Foo<'a>(&'a [(); 100]);
 
 fn test(x: &Foo<'_>) {}
-//~^ ERROR: this argument is passed by value, but not consumed in the function body
+//~^ needless_pass_by_value
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.rs b/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.rs
index f3d8871929a2..949cd5de7fb8 100644
--- a/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.rs
+++ b/src/tools/clippy/tests/ui/crashes/needless_pass_by_value-w-late-bound.rs
@@ -5,6 +5,6 @@
 struct Foo<'a>(&'a [(); 100]);
 
 fn test(x: Foo<'_>) {}
-//~^ ERROR: this argument is passed by value, but not consumed in the function body
+//~^ needless_pass_by_value
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/regressions.rs b/src/tools/clippy/tests/ui/crashes/regressions.rs
index b34997d4ee0b..8fda12fab06a 100644
--- a/src/tools/clippy/tests/ui/crashes/regressions.rs
+++ b/src/tools/clippy/tests/ui/crashes/regressions.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(clippy::disallowed_names, clippy::uninlined_format_args)]
 
 pub fn foo(bar: *const u8) {
diff --git a/src/tools/clippy/tests/ui/crashes/returns.rs b/src/tools/clippy/tests/ui/crashes/returns.rs
index 91cdb5306c89..ccab9522753e 100644
--- a/src/tools/clippy/tests/ui/crashes/returns.rs
+++ b/src/tools/clippy/tests/ui/crashes/returns.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Test for https://github.com/rust-lang/rust-clippy/issues/1346
 
 #[deny(warnings)]
diff --git a/src/tools/clippy/tests/ui/crashes/shadow.rs b/src/tools/clippy/tests/ui/crashes/shadow.rs
index 843e8ef64dcd..237988a01681 100644
--- a/src/tools/clippy/tests/ui/crashes/shadow.rs
+++ b/src/tools/clippy/tests/ui/crashes/shadow.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 fn main() {
     let x: [i32; {
         let u = 2;
diff --git a/src/tools/clippy/tests/ui/crashes/single-match-else.rs b/src/tools/clippy/tests/ui/crashes/single-match-else.rs
index 1ba7ac082132..2ef5dd891c56 100644
--- a/src/tools/clippy/tests/ui/crashes/single-match-else.rs
+++ b/src/tools/clippy/tests/ui/crashes/single-match-else.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::single_match_else)]
 
 //! Test for https://github.com/rust-lang/rust-clippy/issues/1588
diff --git a/src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs b/src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs
index f328e4d9d04c..20c76a4d46d9 100644
--- a/src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs
+++ b/src/tools/clippy/tests/ui/crashes/third-party/conf_allowlisted.rs
@@ -1 +1,3 @@
+//@ check-pass
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/crashes/trivial_bounds.rs b/src/tools/clippy/tests/ui/crashes/trivial_bounds.rs
index 60105a8213fe..23982fca7e7c 100644
--- a/src/tools/clippy/tests/ui/crashes/trivial_bounds.rs
+++ b/src/tools/clippy/tests/ui/crashes/trivial_bounds.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![feature(trivial_bounds)]
 #![allow(unused, trivial_bounds)]
 
diff --git a/src/tools/clippy/tests/ui/crashes/unreachable-array-or-slice.rs b/src/tools/clippy/tests/ui/crashes/unreachable-array-or-slice.rs
index e920e58d6ec6..bc2e9aa92ce1 100644
--- a/src/tools/clippy/tests/ui/crashes/unreachable-array-or-slice.rs
+++ b/src/tools/clippy/tests/ui/crashes/unreachable-array-or-slice.rs
@@ -2,6 +2,7 @@ struct Foo(isize, isize, isize, isize);
 
 pub fn main() {
     let Self::anything_here_kills_it(a, b, ..) = Foo(5, 5, 5, 5);
+    //~^ ERROR: failed to resolve
     match [5, 5, 5, 5] {
         [..] => {},
     }
diff --git a/src/tools/clippy/tests/ui/crashes/used_underscore_binding_macro.rs b/src/tools/clippy/tests/ui/crashes/used_underscore_binding_macro.rs
index 901eb4e50398..0fff0afdf1fe 100644
--- a/src/tools/clippy/tests/ui/crashes/used_underscore_binding_macro.rs
+++ b/src/tools/clippy/tests/ui/crashes/used_underscore_binding_macro.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 use serde::Deserialize;
 
 /// Tests that we do not lint for unused underscores in a `MacroAttribute`
diff --git a/src/tools/clippy/tests/ui/crate_in_macro_def.fixed b/src/tools/clippy/tests/ui/crate_in_macro_def.fixed
index bd91389c8219..d7d8e2a64419 100644
--- a/src/tools/clippy/tests/ui/crate_in_macro_def.fixed
+++ b/src/tools/clippy/tests/ui/crate_in_macro_def.fixed
@@ -16,6 +16,7 @@ mod unhygienic {
     macro_rules! print_message_unhygienic {
         () => {
             println!("{}", $crate::unhygienic::MESSAGE);
+            //~^ crate_in_macro_def
         };
     }
 
diff --git a/src/tools/clippy/tests/ui/crate_in_macro_def.rs b/src/tools/clippy/tests/ui/crate_in_macro_def.rs
index f6fa338eedbf..9ed9dacee48b 100644
--- a/src/tools/clippy/tests/ui/crate_in_macro_def.rs
+++ b/src/tools/clippy/tests/ui/crate_in_macro_def.rs
@@ -16,6 +16,7 @@ mod unhygienic {
     macro_rules! print_message_unhygienic {
         () => {
             println!("{}", crate::unhygienic::MESSAGE);
+            //~^ crate_in_macro_def
         };
     }
 
diff --git a/src/tools/clippy/tests/ui/crate_level_checks/entrypoint_recursion.rs b/src/tools/clippy/tests/ui/crate_level_checks/entrypoint_recursion.rs
index 5d853d97bc35..3ded902e36b1 100644
--- a/src/tools/clippy/tests/ui/crate_level_checks/entrypoint_recursion.rs
+++ b/src/tools/clippy/tests/ui/crate_level_checks/entrypoint_recursion.rs
@@ -1,3 +1,4 @@
+//@check-pass
 //@ignore-target: apple
 
 #![feature(rustc_attrs)]
diff --git a/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.rs b/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.rs
index 536e71b4a25a..66ca97690c17 100644
--- a/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.rs
+++ b/src/tools/clippy/tests/ui/crate_level_checks/no_std_swap.rs
@@ -9,7 +9,7 @@ pub fn main() {
     let mut b = 1337;
 
     a = b;
-    //~^ ERROR: this looks like you are trying to swap `a` and `b`
-    //~| NOTE: or maybe you should use `core::mem::replace`?
+    //~^ almost_swapped
+
     b = a;
 }
diff --git a/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.rs b/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.rs
index c2c3e0958ec7..50f82b59a96e 100644
--- a/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.rs
+++ b/src/tools/clippy/tests/ui/crate_level_checks/std_main_recursion.rs
@@ -3,5 +3,5 @@
 fn main() {
     println!("Hello, World!");
     main();
-    //~^ ERROR: recursing into entrypoint `main`
+    //~^ main_recursion
 }
diff --git a/src/tools/clippy/tests/ui/create_dir.fixed b/src/tools/clippy/tests/ui/create_dir.fixed
index 8fbf7dd19b83..4a5b1b77be6b 100644
--- a/src/tools/clippy/tests/ui/create_dir.fixed
+++ b/src/tools/clippy/tests/ui/create_dir.fixed
@@ -8,7 +8,9 @@ fn create_dir() {}
 fn main() {
     // Should be warned
     create_dir_all("foo");
+    //~^ create_dir
     create_dir_all("bar").unwrap();
+    //~^ create_dir
 
     // Shouldn't be warned
     create_dir();
diff --git a/src/tools/clippy/tests/ui/create_dir.rs b/src/tools/clippy/tests/ui/create_dir.rs
index af2c326ec436..bf185ba3a7c3 100644
--- a/src/tools/clippy/tests/ui/create_dir.rs
+++ b/src/tools/clippy/tests/ui/create_dir.rs
@@ -8,7 +8,9 @@ fn create_dir() {}
 fn main() {
     // Should be warned
     std::fs::create_dir("foo");
+    //~^ create_dir
     std::fs::create_dir("bar").unwrap();
+    //~^ create_dir
 
     // Shouldn't be warned
     create_dir();
diff --git a/src/tools/clippy/tests/ui/create_dir.stderr b/src/tools/clippy/tests/ui/create_dir.stderr
index 9bb98a2606dd..51d6ac686e02 100644
--- a/src/tools/clippy/tests/ui/create_dir.stderr
+++ b/src/tools/clippy/tests/ui/create_dir.stderr
@@ -13,7 +13,7 @@ LL +     create_dir_all("foo");
    |
 
 error: calling `std::fs::create_dir` where there may be a better way
-  --> tests/ui/create_dir.rs:11:5
+  --> tests/ui/create_dir.rs:12:5
    |
 LL |     std::fs::create_dir("bar").unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.fixed b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.fixed
index bda9221a5e1e..fd1a0d8934b3 100644
--- a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.fixed
+++ b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.fixed
@@ -3,28 +3,31 @@
 
 fn foo(n: u32) -> u32 {
     if let Some(n) = n.checked_sub(4) { n } else { n }
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 fn bar(_: ()) {}
 
 fn factorial(n: u32) -> u32 {
     if n <= 1 {
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
+
         1
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     } else {
         n * factorial(n - 1)
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     }
 }
 
 fn main() {
     42;
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     foo(3) + factorial(4);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     (1, 2, 3, 4, 5);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 
 fn issue9914() {
@@ -41,21 +44,26 @@ fn issue9914() {
     macro_rules! expand_to_dbg {
         () => {
             
-            //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+            //~^ dbg_macro
         };
     }
 
     
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     #[allow(clippy::let_unit_value)]
     let _ = ();
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     bar(());
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     foo!(());
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     foo2!(foo!(()));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     expand_to_dbg!();
 }
 
@@ -77,35 +85,36 @@ mod issue7274 {
     struct MyThing;
     define_thing!(MyThing, {
         2;
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     });
 }
 
 #[test]
 pub fn issue8481() {
     1;
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 
 #[cfg(test)]
 fn foo2() {
     1;
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 
 #[cfg(test)]
 mod mod1 {
     fn func() {
         1;
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     }
 }
 
 mod issue12131 {
     fn dbg_in_print(s: &str) {
         println!("dbg: {:?}", s);
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
+
         print!("{}", s);
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     }
 }
diff --git a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.rs b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.rs
index 8244254026be..c96e2c7251c2 100644
--- a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.rs
+++ b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.rs
@@ -3,28 +3,31 @@
 
 fn foo(n: u32) -> u32 {
     if let Some(n) = dbg!(n.checked_sub(4)) { n } else { n }
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 fn bar(_: ()) {}
 
 fn factorial(n: u32) -> u32 {
     if dbg!(n <= 1) {
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
+
         dbg!(1)
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     } else {
         dbg!(n * factorial(n - 1))
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     }
 }
 
 fn main() {
     dbg!(42);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     foo(3) + dbg!(factorial(4));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     dbg!(1, 2, 3, 4, 5);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 
 fn issue9914() {
@@ -41,21 +44,26 @@ fn issue9914() {
     macro_rules! expand_to_dbg {
         () => {
             dbg!();
-            //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+            //~^ dbg_macro
         };
     }
 
     dbg!();
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     #[allow(clippy::let_unit_value)]
     let _ = dbg!();
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     bar(dbg!());
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     foo!(dbg!());
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     foo2!(foo!(dbg!()));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+
     expand_to_dbg!();
 }
 
@@ -77,35 +85,36 @@ mod issue7274 {
     struct MyThing;
     define_thing!(MyThing, {
         dbg!(2);
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     });
 }
 
 #[test]
 pub fn issue8481() {
     dbg!(1);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 
 #[cfg(test)]
 fn foo2() {
     dbg!(1);
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
 }
 
 #[cfg(test)]
 mod mod1 {
     fn func() {
         dbg!(1);
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     }
 }
 
 mod issue12131 {
     fn dbg_in_print(s: &str) {
         println!("dbg: {:?}", dbg!(s));
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
+
         print!("{}", dbg!(s));
-        //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+        //~^ dbg_macro
     }
 }
diff --git a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr
index f218614fdd62..cd6dce584a2f 100644
--- a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr
+++ b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro.stderr
@@ -25,7 +25,7 @@ LL +     if n <= 1 {
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:13:9
+  --> tests/ui/dbg_macro/dbg_macro.rs:14:9
    |
 LL |         dbg!(1)
    |         ^^^^^^^
@@ -37,7 +37,7 @@ LL +         1
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:16:9
+  --> tests/ui/dbg_macro/dbg_macro.rs:17:9
    |
 LL |         dbg!(n * factorial(n - 1))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +         n * factorial(n - 1)
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:22:5
+  --> tests/ui/dbg_macro/dbg_macro.rs:23:5
    |
 LL |     dbg!(42);
    |     ^^^^^^^^
@@ -61,7 +61,7 @@ LL +     42;
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:24:14
+  --> tests/ui/dbg_macro/dbg_macro.rs:26:14
    |
 LL |     foo(3) + dbg!(factorial(4));
    |              ^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     foo(3) + factorial(4);
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:26:5
+  --> tests/ui/dbg_macro/dbg_macro.rs:29:5
    |
 LL |     dbg!(1, 2, 3, 4, 5);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     (1, 2, 3, 4, 5);
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:48:5
+  --> tests/ui/dbg_macro/dbg_macro.rs:51:5
    |
 LL |     dbg!();
    |     ^^^^^^
@@ -96,7 +96,7 @@ LL -     dbg!();
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:51:13
+  --> tests/ui/dbg_macro/dbg_macro.rs:55:13
    |
 LL |     let _ = dbg!();
    |             ^^^^^^
@@ -108,7 +108,7 @@ LL +     let _ = ();
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:53:9
+  --> tests/ui/dbg_macro/dbg_macro.rs:58:9
    |
 LL |     bar(dbg!());
    |         ^^^^^^
@@ -120,7 +120,7 @@ LL +     bar(());
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:55:10
+  --> tests/ui/dbg_macro/dbg_macro.rs:61:10
    |
 LL |     foo!(dbg!());
    |          ^^^^^^
@@ -132,7 +132,7 @@ LL +     foo!(());
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:57:16
+  --> tests/ui/dbg_macro/dbg_macro.rs:64:16
    |
 LL |     foo2!(foo!(dbg!()));
    |                ^^^^^^
@@ -144,7 +144,7 @@ LL +     foo2!(foo!(()));
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:43:13
+  --> tests/ui/dbg_macro/dbg_macro.rs:46:13
    |
 LL |             dbg!();
    |             ^^^^^^
@@ -159,7 +159,7 @@ LL -             dbg!();
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:79:9
+  --> tests/ui/dbg_macro/dbg_macro.rs:87:9
    |
 LL |         dbg!(2);
    |         ^^^^^^^
@@ -171,7 +171,7 @@ LL +         2;
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:86:5
+  --> tests/ui/dbg_macro/dbg_macro.rs:94:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
@@ -183,7 +183,7 @@ LL +     1;
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:92:5
+  --> tests/ui/dbg_macro/dbg_macro.rs:100:5
    |
 LL |     dbg!(1);
    |     ^^^^^^^
@@ -195,7 +195,7 @@ LL +     1;
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:99:9
+  --> tests/ui/dbg_macro/dbg_macro.rs:107:9
    |
 LL |         dbg!(1);
    |         ^^^^^^^
@@ -207,7 +207,7 @@ LL +         1;
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:106:31
+  --> tests/ui/dbg_macro/dbg_macro.rs:114:31
    |
 LL |         println!("dbg: {:?}", dbg!(s));
    |                               ^^^^^^^
@@ -219,7 +219,7 @@ LL +         println!("dbg: {:?}", s);
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro.rs:108:22
+  --> tests/ui/dbg_macro/dbg_macro.rs:117:22
    |
 LL |         print!("{}", dbg!(s));
    |                      ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.rs b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.rs
index 0e83766ccaec..1a5119651b53 100644
--- a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.rs
+++ b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.rs
@@ -1,4 +1,5 @@
 //@no-rustfix
+//@error-in-other-file:
 #![warn(clippy::dbg_macro)]
 
 #[path = "auxiliary/submodule.rs"]
@@ -6,7 +7,11 @@ mod submodule;
 
 fn main() {
     dbg!(dbg!(dbg!(42)));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+    //~| dbg_macro
+    //~| dbg_macro
+
     dbg!(1, 2, dbg!(3, 4));
-    //~^ ERROR: the `dbg!` macro is intended as a debugging tool
+    //~^ dbg_macro
+    //~| dbg_macro
 }
diff --git a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
index e8d5f9f2f46f..afade6f08b3c 100644
--- a/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/dbg_macro/dbg_macro_unfixable.stderr
@@ -12,7 +12,7 @@ LL -     dbg!();
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:8:5
+  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:9:5
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL +     dbg!(dbg!(42));
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:8:10
+  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:9:10
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |          ^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL +     dbg!(dbg!(42));
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:8:15
+  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:9:15
    |
 LL |     dbg!(dbg!(dbg!(42)));
    |               ^^^^^^^^
@@ -48,7 +48,7 @@ LL +     dbg!(dbg!(42));
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:10:5
+  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:14:5
    |
 LL |     dbg!(1, 2, dbg!(3, 4));
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL +     (1, 2, dbg!(3, 4));
    |
 
 error: the `dbg!` macro is intended as a debugging tool
-  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:10:16
+  --> tests/ui/dbg_macro/dbg_macro_unfixable.rs:14:16
    |
 LL |     dbg!(1, 2, dbg!(3, 4));
    |                ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/debug_assert_with_mut_call.rs b/src/tools/clippy/tests/ui/debug_assert_with_mut_call.rs
index 8d04be777c7b..74d59b7593fa 100644
--- a/src/tools/clippy/tests/ui/debug_assert_with_mut_call.rs
+++ b/src/tools/clippy/tests/ui/debug_assert_with_mut_call.rs
@@ -40,20 +40,26 @@ fn func_non_mutable() {
 
 fn func_mutable() {
     debug_assert!(bool_mut(&mut 3));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
-    //~| NOTE: `-D clippy::debug-assert-with-mut-call` implied by `-D warnings`
+    //~^ debug_assert_with_mut_call
+
+
     debug_assert!(!bool_mut(&mut 3));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
 
     debug_assert_eq!(0, u32_mut(&mut 3));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_eq!(u32_mut(&mut 3), 0);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
 
     debug_assert_ne!(1, u32_mut(&mut 3));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_ne!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_ne!(u32_mut(&mut 3), 1);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_ne!`
+    //~^ debug_assert_with_mut_call
+
 }
 
 fn method_non_mutable() {
@@ -69,33 +75,46 @@ fn method_non_mutable() {
 
 fn method_mutable() {
     debug_assert!(S.bool_self_mut());
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert!(!S.bool_self_mut());
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert!(S.bool_self_ref_arg_mut(&mut 3));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert!(S.bool_self_mut_arg_ref(&3));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert!(S.bool_self_mut_arg_mut(&mut 3));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
 
     debug_assert_eq!(S.u32_self_mut(), 0);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_eq!(S.u32_self_mut_arg_ref(&3), 0);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_eq!(S.u32_self_ref_arg_mut(&mut 3), 0);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_eq!(S.u32_self_mut_arg_mut(&mut 3), 0);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
 
     debug_assert_ne!(S.u32_self_mut(), 1);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_ne!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_ne!(S.u32_self_mut_arg_ref(&3), 1);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_ne!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_ne!(S.u32_self_ref_arg_mut(&mut 3), 1);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_ne!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_ne!(S.u32_self_mut_arg_mut(&mut 3), 1);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_ne!`
+    //~^ debug_assert_with_mut_call
+
 }
 
 fn misc() {
@@ -104,35 +123,43 @@ fn misc() {
     debug_assert_eq!(v.get(0), Some(&1));
     debug_assert_ne!(v[0], 2);
     debug_assert_eq!(v.pop(), Some(1));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert_ne!(Some(3), v.pop());
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_ne!`
+    //~^ debug_assert_with_mut_call
+
 
     let a = &mut 3;
     debug_assert!(bool_mut(a));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
 
     // nested
     debug_assert!(!(bool_ref(&u32_mut(&mut 3))));
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
 
     // chained
     debug_assert_eq!(v.pop().unwrap(), 3);
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert_eq!`
+    //~^ debug_assert_with_mut_call
+
 
     // format args
     debug_assert!(bool_ref(&3), "w/o format");
     debug_assert!(bool_mut(&mut 3), "w/o format");
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
     debug_assert!(bool_ref(&3), "{} format", "w/");
     debug_assert!(bool_mut(&mut 3), "{} format", "w/");
-    //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!`
+    //~^ debug_assert_with_mut_call
+
 
     // sub block
     let mut x = 42_u32;
     debug_assert!({
         bool_mut(&mut x);
-        //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!
+        //~^ debug_assert_with_mut_call
+
         x > 10
     });
 
@@ -140,7 +167,8 @@ fn misc() {
     debug_assert!((|| {
         let mut x = 42;
         bool_mut(&mut x);
-        //~^ ERROR: do not call a function with mutable arguments inside of `debug_assert!
+        //~^ debug_assert_with_mut_call
+
         x > 10
     })());
 }
diff --git a/src/tools/clippy/tests/ui/debug_assert_with_mut_call.stderr b/src/tools/clippy/tests/ui/debug_assert_with_mut_call.stderr
index 83e1105a07df..216ab27264c1 100644
--- a/src/tools/clippy/tests/ui/debug_assert_with_mut_call.stderr
+++ b/src/tools/clippy/tests/ui/debug_assert_with_mut_call.stderr
@@ -8,163 +8,163 @@ LL |     debug_assert!(bool_mut(&mut 3));
    = help: to override `-D warnings` add `#[allow(clippy::debug_assert_with_mut_call)]`
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:45:20
+  --> tests/ui/debug_assert_with_mut_call.rs:46:20
    |
 LL |     debug_assert!(!bool_mut(&mut 3));
    |                    ^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:48:25
+  --> tests/ui/debug_assert_with_mut_call.rs:50:25
    |
 LL |     debug_assert_eq!(0, u32_mut(&mut 3));
    |                         ^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:50:22
+  --> tests/ui/debug_assert_with_mut_call.rs:53:22
    |
 LL |     debug_assert_eq!(u32_mut(&mut 3), 0);
    |                      ^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_ne!`
-  --> tests/ui/debug_assert_with_mut_call.rs:53:25
+  --> tests/ui/debug_assert_with_mut_call.rs:57:25
    |
 LL |     debug_assert_ne!(1, u32_mut(&mut 3));
    |                         ^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_ne!`
-  --> tests/ui/debug_assert_with_mut_call.rs:55:22
+  --> tests/ui/debug_assert_with_mut_call.rs:60:22
    |
 LL |     debug_assert_ne!(u32_mut(&mut 3), 1);
    |                      ^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:71:19
+  --> tests/ui/debug_assert_with_mut_call.rs:77:19
    |
 LL |     debug_assert!(S.bool_self_mut());
    |                   ^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:73:20
+  --> tests/ui/debug_assert_with_mut_call.rs:80:20
    |
 LL |     debug_assert!(!S.bool_self_mut());
    |                    ^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:75:19
+  --> tests/ui/debug_assert_with_mut_call.rs:83:19
    |
 LL |     debug_assert!(S.bool_self_ref_arg_mut(&mut 3));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:77:19
+  --> tests/ui/debug_assert_with_mut_call.rs:86:19
    |
 LL |     debug_assert!(S.bool_self_mut_arg_ref(&3));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:79:19
+  --> tests/ui/debug_assert_with_mut_call.rs:89:19
    |
 LL |     debug_assert!(S.bool_self_mut_arg_mut(&mut 3));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:82:22
+  --> tests/ui/debug_assert_with_mut_call.rs:93:22
    |
 LL |     debug_assert_eq!(S.u32_self_mut(), 0);
    |                      ^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:84:22
+  --> tests/ui/debug_assert_with_mut_call.rs:96:22
    |
 LL |     debug_assert_eq!(S.u32_self_mut_arg_ref(&3), 0);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:86:22
+  --> tests/ui/debug_assert_with_mut_call.rs:99:22
    |
 LL |     debug_assert_eq!(S.u32_self_ref_arg_mut(&mut 3), 0);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:88:22
+  --> tests/ui/debug_assert_with_mut_call.rs:102:22
    |
 LL |     debug_assert_eq!(S.u32_self_mut_arg_mut(&mut 3), 0);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_ne!`
-  --> tests/ui/debug_assert_with_mut_call.rs:91:22
+  --> tests/ui/debug_assert_with_mut_call.rs:106:22
    |
 LL |     debug_assert_ne!(S.u32_self_mut(), 1);
    |                      ^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_ne!`
-  --> tests/ui/debug_assert_with_mut_call.rs:93:22
+  --> tests/ui/debug_assert_with_mut_call.rs:109:22
    |
 LL |     debug_assert_ne!(S.u32_self_mut_arg_ref(&3), 1);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_ne!`
-  --> tests/ui/debug_assert_with_mut_call.rs:95:22
+  --> tests/ui/debug_assert_with_mut_call.rs:112:22
    |
 LL |     debug_assert_ne!(S.u32_self_ref_arg_mut(&mut 3), 1);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_ne!`
-  --> tests/ui/debug_assert_with_mut_call.rs:97:22
+  --> tests/ui/debug_assert_with_mut_call.rs:115:22
    |
 LL |     debug_assert_ne!(S.u32_self_mut_arg_mut(&mut 3), 1);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:106:22
+  --> tests/ui/debug_assert_with_mut_call.rs:125:22
    |
 LL |     debug_assert_eq!(v.pop(), Some(1));
    |                      ^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_ne!`
-  --> tests/ui/debug_assert_with_mut_call.rs:108:31
+  --> tests/ui/debug_assert_with_mut_call.rs:128:31
    |
 LL |     debug_assert_ne!(Some(3), v.pop());
    |                               ^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:112:19
+  --> tests/ui/debug_assert_with_mut_call.rs:133:19
    |
 LL |     debug_assert!(bool_mut(a));
    |                   ^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:116:31
+  --> tests/ui/debug_assert_with_mut_call.rs:138:31
    |
 LL |     debug_assert!(!(bool_ref(&u32_mut(&mut 3))));
    |                               ^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert_eq!`
-  --> tests/ui/debug_assert_with_mut_call.rs:120:22
+  --> tests/ui/debug_assert_with_mut_call.rs:143:22
    |
 LL |     debug_assert_eq!(v.pop().unwrap(), 3);
    |                      ^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:125:19
+  --> tests/ui/debug_assert_with_mut_call.rs:149:19
    |
 LL |     debug_assert!(bool_mut(&mut 3), "w/o format");
    |                   ^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:128:19
+  --> tests/ui/debug_assert_with_mut_call.rs:153:19
    |
 LL |     debug_assert!(bool_mut(&mut 3), "{} format", "w/");
    |                   ^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:134:9
+  --> tests/ui/debug_assert_with_mut_call.rs:160:9
    |
 LL |         bool_mut(&mut x);
    |         ^^^^^^^^^^^^^^^^
 
 error: do not call a function with mutable arguments inside of `debug_assert!`
-  --> tests/ui/debug_assert_with_mut_call.rs:142:9
+  --> tests/ui/debug_assert_with_mut_call.rs:169:9
    |
 LL |         bool_mut(&mut x);
    |         ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/decimal_literal_representation.fixed b/src/tools/clippy/tests/ui/decimal_literal_representation.fixed
index e34f48b65dd1..e0477578488c 100644
--- a/src/tools/clippy/tests/ui/decimal_literal_representation.fixed
+++ b/src/tools/clippy/tests/ui/decimal_literal_representation.fixed
@@ -14,12 +14,19 @@ fn main() {
     );
     let bad = (        // Hex:
         0x8005,        // 0x8005
+        //~^ decimal_literal_representation
         0xFF00,        // 0xFF00
+        //~^ decimal_literal_representation
         0x7F0F_F00F, // 0x7F0F_F00F
+        //~^ decimal_literal_representation
         0x7FFF_FFFF, // 0x7FFF_FFFF
+        //~^ decimal_literal_representation
         #[allow(overflowing_literals)]
         0xF0F0_F0F0, // 0xF0F0_F0F0
+        //~^ decimal_literal_representation
         0x8005_usize,   // 0x8005_usize
+        //~^ decimal_literal_representation
         0x7F0F_F00F_isize, // 0x7F0F_F00F_isize
+        //~^ decimal_literal_representation
     );
 }
diff --git a/src/tools/clippy/tests/ui/decimal_literal_representation.rs b/src/tools/clippy/tests/ui/decimal_literal_representation.rs
index bcc4d0df9c0e..85dc4fac0928 100644
--- a/src/tools/clippy/tests/ui/decimal_literal_representation.rs
+++ b/src/tools/clippy/tests/ui/decimal_literal_representation.rs
@@ -14,12 +14,19 @@ fn main() {
     );
     let bad = (        // Hex:
         32_773,        // 0x8005
+        //~^ decimal_literal_representation
         65_280,        // 0xFF00
+        //~^ decimal_literal_representation
         2_131_750_927, // 0x7F0F_F00F
+        //~^ decimal_literal_representation
         2_147_483_647, // 0x7FFF_FFFF
+        //~^ decimal_literal_representation
         #[allow(overflowing_literals)]
         4_042_322_160, // 0xF0F0_F0F0
+        //~^ decimal_literal_representation
         32_773usize,   // 0x8005_usize
+        //~^ decimal_literal_representation
         2_131_750_927isize, // 0x7F0F_F00F_isize
+        //~^ decimal_literal_representation
     );
 }
diff --git a/src/tools/clippy/tests/ui/decimal_literal_representation.stderr b/src/tools/clippy/tests/ui/decimal_literal_representation.stderr
index 824e7ec85ee0..0196350ce402 100644
--- a/src/tools/clippy/tests/ui/decimal_literal_representation.stderr
+++ b/src/tools/clippy/tests/ui/decimal_literal_representation.stderr
@@ -8,37 +8,37 @@ LL |         32_773,        // 0x8005
    = help: to override `-D warnings` add `#[allow(clippy::decimal_literal_representation)]`
 
 error: integer literal has a better hexadecimal representation
-  --> tests/ui/decimal_literal_representation.rs:17:9
+  --> tests/ui/decimal_literal_representation.rs:18:9
    |
 LL |         65_280,        // 0xFF00
    |         ^^^^^^ help: consider: `0xFF00`
 
 error: integer literal has a better hexadecimal representation
-  --> tests/ui/decimal_literal_representation.rs:18:9
+  --> tests/ui/decimal_literal_representation.rs:20:9
    |
 LL |         2_131_750_927, // 0x7F0F_F00F
    |         ^^^^^^^^^^^^^ help: consider: `0x7F0F_F00F`
 
 error: integer literal has a better hexadecimal representation
-  --> tests/ui/decimal_literal_representation.rs:19:9
+  --> tests/ui/decimal_literal_representation.rs:22:9
    |
 LL |         2_147_483_647, // 0x7FFF_FFFF
    |         ^^^^^^^^^^^^^ help: consider: `0x7FFF_FFFF`
 
 error: integer literal has a better hexadecimal representation
-  --> tests/ui/decimal_literal_representation.rs:21:9
+  --> tests/ui/decimal_literal_representation.rs:25:9
    |
 LL |         4_042_322_160, // 0xF0F0_F0F0
    |         ^^^^^^^^^^^^^ help: consider: `0xF0F0_F0F0`
 
 error: integer literal has a better hexadecimal representation
-  --> tests/ui/decimal_literal_representation.rs:22:9
+  --> tests/ui/decimal_literal_representation.rs:27:9
    |
 LL |         32_773usize,   // 0x8005_usize
    |         ^^^^^^^^^^^ help: consider: `0x8005_usize`
 
 error: integer literal has a better hexadecimal representation
-  --> tests/ui/decimal_literal_representation.rs:23:9
+  --> tests/ui/decimal_literal_representation.rs:29:9
    |
 LL |         2_131_750_927isize, // 0x7F0F_F00F_isize
    |         ^^^^^^^^^^^^^^^^^^ help: consider: `0x7F0F_F00F_isize`
diff --git a/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.rs b/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.rs
index a88bf7b21b8b..c87468277fb3 100644
--- a/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.rs
+++ b/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.rs
@@ -9,7 +9,8 @@ enum OptionalCell {
 }
 
 // a constant with enums should be linted only when the used variant is unfrozen (#3962).
-const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(true)); //~ ERROR: interior mutable
+const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(true));
+//~^ declare_interior_mutable_const
 const FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
 
 const fn unfrozen_variant() -> OptionalCell {
@@ -20,7 +21,8 @@ const fn frozen_variant() -> OptionalCell {
     OptionalCell::Frozen
 }
 
-const UNFROZEN_VARIANT_FROM_FN: OptionalCell = unfrozen_variant(); //~ ERROR: interior mutable
+const UNFROZEN_VARIANT_FROM_FN: OptionalCell = unfrozen_variant();
+//~^ declare_interior_mutable_const
 const FROZEN_VARIANT_FROM_FN: OptionalCell = frozen_variant();
 
 enum NestedInnermost {
@@ -43,7 +45,7 @@ struct NestedOutermost {
 
 // a constant with enums should be linted according to its value, no matter how structs involve.
 const NESTED_UNFROZEN_VARIANT: NestedOutermost = NestedOutermost {
-    //~^ ERROR: interior mutable
+    //~^ declare_interior_mutable_const
     outer: NestedOuter::NestedInner(NestedInner {
         inner: NestedInnermost::Unfrozen(AtomicUsize::new(2)),
     }),
@@ -57,11 +59,14 @@ const NESTED_FROZEN_VARIANT: NestedOutermost = NestedOutermost {
 trait AssocConsts {
     // When there's no default value, lint it only according to its type.
     // Further details are on the corresponding code (`NonCopyConst::check_trait_item`).
-    const TO_BE_UNFROZEN_VARIANT: OptionalCell; //~ ERROR: interior mutable
-    const TO_BE_FROZEN_VARIANT: OptionalCell; //~ ERROR: interior mutable
+    const TO_BE_UNFROZEN_VARIANT: OptionalCell;
+    //~^ declare_interior_mutable_const
+    const TO_BE_FROZEN_VARIANT: OptionalCell;
+    //~^ declare_interior_mutable_const
 
     // Lint default values accordingly.
-    const DEFAULTED_ON_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false)); //~ ERROR: interior mutable
+    const DEFAULTED_ON_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false));
+    //~^ declare_interior_mutable_const
     const DEFAULTED_ON_FROZEN_VARIANT: OptionalCell = OptionalCell::Frozen;
 }
 
@@ -87,7 +92,8 @@ trait AssocTypes {
 impl AssocTypes for u64 {
     type ToBeUnfrozen = AtomicUsize;
 
-    const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen> = Some(Self::ToBeUnfrozen::new(4)); //~ ERROR: interior mutable
+    const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen> = Some(Self::ToBeUnfrozen::new(4));
+    //~^ declare_interior_mutable_const
     const TO_BE_FROZEN_VARIANT: Option<Self::ToBeUnfrozen> = None;
 }
 
@@ -99,25 +105,30 @@ enum BothOfCellAndGeneric<T> {
 }
 
 impl<T> BothOfCellAndGeneric<T> {
-    const UNFROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null())); //~ ERROR: interior mutable
+    const UNFROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null()));
+    //~^ declare_interior_mutable_const
 
     // This is a false positive. The argument about this is on `is_value_unfrozen_raw`
-    const GENERIC_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Generic(std::ptr::null()); //~ ERROR: interior mutable
+    const GENERIC_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Generic(std::ptr::null());
+    //~^ declare_interior_mutable_const
 
     const FROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Frozen(5);
 
     // This is what is likely to be a false negative when one tries to fix
     // the `GENERIC_VARIANT` false positive.
-    const NO_ENUM: Cell<*const T> = Cell::new(std::ptr::null()); //~ ERROR: interior mutable
+    const NO_ENUM: Cell<*const T> = Cell::new(std::ptr::null());
+    //~^ declare_interior_mutable_const
 }
 
 // associated types here is basically the same as the one above.
 trait BothOfCellAndGenericWithAssocType {
     type AssocType;
 
-    const UNFROZEN_VARIANT: BothOfCellAndGeneric<Self::AssocType> = //~ ERROR: interior mutable
+    const UNFROZEN_VARIANT: BothOfCellAndGeneric<Self::AssocType> =
+        //~^ declare_interior_mutable_const
         BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null()));
-    const GENERIC_VARIANT: BothOfCellAndGeneric<Self::AssocType> = BothOfCellAndGeneric::Generic(std::ptr::null()); //~ ERROR: interior mutable
+    const GENERIC_VARIANT: BothOfCellAndGeneric<Self::AssocType> = BothOfCellAndGeneric::Generic(std::ptr::null());
+    //~^ declare_interior_mutable_const
     const FROZEN_VARIANT: BothOfCellAndGeneric<Self::AssocType> = BothOfCellAndGeneric::Frozen(5);
 }
 
diff --git a/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.stderr b/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.stderr
index 22329172c3af..32839d14f0ed 100644
--- a/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.stderr
+++ b/src/tools/clippy/tests/ui/declare_interior_mutable_const/enums.stderr
@@ -9,7 +9,7 @@ LL | const UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(tru
    = help: to override `-D warnings` add `#[allow(clippy::declare_interior_mutable_const)]`
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:23:1
+  --> tests/ui/declare_interior_mutable_const/enums.rs:24:1
    |
 LL | const UNFROZEN_VARIANT_FROM_FN: OptionalCell = unfrozen_variant();
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | const UNFROZEN_VARIANT_FROM_FN: OptionalCell = unfrozen_variant();
    = help: consider making this `Sync` so that it can go in a static item or using a `thread_local`
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:45:1
+  --> tests/ui/declare_interior_mutable_const/enums.rs:47:1
    |
 LL | / const NESTED_UNFROZEN_VARIANT: NestedOutermost = NestedOutermost {
 LL | |
@@ -30,56 +30,57 @@ LL | | };
    = help: consider making this a static item
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:60:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:62:5
    |
 LL |     const TO_BE_UNFROZEN_VARIANT: OptionalCell;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:61:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:64:5
    |
 LL |     const TO_BE_FROZEN_VARIANT: OptionalCell;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:64:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:68:5
    |
 LL |     const DEFAULTED_ON_UNFROZEN_VARIANT: OptionalCell = OptionalCell::Unfrozen(Cell::new(false));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:90:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:95:5
    |
 LL |     const TO_BE_UNFROZEN_VARIANT: Option<Self::ToBeUnfrozen> = Some(Self::ToBeUnfrozen::new(4));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:102:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:108:5
    |
 LL |     const UNFROZEN_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:105:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:112:5
    |
 LL |     const GENERIC_VARIANT: BothOfCellAndGeneric<T> = BothOfCellAndGeneric::Generic(std::ptr::null());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:111:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:119:5
    |
 LL |     const NO_ENUM: Cell<*const T> = Cell::new(std::ptr::null());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:118:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:127:5
    |
 LL | /     const UNFROZEN_VARIANT: BothOfCellAndGeneric<Self::AssocType> =
+LL | |
 LL | |         BothOfCellAndGeneric::Unfrozen(Cell::new(std::ptr::null()));
    | |____________________________________________________________________^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/enums.rs:120:5
+  --> tests/ui/declare_interior_mutable_const/enums.rs:130:5
    |
 LL |     const GENERIC_VARIANT: BothOfCellAndGeneric<Self::AssocType> = BothOfCellAndGeneric::Generic(std::ptr::null());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.rs b/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.rs
index 0dccf18c4930..7ce04a3f2c34 100644
--- a/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.rs
+++ b/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.rs
@@ -7,15 +7,17 @@ use std::ptr;
 use std::sync::Once;
 use std::sync::atomic::AtomicUsize;
 
-const ATOMIC: AtomicUsize = AtomicUsize::new(5); //~ ERROR: interior mutable
-const CELL: Cell<usize> = Cell::new(6); //~ ERROR: interior mutable
+const ATOMIC: AtomicUsize = AtomicUsize::new(5);
+//~^ declare_interior_mutable_const
+const CELL: Cell<usize> = Cell::new(6);
+//~^ declare_interior_mutable_const
 const ATOMIC_TUPLE: ([AtomicUsize; 1], Vec<AtomicUsize>, u8) = ([ATOMIC], Vec::new(), 7);
-//~^ ERROR: interior mutable
+//~^ declare_interior_mutable_const
 
 macro_rules! declare_const {
     ($name:ident: $ty:ty = $e:expr) => {
         const $name: $ty = $e;
-        //~^ ERROR: interior mutable
+        //~^ declare_interior_mutable_const
     };
 }
 declare_const!(_ONCE: Once = Once::new());
@@ -43,6 +45,7 @@ mod issue_8493 {
     macro_rules! issue_8493 {
         () => {
             const _BAZ: Cell<usize> = Cell::new(0);
+            //~^ declare_interior_mutable_const
             static _FOOBAR: () = {
                 thread_local! {
                     static _VAR: Cell<i32> = const { Cell::new(0) };
diff --git a/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.stderr b/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.stderr
index 4a7251471424..09299b290416 100644
--- a/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.stderr
+++ b/src/tools/clippy/tests/ui/declare_interior_mutable_const/others.stderr
@@ -9,7 +9,7 @@ LL | const ATOMIC: AtomicUsize = AtomicUsize::new(5);
    = help: to override `-D warnings` add `#[allow(clippy::declare_interior_mutable_const)]`
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:11:1
+  --> tests/ui/declare_interior_mutable_const/others.rs:12:1
    |
 LL | const CELL: Cell<usize> = Cell::new(6);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | const CELL: Cell<usize> = Cell::new(6);
    = help: consider making this `Sync` so that it can go in a static item or using a `thread_local`
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:12:1
+  --> tests/ui/declare_interior_mutable_const/others.rs:14:1
    |
 LL | const ATOMIC_TUPLE: ([AtomicUsize; 1], Vec<AtomicUsize>, u8) = ([ATOMIC], Vec::new(), 7);
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | const ATOMIC_TUPLE: ([AtomicUsize; 1], Vec<AtomicUsize>, u8) = ([ATOMIC], V
    = help: consider making this a static item
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:17:9
+  --> tests/ui/declare_interior_mutable_const/others.rs:19:9
    |
 LL |         const $name: $ty = $e;
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL | declare_const!(_ONCE: Once = Once::new());
    = note: this error originates in the macro `declare_const` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/others.rs:45:13
+  --> tests/ui/declare_interior_mutable_const/others.rs:47:13
    |
 LL |             const _BAZ: Cell<usize> = Cell::new(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs b/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs
index 490073f97fb1..d3139be6859f 100644
--- a/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs
+++ b/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.rs
@@ -7,13 +7,14 @@ use std::sync::atomic::AtomicUsize;
 macro_rules! declare_const {
     ($name:ident: $ty:ty = $e:expr) => {
         const $name: $ty = $e;
-        //~^ ERROR: interior mutable
+        //~^ declare_interior_mutable_const
     };
 }
 
 // a constant whose type is a concrete type should be linted at the definition site.
 trait ConcreteTypes {
-    const ATOMIC: AtomicUsize; //~ ERROR: interior mutable
+    const ATOMIC: AtomicUsize;
+    //~^ declare_interior_mutable_const
     const INTEGER: u64;
     const STRING: String;
     declare_const!(ANOTHER_ATOMIC: AtomicUsize = Self::ATOMIC);
@@ -41,7 +42,8 @@ trait GenericTypes<T, U> {
 
 impl<T: ConstDefault> GenericTypes<T, AtomicUsize> for u64 {
     const TO_REMAIN_GENERIC: T = T::DEFAULT;
-    const TO_BE_CONCRETE: AtomicUsize = AtomicUsize::new(11); //~ ERROR: interior mutable
+    const TO_BE_CONCRETE: AtomicUsize = AtomicUsize::new(11);
+    //~^ declare_interior_mutable_const
 }
 
 // a helper type used below
@@ -66,8 +68,10 @@ impl<T: ConstDefault> AssocTypes for Vec<T> {
     type ToBeGenericParam = T;
 
     const TO_BE_FROZEN: Self::ToBeFrozen = 12;
-    const TO_BE_UNFROZEN: Self::ToBeUnfrozen = AtomicUsize::new(13); //~ ERROR: interior mutable
-    const WRAPPED_TO_BE_UNFROZEN: Wrapper<Self::ToBeUnfrozen> = Wrapper(AtomicUsize::new(14)); //~ ERROR: interior mutable
+    const TO_BE_UNFROZEN: Self::ToBeUnfrozen = AtomicUsize::new(13);
+    //~^ declare_interior_mutable_const
+    const WRAPPED_TO_BE_UNFROZEN: Wrapper<Self::ToBeUnfrozen> = Wrapper(AtomicUsize::new(14));
+    //~^ declare_interior_mutable_const
     const WRAPPED_TO_BE_GENERIC_PARAM: Wrapper<Self::ToBeGenericParam> = Wrapper(T::DEFAULT);
 }
 
@@ -86,7 +90,8 @@ where
     T: AssocTypesHelper<ToBeBounded = AtomicUsize>,
 {
     const NOT_BOUNDED: T::NotToBeBounded;
-    const BOUNDED: T::ToBeBounded; //~ ERROR: interior mutable
+    const BOUNDED: T::ToBeBounded;
+    //~^ declare_interior_mutable_const
 }
 
 impl<T> AssocTypesFromGenericParam<T> for u64
@@ -114,19 +119,24 @@ impl SelfType for u64 {
 impl SelfType for AtomicUsize {
     // this (interior mutable `Self` const) exists in `parking_lot`.
     // `const_trait_impl` will replace it in the future, hopefully.
-    const SELF: Self = AtomicUsize::new(17); //~ ERROR: interior mutable
-    const WRAPPED_SELF: Option<Self> = Some(AtomicUsize::new(21)); //~ ERROR: interior mutable
+    const SELF: Self = AtomicUsize::new(17);
+    //~^ declare_interior_mutable_const
+    const WRAPPED_SELF: Option<Self> = Some(AtomicUsize::new(21));
+    //~^ declare_interior_mutable_const
 }
 
 // Even though a constant contains a generic type, if it also have an interior mutable type,
 // it should be linted at the definition site.
 trait BothOfCellAndGeneric<T> {
-    const DIRECT: Cell<T>; //~ ERROR: interior mutable
-    const INDIRECT: Cell<*const T>; //~ ERROR: interior mutable
+    const DIRECT: Cell<T>;
+    //~^ declare_interior_mutable_const
+    const INDIRECT: Cell<*const T>;
+    //~^ declare_interior_mutable_const
 }
 
 impl<T: ConstDefault> BothOfCellAndGeneric<T> for u64 {
-    const DIRECT: Cell<T> = Cell::new(T::DEFAULT); //~ ERROR: interior mutable
+    const DIRECT: Cell<T> = Cell::new(T::DEFAULT);
+    //~^ declare_interior_mutable_const
     const INDIRECT: Cell<*const T> = Cell::new(std::ptr::null());
 }
 
@@ -138,13 +148,15 @@ impl<T> Local<T>
 where
     T: ConstDefault + AssocTypesHelper<ToBeBounded = AtomicUsize>,
 {
-    const ATOMIC: AtomicUsize = AtomicUsize::new(18); //~ ERROR: interior mutable
+    const ATOMIC: AtomicUsize = AtomicUsize::new(18);
+    //~^ declare_interior_mutable_const
     const COW: Cow<'static, str> = Cow::Borrowed("tuvwxy");
 
     const GENERIC_TYPE: T = T::DEFAULT;
 
     const ASSOC_TYPE: T::NotToBeBounded = T::NOT_TO_BE_BOUNDED;
-    const BOUNDED_ASSOC_TYPE: T::ToBeBounded = AtomicUsize::new(19); //~ ERROR: interior mutable
+    const BOUNDED_ASSOC_TYPE: T::ToBeBounded = AtomicUsize::new(19);
+    //~^ declare_interior_mutable_const
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.stderr b/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.stderr
index 4a793d985e5e..b03dd7a08403 100644
--- a/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.stderr
+++ b/src/tools/clippy/tests/ui/declare_interior_mutable_const/traits.stderr
@@ -19,67 +19,67 @@ LL |     declare_const!(ANOTHER_ATOMIC: AtomicUsize = Self::ATOMIC);
    = note: this error originates in the macro `declare_const` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:44:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:45:5
    |
 LL |     const TO_BE_CONCRETE: AtomicUsize = AtomicUsize::new(11);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:69:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:71:5
    |
 LL |     const TO_BE_UNFROZEN: Self::ToBeUnfrozen = AtomicUsize::new(13);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:70:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:73:5
    |
 LL |     const WRAPPED_TO_BE_UNFROZEN: Wrapper<Self::ToBeUnfrozen> = Wrapper(AtomicUsize::new(14));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:89:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:93:5
    |
 LL |     const BOUNDED: T::ToBeBounded;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:117:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:122:5
    |
 LL |     const SELF: Self = AtomicUsize::new(17);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:118:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:124:5
    |
 LL |     const WRAPPED_SELF: Option<Self> = Some(AtomicUsize::new(21));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:124:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:131:5
    |
 LL |     const DIRECT: Cell<T>;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:125:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:133:5
    |
 LL |     const INDIRECT: Cell<*const T>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:129:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:138:5
    |
 LL |     const DIRECT: Cell<T> = Cell::new(T::DEFAULT);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:141:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:151:5
    |
 LL |     const ATOMIC: AtomicUsize = AtomicUsize::new(18);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: a `const` item should not be interior mutable
-  --> tests/ui/declare_interior_mutable_const/traits.rs:147:5
+  --> tests/ui/declare_interior_mutable_const/traits.rs:158:5
    |
 LL |     const BOUNDED_ASSOC_TYPE: T::ToBeBounded = AtomicUsize::new(19);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/default_constructed_unit_structs.fixed b/src/tools/clippy/tests/ui/default_constructed_unit_structs.fixed
index 3047c221d457..fa4d55177823 100644
--- a/src/tools/clippy/tests/ui/default_constructed_unit_structs.fixed
+++ b/src/tools/clippy/tests/ui/default_constructed_unit_structs.fixed
@@ -9,6 +9,7 @@ impl UnitStruct {
     fn new() -> Self {
         //should lint
         Self
+        //~^ default_constructed_unit_structs
     }
 }
 
@@ -51,6 +52,7 @@ impl NormalStruct {
         // should lint
         Self {
             inner: PhantomData,
+            //~^ default_constructed_unit_structs
         }
     }
 
@@ -124,9 +126,13 @@ mod issue_10755 {
 fn main() {
     // should lint
     let _ = PhantomData::<usize>;
+    //~^ default_constructed_unit_structs
     let _: PhantomData<i32> = PhantomData;
+    //~^ default_constructed_unit_structs
     let _: PhantomData<i32> = std::marker::PhantomData;
+    //~^ default_constructed_unit_structs
     let _ = UnitStruct;
+    //~^ default_constructed_unit_structs
 
     // should not lint
     let _ = TupleStruct::default();
diff --git a/src/tools/clippy/tests/ui/default_constructed_unit_structs.rs b/src/tools/clippy/tests/ui/default_constructed_unit_structs.rs
index 66afedb23801..291cd89da0b7 100644
--- a/src/tools/clippy/tests/ui/default_constructed_unit_structs.rs
+++ b/src/tools/clippy/tests/ui/default_constructed_unit_structs.rs
@@ -9,6 +9,7 @@ impl UnitStruct {
     fn new() -> Self {
         //should lint
         Self::default()
+        //~^ default_constructed_unit_structs
     }
 }
 
@@ -51,6 +52,7 @@ impl NormalStruct {
         // should lint
         Self {
             inner: PhantomData::default(),
+            //~^ default_constructed_unit_structs
         }
     }
 
@@ -124,9 +126,13 @@ mod issue_10755 {
 fn main() {
     // should lint
     let _ = PhantomData::<usize>::default();
+    //~^ default_constructed_unit_structs
     let _: PhantomData<i32> = PhantomData::default();
+    //~^ default_constructed_unit_structs
     let _: PhantomData<i32> = std::marker::PhantomData::default();
+    //~^ default_constructed_unit_structs
     let _ = UnitStruct::default();
+    //~^ default_constructed_unit_structs
 
     // should not lint
     let _ = TupleStruct::default();
diff --git a/src/tools/clippy/tests/ui/default_constructed_unit_structs.stderr b/src/tools/clippy/tests/ui/default_constructed_unit_structs.stderr
index c0fa73515c03..6d4e1bdc2cc8 100644
--- a/src/tools/clippy/tests/ui/default_constructed_unit_structs.stderr
+++ b/src/tools/clippy/tests/ui/default_constructed_unit_structs.stderr
@@ -8,31 +8,31 @@ LL |         Self::default()
    = help: to override `-D warnings` add `#[allow(clippy::default_constructed_unit_structs)]`
 
 error: use of `default` to create a unit struct
-  --> tests/ui/default_constructed_unit_structs.rs:53:31
+  --> tests/ui/default_constructed_unit_structs.rs:54:31
    |
 LL |             inner: PhantomData::default(),
    |                               ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> tests/ui/default_constructed_unit_structs.rs:126:33
+  --> tests/ui/default_constructed_unit_structs.rs:128:33
    |
 LL |     let _ = PhantomData::<usize>::default();
    |                                 ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> tests/ui/default_constructed_unit_structs.rs:127:42
+  --> tests/ui/default_constructed_unit_structs.rs:130:42
    |
 LL |     let _: PhantomData<i32> = PhantomData::default();
    |                                          ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> tests/ui/default_constructed_unit_structs.rs:128:55
+  --> tests/ui/default_constructed_unit_structs.rs:132:55
    |
 LL |     let _: PhantomData<i32> = std::marker::PhantomData::default();
    |                                                       ^^^^^^^^^^^ help: remove this call to `default`
 
 error: use of `default` to create a unit struct
-  --> tests/ui/default_constructed_unit_structs.rs:129:23
+  --> tests/ui/default_constructed_unit_structs.rs:134:23
    |
 LL |     let _ = UnitStruct::default();
    |                       ^^^^^^^^^^^ help: remove this call to `default`
diff --git a/src/tools/clippy/tests/ui/default_instead_of_iter_empty.fixed b/src/tools/clippy/tests/ui/default_instead_of_iter_empty.fixed
index 3298a222bda6..548de9379927 100644
--- a/src/tools/clippy/tests/ui/default_instead_of_iter_empty.fixed
+++ b/src/tools/clippy/tests/ui/default_instead_of_iter_empty.fixed
@@ -10,8 +10,11 @@ struct Iter {
 fn main() {
     // Do lint.
     let _ = std::iter::empty::<usize>();
+    //~^ default_instead_of_iter_empty
     let _ = std::iter::empty::<HashMap<usize, usize>>();
+    //~^ default_instead_of_iter_empty
     let _foo: std::iter::Empty<usize> = std::iter::empty();
+    //~^ default_instead_of_iter_empty
 
     // Do not lint.
     let _ = Vec::<usize>::default();
diff --git a/src/tools/clippy/tests/ui/default_instead_of_iter_empty.rs b/src/tools/clippy/tests/ui/default_instead_of_iter_empty.rs
index 75b088a99590..824cc20566de 100644
--- a/src/tools/clippy/tests/ui/default_instead_of_iter_empty.rs
+++ b/src/tools/clippy/tests/ui/default_instead_of_iter_empty.rs
@@ -10,8 +10,11 @@ struct Iter {
 fn main() {
     // Do lint.
     let _ = std::iter::Empty::<usize>::default();
+    //~^ default_instead_of_iter_empty
     let _ = std::iter::Empty::<HashMap<usize, usize>>::default();
+    //~^ default_instead_of_iter_empty
     let _foo: std::iter::Empty<usize> = std::iter::Empty::default();
+    //~^ default_instead_of_iter_empty
 
     // Do not lint.
     let _ = Vec::<usize>::default();
diff --git a/src/tools/clippy/tests/ui/default_instead_of_iter_empty.stderr b/src/tools/clippy/tests/ui/default_instead_of_iter_empty.stderr
index 4bd4d060a3f7..dc0b757adc2e 100644
--- a/src/tools/clippy/tests/ui/default_instead_of_iter_empty.stderr
+++ b/src/tools/clippy/tests/ui/default_instead_of_iter_empty.stderr
@@ -8,13 +8,13 @@ LL |     let _ = std::iter::Empty::<usize>::default();
    = help: to override `-D warnings` add `#[allow(clippy::default_instead_of_iter_empty)]`
 
 error: `std::iter::empty()` is the more idiomatic way
-  --> tests/ui/default_instead_of_iter_empty.rs:13:13
+  --> tests/ui/default_instead_of_iter_empty.rs:14:13
    |
 LL |     let _ = std::iter::Empty::<HashMap<usize, usize>>::default();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::empty::<HashMap<usize, usize>>()`
 
 error: `std::iter::empty()` is the more idiomatic way
-  --> tests/ui/default_instead_of_iter_empty.rs:14:41
+  --> tests/ui/default_instead_of_iter_empty.rs:16:41
    |
 LL |     let _foo: std::iter::Empty<usize> = std::iter::Empty::default();
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
diff --git a/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.fixed b/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.fixed
index 7300bd9bd2ab..76d75ea7e591 100644
--- a/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.fixed
+++ b/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.fixed
@@ -21,7 +21,9 @@ struct Iter {
 fn main() {
     // Do lint.
     let _ = core::iter::empty::<usize>();
+    //~^ default_instead_of_iter_empty
     let _foo: core::iter::Empty<usize> = core::iter::empty();
+    //~^ default_instead_of_iter_empty
 
     // Do not lint.
     let _ = Iter::default();
diff --git a/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.rs b/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.rs
index 0bc5c7169d12..639b73ba38de 100644
--- a/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.rs
+++ b/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.rs
@@ -21,7 +21,9 @@ struct Iter {
 fn main() {
     // Do lint.
     let _ = core::iter::Empty::<usize>::default();
+    //~^ default_instead_of_iter_empty
     let _foo: core::iter::Empty<usize> = core::iter::Empty::default();
+    //~^ default_instead_of_iter_empty
 
     // Do not lint.
     let _ = Iter::default();
diff --git a/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.stderr b/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.stderr
index eb80da13e850..69812eba5423 100644
--- a/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.stderr
+++ b/src/tools/clippy/tests/ui/default_instead_of_iter_empty_no_std.stderr
@@ -8,7 +8,7 @@ LL |     let _ = core::iter::Empty::<usize>::default();
    = help: to override `-D warnings` add `#[allow(clippy::default_instead_of_iter_empty)]`
 
 error: `core::iter::empty()` is the more idiomatic way
-  --> tests/ui/default_instead_of_iter_empty_no_std.rs:24:42
+  --> tests/ui/default_instead_of_iter_empty_no_std.rs:25:42
    |
 LL |     let _foo: core::iter::Empty<usize> = core::iter::Empty::default();
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `core::iter::empty()`
diff --git a/src/tools/clippy/tests/ui/default_numeric_fallback_f64.fixed b/src/tools/clippy/tests/ui/default_numeric_fallback_f64.fixed
index 00f0d7644340..cf1ccab688c5 100644
--- a/src/tools/clippy/tests/ui/default_numeric_fallback_f64.fixed
+++ b/src/tools/clippy/tests/ui/default_numeric_fallback_f64.fixed
@@ -19,10 +19,20 @@ mod basic_expr {
     fn test() {
         // Should lint unsuffixed literals typed `f64`.
         let x = 0.12_f64;
+        //~^ default_numeric_fallback
         let x = [1.0_f64, 2.0_f64, 3.0_f64];
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = if true { (1.0_f64, 2.0_f64) } else { (3.0_f64, 4.0_f64) };
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = match 1.0_f64 {
+            //~^ default_numeric_fallback
             _ => 1.0_f64,
+            //~^ default_numeric_fallback
         };
 
         // Should NOT lint suffixed literals.
@@ -42,6 +52,7 @@ mod nested_local {
         let x: _ = {
             // Should lint this because this literal is not bound to any types.
             let y = 1.0_f64;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1.
@@ -50,12 +61,14 @@ mod nested_local {
         let x: _ = if true {
             // Should lint this because this literal is not bound to any types.
             let y = 1.0_f64;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1.
         } else {
             // Should lint this because this literal is not bound to any types.
             let y = 1.0_f64;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2.
@@ -64,6 +77,7 @@ mod nested_local {
         const X: f32 = {
             // Should lint this because this literal is not bound to any types.
             let y = 1.0_f64;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1.
@@ -80,10 +94,12 @@ mod function_def {
         // Should lint this because return type is inferred to `f64` and NOT bound to a concrete
         // type.
         let f = || -> _ { 1.0_f64 };
+        //~^ default_numeric_fallback
 
         // Even though the output type is specified,
         // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
         let f = || -> f64 { 1.0_f64 };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -98,9 +114,11 @@ mod function_calls {
 
         // Should lint this because the argument type is inferred to `f64` and NOT bound to a concrete type.
         generic_arg(1.0_f64);
+        //~^ default_numeric_fallback
 
         // Should lint this because the argument type is inferred to `f64` and NOT bound to a concrete type.
         let x: _ = generic_arg(1.0_f64);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -119,9 +137,11 @@ mod struct_ctor {
 
         // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
         GenericStruct { x: 1.0_f64 };
+        //~^ default_numeric_fallback
 
         // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
         let _ = GenericStruct { x: 1.0_f64 };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -140,6 +160,7 @@ mod enum_ctor {
 
         // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
         GenericEnum::X(1.0_f64);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -160,6 +181,7 @@ mod method_calls {
 
         // Should lint this because the argument type is bound to a concrete type.
         s.generic_arg(1.0_f64);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -170,6 +192,7 @@ mod in_macro {
     #[inline_macros]
     fn internal() {
         inline!(let x = 22.0_f64;);
+        //~^ default_numeric_fallback
     }
 
     // Should NOT lint in external macro.
diff --git a/src/tools/clippy/tests/ui/default_numeric_fallback_f64.rs b/src/tools/clippy/tests/ui/default_numeric_fallback_f64.rs
index 942cedac2753..345e65e0b4f9 100644
--- a/src/tools/clippy/tests/ui/default_numeric_fallback_f64.rs
+++ b/src/tools/clippy/tests/ui/default_numeric_fallback_f64.rs
@@ -19,10 +19,20 @@ mod basic_expr {
     fn test() {
         // Should lint unsuffixed literals typed `f64`.
         let x = 0.12;
+        //~^ default_numeric_fallback
         let x = [1., 2., 3.];
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = if true { (1., 2.) } else { (3., 4.) };
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = match 1. {
+            //~^ default_numeric_fallback
             _ => 1.,
+            //~^ default_numeric_fallback
         };
 
         // Should NOT lint suffixed literals.
@@ -42,6 +52,7 @@ mod nested_local {
         let x: _ = {
             // Should lint this because this literal is not bound to any types.
             let y = 1.;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1.
@@ -50,12 +61,14 @@ mod nested_local {
         let x: _ = if true {
             // Should lint this because this literal is not bound to any types.
             let y = 1.;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1.
         } else {
             // Should lint this because this literal is not bound to any types.
             let y = 1.;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2.
@@ -64,6 +77,7 @@ mod nested_local {
         const X: f32 = {
             // Should lint this because this literal is not bound to any types.
             let y = 1.;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1.
@@ -80,10 +94,12 @@ mod function_def {
         // Should lint this because return type is inferred to `f64` and NOT bound to a concrete
         // type.
         let f = || -> _ { 1. };
+        //~^ default_numeric_fallback
 
         // Even though the output type is specified,
         // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
         let f = || -> f64 { 1. };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -98,9 +114,11 @@ mod function_calls {
 
         // Should lint this because the argument type is inferred to `f64` and NOT bound to a concrete type.
         generic_arg(1.);
+        //~^ default_numeric_fallback
 
         // Should lint this because the argument type is inferred to `f64` and NOT bound to a concrete type.
         let x: _ = generic_arg(1.);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -119,9 +137,11 @@ mod struct_ctor {
 
         // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
         GenericStruct { x: 1. };
+        //~^ default_numeric_fallback
 
         // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
         let _ = GenericStruct { x: 1. };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -140,6 +160,7 @@ mod enum_ctor {
 
         // Should lint this because the field type is inferred to `f64` and NOT bound to a concrete type.
         GenericEnum::X(1.);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -160,6 +181,7 @@ mod method_calls {
 
         // Should lint this because the argument type is bound to a concrete type.
         s.generic_arg(1.);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -170,6 +192,7 @@ mod in_macro {
     #[inline_macros]
     fn internal() {
         inline!(let x = 22.;);
+        //~^ default_numeric_fallback
     }
 
     // Should NOT lint in external macro.
diff --git a/src/tools/clippy/tests/ui/default_numeric_fallback_f64.stderr b/src/tools/clippy/tests/ui/default_numeric_fallback_f64.stderr
index d7e4dbd63771..f9451211e1ac 100644
--- a/src/tools/clippy/tests/ui/default_numeric_fallback_f64.stderr
+++ b/src/tools/clippy/tests/ui/default_numeric_fallback_f64.stderr
@@ -8,133 +8,133 @@ LL |         let x = 0.12;
    = help: to override `-D warnings` add `#[allow(clippy::default_numeric_fallback)]`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:22:18
+  --> tests/ui/default_numeric_fallback_f64.rs:23:18
    |
 LL |         let x = [1., 2., 3.];
    |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:22:22
+  --> tests/ui/default_numeric_fallback_f64.rs:23:22
    |
 LL |         let x = [1., 2., 3.];
    |                      ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:22:26
+  --> tests/ui/default_numeric_fallback_f64.rs:23:26
    |
 LL |         let x = [1., 2., 3.];
    |                          ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:23:28
+  --> tests/ui/default_numeric_fallback_f64.rs:27:28
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:23:32
+  --> tests/ui/default_numeric_fallback_f64.rs:27:32
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                ^^ help: consider adding suffix: `2.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:23:46
+  --> tests/ui/default_numeric_fallback_f64.rs:27:46
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                              ^^ help: consider adding suffix: `3.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:23:50
+  --> tests/ui/default_numeric_fallback_f64.rs:27:50
    |
 LL |         let x = if true { (1., 2.) } else { (3., 4.) };
    |                                                  ^^ help: consider adding suffix: `4.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:24:23
+  --> tests/ui/default_numeric_fallback_f64.rs:32:23
    |
 LL |         let x = match 1. {
    |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:25:18
+  --> tests/ui/default_numeric_fallback_f64.rs:34:18
    |
 LL |             _ => 1.,
    |                  ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:44:21
+  --> tests/ui/default_numeric_fallback_f64.rs:54:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:52:21
+  --> tests/ui/default_numeric_fallback_f64.rs:63:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:58:21
+  --> tests/ui/default_numeric_fallback_f64.rs:70:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:66:21
+  --> tests/ui/default_numeric_fallback_f64.rs:79:21
    |
 LL |             let y = 1.;
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:82:27
+  --> tests/ui/default_numeric_fallback_f64.rs:96:27
    |
 LL |         let f = || -> _ { 1. };
    |                           ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:86:29
+  --> tests/ui/default_numeric_fallback_f64.rs:101:29
    |
 LL |         let f = || -> f64 { 1. };
    |                             ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:100:21
+  --> tests/ui/default_numeric_fallback_f64.rs:116:21
    |
 LL |         generic_arg(1.);
    |                     ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:103:32
+  --> tests/ui/default_numeric_fallback_f64.rs:120:32
    |
 LL |         let x: _ = generic_arg(1.);
    |                                ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:121:28
+  --> tests/ui/default_numeric_fallback_f64.rs:139:28
    |
 LL |         GenericStruct { x: 1. };
    |                            ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:124:36
+  --> tests/ui/default_numeric_fallback_f64.rs:143:36
    |
 LL |         let _ = GenericStruct { x: 1. };
    |                                    ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:142:24
+  --> tests/ui/default_numeric_fallback_f64.rs:162:24
    |
 LL |         GenericEnum::X(1.);
    |                        ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:162:23
+  --> tests/ui/default_numeric_fallback_f64.rs:183:23
    |
 LL |         s.generic_arg(1.);
    |                       ^^ help: consider adding suffix: `1.0_f64`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_f64.rs:172:25
+  --> tests/ui/default_numeric_fallback_f64.rs:194:25
    |
 LL |         inline!(let x = 22.;);
    |                         ^^^ help: consider adding suffix: `22.0_f64`
diff --git a/src/tools/clippy/tests/ui/default_numeric_fallback_i32.fixed b/src/tools/clippy/tests/ui/default_numeric_fallback_i32.fixed
index f28ae04fd0a4..496408aa9e87 100644
--- a/src/tools/clippy/tests/ui/default_numeric_fallback_i32.fixed
+++ b/src/tools/clippy/tests/ui/default_numeric_fallback_i32.fixed
@@ -18,11 +18,23 @@ mod basic_expr {
     fn test() {
         // Should lint unsuffixed literals typed `i32`.
         let x = 22_i32;
+        //~^ default_numeric_fallback
         let x = [1_i32, 2_i32, 3_i32];
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = if true { (1_i32, 2_i32) } else { (3_i32, 4_i32) };
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = match 1_i32 {
+            //~^ default_numeric_fallback
             1_i32 => 1_i32,
+            //~^ default_numeric_fallback
+            //~| default_numeric_fallback
             _ => 2_i32,
+            //~^ default_numeric_fallback
         };
 
         // Should NOT lint suffixed literals.
@@ -42,6 +54,7 @@ mod nested_local {
         let x: _ = {
             // Should lint this because this literal is not bound to any types.
             let y = 1_i32;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1
@@ -50,12 +63,14 @@ mod nested_local {
         let x: _ = if true {
             // Should lint this because this literal is not bound to any types.
             let y = 1_i32;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1
         } else {
             // Should lint this because this literal is not bound to any types.
             let y = 1_i32;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2
@@ -64,6 +79,7 @@ mod nested_local {
         const CONST_X: i32 = {
             // Should lint this because this literal is not bound to any types.
             let y = 1_i32;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1
@@ -80,10 +96,12 @@ mod function_def {
         // Should lint this because return type is inferred to `i32` and NOT bound to a concrete
         // type.
         let f = || -> _ { 1_i32 };
+        //~^ default_numeric_fallback
 
         // Even though the output type is specified,
         // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
         let f = || -> i32 { 1_i32 };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -98,9 +116,11 @@ mod function_calls {
 
         // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
         generic_arg(1_i32);
+        //~^ default_numeric_fallback
 
         // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
         let x: _ = generic_arg(1_i32);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -119,9 +139,11 @@ mod struct_ctor {
 
         // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
         GenericStruct { x: 1_i32 };
+        //~^ default_numeric_fallback
 
         // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
         let _ = GenericStruct { x: 1_i32 };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -140,6 +162,7 @@ mod enum_ctor {
 
         // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
         GenericEnum::X(1_i32);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -160,6 +183,7 @@ mod method_calls {
 
         // Should lint this because the argument type is bound to a concrete type.
         s.generic_arg(1_i32);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -170,6 +194,7 @@ mod in_macro {
     #[inline_macros]
     fn internal() {
         inline!(let x = 22_i32;);
+        //~^ default_numeric_fallback
     }
 
     // Should NOT lint in external macro.
@@ -212,6 +237,9 @@ mod type_already_inferred {
         // Should NOT lint in `vec!` call if the type was already stated
         let data_i32: Vec<i32> = vec![1, 2, 3];
         let data_i32 = vec![1_i32, 2_i32, 3_i32];
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/default_numeric_fallback_i32.rs b/src/tools/clippy/tests/ui/default_numeric_fallback_i32.rs
index 78a5006444ee..90fcf4091ddc 100644
--- a/src/tools/clippy/tests/ui/default_numeric_fallback_i32.rs
+++ b/src/tools/clippy/tests/ui/default_numeric_fallback_i32.rs
@@ -18,11 +18,23 @@ mod basic_expr {
     fn test() {
         // Should lint unsuffixed literals typed `i32`.
         let x = 22;
+        //~^ default_numeric_fallback
         let x = [1, 2, 3];
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = if true { (1, 2) } else { (3, 4) };
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
         let x = match 1 {
+            //~^ default_numeric_fallback
             1 => 1,
+            //~^ default_numeric_fallback
+            //~| default_numeric_fallback
             _ => 2,
+            //~^ default_numeric_fallback
         };
 
         // Should NOT lint suffixed literals.
@@ -42,6 +54,7 @@ mod nested_local {
         let x: _ = {
             // Should lint this because this literal is not bound to any types.
             let y = 1;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1
@@ -50,12 +63,14 @@ mod nested_local {
         let x: _ = if true {
             // Should lint this because this literal is not bound to any types.
             let y = 1;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1
         } else {
             // Should lint this because this literal is not bound to any types.
             let y = 1;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             2
@@ -64,6 +79,7 @@ mod nested_local {
         const CONST_X: i32 = {
             // Should lint this because this literal is not bound to any types.
             let y = 1;
+            //~^ default_numeric_fallback
 
             // Should NOT lint this because this literal is bound to `_` of outer `Local`.
             1
@@ -80,10 +96,12 @@ mod function_def {
         // Should lint this because return type is inferred to `i32` and NOT bound to a concrete
         // type.
         let f = || -> _ { 1 };
+        //~^ default_numeric_fallback
 
         // Even though the output type is specified,
         // this unsuffixed literal is linted to reduce heuristics and keep codebase simple.
         let f = || -> i32 { 1 };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -98,9 +116,11 @@ mod function_calls {
 
         // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
         generic_arg(1);
+        //~^ default_numeric_fallback
 
         // Should lint this because the argument type is inferred to `i32` and NOT bound to a concrete type.
         let x: _ = generic_arg(1);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -119,9 +139,11 @@ mod struct_ctor {
 
         // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
         GenericStruct { x: 1 };
+        //~^ default_numeric_fallback
 
         // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
         let _ = GenericStruct { x: 1 };
+        //~^ default_numeric_fallback
     }
 }
 
@@ -140,6 +162,7 @@ mod enum_ctor {
 
         // Should lint this because the field type is inferred to `i32` and NOT bound to a concrete type.
         GenericEnum::X(1);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -160,6 +183,7 @@ mod method_calls {
 
         // Should lint this because the argument type is bound to a concrete type.
         s.generic_arg(1);
+        //~^ default_numeric_fallback
     }
 }
 
@@ -170,6 +194,7 @@ mod in_macro {
     #[inline_macros]
     fn internal() {
         inline!(let x = 22;);
+        //~^ default_numeric_fallback
     }
 
     // Should NOT lint in external macro.
@@ -212,6 +237,9 @@ mod type_already_inferred {
         // Should NOT lint in `vec!` call if the type was already stated
         let data_i32: Vec<i32> = vec![1, 2, 3];
         let data_i32 = vec![1, 2, 3];
+        //~^ default_numeric_fallback
+        //~| default_numeric_fallback
+        //~| default_numeric_fallback
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/default_numeric_fallback_i32.stderr b/src/tools/clippy/tests/ui/default_numeric_fallback_i32.stderr
index 67ab923ecf5f..02afbddcb3be 100644
--- a/src/tools/clippy/tests/ui/default_numeric_fallback_i32.stderr
+++ b/src/tools/clippy/tests/ui/default_numeric_fallback_i32.stderr
@@ -8,145 +8,145 @@ LL |         let x = 22;
    = help: to override `-D warnings` add `#[allow(clippy::default_numeric_fallback)]`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:21:18
+  --> tests/ui/default_numeric_fallback_i32.rs:22:18
    |
 LL |         let x = [1, 2, 3];
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:21:21
+  --> tests/ui/default_numeric_fallback_i32.rs:22:21
    |
 LL |         let x = [1, 2, 3];
    |                     ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:21:24
+  --> tests/ui/default_numeric_fallback_i32.rs:22:24
    |
 LL |         let x = [1, 2, 3];
    |                        ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:22:28
+  --> tests/ui/default_numeric_fallback_i32.rs:26:28
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:22:31
+  --> tests/ui/default_numeric_fallback_i32.rs:26:31
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                               ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:22:44
+  --> tests/ui/default_numeric_fallback_i32.rs:26:44
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                            ^ help: consider adding suffix: `3_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:22:47
+  --> tests/ui/default_numeric_fallback_i32.rs:26:47
    |
 LL |         let x = if true { (1, 2) } else { (3, 4) };
    |                                               ^ help: consider adding suffix: `4_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:23:23
+  --> tests/ui/default_numeric_fallback_i32.rs:31:23
    |
 LL |         let x = match 1 {
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:24:13
+  --> tests/ui/default_numeric_fallback_i32.rs:33:13
    |
 LL |             1 => 1,
    |             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:24:18
+  --> tests/ui/default_numeric_fallback_i32.rs:33:18
    |
 LL |             1 => 1,
    |                  ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:25:18
+  --> tests/ui/default_numeric_fallback_i32.rs:36:18
    |
 LL |             _ => 2,
    |                  ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:44:21
+  --> tests/ui/default_numeric_fallback_i32.rs:56:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:52:21
+  --> tests/ui/default_numeric_fallback_i32.rs:65:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:58:21
+  --> tests/ui/default_numeric_fallback_i32.rs:72:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:66:21
+  --> tests/ui/default_numeric_fallback_i32.rs:81:21
    |
 LL |             let y = 1;
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:82:27
+  --> tests/ui/default_numeric_fallback_i32.rs:98:27
    |
 LL |         let f = || -> _ { 1 };
    |                           ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:86:29
+  --> tests/ui/default_numeric_fallback_i32.rs:103:29
    |
 LL |         let f = || -> i32 { 1 };
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:100:21
+  --> tests/ui/default_numeric_fallback_i32.rs:118:21
    |
 LL |         generic_arg(1);
    |                     ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:103:32
+  --> tests/ui/default_numeric_fallback_i32.rs:122:32
    |
 LL |         let x: _ = generic_arg(1);
    |                                ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:121:28
+  --> tests/ui/default_numeric_fallback_i32.rs:141:28
    |
 LL |         GenericStruct { x: 1 };
    |                            ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:124:36
+  --> tests/ui/default_numeric_fallback_i32.rs:145:36
    |
 LL |         let _ = GenericStruct { x: 1 };
    |                                    ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:142:24
+  --> tests/ui/default_numeric_fallback_i32.rs:164:24
    |
 LL |         GenericEnum::X(1);
    |                        ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:162:23
+  --> tests/ui/default_numeric_fallback_i32.rs:185:23
    |
 LL |         s.generic_arg(1);
    |                       ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:172:25
+  --> tests/ui/default_numeric_fallback_i32.rs:196:25
    |
 LL |         inline!(let x = 22;);
    |                         ^^ help: consider adding suffix: `22_i32`
@@ -154,19 +154,19 @@ LL |         inline!(let x = 22;);
    = note: this error originates in the macro `__inline_mac_fn_internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:214:29
+  --> tests/ui/default_numeric_fallback_i32.rs:239:29
    |
 LL |         let data_i32 = vec![1, 2, 3];
    |                             ^ help: consider adding suffix: `1_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:214:32
+  --> tests/ui/default_numeric_fallback_i32.rs:239:32
    |
 LL |         let data_i32 = vec![1, 2, 3];
    |                                ^ help: consider adding suffix: `2_i32`
 
 error: default numeric fallback might occur
-  --> tests/ui/default_numeric_fallback_i32.rs:214:35
+  --> tests/ui/default_numeric_fallback_i32.rs:239:35
    |
 LL |         let data_i32 = vec![1, 2, 3];
    |                                   ^ help: consider adding suffix: `3_i32`
diff --git a/src/tools/clippy/tests/ui/default_trait_access.fixed b/src/tools/clippy/tests/ui/default_trait_access.fixed
index 6f1e72c5a6c0..d3fe09a052ef 100644
--- a/src/tools/clippy/tests/ui/default_trait_access.fixed
+++ b/src/tools/clippy/tests/ui/default_trait_access.fixed
@@ -11,16 +11,20 @@ use std::{default, string};
 
 fn main() {
     let s1: String = String::default();
+    //~^ default_trait_access
 
     let s2 = String::default();
 
     let s3: String = String::default();
+    //~^ default_trait_access
 
     let s4: String = String::default();
+    //~^ default_trait_access
 
     let s5 = string::String::default();
 
     let s6: String = String::default();
+    //~^ default_trait_access
 
     let s7 = std::string::String::default();
 
@@ -31,18 +35,22 @@ fn main() {
     let s10 = DerivedDefault::default();
 
     let s11: GenericDerivedDefault<String> = GenericDerivedDefault::default();
+    //~^ default_trait_access
 
     let s12 = GenericDerivedDefault::<String>::default();
 
     let s13 = TupleDerivedDefault::default();
 
     let s14: TupleDerivedDefault = TupleDerivedDefault::default();
+    //~^ default_trait_access
 
     let s15: ArrayDerivedDefault = ArrayDerivedDefault::default();
+    //~^ default_trait_access
 
     let s16 = ArrayDerivedDefault::default();
 
     let s17: TupleStructDerivedDefault = TupleStructDerivedDefault::default();
+    //~^ default_trait_access
 
     let s18 = TupleStructDerivedDefault::default();
 
diff --git a/src/tools/clippy/tests/ui/default_trait_access.rs b/src/tools/clippy/tests/ui/default_trait_access.rs
index 5528ca8b7936..cdffb2a2ee8c 100644
--- a/src/tools/clippy/tests/ui/default_trait_access.rs
+++ b/src/tools/clippy/tests/ui/default_trait_access.rs
@@ -11,16 +11,20 @@ use std::{default, string};
 
 fn main() {
     let s1: String = Default::default();
+    //~^ default_trait_access
 
     let s2 = String::default();
 
     let s3: String = D2::default();
+    //~^ default_trait_access
 
     let s4: String = std::default::Default::default();
+    //~^ default_trait_access
 
     let s5 = string::String::default();
 
     let s6: String = default::Default::default();
+    //~^ default_trait_access
 
     let s7 = std::string::String::default();
 
@@ -31,18 +35,22 @@ fn main() {
     let s10 = DerivedDefault::default();
 
     let s11: GenericDerivedDefault<String> = Default::default();
+    //~^ default_trait_access
 
     let s12 = GenericDerivedDefault::<String>::default();
 
     let s13 = TupleDerivedDefault::default();
 
     let s14: TupleDerivedDefault = Default::default();
+    //~^ default_trait_access
 
     let s15: ArrayDerivedDefault = Default::default();
+    //~^ default_trait_access
 
     let s16 = ArrayDerivedDefault::default();
 
     let s17: TupleStructDerivedDefault = Default::default();
+    //~^ default_trait_access
 
     let s18 = TupleStructDerivedDefault::default();
 
diff --git a/src/tools/clippy/tests/ui/default_trait_access.stderr b/src/tools/clippy/tests/ui/default_trait_access.stderr
index 276f03d79df1..aa7eb4f89558 100644
--- a/src/tools/clippy/tests/ui/default_trait_access.stderr
+++ b/src/tools/clippy/tests/ui/default_trait_access.stderr
@@ -11,43 +11,43 @@ LL | #![deny(clippy::default_trait_access)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `String::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:17:22
+  --> tests/ui/default_trait_access.rs:18:22
    |
 LL |     let s3: String = D2::default();
    |                      ^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `String::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:19:22
+  --> tests/ui/default_trait_access.rs:21:22
    |
 LL |     let s4: String = std::default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `String::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:23:22
+  --> tests/ui/default_trait_access.rs:26:22
    |
 LL |     let s6: String = default::Default::default();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `String::default()`
 
 error: calling `GenericDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:33:46
+  --> tests/ui/default_trait_access.rs:37:46
    |
 LL |     let s11: GenericDerivedDefault<String> = Default::default();
    |                                              ^^^^^^^^^^^^^^^^^^ help: try: `GenericDerivedDefault::default()`
 
 error: calling `TupleDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:39:36
+  --> tests/ui/default_trait_access.rs:44:36
    |
 LL |     let s14: TupleDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `TupleDerivedDefault::default()`
 
 error: calling `ArrayDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:41:36
+  --> tests/ui/default_trait_access.rs:47:36
    |
 LL |     let s15: ArrayDerivedDefault = Default::default();
    |                                    ^^^^^^^^^^^^^^^^^^ help: try: `ArrayDerivedDefault::default()`
 
 error: calling `TupleStructDerivedDefault::default()` is more clear than this expression
-  --> tests/ui/default_trait_access.rs:45:42
+  --> tests/ui/default_trait_access.rs:52:42
    |
 LL |     let s17: TupleStructDerivedDefault = Default::default();
    |                                          ^^^^^^^^^^^^^^^^^^ help: try: `TupleStructDerivedDefault::default()`
diff --git a/src/tools/clippy/tests/ui/default_union_representation.rs b/src/tools/clippy/tests/ui/default_union_representation.rs
index ba63cde2fa9d..92c429c79a07 100644
--- a/src/tools/clippy/tests/ui/default_union_representation.rs
+++ b/src/tools/clippy/tests/ui/default_union_representation.rs
@@ -3,7 +3,7 @@
 #![allow(clippy::repr_packed_without_abi)]
 
 union NoAttribute {
-    //~^ ERROR: this union has the default representation
+    //~^ default_union_representation
     a: i32,
     b: u32,
 }
@@ -16,7 +16,7 @@ union ReprC {
 
 #[repr(packed)]
 union ReprPacked {
-    //~^ ERROR: this union has the default representation
+    //~^ default_union_representation
     a: i32,
     b: u32,
 }
@@ -35,7 +35,7 @@ union ReprCAlign {
 
 #[repr(align(32))]
 union ReprAlign {
-    //~^ ERROR: this union has the default representation
+    //~^ default_union_representation
     a: i32,
     b: u32,
 }
@@ -56,7 +56,7 @@ union ZSTsAndField2 {
     f3: (),
 }
 union ZSTAndTwoFields {
-    //~^ ERROR: this union has the default representation
+    //~^ default_union_representation
     f0: u32,
     f1: u64,
     f2: (),
diff --git a/src/tools/clippy/tests/ui/deprecated.rs b/src/tools/clippy/tests/ui/deprecated.rs
index 5617db90a470..35646e1c2391 100644
--- a/src/tools/clippy/tests/ui/deprecated.rs
+++ b/src/tools/clippy/tests/ui/deprecated.rs
@@ -15,5 +15,6 @@
 #![warn(clippy::regex_macro)] //~ ERROR: lint `clippy::regex_macro`
 #![warn(clippy::pub_enum_variant_names)] //~ ERROR: lint `clippy::pub_enum_variant_names`
 #![warn(clippy::wrong_pub_self_convention)] //~ ERROR: lint `clippy::wrong_pub_self_convention`
+#![warn(clippy::option_map_or_err_ok)] //~ ERROR: lint `clippy::option_map_or_err_ok`
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/deprecated.stderr b/src/tools/clippy/tests/ui/deprecated.stderr
index b3e1646c8045..d7be1e583b08 100644
--- a/src/tools/clippy/tests/ui/deprecated.stderr
+++ b/src/tools/clippy/tests/ui/deprecated.stderr
@@ -79,5 +79,11 @@ error: lint `clippy::wrong_pub_self_convention` has been removed: `clippy::wrong
 LL | #![warn(clippy::wrong_pub_self_convention)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 13 previous errors
+error: lint `clippy::option_map_or_err_ok` has been removed: `clippy::manual_ok_or` covers this case
+  --> tests/ui/deprecated.rs:18:9
+   |
+LL | #![warn(clippy::option_map_or_err_ok)]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: aborting due to 14 previous errors
 
diff --git a/src/tools/clippy/tests/ui/deref_addrof.fixed b/src/tools/clippy/tests/ui/deref_addrof.fixed
index f412c57d6505..35dbd790e890 100644
--- a/src/tools/clippy/tests/ui/deref_addrof.fixed
+++ b/src/tools/clippy/tests/ui/deref_addrof.fixed
@@ -21,30 +21,39 @@ fn main() {
     let aref = &a;
 
     let b = a;
+    //~^ deref_addrof
 
     let b = get_number();
+    //~^ deref_addrof
 
     let b = *get_reference(&a);
 
     let bytes: Vec<usize> = vec![1, 2, 3, 4];
     let b = bytes[1..2][0];
+    //~^ deref_addrof
 
     //This produces a suggestion of 'let b = (a);' which
     //will trigger the 'unused_parens' lint
     let b = (a);
+    //~^ deref_addrof
 
     let b = a;
+    //~^ deref_addrof
 
     #[rustfmt::skip]
     let b = a;
+    //~^ deref_addrof
 
     let b = &a;
+    //~^ deref_addrof
 
     let b = *aref;
+    //~^ deref_addrof
 
     let _ = unsafe { *core::ptr::addr_of!(a) };
 
     let _repeat = [0; 64];
+    //~^ deref_addrof
     // do NOT lint for array as semantic differences with/out `*&`.
     let _arr = *&[0, 1, 2, 3, 4];
 }
@@ -55,9 +64,11 @@ pub struct S;
 impl S {
     pub fn f(&self) -> &Self {
         inline!($(@expr self))
+        //~^ deref_addrof
     }
     #[allow(unused_mut)] // mut will be unused, once the macro is fixed
     pub fn f_mut(mut self) -> Self {
         inline!($(@expr self))
+        //~^ deref_addrof
     }
 }
diff --git a/src/tools/clippy/tests/ui/deref_addrof.rs b/src/tools/clippy/tests/ui/deref_addrof.rs
index 67836b0de52d..96d1b92ef7be 100644
--- a/src/tools/clippy/tests/ui/deref_addrof.rs
+++ b/src/tools/clippy/tests/ui/deref_addrof.rs
@@ -21,30 +21,39 @@ fn main() {
     let aref = &a;
 
     let b = *&a;
+    //~^ deref_addrof
 
     let b = *&get_number();
+    //~^ deref_addrof
 
     let b = *get_reference(&a);
 
     let bytes: Vec<usize> = vec![1, 2, 3, 4];
     let b = *&bytes[1..2][0];
+    //~^ deref_addrof
 
     //This produces a suggestion of 'let b = (a);' which
     //will trigger the 'unused_parens' lint
     let b = *&(a);
+    //~^ deref_addrof
 
     let b = *(&a);
+    //~^ deref_addrof
 
     #[rustfmt::skip]
     let b = *((&a));
+    //~^ deref_addrof
 
     let b = *&&a;
+    //~^ deref_addrof
 
     let b = **&aref;
+    //~^ deref_addrof
 
     let _ = unsafe { *core::ptr::addr_of!(a) };
 
     let _repeat = *&[0; 64];
+    //~^ deref_addrof
     // do NOT lint for array as semantic differences with/out `*&`.
     let _arr = *&[0, 1, 2, 3, 4];
 }
@@ -55,9 +64,11 @@ pub struct S;
 impl S {
     pub fn f(&self) -> &Self {
         inline!(*& $(@expr self))
+        //~^ deref_addrof
     }
     #[allow(unused_mut)] // mut will be unused, once the macro is fixed
     pub fn f_mut(mut self) -> Self {
         inline!(*&mut $(@expr self))
+        //~^ deref_addrof
     }
 }
diff --git a/src/tools/clippy/tests/ui/deref_addrof.stderr b/src/tools/clippy/tests/ui/deref_addrof.stderr
index 20069f746c81..81414b625b2f 100644
--- a/src/tools/clippy/tests/ui/deref_addrof.stderr
+++ b/src/tools/clippy/tests/ui/deref_addrof.stderr
@@ -8,55 +8,55 @@ LL |     let b = *&a;
    = help: to override `-D warnings` add `#[allow(clippy::deref_addrof)]`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:25:13
+  --> tests/ui/deref_addrof.rs:26:13
    |
 LL |     let b = *&get_number();
    |             ^^^^^^^^^^^^^^ help: try: `get_number()`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:30:13
+  --> tests/ui/deref_addrof.rs:32:13
    |
 LL |     let b = *&bytes[1..2][0];
    |             ^^^^^^^^^^^^^^^^ help: try: `bytes[1..2][0]`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:34:13
+  --> tests/ui/deref_addrof.rs:37:13
    |
 LL |     let b = *&(a);
    |             ^^^^^ help: try: `(a)`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:36:13
+  --> tests/ui/deref_addrof.rs:40:13
    |
 LL |     let b = *(&a);
    |             ^^^^^ help: try: `a`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:39:13
+  --> tests/ui/deref_addrof.rs:44:13
    |
 LL |     let b = *((&a));
    |             ^^^^^^^ help: try: `a`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:41:13
+  --> tests/ui/deref_addrof.rs:47:13
    |
 LL |     let b = *&&a;
    |             ^^^^ help: try: `&a`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:43:14
+  --> tests/ui/deref_addrof.rs:50:14
    |
 LL |     let b = **&aref;
    |              ^^^^^^ help: try: `aref`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:47:19
+  --> tests/ui/deref_addrof.rs:55:19
    |
 LL |     let _repeat = *&[0; 64];
    |                   ^^^^^^^^^ help: try: `[0; 64]`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:57:17
+  --> tests/ui/deref_addrof.rs:66:17
    |
 LL |         inline!(*& $(@expr self))
    |                 ^^^^^^^^^^^^^^^^ help: try: `$(@expr self)`
@@ -64,7 +64,7 @@ LL |         inline!(*& $(@expr self))
    = note: this error originates in the macro `__inline_mac_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof.rs:61:17
+  --> tests/ui/deref_addrof.rs:71:17
    |
 LL |         inline!(*&mut $(@expr self))
    |                 ^^^^^^^^^^^^^^^^^^^ help: try: `$(@expr self)`
diff --git a/src/tools/clippy/tests/ui/deref_addrof_double_trigger.rs b/src/tools/clippy/tests/ui/deref_addrof_double_trigger.rs
index 6f997875777e..b08b2aba2319 100644
--- a/src/tools/clippy/tests/ui/deref_addrof_double_trigger.rs
+++ b/src/tools/clippy/tests/ui/deref_addrof_double_trigger.rs
@@ -8,13 +8,12 @@ fn main() {
     //This produces a suggestion of 'let b = *&a;' which
     //will trigger the 'clippy::deref_addrof' lint again
     let b = **&&a;
-    //~^ ERROR: immediately dereferencing a reference
-    //~| NOTE: `-D clippy::deref-addrof` implied by `-D warnings`
+    //~^ deref_addrof
 
     {
         let mut x = 10;
         let y = *&mut x;
-        //~^ ERROR: immediately dereferencing a reference
+        //~^ deref_addrof
     }
 
     {
@@ -22,6 +21,6 @@ fn main() {
         //will trigger the 'clippy::deref_addrof' lint again
         let mut x = 10;
         let y = **&mut &mut x;
-        //~^ ERROR: immediately dereferencing a reference
+        //~^ deref_addrof
     }
 }
diff --git a/src/tools/clippy/tests/ui/deref_addrof_double_trigger.stderr b/src/tools/clippy/tests/ui/deref_addrof_double_trigger.stderr
index 8905b1424674..9ac60dd6d544 100644
--- a/src/tools/clippy/tests/ui/deref_addrof_double_trigger.stderr
+++ b/src/tools/clippy/tests/ui/deref_addrof_double_trigger.stderr
@@ -8,13 +8,13 @@ LL |     let b = **&&a;
    = help: to override `-D warnings` add `#[allow(clippy::deref_addrof)]`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof_double_trigger.rs:16:17
+  --> tests/ui/deref_addrof_double_trigger.rs:15:17
    |
 LL |         let y = *&mut x;
    |                 ^^^^^^^ help: try: `x`
 
 error: immediately dereferencing a reference
-  --> tests/ui/deref_addrof_double_trigger.rs:24:18
+  --> tests/ui/deref_addrof_double_trigger.rs:23:18
    |
 LL |         let y = **&mut &mut x;
    |                  ^^^^^^^^^^^^ help: try: `&mut x`
diff --git a/src/tools/clippy/tests/ui/deref_addrof_macro.rs b/src/tools/clippy/tests/ui/deref_addrof_macro.rs
index c7e60f365060..452ccd173a16 100644
--- a/src/tools/clippy/tests/ui/deref_addrof_macro.rs
+++ b/src/tools/clippy/tests/ui/deref_addrof_macro.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build:proc_macros.rs
 
 #![warn(clippy::deref_addrof)]
diff --git a/src/tools/clippy/tests/ui/deref_by_slicing.fixed b/src/tools/clippy/tests/ui/deref_by_slicing.fixed
index 87b33b1f881d..ba03904040b4 100644
--- a/src/tools/clippy/tests/ui/deref_by_slicing.fixed
+++ b/src/tools/clippy/tests/ui/deref_by_slicing.fixed
@@ -6,27 +6,41 @@ use std::io::Read;
 fn main() {
     let mut vec = vec![0];
     let _ = &*vec;
+    //~^ deref_by_slicing
     let _ = &mut *vec;
+    //~^ deref_by_slicing
 
     let ref_vec = &mut vec;
     let _ = &**ref_vec;
+    //~^ deref_by_slicing
     let mut_slice = &mut **ref_vec;
+    //~^ deref_by_slicing
     let _ = &mut *mut_slice; // Err, re-borrows slice
+    //
+    //~^^ deref_by_slicing
 
     let s = String::new();
     let _ = &*s;
+    //~^ deref_by_slicing
 
     static S: &[u8] = &[0, 1, 2];
     let _ = &mut &*S; // Err, re-borrows slice
+    //
+    //~^^ deref_by_slicing
 
     let slice: &[u32] = &[0u32, 1u32];
     let slice_ref = &slice;
     let _ = *slice_ref; // Err, derefs slice
+    //
+    //~^^ deref_by_slicing
 
     let bytes: &[u8] = &[];
     let _ = (&*bytes).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
+    //
+    //~^^ deref_by_slicing
 
     // issue 12751
     let a = &mut [1, 2, 3][..];
     let _ = &*a;
+    //~^ deref_by_slicing
 }
diff --git a/src/tools/clippy/tests/ui/deref_by_slicing.rs b/src/tools/clippy/tests/ui/deref_by_slicing.rs
index 8d8882a1781e..fdaac9467f86 100644
--- a/src/tools/clippy/tests/ui/deref_by_slicing.rs
+++ b/src/tools/clippy/tests/ui/deref_by_slicing.rs
@@ -6,27 +6,41 @@ use std::io::Read;
 fn main() {
     let mut vec = vec![0];
     let _ = &vec[..];
+    //~^ deref_by_slicing
     let _ = &mut vec[..];
+    //~^ deref_by_slicing
 
     let ref_vec = &mut vec;
     let _ = &ref_vec[..];
+    //~^ deref_by_slicing
     let mut_slice = &mut ref_vec[..];
+    //~^ deref_by_slicing
     let _ = &mut mut_slice[..]; // Err, re-borrows slice
+    //
+    //~^^ deref_by_slicing
 
     let s = String::new();
     let _ = &s[..];
+    //~^ deref_by_slicing
 
     static S: &[u8] = &[0, 1, 2];
     let _ = &mut &S[..]; // Err, re-borrows slice
+    //
+    //~^^ deref_by_slicing
 
     let slice: &[u32] = &[0u32, 1u32];
     let slice_ref = &slice;
     let _ = &slice_ref[..]; // Err, derefs slice
+    //
+    //~^^ deref_by_slicing
 
     let bytes: &[u8] = &[];
     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
+    //
+    //~^^ deref_by_slicing
 
     // issue 12751
     let a = &mut [1, 2, 3][..];
     let _ = &a[..];
+    //~^ deref_by_slicing
 }
diff --git a/src/tools/clippy/tests/ui/deref_by_slicing.stderr b/src/tools/clippy/tests/ui/deref_by_slicing.stderr
index ceb9ab6db73d..4a379a83dfa7 100644
--- a/src/tools/clippy/tests/ui/deref_by_slicing.stderr
+++ b/src/tools/clippy/tests/ui/deref_by_slicing.stderr
@@ -8,55 +8,55 @@ LL |     let _ = &vec[..];
    = help: to override `-D warnings` add `#[allow(clippy::deref_by_slicing)]`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:9:13
+  --> tests/ui/deref_by_slicing.rs:10:13
    |
 LL |     let _ = &mut vec[..];
    |             ^^^^^^^^^^^^ help: dereference the original value instead: `&mut *vec`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:12:13
+  --> tests/ui/deref_by_slicing.rs:14:13
    |
 LL |     let _ = &ref_vec[..];
    |             ^^^^^^^^^^^^ help: dereference the original value instead: `&**ref_vec`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:13:21
+  --> tests/ui/deref_by_slicing.rs:16:21
    |
 LL |     let mut_slice = &mut ref_vec[..];
    |                     ^^^^^^^^^^^^^^^^ help: dereference the original value instead: `&mut **ref_vec`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:14:13
+  --> tests/ui/deref_by_slicing.rs:18:13
    |
 LL |     let _ = &mut mut_slice[..]; // Err, re-borrows slice
    |             ^^^^^^^^^^^^^^^^^^ help: reborrow the original value instead: `&mut *mut_slice`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:17:13
+  --> tests/ui/deref_by_slicing.rs:23:13
    |
 LL |     let _ = &s[..];
    |             ^^^^^^ help: dereference the original value instead: `&*s`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:20:18
+  --> tests/ui/deref_by_slicing.rs:27:18
    |
 LL |     let _ = &mut &S[..]; // Err, re-borrows slice
    |                  ^^^^^^ help: reborrow the original value instead: `&*S`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:24:13
+  --> tests/ui/deref_by_slicing.rs:33:13
    |
 LL |     let _ = &slice_ref[..]; // Err, derefs slice
    |             ^^^^^^^^^^^^^^ help: dereference the original value instead: `*slice_ref`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:27:13
+  --> tests/ui/deref_by_slicing.rs:38:13
    |
 LL |     let _ = (&bytes[..]).read_to_end(&mut vec![]).unwrap(); // Err, re-borrows slice
    |             ^^^^^^^^^^^^ help: reborrow the original value instead: `(&*bytes)`
 
 error: slicing when dereferencing would work
-  --> tests/ui/deref_by_slicing.rs:31:13
+  --> tests/ui/deref_by_slicing.rs:44:13
    |
 LL |     let _ = &a[..];
    |             ^^^^^^ help: reborrow the original value instead: `&*a`
diff --git a/src/tools/clippy/tests/ui/derivable_impls.fixed b/src/tools/clippy/tests/ui/derivable_impls.fixed
index c85f384fd6eb..65bfded38835 100644
--- a/src/tools/clippy/tests/ui/derivable_impls.fixed
+++ b/src/tools/clippy/tests/ui/derivable_impls.fixed
@@ -144,6 +144,40 @@ impl Default for SpecializedImpl2<String> {
     }
 }
 
+#[derive(Default)]
+pub struct DirectDefaultDefaultCall {
+    v: Vec<i32>,
+}
+
+
+#[derive(Default)]
+pub struct EquivalentToDefaultDefaultCallVec {
+    v: Vec<i32>,
+}
+
+
+pub struct S {
+    x: i32,
+}
+
+impl S {
+    fn new() -> S {
+        S { x: 42 }
+    }
+}
+
+impl Default for S {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+#[derive(Default)]
+pub struct EquivalentToDefaultDefaultCallLocal {
+    v: S,
+}
+
+
 // https://github.com/rust-lang/rust-clippy/issues/7654
 
 pub struct Color {
diff --git a/src/tools/clippy/tests/ui/derivable_impls.rs b/src/tools/clippy/tests/ui/derivable_impls.rs
index 21d73ba8b777..4826c5497b4a 100644
--- a/src/tools/clippy/tests/ui/derivable_impls.rs
+++ b/src/tools/clippy/tests/ui/derivable_impls.rs
@@ -18,6 +18,7 @@ struct FooDefault<'a> {
 }
 
 impl std::default::Default for FooDefault<'_> {
+    //~^ derivable_impls
     fn default() -> Self {
         Self {
             a: false,
@@ -39,6 +40,7 @@ impl std::default::Default for FooDefault<'_> {
 struct TupleDefault(bool, i32, u64);
 
 impl std::default::Default for TupleDefault {
+    //~^ derivable_impls
     fn default() -> Self {
         Self(false, 0, 0u64)
     }
@@ -91,6 +93,7 @@ impl Default for FooNDVec {
 struct StrDefault<'a>(&'a str);
 
 impl Default for StrDefault<'_> {
+    //~^ derivable_impls
     fn default() -> Self {
         Self("")
     }
@@ -117,6 +120,7 @@ mac!(0);
 
 struct Y(u32);
 impl Default for Y {
+    //~^ derivable_impls
     fn default() -> Self {
         Self(mac!())
     }
@@ -156,6 +160,7 @@ struct WithoutSelfCurly {
 }
 
 impl Default for WithoutSelfCurly {
+    //~^ derivable_impls
     fn default() -> Self {
         WithoutSelfCurly { a: false }
     }
@@ -164,6 +169,7 @@ impl Default for WithoutSelfCurly {
 struct WithoutSelfParan(bool);
 
 impl Default for WithoutSelfParan {
+    //~^ derivable_impls
     fn default() -> Self {
         WithoutSelfParan(false)
     }
@@ -181,6 +187,58 @@ impl Default for SpecializedImpl2<String> {
     }
 }
 
+pub struct DirectDefaultDefaultCall {
+    v: Vec<i32>,
+}
+
+impl Default for DirectDefaultDefaultCall {
+    //~^ derivable_impls
+    fn default() -> Self {
+        // When calling `Default::default()` in all fields, we know it is the same as deriving.
+        Self { v: Default::default() }
+    }
+}
+
+pub struct EquivalentToDefaultDefaultCallVec {
+    v: Vec<i32>,
+}
+
+impl Default for EquivalentToDefaultDefaultCallVec {
+    //~^ derivable_impls
+    fn default() -> Self {
+        // The body of `<Vec as Default>::default()` is `Vec::new()`, so they are equivalent.
+        Self { v: Vec::new() }
+    }
+}
+
+pub struct S {
+    x: i32,
+}
+
+impl S {
+    fn new() -> S {
+        S { x: 42 }
+    }
+}
+
+impl Default for S {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
+pub struct EquivalentToDefaultDefaultCallLocal {
+    v: S,
+}
+
+impl Default for EquivalentToDefaultDefaultCallLocal {
+    //~^ derivable_impls
+    fn default() -> Self {
+        // The body of `<S as Default>::default()` is `S::new()`, so they are equivalent.
+        Self { v: S::new() }
+    }
+}
+
 // https://github.com/rust-lang/rust-clippy/issues/7654
 
 pub struct Color {
@@ -214,6 +272,7 @@ pub struct RepeatDefault1 {
 }
 
 impl Default for RepeatDefault1 {
+    //~^ derivable_impls
     fn default() -> Self {
         RepeatDefault1 { a: [0; 32] }
     }
@@ -248,6 +307,7 @@ pub enum SimpleEnum {
 }
 
 impl Default for SimpleEnum {
+    //~^ derivable_impls
     fn default() -> Self {
         SimpleEnum::Bar
     }
diff --git a/src/tools/clippy/tests/ui/derivable_impls.stderr b/src/tools/clippy/tests/ui/derivable_impls.stderr
index 0caea892358a..0f73ad55a85e 100644
--- a/src/tools/clippy/tests/ui/derivable_impls.stderr
+++ b/src/tools/clippy/tests/ui/derivable_impls.stderr
@@ -2,9 +2,9 @@ error: this `impl` can be derived
   --> tests/ui/derivable_impls.rs:20:1
    |
 LL | / impl std::default::Default for FooDefault<'_> {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         Self {
-LL | |             a: false,
 ...  |
 LL | | }
    | |_^
@@ -18,9 +18,10 @@ LL ~ struct FooDefault<'a> {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:41:1
+  --> tests/ui/derivable_impls.rs:42:1
    |
 LL | / impl std::default::Default for TupleDefault {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         Self(false, 0, 0u64)
 LL | |     }
@@ -34,9 +35,10 @@ LL ~ struct TupleDefault(bool, i32, u64);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:93:1
+  --> tests/ui/derivable_impls.rs:95:1
    |
 LL | / impl Default for StrDefault<'_> {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         Self("")
 LL | |     }
@@ -50,9 +52,10 @@ LL ~ struct StrDefault<'a>(&'a str);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:119:1
+  --> tests/ui/derivable_impls.rs:122:1
    |
 LL | / impl Default for Y {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         Self(mac!())
 LL | |     }
@@ -66,9 +69,10 @@ LL ~ struct Y(u32);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:158:1
+  --> tests/ui/derivable_impls.rs:162:1
    |
 LL | / impl Default for WithoutSelfCurly {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         WithoutSelfCurly { a: false }
 LL | |     }
@@ -82,9 +86,10 @@ LL ~ struct WithoutSelfCurly {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:166:1
+  --> tests/ui/derivable_impls.rs:171:1
    |
 LL | / impl Default for WithoutSelfParan {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         WithoutSelfParan(false)
 LL | |     }
@@ -98,9 +103,58 @@ LL ~ struct WithoutSelfParan(bool);
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:216:1
+  --> tests/ui/derivable_impls.rs:194:1
+   |
+LL | / impl Default for DirectDefaultDefaultCall {
+LL | |
+LL | |     fn default() -> Self {
+...  |
+LL | | }
+   | |_^
+   |
+help: replace the manual implementation with a derive attribute
+   |
+LL + #[derive(Default)]
+LL ~ pub struct DirectDefaultDefaultCall {
+   |
+
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls.rs:206:1
+   |
+LL | / impl Default for EquivalentToDefaultDefaultCallVec {
+LL | |
+LL | |     fn default() -> Self {
+...  |
+LL | | }
+   | |_^
+   |
+help: replace the manual implementation with a derive attribute
+   |
+LL + #[derive(Default)]
+LL ~ pub struct EquivalentToDefaultDefaultCallVec {
+   |
+
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls.rs:234:1
+   |
+LL | / impl Default for EquivalentToDefaultDefaultCallLocal {
+LL | |
+LL | |     fn default() -> Self {
+...  |
+LL | | }
+   | |_^
+   |
+help: replace the manual implementation with a derive attribute
+   |
+LL + #[derive(Default)]
+LL ~ pub struct EquivalentToDefaultDefaultCallLocal {
+   |
+
+error: this `impl` can be derived
+  --> tests/ui/derivable_impls.rs:274:1
    |
 LL | / impl Default for RepeatDefault1 {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         RepeatDefault1 { a: [0; 32] }
 LL | |     }
@@ -114,9 +168,10 @@ LL ~ pub struct RepeatDefault1 {
    |
 
 error: this `impl` can be derived
-  --> tests/ui/derivable_impls.rs:250:1
+  --> tests/ui/derivable_impls.rs:309:1
    |
 LL | / impl Default for SimpleEnum {
+LL | |
 LL | |     fn default() -> Self {
 LL | |         SimpleEnum::Bar
 LL | |     }
@@ -132,5 +187,5 @@ LL ~     #[default]
 LL ~     Bar,
    |
 
-error: aborting due to 8 previous errors
+error: aborting due to 11 previous errors
 
diff --git a/src/tools/clippy/tests/ui/derive.rs b/src/tools/clippy/tests/ui/derive.rs
index d03cc01a08b0..707a9ff05857 100644
--- a/src/tools/clippy/tests/ui/derive.rs
+++ b/src/tools/clippy/tests/ui/derive.rs
@@ -12,7 +12,8 @@
 struct Qux;
 
 impl Clone for Qux {
-    //~^ ERROR: you are implementing `Clone` explicitly on a `Copy` type
+    //~^ expl_impl_clone_on_copy
+
     fn clone(&self) -> Self {
         Qux
     }
@@ -37,7 +38,8 @@ struct Lt<'a> {
 }
 
 impl<'a> Clone for Lt<'a> {
-    //~^ ERROR: you are implementing `Clone` explicitly on a `Copy` type
+    //~^ expl_impl_clone_on_copy
+
     fn clone(&self) -> Self {
         unimplemented!()
     }
@@ -49,7 +51,8 @@ struct BigArray {
 }
 
 impl Clone for BigArray {
-    //~^ ERROR: you are implementing `Clone` explicitly on a `Copy` type
+    //~^ expl_impl_clone_on_copy
+
     fn clone(&self) -> Self {
         unimplemented!()
     }
@@ -61,7 +64,8 @@ struct FnPtr {
 }
 
 impl Clone for FnPtr {
-    //~^ ERROR: you are implementing `Clone` explicitly on a `Copy` type
+    //~^ expl_impl_clone_on_copy
+
     fn clone(&self) -> Self {
         unimplemented!()
     }
@@ -82,7 +86,8 @@ impl<T> Clone for Generic<T> {
 #[derive(Copy)]
 struct Generic2<T>(T);
 impl<T: Clone> Clone for Generic2<T> {
-    //~^ ERROR: you are implementing `Clone` explicitly on a `Copy` type
+    //~^ expl_impl_clone_on_copy
+
     fn clone(&self) -> Self {
         Self(self.0.clone())
     }
diff --git a/src/tools/clippy/tests/ui/derive.stderr b/src/tools/clippy/tests/ui/derive.stderr
index d70a59855229..20278d4f4e4a 100644
--- a/src/tools/clippy/tests/ui/derive.stderr
+++ b/src/tools/clippy/tests/ui/derive.stderr
@@ -3,9 +3,9 @@ error: you are implementing `Clone` explicitly on a `Copy` type
    |
 LL | / impl Clone for Qux {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         Qux
-LL | |     }
+...  |
 LL | | }
    | |_^
    |
@@ -14,99 +14,99 @@ note: consider deriving `Clone` or removing `Copy`
    |
 LL | / impl Clone for Qux {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         Qux
-LL | |     }
+...  |
 LL | | }
    | |_^
    = note: `-D clippy::expl-impl-clone-on-copy` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::expl_impl_clone_on_copy)]`
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> tests/ui/derive.rs:39:1
+  --> tests/ui/derive.rs:40:1
    |
 LL | / impl<'a> Clone for Lt<'a> {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
+...  |
 LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> tests/ui/derive.rs:39:1
+  --> tests/ui/derive.rs:40:1
    |
 LL | / impl<'a> Clone for Lt<'a> {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
+...  |
 LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> tests/ui/derive.rs:51:1
+  --> tests/ui/derive.rs:53:1
    |
 LL | / impl Clone for BigArray {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
+...  |
 LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> tests/ui/derive.rs:51:1
+  --> tests/ui/derive.rs:53:1
    |
 LL | / impl Clone for BigArray {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
+...  |
 LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> tests/ui/derive.rs:63:1
+  --> tests/ui/derive.rs:66:1
    |
 LL | / impl Clone for FnPtr {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
+...  |
 LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> tests/ui/derive.rs:63:1
+  --> tests/ui/derive.rs:66:1
    |
 LL | / impl Clone for FnPtr {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         unimplemented!()
-LL | |     }
+...  |
 LL | | }
    | |_^
 
 error: you are implementing `Clone` explicitly on a `Copy` type
-  --> tests/ui/derive.rs:84:1
+  --> tests/ui/derive.rs:88:1
    |
 LL | / impl<T: Clone> Clone for Generic2<T> {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         Self(self.0.clone())
-LL | |     }
+...  |
 LL | | }
    | |_^
    |
 note: consider deriving `Clone` or removing `Copy`
-  --> tests/ui/derive.rs:84:1
+  --> tests/ui/derive.rs:88:1
    |
 LL | / impl<T: Clone> Clone for Generic2<T> {
 LL | |
+LL | |
 LL | |     fn clone(&self) -> Self {
-LL | |         Self(self.0.clone())
-LL | |     }
+...  |
 LL | | }
    | |_^
 
diff --git a/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs b/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs
index 1c7e6d1c2023..3ef4ee9463dc 100644
--- a/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs
+++ b/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.rs
@@ -20,7 +20,8 @@ impl PartialOrd<u64> for DeriveBoth {
 }
 
 #[derive(Ord, PartialEq, Eq)]
-//~^ ERROR: you are deriving `Ord` but have implemented `PartialOrd` explicitly
+//~^ derive_ord_xor_partial_ord
+
 struct DeriveOrd;
 
 impl PartialOrd for DeriveOrd {
@@ -30,7 +31,8 @@ impl PartialOrd for DeriveOrd {
 }
 
 #[derive(Ord, PartialEq, Eq)]
-//~^ ERROR: you are deriving `Ord` but have implemented `PartialOrd` explicitly
+//~^ derive_ord_xor_partial_ord
+
 struct DeriveOrdWithExplicitTypeVariable;
 
 impl PartialOrd<DeriveOrdWithExplicitTypeVariable> for DeriveOrdWithExplicitTypeVariable {
@@ -43,7 +45,8 @@ impl PartialOrd<DeriveOrdWithExplicitTypeVariable> for DeriveOrdWithExplicitType
 struct DerivePartialOrd;
 
 impl std::cmp::Ord for DerivePartialOrd {
-    //~^ ERROR: you are implementing `Ord` explicitly but have derived `PartialOrd`
+    //~^ derive_ord_xor_partial_ord
+
     fn cmp(&self, other: &Self) -> Ordering {
         Ordering::Less
     }
@@ -64,7 +67,8 @@ mod use_ord {
     struct DerivePartialOrdInUseOrd;
 
     impl Ord for DerivePartialOrdInUseOrd {
-        //~^ ERROR: you are implementing `Ord` explicitly but have derived `PartialOrd`
+        //~^ derive_ord_xor_partial_ord
+
         fn cmp(&self, other: &Self) -> Ordering {
             Ordering::Less
         }
diff --git a/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.stderr b/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.stderr
index dcf32419baa2..6bbe54eeaa6a 100644
--- a/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.stderr
+++ b/src/tools/clippy/tests/ui/derive_ord_xor_partial_ord.stderr
@@ -5,7 +5,7 @@ LL | #[derive(Ord, PartialEq, Eq)]
    |          ^^^
    |
 note: `PartialOrd` implemented here
-  --> tests/ui/derive_ord_xor_partial_ord.rs:26:1
+  --> tests/ui/derive_ord_xor_partial_ord.rs:27:1
    |
 LL | impl PartialOrd for DeriveOrd {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -14,49 +14,49 @@ LL | impl PartialOrd for DeriveOrd {
    = note: this error originates in the derive macro `Ord` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are deriving `Ord` but have implemented `PartialOrd` explicitly
-  --> tests/ui/derive_ord_xor_partial_ord.rs:32:10
+  --> tests/ui/derive_ord_xor_partial_ord.rs:33:10
    |
 LL | #[derive(Ord, PartialEq, Eq)]
    |          ^^^
    |
 note: `PartialOrd` implemented here
-  --> tests/ui/derive_ord_xor_partial_ord.rs:36:1
+  --> tests/ui/derive_ord_xor_partial_ord.rs:38:1
    |
 LL | impl PartialOrd<DeriveOrdWithExplicitTypeVariable> for DeriveOrdWithExplicitTypeVariable {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the derive macro `Ord` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are implementing `Ord` explicitly but have derived `PartialOrd`
-  --> tests/ui/derive_ord_xor_partial_ord.rs:45:1
+  --> tests/ui/derive_ord_xor_partial_ord.rs:47:1
    |
 LL | / impl std::cmp::Ord for DerivePartialOrd {
 LL | |
+LL | |
 LL | |     fn cmp(&self, other: &Self) -> Ordering {
-LL | |         Ordering::Less
-LL | |     }
+...  |
 LL | | }
    | |_^
    |
 note: `PartialOrd` implemented here
-  --> tests/ui/derive_ord_xor_partial_ord.rs:42:10
+  --> tests/ui/derive_ord_xor_partial_ord.rs:44:10
    |
 LL | #[derive(PartialOrd, PartialEq, Eq)]
    |          ^^^^^^^^^^
    = note: this error originates in the derive macro `PartialOrd` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are implementing `Ord` explicitly but have derived `PartialOrd`
-  --> tests/ui/derive_ord_xor_partial_ord.rs:66:5
+  --> tests/ui/derive_ord_xor_partial_ord.rs:69:5
    |
 LL | /     impl Ord for DerivePartialOrdInUseOrd {
 LL | |
+LL | |
 LL | |         fn cmp(&self, other: &Self) -> Ordering {
-LL | |             Ordering::Less
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 note: `PartialOrd` implemented here
-  --> tests/ui/derive_ord_xor_partial_ord.rs:63:14
+  --> tests/ui/derive_ord_xor_partial_ord.rs:66:14
    |
 LL |     #[derive(PartialOrd, PartialEq, Eq)]
    |              ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.fixed b/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.fixed
index e4a33193a1ab..00f51d6acb94 100644
--- a/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.fixed
+++ b/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.fixed
@@ -9,6 +9,7 @@ pub struct NotPartialEq {
 
 // Eq can be derived but is missing
 #[derive(Debug, PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub struct MissingEq {
     foo: u32,
     bar: String,
@@ -67,33 +68,39 @@ impl PartialEq for ManualPartialEqImpl {
 
 // Generic fields should be properly checked for Eq-ness
 #[derive(PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub struct GenericNotEq<T: Eq, U: PartialEq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub struct GenericEq<T: Eq, U: Eq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub struct TupleStruct(u32);
 
 #[derive(PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub struct GenericTupleStruct<T: Eq>(T);
 
 #[derive(PartialEq)]
 pub struct TupleStructNotEq(f32);
 
 #[derive(PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub enum Enum {
     Foo(u32),
     Bar { a: String, b: () },
 }
 
 #[derive(PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub enum GenericEnum<T: Eq, U: Eq, V: Eq> {
     Foo(T),
     Bar { a: U, b: V },
@@ -107,9 +114,11 @@ pub enum EnumNotEq {
 
 // Ensure that rustfix works properly when `PartialEq` has other derives on either side
 #[derive(Debug, PartialEq, Eq, Clone)]
+//~^ derive_partial_eq_without_eq
 pub struct RustFixWithOtherDerives;
 
 #[derive(PartialEq, Eq)]
+//~^ derive_partial_eq_without_eq
 pub struct Generic<T>(T);
 
 #[derive(PartialEq, Eq)]
@@ -117,9 +126,11 @@ pub struct GenericPhantom<T>(core::marker::PhantomData<T>);
 
 mod _hidden {
     #[derive(PartialEq, Eq)]
+    //~^ derive_partial_eq_without_eq
     pub struct Reexported;
 
     #[derive(PartialEq, Eq)]
+    //~^ derive_partial_eq_without_eq
     pub struct InPubFn;
 
     #[derive(PartialEq)]
@@ -180,7 +191,8 @@ mod struct_gen {
     }
 
     #[derive(PartialEq, Eq)]
-    //~^ ERROR: you are deriving `PartialEq` and can implement `Eq`
+    //~^ derive_partial_eq_without_eq
+
     pub struct Foo<C: Suite>(<C::Group as Group>::Element);
 
     #[derive(PartialEq, Eq)]
@@ -188,7 +200,8 @@ mod struct_gen {
 
     // issue 9319
     #[derive(PartialEq, Eq)]
-    //~^ ERROR: you are deriving `PartialEq` and can implement `Eq`
+    //~^ derive_partial_eq_without_eq
+
     pub struct Oof<T: Fn()>(T);
 
     #[derive(PartialEq, Eq)]
diff --git a/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.rs b/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.rs
index a418b38e3499..073330468d31 100644
--- a/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.rs
+++ b/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.rs
@@ -9,6 +9,7 @@ pub struct NotPartialEq {
 
 // Eq can be derived but is missing
 #[derive(Debug, PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub struct MissingEq {
     foo: u32,
     bar: String,
@@ -67,33 +68,39 @@ impl PartialEq for ManualPartialEqImpl {
 
 // Generic fields should be properly checked for Eq-ness
 #[derive(PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub struct GenericNotEq<T: Eq, U: PartialEq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub struct GenericEq<T: Eq, U: Eq> {
     foo: T,
     bar: U,
 }
 
 #[derive(PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub struct TupleStruct(u32);
 
 #[derive(PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub struct GenericTupleStruct<T: Eq>(T);
 
 #[derive(PartialEq)]
 pub struct TupleStructNotEq(f32);
 
 #[derive(PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub enum Enum {
     Foo(u32),
     Bar { a: String, b: () },
 }
 
 #[derive(PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub enum GenericEnum<T: Eq, U: Eq, V: Eq> {
     Foo(T),
     Bar { a: U, b: V },
@@ -107,9 +114,11 @@ pub enum EnumNotEq {
 
 // Ensure that rustfix works properly when `PartialEq` has other derives on either side
 #[derive(Debug, PartialEq, Clone)]
+//~^ derive_partial_eq_without_eq
 pub struct RustFixWithOtherDerives;
 
 #[derive(PartialEq)]
+//~^ derive_partial_eq_without_eq
 pub struct Generic<T>(T);
 
 #[derive(PartialEq, Eq)]
@@ -117,9 +126,11 @@ pub struct GenericPhantom<T>(core::marker::PhantomData<T>);
 
 mod _hidden {
     #[derive(PartialEq)]
+    //~^ derive_partial_eq_without_eq
     pub struct Reexported;
 
     #[derive(PartialEq)]
+    //~^ derive_partial_eq_without_eq
     pub struct InPubFn;
 
     #[derive(PartialEq)]
@@ -180,7 +191,8 @@ mod struct_gen {
     }
 
     #[derive(PartialEq)]
-    //~^ ERROR: you are deriving `PartialEq` and can implement `Eq`
+    //~^ derive_partial_eq_without_eq
+
     pub struct Foo<C: Suite>(<C::Group as Group>::Element);
 
     #[derive(PartialEq, Eq)]
@@ -188,7 +200,8 @@ mod struct_gen {
 
     // issue 9319
     #[derive(PartialEq)]
-    //~^ ERROR: you are deriving `PartialEq` and can implement `Eq`
+    //~^ derive_partial_eq_without_eq
+
     pub struct Oof<T: Fn()>(T);
 
     #[derive(PartialEq, Eq)]
diff --git a/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.stderr b/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.stderr
index 7436114fadb2..fd9bac28a711 100644
--- a/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.stderr
+++ b/src/tools/clippy/tests/ui/derive_partial_eq_without_eq.stderr
@@ -8,19 +8,13 @@ LL | #[derive(Debug, PartialEq)]
    = help: to override `-D warnings` add `#[allow(clippy::derive_partial_eq_without_eq)]`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:69:10
+  --> tests/ui/derive_partial_eq_without_eq.rs:70:10
    |
 LL | #[derive(PartialEq)]
    |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:75:10
-   |
-LL | #[derive(PartialEq)]
-   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
-
-error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:81:10
+  --> tests/ui/derive_partial_eq_without_eq.rs:77:10
    |
 LL | #[derive(PartialEq)]
    |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
@@ -32,49 +26,55 @@ LL | #[derive(PartialEq)]
    |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:90:10
+  --> tests/ui/derive_partial_eq_without_eq.rs:88:10
    |
 LL | #[derive(PartialEq)]
    |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:96:10
+  --> tests/ui/derive_partial_eq_without_eq.rs:95:10
    |
 LL | #[derive(PartialEq)]
    |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:109:17
+  --> tests/ui/derive_partial_eq_without_eq.rs:102:10
+   |
+LL | #[derive(PartialEq)]
+   |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
+
+error: you are deriving `PartialEq` and can implement `Eq`
+  --> tests/ui/derive_partial_eq_without_eq.rs:116:17
    |
 LL | #[derive(Debug, PartialEq, Clone)]
    |                 ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:112:10
+  --> tests/ui/derive_partial_eq_without_eq.rs:120:10
    |
 LL | #[derive(PartialEq)]
    |          ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:119:14
+  --> tests/ui/derive_partial_eq_without_eq.rs:128:14
    |
 LL |     #[derive(PartialEq)]
    |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:122:14
+  --> tests/ui/derive_partial_eq_without_eq.rs:132:14
    |
 LL |     #[derive(PartialEq)]
    |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:182:14
+  --> tests/ui/derive_partial_eq_without_eq.rs:193:14
    |
 LL |     #[derive(PartialEq)]
    |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
 
 error: you are deriving `PartialEq` and can implement `Eq`
-  --> tests/ui/derive_partial_eq_without_eq.rs:190:14
+  --> tests/ui/derive_partial_eq_without_eq.rs:202:14
    |
 LL |     #[derive(PartialEq)]
    |              ^^^^^^^^^ help: consider deriving `Eq` as well: `PartialEq, Eq`
diff --git a/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.rs b/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.rs
index 8423699d99ed..88b574add3f2 100644
--- a/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.rs
+++ b/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.rs
@@ -10,7 +10,8 @@ impl PartialEq<u64> for Foo {
 }
 
 #[derive(Hash)]
-//~^ ERROR: you are deriving `Hash` but have implemented `PartialEq` explicitly
+//~^ derived_hash_with_manual_eq
+
 struct Bar;
 
 impl PartialEq for Bar {
@@ -20,7 +21,8 @@ impl PartialEq for Bar {
 }
 
 #[derive(Hash)]
-//~^ ERROR: you are deriving `Hash` but have implemented `PartialEq` explicitly
+//~^ derived_hash_with_manual_eq
+
 struct Baz;
 
 impl PartialEq<Baz> for Baz {
diff --git a/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.stderr b/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.stderr
index af4d247f95ba..19a24e752810 100644
--- a/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.stderr
+++ b/src/tools/clippy/tests/ui/derived_hash_with_manual_eq.stderr
@@ -5,7 +5,7 @@ LL | #[derive(Hash)]
    |          ^^^^
    |
 note: `PartialEq` implemented here
-  --> tests/ui/derived_hash_with_manual_eq.rs:16:1
+  --> tests/ui/derived_hash_with_manual_eq.rs:17:1
    |
 LL | impl PartialEq for Bar {
    | ^^^^^^^^^^^^^^^^^^^^^^
@@ -13,13 +13,13 @@ LL | impl PartialEq for Bar {
    = note: this error originates in the derive macro `Hash` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: you are deriving `Hash` but have implemented `PartialEq` explicitly
-  --> tests/ui/derived_hash_with_manual_eq.rs:22:10
+  --> tests/ui/derived_hash_with_manual_eq.rs:23:10
    |
 LL | #[derive(Hash)]
    |          ^^^^
    |
 note: `PartialEq` implemented here
-  --> tests/ui/derived_hash_with_manual_eq.rs:26:1
+  --> tests/ui/derived_hash_with_manual_eq.rs:28:1
    |
 LL | impl PartialEq<Baz> for Baz {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/disallowed_names.rs b/src/tools/clippy/tests/ui/disallowed_names.rs
index 96531bf8d88c..30fbdbc1fdc8 100644
--- a/src/tools/clippy/tests/ui/disallowed_names.rs
+++ b/src/tools/clippy/tests/ui/disallowed_names.rs
@@ -10,16 +10,18 @@
 #![warn(clippy::disallowed_names)]
 
 fn test(foo: ()) {}
-//~^ ERROR: use of a disallowed/placeholder name `foo`
-//~| NOTE: `-D clippy::disallowed-names` implied by `-D warnings`
+//~^ disallowed_names
 
 fn main() {
     let foo = 42;
-    //~^ ERROR: use of a disallowed/placeholder name `foo`
+    //~^ disallowed_names
+
     let baz = 42;
-    //~^ ERROR: use of a disallowed/placeholder name `baz`
+    //~^ disallowed_names
+
     let quux = 42;
-    //~^ ERROR: use of a disallowed/placeholder name `quux`
+    //~^ disallowed_names
+
     // Unlike these others, `bar` is actually considered an acceptable name.
     // Among many other legitimate uses, bar commonly refers to a period of time in music.
     // See https://github.com/rust-lang/rust-clippy/issues/5225.
@@ -31,33 +33,37 @@ fn main() {
 
     match (42, Some(1337), Some(0)) {
         (foo, Some(baz), quux @ Some(_)) => (),
-        //~^ ERROR: use of a disallowed/placeholder name `foo`
-        //~| ERROR: use of a disallowed/placeholder name `baz`
-        //~| ERROR: use of a disallowed/placeholder name `quux`
+        //~^ disallowed_names
+        //~| disallowed_names
+        //~| disallowed_names
         _ => (),
     }
 }
 
 fn issue_1647(mut foo: u8) {
-    //~^ ERROR: use of a disallowed/placeholder name `foo`
+    //~^ disallowed_names
+
     let mut baz = 0;
-    //~^ ERROR: use of a disallowed/placeholder name `baz`
+    //~^ disallowed_names
+
     if let Some(mut quux) = Some(42) {}
-    //~^ ERROR: use of a disallowed/placeholder name `quux`
+    //~^ disallowed_names
 }
 
 fn issue_1647_ref() {
     let ref baz = 0;
-    //~^ ERROR: use of a disallowed/placeholder name `baz`
+    //~^ disallowed_names
+
     if let Some(ref quux) = Some(42) {}
-    //~^ ERROR: use of a disallowed/placeholder name `quux`
+    //~^ disallowed_names
 }
 
 fn issue_1647_ref_mut() {
     let ref mut baz = 0;
-    //~^ ERROR: use of a disallowed/placeholder name `baz`
+    //~^ disallowed_names
+
     if let Some(ref mut quux) = Some(42) {}
-    //~^ ERROR: use of a disallowed/placeholder name `quux`
+    //~^ disallowed_names
 }
 
 #[cfg(test)]
diff --git a/src/tools/clippy/tests/ui/disallowed_names.stderr b/src/tools/clippy/tests/ui/disallowed_names.stderr
index d131cad8e11e..09398ebbab77 100644
--- a/src/tools/clippy/tests/ui/disallowed_names.stderr
+++ b/src/tools/clippy/tests/ui/disallowed_names.stderr
@@ -8,7 +8,7 @@ LL | fn test(foo: ()) {}
    = help: to override `-D warnings` add `#[allow(clippy::disallowed_names)]`
 
 error: use of a disallowed/placeholder name `foo`
-  --> tests/ui/disallowed_names.rs:17:9
+  --> tests/ui/disallowed_names.rs:16:9
    |
 LL |     let foo = 42;
    |         ^^^
@@ -20,67 +20,67 @@ LL |     let baz = 42;
    |         ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> tests/ui/disallowed_names.rs:21:9
+  --> tests/ui/disallowed_names.rs:22:9
    |
 LL |     let quux = 42;
    |         ^^^^
 
 error: use of a disallowed/placeholder name `foo`
-  --> tests/ui/disallowed_names.rs:33:10
+  --> tests/ui/disallowed_names.rs:35:10
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |          ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> tests/ui/disallowed_names.rs:33:20
+  --> tests/ui/disallowed_names.rs:35:20
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |                    ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> tests/ui/disallowed_names.rs:33:26
+  --> tests/ui/disallowed_names.rs:35:26
    |
 LL |         (foo, Some(baz), quux @ Some(_)) => (),
    |                          ^^^^
 
 error: use of a disallowed/placeholder name `foo`
-  --> tests/ui/disallowed_names.rs:41:19
+  --> tests/ui/disallowed_names.rs:43:19
    |
 LL | fn issue_1647(mut foo: u8) {
    |                   ^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> tests/ui/disallowed_names.rs:43:13
+  --> tests/ui/disallowed_names.rs:46:13
    |
 LL |     let mut baz = 0;
    |             ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> tests/ui/disallowed_names.rs:45:21
+  --> tests/ui/disallowed_names.rs:49:21
    |
 LL |     if let Some(mut quux) = Some(42) {}
    |                     ^^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> tests/ui/disallowed_names.rs:50:13
+  --> tests/ui/disallowed_names.rs:54:13
    |
 LL |     let ref baz = 0;
    |             ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> tests/ui/disallowed_names.rs:52:21
+  --> tests/ui/disallowed_names.rs:57:21
    |
 LL |     if let Some(ref quux) = Some(42) {}
    |                     ^^^^
 
 error: use of a disallowed/placeholder name `baz`
-  --> tests/ui/disallowed_names.rs:57:17
+  --> tests/ui/disallowed_names.rs:62:17
    |
 LL |     let ref mut baz = 0;
    |                 ^^^
 
 error: use of a disallowed/placeholder name `quux`
-  --> tests/ui/disallowed_names.rs:59:25
+  --> tests/ui/disallowed_names.rs:65:25
    |
 LL |     if let Some(ref mut quux) = Some(42) {}
    |                         ^^^^
diff --git a/src/tools/clippy/tests/ui/disallowed_script_idents.rs b/src/tools/clippy/tests/ui/disallowed_script_idents.rs
index 6b68fae318c0..08fd1d9669ee 100644
--- a/src/tools/clippy/tests/ui/disallowed_script_idents.rs
+++ b/src/tools/clippy/tests/ui/disallowed_script_idents.rs
@@ -9,8 +9,9 @@ fn main() {
 
     // Cyrillic is not allowed by default.
     let счётчик = 10;
-    //~^ ERROR: identifier `счётчик` has a Unicode script that is not allowed by configura
+    //~^ disallowed_script_idents
+
     // Same for japanese.
     let カウンタ = 10;
-    //~^ ERROR: identifier `カウンタ` has a Unicode script that is not allowed by configuratio
+    //~^ disallowed_script_idents
 }
diff --git a/src/tools/clippy/tests/ui/disallowed_script_idents.stderr b/src/tools/clippy/tests/ui/disallowed_script_idents.stderr
index c11655ab6021..edbcea5e5dd6 100644
--- a/src/tools/clippy/tests/ui/disallowed_script_idents.stderr
+++ b/src/tools/clippy/tests/ui/disallowed_script_idents.stderr
@@ -11,7 +11,7 @@ LL | #![deny(clippy::disallowed_script_idents)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: identifier `カウンタ` has a Unicode script that is not allowed by configuration: Katakana
-  --> tests/ui/disallowed_script_idents.rs:14:9
+  --> tests/ui/disallowed_script_idents.rs:15:9
    |
 LL |     let カウンタ = 10;
    |         ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/diverging_sub_expression.rs b/src/tools/clippy/tests/ui/diverging_sub_expression.rs
index 1abba60fd34a..b226ba69799e 100644
--- a/src/tools/clippy/tests/ui/diverging_sub_expression.rs
+++ b/src/tools/clippy/tests/ui/diverging_sub_expression.rs
@@ -18,10 +18,10 @@ impl A {
 fn main() {
     let b = true;
     b || diverge();
-    //~^ ERROR: sub-expression diverges
-    //~| NOTE: `-D clippy::diverging-sub-expression` implied by `-D warnings`
+    //~^ diverging_sub_expression
+
     b || A.foo();
-    //~^ ERROR: sub-expression diverges
+    //~^ diverging_sub_expression
 }
 
 #[allow(dead_code, unused_variables)]
@@ -32,28 +32,36 @@ fn foobar() {
             4 => return,
             5 => continue,
             6 => true || return,
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
             7 => true || continue,
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
             8 => break,
             9 => diverge(),
             3 => true || diverge(),
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
             10 => match 42 {
                 99 => return,
                 _ => true || panic!("boo"),
-                //~^ ERROR: sub-expression diverges
+                //~^ diverging_sub_expression
+
             },
             // lint blocks as well
             15 => true || { return; },
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
             16 => false || { return; },
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
             // ... and when it's a single expression
             17 => true || { return },
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
             18 => false || { return },
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
             // ... but not when there's both an expression and a statement
             19 => true || { _ = 1; return },
             20 => false || { _ = 1; return },
@@ -63,7 +71,8 @@ fn foobar() {
             23 => true || { return; true },
             24 => true || { return; true },
             _ => true || break,
-            //~^ ERROR: sub-expression diverges
+            //~^ diverging_sub_expression
+
         };
     }
 }
diff --git a/src/tools/clippy/tests/ui/diverging_sub_expression.stderr b/src/tools/clippy/tests/ui/diverging_sub_expression.stderr
index f90c95696a9c..3e417aa39cd8 100644
--- a/src/tools/clippy/tests/ui/diverging_sub_expression.stderr
+++ b/src/tools/clippy/tests/ui/diverging_sub_expression.stderr
@@ -20,19 +20,19 @@ LL |             6 => true || return,
    |                          ^^^^^^
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:36:26
+  --> tests/ui/diverging_sub_expression.rs:37:26
    |
 LL |             7 => true || continue,
    |                          ^^^^^^^^
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:40:26
+  --> tests/ui/diverging_sub_expression.rs:42:26
    |
 LL |             3 => true || diverge(),
    |                          ^^^^^^^^^
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:44:30
+  --> tests/ui/diverging_sub_expression.rs:47:30
    |
 LL |                 _ => true || panic!("boo"),
    |                              ^^^^^^^^^^^^^
@@ -40,31 +40,31 @@ LL |                 _ => true || panic!("boo"),
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:48:29
+  --> tests/ui/diverging_sub_expression.rs:52:29
    |
 LL |             15 => true || { return; },
    |                             ^^^^^^
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:50:30
+  --> tests/ui/diverging_sub_expression.rs:55:30
    |
 LL |             16 => false || { return; },
    |                              ^^^^^^
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:53:29
+  --> tests/ui/diverging_sub_expression.rs:59:29
    |
 LL |             17 => true || { return },
    |                             ^^^^^^
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:55:30
+  --> tests/ui/diverging_sub_expression.rs:62:30
    |
 LL |             18 => false || { return },
    |                              ^^^^^^
 
 error: sub-expression diverges
-  --> tests/ui/diverging_sub_expression.rs:65:26
+  --> tests/ui/diverging_sub_expression.rs:73:26
    |
 LL |             _ => true || break,
    |                          ^^^^^
diff --git a/src/tools/clippy/tests/ui/doc/doc-fixable.fixed b/src/tools/clippy/tests/ui/doc/doc-fixable.fixed
index 83574a5cd98d..5f2b697f88b0 100644
--- a/src/tools/clippy/tests/ui/doc/doc-fixable.fixed
+++ b/src/tools/clippy/tests/ui/doc/doc-fixable.fixed
@@ -7,13 +7,22 @@
 #![rustfmt::skip]
 
 /// The `foo_bar` function does _nothing_. See also `foo::bar`. (note the dot there)
+//~^ doc_markdown
+//~| doc_markdown
 /// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. But not `Foo::some_fun`
+//~^ doc_markdown
 /// which should be reported only once despite being __doubly bad__.
 /// Here be `::a::global:path`, and _`::another::global::path`_.  :: is not a path though.
+//~^ doc_markdown
+//~| doc_markdown
 /// Import an item from `::awesome::global::blob::` (Intended postfix)
+//~^ doc_markdown
 /// These are the options for `::Cat`: (Intended trailing single colon, shouldn't be linted)
+//~^ doc_markdown
 /// That's not code ~`NotInCodeBlock`~.
+//~^ doc_markdown
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn foo_bar() {
 }
 
@@ -28,6 +37,7 @@ fn foo_bar() {
 /// _foo bar_
 /// ~~~
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn multiline_codeblock() {
 }
 
@@ -35,6 +45,7 @@ fn multiline_codeblock() {
 /// multiline
 /// emphasis_.
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn test_emphasis() {
 }
 
@@ -49,6 +60,7 @@ fn test_emphasis() {
 /// 32kb 32Mb 32Gb 32Tb 32Pb 32Eb
 /// NaN
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn test_units() {
 }
 
@@ -77,6 +89,7 @@ fn test_units() {
 /// MinGW
 /// CamelCase (see also #2395)
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn test_allowed() {
 }
 
@@ -94,6 +107,7 @@ fn test_allowed() {
 /// expression of the type  `_ <bit_op> m <cmp_op> c` (where `<bit_op>`
 /// is one of {`&`, '|'} and `<cmp_op>` is one of {`!=`, `>=`, `>` ,
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn main() {
     foo_bar();
     multiline_codeblock();
@@ -102,12 +116,16 @@ fn main() {
 }
 
 /// ## `CamelCaseThing`
+//~^ doc_markdown
 /// Talks about `CamelCaseThing`. Titles should be ignored; see issue #897.
 ///
 /// # `CamelCaseThing`
+//~^ doc_markdown
 ///
 /// Not a title #897 `CamelCaseThing`
+//~^ doc_markdown
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn issue897() {
 }
 
@@ -115,6 +133,7 @@ fn issue897() {
 /// I am confused by brackets? (foo `x_y`)
 /// I am confused by brackets? (`x_y` foo)
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn issue900() {
 }
 
@@ -128,6 +147,7 @@ fn issue900() {
 /// [iterator]: https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html
 /// [helper_types]: ../helper_types/index.html
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn issue883() {
 }
 
@@ -146,6 +166,9 @@ That's in a code block: `PackedNode`
 And `BarQuz` too.
 `be_sure_we_got_to_the_end_of_it`
 */
+//~^^^ doc_markdown
+//~^^^ doc_markdown
+//~^^^^^^^^^^ doc_markdown
 fn issue1073() {
 }
 
@@ -157,6 +180,9 @@ That's in a code block: PackedNode
 And `BarQuz` too.
 `be_sure_we_got_to_the_end_of_it`
 */
+//~^^ doc_markdown
+//~^^^^ doc_markdown
+//~^^^^^^^^^^ doc_markdown
 fn issue1073_alt() {
 }
 
@@ -167,6 +193,7 @@ fn issue1073_alt() {
 /// StillDont
 /// ````
 /// `be_sure_we_got_to_the_end_of_it`
+//~^ doc_markdown
 fn four_quotes() {
 }
 
@@ -186,6 +213,7 @@ fn issue_1469() {}
 fn issue_1920() {}
 
 /// An iterator over `mycrate::Collection`'s values.
+//~^ doc_markdown
 /// It should not lint a `'static` lifetime in ticks.
 fn issue_2210() {}
 
@@ -210,6 +238,7 @@ fn intra_doc_link() {}
 fn issue_2581() {}
 
 /// Foo \[bar\] \[baz\] \[qux\]. `DocMarkdownLint`
+//~^ doc_markdown
 fn lint_after_escaped_chars() {}
 
 // issue #7033 - generic_const_exprs ICE
@@ -233,17 +262,22 @@ where [(); N.checked_next_power_of_two().unwrap()]: {
 fn issue_11568() {}
 
 /// There is no try (`do()` or `do_not()`).
+//~^ doc_markdown
+//~| doc_markdown
 fn parenthesized_word() {}
 
 /// `ABes`
+//~^ doc_markdown
 /// OSes
 /// UXes
 fn plural_acronym_test() {}
 
 extern "C" {
     /// `foo()`
+    //~^ doc_markdown
     fn in_extern();
 }
 
 /// <https://github.com/rust-lang/rust-clippy/pull/12836>
+//~^ doc_markdown
 fn check_autofix_for_base_urls() {}
diff --git a/src/tools/clippy/tests/ui/doc/doc-fixable.rs b/src/tools/clippy/tests/ui/doc/doc-fixable.rs
index 20fe89cdc536..ed3925694c67 100644
--- a/src/tools/clippy/tests/ui/doc/doc-fixable.rs
+++ b/src/tools/clippy/tests/ui/doc/doc-fixable.rs
@@ -7,13 +7,22 @@
 #![rustfmt::skip]
 
 /// The foo_bar function does _nothing_. See also foo::bar. (note the dot there)
+//~^ doc_markdown
+//~| doc_markdown
 /// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. But not Foo::some_fun
+//~^ doc_markdown
 /// which should be reported only once despite being __doubly bad__.
 /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
+//~^ doc_markdown
+//~| doc_markdown
 /// Import an item from ::awesome::global::blob:: (Intended postfix)
+//~^ doc_markdown
 /// These are the options for ::Cat: (Intended trailing single colon, shouldn't be linted)
+//~^ doc_markdown
 /// That's not code ~NotInCodeBlock~.
+//~^ doc_markdown
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn foo_bar() {
 }
 
@@ -28,6 +37,7 @@ fn foo_bar() {
 /// _foo bar_
 /// ~~~
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn multiline_codeblock() {
 }
 
@@ -35,6 +45,7 @@ fn multiline_codeblock() {
 /// multiline
 /// emphasis_.
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn test_emphasis() {
 }
 
@@ -49,6 +60,7 @@ fn test_emphasis() {
 /// 32kb 32Mb 32Gb 32Tb 32Pb 32Eb
 /// NaN
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn test_units() {
 }
 
@@ -77,6 +89,7 @@ fn test_units() {
 /// MinGW
 /// CamelCase (see also #2395)
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn test_allowed() {
 }
 
@@ -94,6 +107,7 @@ fn test_allowed() {
 /// expression of the type  `_ <bit_op> m <cmp_op> c` (where `<bit_op>`
 /// is one of {`&`, '|'} and `<cmp_op>` is one of {`!=`, `>=`, `>` ,
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn main() {
     foo_bar();
     multiline_codeblock();
@@ -102,12 +116,16 @@ fn main() {
 }
 
 /// ## CamelCaseThing
+//~^ doc_markdown
 /// Talks about `CamelCaseThing`. Titles should be ignored; see issue #897.
 ///
 /// # CamelCaseThing
+//~^ doc_markdown
 ///
 /// Not a title #897 CamelCaseThing
+//~^ doc_markdown
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn issue897() {
 }
 
@@ -115,6 +133,7 @@ fn issue897() {
 /// I am confused by brackets? (foo `x_y`)
 /// I am confused by brackets? (`x_y` foo)
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn issue900() {
 }
 
@@ -128,6 +147,7 @@ fn issue900() {
 /// [iterator]: https://doc.rust-lang.org/stable/std/iter/trait.Iterator.html
 /// [helper_types]: ../helper_types/index.html
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn issue883() {
 }
 
@@ -146,6 +166,9 @@ That's in a code block: `PackedNode`
 And BarQuz too.
 be_sure_we_got_to_the_end_of_it
 */
+//~^^^ doc_markdown
+//~^^^ doc_markdown
+//~^^^^^^^^^^ doc_markdown
 fn issue1073() {
 }
 
@@ -157,6 +180,9 @@ That's in a code block: PackedNode
 And BarQuz too.
 be_sure_we_got_to_the_end_of_it
 */
+//~^^ doc_markdown
+//~^^^^ doc_markdown
+//~^^^^^^^^^^ doc_markdown
 fn issue1073_alt() {
 }
 
@@ -167,6 +193,7 @@ fn issue1073_alt() {
 /// StillDont
 /// ````
 /// be_sure_we_got_to_the_end_of_it
+//~^ doc_markdown
 fn four_quotes() {
 }
 
@@ -186,6 +213,7 @@ fn issue_1469() {}
 fn issue_1920() {}
 
 /// An iterator over mycrate::Collection's values.
+//~^ doc_markdown
 /// It should not lint a `'static` lifetime in ticks.
 fn issue_2210() {}
 
@@ -210,6 +238,7 @@ fn intra_doc_link() {}
 fn issue_2581() {}
 
 /// Foo \[bar\] \[baz\] \[qux\]. DocMarkdownLint
+//~^ doc_markdown
 fn lint_after_escaped_chars() {}
 
 // issue #7033 - generic_const_exprs ICE
@@ -233,17 +262,22 @@ where [(); N.checked_next_power_of_two().unwrap()]: {
 fn issue_11568() {}
 
 /// There is no try (do() or do_not()).
+//~^ doc_markdown
+//~| doc_markdown
 fn parenthesized_word() {}
 
 /// ABes
+//~^ doc_markdown
 /// OSes
 /// UXes
 fn plural_acronym_test() {}
 
 extern "C" {
     /// foo()
+    //~^ doc_markdown
     fn in_extern();
 }
 
 /// https://github.com/rust-lang/rust-clippy/pull/12836
+//~^ doc_markdown
 fn check_autofix_for_base_urls() {}
diff --git a/src/tools/clippy/tests/ui/doc/doc-fixable.stderr b/src/tools/clippy/tests/ui/doc/doc-fixable.stderr
index 54d735814855..d67da75a230c 100644
--- a/src/tools/clippy/tests/ui/doc/doc-fixable.stderr
+++ b/src/tools/clippy/tests/ui/doc/doc-fixable.stderr
@@ -25,7 +25,7 @@ LL + /// The foo_bar function does _nothing_. See also `foo::bar`. (note the dot
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:10:83
+  --> tests/ui/doc/doc-fixable.rs:12:83
    |
 LL | /// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. But not Foo::some_fun
    |                                                                                   ^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL + /// Markdown is _weird_. I mean _really weird_. This \_ is ok. So is `_`. B
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:12:13
+  --> tests/ui/doc/doc-fixable.rs:15:13
    |
 LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
    |             ^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL + /// Here be `::a::global:path`, and _::another::global::path_.  :: is not a
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:12:36
+  --> tests/ui/doc/doc-fixable.rs:15:36
    |
 LL | /// Here be ::a::global:path, and _::another::global::path_.  :: is not a path though.
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL + /// Here be ::a::global:path, and _`::another::global::path`_.  :: is not a
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:13:25
+  --> tests/ui/doc/doc-fixable.rs:18:25
    |
 LL | /// Import an item from ::awesome::global::blob:: (Intended postfix)
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL + /// Import an item from `::awesome::global::blob::` (Intended postfix)
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:14:31
+  --> tests/ui/doc/doc-fixable.rs:20:31
    |
 LL | /// These are the options for ::Cat: (Intended trailing single colon, shouldn't be linted)
    |                               ^^^^^
@@ -85,7 +85,7 @@ LL + /// These are the options for `::Cat`: (Intended trailing single colon, sho
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:15:22
+  --> tests/ui/doc/doc-fixable.rs:22:22
    |
 LL | /// That's not code ~NotInCodeBlock~.
    |                      ^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL + /// That's not code ~`NotInCodeBlock`~.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:16:5
+  --> tests/ui/doc/doc-fixable.rs:24:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:30:5
+  --> tests/ui/doc/doc-fixable.rs:39:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:37:5
+  --> tests/ui/doc/doc-fixable.rs:47:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:51:5
+  --> tests/ui/doc/doc-fixable.rs:62:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:79:5
+  --> tests/ui/doc/doc-fixable.rs:91:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:96:5
+  --> tests/ui/doc/doc-fixable.rs:109:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:104:8
+  --> tests/ui/doc/doc-fixable.rs:118:8
    |
 LL | /// ## CamelCaseThing
    |        ^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL + /// ## `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:107:7
+  --> tests/ui/doc/doc-fixable.rs:122:7
    |
 LL | /// # CamelCaseThing
    |       ^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL + /// # `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:109:22
+  --> tests/ui/doc/doc-fixable.rs:125:22
    |
 LL | /// Not a title #897 CamelCaseThing
    |                      ^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL + /// Not a title #897 `CamelCaseThing`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:110:5
+  --> tests/ui/doc/doc-fixable.rs:127:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:117:5
+  --> tests/ui/doc/doc-fixable.rs:135:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:130:5
+  --> tests/ui/doc/doc-fixable.rs:149:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:141:43
+  --> tests/ui/doc/doc-fixable.rs:161:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
@@ -253,7 +253,7 @@ LL + /** E.g., serialization of an empty list: `FooBar`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:146:5
+  --> tests/ui/doc/doc-fixable.rs:166:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
@@ -265,7 +265,7 @@ LL + And `BarQuz` too.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:147:1
+  --> tests/ui/doc/doc-fixable.rs:167:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL + `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:152:43
+  --> tests/ui/doc/doc-fixable.rs:175:43
    |
 LL | /** E.g., serialization of an empty list: FooBar
    |                                           ^^^^^^
@@ -289,7 +289,7 @@ LL + /** E.g., serialization of an empty list: `FooBar`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:157:5
+  --> tests/ui/doc/doc-fixable.rs:180:5
    |
 LL | And BarQuz too.
    |     ^^^^^^
@@ -301,7 +301,7 @@ LL + And `BarQuz` too.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:158:1
+  --> tests/ui/doc/doc-fixable.rs:181:1
    |
 LL | be_sure_we_got_to_the_end_of_it
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL + `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:169:5
+  --> tests/ui/doc/doc-fixable.rs:195:5
    |
 LL | /// be_sure_we_got_to_the_end_of_it
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL + /// `be_sure_we_got_to_the_end_of_it`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:188:22
+  --> tests/ui/doc/doc-fixable.rs:215:22
    |
 LL | /// An iterator over mycrate::Collection's values.
    |                      ^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL + /// An iterator over `mycrate::Collection`'s values.
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:212:34
+  --> tests/ui/doc/doc-fixable.rs:240:34
    |
 LL | /// Foo \[bar\] \[baz\] \[qux\]. DocMarkdownLint
    |                                  ^^^^^^^^^^^^^^^
@@ -349,7 +349,7 @@ LL + /// Foo \[bar\] \[baz\] \[qux\]. `DocMarkdownLint`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:235:22
+  --> tests/ui/doc/doc-fixable.rs:264:22
    |
 LL | /// There is no try (do() or do_not()).
    |                      ^^^^
@@ -361,7 +361,7 @@ LL + /// There is no try (`do()` or do_not()).
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:235:30
+  --> tests/ui/doc/doc-fixable.rs:264:30
    |
 LL | /// There is no try (do() or do_not()).
    |                              ^^^^^^^^
@@ -373,7 +373,7 @@ LL + /// There is no try (do() or `do_not()`).
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:238:5
+  --> tests/ui/doc/doc-fixable.rs:269:5
    |
 LL | /// ABes
    |     ^^^^
@@ -385,7 +385,7 @@ LL + /// `ABes`
    |
 
 error: item in documentation is missing backticks
-  --> tests/ui/doc/doc-fixable.rs:244:9
+  --> tests/ui/doc/doc-fixable.rs:276:9
    |
 LL |     /// foo()
    |         ^^^^^
@@ -397,7 +397,7 @@ LL +     /// `foo()`
    |
 
 error: you should put bare URLs between `<`/`>` or make a proper Markdown link
-  --> tests/ui/doc/doc-fixable.rs:248:5
+  --> tests/ui/doc/doc-fixable.rs:281:5
    |
 LL | /// https://github.com/rust-lang/rust-clippy/pull/12836
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `<https://github.com/rust-lang/rust-clippy/pull/12836>`
diff --git a/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.fixed b/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.fixed
index d4ae810d7385..a05954adf5a5 100644
--- a/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.fixed
+++ b/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.fixed
@@ -1,7 +1,8 @@
 #![warn(clippy::doc_include_without_cfg)]
 // Should not lint.
 #![doc(html_playground_url = "https://playground.example.com/")]
-#![cfg_attr(doc, doc = include_str!("../approx_const.rs"))] //~ doc_include_without_cfg
+#![cfg_attr(doc, doc = include_str!("../approx_const.rs"))]
+//~^ doc_include_without_cfg
 // Should not lint.
 #![cfg_attr(feature = "whatever", doc = include_str!("../approx_const.rs"))]
 #![cfg_attr(doc, doc = include_str!("../approx_const.rs"))]
@@ -28,7 +29,8 @@ tst! {
     /// This is a test with no included file
 }
 
-#[cfg_attr(doc, doc = include_str!("../approx_const.rs"))] //~ doc_include_without_cfg
+#[cfg_attr(doc, doc = include_str!("../approx_const.rs"))]
+//~^ doc_include_without_cfg
 // Should not lint.
 #[doc = man_link!("bla", "blob")]
 #[cfg_attr(feature = "whatever", doc = include_str!("../approx_const.rs"))]
diff --git a/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.rs b/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.rs
index c82f6bf20356..26aa7a3a706a 100644
--- a/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.rs
+++ b/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.rs
@@ -1,7 +1,8 @@
 #![warn(clippy::doc_include_without_cfg)]
 // Should not lint.
 #![doc(html_playground_url = "https://playground.example.com/")]
-#![doc = include_str!("../approx_const.rs")] //~ doc_include_without_cfg
+#![doc = include_str!("../approx_const.rs")]
+//~^ doc_include_without_cfg
 // Should not lint.
 #![cfg_attr(feature = "whatever", doc = include_str!("../approx_const.rs"))]
 #![cfg_attr(doc, doc = include_str!("../approx_const.rs"))]
@@ -28,7 +29,8 @@ tst! {
     /// This is a test with no included file
 }
 
-#[doc = include_str!("../approx_const.rs")] //~ doc_include_without_cfg
+#[doc = include_str!("../approx_const.rs")]
+//~^ doc_include_without_cfg
 // Should not lint.
 #[doc = man_link!("bla", "blob")]
 #[cfg_attr(feature = "whatever", doc = include_str!("../approx_const.rs"))]
diff --git a/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.stderr b/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.stderr
index 17ea53c7c318..24991df581e8 100644
--- a/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.stderr
+++ b/src/tools/clippy/tests/ui/doc/doc_include_without_cfg.stderr
@@ -8,7 +8,7 @@ LL | #![doc = include_str!("../approx_const.rs")]
    = help: to override `-D warnings` add `#[allow(clippy::doc_include_without_cfg)]`
 
 error: included a file in documentation unconditionally
-  --> tests/ui/doc/doc_include_without_cfg.rs:31:1
+  --> tests/ui/doc/doc_include_without_cfg.rs:32:1
    |
 LL | #[doc = include_str!("../approx_const.rs")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `cfg_attr(doc, doc = "...")`: `#[cfg_attr(doc, doc = include_str!("../approx_const.rs"))]`
diff --git a/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.fixed b/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.fixed
index fcfcfcc40736..065f4486e390 100644
--- a/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.fixed
+++ b/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.fixed
@@ -69,3 +69,11 @@ pub struct NotEmpty;
 /// - [link]\: notdef
 ///   inner text
 pub struct NotEmptyTight;
+
+/// ## Heading
+///
+/// - [x][] - Done
+//~^ ERROR: link reference defined in list item
+/// - [ ][] - Not Done
+//~^ ERROR: link reference defined in list item
+pub struct GithubCheckboxes;
diff --git a/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.rs b/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.rs
index 53368de4616d..c7eab50c8b38 100644
--- a/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.rs
+++ b/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.rs
@@ -69,3 +69,11 @@ pub struct NotEmpty;
 /// - [link]\: notdef
 ///   inner text
 pub struct NotEmptyTight;
+
+/// ## Heading
+///
+/// - [x] - Done
+//~^ ERROR: link reference defined in list item
+/// - [ ] - Not Done
+//~^ ERROR: link reference defined in list item
+pub struct GithubCheckboxes;
diff --git a/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.stderr b/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.stderr
index 27314c7e968d..5a815dabf4d8 100644
--- a/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.stderr
+++ b/src/tools/clippy/tests/ui/doc/doc_nested_refdef_list_item.stderr
@@ -144,5 +144,29 @@ help: for an intra-doc link, add `[]` between the label and the colon
 LL | /// - [link][]: def "title"
    |             ++
 
-error: aborting due to 12 previous errors
+error: link reference defined in list item
+  --> tests/ui/doc/doc_nested_refdef_list_item.rs:75:7
+   |
+LL | /// - [x] - Done
+   |       ^^^
+   |
+   = help: link definitions are not shown in rendered documentation
+help: for an intra-doc link, add `[]` between the label and the colon
+   |
+LL | /// - [x][] - Done
+   |          ++
+
+error: link reference defined in list item
+  --> tests/ui/doc/doc_nested_refdef_list_item.rs:77:7
+   |
+LL | /// - [ ] - Not Done
+   |       ^^^
+   |
+   = help: link definitions are not shown in rendered documentation
+help: for an intra-doc link, add `[]` between the label and the colon
+   |
+LL | /// - [ ][] - Not Done
+   |          ++
+
+error: aborting due to 14 previous errors
 
diff --git a/src/tools/clippy/tests/ui/doc/footnote_issue_13183.rs b/src/tools/clippy/tests/ui/doc/footnote_issue_13183.rs
index a18b4c3ac539..dbb01bd5155b 100644
--- a/src/tools/clippy/tests/ui/doc/footnote_issue_13183.rs
+++ b/src/tools/clippy/tests/ui/doc/footnote_issue_13183.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // This is a regression test for <https://github.com/rust-lang/rust-clippy/issues/13183>.
 // It should not warn on missing backticks on footnote references.
 
diff --git a/src/tools/clippy/tests/ui/doc/issue_12795.fixed b/src/tools/clippy/tests/ui/doc/issue_12795.fixed
index ade23bf975c2..4172438a82a6 100644
--- a/src/tools/clippy/tests/ui/doc/issue_12795.fixed
+++ b/src/tools/clippy/tests/ui/doc/issue_12795.fixed
@@ -1,9 +1,9 @@
 #![warn(clippy::doc_markdown)]
 
 //! A comment with `a_b(x)` and `a_c` in it and (`a_b((c))` ) too and (maybe `a_b((c))`)
-//~^ ERROR: item in documentation is missing backticks
-//~| ERROR: item in documentation is missing backticks
-//~| ERROR: item in documentation is missing backticks
-//~| ERROR: item in documentation is missing backticks
+//~^ doc_markdown
+//~| doc_markdown
+//~| doc_markdown
+//~| doc_markdown
 
 pub fn main() {}
diff --git a/src/tools/clippy/tests/ui/doc/issue_12795.rs b/src/tools/clippy/tests/ui/doc/issue_12795.rs
index 6d94a07e3036..dbc03cc70865 100644
--- a/src/tools/clippy/tests/ui/doc/issue_12795.rs
+++ b/src/tools/clippy/tests/ui/doc/issue_12795.rs
@@ -1,9 +1,9 @@
 #![warn(clippy::doc_markdown)]
 
 //! A comment with a_b(x) and a_c in it and (a_b((c)) ) too and (maybe a_b((c)))
-//~^ ERROR: item in documentation is missing backticks
-//~| ERROR: item in documentation is missing backticks
-//~| ERROR: item in documentation is missing backticks
-//~| ERROR: item in documentation is missing backticks
+//~^ doc_markdown
+//~| doc_markdown
+//~| doc_markdown
+//~| doc_markdown
 
 pub fn main() {}
diff --git a/src/tools/clippy/tests/ui/doc/issue_1832.rs b/src/tools/clippy/tests/ui/doc/issue_1832.rs
index 10586f16d466..9678badd11c8 100644
--- a/src/tools/clippy/tests/ui/doc/issue_1832.rs
+++ b/src/tools/clippy/tests/ui/doc/issue_1832.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 /// Ok: <http://www.unicode.org/reports/tr9/#Reordering_Resolved_Levels>
 ///
 /// Not ok: http://www.unicode.org
diff --git a/src/tools/clippy/tests/ui/doc/issue_902.rs b/src/tools/clippy/tests/ui/doc/issue_902.rs
index 4b0c835dd3f0..1be6db01dcb2 100644
--- a/src/tools/clippy/tests/ui/doc/issue_902.rs
+++ b/src/tools/clippy/tests/ui/doc/issue_902.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 /// See [NIST SP 800-56A, revision 2].
 ///
 /// [NIST SP 800-56A, revision 2]:
diff --git a/src/tools/clippy/tests/ui/doc/issue_9473.fixed b/src/tools/clippy/tests/ui/doc/issue_9473.fixed
index 276ce7620ca7..2d910c43b263 100644
--- a/src/tools/clippy/tests/ui/doc/issue_9473.fixed
+++ b/src/tools/clippy/tests/ui/doc/issue_9473.fixed
@@ -6,4 +6,5 @@ pub struct Foo(u32);
 
 // Should warn.
 /// Blah blah blah <code>[FooBar]&lt;[FooBar]&gt;</code>[`FooBar`].
+//~^ doc_markdown
 pub struct FooBar(u32);
diff --git a/src/tools/clippy/tests/ui/doc/issue_9473.rs b/src/tools/clippy/tests/ui/doc/issue_9473.rs
index 52527f7106d1..e5798685382a 100644
--- a/src/tools/clippy/tests/ui/doc/issue_9473.rs
+++ b/src/tools/clippy/tests/ui/doc/issue_9473.rs
@@ -6,4 +6,5 @@ pub struct Foo(u32);
 
 // Should warn.
 /// Blah blah blah <code>[FooBar]&lt;[FooBar]&gt;</code>[FooBar].
+//~^ doc_markdown
 pub struct FooBar(u32);
diff --git a/src/tools/clippy/tests/ui/doc/link_adjacent.fixed b/src/tools/clippy/tests/ui/doc/link_adjacent.fixed
new file mode 100644
index 000000000000..0ac297a6b197
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/link_adjacent.fixed
@@ -0,0 +1,52 @@
+#![warn(clippy::doc_link_code)]
+
+//! Test case for code links that are adjacent to code text.
+//!
+//! This is not an example: `first``second`
+//!
+//! Neither is this: [`first`](x)
+//!
+//! Neither is this: [`first`](x) `second`
+//!
+//! Neither is this: [first](x)`second`
+//!
+//! This is: <code>[first](x)second</code>
+//~^ ERROR: adjacent
+//!
+//! So is this <code>first[second](x)</code>
+//~^ ERROR: adjacent
+//!
+//! So is this <code>[first](x)[second](x)</code>
+//~^ ERROR: adjacent
+//!
+//! So is this <code>[first](x)[second](x)[third](x)</code>
+//~^ ERROR: adjacent
+//!
+//! So is this <code>[first](x)second[third](x)</code>
+//~^ ERROR: adjacent
+
+/// Test case for code links that are adjacent to code text.
+///
+/// This is not an example: `first``second` arst
+///
+/// Neither is this: [`first`](x) arst
+///
+/// Neither is this: [`first`](x) `second` arst
+///
+/// Neither is this: [first](x)`second` arst
+///
+/// This is: <code>[first](x)second</code> arst
+//~^ ERROR: adjacent
+///
+/// So is this <code>first[second](x)</code> arst
+//~^ ERROR: adjacent
+///
+/// So is this <code>[first](x)[second](x)</code> arst
+//~^ ERROR: adjacent
+///
+/// So is this <code>[first](x)[second](x)[third](x)</code> arst
+//~^ ERROR: adjacent
+///
+/// So is this <code>[first](x)second[third](x)</code> arst
+//~^ ERROR: adjacent
+pub struct WithTrailing;
diff --git a/src/tools/clippy/tests/ui/doc/link_adjacent.rs b/src/tools/clippy/tests/ui/doc/link_adjacent.rs
new file mode 100644
index 000000000000..af6755eeff61
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/link_adjacent.rs
@@ -0,0 +1,52 @@
+#![warn(clippy::doc_link_code)]
+
+//! Test case for code links that are adjacent to code text.
+//!
+//! This is not an example: `first``second`
+//!
+//! Neither is this: [`first`](x)
+//!
+//! Neither is this: [`first`](x) `second`
+//!
+//! Neither is this: [first](x)`second`
+//!
+//! This is: [`first`](x)`second`
+//~^ ERROR: adjacent
+//!
+//! So is this `first`[`second`](x)
+//~^ ERROR: adjacent
+//!
+//! So is this [`first`](x)[`second`](x)
+//~^ ERROR: adjacent
+//!
+//! So is this [`first`](x)[`second`](x)[`third`](x)
+//~^ ERROR: adjacent
+//!
+//! So is this [`first`](x)`second`[`third`](x)
+//~^ ERROR: adjacent
+
+/// Test case for code links that are adjacent to code text.
+///
+/// This is not an example: `first``second` arst
+///
+/// Neither is this: [`first`](x) arst
+///
+/// Neither is this: [`first`](x) `second` arst
+///
+/// Neither is this: [first](x)`second` arst
+///
+/// This is: [`first`](x)`second` arst
+//~^ ERROR: adjacent
+///
+/// So is this `first`[`second`](x) arst
+//~^ ERROR: adjacent
+///
+/// So is this [`first`](x)[`second`](x) arst
+//~^ ERROR: adjacent
+///
+/// So is this [`first`](x)[`second`](x)[`third`](x) arst
+//~^ ERROR: adjacent
+///
+/// So is this [`first`](x)`second`[`third`](x) arst
+//~^ ERROR: adjacent
+pub struct WithTrailing;
diff --git a/src/tools/clippy/tests/ui/doc/link_adjacent.stderr b/src/tools/clippy/tests/ui/doc/link_adjacent.stderr
new file mode 100644
index 000000000000..27e8a73c7083
--- /dev/null
+++ b/src/tools/clippy/tests/ui/doc/link_adjacent.stderr
@@ -0,0 +1,134 @@
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:13:14
+   |
+LL | //! This is: [`first`](x)`second`
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+   = note: `-D clippy::doc-link-code` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::doc_link_code)]`
+help: wrap the entire group in `<code>` tags
+   |
+LL - //! This is: [`first`](x)`second`
+LL + //! This is: <code>[first](x)second</code>
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:16:16
+   |
+LL | //! So is this `first`[`second`](x)
+   |                ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - //! So is this `first`[`second`](x)
+LL + //! So is this <code>first[second](x)</code>
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:19:16
+   |
+LL | //! So is this [`first`](x)[`second`](x)
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - //! So is this [`first`](x)[`second`](x)
+LL + //! So is this <code>[first](x)[second](x)</code>
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:22:16
+   |
+LL | //! So is this [`first`](x)[`second`](x)[`third`](x)
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - //! So is this [`first`](x)[`second`](x)[`third`](x)
+LL + //! So is this <code>[first](x)[second](x)[third](x)</code>
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:25:16
+   |
+LL | //! So is this [`first`](x)`second`[`third`](x)
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - //! So is this [`first`](x)`second`[`third`](x)
+LL + //! So is this <code>[first](x)second[third](x)</code>
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:38:14
+   |
+LL | /// This is: [`first`](x)`second` arst
+   |              ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - /// This is: [`first`](x)`second` arst
+LL + /// This is: <code>[first](x)second</code> arst
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:41:16
+   |
+LL | /// So is this `first`[`second`](x) arst
+   |                ^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - /// So is this `first`[`second`](x) arst
+LL + /// So is this <code>first[second](x)</code> arst
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:44:16
+   |
+LL | /// So is this [`first`](x)[`second`](x) arst
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - /// So is this [`first`](x)[`second`](x) arst
+LL + /// So is this <code>[first](x)[second](x)</code> arst
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:47:16
+   |
+LL | /// So is this [`first`](x)[`second`](x)[`third`](x) arst
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - /// So is this [`first`](x)[`second`](x)[`third`](x) arst
+LL + /// So is this <code>[first](x)[second](x)[third](x)</code> arst
+   |
+
+error: code link adjacent to code text
+  --> tests/ui/doc/link_adjacent.rs:50:16
+   |
+LL | /// So is this [`first`](x)`second`[`third`](x) arst
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: separate code snippets will be shown with a gap
+help: wrap the entire group in `<code>` tags
+   |
+LL - /// So is this [`first`](x)`second`[`third`](x) arst
+LL + /// So is this <code>[first](x)second[third](x)</code> arst
+   |
+
+error: aborting due to 10 previous errors
+
diff --git a/src/tools/clippy/tests/ui/doc/needless_doctest_main.rs b/src/tools/clippy/tests/ui/doc/needless_doctest_main.rs
index f1a2c0575ee5..633a435ca5ed 100644
--- a/src/tools/clippy/tests/ui/doc/needless_doctest_main.rs
+++ b/src/tools/clippy/tests/ui/doc/needless_doctest_main.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::needless_doctest_main)]
 //! issue 10491:
 //! ```rust,no_test
diff --git a/src/tools/clippy/tests/ui/doc/unbalanced_ticks.rs b/src/tools/clippy/tests/ui/doc/unbalanced_ticks.rs
index a065654e319d..76befb15db80 100644
--- a/src/tools/clippy/tests/ui/doc/unbalanced_ticks.rs
+++ b/src/tools/clippy/tests/ui/doc/unbalanced_ticks.rs
@@ -5,20 +5,20 @@
 #![warn(clippy::doc_markdown)]
 
 /// This is a doc comment with `unbalanced_tick marks and several words that
-//~^ ERROR: backticks are unbalanced
+//~^ doc_markdown
 /// should be `encompassed_by` tick marks because they `contain_underscores`.
 /// Because of the initial `unbalanced_tick` pair, the error message is
 /// very `confusing_and_misleading`.
 fn main() {}
 
 /// This paragraph has `unbalanced_tick marks and should stop_linting.
-//~^ ERROR: backticks are unbalanced
+//~^ doc_markdown
 ///
 /// This paragraph is fine and should_be linted normally.
-//~^ ERROR: item in documentation is missing backticks
+//~^ doc_markdown
 ///
 /// Double unbalanced backtick from ``here to here` should lint.
-//~^ ERROR: backticks are unbalanced
+//~^ doc_markdown
 ///
 /// Double balanced back ticks ``start end`` is fine.
 fn multiple_paragraphs() {}
@@ -32,15 +32,15 @@ fn in_code_block() {}
 /// # `Fine`
 ///
 /// ## not_fine
-//~^ ERROR: item in documentation is missing backticks
+//~^ doc_markdown
 ///
 /// ### `unbalanced
-//~^ ERROR: backticks are unbalanced
+//~^ doc_markdown
 ///
 /// - This `item has unbalanced tick marks
-//~^ ERROR: backticks are unbalanced
+//~^ doc_markdown
 /// - This item needs backticks_here
-//~^ ERROR: item in documentation is missing backticks
+//~^ doc_markdown
 fn other_markdown() {}
 
 #[rustfmt::skip]
@@ -51,7 +51,7 @@ fn other_markdown() {}
 fn issue_7421() {}
 
 /// `
-//~^ ERROR: backticks are unbalanced
+//~^ doc_markdown
 fn escape_0() {}
 
 /// Escaped \` backticks don't count.
@@ -61,7 +61,7 @@ fn escape_1() {}
 fn escape_2() {}
 
 /// Escaped \` ` backticks don't count, but unescaped backticks do.
-//~^ ERROR: backticks are unbalanced
+//~^ doc_markdown
 fn escape_3() {}
 
 /// Backslashes ` \` within code blocks don't count.
@@ -80,5 +80,6 @@ impl Foo for Bar {
     /// ---------------------------| -------------------- | --------------------- | ... | -----
     /// ``:                        | Some(Month::January) | Some(Month::February) | ... |
     /// Some(Month::December)
+    //~^^^^ doc_markdown
     fn bar() {}
 }
diff --git a/src/tools/clippy/tests/ui/doc_errors.rs b/src/tools/clippy/tests/ui/doc_errors.rs
index 9b3783aaf09d..f67e3216c01e 100644
--- a/src/tools/clippy/tests/ui/doc_errors.rs
+++ b/src/tools/clippy/tests/ui/doc_errors.rs
@@ -5,25 +5,28 @@
 use std::io;
 
 pub fn pub_fn_missing_errors_header() -> Result<(), ()> {
-    //~^ ERROR: docs for function returning `Result` missing `# Errors` section
-    //~| NOTE: `-D clippy::missing-errors-doc` implied by `-D warnings`
+    //~^ missing_errors_doc
+
     unimplemented!();
 }
 
 pub async fn async_pub_fn_missing_errors_header() -> Result<(), ()> {
-    //~^ ERROR: docs for function returning `Result` missing `# Errors` section
+    //~^ missing_errors_doc
+
     unimplemented!();
 }
 
 /// This is not sufficiently documented.
 pub fn pub_fn_returning_io_result() -> io::Result<()> {
-    //~^ ERROR: docs for function returning `Result` missing `# Errors` section
+    //~^ missing_errors_doc
+
     unimplemented!();
 }
 
 /// This is not sufficiently documented.
 pub async fn async_pub_fn_returning_io_result() -> io::Result<()> {
-    //~^ ERROR: docs for function returning `Result` missing `# Errors` section
+    //~^ missing_errors_doc
+
     unimplemented!();
 }
 
@@ -54,13 +57,15 @@ pub struct Struct1;
 impl Struct1 {
     /// This is not sufficiently documented.
     pub fn pub_method_missing_errors_header() -> Result<(), ()> {
-        //~^ ERROR: docs for function returning `Result` missing `# Errors` section
+        //~^ missing_errors_doc
+
         unimplemented!();
     }
 
     /// This is not sufficiently documented.
     pub async fn async_pub_method_missing_errors_header() -> Result<(), ()> {
-        //~^ ERROR: docs for function returning `Result` missing `# Errors` section
+        //~^ missing_errors_doc
+
         unimplemented!();
     }
 
@@ -111,7 +116,7 @@ impl Struct1 {
 pub trait Trait1 {
     /// This is not sufficiently documented.
     fn trait_method_missing_errors_header() -> Result<(), ()>;
-    //~^ ERROR: docs for function returning `Result` missing `# Errors` section
+    //~^ missing_errors_doc
 
     /// # Errors
     /// A description of the errors goes here.
diff --git a/src/tools/clippy/tests/ui/doc_errors.stderr b/src/tools/clippy/tests/ui/doc_errors.stderr
index c5b9479adace..aeb2516e5123 100644
--- a/src/tools/clippy/tests/ui/doc_errors.stderr
+++ b/src/tools/clippy/tests/ui/doc_errors.stderr
@@ -14,31 +14,31 @@ LL | pub async fn async_pub_fn_missing_errors_header() -> Result<(), ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> tests/ui/doc_errors.rs:19:1
+  --> tests/ui/doc_errors.rs:20:1
    |
 LL | pub fn pub_fn_returning_io_result() -> io::Result<()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> tests/ui/doc_errors.rs:25:1
+  --> tests/ui/doc_errors.rs:27:1
    |
 LL | pub async fn async_pub_fn_returning_io_result() -> io::Result<()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> tests/ui/doc_errors.rs:56:5
+  --> tests/ui/doc_errors.rs:59:5
    |
 LL |     pub fn pub_method_missing_errors_header() -> Result<(), ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> tests/ui/doc_errors.rs:62:5
+  --> tests/ui/doc_errors.rs:66:5
    |
 LL |     pub async fn async_pub_method_missing_errors_header() -> Result<(), ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function returning `Result` missing `# Errors` section
-  --> tests/ui/doc_errors.rs:113:5
+  --> tests/ui/doc_errors.rs:118:5
    |
 LL |     fn trait_method_missing_errors_header() -> Result<(), ()>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/doc_link_with_quotes.rs b/src/tools/clippy/tests/ui/doc_link_with_quotes.rs
index 48e1b1819c6f..0c0e273da6db 100644
--- a/src/tools/clippy/tests/ui/doc_link_with_quotes.rs
+++ b/src/tools/clippy/tests/ui/doc_link_with_quotes.rs
@@ -5,14 +5,13 @@ fn main() {
 }
 
 /// Calls ['bar'] uselessly
-//~^ ERROR: possible intra-doc link using quotes instead of backticks
-//~| NOTE: `-D clippy::doc-link-with-quotes` implied by `-D warnings`
+//~^ doc_link_with_quotes
 pub fn foo() {
     bar()
 }
 
 /// Calls ["bar"] uselessly
-//~^ ERROR: possible intra-doc link using quotes instead of backticks
+//~^ doc_link_with_quotes
 pub fn foo2() {
     bar()
 }
diff --git a/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr b/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr
index e4be59c65719..47c60390310c 100644
--- a/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr
+++ b/src/tools/clippy/tests/ui/doc_link_with_quotes.stderr
@@ -8,7 +8,7 @@ LL | /// Calls ['bar'] uselessly
    = help: to override `-D warnings` add `#[allow(clippy::doc_link_with_quotes)]`
 
 error: possible intra-doc link using quotes instead of backticks
-  --> tests/ui/doc_link_with_quotes.rs:14:12
+  --> tests/ui/doc_link_with_quotes.rs:13:12
    |
 LL | /// Calls ["bar"] uselessly
    |            ^^^^^
diff --git a/src/tools/clippy/tests/ui/doc_unsafe.rs b/src/tools/clippy/tests/ui/doc_unsafe.rs
index f7f41c915e3f..1bdf01e4e22e 100644
--- a/src/tools/clippy/tests/ui/doc_unsafe.rs
+++ b/src/tools/clippy/tests/ui/doc_unsafe.rs
@@ -7,6 +7,7 @@ use proc_macros::external;
 
 /// This is not sufficiently documented
 pub unsafe fn destroy_the_planet() {
+    //~^ missing_safety_doc
     unimplemented!();
 }
 
@@ -30,6 +31,7 @@ mod private_mod {
     }
 
     pub unsafe fn republished() {
+        //~^ missing_safety_doc
         unimplemented!();
     }
 }
@@ -38,12 +40,14 @@ pub use private_mod::republished;
 
 pub trait SafeTraitUnsafeMethods {
     unsafe fn woefully_underdocumented(self);
+    //~^ missing_safety_doc
 
     /// # Safety
     unsafe fn at_least_somewhat_documented(self);
 }
 
 pub unsafe trait UnsafeTrait {
+    //~^ missing_safety_doc
     fn method();
 }
 
@@ -74,6 +78,7 @@ unsafe impl DocumentedUnsafeTrait for Struct {
 
 impl Struct {
     pub unsafe fn more_undocumented_unsafe() -> Self {
+        //~^ missing_safety_doc
         unimplemented!();
     }
 
@@ -90,6 +95,7 @@ impl Struct {
 macro_rules! very_unsafe {
     () => {
         pub unsafe fn whee() {
+            //~^ missing_safety_doc
             unimplemented!()
         }
 
diff --git a/src/tools/clippy/tests/ui/doc_unsafe.stderr b/src/tools/clippy/tests/ui/doc_unsafe.stderr
index 929afbceb879..6e128133d498 100644
--- a/src/tools/clippy/tests/ui/doc_unsafe.stderr
+++ b/src/tools/clippy/tests/ui/doc_unsafe.stderr
@@ -8,31 +8,31 @@ LL | pub unsafe fn destroy_the_planet() {
    = help: to override `-D warnings` add `#[allow(clippy::missing_safety_doc)]`
 
 error: unsafe function's docs are missing a `# Safety` section
-  --> tests/ui/doc_unsafe.rs:32:5
+  --> tests/ui/doc_unsafe.rs:33:5
    |
 LL |     pub unsafe fn republished() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe function's docs are missing a `# Safety` section
-  --> tests/ui/doc_unsafe.rs:40:5
+  --> tests/ui/doc_unsafe.rs:42:5
    |
 LL |     unsafe fn woefully_underdocumented(self);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for unsafe trait missing `# Safety` section
-  --> tests/ui/doc_unsafe.rs:46:1
+  --> tests/ui/doc_unsafe.rs:49:1
    |
 LL | pub unsafe trait UnsafeTrait {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe function's docs are missing a `# Safety` section
-  --> tests/ui/doc_unsafe.rs:76:5
+  --> tests/ui/doc_unsafe.rs:80:5
    |
 LL |     pub unsafe fn more_undocumented_unsafe() -> Self {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: unsafe function's docs are missing a `# Safety` section
-  --> tests/ui/doc_unsafe.rs:92:9
+  --> tests/ui/doc_unsafe.rs:97:9
    |
 LL |         pub unsafe fn whee() {
    |         ^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/double_comparison.fixed b/src/tools/clippy/tests/ui/double_comparison.fixed
index 788f3224b418..685e3319bf9a 100644
--- a/src/tools/clippy/tests/ui/double_comparison.fixed
+++ b/src/tools/clippy/tests/ui/double_comparison.fixed
@@ -4,27 +4,35 @@ fn main() {
     let x = 1;
     let y = 2;
     if x <= y {
+        //~^ double_comparisons
         // do something
     }
     if x <= y {
+        //~^ double_comparisons
         // do something
     }
     if x >= y {
+        //~^ double_comparisons
         // do something
     }
     if x >= y {
+        //~^ double_comparisons
         // do something
     }
     if x != y {
+        //~^ double_comparisons
         // do something
     }
     if x != y {
+        //~^ double_comparisons
         // do something
     }
     if x == y {
+        //~^ double_comparisons
         // do something
     }
     if x == y {
+        //~^ double_comparisons
         // do something
     }
 }
diff --git a/src/tools/clippy/tests/ui/double_comparison.rs b/src/tools/clippy/tests/ui/double_comparison.rs
index 245a83d5709d..3670a050e88d 100644
--- a/src/tools/clippy/tests/ui/double_comparison.rs
+++ b/src/tools/clippy/tests/ui/double_comparison.rs
@@ -4,27 +4,35 @@ fn main() {
     let x = 1;
     let y = 2;
     if x == y || x < y {
+        //~^ double_comparisons
         // do something
     }
     if x < y || x == y {
+        //~^ double_comparisons
         // do something
     }
     if x == y || x > y {
+        //~^ double_comparisons
         // do something
     }
     if x > y || x == y {
+        //~^ double_comparisons
         // do something
     }
     if x < y || x > y {
+        //~^ double_comparisons
         // do something
     }
     if x > y || x < y {
+        //~^ double_comparisons
         // do something
     }
     if x <= y && x >= y {
+        //~^ double_comparisons
         // do something
     }
     if x >= y && x <= y {
+        //~^ double_comparisons
         // do something
     }
 }
diff --git a/src/tools/clippy/tests/ui/double_comparison.stderr b/src/tools/clippy/tests/ui/double_comparison.stderr
index 01ba7a8ee108..984614c203eb 100644
--- a/src/tools/clippy/tests/ui/double_comparison.stderr
+++ b/src/tools/clippy/tests/ui/double_comparison.stderr
@@ -8,43 +8,43 @@ LL |     if x == y || x < y {
    = help: to override `-D warnings` add `#[allow(clippy::double_comparisons)]`
 
 error: this binary expression can be simplified
-  --> tests/ui/double_comparison.rs:9:8
+  --> tests/ui/double_comparison.rs:10:8
    |
 LL |     if x < y || x == y {
    |        ^^^^^^^^^^^^^^^ help: try: `x <= y`
 
 error: this binary expression can be simplified
-  --> tests/ui/double_comparison.rs:12:8
+  --> tests/ui/double_comparison.rs:14:8
    |
 LL |     if x == y || x > y {
    |        ^^^^^^^^^^^^^^^ help: try: `x >= y`
 
 error: this binary expression can be simplified
-  --> tests/ui/double_comparison.rs:15:8
+  --> tests/ui/double_comparison.rs:18:8
    |
 LL |     if x > y || x == y {
    |        ^^^^^^^^^^^^^^^ help: try: `x >= y`
 
 error: this binary expression can be simplified
-  --> tests/ui/double_comparison.rs:18:8
+  --> tests/ui/double_comparison.rs:22:8
    |
 LL |     if x < y || x > y {
    |        ^^^^^^^^^^^^^^ help: try: `x != y`
 
 error: this binary expression can be simplified
-  --> tests/ui/double_comparison.rs:21:8
+  --> tests/ui/double_comparison.rs:26:8
    |
 LL |     if x > y || x < y {
    |        ^^^^^^^^^^^^^^ help: try: `x != y`
 
 error: this binary expression can be simplified
-  --> tests/ui/double_comparison.rs:24:8
+  --> tests/ui/double_comparison.rs:30:8
    |
 LL |     if x <= y && x >= y {
    |        ^^^^^^^^^^^^^^^^ help: try: `x == y`
 
 error: this binary expression can be simplified
-  --> tests/ui/double_comparison.rs:27:8
+  --> tests/ui/double_comparison.rs:34:8
    |
 LL |     if x >= y && x <= y {
    |        ^^^^^^^^^^^^^^^^ help: try: `x == y`
diff --git a/src/tools/clippy/tests/ui/double_ended_iterator_last.fixed b/src/tools/clippy/tests/ui/double_ended_iterator_last.fixed
index 06c48e337537..17d0d71a8854 100644
--- a/src/tools/clippy/tests/ui/double_ended_iterator_last.fixed
+++ b/src/tools/clippy/tests/ui/double_ended_iterator_last.fixed
@@ -2,7 +2,7 @@
 
 // Typical case
 pub fn last_arg(s: &str) -> Option<&str> {
-    s.split(' ').next_back()
+    s.split(' ').next_back() //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
 }
 
 fn main() {
@@ -19,7 +19,7 @@ fn main() {
             Some(())
         }
     }
-    let _ = DeIterator.next_back();
+    let _ = DeIterator.next_back(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
     // Should not apply to other methods of Iterator
     let _ = DeIterator.count();
 
@@ -51,3 +51,42 @@ fn main() {
     }
     let _ = CustomLast.last();
 }
+
+fn issue_14139() {
+    let mut index = [true, true, false, false, false, true].iter();
+    let mut subindex = index.by_ref().take(3);
+    let _ = subindex.next_back(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let mut subindex = index.by_ref().take(3);
+    let _ = subindex.next_back(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let mut subindex = index.by_ref().take(3);
+    let subindex = &mut subindex;
+    let _ = subindex.next_back(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let mut subindex = index.by_ref().take(3);
+    let subindex = &mut subindex;
+    let _ = subindex.next_back(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let (mut subindex, _) = (index.by_ref().take(3), 42);
+    let _ = subindex.next_back(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+}
+
+fn drop_order() {
+    struct S(&'static str);
+    impl std::ops::Drop for S {
+        fn drop(&mut self) {
+            println!("Dropping {}", self.0);
+        }
+    }
+
+    let v = vec![S("one"), S("two"), S("three")];
+    let mut v = v.into_iter();
+    println!("Last element is {}", v.next_back().unwrap().0);
+    //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+    println!("Done");
+}
diff --git a/src/tools/clippy/tests/ui/double_ended_iterator_last.rs b/src/tools/clippy/tests/ui/double_ended_iterator_last.rs
index 9c13b496d117..41bc669b1719 100644
--- a/src/tools/clippy/tests/ui/double_ended_iterator_last.rs
+++ b/src/tools/clippy/tests/ui/double_ended_iterator_last.rs
@@ -2,7 +2,7 @@
 
 // Typical case
 pub fn last_arg(s: &str) -> Option<&str> {
-    s.split(' ').last()
+    s.split(' ').last() //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
 }
 
 fn main() {
@@ -19,7 +19,7 @@ fn main() {
             Some(())
         }
     }
-    let _ = DeIterator.last();
+    let _ = DeIterator.last(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
     // Should not apply to other methods of Iterator
     let _ = DeIterator.count();
 
@@ -51,3 +51,42 @@ fn main() {
     }
     let _ = CustomLast.last();
 }
+
+fn issue_14139() {
+    let mut index = [true, true, false, false, false, true].iter();
+    let subindex = index.by_ref().take(3);
+    let _ = subindex.last(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let mut subindex = index.by_ref().take(3);
+    let _ = subindex.last(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let mut subindex = index.by_ref().take(3);
+    let subindex = &mut subindex;
+    let _ = subindex.last(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let mut subindex = index.by_ref().take(3);
+    let subindex = &mut subindex;
+    let _ = subindex.last(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+
+    let mut index = [true, true, false, false, false, true].iter();
+    let (subindex, _) = (index.by_ref().take(3), 42);
+    let _ = subindex.last(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+}
+
+fn drop_order() {
+    struct S(&'static str);
+    impl std::ops::Drop for S {
+        fn drop(&mut self) {
+            println!("Dropping {}", self.0);
+        }
+    }
+
+    let v = vec![S("one"), S("two"), S("three")];
+    let v = v.into_iter();
+    println!("Last element is {}", v.last().unwrap().0);
+    //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+    println!("Done");
+}
diff --git a/src/tools/clippy/tests/ui/double_ended_iterator_last.stderr b/src/tools/clippy/tests/ui/double_ended_iterator_last.stderr
index b795c18a736e..1702a24d7a05 100644
--- a/src/tools/clippy/tests/ui/double_ended_iterator_last.stderr
+++ b/src/tools/clippy/tests/ui/double_ended_iterator_last.stderr
@@ -1,17 +1,82 @@
 error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
-  --> tests/ui/double_ended_iterator_last.rs:5:18
+  --> tests/ui/double_ended_iterator_last.rs:5:5
    |
 LL |     s.split(' ').last()
-   |                  ^^^^^^ help: try: `next_back()`
+   |     ^^^^^^^^^^^^^------
+   |                  |
+   |                  help: try: `next_back()`
    |
    = note: `-D clippy::double-ended-iterator-last` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::double_ended_iterator_last)]`
 
 error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
-  --> tests/ui/double_ended_iterator_last.rs:22:24
+  --> tests/ui/double_ended_iterator_last.rs:22:13
    |
 LL |     let _ = DeIterator.last();
-   |                        ^^^^^^ help: try: `next_back()`
+   |             ^^^^^^^^^^^------
+   |                        |
+   |                        help: try: `next_back()`
 
-error: aborting due to 2 previous errors
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last.rs:58:13
+   |
+LL |     let _ = subindex.last();
+   |             ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     let mut subindex = index.by_ref().take(3);
+LL ~     let _ = subindex.next_back();
+   |
+
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last.rs:62:13
+   |
+LL |     let _ = subindex.last();
+   |             ^^^^^^^^^------
+   |                      |
+   |                      help: try: `next_back()`
+
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last.rs:67:13
+   |
+LL |     let _ = subindex.last();
+   |             ^^^^^^^^^------
+   |                      |
+   |                      help: try: `next_back()`
+
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last.rs:72:13
+   |
+LL |     let _ = subindex.last();
+   |             ^^^^^^^^^------
+   |                      |
+   |                      help: try: `next_back()`
+
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last.rs:76:13
+   |
+LL |     let _ = subindex.last();
+   |             ^^^^^^^^^^^^^^^
+   |
+help: try
+   |
+LL ~     let (mut subindex, _) = (index.by_ref().take(3), 42);
+LL ~     let _ = subindex.next_back();
+   |
+
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last.rs:89:36
+   |
+LL |     println!("Last element is {}", v.last().unwrap().0);
+   |                                    ^^^^^^^^
+   |
+   = note: this change will alter drop order which may be undesirable
+help: try
+   |
+LL ~     let mut v = v.into_iter();
+LL ~     println!("Last element is {}", v.next_back().unwrap().0);
+   |
+
+error: aborting due to 8 previous errors
 
diff --git a/src/tools/clippy/tests/ui/double_ended_iterator_last_unfixable.rs b/src/tools/clippy/tests/ui/double_ended_iterator_last_unfixable.rs
new file mode 100644
index 000000000000..3f125c7f20c1
--- /dev/null
+++ b/src/tools/clippy/tests/ui/double_ended_iterator_last_unfixable.rs
@@ -0,0 +1,23 @@
+//@no-rustfix
+#![warn(clippy::double_ended_iterator_last)]
+
+fn main() {
+    let mut index = [true, true, false, false, false, true].iter();
+    let subindex = (index.by_ref().take(3), 42);
+    let _ = subindex.0.last(); //~ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+}
+
+fn drop_order() {
+    struct S(&'static str);
+    impl std::ops::Drop for S {
+        fn drop(&mut self) {
+            println!("Dropping {}", self.0);
+        }
+    }
+
+    let v = vec![S("one"), S("two"), S("three")];
+    let v = (v.into_iter(), 42);
+    println!("Last element is {}", v.0.last().unwrap().0);
+    //~^ ERROR: called `Iterator::last` on a `DoubleEndedIterator`
+    println!("Done");
+}
diff --git a/src/tools/clippy/tests/ui/double_ended_iterator_last_unfixable.stderr b/src/tools/clippy/tests/ui/double_ended_iterator_last_unfixable.stderr
new file mode 100644
index 000000000000..f4be757d00d2
--- /dev/null
+++ b/src/tools/clippy/tests/ui/double_ended_iterator_last_unfixable.stderr
@@ -0,0 +1,33 @@
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last_unfixable.rs:7:13
+   |
+LL |     let _ = subindex.0.last();
+   |             ^^^^^^^^^^^------
+   |                        |
+   |                        help: try: `next_back()`
+   |
+note: this must be made mutable to use `.next_back()`
+  --> tests/ui/double_ended_iterator_last_unfixable.rs:7:13
+   |
+LL |     let _ = subindex.0.last();
+   |             ^^^^^^^^^^
+   = note: `-D clippy::double-ended-iterator-last` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::double_ended_iterator_last)]`
+
+error: called `Iterator::last` on a `DoubleEndedIterator`; this will needlessly iterate the entire iterator
+  --> tests/ui/double_ended_iterator_last_unfixable.rs:20:36
+   |
+LL |     println!("Last element is {}", v.0.last().unwrap().0);
+   |                                    ^^^^------
+   |                                        |
+   |                                        help: try: `next_back()`
+   |
+   = note: this change will alter drop order which may be undesirable
+note: this must be made mutable to use `.next_back()`
+  --> tests/ui/double_ended_iterator_last_unfixable.rs:20:36
+   |
+LL |     println!("Last element is {}", v.0.last().unwrap().0);
+   |                                    ^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/src/tools/clippy/tests/ui/double_must_use.rs b/src/tools/clippy/tests/ui/double_must_use.rs
index 4460aeb075bf..3d4aaa9baa49 100644
--- a/src/tools/clippy/tests/ui/double_must_use.rs
+++ b/src/tools/clippy/tests/ui/double_must_use.rs
@@ -3,19 +3,22 @@
 
 #[must_use]
 pub fn must_use_result() -> Result<(), ()> {
-    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
+    //~^ double_must_use
+
     unimplemented!();
 }
 
 #[must_use]
 pub fn must_use_tuple() -> (Result<(), ()>, u8) {
-    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
+    //~^ double_must_use
+
     unimplemented!();
 }
 
 #[must_use]
 pub fn must_use_array() -> [Result<(), ()>; 1] {
-    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
+    //~^ double_must_use
+
     unimplemented!();
 }
 
@@ -32,7 +35,8 @@ async fn async_must_use() -> usize {
 
 #[must_use]
 async fn async_must_use_result() -> Result<(), ()> {
-    //~^ ERROR: this function has a `#[must_use]` attribute with no message, but returns a type already
+    //~^ double_must_use
+
     Ok(())
 }
 
diff --git a/src/tools/clippy/tests/ui/double_must_use.stderr b/src/tools/clippy/tests/ui/double_must_use.stderr
index b26d1e48a8b8..555dd8902cac 100644
--- a/src/tools/clippy/tests/ui/double_must_use.stderr
+++ b/src/tools/clippy/tests/ui/double_must_use.stderr
@@ -9,7 +9,7 @@ LL | pub fn must_use_result() -> Result<(), ()> {
    = help: to override `-D warnings` add `#[allow(clippy::double_must_use)]`
 
 error: this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`
-  --> tests/ui/double_must_use.rs:11:1
+  --> tests/ui/double_must_use.rs:12:1
    |
 LL | pub fn must_use_tuple() -> (Result<(), ()>, u8) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | pub fn must_use_tuple() -> (Result<(), ()>, u8) {
    = help: either add some descriptive message or remove the attribute
 
 error: this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`
-  --> tests/ui/double_must_use.rs:17:1
+  --> tests/ui/double_must_use.rs:19:1
    |
 LL | pub fn must_use_array() -> [Result<(), ()>; 1] {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | pub fn must_use_array() -> [Result<(), ()>; 1] {
    = help: either add some descriptive message or remove the attribute
 
 error: this function has a `#[must_use]` attribute with no message, but returns a type already marked as `#[must_use]`
-  --> tests/ui/double_must_use.rs:34:1
+  --> tests/ui/double_must_use.rs:37:1
    |
 LL | async fn async_must_use_result() -> Result<(), ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/double_parens.rs b/src/tools/clippy/tests/ui/double_parens.rs
index ab1459eed48b..7c976015b4e7 100644
--- a/src/tools/clippy/tests/ui/double_parens.rs
+++ b/src/tools/clippy/tests/ui/double_parens.rs
@@ -13,28 +13,33 @@ impl DummyStruct {
 
 fn simple_double_parens() -> i32 {
     ((0))
-    //~^ ERROR: consider removing unnecessary double parentheses
-    //~| NOTE: `-D clippy::double-parens` implied by `-D warnings`
+    //~^ double_parens
+
+
 }
 
 fn fn_double_parens() {
     dummy_fn((0));
-    //~^ ERROR: consider removing unnecessary double parentheses
+    //~^ double_parens
+
 }
 
 fn method_double_parens(x: DummyStruct) {
     x.dummy_method((0));
-    //~^ ERROR: consider removing unnecessary double parentheses
+    //~^ double_parens
+
 }
 
 fn tuple_double_parens() -> (i32, i32) {
     ((1, 2))
-    //~^ ERROR: consider removing unnecessary double parentheses
+    //~^ double_parens
+
 }
 
 fn unit_double_parens() {
     (())
-    //~^ ERROR: consider removing unnecessary double parentheses
+    //~^ double_parens
+
 }
 
 fn fn_tuple_ok() {
@@ -57,7 +62,8 @@ fn method_unit_ok(x: DummyStruct) {
 fn inside_macro() {
     assert_eq!((1, 2), (1, 2), "Error");
     assert_eq!(((1, 2)), (1, 2), "Error");
-    //~^ ERROR: consider removing unnecessary double parentheses
+    //~^ double_parens
+
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/double_parens.stderr b/src/tools/clippy/tests/ui/double_parens.stderr
index aba301e9f072..e119f54949b1 100644
--- a/src/tools/clippy/tests/ui/double_parens.stderr
+++ b/src/tools/clippy/tests/ui/double_parens.stderr
@@ -8,31 +8,31 @@ LL |     ((0))
    = help: to override `-D warnings` add `#[allow(clippy::double_parens)]`
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:21:14
+  --> tests/ui/double_parens.rs:22:14
    |
 LL |     dummy_fn((0));
    |              ^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:26:20
+  --> tests/ui/double_parens.rs:28:20
    |
 LL |     x.dummy_method((0));
    |                    ^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:31:5
+  --> tests/ui/double_parens.rs:34:5
    |
 LL |     ((1, 2))
    |     ^^^^^^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:36:5
+  --> tests/ui/double_parens.rs:40:5
    |
 LL |     (())
    |     ^^^^
 
 error: consider removing unnecessary double parentheses
-  --> tests/ui/double_parens.rs:59:16
+  --> tests/ui/double_parens.rs:64:16
    |
 LL |     assert_eq!(((1, 2)), (1, 2), "Error");
    |                ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/drain_collect.fixed b/src/tools/clippy/tests/ui/drain_collect.fixed
index 6f597243fe6f..7ae971d975b1 100644
--- a/src/tools/clippy/tests/ui/drain_collect.fixed
+++ b/src/tools/clippy/tests/ui/drain_collect.fixed
@@ -5,6 +5,7 @@ use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
 fn binaryheap(b: &mut BinaryHeap<i32>) -> BinaryHeap<i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn binaryheap_dont_lint(b: &mut BinaryHeap<i32>) -> HashSet<i32> {
@@ -13,6 +14,7 @@ fn binaryheap_dont_lint(b: &mut BinaryHeap<i32>) -> HashSet<i32> {
 
 fn hashmap(b: &mut HashMap<i32, i32>) -> HashMap<i32, i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn hashmap_dont_lint(b: &mut HashMap<i32, i32>) -> Vec<(i32, i32)> {
@@ -21,6 +23,7 @@ fn hashmap_dont_lint(b: &mut HashMap<i32, i32>) -> Vec<(i32, i32)> {
 
 fn hashset(b: &mut HashSet<i32>) -> HashSet<i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn hashset_dont_lint(b: &mut HashSet<i32>) -> Vec<i32> {
@@ -29,6 +32,7 @@ fn hashset_dont_lint(b: &mut HashSet<i32>) -> Vec<i32> {
 
 fn vecdeque(b: &mut VecDeque<i32>) -> VecDeque<i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn vecdeque_dont_lint(b: &mut VecDeque<i32>) -> HashSet<i32> {
@@ -37,23 +41,28 @@ fn vecdeque_dont_lint(b: &mut VecDeque<i32>) -> HashSet<i32> {
 
 fn vec(b: &mut Vec<i32>) -> Vec<i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn vec2(b: &mut Vec<i32>) -> Vec<i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn vec3(b: &mut Vec<i32>) -> Vec<i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn vec4(b: &mut Vec<i32>) -> Vec<i32> {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn vec_no_reborrow() -> Vec<i32> {
     let mut b = vec![1, 2, 3];
     std::mem::take(&mut b)
+    //~^ drain_collect
 }
 
 fn vec_dont_lint(b: &mut Vec<i32>) -> HashSet<i32> {
@@ -62,6 +71,7 @@ fn vec_dont_lint(b: &mut Vec<i32>) -> HashSet<i32> {
 
 fn string(b: &mut String) -> String {
     std::mem::take(b)
+    //~^ drain_collect
 }
 
 fn string_dont_lint(b: &mut String) -> HashSet<char> {
diff --git a/src/tools/clippy/tests/ui/drain_collect.rs b/src/tools/clippy/tests/ui/drain_collect.rs
index 353aac4da9a4..e99d84fa8b66 100644
--- a/src/tools/clippy/tests/ui/drain_collect.rs
+++ b/src/tools/clippy/tests/ui/drain_collect.rs
@@ -5,6 +5,7 @@ use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 
 fn binaryheap(b: &mut BinaryHeap<i32>) -> BinaryHeap<i32> {
     b.drain().collect()
+    //~^ drain_collect
 }
 
 fn binaryheap_dont_lint(b: &mut BinaryHeap<i32>) -> HashSet<i32> {
@@ -13,6 +14,7 @@ fn binaryheap_dont_lint(b: &mut BinaryHeap<i32>) -> HashSet<i32> {
 
 fn hashmap(b: &mut HashMap<i32, i32>) -> HashMap<i32, i32> {
     b.drain().collect()
+    //~^ drain_collect
 }
 
 fn hashmap_dont_lint(b: &mut HashMap<i32, i32>) -> Vec<(i32, i32)> {
@@ -21,6 +23,7 @@ fn hashmap_dont_lint(b: &mut HashMap<i32, i32>) -> Vec<(i32, i32)> {
 
 fn hashset(b: &mut HashSet<i32>) -> HashSet<i32> {
     b.drain().collect()
+    //~^ drain_collect
 }
 
 fn hashset_dont_lint(b: &mut HashSet<i32>) -> Vec<i32> {
@@ -29,6 +32,7 @@ fn hashset_dont_lint(b: &mut HashSet<i32>) -> Vec<i32> {
 
 fn vecdeque(b: &mut VecDeque<i32>) -> VecDeque<i32> {
     b.drain(..).collect()
+    //~^ drain_collect
 }
 
 fn vecdeque_dont_lint(b: &mut VecDeque<i32>) -> HashSet<i32> {
@@ -37,23 +41,28 @@ fn vecdeque_dont_lint(b: &mut VecDeque<i32>) -> HashSet<i32> {
 
 fn vec(b: &mut Vec<i32>) -> Vec<i32> {
     b.drain(..).collect()
+    //~^ drain_collect
 }
 
 fn vec2(b: &mut Vec<i32>) -> Vec<i32> {
     b.drain(0..).collect()
+    //~^ drain_collect
 }
 
 fn vec3(b: &mut Vec<i32>) -> Vec<i32> {
     b.drain(..b.len()).collect()
+    //~^ drain_collect
 }
 
 fn vec4(b: &mut Vec<i32>) -> Vec<i32> {
     b.drain(0..b.len()).collect()
+    //~^ drain_collect
 }
 
 fn vec_no_reborrow() -> Vec<i32> {
     let mut b = vec![1, 2, 3];
     b.drain(..).collect()
+    //~^ drain_collect
 }
 
 fn vec_dont_lint(b: &mut Vec<i32>) -> HashSet<i32> {
@@ -62,6 +71,7 @@ fn vec_dont_lint(b: &mut Vec<i32>) -> HashSet<i32> {
 
 fn string(b: &mut String) -> String {
     b.drain(..).collect()
+    //~^ drain_collect
 }
 
 fn string_dont_lint(b: &mut String) -> HashSet<char> {
diff --git a/src/tools/clippy/tests/ui/drain_collect.stderr b/src/tools/clippy/tests/ui/drain_collect.stderr
index 1dfd0f1e3463..cfb1e01b65cf 100644
--- a/src/tools/clippy/tests/ui/drain_collect.stderr
+++ b/src/tools/clippy/tests/ui/drain_collect.stderr
@@ -11,25 +11,19 @@ LL | #![deny(clippy::drain_collect)]
    |         ^^^^^^^^^^^^^^^^^^^^^
 
 error: you seem to be trying to move all elements into a new `HashMap`
-  --> tests/ui/drain_collect.rs:15:5
+  --> tests/ui/drain_collect.rs:16:5
    |
 LL |     b.drain().collect()
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `HashSet`
-  --> tests/ui/drain_collect.rs:23:5
+  --> tests/ui/drain_collect.rs:25:5
    |
 LL |     b.drain().collect()
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> tests/ui/drain_collect.rs:31:5
-   |
-LL |     b.drain(..).collect()
-   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
-
-error: you seem to be trying to move all elements into a new `Vec`
-  --> tests/ui/drain_collect.rs:39:5
+  --> tests/ui/drain_collect.rs:34:5
    |
 LL |     b.drain(..).collect()
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
@@ -37,29 +31,35 @@ LL |     b.drain(..).collect()
 error: you seem to be trying to move all elements into a new `Vec`
   --> tests/ui/drain_collect.rs:43:5
    |
+LL |     b.drain(..).collect()
+   |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
+
+error: you seem to be trying to move all elements into a new `Vec`
+  --> tests/ui/drain_collect.rs:48:5
+   |
 LL |     b.drain(0..).collect()
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> tests/ui/drain_collect.rs:47:5
+  --> tests/ui/drain_collect.rs:53:5
    |
 LL |     b.drain(..b.len()).collect()
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> tests/ui/drain_collect.rs:51:5
+  --> tests/ui/drain_collect.rs:58:5
    |
 LL |     b.drain(0..b.len()).collect()
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
 
 error: you seem to be trying to move all elements into a new `Vec`
-  --> tests/ui/drain_collect.rs:56:5
+  --> tests/ui/drain_collect.rs:64:5
    |
 LL |     b.drain(..).collect()
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(&mut b)`
 
 error: you seem to be trying to move all elements into a new `String`
-  --> tests/ui/drain_collect.rs:64:5
+  --> tests/ui/drain_collect.rs:73:5
    |
 LL |     b.drain(..).collect()
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using `mem::take`: `std::mem::take(b)`
diff --git a/src/tools/clippy/tests/ui/drain_collect_nostd.fixed b/src/tools/clippy/tests/ui/drain_collect_nostd.fixed
index a4ab2956f2a6..4741922d1dc4 100644
--- a/src/tools/clippy/tests/ui/drain_collect_nostd.fixed
+++ b/src/tools/clippy/tests/ui/drain_collect_nostd.fixed
@@ -5,4 +5,5 @@ use alloc::vec::Vec;
 
 fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
     core::mem::take(v)
+    //~^ drain_collect
 }
diff --git a/src/tools/clippy/tests/ui/drain_collect_nostd.rs b/src/tools/clippy/tests/ui/drain_collect_nostd.rs
index a8be1ce6bbd3..69dcb1c41658 100644
--- a/src/tools/clippy/tests/ui/drain_collect_nostd.rs
+++ b/src/tools/clippy/tests/ui/drain_collect_nostd.rs
@@ -5,4 +5,5 @@ use alloc::vec::Vec;
 
 fn remove_all(v: &mut Vec<i32>) -> Vec<i32> {
     v.drain(..).collect()
+    //~^ drain_collect
 }
diff --git a/src/tools/clippy/tests/ui/drop_non_drop.rs b/src/tools/clippy/tests/ui/drop_non_drop.rs
index 6dbcb7777d49..0345e8670ab8 100644
--- a/src/tools/clippy/tests/ui/drop_non_drop.rs
+++ b/src/tools/clippy/tests/ui/drop_non_drop.rs
@@ -20,7 +20,8 @@ fn main() {
     struct Foo;
     // Lint
     drop(Foo);
-    //~^ ERROR: call to `std::mem::drop` with a value that does not implement `Drop`. Drop
+    //~^ drop_non_drop
+
     // Don't lint
     drop(make_result(Foo));
     // Don't lint
@@ -36,7 +37,8 @@ fn main() {
     struct Baz<T>(T);
     // Lint
     drop(Baz(Foo));
-    //~^ ERROR: call to `std::mem::drop` with a value that does not implement `Drop`. Drop
+    //~^ drop_non_drop
+
     // Don't lint
     drop(Baz(Bar));
 }
diff --git a/src/tools/clippy/tests/ui/drop_non_drop.stderr b/src/tools/clippy/tests/ui/drop_non_drop.stderr
index fac89bf1f26a..b431c62c92c5 100644
--- a/src/tools/clippy/tests/ui/drop_non_drop.stderr
+++ b/src/tools/clippy/tests/ui/drop_non_drop.stderr
@@ -13,13 +13,13 @@ LL |     drop(Foo);
    = help: to override `-D warnings` add `#[allow(clippy::drop_non_drop)]`
 
 error: call to `std::mem::drop` with a value that does not implement `Drop`. Dropping such a type only extends its contained lifetimes
-  --> tests/ui/drop_non_drop.rs:38:5
+  --> tests/ui/drop_non_drop.rs:39:5
    |
 LL |     drop(Baz(Foo));
    |     ^^^^^^^^^^^^^^
    |
 note: argument has type `main::Baz<main::Foo>`
-  --> tests/ui/drop_non_drop.rs:38:10
+  --> tests/ui/drop_non_drop.rs:39:10
    |
 LL |     drop(Baz(Foo));
    |          ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/duplicate_underscore_argument.rs b/src/tools/clippy/tests/ui/duplicate_underscore_argument.rs
index a725538436cb..b71f5a20a843 100644
--- a/src/tools/clippy/tests/ui/duplicate_underscore_argument.rs
+++ b/src/tools/clippy/tests/ui/duplicate_underscore_argument.rs
@@ -1,8 +1,8 @@
 #![warn(clippy::duplicate_underscore_argument)]
 
 fn join_the_dark_side(darth: i32, _darth: i32) {}
-//~^ ERROR: `darth` already exists, having another argument having almost the same name ma
-//~| NOTE: `-D clippy::duplicate-underscore-argument` implied by `-D warnings`
+//~^ duplicate_underscore_argument
+
 fn join_the_light_side(knight: i32, _master: i32) {} // the Force is strong with this one
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/duration_subsec.fixed b/src/tools/clippy/tests/ui/duration_subsec.fixed
index 114c516ed1a1..a8c2f78ca383 100644
--- a/src/tools/clippy/tests/ui/duration_subsec.fixed
+++ b/src/tools/clippy/tests/ui/duration_subsec.fixed
@@ -7,21 +7,26 @@ fn main() {
     let dur = Duration::new(5, 0);
 
     let bad_millis_1 = dur.subsec_millis();
+    //~^ duration_subsec
     let bad_millis_2 = dur.subsec_millis();
+    //~^ duration_subsec
     let good_millis = dur.subsec_millis();
     assert_eq!(bad_millis_1, good_millis);
     assert_eq!(bad_millis_2, good_millis);
 
     let bad_micros = dur.subsec_micros();
+    //~^ duration_subsec
     let good_micros = dur.subsec_micros();
     assert_eq!(bad_micros, good_micros);
 
     // Handle refs
     let _ = (&dur).subsec_micros();
+    //~^ duration_subsec
 
     // Handle constants
     const NANOS_IN_MICRO: u32 = 1_000;
     let _ = dur.subsec_micros();
+    //~^ duration_subsec
 
     // Other literals aren't linted
     let _ = dur.subsec_nanos() / 699;
diff --git a/src/tools/clippy/tests/ui/duration_subsec.rs b/src/tools/clippy/tests/ui/duration_subsec.rs
index 8469fe086b10..582f4717de27 100644
--- a/src/tools/clippy/tests/ui/duration_subsec.rs
+++ b/src/tools/clippy/tests/ui/duration_subsec.rs
@@ -7,21 +7,26 @@ fn main() {
     let dur = Duration::new(5, 0);
 
     let bad_millis_1 = dur.subsec_micros() / 1_000;
+    //~^ duration_subsec
     let bad_millis_2 = dur.subsec_nanos() / 1_000_000;
+    //~^ duration_subsec
     let good_millis = dur.subsec_millis();
     assert_eq!(bad_millis_1, good_millis);
     assert_eq!(bad_millis_2, good_millis);
 
     let bad_micros = dur.subsec_nanos() / 1_000;
+    //~^ duration_subsec
     let good_micros = dur.subsec_micros();
     assert_eq!(bad_micros, good_micros);
 
     // Handle refs
     let _ = (&dur).subsec_nanos() / 1_000;
+    //~^ duration_subsec
 
     // Handle constants
     const NANOS_IN_MICRO: u32 = 1_000;
     let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
+    //~^ duration_subsec
 
     // Other literals aren't linted
     let _ = dur.subsec_nanos() / 699;
diff --git a/src/tools/clippy/tests/ui/duration_subsec.stderr b/src/tools/clippy/tests/ui/duration_subsec.stderr
index 55e44f149cf1..1a41742e1fa6 100644
--- a/src/tools/clippy/tests/ui/duration_subsec.stderr
+++ b/src/tools/clippy/tests/ui/duration_subsec.stderr
@@ -8,25 +8,25 @@ LL |     let bad_millis_1 = dur.subsec_micros() / 1_000;
    = help: to override `-D warnings` add `#[allow(clippy::duration_subsec)]`
 
 error: calling `subsec_millis()` is more concise than this calculation
-  --> tests/ui/duration_subsec.rs:10:24
+  --> tests/ui/duration_subsec.rs:11:24
    |
 LL |     let bad_millis_2 = dur.subsec_nanos() / 1_000_000;
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `dur.subsec_millis()`
 
 error: calling `subsec_micros()` is more concise than this calculation
-  --> tests/ui/duration_subsec.rs:15:22
+  --> tests/ui/duration_subsec.rs:17:22
    |
 LL |     let bad_micros = dur.subsec_nanos() / 1_000;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `dur.subsec_micros()`
 
 error: calling `subsec_micros()` is more concise than this calculation
-  --> tests/ui/duration_subsec.rs:20:13
+  --> tests/ui/duration_subsec.rs:23:13
    |
 LL |     let _ = (&dur).subsec_nanos() / 1_000;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&dur).subsec_micros()`
 
 error: calling `subsec_micros()` is more concise than this calculation
-  --> tests/ui/duration_subsec.rs:24:13
+  --> tests/ui/duration_subsec.rs:28:13
    |
 LL |     let _ = dur.subsec_nanos() / NANOS_IN_MICRO;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `dur.subsec_micros()`
diff --git a/src/tools/clippy/tests/ui/eager_transmute.fixed b/src/tools/clippy/tests/ui/eager_transmute.fixed
index ba4342462dca..14cbb6113e62 100644
--- a/src/tools/clippy/tests/ui/eager_transmute.fixed
+++ b/src/tools/clippy/tests/ui/eager_transmute.fixed
@@ -19,20 +19,27 @@ struct Data {
 
 fn int_to_opcode(op: u8) -> Option<Opcode> {
     (op < 4).then(|| unsafe { std::mem::transmute(op) })
+    //~^ eager_transmute
 }
 
 fn f(op: u8, op2: Data, unrelated: u8) {
     true.then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (unrelated < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op < 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+    //~^ eager_transmute
     (op > 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+    //~^ eager_transmute
     (op == 0).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
+    //~^ eager_transmute
 
     let _: Option<Opcode> = (op > 0 && op < 10).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
 
     // lint even when the transmutable goes through field/array accesses
     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then(|| unsafe { std::mem::transmute(op2.foo[0]) });
+    //~^ eager_transmute
 
     // don't lint: wrong index used in the transmute
     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[1]) });
@@ -45,11 +52,17 @@ fn f(op: u8, op2: Data, unrelated: u8) {
 
     // range contains checks
     let _: Option<Opcode> = (1..=3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (1..3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (1..).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (..3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (..=3).contains(&op).then(|| unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
 
     // unrelated binding in contains
     let _: Option<Opcode> = (1..=3)
@@ -59,6 +72,7 @@ fn f(op: u8, op2: Data, unrelated: u8) {
 
 unsafe fn f2(op: u8) {
     (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
+    //~^ eager_transmute
 }
 
 #[rustc_layout_scalar_valid_range_end(254)]
@@ -88,18 +102,21 @@ impls!(NonMaxU8, NonZeroNonMaxU8);
 fn niche_tests(v1: u8, v2: NonZero<u8>, v3: NonZeroNonMaxU8) {
     // u8 -> NonZero<u8>, do lint
     let _: Option<NonZero<u8>> = (v1 > 0).then(|| unsafe { std::mem::transmute(v1) });
+    //~^ eager_transmute
 
     // NonZero<u8> -> u8, don't lint, target type has no niche and therefore a higher validity range
     let _: Option<u8> = (v2 > NonZero::new(1u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
 
     // NonZero<u8> -> NonMaxU8, do lint, different niche
     let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+    //~^ eager_transmute
 
     // NonZeroNonMaxU8 -> NonMaxU8, don't lint, target type has more validity
     let _: Option<NonMaxU8> = (v3 < 255).then_some(unsafe { std::mem::transmute(v2) });
 
     // NonZero<u8> -> NonZeroNonMaxU8, do lint, target type has less validity
     let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| unsafe { std::mem::transmute(v2) });
+    //~^ eager_transmute
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/eager_transmute.rs b/src/tools/clippy/tests/ui/eager_transmute.rs
index 9750e87ce574..48d7d50cdaef 100644
--- a/src/tools/clippy/tests/ui/eager_transmute.rs
+++ b/src/tools/clippy/tests/ui/eager_transmute.rs
@@ -19,20 +19,27 @@ struct Data {
 
 fn int_to_opcode(op: u8) -> Option<Opcode> {
     (op < 4).then_some(unsafe { std::mem::transmute(op) })
+    //~^ eager_transmute
 }
 
 fn f(op: u8, op2: Data, unrelated: u8) {
     true.then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (unrelated < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
     (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    //~^ eager_transmute
     (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    //~^ eager_transmute
     (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
+    //~^ eager_transmute
 
     let _: Option<Opcode> = (op > 0 && op < 10).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
 
     // lint even when the transmutable goes through field/array accesses
     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[0]) });
+    //~^ eager_transmute
 
     // don't lint: wrong index used in the transmute
     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[1]) });
@@ -45,11 +52,17 @@ fn f(op: u8, op2: Data, unrelated: u8) {
 
     // range contains checks
     let _: Option<Opcode> = (1..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (1..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (1..).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
     let _: Option<Opcode> = (..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
+    //~^ eager_transmute
 
     // unrelated binding in contains
     let _: Option<Opcode> = (1..=3)
@@ -59,6 +72,7 @@ fn f(op: u8, op2: Data, unrelated: u8) {
 
 unsafe fn f2(op: u8) {
     (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));
+    //~^ eager_transmute
 }
 
 #[rustc_layout_scalar_valid_range_end(254)]
@@ -88,18 +102,21 @@ impls!(NonMaxU8, NonZeroNonMaxU8);
 fn niche_tests(v1: u8, v2: NonZero<u8>, v3: NonZeroNonMaxU8) {
     // u8 -> NonZero<u8>, do lint
     let _: Option<NonZero<u8>> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
+    //~^ eager_transmute
 
     // NonZero<u8> -> u8, don't lint, target type has no niche and therefore a higher validity range
     let _: Option<u8> = (v2 > NonZero::new(1u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
 
     // NonZero<u8> -> NonMaxU8, do lint, different niche
     let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+    //~^ eager_transmute
 
     // NonZeroNonMaxU8 -> NonMaxU8, don't lint, target type has more validity
     let _: Option<NonMaxU8> = (v3 < 255).then_some(unsafe { std::mem::transmute(v2) });
 
     // NonZero<u8> -> NonZeroNonMaxU8, do lint, target type has less validity
     let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
+    //~^ eager_transmute
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/eager_transmute.stderr b/src/tools/clippy/tests/ui/eager_transmute.stderr
index 68690c3730d8..54850d110eb2 100644
--- a/src/tools/clippy/tests/ui/eager_transmute.stderr
+++ b/src/tools/clippy/tests/ui/eager_transmute.stderr
@@ -13,7 +13,7 @@ LL +     (op < 4).then(|| unsafe { std::mem::transmute(op) })
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:27:33
+  --> tests/ui/eager_transmute.rs:28:33
    |
 LL |     (op < 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     (op < 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:28:33
+  --> tests/ui/eager_transmute.rs:30:33
    |
 LL |     (op > 4).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     (op > 4).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:29:34
+  --> tests/ui/eager_transmute.rs:32:34
    |
 LL |     (op == 0).then_some(unsafe { std::mem::transmute::<_, Opcode>(op) });
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     (op == 0).then(|| unsafe { std::mem::transmute::<_, Opcode>(op) });
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:31:68
+  --> tests/ui/eager_transmute.rs:35:68
    |
 LL |     let _: Option<Opcode> = (op > 0 && op < 10).then_some(unsafe { std::mem::transmute(op) });
    |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     let _: Option<Opcode> = (op > 0 && op < 10).then(|| unsafe { std::mem::
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:32:86
+  --> tests/ui/eager_transmute.rs:37:86
    |
 LL |     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then_some(unsafe { std::mem::transmute(op) });
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     let _: Option<Opcode> = (op > 0 && op < 10 && unrelated == 0).then(|| u
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:35:84
+  --> tests/ui/eager_transmute.rs:41:84
    |
 LL |     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then_some(unsafe { std::mem::transmute(op2.foo[0]) });
    |                                                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let _: Option<Opcode> = (op2.foo[0] > 0 && op2.foo[0] < 10).then(|| uns
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:47:70
+  --> tests/ui/eager_transmute.rs:54:70
    |
 LL |     let _: Option<Opcode> = (1..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let _: Option<Opcode> = (1..=3).contains(&op).then(|| unsafe { std::mem
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:48:83
+  --> tests/ui/eager_transmute.rs:56:83
    |
 LL |     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then_some(unsafe { std::mem::transmute(op) });
    |                                                                                   ^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let _: Option<Opcode> = ((1..=3).contains(&op) || op == 4).then(|| unsa
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:49:69
+  --> tests/ui/eager_transmute.rs:58:69
    |
 LL |     let _: Option<Opcode> = (1..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let _: Option<Opcode> = (1..3).contains(&op).then(|| unsafe { std::mem:
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:50:68
+  --> tests/ui/eager_transmute.rs:60:68
    |
 LL |     let _: Option<Opcode> = (1..).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     let _: Option<Opcode> = (1..).contains(&op).then(|| unsafe { std::mem::
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:51:68
+  --> tests/ui/eager_transmute.rs:62:68
    |
 LL |     let _: Option<Opcode> = (..3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     let _: Option<Opcode> = (..3).contains(&op).then(|| unsafe { std::mem::
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:52:69
+  --> tests/ui/eager_transmute.rs:64:69
    |
 LL |     let _: Option<Opcode> = (..=3).contains(&op).then_some(unsafe { std::mem::transmute(op) });
    |                                                                     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let _: Option<Opcode> = (..=3).contains(&op).then(|| unsafe { std::mem:
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:61:24
+  --> tests/ui/eager_transmute.rs:74:24
    |
 LL |     (op < 4).then_some(std::mem::transmute::<_, Opcode>(op));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     (op < 4).then(|| std::mem::transmute::<_, Opcode>(op));
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:90:62
+  --> tests/ui/eager_transmute.rs:104:62
    |
 LL |     let _: Option<NonZero<u8>> = (v1 > 0).then_some(unsafe { std::mem::transmute(v1) });
    |                                                              ^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     let _: Option<NonZero<u8>> = (v1 > 0).then(|| unsafe { std::mem::transm
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:96:86
+  --> tests/ui/eager_transmute.rs:111:86
    |
 LL |     let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     let _: Option<NonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then(|| u
    |
 
 error: this transmute is always evaluated eagerly, even if the condition is false
-  --> tests/ui/eager_transmute.rs:102:93
+  --> tests/ui/eager_transmute.rs:118:93
    |
 LL |     let _: Option<NonZeroNonMaxU8> = (v2 < NonZero::new(255u8).unwrap()).then_some(unsafe { std::mem::transmute(v2) });
    |                                                                                             ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/elidable_lifetime_names.fixed b/src/tools/clippy/tests/ui/elidable_lifetime_names.fixed
new file mode 100644
index 000000000000..abeee5c4cef3
--- /dev/null
+++ b/src/tools/clippy/tests/ui/elidable_lifetime_names.fixed
@@ -0,0 +1,194 @@
+#![warn(clippy::needless_lifetimes, clippy::elidable_lifetime_names)]
+
+type Ref<'r> = &'r u8;
+
+// No error; same lifetime on two params.
+fn lifetime_param_1<'a>(_x: Ref<'a>, _y: &'a u8) {}
+
+//~v ERROR: could be elided: 'a, 'b
+fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
+
+// No error; bounded lifetime.
+fn lifetime_param_3<'a, 'b: 'a>(_x: Ref<'a>, _y: &'b u8) {}
+
+// No error; bounded lifetime.
+fn lifetime_param_4<'a, 'b>(_x: Ref<'a>, _y: &'b u8)
+where
+    'b: 'a,
+{
+}
+
+struct Lt<'a, I: 'static> {
+    x: &'a I,
+}
+
+// No error; fn bound references `'a`.
+fn fn_bound<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+where
+    F: Fn(Lt<'a, I>) -> Lt<'a, I>,
+{
+    unreachable!()
+}
+
+//~v ERROR: could be elided: 'a
+fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
+where
+    for<'x> F: Fn(Lt<'x, I>) -> Lt<'x, I>,
+{
+    unreachable!()
+}
+
+struct Foo<'a>(&'a u8);
+
+//~v ERROR: could be elided: 'a
+fn struct_with_lt(_foo: Foo<'_>) -> &str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (named on the reference, anonymous on `Foo`).
+fn struct_with_lt2<'a>(_foo: &'a Foo) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (anonymous on the reference, named on `Foo`).
+fn struct_with_lt3<'a>(_foo: &Foo<'a>) -> &'a str {
+    unimplemented!()
+}
+
+//~v ERROR: could be elided: 'b
+fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
+    unimplemented!()
+}
+
+type FooAlias<'a> = Foo<'a>;
+
+//~v ERROR: could be elided: 'a
+fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (named on the reference, anonymous on `FooAlias`).
+fn alias_with_lt2<'a>(_foo: &'a FooAlias) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (anonymous on the reference, named on `FooAlias`).
+fn alias_with_lt3<'a>(_foo: &FooAlias<'a>) -> &'a str {
+    unimplemented!()
+}
+
+//~v ERROR: could be elided: 'b
+fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
+    unimplemented!()
+}
+
+// Issue #3284: give hint regarding lifetime in return type.
+struct Cow<'a> {
+    x: &'a str,
+}
+
+//~v ERROR: could be elided: 'a
+fn out_return_type_lts(e: &str) -> Cow<'_> {
+    unimplemented!()
+}
+
+mod issue2944 {
+    trait Foo {}
+    struct Bar;
+    struct Baz<'a> {
+        bar: &'a Bar,
+    }
+
+    //~v ERROR: could be elided: 'a
+    impl Foo for Baz<'_> {}
+    impl Bar {
+        //~v ERROR: could be elided: 'a
+        fn baz(&self) -> impl Foo + '_ {
+            Baz { bar: self }
+        }
+    }
+}
+
+mod issue13923 {
+    struct Py<'py> {
+        data: &'py str,
+    }
+
+    enum Content<'t, 'py> {
+        Py(Py<'py>),
+        T1(&'t str),
+        T2(&'t str),
+    }
+
+    enum ContentString<'t> {
+        T1(&'t str),
+        T2(&'t str),
+    }
+
+    impl<'t, 'py> ContentString<'t> {
+        // `'py` cannot be elided
+        fn map_content1(self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(content) => Content::T2(f(content)),
+            }
+        }
+    }
+
+    //~v ERROR: could be elided: 'py
+    impl<'t> ContentString<'t> {
+        // `'py` can be elided because of `&self`
+        fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(content) => Content::T2(f(content)),
+            }
+        }
+    }
+
+    //~v ERROR: could be elided: 'py
+    impl<'t> ContentString<'t> {
+        // `'py` can be elided because of `&'_ self`
+        fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(content) => Content::T2(f(content)),
+            }
+        }
+    }
+
+    impl<'t, 'py> ContentString<'t> {
+        // `'py` should not be elided as the default lifetime, even if working, could be named as `'t`
+        fn map_content4(self, f: impl FnOnce(&'t str) -> &'t str, o: &'t str) -> Content<'t, 'py> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(_) => Content::T2(o),
+            }
+        }
+    }
+
+    //~v ERROR: could be elided: 'py
+    impl<'t> ContentString<'t> {
+        // `'py` can be elided because of `&Self`
+        fn map_content5(
+            self: std::pin::Pin<&Self>,
+            f: impl FnOnce(&'t str) -> &'t str,
+            o: &'t str,
+        ) -> Content<'t, '_> {
+            match *self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(_) => Content::T2(o),
+            }
+        }
+    }
+
+    struct Cx<'a, 'b> {
+        a: &'a u32,
+        b: &'b u32,
+    }
+
+    // `'c` cannot be elided because we have several input lifetimes
+    fn one_explicit<'b>(x: Cx<'_, 'b>) -> &'b u32 {
+        x.b
+    }
+}
diff --git a/src/tools/clippy/tests/ui/elidable_lifetime_names.rs b/src/tools/clippy/tests/ui/elidable_lifetime_names.rs
new file mode 100644
index 000000000000..fae3577a8e96
--- /dev/null
+++ b/src/tools/clippy/tests/ui/elidable_lifetime_names.rs
@@ -0,0 +1,194 @@
+#![warn(clippy::needless_lifetimes, clippy::elidable_lifetime_names)]
+
+type Ref<'r> = &'r u8;
+
+// No error; same lifetime on two params.
+fn lifetime_param_1<'a>(_x: Ref<'a>, _y: &'a u8) {}
+
+//~v ERROR: could be elided: 'a, 'b
+fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
+
+// No error; bounded lifetime.
+fn lifetime_param_3<'a, 'b: 'a>(_x: Ref<'a>, _y: &'b u8) {}
+
+// No error; bounded lifetime.
+fn lifetime_param_4<'a, 'b>(_x: Ref<'a>, _y: &'b u8)
+where
+    'b: 'a,
+{
+}
+
+struct Lt<'a, I: 'static> {
+    x: &'a I,
+}
+
+// No error; fn bound references `'a`.
+fn fn_bound<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+where
+    F: Fn(Lt<'a, I>) -> Lt<'a, I>,
+{
+    unreachable!()
+}
+
+//~v ERROR: could be elided: 'a
+fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+where
+    for<'x> F: Fn(Lt<'x, I>) -> Lt<'x, I>,
+{
+    unreachable!()
+}
+
+struct Foo<'a>(&'a u8);
+
+//~v ERROR: could be elided: 'a
+fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (named on the reference, anonymous on `Foo`).
+fn struct_with_lt2<'a>(_foo: &'a Foo) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (anonymous on the reference, named on `Foo`).
+fn struct_with_lt3<'a>(_foo: &Foo<'a>) -> &'a str {
+    unimplemented!()
+}
+
+//~v ERROR: could be elided: 'b
+fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+    unimplemented!()
+}
+
+type FooAlias<'a> = Foo<'a>;
+
+//~v ERROR: could be elided: 'a
+fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (named on the reference, anonymous on `FooAlias`).
+fn alias_with_lt2<'a>(_foo: &'a FooAlias) -> &'a str {
+    unimplemented!()
+}
+
+// No warning; two input lifetimes (anonymous on the reference, named on `FooAlias`).
+fn alias_with_lt3<'a>(_foo: &FooAlias<'a>) -> &'a str {
+    unimplemented!()
+}
+
+//~v ERROR: could be elided: 'b
+fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+    unimplemented!()
+}
+
+// Issue #3284: give hint regarding lifetime in return type.
+struct Cow<'a> {
+    x: &'a str,
+}
+
+//~v ERROR: could be elided: 'a
+fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
+    unimplemented!()
+}
+
+mod issue2944 {
+    trait Foo {}
+    struct Bar;
+    struct Baz<'a> {
+        bar: &'a Bar,
+    }
+
+    //~v ERROR: could be elided: 'a
+    impl<'a> Foo for Baz<'a> {}
+    impl Bar {
+        //~v ERROR: could be elided: 'a
+        fn baz<'a>(&'a self) -> impl Foo + 'a {
+            Baz { bar: self }
+        }
+    }
+}
+
+mod issue13923 {
+    struct Py<'py> {
+        data: &'py str,
+    }
+
+    enum Content<'t, 'py> {
+        Py(Py<'py>),
+        T1(&'t str),
+        T2(&'t str),
+    }
+
+    enum ContentString<'t> {
+        T1(&'t str),
+        T2(&'t str),
+    }
+
+    impl<'t, 'py> ContentString<'t> {
+        // `'py` cannot be elided
+        fn map_content1(self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(content) => Content::T2(f(content)),
+            }
+        }
+    }
+
+    //~v ERROR: could be elided: 'py
+    impl<'t, 'py> ContentString<'t> {
+        // `'py` can be elided because of `&self`
+        fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(content) => Content::T2(f(content)),
+            }
+        }
+    }
+
+    //~v ERROR: could be elided: 'py
+    impl<'t, 'py> ContentString<'t> {
+        // `'py` can be elided because of `&'_ self`
+        fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(content) => Content::T2(f(content)),
+            }
+        }
+    }
+
+    impl<'t, 'py> ContentString<'t> {
+        // `'py` should not be elided as the default lifetime, even if working, could be named as `'t`
+        fn map_content4(self, f: impl FnOnce(&'t str) -> &'t str, o: &'t str) -> Content<'t, 'py> {
+            match self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(_) => Content::T2(o),
+            }
+        }
+    }
+
+    //~v ERROR: could be elided: 'py
+    impl<'t, 'py> ContentString<'t> {
+        // `'py` can be elided because of `&Self`
+        fn map_content5(
+            self: std::pin::Pin<&Self>,
+            f: impl FnOnce(&'t str) -> &'t str,
+            o: &'t str,
+        ) -> Content<'t, 'py> {
+            match *self {
+                Self::T1(content) => Content::T1(f(content)),
+                Self::T2(_) => Content::T2(o),
+            }
+        }
+    }
+
+    struct Cx<'a, 'b> {
+        a: &'a u32,
+        b: &'b u32,
+    }
+
+    // `'c` cannot be elided because we have several input lifetimes
+    fn one_explicit<'b>(x: Cx<'_, 'b>) -> &'b u32 {
+        x.b
+    }
+}
diff --git a/src/tools/clippy/tests/ui/elidable_lifetime_names.stderr b/src/tools/clippy/tests/ui/elidable_lifetime_names.stderr
new file mode 100644
index 000000000000..a60dfc697564
--- /dev/null
+++ b/src/tools/clippy/tests/ui/elidable_lifetime_names.stderr
@@ -0,0 +1,162 @@
+error: the following explicit lifetimes could be elided: 'a, 'b
+  --> tests/ui/elidable_lifetime_names.rs:9:21
+   |
+LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
+   |                     ^^  ^^          ^^        ^^
+   |
+   = note: `-D clippy::elidable-lifetime-names` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::elidable_lifetime_names)]`
+help: elide the lifetimes
+   |
+LL - fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
+LL + fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:34:15
+   |
+LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+   |               ^^               ^^                   ^^
+   |
+help: elide the lifetimes
+   |
+LL - fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
+LL + fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:44:19
+   |
+LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
+   |                   ^^            ^^       ^^
+   |
+help: elide the lifetimes
+   |
+LL - fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
+LL + fn struct_with_lt(_foo: Foo<'_>) -> &str {
+   |
+
+error: the following explicit lifetimes could be elided: 'b
+  --> tests/ui/elidable_lifetime_names.rs:59:25
+   |
+LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+   |                         ^^                ^^
+   |
+help: elide the lifetimes
+   |
+LL - fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
+LL + fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:66:18
+   |
+LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
+   |                  ^^                 ^^       ^^
+   |
+help: elide the lifetimes
+   |
+LL - fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
+LL + fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
+   |
+
+error: the following explicit lifetimes could be elided: 'b
+  --> tests/ui/elidable_lifetime_names.rs:81:24
+   |
+LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+   |                        ^^                     ^^
+   |
+help: elide the lifetimes
+   |
+LL - fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
+LL + fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:91:24
+   |
+LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
+   |                        ^^      ^^             ^^
+   |
+help: elide the lifetimes
+   |
+LL - fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
+LL + fn out_return_type_lts(e: &str) -> Cow<'_> {
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:103:10
+   |
+LL |     impl<'a> Foo for Baz<'a> {}
+   |          ^^              ^^
+   |
+help: elide the lifetimes
+   |
+LL -     impl<'a> Foo for Baz<'a> {}
+LL +     impl Foo for Baz<'_> {}
+   |
+
+error: the following explicit lifetimes could be elided: 'a
+  --> tests/ui/elidable_lifetime_names.rs:106:16
+   |
+LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
+   |                ^^   ^^                     ^^
+   |
+help: elide the lifetimes
+   |
+LL -         fn baz<'a>(&'a self) -> impl Foo + 'a {
+LL +         fn baz(&self) -> impl Foo + '_ {
+   |
+
+error: the following explicit lifetimes could be elided: 'py
+  --> tests/ui/elidable_lifetime_names.rs:139:14
+   |
+LL |     impl<'t, 'py> ContentString<'t> {
+   |              ^^^
+LL |         // `'py` can be elided because of `&self`
+LL |         fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
+   |                                                                                   ^^^
+   |
+help: elide the lifetimes
+   |
+LL ~     impl<'t> ContentString<'t> {
+LL |         // `'py` can be elided because of `&self`
+LL ~         fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
+   |
+
+error: the following explicit lifetimes could be elided: 'py
+  --> tests/ui/elidable_lifetime_names.rs:150:14
+   |
+LL |     impl<'t, 'py> ContentString<'t> {
+   |              ^^^
+LL |         // `'py` can be elided because of `&'_ self`
+LL |         fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
+   |                                                                                      ^^^
+   |
+help: elide the lifetimes
+   |
+LL ~     impl<'t> ContentString<'t> {
+LL |         // `'py` can be elided because of `&'_ self`
+LL ~         fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
+   |
+
+error: the following explicit lifetimes could be elided: 'py
+  --> tests/ui/elidable_lifetime_names.rs:171:14
+   |
+LL |     impl<'t, 'py> ContentString<'t> {
+   |              ^^^
+...
+LL |         ) -> Content<'t, 'py> {
+   |                          ^^^
+   |
+help: elide the lifetimes
+   |
+LL ~     impl<'t> ContentString<'t> {
+LL |         // `'py` can be elided because of `&Self`
+...
+LL |             o: &'t str,
+LL ~         ) -> Content<'t, '_> {
+   |
+
+error: aborting due to 12 previous errors
+
diff --git a/src/tools/clippy/tests/ui/else_if_without_else.rs b/src/tools/clippy/tests/ui/else_if_without_else.rs
index b04c22fa2aed..05d56600e100 100644
--- a/src/tools/clippy/tests/ui/else_if_without_else.rs
+++ b/src/tools/clippy/tests/ui/else_if_without_else.rs
@@ -49,7 +49,8 @@ fn main() {
     if bla1() {
         println!("if");
     } else if bla2() {
-        //~^ ERROR: `if` expression with an `else if`, but without a final `else`
+        //~^ else_if_without_else
+
         println!("else if");
     }
 
@@ -58,7 +59,8 @@ fn main() {
     } else if bla2() {
         println!("else if 1");
     } else if bla3() {
-        //~^ ERROR: `if` expression with an `else if`, but without a final `else`
+        //~^ else_if_without_else
+
         println!("else if 2");
     }
 
@@ -85,7 +87,8 @@ fn main() {
     } else if bla4() {
         println!("else if 3");
     } else if bla5() {
-        //~^ ERROR: `if` expression with an `else if`, but without a final `else`
+        //~^ else_if_without_else
+
         println!("else if 4");
     }
 
@@ -115,7 +118,8 @@ fn main() {
         } else if bla4() {
             println!("else if 3");
         } else if bla5() {
-            //~^ ERROR: `if` expression with an `else if`, but without a final `else`
+            //~^ else_if_without_else
+
             println!("else if 4");
         }
     }
diff --git a/src/tools/clippy/tests/ui/else_if_without_else.stderr b/src/tools/clippy/tests/ui/else_if_without_else.stderr
index bc7174852293..ac7802345b97 100644
--- a/src/tools/clippy/tests/ui/else_if_without_else.stderr
+++ b/src/tools/clippy/tests/ui/else_if_without_else.stderr
@@ -4,6 +4,7 @@ error: `if` expression with an `else if`, but without a final `else`
 LL |       } else if bla2() {
    |  ____________^
 LL | |
+LL | |
 LL | |         println!("else if");
 LL | |     }
    | |_____^
@@ -13,11 +14,12 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::else_if_without_else)]`
 
 error: `if` expression with an `else if`, but without a final `else`
-  --> tests/ui/else_if_without_else.rs:60:12
+  --> tests/ui/else_if_without_else.rs:61:12
    |
 LL |       } else if bla3() {
    |  ____________^
 LL | |
+LL | |
 LL | |         println!("else if 2");
 LL | |     }
    | |_____^
@@ -25,11 +27,12 @@ LL | |     }
    = help: add an `else` block here
 
 error: `if` expression with an `else if`, but without a final `else`
-  --> tests/ui/else_if_without_else.rs:87:12
+  --> tests/ui/else_if_without_else.rs:89:12
    |
 LL |       } else if bla5() {
    |  ____________^
 LL | |
+LL | |
 LL | |         println!("else if 4");
 LL | |     }
    | |_____^
@@ -37,11 +40,12 @@ LL | |     }
    = help: add an `else` block here
 
 error: `if` expression with an `else if`, but without a final `else`
-  --> tests/ui/else_if_without_else.rs:117:16
+  --> tests/ui/else_if_without_else.rs:120:16
    |
 LL |           } else if bla5() {
    |  ________________^
 LL | |
+LL | |
 LL | |             println!("else if 4");
 LL | |         }
    | |_________^
diff --git a/src/tools/clippy/tests/ui/empty_docs.rs b/src/tools/clippy/tests/ui/empty_docs.rs
index 00e64eebc5fb..d7768e07901a 100644
--- a/src/tools/clippy/tests/ui/empty_docs.rs
+++ b/src/tools/clippy/tests/ui/empty_docs.rs
@@ -7,6 +7,7 @@
 
 mod outer {
     //!
+    //~^ empty_docs
 
     /// this is a struct
     struct Bananas {
@@ -15,8 +16,10 @@ mod outer {
     }
 
     ///
+    //~^ empty_docs
     enum Warn {
         ///
+        //~^ empty_docs
         A,
         B,
     }
@@ -28,16 +31,19 @@ mod outer {
     }
 
     #[doc = ""]
+    //~^ empty_docs
     fn warn_about_this() {}
 
     #[doc = ""]
     #[doc = ""]
+    //~^^ empty_docs
     fn this_doesn_warn() {}
 
     #[doc = "a fine function"]
     fn this_is_fine() {}
 
     ///
+    //~^ empty_docs
     mod inner {
         ///
         fn dont_warn_inner_outer() {
@@ -51,6 +57,7 @@ mod outer {
 
         fn warn() {
             /*! */
+            //~^ empty_docs
         }
 
         fn dont_warn() {
@@ -59,6 +66,7 @@ mod outer {
 
         trait NoDoc {
             ///
+            //~^ empty_docs
             fn some() {}
         }
     }
@@ -67,6 +75,7 @@ mod outer {
         /// lint y
         x: i32,
         ///
+        //~^ empty_docs
         y: i32,
     }
 }
diff --git a/src/tools/clippy/tests/ui/empty_docs.stderr b/src/tools/clippy/tests/ui/empty_docs.stderr
index 5fd7272d7c16..2eba6806852b 100644
--- a/src/tools/clippy/tests/ui/empty_docs.stderr
+++ b/src/tools/clippy/tests/ui/empty_docs.stderr
@@ -9,7 +9,7 @@ LL |     //!
    = help: to override `-D warnings` add `#[allow(clippy::empty_docs)]`
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:17:5
+  --> tests/ui/empty_docs.rs:18:5
    |
 LL |     ///
    |     ^^^
@@ -17,7 +17,7 @@ LL |     ///
    = help: consider removing or filling it
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:19:9
+  --> tests/ui/empty_docs.rs:21:9
    |
 LL |         ///
    |         ^^^
@@ -25,7 +25,7 @@ LL |         ///
    = help: consider removing or filling it
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:30:13
+  --> tests/ui/empty_docs.rs:33:13
    |
 LL |     #[doc = ""]
    |             ^^
@@ -33,7 +33,7 @@ LL |     #[doc = ""]
    = help: consider removing or filling it
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:33:13
+  --> tests/ui/empty_docs.rs:37:13
    |
 LL |       #[doc = ""]
    |  _____________^
@@ -43,7 +43,7 @@ LL | |     #[doc = ""]
    = help: consider removing or filling it
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:40:5
+  --> tests/ui/empty_docs.rs:45:5
    |
 LL |     ///
    |     ^^^
@@ -51,7 +51,7 @@ LL |     ///
    = help: consider removing or filling it
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:53:13
+  --> tests/ui/empty_docs.rs:59:13
    |
 LL |             /*! */
    |             ^^^^^^
@@ -59,7 +59,7 @@ LL |             /*! */
    = help: consider removing or filling it
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:61:13
+  --> tests/ui/empty_docs.rs:68:13
    |
 LL |             ///
    |             ^^^
@@ -67,7 +67,7 @@ LL |             ///
    = help: consider removing or filling it
 
 error: empty doc comment
-  --> tests/ui/empty_docs.rs:69:9
+  --> tests/ui/empty_docs.rs:77:9
    |
 LL |         ///
    |         ^^^
diff --git a/src/tools/clippy/tests/ui/empty_drop.rs b/src/tools/clippy/tests/ui/empty_drop.rs
index 74822ea50ec7..5793f783a724 100644
--- a/src/tools/clippy/tests/ui/empty_drop.rs
+++ b/src/tools/clippy/tests/ui/empty_drop.rs
@@ -5,6 +5,7 @@
 struct Foo;
 
 impl Drop for Foo {
+    //~^ empty_drop
     fn drop(&mut self) {}
 }
 
@@ -21,6 +22,7 @@ impl Drop for Bar {
 struct Baz;
 
 impl Drop for Baz {
+    //~^ empty_drop
     fn drop(&mut self) {
         {}
     }
diff --git a/src/tools/clippy/tests/ui/empty_drop.stderr b/src/tools/clippy/tests/ui/empty_drop.stderr
index d4d020fec30c..3073bf553969 100644
--- a/src/tools/clippy/tests/ui/empty_drop.stderr
+++ b/src/tools/clippy/tests/ui/empty_drop.stderr
@@ -2,6 +2,7 @@ error: empty drop implementation
   --> tests/ui/empty_drop.rs:7:1
    |
 LL | / impl Drop for Foo {
+LL | |
 LL | |     fn drop(&mut self) {}
 LL | | }
    | |_^
@@ -11,9 +12,10 @@ LL | | }
    = help: try removing this impl
 
 error: empty drop implementation
-  --> tests/ui/empty_drop.rs:23:1
+  --> tests/ui/empty_drop.rs:24:1
    |
 LL | / impl Drop for Baz {
+LL | |
 LL | |     fn drop(&mut self) {
 LL | |         {}
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/empty_enum.rs b/src/tools/clippy/tests/ui/empty_enum.rs
index 77357c15d957..439fd0974f5f 100644
--- a/src/tools/clippy/tests/ui/empty_enum.rs
+++ b/src/tools/clippy/tests/ui/empty_enum.rs
@@ -3,6 +3,6 @@
 // Enable never type to test empty enum lint
 #![feature(never_type)]
 enum Empty {}
-//~^ ERROR: enum with no variants
+//~^ empty_enum
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.fixed b/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.fixed
index 1a5e78dd47fe..885f6a50025e 100644
--- a/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.fixed
+++ b/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.fixed
@@ -4,16 +4,20 @@
 pub enum PublicTestEnum {
     NonEmptyBraces { x: i32, y: i32 }, // No error
     NonEmptyParentheses(i32, i32),     // No error
-    EmptyBraces,                    //~ ERROR: enum variant has empty brackets
-    EmptyParentheses,                //~ ERROR: enum variant has empty brackets
+    EmptyBraces,
+    //~^ empty_enum_variants_with_brackets
+    EmptyParentheses,
+    //~^ empty_enum_variants_with_brackets
 }
 
 enum TestEnum {
     NonEmptyBraces { x: i32, y: i32 }, // No error
     NonEmptyParentheses(i32, i32),     // No error
-    EmptyBraces,                    //~ ERROR: enum variant has empty brackets
-    EmptyParentheses,                //~ ERROR: enum variant has empty brackets
-    AnotherEnum,                       // No error
+    EmptyBraces,
+    //~^ empty_enum_variants_with_brackets
+    EmptyParentheses,
+    //~^ empty_enum_variants_with_brackets
+    AnotherEnum, // No error
 }
 
 enum TestEnumWithFeatures {
diff --git a/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.rs b/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.rs
index ca20b969a240..092712ee2ead 100644
--- a/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.rs
+++ b/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.rs
@@ -4,16 +4,20 @@
 pub enum PublicTestEnum {
     NonEmptyBraces { x: i32, y: i32 }, // No error
     NonEmptyParentheses(i32, i32),     // No error
-    EmptyBraces {},                    //~ ERROR: enum variant has empty brackets
-    EmptyParentheses(),                //~ ERROR: enum variant has empty brackets
+    EmptyBraces {},
+    //~^ empty_enum_variants_with_brackets
+    EmptyParentheses(),
+    //~^ empty_enum_variants_with_brackets
 }
 
 enum TestEnum {
     NonEmptyBraces { x: i32, y: i32 }, // No error
     NonEmptyParentheses(i32, i32),     // No error
-    EmptyBraces {},                    //~ ERROR: enum variant has empty brackets
-    EmptyParentheses(),                //~ ERROR: enum variant has empty brackets
-    AnotherEnum,                       // No error
+    EmptyBraces {},
+    //~^ empty_enum_variants_with_brackets
+    EmptyParentheses(),
+    //~^ empty_enum_variants_with_brackets
+    AnotherEnum, // No error
 }
 
 enum TestEnumWithFeatures {
diff --git a/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.stderr b/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.stderr
index 2b187b8f755b..a9ae3b476dd6 100644
--- a/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.stderr
+++ b/src/tools/clippy/tests/ui/empty_enum_variants_with_brackets.stderr
@@ -9,7 +9,7 @@ LL |     EmptyBraces {},
    = help: remove the brackets
 
 error: enum variant has empty brackets
-  --> tests/ui/empty_enum_variants_with_brackets.rs:8:21
+  --> tests/ui/empty_enum_variants_with_brackets.rs:9:21
    |
 LL |     EmptyParentheses(),
    |                     ^^
@@ -17,7 +17,7 @@ LL |     EmptyParentheses(),
    = help: remove the brackets
 
 error: enum variant has empty brackets
-  --> tests/ui/empty_enum_variants_with_brackets.rs:14:16
+  --> tests/ui/empty_enum_variants_with_brackets.rs:16:16
    |
 LL |     EmptyBraces {},
    |                ^^^
@@ -25,7 +25,7 @@ LL |     EmptyBraces {},
    = help: remove the brackets
 
 error: enum variant has empty brackets
-  --> tests/ui/empty_enum_variants_with_brackets.rs:15:21
+  --> tests/ui/empty_enum_variants_with_brackets.rs:18:21
    |
 LL |     EmptyParentheses(),
    |                     ^^
diff --git a/src/tools/clippy/tests/ui/empty_enum_without_never_type.rs b/src/tools/clippy/tests/ui/empty_enum_without_never_type.rs
index 386677352e29..3661a1537208 100644
--- a/src/tools/clippy/tests/ui/empty_enum_without_never_type.rs
+++ b/src/tools/clippy/tests/ui/empty_enum_without_never_type.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(dead_code)]
 #![warn(clippy::empty_enum)]
 
diff --git a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.1.fixed b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.1.fixed
index 3772b465fdb2..e4ba09ea1d47 100644
--- a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.1.fixed
+++ b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.1.fixed
@@ -138,6 +138,7 @@ trait Foo {
 
 impl Foo for LineComment {
     /// comment on assoc item
+    //~^ empty_line_after_doc_comments
     fn bar() {}
 }
 
diff --git a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.2.fixed b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.2.fixed
index 3028d03b6699..a20f9bc20eb5 100644
--- a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.2.fixed
+++ b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.2.fixed
@@ -146,7 +146,9 @@ trait Foo {
 }
 
 impl Foo for LineComment {
-    /// comment on assoc item
+    // /// comment on assoc item
+    //~^ empty_line_after_doc_comments
+
     fn bar() {}
 }
 
diff --git a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.rs b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.rs
index ae4ebc271fa1..9e3ddfd5abe1 100644
--- a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.rs
+++ b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.rs
@@ -150,6 +150,7 @@ trait Foo {
 
 impl Foo for LineComment {
     /// comment on assoc item
+    //~^ empty_line_after_doc_comments
 
     fn bar() {}
 }
diff --git a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.stderr b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.stderr
index ca05a1b03eb1..fe25ba9afcb9 100644
--- a/src/tools/clippy/tests/ui/empty_line_after/doc_comments.stderr
+++ b/src/tools/clippy/tests/ui/empty_line_after/doc_comments.stderr
@@ -176,12 +176,17 @@ error: empty line after doc comment
   --> tests/ui/empty_line_after/doc_comments.rs:152:5
    |
 LL | /     /// comment on assoc item
+LL | |
 LL | |
    | |_^
 LL |       fn bar() {}
    |       ------ the comment documents this function
    |
    = help: if the empty line is unintentional, remove it
+help: if the doc comment should not document `bar` comment it out
+   |
+LL |     // /// comment on assoc item
+   |     ++
 
 error: aborting due to 11 previous errors
 
diff --git a/src/tools/clippy/tests/ui/empty_loop.rs b/src/tools/clippy/tests/ui/empty_loop.rs
index be347563135c..e2d4ff84b56a 100644
--- a/src/tools/clippy/tests/ui/empty_loop.rs
+++ b/src/tools/clippy/tests/ui/empty_loop.rs
@@ -7,14 +7,17 @@ use proc_macros::{external, inline_macros};
 
 fn should_trigger() {
     loop {}
+    //~^ empty_loop
     #[allow(clippy::never_loop)]
     loop {
         loop {}
+        //~^ empty_loop
     }
 
     #[allow(clippy::never_loop)]
     'outer: loop {
         'inner: loop {}
+        //~^ empty_loop
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/empty_loop.stderr b/src/tools/clippy/tests/ui/empty_loop.stderr
index 3ac93f4ece0c..bc723ceefbb3 100644
--- a/src/tools/clippy/tests/ui/empty_loop.stderr
+++ b/src/tools/clippy/tests/ui/empty_loop.stderr
@@ -9,7 +9,7 @@ LL |     loop {}
    = help: to override `-D warnings` add `#[allow(clippy::empty_loop)]`
 
 error: empty `loop {}` wastes CPU cycles
-  --> tests/ui/empty_loop.rs:12:9
+  --> tests/ui/empty_loop.rs:13:9
    |
 LL |         loop {}
    |         ^^^^^^^
@@ -17,7 +17,7 @@ LL |         loop {}
    = help: you should either use `panic!()` or add `std::thread::sleep(..);` to the loop body
 
 error: empty `loop {}` wastes CPU cycles
-  --> tests/ui/empty_loop.rs:17:9
+  --> tests/ui/empty_loop.rs:19:9
    |
 LL |         'inner: loop {}
    |         ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/empty_loop_no_std.rs b/src/tools/clippy/tests/ui/empty_loop_no_std.rs
index 9bfcbfba9697..6407bd678f9c 100644
--- a/src/tools/clippy/tests/ui/empty_loop_no_std.rs
+++ b/src/tools/clippy/tests/ui/empty_loop_no_std.rs
@@ -8,5 +8,5 @@
 pub fn main(argc: isize, argv: *const *const u8) -> isize {
     // This should trigger the lint
     loop {}
-    //~^ ERROR: empty `loop {}` wastes CPU cycles
+    //~^ empty_loop
 }
diff --git a/src/tools/clippy/tests/ui/empty_structs_with_brackets.fixed b/src/tools/clippy/tests/ui/empty_structs_with_brackets.fixed
index 80572645f5d1..b1600862a8f6 100644
--- a/src/tools/clippy/tests/ui/empty_structs_with_brackets.fixed
+++ b/src/tools/clippy/tests/ui/empty_structs_with_brackets.fixed
@@ -2,7 +2,9 @@
 #![allow(dead_code)]
 
 pub struct MyEmptyStruct; // should trigger lint
+//~^ empty_structs_with_brackets
 struct MyEmptyTupleStruct; // should trigger lint
+//~^ empty_structs_with_brackets
 
 // should not trigger lint
 struct MyCfgStruct {
diff --git a/src/tools/clippy/tests/ui/empty_structs_with_brackets.rs b/src/tools/clippy/tests/ui/empty_structs_with_brackets.rs
index 8fb3e247a419..1f69c4be9ec7 100644
--- a/src/tools/clippy/tests/ui/empty_structs_with_brackets.rs
+++ b/src/tools/clippy/tests/ui/empty_structs_with_brackets.rs
@@ -2,7 +2,9 @@
 #![allow(dead_code)]
 
 pub struct MyEmptyStruct {} // should trigger lint
+//~^ empty_structs_with_brackets
 struct MyEmptyTupleStruct(); // should trigger lint
+//~^ empty_structs_with_brackets
 
 // should not trigger lint
 struct MyCfgStruct {
diff --git a/src/tools/clippy/tests/ui/empty_structs_with_brackets.stderr b/src/tools/clippy/tests/ui/empty_structs_with_brackets.stderr
index e57249aec023..86ef43aa9600 100644
--- a/src/tools/clippy/tests/ui/empty_structs_with_brackets.stderr
+++ b/src/tools/clippy/tests/ui/empty_structs_with_brackets.stderr
@@ -9,7 +9,7 @@ LL | pub struct MyEmptyStruct {} // should trigger lint
    = help: remove the brackets
 
 error: found empty brackets on struct declaration
-  --> tests/ui/empty_structs_with_brackets.rs:5:26
+  --> tests/ui/empty_structs_with_brackets.rs:6:26
    |
 LL | struct MyEmptyTupleStruct(); // should trigger lint
    |                          ^^^
diff --git a/src/tools/clippy/tests/ui/endian_bytes.rs b/src/tools/clippy/tests/ui/endian_bytes.rs
index 580fc2fc24d7..879467c7f6e2 100644
--- a/src/tools/clippy/tests/ui/endian_bytes.rs
+++ b/src/tools/clippy/tests/ui/endian_bytes.rs
@@ -7,62 +7,118 @@
 macro_rules! fn_body {
     () => {
         2u8.to_ne_bytes();
+        //~^ host_endian_bytes
         2i8.to_ne_bytes();
+        //~^ host_endian_bytes
         2u16.to_ne_bytes();
+        //~^ host_endian_bytes
         2i16.to_ne_bytes();
+        //~^ host_endian_bytes
         2u32.to_ne_bytes();
+        //~^ host_endian_bytes
         2i32.to_ne_bytes();
+        //~^ host_endian_bytes
         2u64.to_ne_bytes();
+        //~^ host_endian_bytes
         2i64.to_ne_bytes();
+        //~^ host_endian_bytes
         2u128.to_ne_bytes();
+        //~^ host_endian_bytes
         2i128.to_ne_bytes();
+        //~^ host_endian_bytes
         2.0f32.to_ne_bytes();
+        //~^ host_endian_bytes
         2.0f64.to_ne_bytes();
+        //~^ host_endian_bytes
         2usize.to_ne_bytes();
+        //~^ host_endian_bytes
         2isize.to_ne_bytes();
+        //~^ host_endian_bytes
         u8::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         i8::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         u16::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         i16::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         u32::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         i32::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         u64::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         i64::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         u128::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         i128::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         usize::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         isize::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         f32::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
         f64::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
 
         2u8.to_le_bytes();
+        //~^ little_endian_bytes
         2i8.to_le_bytes();
+        //~^ little_endian_bytes
         2u16.to_le_bytes();
+        //~^ little_endian_bytes
         2i16.to_le_bytes();
+        //~^ little_endian_bytes
         2u32.to_le_bytes();
+        //~^ little_endian_bytes
         2i32.to_le_bytes();
+        //~^ little_endian_bytes
         2u64.to_le_bytes();
+        //~^ little_endian_bytes
         2i64.to_le_bytes();
+        //~^ little_endian_bytes
         2u128.to_le_bytes();
+        //~^ little_endian_bytes
         2i128.to_le_bytes();
+        //~^ little_endian_bytes
         2.0f32.to_le_bytes();
+        //~^ little_endian_bytes
         2.0f64.to_le_bytes();
+        //~^ little_endian_bytes
         2usize.to_le_bytes();
+        //~^ little_endian_bytes
         2isize.to_le_bytes();
+        //~^ little_endian_bytes
         u8::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         i8::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         u16::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         i16::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         u32::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         i32::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         u64::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         i64::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         u128::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         i128::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         usize::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         isize::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         f32::from_le_bytes(todo!());
+        //~^ little_endian_bytes
         f64::from_le_bytes(todo!());
+        //~^ little_endian_bytes
     };
 }
 
@@ -70,13 +126,43 @@ macro_rules! fn_body {
 macro_rules! fn_body_smol {
     () => {
         2u8.to_ne_bytes();
+        //~^ host_endian_bytes
+        //~| host_endian_bytes
+        //~| host_endian_bytes
+        //~| host_endian_bytes
+        //~| host_endian_bytes
         u8::from_ne_bytes(todo!());
+        //~^ host_endian_bytes
+        //~| host_endian_bytes
+        //~| host_endian_bytes
+        //~| host_endian_bytes
+        //~| host_endian_bytes
 
         2u8.to_le_bytes();
+        //~^ little_endian_bytes
+        //~| little_endian_bytes
+        //~| little_endian_bytes
+        //~| little_endian_bytes
+        //~| little_endian_bytes
         u8::from_le_bytes(todo!());
+        //~^ little_endian_bytes
+        //~| little_endian_bytes
+        //~| little_endian_bytes
+        //~| little_endian_bytes
+        //~| little_endian_bytes
 
         2u8.to_be_bytes();
+        //~^ big_endian_bytes
+        //~| big_endian_bytes
+        //~| big_endian_bytes
+        //~| big_endian_bytes
+        //~| big_endian_bytes
         u8::from_be_bytes(todo!());
+        //~^ big_endian_bytes
+        //~| big_endian_bytes
+        //~| big_endian_bytes
+        //~| big_endian_bytes
+        //~| big_endian_bytes
     };
 }
 
diff --git a/src/tools/clippy/tests/ui/endian_bytes.stderr b/src/tools/clippy/tests/ui/endian_bytes.stderr
index fd19ec45872b..edc2a3309f24 100644
--- a/src/tools/clippy/tests/ui/endian_bytes.stderr
+++ b/src/tools/clippy/tests/ui/endian_bytes.stderr
@@ -13,7 +13,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i8::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:10:9
+  --> tests/ui/endian_bytes.rs:11:9
    |
 LL |         2i8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u16::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:11:9
+  --> tests/ui/endian_bytes.rs:13:9
    |
 LL |         2u16.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i16::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:12:9
+  --> tests/ui/endian_bytes.rs:15:9
    |
 LL |         2i16.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u32::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:13:9
+  --> tests/ui/endian_bytes.rs:17:9
    |
 LL |         2u32.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i32::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:14:9
+  --> tests/ui/endian_bytes.rs:19:9
    |
 LL |         2i32.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u64::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:15:9
+  --> tests/ui/endian_bytes.rs:21:9
    |
 LL |         2u64.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i64::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:16:9
+  --> tests/ui/endian_bytes.rs:23:9
    |
 LL |         2i64.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u128::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:17:9
+  --> tests/ui/endian_bytes.rs:25:9
    |
 LL |         2u128.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i128::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:18:9
+  --> tests/ui/endian_bytes.rs:27:9
    |
 LL |         2i128.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `f32::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:19:9
+  --> tests/ui/endian_bytes.rs:29:9
    |
 LL |         2.0f32.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `f64::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:20:9
+  --> tests/ui/endian_bytes.rs:31:9
    |
 LL |         2.0f64.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `usize::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:21:9
+  --> tests/ui/endian_bytes.rs:33:9
    |
 LL |         2usize.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `isize::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:22:9
+  --> tests/ui/endian_bytes.rs:35:9
    |
 LL |         2isize.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:23:9
+  --> tests/ui/endian_bytes.rs:37:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i8::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:24:9
+  --> tests/ui/endian_bytes.rs:39:9
    |
 LL |         i8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u16::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:25:9
+  --> tests/ui/endian_bytes.rs:41:9
    |
 LL |         u16::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i16::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:26:9
+  --> tests/ui/endian_bytes.rs:43:9
    |
 LL |         i16::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u32::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:27:9
+  --> tests/ui/endian_bytes.rs:45:9
    |
 LL |         u32::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i32::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:28:9
+  --> tests/ui/endian_bytes.rs:47:9
    |
 LL |         i32::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u64::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:29:9
+  --> tests/ui/endian_bytes.rs:49:9
    |
 LL |         u64::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i64::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:30:9
+  --> tests/ui/endian_bytes.rs:51:9
    |
 LL |         i64::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -265,7 +265,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u128::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:31:9
+  --> tests/ui/endian_bytes.rs:53:9
    |
 LL |         u128::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i128::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:32:9
+  --> tests/ui/endian_bytes.rs:55:9
    |
 LL |         i128::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -289,7 +289,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `usize::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:33:9
+  --> tests/ui/endian_bytes.rs:57:9
    |
 LL |         usize::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -301,7 +301,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `isize::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:34:9
+  --> tests/ui/endian_bytes.rs:59:9
    |
 LL |         isize::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `f32::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:35:9
+  --> tests/ui/endian_bytes.rs:61:9
    |
 LL |         f32::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `f64::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:36:9
+  --> tests/ui/endian_bytes.rs:63:9
    |
 LL |         f64::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL | fn host() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:38:9
+  --> tests/ui/endian_bytes.rs:66:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -351,7 +351,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i8::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:39:9
+  --> tests/ui/endian_bytes.rs:68:9
    |
 LL |         2i8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -363,7 +363,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u16::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:40:9
+  --> tests/ui/endian_bytes.rs:70:9
    |
 LL |         2u16.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -375,7 +375,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i16::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:41:9
+  --> tests/ui/endian_bytes.rs:72:9
    |
 LL |         2i16.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -387,7 +387,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u32::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:42:9
+  --> tests/ui/endian_bytes.rs:74:9
    |
 LL |         2u32.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -399,7 +399,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i32::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:43:9
+  --> tests/ui/endian_bytes.rs:76:9
    |
 LL |         2i32.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -411,7 +411,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u64::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:44:9
+  --> tests/ui/endian_bytes.rs:78:9
    |
 LL |         2u64.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -423,7 +423,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i64::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:45:9
+  --> tests/ui/endian_bytes.rs:80:9
    |
 LL |         2i64.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^
@@ -435,7 +435,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u128::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:46:9
+  --> tests/ui/endian_bytes.rs:82:9
    |
 LL |         2u128.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^^
@@ -447,7 +447,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `i128::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:47:9
+  --> tests/ui/endian_bytes.rs:84:9
    |
 LL |         2i128.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^^
@@ -459,7 +459,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `f32::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:48:9
+  --> tests/ui/endian_bytes.rs:86:9
    |
 LL |         2.0f32.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -471,7 +471,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `f64::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:49:9
+  --> tests/ui/endian_bytes.rs:88:9
    |
 LL |         2.0f64.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -483,7 +483,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `usize::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:50:9
+  --> tests/ui/endian_bytes.rs:90:9
    |
 LL |         2usize.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -495,7 +495,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `isize::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:51:9
+  --> tests/ui/endian_bytes.rs:92:9
    |
 LL |         2isize.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -507,7 +507,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:52:9
+  --> tests/ui/endian_bytes.rs:94:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -519,7 +519,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i8::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:53:9
+  --> tests/ui/endian_bytes.rs:96:9
    |
 LL |         i8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -531,7 +531,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u16::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:54:9
+  --> tests/ui/endian_bytes.rs:98:9
    |
 LL |         u16::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -543,7 +543,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i16::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:55:9
+  --> tests/ui/endian_bytes.rs:100:9
    |
 LL |         i16::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -555,7 +555,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u32::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:56:9
+  --> tests/ui/endian_bytes.rs:102:9
    |
 LL |         u32::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -567,7 +567,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i32::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:57:9
+  --> tests/ui/endian_bytes.rs:104:9
    |
 LL |         i32::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -579,7 +579,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u64::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:58:9
+  --> tests/ui/endian_bytes.rs:106:9
    |
 LL |         u64::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -591,7 +591,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i64::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:59:9
+  --> tests/ui/endian_bytes.rs:108:9
    |
 LL |         i64::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -603,7 +603,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u128::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:60:9
+  --> tests/ui/endian_bytes.rs:110:9
    |
 LL |         u128::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -615,7 +615,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `i128::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:61:9
+  --> tests/ui/endian_bytes.rs:112:9
    |
 LL |         i128::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -627,7 +627,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `usize::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:62:9
+  --> tests/ui/endian_bytes.rs:114:9
    |
 LL |         usize::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -639,7 +639,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `isize::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:63:9
+  --> tests/ui/endian_bytes.rs:116:9
    |
 LL |         isize::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -651,7 +651,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `f32::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:64:9
+  --> tests/ui/endian_bytes.rs:118:9
    |
 LL |         f32::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -663,7 +663,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `f64::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:65:9
+  --> tests/ui/endian_bytes.rs:120:9
    |
 LL |         f64::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -675,7 +675,7 @@ LL | fn little() { fn_body!(); }
    = note: this error originates in the macro `fn_body` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:72:9
+  --> tests/ui/endian_bytes.rs:128:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -687,7 +687,7 @@ LL | fn host_encourage_little() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:73:9
+  --> tests/ui/endian_bytes.rs:134:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -699,7 +699,7 @@ LL | fn host_encourage_little() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_be_bytes` method
-  --> tests/ui/endian_bytes.rs:78:9
+  --> tests/ui/endian_bytes.rs:154:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -713,7 +713,7 @@ LL | fn host_encourage_little() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_be_bytes`
-  --> tests/ui/endian_bytes.rs:79:9
+  --> tests/ui/endian_bytes.rs:160:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -725,7 +725,7 @@ LL | fn host_encourage_little() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:72:9
+  --> tests/ui/endian_bytes.rs:128:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -737,7 +737,7 @@ LL | fn host_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:73:9
+  --> tests/ui/endian_bytes.rs:134:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -749,7 +749,7 @@ LL | fn host_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:75:9
+  --> tests/ui/endian_bytes.rs:141:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -761,7 +761,7 @@ LL | fn host_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:76:9
+  --> tests/ui/endian_bytes.rs:147:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -773,7 +773,7 @@ LL | fn host_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:72:9
+  --> tests/ui/endian_bytes.rs:128:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -784,7 +784,7 @@ LL | fn no_help() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:73:9
+  --> tests/ui/endian_bytes.rs:134:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -795,7 +795,7 @@ LL | fn no_help() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:75:9
+  --> tests/ui/endian_bytes.rs:141:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -806,7 +806,7 @@ LL | fn no_help() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:76:9
+  --> tests/ui/endian_bytes.rs:147:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -817,7 +817,7 @@ LL | fn no_help() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_be_bytes` method
-  --> tests/ui/endian_bytes.rs:78:9
+  --> tests/ui/endian_bytes.rs:154:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -828,7 +828,7 @@ LL | fn no_help() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_be_bytes`
-  --> tests/ui/endian_bytes.rs:79:9
+  --> tests/ui/endian_bytes.rs:160:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -839,7 +839,7 @@ LL | fn no_help() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:75:9
+  --> tests/ui/endian_bytes.rs:141:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -851,7 +851,7 @@ LL | fn little_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:76:9
+  --> tests/ui/endian_bytes.rs:147:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -863,7 +863,7 @@ LL | fn little_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_be_bytes` method
-  --> tests/ui/endian_bytes.rs:78:9
+  --> tests/ui/endian_bytes.rs:154:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -875,7 +875,7 @@ LL | fn little_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_be_bytes`
-  --> tests/ui/endian_bytes.rs:79:9
+  --> tests/ui/endian_bytes.rs:160:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -887,7 +887,7 @@ LL | fn little_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:72:9
+  --> tests/ui/endian_bytes.rs:128:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -899,7 +899,7 @@ LL | fn little_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:73:9
+  --> tests/ui/endian_bytes.rs:134:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -911,7 +911,7 @@ LL | fn little_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:75:9
+  --> tests/ui/endian_bytes.rs:141:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -923,7 +923,7 @@ LL | fn little_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:76:9
+  --> tests/ui/endian_bytes.rs:147:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -935,7 +935,7 @@ LL | fn little_encourage_big() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_le_bytes` method
-  --> tests/ui/endian_bytes.rs:75:9
+  --> tests/ui/endian_bytes.rs:141:9
    |
 LL |         2u8.to_le_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -947,7 +947,7 @@ LL | fn big_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_le_bytes`
-  --> tests/ui/endian_bytes.rs:76:9
+  --> tests/ui/endian_bytes.rs:147:9
    |
 LL |         u8::from_le_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -959,7 +959,7 @@ LL | fn big_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_be_bytes` method
-  --> tests/ui/endian_bytes.rs:78:9
+  --> tests/ui/endian_bytes.rs:154:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -971,7 +971,7 @@ LL | fn big_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_be_bytes`
-  --> tests/ui/endian_bytes.rs:79:9
+  --> tests/ui/endian_bytes.rs:160:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -983,7 +983,7 @@ LL | fn big_encourage_host() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_ne_bytes` method
-  --> tests/ui/endian_bytes.rs:72:9
+  --> tests/ui/endian_bytes.rs:128:9
    |
 LL |         2u8.to_ne_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -995,7 +995,7 @@ LL | fn big_encourage_little() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_ne_bytes`
-  --> tests/ui/endian_bytes.rs:73:9
+  --> tests/ui/endian_bytes.rs:134:9
    |
 LL |         u8::from_ne_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -1007,7 +1007,7 @@ LL | fn big_encourage_little() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the `u8::to_be_bytes` method
-  --> tests/ui/endian_bytes.rs:78:9
+  --> tests/ui/endian_bytes.rs:154:9
    |
 LL |         2u8.to_be_bytes();
    |         ^^^^^^^^^^^^^^^^^
@@ -1019,7 +1019,7 @@ LL | fn big_encourage_little() { fn_body_smol!(); }
    = note: this error originates in the macro `fn_body_smol` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: usage of the function `u8::from_be_bytes`
-  --> tests/ui/endian_bytes.rs:79:9
+  --> tests/ui/endian_bytes.rs:160:9
    |
 LL |         u8::from_be_bytes(todo!());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/entry.fixed b/src/tools/clippy/tests/ui/entry.fixed
index abdfae2a3e13..69452a8d9a67 100644
--- a/src/tools/clippy/tests/ui/entry.fixed
+++ b/src/tools/clippy/tests/ui/entry.fixed
@@ -25,6 +25,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // semicolon on insert, use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
+        //~^ map_entry
         if true {
             v
         } else {
@@ -34,6 +35,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // semicolon on if, use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
+        //~^ map_entry
         if true {
             v
         } else {
@@ -43,6 +45,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // early return, use if let
     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        //~^ map_entry
         if true {
             e.insert(v);
         } else {
@@ -53,12 +56,14 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
+        //~^ map_entry
         foo();
         v
     });
 
     // semicolon on insert and match, use or_insert_with(..)
     m.entry(k).or_insert_with(|| {
+        //~^ map_entry
         match 0 {
             1 if true => {
                 v
@@ -71,6 +76,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // one branch doesn't insert, use if let
     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        //~^ map_entry
         match 0 {
             0 => foo(),
             _ => {
@@ -81,6 +87,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // use or_insert_with
     m.entry(k).or_insert_with(|| {
+        //~^ map_entry
         foo();
         match 0 {
             0 if false => {
@@ -145,6 +152,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // or_insert_with. Partial move of a local declared in the closure is ok.
     m.entry(k).or_insert_with(|| {
+        //~^ map_entry
         let x = (String::new(), String::new());
         let _ = x.0;
         v
@@ -178,6 +186,7 @@ pub fn issue_11935() {
 
 fn issue12489(map: &mut HashMap<u64, u64>) -> Option<()> {
     if let std::collections::hash_map::Entry::Vacant(e) = map.entry(1) {
+        //~^ map_entry
         let Some(1) = Some(2) else {
             return None;
         };
@@ -186,4 +195,35 @@ fn issue12489(map: &mut HashMap<u64, u64>) -> Option<()> {
     Some(())
 }
 
+mod issue13934 {
+    use std::collections::HashMap;
+
+    struct Member {}
+
+    pub struct Foo {
+        members: HashMap<u8, Member>,
+    }
+
+    impl Foo {
+        pub fn should_also_not_cause_lint(&mut self, input: u8) {
+            if self.members.contains_key(&input) {
+                todo!();
+            } else {
+                self.other();
+                self.members.insert(input, Member {});
+            }
+        }
+
+        fn other(&self) {}
+    }
+}
+
+fn issue11976() {
+    let mut hashmap = std::collections::HashMap::new();
+    if !hashmap.contains_key(&0) {
+        let _ = || hashmap.get(&0);
+        hashmap.insert(0, 0);
+    }
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/entry.rs b/src/tools/clippy/tests/ui/entry.rs
index 7774f99a2a22..3578324f01c5 100644
--- a/src/tools/clippy/tests/ui/entry.rs
+++ b/src/tools/clippy/tests/ui/entry.rs
@@ -22,11 +22,13 @@ fn foo() {}
 fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMap<K, V>, k: K, k2: K, v: V, v2: V) {
     // or_insert(v)
     if !m.contains_key(&k) {
+        //~^ map_entry
         m.insert(k, v);
     }
 
     // semicolon on insert, use or_insert_with(..)
     if !m.contains_key(&k) {
+        //~^ map_entry
         if true {
             m.insert(k, v);
         } else {
@@ -36,6 +38,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // semicolon on if, use or_insert_with(..)
     if !m.contains_key(&k) {
+        //~^ map_entry
         if true {
             m.insert(k, v)
         } else {
@@ -45,6 +48,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // early return, use if let
     if !m.contains_key(&k) {
+        //~^ map_entry
         if true {
             m.insert(k, v);
         } else {
@@ -55,12 +59,14 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // use or_insert_with(..)
     if !m.contains_key(&k) {
+        //~^ map_entry
         foo();
         m.insert(k, v);
     }
 
     // semicolon on insert and match, use or_insert_with(..)
     if !m.contains_key(&k) {
+        //~^ map_entry
         match 0 {
             1 if true => {
                 m.insert(k, v);
@@ -73,6 +79,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // one branch doesn't insert, use if let
     if !m.contains_key(&k) {
+        //~^ map_entry
         match 0 {
             0 => foo(),
             _ => {
@@ -83,6 +90,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // use or_insert_with
     if !m.contains_key(&k) {
+        //~^ map_entry
         foo();
         match 0 {
             0 if false => {
@@ -117,6 +125,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // macro_expansion test, use or_insert(..)
     if !m.contains_key(&m!(k)) {
+        //~^ map_entry
         m.insert(m!(k), m!(v));
     }
 
@@ -149,6 +158,7 @@ fn hash_map<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, m2: &mut HashMa
 
     // or_insert_with. Partial move of a local declared in the closure is ok.
     if !m.contains_key(&k) {
+        //~^ map_entry
         let x = (String::new(), String::new());
         let _ = x.0;
         m.insert(k, v);
@@ -182,6 +192,7 @@ pub fn issue_11935() {
 
 fn issue12489(map: &mut HashMap<u64, u64>) -> Option<()> {
     if !map.contains_key(&1) {
+        //~^ map_entry
         let Some(1) = Some(2) else {
             return None;
         };
@@ -190,4 +201,35 @@ fn issue12489(map: &mut HashMap<u64, u64>) -> Option<()> {
     Some(())
 }
 
+mod issue13934 {
+    use std::collections::HashMap;
+
+    struct Member {}
+
+    pub struct Foo {
+        members: HashMap<u8, Member>,
+    }
+
+    impl Foo {
+        pub fn should_also_not_cause_lint(&mut self, input: u8) {
+            if self.members.contains_key(&input) {
+                todo!();
+            } else {
+                self.other();
+                self.members.insert(input, Member {});
+            }
+        }
+
+        fn other(&self) {}
+    }
+}
+
+fn issue11976() {
+    let mut hashmap = std::collections::HashMap::new();
+    if !hashmap.contains_key(&0) {
+        let _ = || hashmap.get(&0);
+        hashmap.insert(0, 0);
+    }
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/entry.stderr b/src/tools/clippy/tests/ui/entry.stderr
index 4b6bd3b4a258..009b78d29073 100644
--- a/src/tools/clippy/tests/ui/entry.stderr
+++ b/src/tools/clippy/tests/ui/entry.stderr
@@ -2,6 +2,7 @@ error: usage of `contains_key` followed by `insert` on a `HashMap`
   --> tests/ui/entry.rs:24:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         m.insert(k, v);
 LL | |     }
    | |_____^ help: try: `m.entry(k).or_insert(v);`
@@ -10,12 +11,12 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::map_entry)]`
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:29:5
+  --> tests/ui/entry.rs:30:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         if true {
 LL | |             m.insert(k, v);
-LL | |         } else {
 ...  |
 LL | |     }
    | |_____^
@@ -23,6 +24,7 @@ LL | |     }
 help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
+LL +
 LL +         if true {
 LL +             v
 LL +         } else {
@@ -32,13 +34,13 @@ LL +     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:38:5
+  --> tests/ui/entry.rs:40:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         if true {
 LL | |             m.insert(k, v)
-LL | |         } else {
-LL | |             m.insert(k, v2)
+...  |
 LL | |         };
 LL | |     }
    | |_____^
@@ -46,6 +48,7 @@ LL | |     }
 help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
+LL +
 LL +         if true {
 LL +             v
 LL +         } else {
@@ -55,12 +58,12 @@ LL +     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:47:5
+  --> tests/ui/entry.rs:50:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         if true {
 LL | |             m.insert(k, v);
-LL | |         } else {
 ...  |
 LL | |     }
    | |_____^
@@ -68,6 +71,7 @@ LL | |     }
 help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL +
 LL +         if true {
 LL +             e.insert(v);
 LL +         } else {
@@ -78,9 +82,10 @@ LL +     }
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:57:5
+  --> tests/ui/entry.rs:61:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         foo();
 LL | |         m.insert(k, v);
 LL | |     }
@@ -89,18 +94,19 @@ LL | |     }
 help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
+LL +
 LL +         foo();
 LL +         v
 LL +     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:63:5
+  --> tests/ui/entry.rs:68:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         match 0 {
 LL | |             1 if true => {
-LL | |                 m.insert(k, v);
 ...  |
 LL | |         };
 LL | |     }
@@ -109,6 +115,7 @@ LL | |     }
 help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
+LL +
 LL +         match 0 {
 LL +             1 if true => {
 LL +                 v
@@ -121,12 +128,12 @@ LL +     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:75:5
+  --> tests/ui/entry.rs:81:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         match 0 {
 LL | |             0 => foo(),
-LL | |             _ => {
 ...  |
 LL | |         };
 LL | |     }
@@ -135,6 +142,7 @@ LL | |     }
 help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL +
 LL +         match 0 {
 LL +             0 => foo(),
 LL +             _ => {
@@ -145,12 +153,12 @@ LL +     }
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:85:5
+  --> tests/ui/entry.rs:92:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         foo();
 LL | |         match 0 {
-LL | |             0 if false => {
 ...  |
 LL | |     }
    | |_____^
@@ -158,6 +166,7 @@ LL | |     }
 help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
+LL +
 LL +         foo();
 LL +         match 0 {
 LL +             0 if false => {
@@ -185,17 +194,19 @@ LL +     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:119:5
+  --> tests/ui/entry.rs:127:5
    |
 LL | /     if !m.contains_key(&m!(k)) {
+LL | |
 LL | |         m.insert(m!(k), m!(v));
 LL | |     }
    | |_____^ help: try: `m.entry(m!(k)).or_insert_with(|| m!(v));`
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:151:5
+  --> tests/ui/entry.rs:160:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         let x = (String::new(), String::new());
 LL | |         let _ = x.0;
 LL | |         m.insert(k, v);
@@ -205,6 +216,7 @@ LL | |     }
 help: try
    |
 LL ~     m.entry(k).or_insert_with(|| {
+LL +
 LL +         let x = (String::new(), String::new());
 LL +         let _ = x.0;
 LL +         v
@@ -212,9 +224,10 @@ LL +     });
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry.rs:184:5
+  --> tests/ui/entry.rs:194:5
    |
 LL | /     if !map.contains_key(&1) {
+LL | |
 LL | |         let Some(1) = Some(2) else {
 LL | |             return None;
 LL | |         };
@@ -225,6 +238,7 @@ LL | |     }
 help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Vacant(e) = map.entry(1) {
+LL +
 LL +         let Some(1) = Some(2) else {
 LL +             return None;
 LL +         };
diff --git a/src/tools/clippy/tests/ui/entry_btree.fixed b/src/tools/clippy/tests/ui/entry_btree.fixed
index 228212c79eaf..1218202f02b9 100644
--- a/src/tools/clippy/tests/ui/entry_btree.fixed
+++ b/src/tools/clippy/tests/ui/entry_btree.fixed
@@ -8,6 +8,7 @@ fn foo() {}
 fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V) {
     // insert then do something, use if let
     if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
+        //~^ map_entry
         e.insert(v);
         foo();
     }
diff --git a/src/tools/clippy/tests/ui/entry_btree.rs b/src/tools/clippy/tests/ui/entry_btree.rs
index 44703c567113..b795e32158ad 100644
--- a/src/tools/clippy/tests/ui/entry_btree.rs
+++ b/src/tools/clippy/tests/ui/entry_btree.rs
@@ -8,6 +8,7 @@ fn foo() {}
 fn btree_map<K: Eq + Ord + Copy, V: Copy>(m: &mut BTreeMap<K, V>, k: K, v: V) {
     // insert then do something, use if let
     if !m.contains_key(&k) {
+        //~^ map_entry
         m.insert(k, v);
         foo();
     }
diff --git a/src/tools/clippy/tests/ui/entry_btree.stderr b/src/tools/clippy/tests/ui/entry_btree.stderr
index 290e6b788054..671340b89532 100644
--- a/src/tools/clippy/tests/ui/entry_btree.stderr
+++ b/src/tools/clippy/tests/ui/entry_btree.stderr
@@ -2,6 +2,7 @@ error: usage of `contains_key` followed by `insert` on a `BTreeMap`
   --> tests/ui/entry_btree.rs:10:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         m.insert(k, v);
 LL | |         foo();
 LL | |     }
@@ -12,6 +13,7 @@ LL | |     }
 help: try
    |
 LL ~     if let std::collections::btree_map::Entry::Vacant(e) = m.entry(k) {
+LL +
 LL +         e.insert(v);
 LL +         foo();
 LL +     }
diff --git a/src/tools/clippy/tests/ui/entry_with_else.fixed b/src/tools/clippy/tests/ui/entry_with_else.fixed
index 34804b9ee5d7..76e6998235c2 100644
--- a/src/tools/clippy/tests/ui/entry_with_else.fixed
+++ b/src/tools/clippy/tests/ui/entry_with_else.fixed
@@ -13,6 +13,7 @@ fn foo() {}
 fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
     match m.entry(k) {
         std::collections::hash_map::Entry::Vacant(e) => {
+            //~^ map_entry
             e.insert(v);
         }
         std::collections::hash_map::Entry::Occupied(mut e) => {
@@ -22,6 +23,7 @@ fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K,
 
     match m.entry(k) {
         std::collections::hash_map::Entry::Occupied(mut e) => {
+            //~^ map_entry
             e.insert(v);
         }
         std::collections::hash_map::Entry::Vacant(e) => {
@@ -30,6 +32,7 @@ fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K,
     }
 
     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+        //~^ map_entry
         e.insert(v);
     } else {
         foo();
@@ -38,11 +41,13 @@ fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K,
     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
         e.insert(v);
     } else {
+        //~^ map_entry
         foo();
     }
 
     match m.entry(k) {
         std::collections::hash_map::Entry::Vacant(e) => {
+            //~^ map_entry
             e.insert(v);
         }
         std::collections::hash_map::Entry::Occupied(mut e) => {
@@ -52,6 +57,7 @@ fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K,
 
     match m.entry(k) {
         std::collections::hash_map::Entry::Occupied(mut e) => {
+            //~^ map_entry
             if true { Some(e.insert(v)) } else { Some(e.insert(v2)) }
         }
         std::collections::hash_map::Entry::Vacant(e) => {
@@ -61,6 +67,7 @@ fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K,
     };
 
     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
+        //~^ map_entry
         foo();
         Some(e.insert(v))
     } else {
diff --git a/src/tools/clippy/tests/ui/entry_with_else.rs b/src/tools/clippy/tests/ui/entry_with_else.rs
index 0515748fd733..1669cdc0c7cf 100644
--- a/src/tools/clippy/tests/ui/entry_with_else.rs
+++ b/src/tools/clippy/tests/ui/entry_with_else.rs
@@ -12,42 +12,49 @@ fn foo() {}
 
 fn insert_if_absent0<K: Eq + Hash + Copy, V: Copy>(m: &mut HashMap<K, V>, k: K, v: V, v2: V) {
     if !m.contains_key(&k) {
+        //~^ map_entry
         m.insert(k, v);
     } else {
         m.insert(k, v2);
     }
 
     if m.contains_key(&k) {
+        //~^ map_entry
         m.insert(k, v);
     } else {
         m.insert(k, v2);
     }
 
     if !m.contains_key(&k) {
+        //~^ map_entry
         m.insert(k, v);
     } else {
         foo();
     }
 
     if !m.contains_key(&k) {
+        //~^ map_entry
         foo();
     } else {
         m.insert(k, v);
     }
 
     if !m.contains_key(&k) {
+        //~^ map_entry
         m.insert(k, v);
     } else {
         m.insert(k, v2);
     }
 
     if m.contains_key(&k) {
+        //~^ map_entry
         if true { m.insert(k, v) } else { m.insert(k, v2) }
     } else {
         m.insert(k, v)
     };
 
     if m.contains_key(&k) {
+        //~^ map_entry
         foo();
         m.insert(k, v)
     } else {
diff --git a/src/tools/clippy/tests/ui/entry_with_else.stderr b/src/tools/clippy/tests/ui/entry_with_else.stderr
index 26b21b076b6c..d483ac95ad5b 100644
--- a/src/tools/clippy/tests/ui/entry_with_else.stderr
+++ b/src/tools/clippy/tests/ui/entry_with_else.stderr
@@ -2,6 +2,7 @@ error: usage of `contains_key` followed by `insert` on a `HashMap`
   --> tests/ui/entry_with_else.rs:14:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         m.insert(k, v);
 LL | |     } else {
 LL | |         m.insert(k, v2);
@@ -14,6 +15,7 @@ help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Vacant(e) => {
+LL +
 LL +             e.insert(v);
 LL +         }
 LL +         std::collections::hash_map::Entry::Occupied(mut e) => {
@@ -23,9 +25,10 @@ LL +     }
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry_with_else.rs:20:5
+  --> tests/ui/entry_with_else.rs:21:5
    |
 LL | /     if m.contains_key(&k) {
+LL | |
 LL | |         m.insert(k, v);
 LL | |     } else {
 LL | |         m.insert(k, v2);
@@ -36,6 +39,7 @@ help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Occupied(mut e) => {
+LL +
 LL +             e.insert(v);
 LL +         }
 LL +         std::collections::hash_map::Entry::Vacant(e) => {
@@ -45,9 +49,10 @@ LL +     }
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry_with_else.rs:26:5
+  --> tests/ui/entry_with_else.rs:28:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         m.insert(k, v);
 LL | |     } else {
 LL | |         foo();
@@ -57,6 +62,7 @@ LL | |     }
 help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Vacant(e) = m.entry(k) {
+LL +
 LL +         e.insert(v);
 LL +     } else {
 LL +         foo();
@@ -64,9 +70,10 @@ LL +     }
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry_with_else.rs:32:5
+  --> tests/ui/entry_with_else.rs:35:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         foo();
 LL | |     } else {
 LL | |         m.insert(k, v);
@@ -78,14 +85,16 @@ help: try
 LL ~     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
 LL +         e.insert(v);
 LL +     } else {
+LL +
 LL +         foo();
 LL +     }
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry_with_else.rs:38:5
+  --> tests/ui/entry_with_else.rs:42:5
    |
 LL | /     if !m.contains_key(&k) {
+LL | |
 LL | |         m.insert(k, v);
 LL | |     } else {
 LL | |         m.insert(k, v2);
@@ -96,6 +105,7 @@ help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Vacant(e) => {
+LL +
 LL +             e.insert(v);
 LL +         }
 LL +         std::collections::hash_map::Entry::Occupied(mut e) => {
@@ -105,9 +115,10 @@ LL +     }
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry_with_else.rs:44:5
+  --> tests/ui/entry_with_else.rs:49:5
    |
 LL | /     if m.contains_key(&k) {
+LL | |
 LL | |         if true { m.insert(k, v) } else { m.insert(k, v2) }
 LL | |     } else {
 LL | |         m.insert(k, v)
@@ -118,6 +129,7 @@ help: try
    |
 LL ~     match m.entry(k) {
 LL +         std::collections::hash_map::Entry::Occupied(mut e) => {
+LL +
 LL +             if true { Some(e.insert(v)) } else { Some(e.insert(v2)) }
 LL +         }
 LL +         std::collections::hash_map::Entry::Vacant(e) => {
@@ -128,9 +140,10 @@ LL ~     };
    |
 
 error: usage of `contains_key` followed by `insert` on a `HashMap`
-  --> tests/ui/entry_with_else.rs:50:5
+  --> tests/ui/entry_with_else.rs:56:5
    |
 LL | /     if m.contains_key(&k) {
+LL | |
 LL | |         foo();
 LL | |         m.insert(k, v)
 LL | |     } else {
@@ -141,6 +154,7 @@ LL | |     };
 help: try
    |
 LL ~     if let std::collections::hash_map::Entry::Occupied(mut e) = m.entry(k) {
+LL +
 LL +         foo();
 LL +         Some(e.insert(v))
 LL +     } else {
diff --git a/src/tools/clippy/tests/ui/enum_clike_unportable_variant.rs b/src/tools/clippy/tests/ui/enum_clike_unportable_variant.rs
index 37849179d6a0..4ff2024b25e9 100644
--- a/src/tools/clippy/tests/ui/enum_clike_unportable_variant.rs
+++ b/src/tools/clippy/tests/ui/enum_clike_unportable_variant.rs
@@ -6,8 +6,7 @@
 #[repr(usize)]
 enum NonPortable {
     X = 0x1_0000_0000,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
-    //~| NOTE: `-D clippy::enum-clike-unportable-variant` implied by `-D warnings`
+    //~^ enum_clike_unportable_variant
     Y = 0,
     Z = 0x7FFF_FFFF,
     A = 0xFFFF_FFFF,
@@ -15,11 +14,11 @@ enum NonPortable {
 
 enum NonPortableNoHint {
     X = 0x1_0000_0000,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
     Y = 0,
     Z = 0x7FFF_FFFF,
     A = 0xFFFF_FFFF,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
 }
 
 #[repr(isize)]
@@ -27,27 +26,27 @@ enum NonPortableSigned {
     X = -1,
     Y = 0x7FFF_FFFF,
     Z = 0xFFFF_FFFF,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
     A = 0x1_0000_0000,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
     B = i32::MIN as isize,
     C = (i32::MIN as isize) - 1,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
 }
 
 enum NonPortableSignedNoHint {
     X = -1,
     Y = 0x7FFF_FFFF,
     Z = 0xFFFF_FFFF,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
     A = 0x1_0000_0000,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
 }
 
 #[repr(usize)]
 enum NonPortable2 {
     X = <usize as Trait>::Number,
-    //~^ ERROR: C-like enum variant discriminant is not portable to 32-bit targets
+    //~^ enum_clike_unportable_variant
     Y = 0,
 }
 
diff --git a/src/tools/clippy/tests/ui/enum_clike_unportable_variant.stderr b/src/tools/clippy/tests/ui/enum_clike_unportable_variant.stderr
index 741de179a497..5a022a6fe8a6 100644
--- a/src/tools/clippy/tests/ui/enum_clike_unportable_variant.stderr
+++ b/src/tools/clippy/tests/ui/enum_clike_unportable_variant.stderr
@@ -8,49 +8,49 @@ LL |     X = 0x1_0000_0000,
    = help: to override `-D warnings` add `#[allow(clippy::enum_clike_unportable_variant)]`
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:17:5
+  --> tests/ui/enum_clike_unportable_variant.rs:16:5
    |
 LL |     X = 0x1_0000_0000,
    |     ^^^^^^^^^^^^^^^^^
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:21:5
+  --> tests/ui/enum_clike_unportable_variant.rs:20:5
    |
 LL |     A = 0xFFFF_FFFF,
    |     ^^^^^^^^^^^^^^^
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:29:5
+  --> tests/ui/enum_clike_unportable_variant.rs:28:5
    |
 LL |     Z = 0xFFFF_FFFF,
    |     ^^^^^^^^^^^^^^^
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:31:5
+  --> tests/ui/enum_clike_unportable_variant.rs:30:5
    |
 LL |     A = 0x1_0000_0000,
    |     ^^^^^^^^^^^^^^^^^
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:34:5
+  --> tests/ui/enum_clike_unportable_variant.rs:33:5
    |
 LL |     C = (i32::MIN as isize) - 1,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:41:5
+  --> tests/ui/enum_clike_unportable_variant.rs:40:5
    |
 LL |     Z = 0xFFFF_FFFF,
    |     ^^^^^^^^^^^^^^^
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:43:5
+  --> tests/ui/enum_clike_unportable_variant.rs:42:5
    |
 LL |     A = 0x1_0000_0000,
    |     ^^^^^^^^^^^^^^^^^
 
 error: C-like enum variant discriminant is not portable to 32-bit targets
-  --> tests/ui/enum_clike_unportable_variant.rs:49:5
+  --> tests/ui/enum_clike_unportable_variant.rs:48:5
    |
 LL |     X = <usize as Trait>::Number,
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/enum_glob_use.fixed b/src/tools/clippy/tests/ui/enum_glob_use.fixed
index 3c0db9beb1a6..881493f3d5ff 100644
--- a/src/tools/clippy/tests/ui/enum_glob_use.fixed
+++ b/src/tools/clippy/tests/ui/enum_glob_use.fixed
@@ -3,16 +3,19 @@
 #![warn(unused_imports)]
 
 use std::cmp::Ordering::Less;
+//~^ enum_glob_use
 
 enum Enum {
     Foo,
 }
 
 use self::Enum::Foo;
+//~^ enum_glob_use
 
 mod in_fn_test {
     fn blarg() {
         use crate::Enum::Foo;
+        //~^ enum_glob_use
 
         let _ = Foo;
     }
diff --git a/src/tools/clippy/tests/ui/enum_glob_use.rs b/src/tools/clippy/tests/ui/enum_glob_use.rs
index 2538477f7978..a510462ecb2f 100644
--- a/src/tools/clippy/tests/ui/enum_glob_use.rs
+++ b/src/tools/clippy/tests/ui/enum_glob_use.rs
@@ -3,16 +3,19 @@
 #![warn(unused_imports)]
 
 use std::cmp::Ordering::*;
+//~^ enum_glob_use
 
 enum Enum {
     Foo,
 }
 
 use self::Enum::*;
+//~^ enum_glob_use
 
 mod in_fn_test {
     fn blarg() {
         use crate::Enum::*;
+        //~^ enum_glob_use
 
         let _ = Foo;
     }
diff --git a/src/tools/clippy/tests/ui/enum_glob_use.stderr b/src/tools/clippy/tests/ui/enum_glob_use.stderr
index 6825383b769d..a2cef8008e21 100644
--- a/src/tools/clippy/tests/ui/enum_glob_use.stderr
+++ b/src/tools/clippy/tests/ui/enum_glob_use.stderr
@@ -8,13 +8,13 @@ LL | use std::cmp::Ordering::*;
    = help: to override `-D warnings` add `#[allow(clippy::enum_glob_use)]`
 
 error: usage of wildcard import for enum variants
-  --> tests/ui/enum_glob_use.rs:11:5
+  --> tests/ui/enum_glob_use.rs:12:5
    |
 LL | use self::Enum::*;
    |     ^^^^^^^^^^^^^ help: try: `self::Enum::Foo`
 
 error: usage of wildcard import for enum variants
-  --> tests/ui/enum_glob_use.rs:15:13
+  --> tests/ui/enum_glob_use.rs:17:13
    |
 LL |         use crate::Enum::*;
    |             ^^^^^^^^^^^^^^ help: try: `crate::Enum::Foo`
diff --git a/src/tools/clippy/tests/ui/enum_variants.rs b/src/tools/clippy/tests/ui/enum_variants.rs
index ddf2dfdaea9b..f7bbf83654f1 100644
--- a/src/tools/clippy/tests/ui/enum_variants.rs
+++ b/src/tools/clippy/tests/ui/enum_variants.rs
@@ -12,10 +12,9 @@ enum FakeCallType2 {
 }
 
 enum Foo {
-    //~^ ERROR: all variants have the same prefix: `c`
+    //~^ enum_variant_names
     cFoo,
-    //~^ ERROR: variant name ends with the enum's name
-    //~| NOTE: `-D clippy::enum-variant-names` implied by `-D warnings`
+    //~^ enum_variant_names
     cBar,
     cBaz,
 }
@@ -26,13 +25,13 @@ enum Fooo {
 }
 
 enum Food {
-    //~^ ERROR: all variants have the same prefix: `Food`
+    //~^ enum_variant_names
     FoodGood,
-    //~^ ERROR: variant name starts with the enum's name
+    //~^ enum_variant_names
     FoodMiddle,
-    //~^ ERROR: variant name starts with the enum's name
+    //~^ enum_variant_names
     FoodBad,
-    //~^ ERROR: variant name starts with the enum's name
+    //~^ enum_variant_names
 }
 
 enum Stuff {
@@ -40,7 +39,7 @@ enum Stuff {
 }
 
 enum BadCallType {
-    //~^ ERROR: all variants have the same prefix: `CallType`
+    //~^ enum_variant_names
     CallTypeCall,
     CallTypeCreate,
     CallTypeDestroy,
@@ -53,7 +52,7 @@ enum TwoCallType {
 }
 
 enum Consts {
-    //~^ ERROR: all variants have the same prefix: `Constant`
+    //~^ enum_variant_names
     ConstantInt,
     ConstantCake,
     ConstantLie,
@@ -66,7 +65,7 @@ enum Two {
 }
 
 enum Something {
-    //~^ ERROR: all variants have the same prefix: `C`
+    //~^ enum_variant_names
     CCall,
     CCreate,
     CCryogenize,
@@ -89,7 +88,7 @@ enum Sealll {
 }
 
 enum Seallll {
-    //~^ ERROR: all variants have the same prefix: `WithOut`
+    //~^ enum_variant_names
     WithOutCake,
     WithOutTea,
     WithOut,
@@ -145,14 +144,14 @@ pub enum NetworkLayer {
 
 // should lint suggesting `IData`, not only `Data` (see #4639)
 enum IDataRequest {
-    //~^ ERROR: all variants have the same postfix: `IData`
+    //~^ enum_variant_names
     PutIData(String),
     GetIData(String),
     DeleteUnpubIData(String),
 }
 
 enum HIDataRequest {
-    //~^ ERROR: all variants have the same postfix: `HIData`
+    //~^ enum_variant_names
     PutHIData(String),
     GetHIData(String),
     DeleteUnpubHIData(String),
@@ -173,7 +172,7 @@ enum Phase {
 
 mod issue9018 {
     enum DoLint {
-        //~^ ERROR: all variants have the same prefix: `_Type`
+        //~^ enum_variant_names
         _TypeCreate,
         _TypeRead,
         _TypeUpdate,
@@ -181,7 +180,7 @@ mod issue9018 {
     }
 
     enum DoLintToo {
-        //~^ ERROR: all variants have the same postfix: `Type`
+        //~^ enum_variant_names
         _CreateType,
         _UpdateType,
         _DeleteType,
@@ -210,12 +209,12 @@ mod issue11494 {
         Valid,
         Invalid,
         DataDependent,
-        //~^ ERROR: variant name starts with the enum's name
+        //~^ enum_variant_names
     }
 
     enum Datas {
         DatasDependent,
-        //~^ ERROR: variant name starts with the enum's name
+        //~^ enum_variant_names
         Valid,
         Invalid,
     }
diff --git a/src/tools/clippy/tests/ui/enum_variants.stderr b/src/tools/clippy/tests/ui/enum_variants.stderr
index ecca6c833ac5..cca9d50033cf 100644
--- a/src/tools/clippy/tests/ui/enum_variants.stderr
+++ b/src/tools/clippy/tests/ui/enum_variants.stderr
@@ -21,25 +21,25 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: variant name starts with the enum's name
-  --> tests/ui/enum_variants.rs:30:5
+  --> tests/ui/enum_variants.rs:29:5
    |
 LL |     FoodGood,
    |     ^^^^^^^^
 
 error: variant name starts with the enum's name
-  --> tests/ui/enum_variants.rs:32:5
+  --> tests/ui/enum_variants.rs:31:5
    |
 LL |     FoodMiddle,
    |     ^^^^^^^^^^
 
 error: variant name starts with the enum's name
-  --> tests/ui/enum_variants.rs:34:5
+  --> tests/ui/enum_variants.rs:33:5
    |
 LL |     FoodBad,
    |     ^^^^^^^
 
 error: all variants have the same prefix: `Food`
-  --> tests/ui/enum_variants.rs:28:1
+  --> tests/ui/enum_variants.rs:27:1
    |
 LL | / enum Food {
 LL | |
@@ -51,7 +51,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `CallType`
-  --> tests/ui/enum_variants.rs:42:1
+  --> tests/ui/enum_variants.rs:41:1
    |
 LL | / enum BadCallType {
 LL | |
@@ -64,7 +64,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `Constant`
-  --> tests/ui/enum_variants.rs:55:1
+  --> tests/ui/enum_variants.rs:54:1
    |
 LL | / enum Consts {
 LL | |
@@ -77,7 +77,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `C`
-  --> tests/ui/enum_variants.rs:68:1
+  --> tests/ui/enum_variants.rs:67:1
    |
 LL | / enum Something {
 LL | |
@@ -90,7 +90,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `WithOut`
-  --> tests/ui/enum_variants.rs:91:1
+  --> tests/ui/enum_variants.rs:90:1
    |
 LL | / enum Seallll {
 LL | |
@@ -103,7 +103,7 @@ LL | | }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same postfix: `IData`
-  --> tests/ui/enum_variants.rs:147:1
+  --> tests/ui/enum_variants.rs:146:1
    |
 LL | / enum IDataRequest {
 LL | |
@@ -116,7 +116,7 @@ LL | | }
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same postfix: `HIData`
-  --> tests/ui/enum_variants.rs:154:1
+  --> tests/ui/enum_variants.rs:153:1
    |
 LL | / enum HIDataRequest {
 LL | |
@@ -129,7 +129,7 @@ LL | | }
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same prefix: `_Type`
-  --> tests/ui/enum_variants.rs:175:5
+  --> tests/ui/enum_variants.rs:174:5
    |
 LL | /     enum DoLint {
 LL | |
@@ -143,7 +143,7 @@ LL | |     }
    = help: remove the prefixes and use full paths to the variants instead of glob imports
 
 error: all variants have the same postfix: `Type`
-  --> tests/ui/enum_variants.rs:183:5
+  --> tests/ui/enum_variants.rs:182:5
    |
 LL | /     enum DoLintToo {
 LL | |
@@ -156,13 +156,13 @@ LL | |     }
    = help: remove the postfixes and use full paths to the variants instead of glob imports
 
 error: variant name starts with the enum's name
-  --> tests/ui/enum_variants.rs:212:9
+  --> tests/ui/enum_variants.rs:211:9
    |
 LL |         DataDependent,
    |         ^^^^^^^^^^^^^
 
 error: variant name starts with the enum's name
-  --> tests/ui/enum_variants.rs:217:9
+  --> tests/ui/enum_variants.rs:216:9
    |
 LL |         DatasDependent,
    |         ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/eprint_with_newline.fixed b/src/tools/clippy/tests/ui/eprint_with_newline.fixed
index 7383d784c841..c50a707ace92 100644
--- a/src/tools/clippy/tests/ui/eprint_with_newline.fixed
+++ b/src/tools/clippy/tests/ui/eprint_with_newline.fixed
@@ -3,16 +3,19 @@
 
 fn main() {
     eprintln!("Hello");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
-    //~| NOTE: `-D clippy::print-with-newline` implied by `-D warnings`
+    //~^ print_with_newline
+
     eprintln!("Hello {}", "world");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprintln!("Hello {} {}", "world", "#2");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprintln!("{}", 1265);
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprintln!();
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
 
     // these are all fine
     eprint!("");
@@ -35,7 +38,8 @@ fn main() {
     // #3514
     eprint!("\\n");
     eprintln!("\\");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprint!("\\\\n");
 
     // Raw strings
@@ -44,11 +48,11 @@ fn main() {
 
     // Literal newlines should also fail
     eprintln!(
-        //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         
     );
     eprintln!(
-        //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         
     );
 
@@ -56,7 +60,8 @@ fn main() {
     eprint!("\r\n");
     eprint!("foo\r\n");
     eprintln!("\\r");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprint!("foo\rbar\n");
 
     // Ignore expanded format strings
diff --git a/src/tools/clippy/tests/ui/eprint_with_newline.rs b/src/tools/clippy/tests/ui/eprint_with_newline.rs
index 5b114056411d..2c90480bdc78 100644
--- a/src/tools/clippy/tests/ui/eprint_with_newline.rs
+++ b/src/tools/clippy/tests/ui/eprint_with_newline.rs
@@ -3,16 +3,19 @@
 
 fn main() {
     eprint!("Hello\n");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
-    //~| NOTE: `-D clippy::print-with-newline` implied by `-D warnings`
+    //~^ print_with_newline
+
     eprint!("Hello {}\n", "world");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprint!("Hello {} {}\n", "world", "#2");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprint!("{}\n", 1265);
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprint!("\n");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
 
     // these are all fine
     eprint!("");
@@ -35,7 +38,8 @@ fn main() {
     // #3514
     eprint!("\\n");
     eprint!("\\\n");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprint!("\\\\n");
 
     // Raw strings
@@ -44,12 +48,12 @@ fn main() {
 
     // Literal newlines should also fail
     eprint!(
-        //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         "
 "
     );
     eprint!(
-        //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         r"
 "
     );
@@ -58,7 +62,8 @@ fn main() {
     eprint!("\r\n");
     eprint!("foo\r\n");
     eprint!("\\r\n");
-    //~^ ERROR: using `eprint!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     eprint!("foo\rbar\n");
 
     // Ignore expanded format strings
diff --git a/src/tools/clippy/tests/ui/eprint_with_newline.stderr b/src/tools/clippy/tests/ui/eprint_with_newline.stderr
index de450090a66e..c78cffd40c99 100644
--- a/src/tools/clippy/tests/ui/eprint_with_newline.stderr
+++ b/src/tools/clippy/tests/ui/eprint_with_newline.stderr
@@ -25,7 +25,7 @@ LL +     eprintln!("Hello {}", "world");
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
-  --> tests/ui/eprint_with_newline.rs:10:5
+  --> tests/ui/eprint_with_newline.rs:11:5
    |
 LL |     eprint!("Hello {} {}\n", "world", "#2");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     eprintln!("Hello {} {}", "world", "#2");
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
-  --> tests/ui/eprint_with_newline.rs:12:5
+  --> tests/ui/eprint_with_newline.rs:14:5
    |
 LL |     eprint!("{}\n", 1265);
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     eprintln!("{}", 1265);
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
-  --> tests/ui/eprint_with_newline.rs:14:5
+  --> tests/ui/eprint_with_newline.rs:17:5
    |
 LL |     eprint!("\n");
    |     ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     eprintln!();
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
-  --> tests/ui/eprint_with_newline.rs:37:5
+  --> tests/ui/eprint_with_newline.rs:40:5
    |
 LL |     eprint!("\\\n");
    |     ^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     eprintln!("\\");
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
-  --> tests/ui/eprint_with_newline.rs:46:5
+  --> tests/ui/eprint_with_newline.rs:50:5
    |
 LL | /     eprint!(
 LL | |
@@ -90,7 +90,7 @@ LL ~
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
-  --> tests/ui/eprint_with_newline.rs:51:5
+  --> tests/ui/eprint_with_newline.rs:55:5
    |
 LL | /     eprint!(
 LL | |
@@ -107,7 +107,7 @@ LL ~
    |
 
 error: using `eprint!()` with a format string that ends in a single newline
-  --> tests/ui/eprint_with_newline.rs:60:5
+  --> tests/ui/eprint_with_newline.rs:64:5
    |
 LL |     eprint!("\\r\n");
    |     ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/eq_op.rs b/src/tools/clippy/tests/ui/eq_op.rs
index 7c2c13187518..ced0452ee9a8 100644
--- a/src/tools/clippy/tests/ui/eq_op.rs
+++ b/src/tools/clippy/tests/ui/eq_op.rs
@@ -5,80 +5,96 @@
 fn main() {
     // simple values and comparisons
     let _ = 1 == 1;
-    //~^ ERROR: equal expressions as operands to `==`
-    //~| NOTE: `-D clippy::eq-op` implied by `-D warnings`
+    //~^ eq_op
+
     let _ = "no" == "no";
-    //~^ ERROR: equal expressions as operands to `==`
+    //~^ eq_op
+
     // even though I agree that no means no ;-)
     let _ = false != false;
-    //~^ ERROR: equal expressions as operands to `!=`
+    //~^ eq_op
+
     let _ = 1.5 < 1.5;
-    //~^ ERROR: equal expressions as operands to `<`
+    //~^ eq_op
+
     let _ = 1u64 >= 1u64;
-    //~^ ERROR: equal expressions as operands to `>=`
+    //~^ eq_op
+
     let x = f32::NAN;
     let _ = x != x;
-    //~^ ERROR: equal expressions as operands to `!=`
-    //~| NOTE: if you intended to check if the operand is NaN, use `.is_nan()` instead
+    //~^ eq_op
 
     // casts, methods, parentheses
     let _ = (1u32 as u64) & (1u32 as u64);
-    //~^ ERROR: equal expressions as operands to `&`
+    //~^ eq_op
+
     #[rustfmt::skip]
     {
         let _ = 1 ^ ((((((1))))));
-        //~^ ERROR: equal expressions as operands to `^`
+        //~^ eq_op
+
     };
 
     // unary and binary operators
     let _ = (-(2) < -(2));
-    //~^ ERROR: equal expressions as operands to `<`
+    //~^ eq_op
+
     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
-    //~^ ERROR: equal expressions as operands to `==`
-    //~| ERROR: equal expressions as operands to `&`
-    //~| ERROR: equal expressions as operands to `&`
+    //~^ eq_op
+    //~| eq_op
+    //~| eq_op
+
     let _ = (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
-    //~^ ERROR: equal expressions as operands to `==`
+    //~^ eq_op
 
     // various other things
     let _ = ([1] != [1]);
-    //~^ ERROR: equal expressions as operands to `!=`
+    //~^ eq_op
+
     let _ = ((1, 2) != (1, 2));
-    //~^ ERROR: equal expressions as operands to `!=`
+    //~^ eq_op
+
     let _ = vec![1, 2, 3] == vec![1, 2, 3]; //no error yet, as we don't match macros
 
     // const folding
     let _ = 1 + 1 == 2;
-    //~^ ERROR: equal expressions as operands to `==`
+    //~^ eq_op
+
     let _ = 1 - 1 == 0;
-    //~^ ERROR: equal expressions as operands to `==`
-    //~| ERROR: equal expressions as operands to `-`
+    //~^ eq_op
+    //~| eq_op
 
     let _ = 1 - 1;
-    //~^ ERROR: equal expressions as operands to `-`
+    //~^ eq_op
+
     let _ = 1 / 1;
-    //~^ ERROR: equal expressions as operands to `/`
+    //~^ eq_op
+
     let _ = true && true;
-    //~^ ERROR: equal expressions as operands to `&&`
+    //~^ eq_op
 
     let _ = true || true;
-    //~^ ERROR: equal expressions as operands to `||`
+    //~^ eq_op
 
     let a: u32 = 0;
     let b: u32 = 0;
 
     let _ = a == b && b == a;
-    //~^ ERROR: equal expressions as operands to `&&`
+    //~^ eq_op
+
     let _ = a != b && b != a;
-    //~^ ERROR: equal expressions as operands to `&&`
+    //~^ eq_op
+
     let _ = a < b && b > a;
-    //~^ ERROR: equal expressions as operands to `&&`
+    //~^ eq_op
+
     let _ = a <= b && b >= a;
-    //~^ ERROR: equal expressions as operands to `&&`
+    //~^ eq_op
 
     let mut a = vec![1];
     let _ = a == a;
-    //~^ ERROR: equal expressions as operands to `==`
+    //~^ eq_op
+
     let _ = 2 * a.len() == 2 * a.len(); // ok, functions
     let _ = a.pop() == a.pop(); // ok, functions
 
@@ -89,7 +105,7 @@ fn main() {
     const B: u32 = 10;
     const C: u32 = A / B; // ok, different named constants
     const D: u32 = A / A;
-    //~^ ERROR: equal expressions as operands to `/`
+    //~^ eq_op
 }
 
 macro_rules! check_if_named_foo {
@@ -121,7 +137,7 @@ struct Nested {
 fn check_nested(n1: &Nested, n2: &Nested) -> bool {
     // `n2.inner.0.0` mistyped as `n1.inner.0.0`
     (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
-    //~^ ERROR: equal expressions as operands to `==`
+    //~^ eq_op
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui/eq_op.stderr b/src/tools/clippy/tests/ui/eq_op.stderr
index bd3c115d8b8b..1696f09d6d17 100644
--- a/src/tools/clippy/tests/ui/eq_op.stderr
+++ b/src/tools/clippy/tests/ui/eq_op.stderr
@@ -14,25 +14,25 @@ LL |     let _ = "no" == "no";
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> tests/ui/eq_op.rs:13:13
+  --> tests/ui/eq_op.rs:14:13
    |
 LL |     let _ = false != false;
    |             ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `<`
-  --> tests/ui/eq_op.rs:15:13
+  --> tests/ui/eq_op.rs:17:13
    |
 LL |     let _ = 1.5 < 1.5;
    |             ^^^^^^^^^
 
 error: equal expressions as operands to `>=`
-  --> tests/ui/eq_op.rs:17:13
+  --> tests/ui/eq_op.rs:20:13
    |
 LL |     let _ = 1u64 >= 1u64;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> tests/ui/eq_op.rs:20:13
+  --> tests/ui/eq_op.rs:24:13
    |
 LL |     let _ = x != x;
    |             ^^^^^^
@@ -40,139 +40,139 @@ LL |     let _ = x != x;
    = note: if you intended to check if the operand is NaN, use `.is_nan()` instead
 
 error: equal expressions as operands to `&`
-  --> tests/ui/eq_op.rs:25:13
+  --> tests/ui/eq_op.rs:28:13
    |
 LL |     let _ = (1u32 as u64) & (1u32 as u64);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `^`
-  --> tests/ui/eq_op.rs:29:17
+  --> tests/ui/eq_op.rs:33:17
    |
 LL |         let _ = 1 ^ ((((((1))))));
    |                 ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `<`
-  --> tests/ui/eq_op.rs:34:13
+  --> tests/ui/eq_op.rs:39:13
    |
 LL |     let _ = (-(2) < -(2));
    |             ^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/eq_op.rs:36:13
+  --> tests/ui/eq_op.rs:42:13
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> tests/ui/eq_op.rs:36:14
+  --> tests/ui/eq_op.rs:42:14
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |              ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&`
-  --> tests/ui/eq_op.rs:36:35
+  --> tests/ui/eq_op.rs:42:35
    |
 LL |     let _ = ((1 + 1) & (1 + 1) == (1 + 1) & (1 + 1));
    |                                   ^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/eq_op.rs:40:13
+  --> tests/ui/eq_op.rs:47:13
    |
 LL |     let _ = (1 * 2) + (3 * 4) == 1 * 2 + 3 * 4;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> tests/ui/eq_op.rs:44:13
+  --> tests/ui/eq_op.rs:51:13
    |
 LL |     let _ = ([1] != [1]);
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> tests/ui/eq_op.rs:46:13
+  --> tests/ui/eq_op.rs:54:13
    |
 LL |     let _ = ((1, 2) != (1, 2));
    |             ^^^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/eq_op.rs:51:13
+  --> tests/ui/eq_op.rs:60:13
    |
 LL |     let _ = 1 + 1 == 2;
    |             ^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/eq_op.rs:53:13
+  --> tests/ui/eq_op.rs:63:13
    |
 LL |     let _ = 1 - 1 == 0;
    |             ^^^^^^^^^^
 
 error: equal expressions as operands to `-`
-  --> tests/ui/eq_op.rs:53:13
+  --> tests/ui/eq_op.rs:63:13
    |
 LL |     let _ = 1 - 1 == 0;
    |             ^^^^^
 
 error: equal expressions as operands to `-`
-  --> tests/ui/eq_op.rs:57:13
+  --> tests/ui/eq_op.rs:67:13
    |
 LL |     let _ = 1 - 1;
    |             ^^^^^
 
 error: equal expressions as operands to `/`
-  --> tests/ui/eq_op.rs:59:13
+  --> tests/ui/eq_op.rs:70:13
    |
 LL |     let _ = 1 / 1;
    |             ^^^^^
 
 error: equal expressions as operands to `&&`
-  --> tests/ui/eq_op.rs:61:13
+  --> tests/ui/eq_op.rs:73:13
    |
 LL |     let _ = true && true;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `||`
-  --> tests/ui/eq_op.rs:64:13
+  --> tests/ui/eq_op.rs:76:13
    |
 LL |     let _ = true || true;
    |             ^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> tests/ui/eq_op.rs:70:13
+  --> tests/ui/eq_op.rs:82:13
    |
 LL |     let _ = a == b && b == a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> tests/ui/eq_op.rs:72:13
+  --> tests/ui/eq_op.rs:85:13
    |
 LL |     let _ = a != b && b != a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> tests/ui/eq_op.rs:74:13
+  --> tests/ui/eq_op.rs:88:13
    |
 LL |     let _ = a < b && b > a;
    |             ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `&&`
-  --> tests/ui/eq_op.rs:76:13
+  --> tests/ui/eq_op.rs:91:13
    |
 LL |     let _ = a <= b && b >= a;
    |             ^^^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/eq_op.rs:80:13
+  --> tests/ui/eq_op.rs:95:13
    |
 LL |     let _ = a == a;
    |             ^^^^^^
 
 error: equal expressions as operands to `/`
-  --> tests/ui/eq_op.rs:91:20
+  --> tests/ui/eq_op.rs:107:20
    |
 LL |     const D: u32 = A / A;
    |                    ^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/eq_op.rs:123:5
+  --> tests/ui/eq_op.rs:139:5
    |
 LL |     (n1.inner.0).0 == (n1.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/eq_op_macros.rs b/src/tools/clippy/tests/ui/eq_op_macros.rs
index a511af4a31c8..82242d0eb196 100644
--- a/src/tools/clippy/tests/ui/eq_op_macros.rs
+++ b/src/tools/clippy/tests/ui/eq_op_macros.rs
@@ -6,9 +6,13 @@ macro_rules! assert_in_macro_def {
     () => {
         let a = 42;
         assert_eq!(a, a);
+        //~^ eq_op
         assert_ne!(a, a);
+        //~^ eq_op
         debug_assert_eq!(a, a);
+        //~^ eq_op
         debug_assert_ne!(a, a);
+        //~^ eq_op
     };
 }
 
@@ -21,9 +25,11 @@ fn main() {
 
     // lint identical args in `assert_eq!`
     assert_eq!(a, a);
-    //~^ ERROR: identical args used in this `assert_eq!` macro call
+    //~^ eq_op
+
     assert_eq!(a + 1, a + 1);
-    //~^ ERROR: identical args used in this `assert_eq!` macro call
+    //~^ eq_op
+
     // ok
     assert_eq!(a, b);
     assert_eq!(a, a + 1);
@@ -31,9 +37,11 @@ fn main() {
 
     // lint identical args in `assert_ne!`
     assert_ne!(a, a);
-    //~^ ERROR: identical args used in this `assert_ne!` macro call
+    //~^ eq_op
+
     assert_ne!(a + 1, a + 1);
-    //~^ ERROR: identical args used in this `assert_ne!` macro call
+    //~^ eq_op
+
     // ok
     assert_ne!(a, b);
     assert_ne!(a, a + 1);
@@ -41,9 +49,11 @@ fn main() {
 
     // lint identical args in `debug_assert_eq!`
     debug_assert_eq!(a, a);
-    //~^ ERROR: identical args used in this `debug_assert_eq!` macro call
+    //~^ eq_op
+
     debug_assert_eq!(a + 1, a + 1);
-    //~^ ERROR: identical args used in this `debug_assert_eq!` macro call
+    //~^ eq_op
+
     // ok
     debug_assert_eq!(a, b);
     debug_assert_eq!(a, a + 1);
@@ -51,9 +61,11 @@ fn main() {
 
     // lint identical args in `debug_assert_ne!`
     debug_assert_ne!(a, a);
-    //~^ ERROR: identical args used in this `debug_assert_ne!` macro call
+    //~^ eq_op
+
     debug_assert_ne!(a + 1, a + 1);
-    //~^ ERROR: identical args used in this `debug_assert_ne!` macro call
+    //~^ eq_op
+
     // ok
     debug_assert_ne!(a, b);
     debug_assert_ne!(a, a + 1);
diff --git a/src/tools/clippy/tests/ui/eq_op_macros.stderr b/src/tools/clippy/tests/ui/eq_op_macros.stderr
index b114db0ca98e..72315e87bfef 100644
--- a/src/tools/clippy/tests/ui/eq_op_macros.stderr
+++ b/src/tools/clippy/tests/ui/eq_op_macros.stderr
@@ -12,7 +12,7 @@ LL |     assert_in_macro_def!();
    = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: identical args used in this `assert_ne!` macro call
-  --> tests/ui/eq_op_macros.rs:9:20
+  --> tests/ui/eq_op_macros.rs:10:20
    |
 LL |         assert_ne!(a, a);
    |                    ^^^^
@@ -23,7 +23,7 @@ LL |     assert_in_macro_def!();
    = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: identical args used in this `debug_assert_eq!` macro call
-  --> tests/ui/eq_op_macros.rs:10:26
+  --> tests/ui/eq_op_macros.rs:12:26
    |
 LL |         debug_assert_eq!(a, a);
    |                          ^^^^
@@ -34,7 +34,7 @@ LL |     assert_in_macro_def!();
    = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: identical args used in this `debug_assert_ne!` macro call
-  --> tests/ui/eq_op_macros.rs:11:26
+  --> tests/ui/eq_op_macros.rs:14:26
    |
 LL |         debug_assert_ne!(a, a);
    |                          ^^^^
@@ -45,49 +45,49 @@ LL |     assert_in_macro_def!();
    = note: this error originates in the macro `assert_in_macro_def` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: identical args used in this `assert_eq!` macro call
-  --> tests/ui/eq_op_macros.rs:23:16
+  --> tests/ui/eq_op_macros.rs:27:16
    |
 LL |     assert_eq!(a, a);
    |                ^^^^
 
 error: identical args used in this `assert_eq!` macro call
-  --> tests/ui/eq_op_macros.rs:25:16
+  --> tests/ui/eq_op_macros.rs:30:16
    |
 LL |     assert_eq!(a + 1, a + 1);
    |                ^^^^^^^^^^^^
 
 error: identical args used in this `assert_ne!` macro call
-  --> tests/ui/eq_op_macros.rs:33:16
+  --> tests/ui/eq_op_macros.rs:39:16
    |
 LL |     assert_ne!(a, a);
    |                ^^^^
 
 error: identical args used in this `assert_ne!` macro call
-  --> tests/ui/eq_op_macros.rs:35:16
+  --> tests/ui/eq_op_macros.rs:42:16
    |
 LL |     assert_ne!(a + 1, a + 1);
    |                ^^^^^^^^^^^^
 
 error: identical args used in this `debug_assert_eq!` macro call
-  --> tests/ui/eq_op_macros.rs:43:22
+  --> tests/ui/eq_op_macros.rs:51:22
    |
 LL |     debug_assert_eq!(a, a);
    |                      ^^^^
 
 error: identical args used in this `debug_assert_eq!` macro call
-  --> tests/ui/eq_op_macros.rs:45:22
+  --> tests/ui/eq_op_macros.rs:54:22
    |
 LL |     debug_assert_eq!(a + 1, a + 1);
    |                      ^^^^^^^^^^^^
 
 error: identical args used in this `debug_assert_ne!` macro call
-  --> tests/ui/eq_op_macros.rs:53:22
+  --> tests/ui/eq_op_macros.rs:63:22
    |
 LL |     debug_assert_ne!(a, a);
    |                      ^^^^
 
 error: identical args used in this `debug_assert_ne!` macro call
-  --> tests/ui/eq_op_macros.rs:55:22
+  --> tests/ui/eq_op_macros.rs:66:22
    |
 LL |     debug_assert_ne!(a + 1, a + 1);
    |                      ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/equatable_if_let.fixed b/src/tools/clippy/tests/ui/equatable_if_let.fixed
index 2b523e1e185c..166b1387ba26 100644
--- a/src/tools/clippy/tests/ui/equatable_if_let.fixed
+++ b/src/tools/clippy/tests/ui/equatable_if_let.fixed
@@ -62,13 +62,21 @@ fn main() {
     // true
 
     if a == 2 {}
+    //~^ equatable_if_let
     if a.cmp(&b) == Ordering::Greater {}
+    //~^ equatable_if_let
     if c == Some(2) {}
+    //~^ equatable_if_let
     if d == (Struct { a: 2, b: false }) {}
+    //~^ equatable_if_let
     if e == Enum::TupleVariant(32, 64) {}
+    //~^ equatable_if_let
     if e == (Enum::RecordVariant { a: 64, b: 32 }) {}
+    //~^ equatable_if_let
     if e == Enum::UnitVariant {}
+    //~^ equatable_if_let
     if (e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false }) {}
+    //~^ equatable_if_let
 
     // false
 
@@ -78,12 +86,18 @@ fn main() {
     if let Struct { a, b: false } = d {}
     if let Struct { a: 2, b: x } = d {}
     if matches!(f, NotPartialEq::A) {}
+    //~^ equatable_if_let
     if g == NotStructuralEq::A {}
+    //~^ equatable_if_let
     if matches!(Some(f), Some(NotPartialEq::A)) {}
+    //~^ equatable_if_let
     if Some(g) == Some(NotStructuralEq::A) {}
+    //~^ equatable_if_let
     if matches!(h, NoPartialEqStruct { a: 2, b: false }) {}
+    //~^ equatable_if_let
 
     if "abc" == inline!("abc") {
+        //~^ equatable_if_let
         println!("OK");
     }
 
diff --git a/src/tools/clippy/tests/ui/equatable_if_let.rs b/src/tools/clippy/tests/ui/equatable_if_let.rs
index f7e3bb2964da..09c2483ae6d4 100644
--- a/src/tools/clippy/tests/ui/equatable_if_let.rs
+++ b/src/tools/clippy/tests/ui/equatable_if_let.rs
@@ -62,13 +62,21 @@ fn main() {
     // true
 
     if let 2 = a {}
+    //~^ equatable_if_let
     if let Ordering::Greater = a.cmp(&b) {}
+    //~^ equatable_if_let
     if let Some(2) = c {}
+    //~^ equatable_if_let
     if let Struct { a: 2, b: false } = d {}
+    //~^ equatable_if_let
     if let Enum::TupleVariant(32, 64) = e {}
+    //~^ equatable_if_let
     if let Enum::RecordVariant { a: 64, b: 32 } = e {}
+    //~^ equatable_if_let
     if let Enum::UnitVariant = e {}
+    //~^ equatable_if_let
     if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
+    //~^ equatable_if_let
 
     // false
 
@@ -78,12 +86,18 @@ fn main() {
     if let Struct { a, b: false } = d {}
     if let Struct { a: 2, b: x } = d {}
     if let NotPartialEq::A = f {}
+    //~^ equatable_if_let
     if let NotStructuralEq::A = g {}
+    //~^ equatable_if_let
     if let Some(NotPartialEq::A) = Some(f) {}
+    //~^ equatable_if_let
     if let Some(NotStructuralEq::A) = Some(g) {}
+    //~^ equatable_if_let
     if let NoPartialEqStruct { a: 2, b: false } = h {}
+    //~^ equatable_if_let
 
     if let inline!("abc") = "abc" {
+        //~^ equatable_if_let
         println!("OK");
     }
 
diff --git a/src/tools/clippy/tests/ui/equatable_if_let.stderr b/src/tools/clippy/tests/ui/equatable_if_let.stderr
index 9e93a33cd7e2..81e0e15a5c74 100644
--- a/src/tools/clippy/tests/ui/equatable_if_let.stderr
+++ b/src/tools/clippy/tests/ui/equatable_if_let.stderr
@@ -8,79 +8,79 @@ LL |     if let 2 = a {}
    = help: to override `-D warnings` add `#[allow(clippy::equatable_if_let)]`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:65:8
+  --> tests/ui/equatable_if_let.rs:66:8
    |
 LL |     if let Ordering::Greater = a.cmp(&b) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.cmp(&b) == Ordering::Greater`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:66:8
+  --> tests/ui/equatable_if_let.rs:68:8
    |
 LL |     if let Some(2) = c {}
    |        ^^^^^^^^^^^^^^^ help: try: `c == Some(2)`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:67:8
+  --> tests/ui/equatable_if_let.rs:70:8
    |
 LL |     if let Struct { a: 2, b: false } = d {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `d == (Struct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:68:8
+  --> tests/ui/equatable_if_let.rs:72:8
    |
 LL |     if let Enum::TupleVariant(32, 64) = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::TupleVariant(32, 64)`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:69:8
+  --> tests/ui/equatable_if_let.rs:74:8
    |
 LL |     if let Enum::RecordVariant { a: 64, b: 32 } = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == (Enum::RecordVariant { a: 64, b: 32 })`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:70:8
+  --> tests/ui/equatable_if_let.rs:76:8
    |
 LL |     if let Enum::UnitVariant = e {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `e == Enum::UnitVariant`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:71:8
+  --> tests/ui/equatable_if_let.rs:78:8
    |
 LL |     if let (Enum::UnitVariant, &Struct { a: 2, b: false }) = (e, &d) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(e, &d) == (Enum::UnitVariant, &Struct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using `matches!`
-  --> tests/ui/equatable_if_let.rs:80:8
+  --> tests/ui/equatable_if_let.rs:88:8
    |
 LL |     if let NotPartialEq::A = f {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(f, NotPartialEq::A)`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:81:8
+  --> tests/ui/equatable_if_let.rs:90:8
    |
 LL |     if let NotStructuralEq::A = g {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `g == NotStructuralEq::A`
 
 error: this pattern matching can be expressed using `matches!`
-  --> tests/ui/equatable_if_let.rs:82:8
+  --> tests/ui/equatable_if_let.rs:92:8
    |
 LL |     if let Some(NotPartialEq::A) = Some(f) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(Some(f), Some(NotPartialEq::A))`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:83:8
+  --> tests/ui/equatable_if_let.rs:94:8
    |
 LL |     if let Some(NotStructuralEq::A) = Some(g) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(g) == Some(NotStructuralEq::A)`
 
 error: this pattern matching can be expressed using `matches!`
-  --> tests/ui/equatable_if_let.rs:84:8
+  --> tests/ui/equatable_if_let.rs:96:8
    |
 LL |     if let NoPartialEqStruct { a: 2, b: false } = h {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(h, NoPartialEqStruct { a: 2, b: false })`
 
 error: this pattern matching can be expressed using equality
-  --> tests/ui/equatable_if_let.rs:86:8
+  --> tests/ui/equatable_if_let.rs:99:8
    |
 LL |     if let inline!("abc") = "abc" {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"abc" == inline!("abc")`
diff --git a/src/tools/clippy/tests/ui/erasing_op.rs b/src/tools/clippy/tests/ui/erasing_op.rs
index 00c74f23fed0..9237b9eb11f0 100644
--- a/src/tools/clippy/tests/ui/erasing_op.rs
+++ b/src/tools/clippy/tests/ui/erasing_op.rs
@@ -33,17 +33,20 @@ impl core::ops::Mul<i32> for Vec1 {
 #[warn(clippy::erasing_op)]
 fn test(x: u8) {
     x * 0;
-    //~^ ERROR: this operation will always return zero. This is likely not the intended ou
-    //~| NOTE: `-D clippy::erasing-op` implied by `-D warnings`
+    //~^ erasing_op
+
     0 & x;
-    //~^ ERROR: this operation will always return zero. This is likely not the intended ou
+    //~^ erasing_op
+
     0 / x;
-    //~^ ERROR: this operation will always return zero. This is likely not the intended ou
+    //~^ erasing_op
+
     0 * Meter; // no error: Output type is different from the non-zero argument
     0 * Vec1 { x: 5 };
-    //~^ ERROR: this operation will always return zero. This is likely not the intended ou
+    //~^ erasing_op
+
     Vec1 { x: 5 } * 0;
-    //~^ ERROR: this operation will always return zero. This is likely not the intended ou
+    //~^ erasing_op
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/erasing_op.stderr b/src/tools/clippy/tests/ui/erasing_op.stderr
index 6ed8bffeb24d..94730b066801 100644
--- a/src/tools/clippy/tests/ui/erasing_op.stderr
+++ b/src/tools/clippy/tests/ui/erasing_op.stderr
@@ -14,19 +14,19 @@ LL |     0 & x;
    |     ^^^^^
 
 error: this operation will always return zero. This is likely not the intended outcome
-  --> tests/ui/erasing_op.rs:40:5
+  --> tests/ui/erasing_op.rs:41:5
    |
 LL |     0 / x;
    |     ^^^^^
 
 error: this operation will always return zero. This is likely not the intended outcome
-  --> tests/ui/erasing_op.rs:43:5
+  --> tests/ui/erasing_op.rs:45:5
    |
 LL |     0 * Vec1 { x: 5 };
    |     ^^^^^^^^^^^^^^^^^
 
 error: this operation will always return zero. This is likely not the intended outcome
-  --> tests/ui/erasing_op.rs:45:5
+  --> tests/ui/erasing_op.rs:48:5
    |
 LL |     Vec1 { x: 5 } * 0;
    |     ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/err_expect.fixed b/src/tools/clippy/tests/ui/err_expect.fixed
index abbc6dbebedb..9e1a3a0c739c 100644
--- a/src/tools/clippy/tests/ui/err_expect.fixed
+++ b/src/tools/clippy/tests/ui/err_expect.fixed
@@ -8,6 +8,7 @@ struct MyTypeDebug;
 fn main() {
     let test_debug: Result<MyTypeDebug, u32> = Ok(MyTypeDebug);
     test_debug.expect_err("Testing debug type");
+    //~^ err_expect
 
     let test_non_debug: Result<MyTypeNonDebug, u32> = Ok(MyTypeNonDebug);
     test_non_debug.err().expect("Testing non debug type");
@@ -23,4 +24,5 @@ fn msrv_1_16() {
 fn msrv_1_17() {
     let x: Result<u32, &str> = Ok(17);
     x.expect_err("17");
+    //~^ err_expect
 }
diff --git a/src/tools/clippy/tests/ui/err_expect.rs b/src/tools/clippy/tests/ui/err_expect.rs
index 0c7ad185dfbe..8e9063a2e1d4 100644
--- a/src/tools/clippy/tests/ui/err_expect.rs
+++ b/src/tools/clippy/tests/ui/err_expect.rs
@@ -8,6 +8,7 @@ struct MyTypeDebug;
 fn main() {
     let test_debug: Result<MyTypeDebug, u32> = Ok(MyTypeDebug);
     test_debug.err().expect("Testing debug type");
+    //~^ err_expect
 
     let test_non_debug: Result<MyTypeNonDebug, u32> = Ok(MyTypeNonDebug);
     test_non_debug.err().expect("Testing non debug type");
@@ -23,4 +24,5 @@ fn msrv_1_16() {
 fn msrv_1_17() {
     let x: Result<u32, &str> = Ok(17);
     x.err().expect("17");
+    //~^ err_expect
 }
diff --git a/src/tools/clippy/tests/ui/err_expect.stderr b/src/tools/clippy/tests/ui/err_expect.stderr
index 68f39cc45c5b..5b591e1604db 100644
--- a/src/tools/clippy/tests/ui/err_expect.stderr
+++ b/src/tools/clippy/tests/ui/err_expect.stderr
@@ -8,7 +8,7 @@ LL |     test_debug.err().expect("Testing debug type");
    = help: to override `-D warnings` add `#[allow(clippy::err_expect)]`
 
 error: called `.err().expect()` on a `Result` value
-  --> tests/ui/err_expect.rs:25:7
+  --> tests/ui/err_expect.rs:26:7
    |
 LL |     x.err().expect("17");
    |       ^^^^^^^^^^^^ help: try: `expect_err`
diff --git a/src/tools/clippy/tests/ui/error_impl_error.rs b/src/tools/clippy/tests/ui/error_impl_error.rs
index 05003f7d047c..5c88888f38ea 100644
--- a/src/tools/clippy/tests/ui/error_impl_error.rs
+++ b/src/tools/clippy/tests/ui/error_impl_error.rs
@@ -5,7 +5,7 @@
 pub mod a {
     #[derive(Debug)]
     pub struct Error;
-    //~^ ERROR: exported type named `Error` that implements `Error`
+    //~^ error_impl_error
 
     impl std::fmt::Display for Error {
         fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -19,7 +19,7 @@ pub mod a {
 mod b {
     #[derive(Debug)]
     pub(super) enum Error {}
-    //~^ ERROR: exported type named `Error` that implements `Error`
+    //~^ error_impl_error
 
     impl std::fmt::Display for Error {
         fn fmt(&self, _: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
@@ -32,7 +32,7 @@ mod b {
 
 pub mod c {
     pub union Error {
-        //~^ ERROR: exported type named `Error` that implements `Error`
+        //~^ error_impl_error
         a: u32,
         b: u32,
     }
@@ -54,7 +54,7 @@ pub mod c {
 
 pub mod d {
     pub type Error = std::fmt::Error;
-    //~^ ERROR: exported type alias named `Error` that implements `Error`
+    //~^ error_impl_error
 }
 
 mod e {
diff --git a/src/tools/clippy/tests/ui/eta.fixed b/src/tools/clippy/tests/ui/eta.fixed
index abccc30ef87d..0ba631fda051 100644
--- a/src/tools/clippy/tests/ui/eta.fixed
+++ b/src/tools/clippy/tests/ui/eta.fixed
@@ -29,12 +29,19 @@ macro_rules! closure_mac {
 
 fn main() {
     let a = Some(1u8).map(foo);
+    //~^ redundant_closure
     let c = Some(1u8).map(|a| {1+2; foo}(a));
     true.then(|| mac!()); // don't lint function in macro expansion
     Some(1).map(closure_mac!()); // don't lint closure in macro expansion
     let _: Option<Vec<u8>> = true.then(std::vec::Vec::new); // special case vec!
+    //
+    //~^^ redundant_closure
     let d = Some(1u8).map(|a| foo(foo2(a))); //is adjusted?
+    //
+    //~^^ redundant_closure
     all(&[1, 2, 3], &&2, below); //is adjusted
+    //
+    //~^^ redundant_closure
     unsafe {
         Some(1u8).map(|a| unsafe_fn(a)); // unsafe fn
     }
@@ -42,6 +49,7 @@ fn main() {
     // See #815
     let e = Some(1u8).map(|a| divergent(a));
     let e = Some(1u8).map(generic);
+    //~^ redundant_closure
     let e = Some(1u8).map(generic);
     // See #515
     let a: Option<Box<dyn (::std::ops::Deref<Target = [i32]>)>> =
@@ -94,16 +102,22 @@ impl<'a> std::ops::Deref for TestStruct<'a> {
 fn test_redundant_closures_containing_method_calls() {
     let i = 10;
     let e = Some(TestStruct { some_ref: &i }).map(TestStruct::foo);
+    //~^ redundant_closure_for_method_calls
     let e = Some(TestStruct { some_ref: &i }).map(TestTrait::trait_foo);
+    //~^ redundant_closure_for_method_calls
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo_ref());
     let e = Some(&mut vec![1, 2, 3]).map(std::vec::Vec::clear);
+    //~^ redundant_closure_for_method_calls
     unsafe {
         let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo_unsafe());
     }
     let e = Some("str").map(std::string::ToString::to_string);
+    //~^ redundant_closure_for_method_calls
     let e = Some('a').map(char::to_uppercase);
+    //~^ redundant_closure_for_method_calls
     let e: std::vec::Vec<usize> = vec!['a', 'b', 'c'].iter().map(|c| c.len_utf8()).collect();
     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(char::to_ascii_uppercase).collect();
+    //~^ redundant_closure_for_method_calls
     let e = Some(PathBuf::new()).as_ref().and_then(|s| s.to_str());
     let c = Some(TestStruct { some_ref: &i })
         .as_ref()
@@ -120,6 +134,7 @@ fn test_redundant_closures_containing_method_calls() {
     fn issue14096() {
         let x = Some("42");
         let _ = x.map(str::parse::<i16>);
+        //~^ redundant_closure_for_method_calls
     }
 }
 
@@ -172,6 +187,7 @@ fn generic<T>(_: T) -> u8 {
 
 fn passes_fn_mut(mut x: Box<dyn FnMut()>) {
     requires_fn_once(x);
+    //~^ redundant_closure
 }
 fn requires_fn_once<T: FnOnce()>(_: T) {}
 
@@ -179,11 +195,13 @@ fn test_redundant_closure_with_function_pointer() {
     type FnPtrType = fn(u8);
     let foo_ptr: FnPtrType = foo;
     let a = Some(1u8).map(foo_ptr);
+    //~^ redundant_closure
 }
 
 fn test_redundant_closure_with_another_closure() {
     let closure = |a| println!("{}", a);
     let a = Some(1u8).map(closure);
+    //~^ redundant_closure
 }
 
 fn make_lazy(f: impl Fn() -> fn(u8) -> u8) -> impl Fn(u8) -> u8 {
@@ -216,8 +234,11 @@ fn mutable_closure_used_again(x: Vec<i32>, y: Vec<i32>, z: Vec<i32>) {
     let mut res = Vec::new();
     let mut add_to_res = |n| res.push(n);
     x.into_iter().for_each(&mut add_to_res);
+    //~^ redundant_closure
     y.into_iter().for_each(&mut add_to_res);
+    //~^ redundant_closure
     z.into_iter().for_each(add_to_res);
+    //~^ redundant_closure
 }
 
 fn mutable_closure_in_loop() {
@@ -225,10 +246,12 @@ fn mutable_closure_in_loop() {
     let mut closure = |n| value += n;
     for _ in 0..5 {
         Some(1).map(&mut closure);
+        //~^ redundant_closure
 
         let mut value = 0;
         let mut in_loop = |n| value += n;
         Some(1).map(in_loop);
+        //~^ redundant_closure
     }
 }
 
@@ -322,13 +345,16 @@ fn not_general_enough() {
 pub fn mutable_impl_fn_mut(mut f: impl FnMut(), mut f_used_once: impl FnMut()) -> impl FnMut() {
     fn takes_fn_mut(_: impl FnMut()) {}
     takes_fn_mut(&mut f);
+    //~^ redundant_closure
 
     fn takes_fn_once(_: impl FnOnce()) {}
     takes_fn_once(&mut f);
+    //~^ redundant_closure
 
     f();
 
     move || takes_fn_mut(&mut f_used_once)
+    //~^ redundant_closure
 }
 
 impl dyn TestTrait + '_ {
@@ -341,16 +367,20 @@ impl dyn TestTrait + '_ {
 fn angle_brackets_and_args() {
     let array_opt: Option<&[u8; 3]> = Some(&[4, 8, 7]);
     array_opt.map(<[u8; 3]>::as_slice);
+    //~^ redundant_closure_for_method_calls
 
     let slice_opt: Option<&[u8]> = Some(b"slice");
     slice_opt.map(<[u8]>::len);
+    //~^ redundant_closure_for_method_calls
 
     let ptr_opt: Option<*const usize> = Some(&487);
     ptr_opt.map(<*const usize>::is_null);
+    //~^ redundant_closure_for_method_calls
 
     let test_struct = TestStruct { some_ref: &487 };
     let dyn_opt: Option<&dyn TestTrait> = Some(&test_struct);
     dyn_opt.map(<dyn TestTrait>::method_on_dyn);
+    //~^ redundant_closure_for_method_calls
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/12199
@@ -411,6 +441,7 @@ fn _mixed_late_bound_and_early_bound_regions() {
         *y
     }
     let _ = f(&0, f2);
+    //~^ redundant_closure
 }
 
 fn _closure_with_types() {
@@ -439,10 +470,12 @@ mod issue_10854 {
 
         pub fn calls_test(test: Option<Test>) -> Option<i32> {
             test.map(Test::method)
+            //~^ redundant_closure_for_method_calls
         }
 
         pub fn calls_outer(test: Option<super::Outer>) -> Option<i32> {
             test.map(super::Outer::method)
+            //~^ redundant_closure_for_method_calls
         }
     }
 
@@ -456,6 +489,7 @@ mod issue_10854 {
 
     pub fn calls_into_mod(test: Option<test_mod::Test>) -> Option<i32> {
         test.map(test_mod::Test::method)
+        //~^ redundant_closure_for_method_calls
     }
 
     mod a {
@@ -463,6 +497,7 @@ mod issue_10854 {
             pub mod c {
                 pub fn extreme_nesting(test: Option<super::super::super::d::Test>) -> Option<i32> {
                     test.map(crate::issue_10854::d::Test::method)
+                    //~^ redundant_closure_for_method_calls
                 }
             }
         }
@@ -482,10 +517,12 @@ mod issue_10854 {
 mod issue_12853 {
     fn f_by_value<F: Fn(u32)>(f: F) {
         let x = Box::new(|| None.map(&f));
+        //~^ redundant_closure
         x();
     }
     fn f_by_ref<F: Fn(u32)>(f: &F) {
         let x = Box::new(|| None.map(f));
+        //~^ redundant_closure
         x();
     }
 }
@@ -503,5 +540,6 @@ mod issue_13073 {
         let _field = bind.as_deref().or_else(|| get_default()).unwrap();
         // should lint
         let _field = bind.or_else(get_default).unwrap();
+        //~^ redundant_closure
     }
 }
diff --git a/src/tools/clippy/tests/ui/eta.rs b/src/tools/clippy/tests/ui/eta.rs
index 9bcee4eba340..4d8b29d450c5 100644
--- a/src/tools/clippy/tests/ui/eta.rs
+++ b/src/tools/clippy/tests/ui/eta.rs
@@ -29,12 +29,19 @@ macro_rules! closure_mac {
 
 fn main() {
     let a = Some(1u8).map(|a| foo(a));
+    //~^ redundant_closure
     let c = Some(1u8).map(|a| {1+2; foo}(a));
     true.then(|| mac!()); // don't lint function in macro expansion
     Some(1).map(closure_mac!()); // don't lint closure in macro expansion
     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
+    //
+    //~^^ redundant_closure
     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
+    //
+    //~^^ redundant_closure
     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
+    //
+    //~^^ redundant_closure
     unsafe {
         Some(1u8).map(|a| unsafe_fn(a)); // unsafe fn
     }
@@ -42,6 +49,7 @@ fn main() {
     // See #815
     let e = Some(1u8).map(|a| divergent(a));
     let e = Some(1u8).map(|a| generic(a));
+    //~^ redundant_closure
     let e = Some(1u8).map(generic);
     // See #515
     let a: Option<Box<dyn (::std::ops::Deref<Target = [i32]>)>> =
@@ -94,16 +102,22 @@ impl<'a> std::ops::Deref for TestStruct<'a> {
 fn test_redundant_closures_containing_method_calls() {
     let i = 10;
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
+    //~^ redundant_closure_for_method_calls
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
+    //~^ redundant_closure_for_method_calls
     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo_ref());
     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
+    //~^ redundant_closure_for_method_calls
     unsafe {
         let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo_unsafe());
     }
     let e = Some("str").map(|s| s.to_string());
+    //~^ redundant_closure_for_method_calls
     let e = Some('a').map(|s| s.to_uppercase());
+    //~^ redundant_closure_for_method_calls
     let e: std::vec::Vec<usize> = vec!['a', 'b', 'c'].iter().map(|c| c.len_utf8()).collect();
     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
+    //~^ redundant_closure_for_method_calls
     let e = Some(PathBuf::new()).as_ref().and_then(|s| s.to_str());
     let c = Some(TestStruct { some_ref: &i })
         .as_ref()
@@ -120,6 +134,7 @@ fn test_redundant_closures_containing_method_calls() {
     fn issue14096() {
         let x = Some("42");
         let _ = x.map(|x| x.parse::<i16>());
+        //~^ redundant_closure_for_method_calls
     }
 }
 
@@ -172,6 +187,7 @@ fn generic<T>(_: T) -> u8 {
 
 fn passes_fn_mut(mut x: Box<dyn FnMut()>) {
     requires_fn_once(|| x());
+    //~^ redundant_closure
 }
 fn requires_fn_once<T: FnOnce()>(_: T) {}
 
@@ -179,11 +195,13 @@ fn test_redundant_closure_with_function_pointer() {
     type FnPtrType = fn(u8);
     let foo_ptr: FnPtrType = foo;
     let a = Some(1u8).map(|a| foo_ptr(a));
+    //~^ redundant_closure
 }
 
 fn test_redundant_closure_with_another_closure() {
     let closure = |a| println!("{}", a);
     let a = Some(1u8).map(|a| closure(a));
+    //~^ redundant_closure
 }
 
 fn make_lazy(f: impl Fn() -> fn(u8) -> u8) -> impl Fn(u8) -> u8 {
@@ -216,8 +234,11 @@ fn mutable_closure_used_again(x: Vec<i32>, y: Vec<i32>, z: Vec<i32>) {
     let mut res = Vec::new();
     let mut add_to_res = |n| res.push(n);
     x.into_iter().for_each(|x| add_to_res(x));
+    //~^ redundant_closure
     y.into_iter().for_each(|x| add_to_res(x));
+    //~^ redundant_closure
     z.into_iter().for_each(|x| add_to_res(x));
+    //~^ redundant_closure
 }
 
 fn mutable_closure_in_loop() {
@@ -225,10 +246,12 @@ fn mutable_closure_in_loop() {
     let mut closure = |n| value += n;
     for _ in 0..5 {
         Some(1).map(|n| closure(n));
+        //~^ redundant_closure
 
         let mut value = 0;
         let mut in_loop = |n| value += n;
         Some(1).map(|n| in_loop(n));
+        //~^ redundant_closure
     }
 }
 
@@ -322,13 +345,16 @@ fn not_general_enough() {
 pub fn mutable_impl_fn_mut(mut f: impl FnMut(), mut f_used_once: impl FnMut()) -> impl FnMut() {
     fn takes_fn_mut(_: impl FnMut()) {}
     takes_fn_mut(|| f());
+    //~^ redundant_closure
 
     fn takes_fn_once(_: impl FnOnce()) {}
     takes_fn_once(|| f());
+    //~^ redundant_closure
 
     f();
 
     move || takes_fn_mut(|| f_used_once())
+    //~^ redundant_closure
 }
 
 impl dyn TestTrait + '_ {
@@ -341,16 +367,20 @@ impl dyn TestTrait + '_ {
 fn angle_brackets_and_args() {
     let array_opt: Option<&[u8; 3]> = Some(&[4, 8, 7]);
     array_opt.map(|a| a.as_slice());
+    //~^ redundant_closure_for_method_calls
 
     let slice_opt: Option<&[u8]> = Some(b"slice");
     slice_opt.map(|s| s.len());
+    //~^ redundant_closure_for_method_calls
 
     let ptr_opt: Option<*const usize> = Some(&487);
     ptr_opt.map(|p| p.is_null());
+    //~^ redundant_closure_for_method_calls
 
     let test_struct = TestStruct { some_ref: &487 };
     let dyn_opt: Option<&dyn TestTrait> = Some(&test_struct);
     dyn_opt.map(|d| d.method_on_dyn());
+    //~^ redundant_closure_for_method_calls
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/12199
@@ -411,6 +441,7 @@ fn _mixed_late_bound_and_early_bound_regions() {
         *y
     }
     let _ = f(&0, |x, y| f2(x, y));
+    //~^ redundant_closure
 }
 
 fn _closure_with_types() {
@@ -439,10 +470,12 @@ mod issue_10854 {
 
         pub fn calls_test(test: Option<Test>) -> Option<i32> {
             test.map(|t| t.method())
+            //~^ redundant_closure_for_method_calls
         }
 
         pub fn calls_outer(test: Option<super::Outer>) -> Option<i32> {
             test.map(|t| t.method())
+            //~^ redundant_closure_for_method_calls
         }
     }
 
@@ -456,6 +489,7 @@ mod issue_10854 {
 
     pub fn calls_into_mod(test: Option<test_mod::Test>) -> Option<i32> {
         test.map(|t| t.method())
+        //~^ redundant_closure_for_method_calls
     }
 
     mod a {
@@ -463,6 +497,7 @@ mod issue_10854 {
             pub mod c {
                 pub fn extreme_nesting(test: Option<super::super::super::d::Test>) -> Option<i32> {
                     test.map(|t| t.method())
+                    //~^ redundant_closure_for_method_calls
                 }
             }
         }
@@ -482,10 +517,12 @@ mod issue_10854 {
 mod issue_12853 {
     fn f_by_value<F: Fn(u32)>(f: F) {
         let x = Box::new(|| None.map(|x| f(x)));
+        //~^ redundant_closure
         x();
     }
     fn f_by_ref<F: Fn(u32)>(f: &F) {
         let x = Box::new(|| None.map(|x| f(x)));
+        //~^ redundant_closure
         x();
     }
 }
@@ -503,5 +540,6 @@ mod issue_13073 {
         let _field = bind.as_deref().or_else(|| get_default()).unwrap();
         // should lint
         let _field = bind.or_else(|| get_default()).unwrap();
+        //~^ redundant_closure
     }
 }
diff --git a/src/tools/clippy/tests/ui/eta.stderr b/src/tools/clippy/tests/ui/eta.stderr
index ac58e87bc5ec..8bc08add2fab 100644
--- a/src/tools/clippy/tests/ui/eta.stderr
+++ b/src/tools/clippy/tests/ui/eta.stderr
@@ -8,31 +8,31 @@ LL |     let a = Some(1u8).map(|a| foo(a));
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
 
 error: redundant closure
-  --> tests/ui/eta.rs:35:40
+  --> tests/ui/eta.rs:36:40
    |
 LL |     let _: Option<Vec<u8>> = true.then(|| vec![]); // special case vec!
    |                                        ^^^^^^^^^ help: replace the closure with `Vec::new`: `std::vec::Vec::new`
 
 error: redundant closure
-  --> tests/ui/eta.rs:36:35
+  --> tests/ui/eta.rs:39:35
    |
 LL |     let d = Some(1u8).map(|a| foo((|b| foo2(b))(a))); //is adjusted?
    |                                   ^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo2`
 
 error: redundant closure
-  --> tests/ui/eta.rs:37:26
+  --> tests/ui/eta.rs:42:26
    |
 LL |     all(&[1, 2, 3], &&2, |x, y| below(x, y)); //is adjusted
    |                          ^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `below`
 
 error: redundant closure
-  --> tests/ui/eta.rs:44:27
+  --> tests/ui/eta.rs:51:27
    |
 LL |     let e = Some(1u8).map(|a| generic(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `generic`
 
 error: redundant closure
-  --> tests/ui/eta.rs:96:51
+  --> tests/ui/eta.rs:104:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    |                                                   ^^^^^^^^^^^ help: replace the closure with the method itself: `TestStruct::foo`
@@ -41,175 +41,175 @@ LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.foo());
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_for_method_calls)]`
 
 error: redundant closure
-  --> tests/ui/eta.rs:97:51
+  --> tests/ui/eta.rs:106:51
    |
 LL |     let e = Some(TestStruct { some_ref: &i }).map(|a| a.trait_foo());
    |                                                   ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `TestTrait::trait_foo`
 
 error: redundant closure
-  --> tests/ui/eta.rs:99:42
+  --> tests/ui/eta.rs:109:42
    |
 LL |     let e = Some(&mut vec![1, 2, 3]).map(|v| v.clear());
    |                                          ^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::vec::Vec::clear`
 
 error: redundant closure
-  --> tests/ui/eta.rs:103:29
+  --> tests/ui/eta.rs:114:29
    |
 LL |     let e = Some("str").map(|s| s.to_string());
    |                             ^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `std::string::ToString::to_string`
 
 error: redundant closure
-  --> tests/ui/eta.rs:104:27
+  --> tests/ui/eta.rs:116:27
    |
 LL |     let e = Some('a').map(|s| s.to_uppercase());
    |                           ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_uppercase`
 
 error: redundant closure
-  --> tests/ui/eta.rs:106:65
+  --> tests/ui/eta.rs:119:65
    |
 LL |     let e: std::vec::Vec<char> = vec!['a', 'b', 'c'].iter().map(|c| c.to_ascii_uppercase()).collect();
    |                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `char::to_ascii_uppercase`
 
 error: redundant closure
-  --> tests/ui/eta.rs:122:23
+  --> tests/ui/eta.rs:136:23
    |
 LL |         let _ = x.map(|x| x.parse::<i16>());
    |                       ^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `str::parse::<i16>`
 
 error: redundant closure
-  --> tests/ui/eta.rs:174:22
+  --> tests/ui/eta.rs:189:22
    |
 LL |     requires_fn_once(|| x());
    |                      ^^^^^^ help: replace the closure with the function itself: `x`
 
 error: redundant closure
-  --> tests/ui/eta.rs:181:27
+  --> tests/ui/eta.rs:197:27
    |
 LL |     let a = Some(1u8).map(|a| foo_ptr(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `foo_ptr`
 
 error: redundant closure
-  --> tests/ui/eta.rs:186:27
+  --> tests/ui/eta.rs:203:27
    |
 LL |     let a = Some(1u8).map(|a| closure(a));
    |                           ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `closure`
 
 error: redundant closure
-  --> tests/ui/eta.rs:218:28
+  --> tests/ui/eta.rs:236:28
    |
 LL |     x.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:219:28
+  --> tests/ui/eta.rs:238:28
    |
 LL |     y.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:220:28
+  --> tests/ui/eta.rs:240:28
    |
 LL |     z.into_iter().for_each(|x| add_to_res(x));
    |                            ^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `add_to_res`
 
 error: redundant closure
-  --> tests/ui/eta.rs:227:21
+  --> tests/ui/eta.rs:248:21
    |
 LL |         Some(1).map(|n| closure(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut closure`
 
 error: redundant closure
-  --> tests/ui/eta.rs:231:21
+  --> tests/ui/eta.rs:253:21
    |
 LL |         Some(1).map(|n| in_loop(n));
    |                     ^^^^^^^^^^^^^^ help: replace the closure with the function itself: `in_loop`
 
 error: redundant closure
-  --> tests/ui/eta.rs:324:18
+  --> tests/ui/eta.rs:347:18
    |
 LL |     takes_fn_mut(|| f());
    |                  ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:327:19
+  --> tests/ui/eta.rs:351:19
    |
 LL |     takes_fn_once(|| f());
    |                   ^^^^^^ help: replace the closure with the function itself: `&mut f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:331:26
+  --> tests/ui/eta.rs:356:26
    |
 LL |     move || takes_fn_mut(|| f_used_once())
    |                          ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `&mut f_used_once`
 
 error: redundant closure
-  --> tests/ui/eta.rs:343:19
+  --> tests/ui/eta.rs:369:19
    |
 LL |     array_opt.map(|a| a.as_slice());
    |                   ^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8; 3]>::as_slice`
 
 error: redundant closure
-  --> tests/ui/eta.rs:346:19
+  --> tests/ui/eta.rs:373:19
    |
 LL |     slice_opt.map(|s| s.len());
    |                   ^^^^^^^^^^^ help: replace the closure with the method itself: `<[u8]>::len`
 
 error: redundant closure
-  --> tests/ui/eta.rs:349:17
+  --> tests/ui/eta.rs:377:17
    |
 LL |     ptr_opt.map(|p| p.is_null());
    |                 ^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<*const usize>::is_null`
 
 error: redundant closure
-  --> tests/ui/eta.rs:353:17
+  --> tests/ui/eta.rs:382:17
    |
 LL |     dyn_opt.map(|d| d.method_on_dyn());
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the method itself: `<dyn TestTrait>::method_on_dyn`
 
 error: redundant closure
-  --> tests/ui/eta.rs:413:19
+  --> tests/ui/eta.rs:443:19
    |
 LL |     let _ = f(&0, |x, y| f2(x, y));
    |                   ^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `f2`
 
 error: redundant closure
-  --> tests/ui/eta.rs:441:22
+  --> tests/ui/eta.rs:472:22
    |
 LL |             test.map(|t| t.method())
    |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:445:22
+  --> tests/ui/eta.rs:477:22
    |
 LL |             test.map(|t| t.method())
    |                      ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `super::Outer::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:458:18
+  --> tests/ui/eta.rs:491:18
    |
 LL |         test.map(|t| t.method())
    |                  ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `test_mod::Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:465:30
+  --> tests/ui/eta.rs:499:30
    |
 LL |                     test.map(|t| t.method())
    |                              ^^^^^^^^^^^^^^ help: replace the closure with the method itself: `crate::issue_10854::d::Test::method`
 
 error: redundant closure
-  --> tests/ui/eta.rs:484:38
+  --> tests/ui/eta.rs:519:38
    |
 LL |         let x = Box::new(|| None.map(|x| f(x)));
    |                                      ^^^^^^^^ help: replace the closure with the function itself: `&f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:488:38
+  --> tests/ui/eta.rs:524:38
    |
 LL |         let x = Box::new(|| None.map(|x| f(x)));
    |                                      ^^^^^^^^ help: replace the closure with the function itself: `f`
 
 error: redundant closure
-  --> tests/ui/eta.rs:505:35
+  --> tests/ui/eta.rs:542:35
    |
 LL |         let _field = bind.or_else(|| get_default()).unwrap();
    |                                   ^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `get_default`
diff --git a/src/tools/clippy/tests/ui/eta_nostd.fixed b/src/tools/clippy/tests/ui/eta_nostd.fixed
index 23059c52b67f..134af34a826a 100644
--- a/src/tools/clippy/tests/ui/eta_nostd.fixed
+++ b/src/tools/clippy/tests/ui/eta_nostd.fixed
@@ -7,4 +7,5 @@ use alloc::vec::Vec;
 
 fn issue_13895() {
     let _: Option<Vec<u8>> = true.then(alloc::vec::Vec::new);
+    //~^ redundant_closure
 }
diff --git a/src/tools/clippy/tests/ui/eta_nostd.rs b/src/tools/clippy/tests/ui/eta_nostd.rs
index ae44ac348c64..8d0541bedb2e 100644
--- a/src/tools/clippy/tests/ui/eta_nostd.rs
+++ b/src/tools/clippy/tests/ui/eta_nostd.rs
@@ -7,4 +7,5 @@ use alloc::vec::Vec;
 
 fn issue_13895() {
     let _: Option<Vec<u8>> = true.then(|| vec![]);
+    //~^ redundant_closure
 }
diff --git a/src/tools/clippy/tests/ui/excessive_precision.fixed b/src/tools/clippy/tests/ui/excessive_precision.fixed
index 372f64f7d99e..99d09774d16d 100644
--- a/src/tools/clippy/tests/ui/excessive_precision.fixed
+++ b/src/tools/clippy/tests/ui/excessive_precision.fixed
@@ -18,16 +18,22 @@ fn main() {
     const GOOD64_DOT: f32 = 10_000_000_000_000_000.0;
 
     const BAD32_1: f32 = 0.123_456_79_f32;
+    //~^ excessive_precision
     const BAD32_2: f32 = 0.123_456_79;
+    //~^ excessive_precision
     const BAD32_3: f32 = 0.1;
+    //~^ excessive_precision
     const BAD32_EDGE: f32 = 1.000_001;
+    //~^ excessive_precision
 
     const BAD64_1: f64 = 0.123_456_789_012_345_67f64;
     const BAD64_2: f64 = 0.123_456_789_012_345_67;
     const BAD64_3: f64 = 0.1;
+    //~^ excessive_precision
 
     // Literal as param
     println!("{:?}", 8.888_888_888_888_89);
+    //~^ excessive_precision
 
     // // TODO add inferred type tests for f32
     // Locals
@@ -39,8 +45,11 @@ fn main() {
     let good64_inf = 0.123_456_789_012;
 
     let bad32: f32 = 1.123_456_8;
+    //~^ excessive_precision
     let bad32_suf: f32 = 1.123_456_8_f32;
+    //~^ excessive_precision
     let bad32_inf = 1.123_456_8_f32;
+    //~^ excessive_precision
 
     let bad64: f64 = 0.123_456_789_012_345_67;
     let bad64_suf: f64 = 0.123_456_789_012_345_67f64;
@@ -51,14 +60,18 @@ fn main() {
     let good_vec64: Vec<f64> = vec![0.123_456_789];
 
     let bad_vec32: Vec<f32> = vec![0.123_456_79];
+    //~^ excessive_precision
     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_78];
+    //~^ excessive_precision
 
     // Exponential float notation
     let good_e32: f32 = 1e-10;
     let bad_e32: f32 = 1.123_456_8e-10;
+    //~^ excessive_precision
 
     let good_bige32: f32 = 1E-10;
     let bad_bige32: f32 = 1.123_456_8E-10;
+    //~^ excessive_precision
 
     // Inferred type
     let good_inferred: f32 = 1f32 * 1_000_000_000.;
@@ -68,9 +81,11 @@ fn main() {
 
     // issue #7744
     let _ = 2.225_073_858_507_201e-308_f64;
+    //~^ excessive_precision
 
     // issue #7745
     let _ = 0_f64;
+    //~^ excessive_precision
 
     // issue #9910
     const INF1: f32 = 1.0e+33f32;
@@ -81,5 +96,6 @@ fn main() {
 
     // issue #12954
     const _: f64 = 3.0;
+    //~^ excessive_precision
     const _: f64 = 3.0000000000000000;
 }
diff --git a/src/tools/clippy/tests/ui/excessive_precision.rs b/src/tools/clippy/tests/ui/excessive_precision.rs
index 1e40efbf2452..a542fb2e7e3c 100644
--- a/src/tools/clippy/tests/ui/excessive_precision.rs
+++ b/src/tools/clippy/tests/ui/excessive_precision.rs
@@ -18,16 +18,22 @@ fn main() {
     const GOOD64_DOT: f32 = 10_000_000_000_000_000.0;
 
     const BAD32_1: f32 = 0.123_456_789_f32;
+    //~^ excessive_precision
     const BAD32_2: f32 = 0.123_456_789;
+    //~^ excessive_precision
     const BAD32_3: f32 = 0.100_000_000_000_1;
+    //~^ excessive_precision
     const BAD32_EDGE: f32 = 1.000_000_9;
+    //~^ excessive_precision
 
     const BAD64_1: f64 = 0.123_456_789_012_345_67f64;
     const BAD64_2: f64 = 0.123_456_789_012_345_67;
     const BAD64_3: f64 = 0.100_000_000_000_000_000_1;
+    //~^ excessive_precision
 
     // Literal as param
     println!("{:?}", 8.888_888_888_888_888_888_888);
+    //~^ excessive_precision
 
     // // TODO add inferred type tests for f32
     // Locals
@@ -39,8 +45,11 @@ fn main() {
     let good64_inf = 0.123_456_789_012;
 
     let bad32: f32 = 1.123_456_789;
+    //~^ excessive_precision
     let bad32_suf: f32 = 1.123_456_789_f32;
+    //~^ excessive_precision
     let bad32_inf = 1.123_456_789_f32;
+    //~^ excessive_precision
 
     let bad64: f64 = 0.123_456_789_012_345_67;
     let bad64_suf: f64 = 0.123_456_789_012_345_67f64;
@@ -51,14 +60,18 @@ fn main() {
     let good_vec64: Vec<f64> = vec![0.123_456_789];
 
     let bad_vec32: Vec<f32> = vec![0.123_456_789];
+    //~^ excessive_precision
     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_789];
+    //~^ excessive_precision
 
     // Exponential float notation
     let good_e32: f32 = 1e-10;
     let bad_e32: f32 = 1.123_456_788_888e-10;
+    //~^ excessive_precision
 
     let good_bige32: f32 = 1E-10;
     let bad_bige32: f32 = 1.123_456_788_888E-10;
+    //~^ excessive_precision
 
     // Inferred type
     let good_inferred: f32 = 1f32 * 1_000_000_000.;
@@ -68,9 +81,11 @@ fn main() {
 
     // issue #7744
     let _ = 2.225_073_858_507_201_1e-308_f64;
+    //~^ excessive_precision
 
     // issue #7745
     let _ = 1.000_000_000_000_001e-324_f64;
+    //~^ excessive_precision
 
     // issue #9910
     const INF1: f32 = 1.0e+33f32;
@@ -81,5 +96,6 @@ fn main() {
 
     // issue #12954
     const _: f64 = 3.0000000000000000e+00;
+    //~^ excessive_precision
     const _: f64 = 3.0000000000000000;
 }
diff --git a/src/tools/clippy/tests/ui/excessive_precision.stderr b/src/tools/clippy/tests/ui/excessive_precision.stderr
index b1f12eed4200..934a367e1065 100644
--- a/src/tools/clippy/tests/ui/excessive_precision.stderr
+++ b/src/tools/clippy/tests/ui/excessive_precision.stderr
@@ -13,7 +13,7 @@ LL +     const BAD32_1: f32 = 0.123_456_79_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:21:26
+  --> tests/ui/excessive_precision.rs:22:26
    |
 LL |     const BAD32_2: f32 = 0.123_456_789;
    |                          ^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     const BAD32_2: f32 = 0.123_456_79;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:22:26
+  --> tests/ui/excessive_precision.rs:24:26
    |
 LL |     const BAD32_3: f32 = 0.100_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     const BAD32_3: f32 = 0.1;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:23:29
+  --> tests/ui/excessive_precision.rs:26:29
    |
 LL |     const BAD32_EDGE: f32 = 1.000_000_9;
    |                             ^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     const BAD32_EDGE: f32 = 1.000_001;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:27:26
+  --> tests/ui/excessive_precision.rs:31:26
    |
 LL |     const BAD64_3: f64 = 0.100_000_000_000_000_000_1;
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     const BAD64_3: f64 = 0.1;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:30:22
+  --> tests/ui/excessive_precision.rs:35:22
    |
 LL |     println!("{:?}", 8.888_888_888_888_888_888_888);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     println!("{:?}", 8.888_888_888_888_89);
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:41:22
+  --> tests/ui/excessive_precision.rs:47:22
    |
 LL |     let bad32: f32 = 1.123_456_789;
    |                      ^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let bad32: f32 = 1.123_456_8;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:42:26
+  --> tests/ui/excessive_precision.rs:49:26
    |
 LL |     let bad32_suf: f32 = 1.123_456_789_f32;
    |                          ^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let bad32_suf: f32 = 1.123_456_8_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:43:21
+  --> tests/ui/excessive_precision.rs:51:21
    |
 LL |     let bad32_inf = 1.123_456_789_f32;
    |                     ^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let bad32_inf = 1.123_456_8_f32;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:53:36
+  --> tests/ui/excessive_precision.rs:62:36
    |
 LL |     let bad_vec32: Vec<f32> = vec![0.123_456_789];
    |                                    ^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let bad_vec32: Vec<f32> = vec![0.123_456_79];
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:54:36
+  --> tests/ui/excessive_precision.rs:64:36
    |
 LL |     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_789];
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     let bad_vec64: Vec<f64> = vec![0.123_456_789_123_456_78];
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:58:24
+  --> tests/ui/excessive_precision.rs:69:24
    |
 LL |     let bad_e32: f32 = 1.123_456_788_888e-10;
    |                        ^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     let bad_e32: f32 = 1.123_456_8e-10;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:61:27
+  --> tests/ui/excessive_precision.rs:73:27
    |
 LL |     let bad_bige32: f32 = 1.123_456_788_888E-10;
    |                           ^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let bad_bige32: f32 = 1.123_456_8E-10;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:70:13
+  --> tests/ui/excessive_precision.rs:83:13
    |
 LL |     let _ = 2.225_073_858_507_201_1e-308_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     let _ = 2.225_073_858_507_201e-308_f64;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:73:13
+  --> tests/ui/excessive_precision.rs:87:13
    |
 LL |     let _ = 1.000_000_000_000_001e-324_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     let _ = 0_f64;
    |
 
 error: float has excessive precision
-  --> tests/ui/excessive_precision.rs:83:20
+  --> tests/ui/excessive_precision.rs:98:20
    |
 LL |     const _: f64 = 3.0000000000000000e+00;
    |                    ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/exhaustive_items.fixed b/src/tools/clippy/tests/ui/exhaustive_items.fixed
index 1bf33a5f2f13..79c74aeefbd8 100644
--- a/src/tools/clippy/tests/ui/exhaustive_items.fixed
+++ b/src/tools/clippy/tests/ui/exhaustive_items.fixed
@@ -8,6 +8,7 @@ fn main() {
 pub mod enums {
     #[non_exhaustive]
     pub enum Exhaustive {
+        //~^ exhaustive_enums
         Foo,
         Bar,
         Baz,
@@ -18,6 +19,7 @@ pub mod enums {
     #[repr(C)]
     #[non_exhaustive]
     pub enum ExhaustiveWithAttrs {
+        //~^ exhaustive_enums
         Foo,
         Bar,
         Baz,
@@ -54,6 +56,7 @@ pub mod enums {
 pub mod structs {
     #[non_exhaustive]
     pub struct Exhaustive {
+        //~^ exhaustive_structs
         pub foo: u8,
         pub bar: String,
     }
diff --git a/src/tools/clippy/tests/ui/exhaustive_items.rs b/src/tools/clippy/tests/ui/exhaustive_items.rs
index 1328791e186d..4e851f4c492e 100644
--- a/src/tools/clippy/tests/ui/exhaustive_items.rs
+++ b/src/tools/clippy/tests/ui/exhaustive_items.rs
@@ -7,6 +7,7 @@ fn main() {
 
 pub mod enums {
     pub enum Exhaustive {
+        //~^ exhaustive_enums
         Foo,
         Bar,
         Baz,
@@ -16,6 +17,7 @@ pub mod enums {
     /// Some docs
     #[repr(C)]
     pub enum ExhaustiveWithAttrs {
+        //~^ exhaustive_enums
         Foo,
         Bar,
         Baz,
@@ -51,6 +53,7 @@ pub mod enums {
 
 pub mod structs {
     pub struct Exhaustive {
+        //~^ exhaustive_structs
         pub foo: u8,
         pub bar: String,
     }
diff --git a/src/tools/clippy/tests/ui/exhaustive_items.stderr b/src/tools/clippy/tests/ui/exhaustive_items.stderr
index 536fbe8d790f..c92c8a9efaae 100644
--- a/src/tools/clippy/tests/ui/exhaustive_items.stderr
+++ b/src/tools/clippy/tests/ui/exhaustive_items.stderr
@@ -2,6 +2,7 @@ error: exported enums should not be exhaustive
   --> tests/ui/exhaustive_items.rs:9:5
    |
 LL | /     pub enum Exhaustive {
+LL | |
 LL | |         Foo,
 LL | |         Bar,
 LL | |         Baz,
@@ -21,9 +22,10 @@ LL ~     pub enum Exhaustive {
    |
 
 error: exported enums should not be exhaustive
-  --> tests/ui/exhaustive_items.rs:18:5
+  --> tests/ui/exhaustive_items.rs:19:5
    |
 LL | /     pub enum ExhaustiveWithAttrs {
+LL | |
 LL | |         Foo,
 LL | |         Bar,
 LL | |         Baz,
@@ -38,9 +40,10 @@ LL ~     pub enum ExhaustiveWithAttrs {
    |
 
 error: exported structs should not be exhaustive
-  --> tests/ui/exhaustive_items.rs:53:5
+  --> tests/ui/exhaustive_items.rs:55:5
    |
 LL | /     pub struct Exhaustive {
+LL | |
 LL | |         pub foo: u8,
 LL | |         pub bar: String,
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/exit1.rs b/src/tools/clippy/tests/ui/exit1.rs
index 36b3c42fd995..be8752cc7d8e 100644
--- a/src/tools/clippy/tests/ui/exit1.rs
+++ b/src/tools/clippy/tests/ui/exit1.rs
@@ -3,8 +3,7 @@
 fn not_main() {
     if true {
         std::process::exit(4);
-        //~^ ERROR: usage of `process::exit`
-        //~| NOTE: `-D clippy::exit` implied by `-D warnings`
+        //~^ exit
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/exit2.rs b/src/tools/clippy/tests/ui/exit2.rs
index 9bbb7b073a4b..2be8a84b6d4b 100644
--- a/src/tools/clippy/tests/ui/exit2.rs
+++ b/src/tools/clippy/tests/ui/exit2.rs
@@ -2,8 +2,7 @@
 
 fn also_not_main() {
     std::process::exit(3);
-    //~^ ERROR: usage of `process::exit`
-    //~| NOTE: `-D clippy::exit` implied by `-D warnings`
+    //~^ exit
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/exit3.rs b/src/tools/clippy/tests/ui/exit3.rs
index cab908aafd33..a8af1b225788 100644
--- a/src/tools/clippy/tests/ui/exit3.rs
+++ b/src/tools/clippy/tests/ui/exit3.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::exit)]
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/expect.rs b/src/tools/clippy/tests/ui/expect.rs
index f15b3d37e154..8f7379f00214 100644
--- a/src/tools/clippy/tests/ui/expect.rs
+++ b/src/tools/clippy/tests/ui/expect.rs
@@ -4,15 +4,16 @@
 fn expect_option() {
     let opt = Some(0);
     let _ = opt.expect("");
-    //~^ ERROR: used `expect()` on an `Option` value
+    //~^ expect_used
 }
 
 fn expect_result() {
     let res: Result<u8, u8> = Ok(0);
     let _ = res.expect("");
-    //~^ ERROR: used `expect()` on a `Result` value
+    //~^ expect_used
+
     let _ = res.expect_err("");
-    //~^ ERROR: used `expect_err()` on a `Result` value
+    //~^ expect_used
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/expect.stderr b/src/tools/clippy/tests/ui/expect.stderr
index c0ba3390aac5..70cf3072003e 100644
--- a/src/tools/clippy/tests/ui/expect.stderr
+++ b/src/tools/clippy/tests/ui/expect.stderr
@@ -17,7 +17,7 @@ LL |     let _ = res.expect("");
    = note: if this value is an `Err`, it will panic
 
 error: used `expect_err()` on a `Result` value
-  --> tests/ui/expect.rs:14:13
+  --> tests/ui/expect.rs:15:13
    |
 LL |     let _ = res.expect_err("");
    |             ^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/expect_fun_call.fixed b/src/tools/clippy/tests/ui/expect_fun_call.fixed
index 8f800c71941a..73eaebf773c8 100644
--- a/src/tools/clippy/tests/ui/expect_fun_call.fixed
+++ b/src/tools/clippy/tests/ui/expect_fun_call.fixed
@@ -33,12 +33,15 @@ fn main() {
     let error_code = 123_i32;
     let with_none_and_format: Option<i32> = None;
     with_none_and_format.unwrap_or_else(|| panic!("Error {}: fake error", error_code));
+    //~^ expect_fun_call
 
     let with_none_and_as_str: Option<i32> = None;
     with_none_and_as_str.unwrap_or_else(|| panic!("Error {}: fake error", error_code));
+    //~^ expect_fun_call
 
     let with_none_and_format_with_macro: Option<i32> = None;
     with_none_and_format_with_macro.unwrap_or_else(|| panic!("Error {}: fake error", one!()));
+    //~^ expect_fun_call
 
     let with_ok: Result<(), ()> = Ok(());
     with_ok.expect("error");
@@ -49,9 +52,11 @@ fn main() {
     let error_code = 123_i32;
     let with_err_and_format: Result<(), ()> = Err(());
     with_err_and_format.unwrap_or_else(|_| panic!("Error {}: fake error", error_code));
+    //~^ expect_fun_call
 
     let with_err_and_as_str: Result<(), ()> = Err(());
     with_err_and_as_str.unwrap_or_else(|_| panic!("Error {}: fake error", error_code));
+    //~^ expect_fun_call
 
     let with_dummy_type = Foo::new();
     with_dummy_type.expect("another test string");
@@ -64,6 +69,7 @@ fn main() {
 
     //Issue #2937
     Some("foo").unwrap_or_else(|| panic!("{} {}", 1, 2));
+    //~^ expect_fun_call
 
     //Issue #2979 - this should not lint
     {
@@ -85,26 +91,35 @@ fn main() {
         }
 
         Some("foo").unwrap_or_else(|| { panic!("{}", get_string()) });
+        //~^ expect_fun_call
         Some("foo").unwrap_or_else(|| { panic!("{}", get_string()) });
+        //~^ expect_fun_call
         Some("foo").unwrap_or_else(|| { panic!("{}", get_string()) });
+        //~^ expect_fun_call
 
         Some("foo").unwrap_or_else(|| { panic!("{}", get_static_str()) });
+        //~^ expect_fun_call
         Some("foo").unwrap_or_else(|| { panic!("{}", get_non_static_str(&0).to_string()) });
+        //~^ expect_fun_call
     }
 
     //Issue #3839
     Some(true).unwrap_or_else(|| panic!("key {}, {}", 1, 2));
+    //~^ expect_fun_call
 
     //Issue #4912 - the receiver is a &Option
     {
         let opt = Some(1);
         let opt_ref = &opt;
         opt_ref.unwrap_or_else(|| panic!("{:?}", opt_ref));
+        //~^ expect_fun_call
     }
 
     let format_capture: Option<i32> = None;
     format_capture.unwrap_or_else(|| panic!("{error_code}"));
+    //~^ expect_fun_call
 
     let format_capture_and_value: Option<i32> = None;
     format_capture_and_value.unwrap_or_else(|| panic!("{error_code}, {}", 1));
+    //~^ expect_fun_call
 }
diff --git a/src/tools/clippy/tests/ui/expect_fun_call.rs b/src/tools/clippy/tests/ui/expect_fun_call.rs
index b5cfafb2993e..ecebc9ebfb6f 100644
--- a/src/tools/clippy/tests/ui/expect_fun_call.rs
+++ b/src/tools/clippy/tests/ui/expect_fun_call.rs
@@ -33,12 +33,15 @@ fn main() {
     let error_code = 123_i32;
     let with_none_and_format: Option<i32> = None;
     with_none_and_format.expect(&format!("Error {}: fake error", error_code));
+    //~^ expect_fun_call
 
     let with_none_and_as_str: Option<i32> = None;
     with_none_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+    //~^ expect_fun_call
 
     let with_none_and_format_with_macro: Option<i32> = None;
     with_none_and_format_with_macro.expect(format!("Error {}: fake error", one!()).as_str());
+    //~^ expect_fun_call
 
     let with_ok: Result<(), ()> = Ok(());
     with_ok.expect("error");
@@ -49,9 +52,11 @@ fn main() {
     let error_code = 123_i32;
     let with_err_and_format: Result<(), ()> = Err(());
     with_err_and_format.expect(&format!("Error {}: fake error", error_code));
+    //~^ expect_fun_call
 
     let with_err_and_as_str: Result<(), ()> = Err(());
     with_err_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
+    //~^ expect_fun_call
 
     let with_dummy_type = Foo::new();
     with_dummy_type.expect("another test string");
@@ -64,6 +69,7 @@ fn main() {
 
     //Issue #2937
     Some("foo").expect(format!("{} {}", 1, 2).as_ref());
+    //~^ expect_fun_call
 
     //Issue #2979 - this should not lint
     {
@@ -85,26 +91,35 @@ fn main() {
         }
 
         Some("foo").expect(&get_string());
+        //~^ expect_fun_call
         Some("foo").expect(get_string().as_ref());
+        //~^ expect_fun_call
         Some("foo").expect(get_string().as_str());
+        //~^ expect_fun_call
 
         Some("foo").expect(get_static_str());
+        //~^ expect_fun_call
         Some("foo").expect(get_non_static_str(&0));
+        //~^ expect_fun_call
     }
 
     //Issue #3839
     Some(true).expect(&format!("key {}, {}", 1, 2));
+    //~^ expect_fun_call
 
     //Issue #4912 - the receiver is a &Option
     {
         let opt = Some(1);
         let opt_ref = &opt;
         opt_ref.expect(&format!("{:?}", opt_ref));
+        //~^ expect_fun_call
     }
 
     let format_capture: Option<i32> = None;
     format_capture.expect(&format!("{error_code}"));
+    //~^ expect_fun_call
 
     let format_capture_and_value: Option<i32> = None;
     format_capture_and_value.expect(&format!("{error_code}, {}", 1));
+    //~^ expect_fun_call
 }
diff --git a/src/tools/clippy/tests/ui/expect_fun_call.stderr b/src/tools/clippy/tests/ui/expect_fun_call.stderr
index 050c039f834d..36713196cb92 100644
--- a/src/tools/clippy/tests/ui/expect_fun_call.stderr
+++ b/src/tools/clippy/tests/ui/expect_fun_call.stderr
@@ -8,85 +8,85 @@ LL |     with_none_and_format.expect(&format!("Error {}: fake error", error_code
    = help: to override `-D warnings` add `#[allow(clippy::expect_fun_call)]`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:38:26
+  --> tests/ui/expect_fun_call.rs:39:26
    |
 LL |     with_none_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("Error {}: fake error", error_code))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:41:37
+  --> tests/ui/expect_fun_call.rs:43:37
    |
 LL |     with_none_and_format_with_macro.expect(format!("Error {}: fake error", one!()).as_str());
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("Error {}: fake error", one!()))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:51:25
+  --> tests/ui/expect_fun_call.rs:54:25
    |
 LL |     with_err_and_format.expect(&format!("Error {}: fake error", error_code));
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:54:25
+  --> tests/ui/expect_fun_call.rs:58:25
    |
 LL |     with_err_and_as_str.expect(format!("Error {}: fake error", error_code).as_str());
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| panic!("Error {}: fake error", error_code))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:66:17
+  --> tests/ui/expect_fun_call.rs:71:17
    |
 LL |     Some("foo").expect(format!("{} {}", 1, 2).as_ref());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{} {}", 1, 2))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:87:21
+  --> tests/ui/expect_fun_call.rs:93:21
    |
 LL |         Some("foo").expect(&get_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_string()) })`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:88:21
+  --> tests/ui/expect_fun_call.rs:95:21
    |
 LL |         Some("foo").expect(get_string().as_ref());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_string()) })`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:89:21
+  --> tests/ui/expect_fun_call.rs:97:21
    |
 LL |         Some("foo").expect(get_string().as_str());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_string()) })`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:91:21
+  --> tests/ui/expect_fun_call.rs:100:21
    |
 LL |         Some("foo").expect(get_static_str());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_static_str()) })`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:92:21
+  --> tests/ui/expect_fun_call.rs:102:21
    |
 LL |         Some("foo").expect(get_non_static_str(&0));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| { panic!("{}", get_non_static_str(&0).to_string()) })`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:96:16
+  --> tests/ui/expect_fun_call.rs:107:16
    |
 LL |     Some(true).expect(&format!("key {}, {}", 1, 2));
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("key {}, {}", 1, 2))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:102:17
+  --> tests/ui/expect_fun_call.rs:114:17
    |
 LL |         opt_ref.expect(&format!("{:?}", opt_ref));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{:?}", opt_ref))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:106:20
+  --> tests/ui/expect_fun_call.rs:119:20
    |
 LL |     format_capture.expect(&format!("{error_code}"));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{error_code}"))`
 
 error: function call inside of `expect`
-  --> tests/ui/expect_fun_call.rs:109:30
+  --> tests/ui/expect_fun_call.rs:123:30
    |
 LL |     format_capture_and_value.expect(&format!("{error_code}, {}", 1));
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| panic!("{error_code}, {}", 1))`
diff --git a/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.rs b/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.rs
index 2634c56794e7..2295691c8127 100644
--- a/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.rs
+++ b/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.rs
@@ -30,11 +30,14 @@ mod rustc_warn {
     #[expect(dead_code)]
     //~^ ERROR: this lint expectation is unfulfilled
     //~| NOTE: `-D unfulfilled-lint-expectations` implied by `-D warnings`
+    //~| HELP: to override `-D warnings` add `#[allow(unfulfilled_lint_expectations)]`
     pub fn rustc_lints() {
         let x = 42;
 
         #[expect(invalid_nan_comparisons)]
         //~^ ERROR: this lint expectation is unfulfilled
+        //~| NOTE: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+        //~| ERROR: this lint expectation is unfulfilled
         let _b = x == 5;
     }
 }
diff --git a/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.stderr b/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.stderr
index 028e22ca724e..b274d5c23693 100644
--- a/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.stderr
+++ b/src/tools/clippy/tests/ui/expect_tool_lint_rfc_2383.stderr
@@ -8,13 +8,13 @@ LL |     #[expect(dead_code)]
    = help: to override `-D warnings` add `#[allow(unfulfilled_lint_expectations)]`
 
 error: this lint expectation is unfulfilled
-  --> tests/ui/expect_tool_lint_rfc_2383.rs:36:18
+  --> tests/ui/expect_tool_lint_rfc_2383.rs:37:18
    |
 LL |         #[expect(invalid_nan_comparisons)]
    |                  ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> tests/ui/expect_tool_lint_rfc_2383.rs:36:18
+  --> tests/ui/expect_tool_lint_rfc_2383.rs:37:18
    |
 LL |         #[expect(invalid_nan_comparisons)]
    |                  ^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,25 +22,25 @@ LL |         #[expect(invalid_nan_comparisons)]
    = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
 
 error: this lint expectation is unfulfilled
-  --> tests/ui/expect_tool_lint_rfc_2383.rs:107:14
+  --> tests/ui/expect_tool_lint_rfc_2383.rs:110:14
    |
 LL |     #[expect(clippy::almost_swapped)]
    |              ^^^^^^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> tests/ui/expect_tool_lint_rfc_2383.rs:115:14
+  --> tests/ui/expect_tool_lint_rfc_2383.rs:118:14
    |
 LL |     #[expect(clippy::bytes_nth)]
    |              ^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> tests/ui/expect_tool_lint_rfc_2383.rs:121:14
+  --> tests/ui/expect_tool_lint_rfc_2383.rs:124:14
    |
 LL |     #[expect(clippy::if_same_then_else)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this lint expectation is unfulfilled
-  --> tests/ui/expect_tool_lint_rfc_2383.rs:127:14
+  --> tests/ui/expect_tool_lint_rfc_2383.rs:130:14
    |
 LL |     #[expect(clippy::overly_complex_bool_expr)]
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/explicit_auto_deref.fixed b/src/tools/clippy/tests/ui/explicit_auto_deref.fixed
index 9d476259b87e..7235f7d5b82a 100644
--- a/src/tools/clippy/tests/ui/explicit_auto_deref.fixed
+++ b/src/tools/clippy/tests/ui/explicit_auto_deref.fixed
@@ -67,43 +67,55 @@ fn main() {
     let s = String::new();
 
     let _: &str = &s;
+    //~^ explicit_auto_deref
     let _: &str = &{ String::new() };
+    //~^ explicit_auto_deref
     let _: &str = &mut { String::new() };
+    //~^ explicit_auto_deref
     let _ = &*s; // Don't lint. Inferred type would change.
     let _: &_ = &*s; // Don't lint. Inferred type would change.
 
     f_str(&s);
+    //~^ explicit_auto_deref
     f_t(&*s); // Don't lint. Inferred type would change.
     f_ref_t(&*s); // Don't lint. Inferred type would change.
 
     f_str_t(&s, &*s); // Don't lint second param.
+    //
+    //~^^ explicit_auto_deref
 
     let b = Box::new(Box::new(Box::new(5)));
     let _: &Box<i32> = &b;
+    //~^ explicit_auto_deref
     let _: &Box<_> = &**b; // Don't lint. Inferred type would change.
 
     f_box_t(&**b); // Don't lint. Inferred type would change.
 
     let c = |_x: &str| ();
     c(&s);
+    //~^ explicit_auto_deref
 
     let c = |_x| ();
     c(&*s); // Don't lint. Inferred type would change.
 
     fn _f(x: &String) -> &str {
         x
+        //~^ explicit_auto_deref
     }
 
     fn _f1(x: &String) -> &str {
         { x }
+        //~^ explicit_auto_deref
     }
 
     fn _f2(x: &String) -> &str {
         { x }
+        //~^ explicit_auto_deref
     }
 
     fn _f3(x: &Box<Box<Box<i32>>>) -> &Box<i32> {
         x
+        //~^ explicit_auto_deref
     }
 
     fn _f4(
@@ -121,25 +133,38 @@ fn main() {
         f11: &dyn CallableT<str, T = fn(&str)>,
     ) {
         f1(&x);
+        //~^ explicit_auto_deref
         f2(&x);
+        //~^ explicit_auto_deref
         f3(&x);
+        //~^ explicit_auto_deref
         f4.callable_str()(&x);
+        //~^ explicit_auto_deref
         f5(&x);
+        //~^ explicit_auto_deref
         f6(&x);
+        //~^ explicit_auto_deref
         f7.callable_str()(&x);
+        //~^ explicit_auto_deref
         f8.callable_t()(&x);
+        //~^ explicit_auto_deref
         f9(&x);
+        //~^ explicit_auto_deref
         f10(&x);
+        //~^ explicit_auto_deref
         f11.callable_t()(&x);
+        //~^ explicit_auto_deref
     }
 
     struct S1<'a>(&'a str);
     let _ = S1(&s);
+    //~^ explicit_auto_deref
 
     struct S2<'a> {
         s: &'a str,
     }
     let _ = S2 { s: &s };
+    //~^ explicit_auto_deref
 
     struct S3<'a, T: ?Sized>(&'a T);
     let _ = S3(&*s); // Don't lint. Inferred type would change.
@@ -156,11 +181,15 @@ fn main() {
     impl<'a> E1<'a> {
         fn m1(s: &'a String) {
             let _ = Self::S1(s);
+            //~^ explicit_auto_deref
             let _ = Self::S2 { s: s };
+            //~^ explicit_auto_deref
         }
     }
     let _ = E1::S1(&s);
+    //~^ explicit_auto_deref
     let _ = E1::S2 { s: &s };
+    //~^ explicit_auto_deref
 
     enum E2<'a, T: ?Sized> {
         S1(&'a T),
@@ -179,7 +208,9 @@ fn main() {
     let b = Box::new(Box::new(S5 { foo: 5 }));
     let _ = b.foo;
     let _ = b.foo;
+    //~^ explicit_auto_deref
     let _ = b.foo;
+    //~^ explicit_auto_deref
 
     struct S6 {
         foo: S5,
@@ -195,8 +226,10 @@ fn main() {
 
     let ref_str = &"foo";
     let _ = f_str(ref_str);
+    //~^ explicit_auto_deref
     let ref_ref_str = &ref_str;
     let _ = f_str(ref_ref_str);
+    //~^ explicit_auto_deref
 
     fn _f5(x: &u32) -> u32 {
         if true {
@@ -207,7 +240,11 @@ fn main() {
     }
 
     f_str(&ref_str); // `needless_borrow` will suggest removing both references
+    //
+    //~^^ explicit_auto_deref
     f_str(&ref_str); // `needless_borrow` will suggest removing only one reference
+    //
+    //~^^ explicit_auto_deref
 
     let x = &&40;
     unsafe {
@@ -217,6 +254,7 @@ fn main() {
     let s = &"str";
     let _ = || return *s;
     let _ = || -> &'static str { return s };
+    //~^ explicit_auto_deref
 
     struct X;
     struct Y(X);
@@ -236,6 +274,7 @@ fn main() {
 
     fn deref_to_u<U, T: core::ops::Deref<Target = U>>(x: &T) -> &U {
         x
+        //~^ explicit_auto_deref
     }
 
     let _ = |x: &'static Box<dyn Iterator<Item = u32>>| -> &'static dyn Iterator<Item = u32> { &**x };
@@ -259,11 +298,14 @@ fn main() {
     let c1 = |_: &Vec<&u32>| {};
     let x = &&vec![&1u32];
     c1(x);
+    //~^ explicit_auto_deref
     let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> {
         if b {
             return x;
+            //~^ explicit_auto_deref
         }
         x
+        //~^ explicit_auto_deref
     };
 
     trait WithAssoc {
@@ -298,6 +340,7 @@ fn main() {
     // Issue #11366
     let _: &mut u32 = match &mut Some(&mut 0u32) {
         Some(x) => x,
+        //~^ explicit_auto_deref
         None => panic!(),
     };
 
@@ -331,18 +374,23 @@ fn main() {
         };
         let _ = &mut (*x.u).x;
         let _ = &mut { x.u }.x;
+        //~^ explicit_auto_deref
         let _ = &mut ({ *x.u }).x;
 
         let mut x = U {
             u: Wrap(core::mem::ManuallyDrop::new(S8 { x: "" })),
         };
         let _ = &mut (*x.u).x;
+        //~^ explicit_auto_deref
         let _ = &mut { x.u }.x;
+        //~^ explicit_auto_deref
         let _ = &mut ({ **x.u }).x;
 
         let mut x = U { u: Wrap(S8 { x: "" }) };
         let _ = &mut x.u.x;
+        //~^ explicit_auto_deref
         let _ = &mut { x.u }.x;
+        //~^ explicit_auto_deref
         let _ = &mut ({ *x.u }).x;
     }
 }
@@ -366,6 +414,7 @@ mod issue_12969 {
         let wrapped_bar = Wrapper("");
 
         foo(&wrapped_bar);
+        //~^ explicit_auto_deref
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/explicit_auto_deref.rs b/src/tools/clippy/tests/ui/explicit_auto_deref.rs
index 23307c837f0e..c4d2b28ff4b5 100644
--- a/src/tools/clippy/tests/ui/explicit_auto_deref.rs
+++ b/src/tools/clippy/tests/ui/explicit_auto_deref.rs
@@ -67,43 +67,55 @@ fn main() {
     let s = String::new();
 
     let _: &str = &*s;
+    //~^ explicit_auto_deref
     let _: &str = &*{ String::new() };
+    //~^ explicit_auto_deref
     let _: &str = &mut *{ String::new() };
+    //~^ explicit_auto_deref
     let _ = &*s; // Don't lint. Inferred type would change.
     let _: &_ = &*s; // Don't lint. Inferred type would change.
 
     f_str(&*s);
+    //~^ explicit_auto_deref
     f_t(&*s); // Don't lint. Inferred type would change.
     f_ref_t(&*s); // Don't lint. Inferred type would change.
 
     f_str_t(&*s, &*s); // Don't lint second param.
+    //
+    //~^^ explicit_auto_deref
 
     let b = Box::new(Box::new(Box::new(5)));
     let _: &Box<i32> = &**b;
+    //~^ explicit_auto_deref
     let _: &Box<_> = &**b; // Don't lint. Inferred type would change.
 
     f_box_t(&**b); // Don't lint. Inferred type would change.
 
     let c = |_x: &str| ();
     c(&*s);
+    //~^ explicit_auto_deref
 
     let c = |_x| ();
     c(&*s); // Don't lint. Inferred type would change.
 
     fn _f(x: &String) -> &str {
         &**x
+        //~^ explicit_auto_deref
     }
 
     fn _f1(x: &String) -> &str {
         { &**x }
+        //~^ explicit_auto_deref
     }
 
     fn _f2(x: &String) -> &str {
         &**{ x }
+        //~^ explicit_auto_deref
     }
 
     fn _f3(x: &Box<Box<Box<i32>>>) -> &Box<i32> {
         &***x
+        //~^ explicit_auto_deref
     }
 
     fn _f4(
@@ -121,25 +133,38 @@ fn main() {
         f11: &dyn CallableT<str, T = fn(&str)>,
     ) {
         f1(&*x);
+        //~^ explicit_auto_deref
         f2(&*x);
+        //~^ explicit_auto_deref
         f3(&*x);
+        //~^ explicit_auto_deref
         f4.callable_str()(&*x);
+        //~^ explicit_auto_deref
         f5(&*x);
+        //~^ explicit_auto_deref
         f6(&*x);
+        //~^ explicit_auto_deref
         f7.callable_str()(&*x);
+        //~^ explicit_auto_deref
         f8.callable_t()(&*x);
+        //~^ explicit_auto_deref
         f9(&*x);
+        //~^ explicit_auto_deref
         f10(&*x);
+        //~^ explicit_auto_deref
         f11.callable_t()(&*x);
+        //~^ explicit_auto_deref
     }
 
     struct S1<'a>(&'a str);
     let _ = S1(&*s);
+    //~^ explicit_auto_deref
 
     struct S2<'a> {
         s: &'a str,
     }
     let _ = S2 { s: &*s };
+    //~^ explicit_auto_deref
 
     struct S3<'a, T: ?Sized>(&'a T);
     let _ = S3(&*s); // Don't lint. Inferred type would change.
@@ -156,11 +181,15 @@ fn main() {
     impl<'a> E1<'a> {
         fn m1(s: &'a String) {
             let _ = Self::S1(&**s);
+            //~^ explicit_auto_deref
             let _ = Self::S2 { s: &**s };
+            //~^ explicit_auto_deref
         }
     }
     let _ = E1::S1(&*s);
+    //~^ explicit_auto_deref
     let _ = E1::S2 { s: &*s };
+    //~^ explicit_auto_deref
 
     enum E2<'a, T: ?Sized> {
         S1(&'a T),
@@ -179,7 +208,9 @@ fn main() {
     let b = Box::new(Box::new(S5 { foo: 5 }));
     let _ = b.foo;
     let _ = (*b).foo;
+    //~^ explicit_auto_deref
     let _ = (**b).foo;
+    //~^ explicit_auto_deref
 
     struct S6 {
         foo: S5,
@@ -195,8 +226,10 @@ fn main() {
 
     let ref_str = &"foo";
     let _ = f_str(*ref_str);
+    //~^ explicit_auto_deref
     let ref_ref_str = &ref_str;
     let _ = f_str(**ref_ref_str);
+    //~^ explicit_auto_deref
 
     fn _f5(x: &u32) -> u32 {
         if true {
@@ -207,7 +240,11 @@ fn main() {
     }
 
     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
+    //
+    //~^^ explicit_auto_deref
     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
+    //
+    //~^^ explicit_auto_deref
 
     let x = &&40;
     unsafe {
@@ -217,6 +254,7 @@ fn main() {
     let s = &"str";
     let _ = || return *s;
     let _ = || -> &'static str { return *s };
+    //~^ explicit_auto_deref
 
     struct X;
     struct Y(X);
@@ -236,6 +274,7 @@ fn main() {
 
     fn deref_to_u<U, T: core::ops::Deref<Target = U>>(x: &T) -> &U {
         &**x
+        //~^ explicit_auto_deref
     }
 
     let _ = |x: &'static Box<dyn Iterator<Item = u32>>| -> &'static dyn Iterator<Item = u32> { &**x };
@@ -259,11 +298,14 @@ fn main() {
     let c1 = |_: &Vec<&u32>| {};
     let x = &&vec![&1u32];
     c1(*x);
+    //~^ explicit_auto_deref
     let _ = for<'a, 'b> |x: &'a &'a Vec<&'b u32>, b: bool| -> &'a Vec<&'b u32> {
         if b {
             return *x;
+            //~^ explicit_auto_deref
         }
         *x
+        //~^ explicit_auto_deref
     };
 
     trait WithAssoc {
@@ -298,6 +340,7 @@ fn main() {
     // Issue #11366
     let _: &mut u32 = match &mut Some(&mut 0u32) {
         Some(x) => &mut *x,
+        //~^ explicit_auto_deref
         None => panic!(),
     };
 
@@ -331,18 +374,23 @@ fn main() {
         };
         let _ = &mut (*x.u).x;
         let _ = &mut (*{ x.u }).x;
+        //~^ explicit_auto_deref
         let _ = &mut ({ *x.u }).x;
 
         let mut x = U {
             u: Wrap(core::mem::ManuallyDrop::new(S8 { x: "" })),
         };
         let _ = &mut (**x.u).x;
+        //~^ explicit_auto_deref
         let _ = &mut (**{ x.u }).x;
+        //~^ explicit_auto_deref
         let _ = &mut ({ **x.u }).x;
 
         let mut x = U { u: Wrap(S8 { x: "" }) };
         let _ = &mut (*x.u).x;
+        //~^ explicit_auto_deref
         let _ = &mut (*{ x.u }).x;
+        //~^ explicit_auto_deref
         let _ = &mut ({ *x.u }).x;
     }
 }
@@ -366,6 +414,7 @@ mod issue_12969 {
         let wrapped_bar = Wrapper("");
 
         foo(&*wrapped_bar);
+        //~^ explicit_auto_deref
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/explicit_auto_deref.stderr b/src/tools/clippy/tests/ui/explicit_auto_deref.stderr
index 0b05a554eb11..ba4cd86e0b5a 100644
--- a/src/tools/clippy/tests/ui/explicit_auto_deref.stderr
+++ b/src/tools/clippy/tests/ui/explicit_auto_deref.stderr
@@ -8,271 +8,271 @@ LL |     let _: &str = &*s;
    = help: to override `-D warnings` add `#[allow(clippy::explicit_auto_deref)]`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:70:19
+  --> tests/ui/explicit_auto_deref.rs:71:19
    |
 LL |     let _: &str = &*{ String::new() };
    |                   ^^^^^^^^^^^^^^^^^^^ help: try: `&{ String::new() }`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:71:19
+  --> tests/ui/explicit_auto_deref.rs:73:19
    |
 LL |     let _: &str = &mut *{ String::new() };
    |                   ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut { String::new() }`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:75:11
+  --> tests/ui/explicit_auto_deref.rs:78:11
    |
 LL |     f_str(&*s);
    |           ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:79:13
+  --> tests/ui/explicit_auto_deref.rs:83:13
    |
 LL |     f_str_t(&*s, &*s); // Don't lint second param.
    |             ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:82:24
+  --> tests/ui/explicit_auto_deref.rs:88:24
    |
 LL |     let _: &Box<i32> = &**b;
    |                        ^^^^ help: try: `&b`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:88:7
+  --> tests/ui/explicit_auto_deref.rs:95:7
    |
 LL |     c(&*s);
    |       ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:94:9
+  --> tests/ui/explicit_auto_deref.rs:102:9
    |
 LL |         &**x
    |         ^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:98:11
+  --> tests/ui/explicit_auto_deref.rs:107:11
    |
 LL |         { &**x }
    |           ^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:102:9
+  --> tests/ui/explicit_auto_deref.rs:112:9
    |
 LL |         &**{ x }
    |         ^^^^^^^^ help: try: `{ x }`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:106:9
+  --> tests/ui/explicit_auto_deref.rs:117:9
    |
 LL |         &***x
    |         ^^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:123:12
+  --> tests/ui/explicit_auto_deref.rs:135:12
    |
 LL |         f1(&*x);
    |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:124:12
+  --> tests/ui/explicit_auto_deref.rs:137:12
    |
 LL |         f2(&*x);
    |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:125:12
+  --> tests/ui/explicit_auto_deref.rs:139:12
    |
 LL |         f3(&*x);
    |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:126:27
+  --> tests/ui/explicit_auto_deref.rs:141:27
    |
 LL |         f4.callable_str()(&*x);
    |                           ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:127:12
+  --> tests/ui/explicit_auto_deref.rs:143:12
    |
 LL |         f5(&*x);
    |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:128:12
+  --> tests/ui/explicit_auto_deref.rs:145:12
    |
 LL |         f6(&*x);
    |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:129:27
+  --> tests/ui/explicit_auto_deref.rs:147:27
    |
 LL |         f7.callable_str()(&*x);
    |                           ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:130:25
+  --> tests/ui/explicit_auto_deref.rs:149:25
    |
 LL |         f8.callable_t()(&*x);
    |                         ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:131:12
+  --> tests/ui/explicit_auto_deref.rs:151:12
    |
 LL |         f9(&*x);
    |            ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:132:13
+  --> tests/ui/explicit_auto_deref.rs:153:13
    |
 LL |         f10(&*x);
    |             ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:133:26
+  --> tests/ui/explicit_auto_deref.rs:155:26
    |
 LL |         f11.callable_t()(&*x);
    |                          ^^^ help: try: `&x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:137:16
+  --> tests/ui/explicit_auto_deref.rs:160:16
    |
 LL |     let _ = S1(&*s);
    |                ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:142:21
+  --> tests/ui/explicit_auto_deref.rs:166:21
    |
 LL |     let _ = S2 { s: &*s };
    |                     ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:158:30
+  --> tests/ui/explicit_auto_deref.rs:183:30
    |
 LL |             let _ = Self::S1(&**s);
    |                              ^^^^ help: try: `s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:159:35
+  --> tests/ui/explicit_auto_deref.rs:185:35
    |
 LL |             let _ = Self::S2 { s: &**s };
    |                                   ^^^^ help: try: `s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:162:20
+  --> tests/ui/explicit_auto_deref.rs:189:20
    |
 LL |     let _ = E1::S1(&*s);
    |                    ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:163:25
+  --> tests/ui/explicit_auto_deref.rs:191:25
    |
 LL |     let _ = E1::S2 { s: &*s };
    |                         ^^^ help: try: `&s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:181:13
+  --> tests/ui/explicit_auto_deref.rs:210:13
    |
 LL |     let _ = (*b).foo;
    |             ^^^^ help: try: `b`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:182:13
+  --> tests/ui/explicit_auto_deref.rs:212:13
    |
 LL |     let _ = (**b).foo;
    |             ^^^^^ help: try: `b`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:197:19
+  --> tests/ui/explicit_auto_deref.rs:228:19
    |
 LL |     let _ = f_str(*ref_str);
    |                   ^^^^^^^^ help: try: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:199:19
+  --> tests/ui/explicit_auto_deref.rs:231:19
    |
 LL |     let _ = f_str(**ref_ref_str);
    |                   ^^^^^^^^^^^^^ help: try: `ref_ref_str`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:209:12
+  --> tests/ui/explicit_auto_deref.rs:242:12
    |
 LL |     f_str(&&*ref_str); // `needless_borrow` will suggest removing both references
    |            ^^^^^^^^^ help: try: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:210:12
+  --> tests/ui/explicit_auto_deref.rs:245:12
    |
 LL |     f_str(&&**ref_str); // `needless_borrow` will suggest removing only one reference
    |            ^^^^^^^^^^ help: try: `ref_str`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:219:41
+  --> tests/ui/explicit_auto_deref.rs:256:41
    |
 LL |     let _ = || -> &'static str { return *s };
    |                                         ^^ help: try: `s`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:238:9
+  --> tests/ui/explicit_auto_deref.rs:276:9
    |
 LL |         &**x
    |         ^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:261:8
+  --> tests/ui/explicit_auto_deref.rs:300:8
    |
 LL |     c1(*x);
    |        ^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:264:20
+  --> tests/ui/explicit_auto_deref.rs:304:20
    |
 LL |             return *x;
    |                    ^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:266:9
+  --> tests/ui/explicit_auto_deref.rs:307:9
    |
 LL |         *x
    |         ^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:300:20
+  --> tests/ui/explicit_auto_deref.rs:342:20
    |
 LL |         Some(x) => &mut *x,
    |                    ^^^^^^^ help: try: `x`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:333:22
+  --> tests/ui/explicit_auto_deref.rs:376:22
    |
 LL |         let _ = &mut (*{ x.u }).x;
    |                      ^^^^^^^^^^ help: try: `{ x.u }`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:339:22
+  --> tests/ui/explicit_auto_deref.rs:383:22
    |
 LL |         let _ = &mut (**x.u).x;
    |                      ^^^^^^^ help: try: `(*x.u)`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:340:22
+  --> tests/ui/explicit_auto_deref.rs:385:22
    |
 LL |         let _ = &mut (**{ x.u }).x;
    |                      ^^^^^^^^^^^ help: try: `{ x.u }`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:344:22
+  --> tests/ui/explicit_auto_deref.rs:390:22
    |
 LL |         let _ = &mut (*x.u).x;
    |                      ^^^^^^ help: try: `x.u`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:345:22
+  --> tests/ui/explicit_auto_deref.rs:392:22
    |
 LL |         let _ = &mut (*{ x.u }).x;
    |                      ^^^^^^^^^^ help: try: `{ x.u }`
 
 error: deref which would be done by auto-deref
-  --> tests/ui/explicit_auto_deref.rs:368:13
+  --> tests/ui/explicit_auto_deref.rs:416:13
    |
 LL |         foo(&*wrapped_bar);
    |             ^^^^^^^^^^^^^ help: try: `&wrapped_bar`
diff --git a/src/tools/clippy/tests/ui/explicit_counter_loop.rs b/src/tools/clippy/tests/ui/explicit_counter_loop.rs
index 28b477b69215..8340d99ace22 100644
--- a/src/tools/clippy/tests/ui/explicit_counter_loop.rs
+++ b/src/tools/clippy/tests/ui/explicit_counter_loop.rs
@@ -5,27 +5,30 @@ fn main() {
     let mut vec = vec![1, 2, 3, 4];
     let mut _index = 0;
     for _v in &vec {
-        //~^ ERROR: the variable `_index` is used as a loop counter
-        //~| NOTE: `-D clippy::explicit-counter-loop` implied by `-D warnings`
+        //~^ explicit_counter_loop
+
         _index += 1
     }
 
     let mut _index = 1;
     _index = 0;
     for _v in &vec {
-        //~^ ERROR: the variable `_index` is used as a loop counter
+        //~^ explicit_counter_loop
+
         _index += 1
     }
 
     let mut _index = 0;
     for _v in &mut vec {
-        //~^ ERROR: the variable `_index` is used as a loop counter
+        //~^ explicit_counter_loop
+
         _index += 1;
     }
 
     let mut _index = 0;
     for _v in vec {
-        //~^ ERROR: the variable `_index` is used as a loop counter
+        //~^ explicit_counter_loop
+
         _index += 1;
     }
 
@@ -113,7 +116,8 @@ mod issue_1219 {
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
-            //~^ ERROR: the variable `count` is used as a loop counter
+            //~^ explicit_counter_loop
+
             println!("{}", count);
             count += 1;
             if ch == 'a' {
@@ -125,7 +129,8 @@ mod issue_1219 {
         let text = "banana";
         let mut count = 0;
         for ch in text.chars() {
-            //~^ ERROR: the variable `count` is used as a loop counter
+            //~^ explicit_counter_loop
+
             println!("{}", count);
             count += 1;
             for i in 0..2 {
@@ -184,7 +189,8 @@ mod issue_1670 {
     pub fn test() {
         let mut count = 0;
         for _i in 3..10 {
-            //~^ ERROR: the variable `count` is used as a loop counter
+            //~^ explicit_counter_loop
+
             count += 1;
         }
     }
@@ -225,7 +231,8 @@ mod issue_7920 {
 
         // should suggest `enumerate`
         for _item in slice {
-            //~^ ERROR: the variable `idx_usize` is used as a loop counter
+            //~^ explicit_counter_loop
+
             if idx_usize == index_usize {
                 break;
             }
@@ -238,8 +245,8 @@ mod issue_7920 {
 
         // should suggest `zip`
         for _item in slice {
-            //~^ ERROR: the variable `idx_u32` is used as a loop counter
-            //~| NOTE: `idx_u32` is of type `u32`, making it ineligible for `Iterator::enumera
+            //~^ explicit_counter_loop
+
             if idx_u32 == index_u32 {
                 break;
             }
@@ -284,6 +291,7 @@ mod issue_13123 {
         let mut vec = vec![1, 2, 3, 4];
         let mut _index = 0;
         'label: for v in vec {
+            //~^ explicit_counter_loop
             _index += 1;
             if v == 1 {
                 break 'label;
diff --git a/src/tools/clippy/tests/ui/explicit_counter_loop.stderr b/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
index 1b2d1f8570a3..a73516558c20 100644
--- a/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
+++ b/src/tools/clippy/tests/ui/explicit_counter_loop.stderr
@@ -14,43 +14,43 @@ LL |     for _v in &vec {
    |     ^^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.iter().enumerate()`
 
 error: the variable `_index` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:21:5
+  --> tests/ui/explicit_counter_loop.rs:22:5
    |
 LL |     for _v in &mut vec {
    |     ^^^^^^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.iter_mut().enumerate()`
 
 error: the variable `_index` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:27:5
+  --> tests/ui/explicit_counter_loop.rs:29:5
    |
 LL |     for _v in vec {
    |     ^^^^^^^^^^^^^ help: consider using: `for (_index, _v) in vec.into_iter().enumerate()`
 
 error: the variable `count` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:115:9
+  --> tests/ui/explicit_counter_loop.rs:118:9
    |
 LL |         for ch in text.chars() {
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `for (count, ch) in text.chars().enumerate()`
 
 error: the variable `count` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:127:9
+  --> tests/ui/explicit_counter_loop.rs:131:9
    |
 LL |         for ch in text.chars() {
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `for (count, ch) in text.chars().enumerate()`
 
 error: the variable `count` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:186:9
+  --> tests/ui/explicit_counter_loop.rs:191:9
    |
 LL |         for _i in 3..10 {
    |         ^^^^^^^^^^^^^^^ help: consider using: `for (count, _i) in (3..10).enumerate()`
 
 error: the variable `idx_usize` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:227:9
+  --> tests/ui/explicit_counter_loop.rs:233:9
    |
 LL |         for _item in slice {
    |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_usize, _item) in slice.iter().enumerate()`
 
 error: the variable `idx_u32` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:240:9
+  --> tests/ui/explicit_counter_loop.rs:247:9
    |
 LL |         for _item in slice {
    |         ^^^^^^^^^^^^^^^^^^ help: consider using: `for (idx_u32, _item) in (0_u32..).zip(slice.iter())`
@@ -58,7 +58,7 @@ LL |         for _item in slice {
    = note: `idx_u32` is of type `u32`, making it ineligible for `Iterator::enumerate`
 
 error: the variable `_index` is used as a loop counter
-  --> tests/ui/explicit_counter_loop.rs:286:9
+  --> tests/ui/explicit_counter_loop.rs:293:9
    |
 LL |         'label: for v in vec {
    |         ^^^^^^^^^^^^^^^^^^^^ help: consider using: `'label: for (_index, v) in vec.into_iter().enumerate()`
diff --git a/src/tools/clippy/tests/ui/explicit_deref_methods.fixed b/src/tools/clippy/tests/ui/explicit_deref_methods.fixed
index 7b2dd2fe6eb8..0d1a5f80f3d5 100644
--- a/src/tools/clippy/tests/ui/explicit_deref_methods.fixed
+++ b/src/tools/clippy/tests/ui/explicit_deref_methods.fixed
@@ -52,29 +52,40 @@ fn main() {
     // these should require linting
 
     let b: &str = &*a;
+    //~^ explicit_deref_methods
 
     let b: &mut str = &mut **a;
+    //~^ explicit_deref_methods
 
     // both derefs should get linted here
     let b: String = format!("{}, {}", &*a, &*a);
+    //~^ explicit_deref_methods
+    //~| explicit_deref_methods
 
     println!("{}", &*a);
+    //~^ explicit_deref_methods
 
     #[allow(clippy::match_single_binding)]
     match &*a {
+        //~^ explicit_deref_methods
         _ => (),
     }
 
     let b: String = concat(&*a);
+    //~^ explicit_deref_methods
 
     let b = just_return(a);
+    //~^ explicit_deref_methods
 
     let b: String = concat(just_return(a));
+    //~^ explicit_deref_methods
 
     let b: &str = &**a;
+    //~^ explicit_deref_methods
 
     let opt_a = Some(a.clone());
     let b = &*opt_a.unwrap();
+    //~^ explicit_deref_methods
 
     // make sure `Aaa::deref` instead of `aaa.deref()` is not linted, as well as fully qualified
     // syntax
@@ -112,6 +123,7 @@ fn main() {
     let b: &str = expr_deref!(a);
 
     let b: &str = expr_deref!(&*a);
+    //~^ explicit_deref_methods
 
     // The struct does not implement Deref trait
     #[derive(Copy, Clone)]
diff --git a/src/tools/clippy/tests/ui/explicit_deref_methods.rs b/src/tools/clippy/tests/ui/explicit_deref_methods.rs
index eb52cfb0d857..8d4a899cd260 100644
--- a/src/tools/clippy/tests/ui/explicit_deref_methods.rs
+++ b/src/tools/clippy/tests/ui/explicit_deref_methods.rs
@@ -52,29 +52,40 @@ fn main() {
     // these should require linting
 
     let b: &str = a.deref();
+    //~^ explicit_deref_methods
 
     let b: &mut str = a.deref_mut();
+    //~^ explicit_deref_methods
 
     // both derefs should get linted here
     let b: String = format!("{}, {}", a.deref(), a.deref());
+    //~^ explicit_deref_methods
+    //~| explicit_deref_methods
 
     println!("{}", a.deref());
+    //~^ explicit_deref_methods
 
     #[allow(clippy::match_single_binding)]
     match a.deref() {
+        //~^ explicit_deref_methods
         _ => (),
     }
 
     let b: String = concat(a.deref());
+    //~^ explicit_deref_methods
 
     let b = just_return(a).deref();
+    //~^ explicit_deref_methods
 
     let b: String = concat(just_return(a).deref());
+    //~^ explicit_deref_methods
 
     let b: &str = a.deref().deref();
+    //~^ explicit_deref_methods
 
     let opt_a = Some(a.clone());
     let b = opt_a.unwrap().deref();
+    //~^ explicit_deref_methods
 
     // make sure `Aaa::deref` instead of `aaa.deref()` is not linted, as well as fully qualified
     // syntax
@@ -112,6 +123,7 @@ fn main() {
     let b: &str = expr_deref!(a);
 
     let b: &str = expr_deref!(a.deref());
+    //~^ explicit_deref_methods
 
     // The struct does not implement Deref trait
     #[derive(Copy, Clone)]
diff --git a/src/tools/clippy/tests/ui/explicit_deref_methods.stderr b/src/tools/clippy/tests/ui/explicit_deref_methods.stderr
index aab862baf599..2ca376cba00b 100644
--- a/src/tools/clippy/tests/ui/explicit_deref_methods.stderr
+++ b/src/tools/clippy/tests/ui/explicit_deref_methods.stderr
@@ -8,67 +8,67 @@ LL |     let b: &str = a.deref();
    = help: to override `-D warnings` add `#[allow(clippy::explicit_deref_methods)]`
 
 error: explicit `deref_mut` method call
-  --> tests/ui/explicit_deref_methods.rs:56:23
+  --> tests/ui/explicit_deref_methods.rs:57:23
    |
 LL |     let b: &mut str = a.deref_mut();
    |                       ^^^^^^^^^^^^^ help: try: `&mut **a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:59:39
+  --> tests/ui/explicit_deref_methods.rs:61:39
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                       ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:59:50
+  --> tests/ui/explicit_deref_methods.rs:61:50
    |
 LL |     let b: String = format!("{}, {}", a.deref(), a.deref());
    |                                                  ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:61:20
+  --> tests/ui/explicit_deref_methods.rs:65:20
    |
 LL |     println!("{}", a.deref());
    |                    ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:64:11
+  --> tests/ui/explicit_deref_methods.rs:69:11
    |
 LL |     match a.deref() {
    |           ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:68:28
+  --> tests/ui/explicit_deref_methods.rs:74:28
    |
 LL |     let b: String = concat(a.deref());
    |                            ^^^^^^^^^ help: try: `&*a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:70:13
+  --> tests/ui/explicit_deref_methods.rs:77:13
    |
 LL |     let b = just_return(a).deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:72:28
+  --> tests/ui/explicit_deref_methods.rs:80:28
    |
 LL |     let b: String = concat(just_return(a).deref());
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try: `just_return(a)`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:74:19
+  --> tests/ui/explicit_deref_methods.rs:83:19
    |
 LL |     let b: &str = a.deref().deref();
    |                   ^^^^^^^^^^^^^^^^^ help: try: `&**a`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:77:13
+  --> tests/ui/explicit_deref_methods.rs:87:13
    |
 LL |     let b = opt_a.unwrap().deref();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*opt_a.unwrap()`
 
 error: explicit `deref` method call
-  --> tests/ui/explicit_deref_methods.rs:114:31
+  --> tests/ui/explicit_deref_methods.rs:125:31
    |
 LL |     let b: &str = expr_deref!(a.deref());
    |                               ^^^^^^^^^ help: try: `&*a`
diff --git a/src/tools/clippy/tests/ui/explicit_into_iter_loop.fixed b/src/tools/clippy/tests/ui/explicit_into_iter_loop.fixed
index 6d67488a7130..2b68906ae39f 100644
--- a/src/tools/clippy/tests/ui/explicit_into_iter_loop.fixed
+++ b/src/tools/clippy/tests/ui/explicit_into_iter_loop.fixed
@@ -8,6 +8,7 @@ fn main() {
         for<'a> &'a T: IntoIterator<Item = &'a String>,
     {
         for _ in iterator {}
+        //~^ explicit_into_iter_loop
     }
 
     struct T;
@@ -21,9 +22,11 @@ fn main() {
 
     let mut t = T;
     for _ in &t {}
+    //~^ explicit_into_iter_loop
 
     let r = &t;
     for _ in r {}
+    //~^ explicit_into_iter_loop
 
     // No suggestion for this.
     // We'd have to suggest `for _ in *rr {}` which is less clear.
@@ -32,6 +35,7 @@ fn main() {
 
     let mr = &mut t;
     for _ in &*mr {}
+    //~^ explicit_into_iter_loop
 
     struct U;
     impl IntoIterator for &mut U {
@@ -44,9 +48,11 @@ fn main() {
 
     let mut u = U;
     for _ in &mut u {}
+    //~^ explicit_into_iter_loop
 
     let mr = &mut u;
     for _ in &mut *mr {}
+    //~^ explicit_into_iter_loop
 
     // Issue #6900
     struct S;
diff --git a/src/tools/clippy/tests/ui/explicit_into_iter_loop.rs b/src/tools/clippy/tests/ui/explicit_into_iter_loop.rs
index 14630c07c5cc..ca335b62d906 100644
--- a/src/tools/clippy/tests/ui/explicit_into_iter_loop.rs
+++ b/src/tools/clippy/tests/ui/explicit_into_iter_loop.rs
@@ -8,6 +8,7 @@ fn main() {
         for<'a> &'a T: IntoIterator<Item = &'a String>,
     {
         for _ in iterator.into_iter() {}
+        //~^ explicit_into_iter_loop
     }
 
     struct T;
@@ -21,9 +22,11 @@ fn main() {
 
     let mut t = T;
     for _ in t.into_iter() {}
+    //~^ explicit_into_iter_loop
 
     let r = &t;
     for _ in r.into_iter() {}
+    //~^ explicit_into_iter_loop
 
     // No suggestion for this.
     // We'd have to suggest `for _ in *rr {}` which is less clear.
@@ -32,6 +35,7 @@ fn main() {
 
     let mr = &mut t;
     for _ in mr.into_iter() {}
+    //~^ explicit_into_iter_loop
 
     struct U;
     impl IntoIterator for &mut U {
@@ -44,9 +48,11 @@ fn main() {
 
     let mut u = U;
     for _ in u.into_iter() {}
+    //~^ explicit_into_iter_loop
 
     let mr = &mut u;
     for _ in mr.into_iter() {}
+    //~^ explicit_into_iter_loop
 
     // Issue #6900
     struct S;
diff --git a/src/tools/clippy/tests/ui/explicit_into_iter_loop.stderr b/src/tools/clippy/tests/ui/explicit_into_iter_loop.stderr
index f0e2048e036f..1c3156755d4e 100644
--- a/src/tools/clippy/tests/ui/explicit_into_iter_loop.stderr
+++ b/src/tools/clippy/tests/ui/explicit_into_iter_loop.stderr
@@ -8,31 +8,31 @@ LL |         for _ in iterator.into_iter() {}
    = help: to override `-D warnings` add `#[allow(clippy::explicit_into_iter_loop)]`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> tests/ui/explicit_into_iter_loop.rs:23:14
+  --> tests/ui/explicit_into_iter_loop.rs:24:14
    |
 LL |     for _ in t.into_iter() {}
    |              ^^^^^^^^^^^^^ help: to write this more concisely, try: `&t`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> tests/ui/explicit_into_iter_loop.rs:26:14
+  --> tests/ui/explicit_into_iter_loop.rs:28:14
    |
 LL |     for _ in r.into_iter() {}
    |              ^^^^^^^^^^^^^ help: to write this more concisely, try: `r`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> tests/ui/explicit_into_iter_loop.rs:34:14
+  --> tests/ui/explicit_into_iter_loop.rs:37:14
    |
 LL |     for _ in mr.into_iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&*mr`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> tests/ui/explicit_into_iter_loop.rs:46:14
+  --> tests/ui/explicit_into_iter_loop.rs:50:14
    |
 LL |     for _ in u.into_iter() {}
    |              ^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut u`
 
 error: it is more concise to loop over containers instead of using explicit iteration methods
-  --> tests/ui/explicit_into_iter_loop.rs:49:14
+  --> tests/ui/explicit_into_iter_loop.rs:54:14
    |
 LL |     for _ in mr.into_iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut *mr`
diff --git a/src/tools/clippy/tests/ui/explicit_iter_loop.fixed b/src/tools/clippy/tests/ui/explicit_iter_loop.fixed
index 1148f0f6c6a6..cd0898dfc367 100644
--- a/src/tools/clippy/tests/ui/explicit_iter_loop.fixed
+++ b/src/tools/clippy/tests/ui/explicit_iter_loop.fixed
@@ -16,10 +16,13 @@ fn main() {
     let mut vec = vec![1, 2, 3, 4];
 
     for _ in &vec {}
+    //~^ explicit_iter_loop
     for _ in &mut vec {}
+    //~^ explicit_iter_loop
 
     let rvec = &vec;
     for _ in rvec {}
+    //~^ explicit_iter_loop
 
     let rmvec = &mut vec;
     for _ in rmvec.iter() {}
@@ -29,36 +32,48 @@ fn main() {
     for _ in &mut vec {} // these are fine
 
     for _ in &[1, 2, 3] {}
+    //~^ explicit_iter_loop
 
     for _ in (&mut [1, 2, 3]).iter() {}
 
     for _ in &[0; 32] {}
+    //~^ explicit_iter_loop
     for _ in &[0; 33] {}
+    //~^ explicit_iter_loop
 
     let ll: LinkedList<()> = LinkedList::new();
     for _ in &ll {}
+    //~^ explicit_iter_loop
     let rll = &ll;
     for _ in rll {}
+    //~^ explicit_iter_loop
 
     let vd: VecDeque<()> = VecDeque::new();
     for _ in &vd {}
+    //~^ explicit_iter_loop
     let rvd = &vd;
     for _ in rvd {}
+    //~^ explicit_iter_loop
 
     let bh: BinaryHeap<()> = BinaryHeap::new();
     for _ in &bh {}
+    //~^ explicit_iter_loop
 
     let hm: HashMap<(), ()> = HashMap::new();
     for _ in &hm {}
+    //~^ explicit_iter_loop
 
     let bt: BTreeMap<(), ()> = BTreeMap::new();
     for _ in &bt {}
+    //~^ explicit_iter_loop
 
     let hs: HashSet<()> = HashSet::new();
     for _ in &hs {}
+    //~^ explicit_iter_loop
 
     let bs: BTreeSet<()> = BTreeSet::new();
     for _ in &bs {}
+    //~^ explicit_iter_loop
 
     struct NoIntoIter();
     impl NoIntoIter {
@@ -148,10 +163,13 @@ fn main() {
     }
     let mut x = CustomType;
     for _ in &x {}
+    //~^ explicit_iter_loop
     for _ in &mut x {}
+    //~^ explicit_iter_loop
 
     let r = &x;
     for _ in r {}
+    //~^ explicit_iter_loop
 }
 
 #[clippy::msrv = "1.79"]
diff --git a/src/tools/clippy/tests/ui/explicit_iter_loop.rs b/src/tools/clippy/tests/ui/explicit_iter_loop.rs
index 4dda2f13e5b8..02405280ce42 100644
--- a/src/tools/clippy/tests/ui/explicit_iter_loop.rs
+++ b/src/tools/clippy/tests/ui/explicit_iter_loop.rs
@@ -16,10 +16,13 @@ fn main() {
     let mut vec = vec![1, 2, 3, 4];
 
     for _ in vec.iter() {}
+    //~^ explicit_iter_loop
     for _ in vec.iter_mut() {}
+    //~^ explicit_iter_loop
 
     let rvec = &vec;
     for _ in rvec.iter() {}
+    //~^ explicit_iter_loop
 
     let rmvec = &mut vec;
     for _ in rmvec.iter() {}
@@ -29,36 +32,48 @@ fn main() {
     for _ in &mut vec {} // these are fine
 
     for _ in [1, 2, 3].iter() {}
+    //~^ explicit_iter_loop
 
     for _ in (&mut [1, 2, 3]).iter() {}
 
     for _ in [0; 32].iter() {}
+    //~^ explicit_iter_loop
     for _ in [0; 33].iter() {}
+    //~^ explicit_iter_loop
 
     let ll: LinkedList<()> = LinkedList::new();
     for _ in ll.iter() {}
+    //~^ explicit_iter_loop
     let rll = &ll;
     for _ in rll.iter() {}
+    //~^ explicit_iter_loop
 
     let vd: VecDeque<()> = VecDeque::new();
     for _ in vd.iter() {}
+    //~^ explicit_iter_loop
     let rvd = &vd;
     for _ in rvd.iter() {}
+    //~^ explicit_iter_loop
 
     let bh: BinaryHeap<()> = BinaryHeap::new();
     for _ in bh.iter() {}
+    //~^ explicit_iter_loop
 
     let hm: HashMap<(), ()> = HashMap::new();
     for _ in hm.iter() {}
+    //~^ explicit_iter_loop
 
     let bt: BTreeMap<(), ()> = BTreeMap::new();
     for _ in bt.iter() {}
+    //~^ explicit_iter_loop
 
     let hs: HashSet<()> = HashSet::new();
     for _ in hs.iter() {}
+    //~^ explicit_iter_loop
 
     let bs: BTreeSet<()> = BTreeSet::new();
     for _ in bs.iter() {}
+    //~^ explicit_iter_loop
 
     struct NoIntoIter();
     impl NoIntoIter {
@@ -148,10 +163,13 @@ fn main() {
     }
     let mut x = CustomType;
     for _ in x.iter() {}
+    //~^ explicit_iter_loop
     for _ in x.iter_mut() {}
+    //~^ explicit_iter_loop
 
     let r = &x;
     for _ in r.iter() {}
+    //~^ explicit_iter_loop
 }
 
 #[clippy::msrv = "1.79"]
diff --git a/src/tools/clippy/tests/ui/explicit_iter_loop.stderr b/src/tools/clippy/tests/ui/explicit_iter_loop.stderr
index c646e61aa045..3816bb4db98b 100644
--- a/src/tools/clippy/tests/ui/explicit_iter_loop.stderr
+++ b/src/tools/clippy/tests/ui/explicit_iter_loop.stderr
@@ -11,103 +11,103 @@ LL | #![deny(clippy::explicit_iter_loop)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:19:14
+  --> tests/ui/explicit_iter_loop.rs:20:14
    |
 LL |     for _ in vec.iter_mut() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&mut vec`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:22:14
+  --> tests/ui/explicit_iter_loop.rs:24:14
    |
 LL |     for _ in rvec.iter() {}
    |              ^^^^^^^^^^^ help: to write this more concisely, try: `rvec`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:31:14
+  --> tests/ui/explicit_iter_loop.rs:34:14
    |
 LL |     for _ in [1, 2, 3].iter() {}
    |              ^^^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[1, 2, 3]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:35:14
+  --> tests/ui/explicit_iter_loop.rs:39:14
    |
 LL |     for _ in [0; 32].iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 32]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:36:14
+  --> tests/ui/explicit_iter_loop.rs:41:14
    |
 LL |     for _ in [0; 33].iter() {}
    |              ^^^^^^^^^^^^^^ help: to write this more concisely, try: `&[0; 33]`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:39:14
+  --> tests/ui/explicit_iter_loop.rs:45:14
    |
 LL |     for _ in ll.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&ll`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:41:14
+  --> tests/ui/explicit_iter_loop.rs:48:14
    |
 LL |     for _ in rll.iter() {}
    |              ^^^^^^^^^^ help: to write this more concisely, try: `rll`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:44:14
+  --> tests/ui/explicit_iter_loop.rs:52:14
    |
 LL |     for _ in vd.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&vd`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:46:14
+  --> tests/ui/explicit_iter_loop.rs:55:14
    |
 LL |     for _ in rvd.iter() {}
    |              ^^^^^^^^^^ help: to write this more concisely, try: `rvd`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:49:14
+  --> tests/ui/explicit_iter_loop.rs:59:14
    |
 LL |     for _ in bh.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bh`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:52:14
+  --> tests/ui/explicit_iter_loop.rs:63:14
    |
 LL |     for _ in hm.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&hm`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:55:14
+  --> tests/ui/explicit_iter_loop.rs:67:14
    |
 LL |     for _ in bt.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bt`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:58:14
+  --> tests/ui/explicit_iter_loop.rs:71:14
    |
 LL |     for _ in hs.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&hs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:61:14
+  --> tests/ui/explicit_iter_loop.rs:75:14
    |
 LL |     for _ in bs.iter() {}
    |              ^^^^^^^^^ help: to write this more concisely, try: `&bs`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:150:14
+  --> tests/ui/explicit_iter_loop.rs:165:14
    |
 LL |     for _ in x.iter() {}
    |              ^^^^^^^^ help: to write this more concisely, try: `&x`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:151:14
+  --> tests/ui/explicit_iter_loop.rs:167:14
    |
 LL |     for _ in x.iter_mut() {}
    |              ^^^^^^^^^^^^ help: to write this more concisely, try: `&mut x`
 
 error: it is more concise to loop over references to containers instead of using explicit iteration methods
-  --> tests/ui/explicit_iter_loop.rs:154:14
+  --> tests/ui/explicit_iter_loop.rs:171:14
    |
 LL |     for _ in r.iter() {}
    |              ^^^^^^^^ help: to write this more concisely, try: `r`
diff --git a/src/tools/clippy/tests/ui/explicit_write.fixed b/src/tools/clippy/tests/ui/explicit_write.fixed
index 77a910dc1963..024999fc609e 100644
--- a/src/tools/clippy/tests/ui/explicit_write.fixed
+++ b/src/tools/clippy/tests/ui/explicit_write.fixed
@@ -21,23 +21,36 @@ fn main() {
     {
         use std::io::Write;
         print!("test");
+        //~^ explicit_write
         eprint!("test");
+        //~^ explicit_write
         println!("test");
+        //~^ explicit_write
         eprintln!("test");
+        //~^ explicit_write
         print!("test");
+        //~^ explicit_write
         eprint!("test");
+        //~^ explicit_write
 
         // including newlines
         println!("test\ntest");
+        //~^ explicit_write
         eprintln!("test\ntest");
+        //~^ explicit_write
 
         let value = 1;
         eprintln!("with {}", value);
+        //~^ explicit_write
         eprintln!("with {} {}", 2, value);
+        //~^ explicit_write
         eprintln!("with {value}");
+        //~^ explicit_write
         eprintln!("macro arg {}", one!());
+        //~^ explicit_write
         let width = 2;
         eprintln!("{:w$}", value, w = width);
+        //~^ explicit_write
     }
     // these should not warn, different destination
     {
diff --git a/src/tools/clippy/tests/ui/explicit_write.rs b/src/tools/clippy/tests/ui/explicit_write.rs
index c77956264f6d..c83c760d48c8 100644
--- a/src/tools/clippy/tests/ui/explicit_write.rs
+++ b/src/tools/clippy/tests/ui/explicit_write.rs
@@ -21,23 +21,36 @@ fn main() {
     {
         use std::io::Write;
         write!(std::io::stdout(), "test").unwrap();
+        //~^ explicit_write
         write!(std::io::stderr(), "test").unwrap();
+        //~^ explicit_write
         writeln!(std::io::stdout(), "test").unwrap();
+        //~^ explicit_write
         writeln!(std::io::stderr(), "test").unwrap();
+        //~^ explicit_write
         std::io::stdout().write_fmt(format_args!("test")).unwrap();
+        //~^ explicit_write
         std::io::stderr().write_fmt(format_args!("test")).unwrap();
+        //~^ explicit_write
 
         // including newlines
         writeln!(std::io::stdout(), "test\ntest").unwrap();
+        //~^ explicit_write
         writeln!(std::io::stderr(), "test\ntest").unwrap();
+        //~^ explicit_write
 
         let value = 1;
         writeln!(std::io::stderr(), "with {}", value).unwrap();
+        //~^ explicit_write
         writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
+        //~^ explicit_write
         writeln!(std::io::stderr(), "with {value}").unwrap();
+        //~^ explicit_write
         writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
+        //~^ explicit_write
         let width = 2;
         writeln!(std::io::stderr(), "{:w$}", value, w = width).unwrap();
+        //~^ explicit_write
     }
     // these should not warn, different destination
     {
diff --git a/src/tools/clippy/tests/ui/explicit_write.stderr b/src/tools/clippy/tests/ui/explicit_write.stderr
index 0d22f02c36f2..670a0411b310 100644
--- a/src/tools/clippy/tests/ui/explicit_write.stderr
+++ b/src/tools/clippy/tests/ui/explicit_write.stderr
@@ -8,73 +8,73 @@ LL |         write!(std::io::stdout(), "test").unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::explicit_write)]`
 
 error: use of `write!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:24:9
+  --> tests/ui/explicit_write.rs:25:9
    |
 LL |         write!(std::io::stderr(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:25:9
+  --> tests/ui/explicit_write.rs:27:9
    |
 LL |         writeln!(std::io::stdout(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `println!("test")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:26:9
+  --> tests/ui/explicit_write.rs:29:9
    |
 LL |         writeln!(std::io::stderr(), "test").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("test")`
 
 error: use of `stdout().write_fmt(...).unwrap()`
-  --> tests/ui/explicit_write.rs:27:9
+  --> tests/ui/explicit_write.rs:31:9
    |
 LL |         std::io::stdout().write_fmt(format_args!("test")).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `print!("test")`
 
 error: use of `stderr().write_fmt(...).unwrap()`
-  --> tests/ui/explicit_write.rs:28:9
+  --> tests/ui/explicit_write.rs:33:9
    |
 LL |         std::io::stderr().write_fmt(format_args!("test")).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprint!("test")`
 
 error: use of `writeln!(stdout(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:31:9
+  --> tests/ui/explicit_write.rs:37:9
    |
 LL |         writeln!(std::io::stdout(), "test\ntest").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `println!("test\ntest")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:32:9
+  --> tests/ui/explicit_write.rs:39:9
    |
 LL |         writeln!(std::io::stderr(), "test\ntest").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("test\ntest")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:35:9
+  --> tests/ui/explicit_write.rs:43:9
    |
 LL |         writeln!(std::io::stderr(), "with {}", value).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {}", value)`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:36:9
+  --> tests/ui/explicit_write.rs:45:9
    |
 LL |         writeln!(std::io::stderr(), "with {} {}", 2, value).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {} {}", 2, value)`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:37:9
+  --> tests/ui/explicit_write.rs:47:9
    |
 LL |         writeln!(std::io::stderr(), "with {value}").unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("with {value}")`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:38:9
+  --> tests/ui/explicit_write.rs:49:9
    |
 LL |         writeln!(std::io::stderr(), "macro arg {}", one!()).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("macro arg {}", one!())`
 
 error: use of `writeln!(stderr(), ...).unwrap()`
-  --> tests/ui/explicit_write.rs:40:9
+  --> tests/ui/explicit_write.rs:52:9
    |
 LL |         writeln!(std::io::stderr(), "{:w$}", value, w = width).unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `eprintln!("{:w$}", value, w = width)`
diff --git a/src/tools/clippy/tests/ui/extend_with_drain.fixed b/src/tools/clippy/tests/ui/extend_with_drain.fixed
index 856c1a42dafc..7b314381e9a3 100644
--- a/src/tools/clippy/tests/ui/extend_with_drain.fixed
+++ b/src/tools/clippy/tests/ui/extend_with_drain.fixed
@@ -6,15 +6,18 @@ fn main() {
     let mut vec1 = vec![0u8; 1024];
     let mut vec2: std::vec::Vec<u8> = Vec::new();
     vec2.append(&mut vec1);
+    //~^ extend_with_drain
 
     let mut vec3 = vec![0u8; 1024];
     let mut vec4: std::vec::Vec<u8> = Vec::new();
 
     vec4.append(&mut vec3);
+    //~^ extend_with_drain
 
     let mut vec11: std::vec::Vec<u8> = Vec::new();
 
     vec11.append(&mut return_vector());
+    //~^ extend_with_drain
 
     //won't get linted it doesn't move the entire content of a vec into another
     let mut test1 = vec![0u8, 10];
@@ -46,6 +49,7 @@ fn main() {
     let ref_x = &mut x;
     let mut y = Vec::new();
     y.append(ref_x);
+    //~^ extend_with_drain
 }
 
 fn return_vector() -> Vec<u8> {
diff --git a/src/tools/clippy/tests/ui/extend_with_drain.rs b/src/tools/clippy/tests/ui/extend_with_drain.rs
index 7d538097639f..77214c053979 100644
--- a/src/tools/clippy/tests/ui/extend_with_drain.rs
+++ b/src/tools/clippy/tests/ui/extend_with_drain.rs
@@ -6,15 +6,18 @@ fn main() {
     let mut vec1 = vec![0u8; 1024];
     let mut vec2: std::vec::Vec<u8> = Vec::new();
     vec2.extend(vec1.drain(..));
+    //~^ extend_with_drain
 
     let mut vec3 = vec![0u8; 1024];
     let mut vec4: std::vec::Vec<u8> = Vec::new();
 
     vec4.extend(vec3.drain(..));
+    //~^ extend_with_drain
 
     let mut vec11: std::vec::Vec<u8> = Vec::new();
 
     vec11.extend(return_vector().drain(..));
+    //~^ extend_with_drain
 
     //won't get linted it doesn't move the entire content of a vec into another
     let mut test1 = vec![0u8, 10];
@@ -46,6 +49,7 @@ fn main() {
     let ref_x = &mut x;
     let mut y = Vec::new();
     y.extend(ref_x.drain(..));
+    //~^ extend_with_drain
 }
 
 fn return_vector() -> Vec<u8> {
diff --git a/src/tools/clippy/tests/ui/extend_with_drain.stderr b/src/tools/clippy/tests/ui/extend_with_drain.stderr
index 444cc82bbae7..2ee7aa7294e0 100644
--- a/src/tools/clippy/tests/ui/extend_with_drain.stderr
+++ b/src/tools/clippy/tests/ui/extend_with_drain.stderr
@@ -8,19 +8,19 @@ LL |     vec2.extend(vec1.drain(..));
    = help: to override `-D warnings` add `#[allow(clippy::extend_with_drain)]`
 
 error: use of `extend` instead of `append` for adding the full range of a second vector
-  --> tests/ui/extend_with_drain.rs:13:5
+  --> tests/ui/extend_with_drain.rs:14:5
    |
 LL |     vec4.extend(vec3.drain(..));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec4.append(&mut vec3)`
 
 error: use of `extend` instead of `append` for adding the full range of a second vector
-  --> tests/ui/extend_with_drain.rs:17:5
+  --> tests/ui/extend_with_drain.rs:19:5
    |
 LL |     vec11.extend(return_vector().drain(..));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec11.append(&mut return_vector())`
 
 error: use of `extend` instead of `append` for adding the full range of a second vector
-  --> tests/ui/extend_with_drain.rs:48:5
+  --> tests/ui/extend_with_drain.rs:51:5
    |
 LL |     y.extend(ref_x.drain(..));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `y.append(ref_x)`
diff --git a/src/tools/clippy/tests/ui/extra_unused_lifetimes.rs b/src/tools/clippy/tests/ui/extra_unused_lifetimes.rs
index aa964af3fc2d..5fdcd5a7e078 100644
--- a/src/tools/clippy/tests/ui/extra_unused_lifetimes.rs
+++ b/src/tools/clippy/tests/ui/extra_unused_lifetimes.rs
@@ -17,6 +17,7 @@ fn empty() {}
 fn used_lt<'a>(x: &'a u8) {}
 
 fn unused_lt<'a>(x: u8) {}
+//~^ extra_unused_lifetimes
 
 fn unused_lt_transitive<'a, 'b: 'a>(x: &'b u8) {
     // 'a is useless here since it's not directly bound
@@ -44,6 +45,7 @@ struct Bar;
 
 impl Bar {
     fn x<'a>(&self) {}
+    //~^ extra_unused_lifetimes
 }
 
 // test for #489 (used lifetimes in bounds)
@@ -70,6 +72,7 @@ impl X {
 mod issue4291 {
     trait BadTrait {
         fn unused_lt<'a>(x: u8) {}
+        //~^ extra_unused_lifetimes
     }
 
     impl BadTrait for () {
@@ -81,13 +84,16 @@ mod issue6437 {
     pub struct Scalar;
 
     impl<'a> std::ops::AddAssign<&Scalar> for &mut Scalar {
+        //~^ extra_unused_lifetimes
         fn add_assign(&mut self, _rhs: &Scalar) {
             unimplemented!();
         }
     }
 
     impl<'b> Scalar {
+        //~^ extra_unused_lifetimes
         pub fn something<'c>() -> Self {
+            //~^ extra_unused_lifetimes
             Self
         }
     }
@@ -117,6 +123,7 @@ mod second_case {
     // Should lint. The response to the above comment incorrectly called this a false positive. The
     // lifetime `'a` can be removed, as demonstrated below.
     impl<'a, T: Source + ?Sized + 'a> Source for Box<T> {
+        //~^ extra_unused_lifetimes
         fn hey() {}
     }
 
diff --git a/src/tools/clippy/tests/ui/extra_unused_lifetimes.stderr b/src/tools/clippy/tests/ui/extra_unused_lifetimes.stderr
index 85fbb7568ff4..0cecbbe80f76 100644
--- a/src/tools/clippy/tests/ui/extra_unused_lifetimes.stderr
+++ b/src/tools/clippy/tests/ui/extra_unused_lifetimes.stderr
@@ -8,37 +8,37 @@ LL | fn unused_lt<'a>(x: u8) {}
    = help: to override `-D warnings` add `#[allow(clippy::extra_unused_lifetimes)]`
 
 error: this lifetime isn't used in the function definition
-  --> tests/ui/extra_unused_lifetimes.rs:46:10
+  --> tests/ui/extra_unused_lifetimes.rs:47:10
    |
 LL |     fn x<'a>(&self) {}
    |          ^^
 
 error: this lifetime isn't used in the function definition
-  --> tests/ui/extra_unused_lifetimes.rs:72:22
+  --> tests/ui/extra_unused_lifetimes.rs:74:22
    |
 LL |         fn unused_lt<'a>(x: u8) {}
    |                      ^^
 
 error: this lifetime isn't used in the impl
-  --> tests/ui/extra_unused_lifetimes.rs:83:10
+  --> tests/ui/extra_unused_lifetimes.rs:86:10
    |
 LL |     impl<'a> std::ops::AddAssign<&Scalar> for &mut Scalar {
    |          ^^
 
 error: this lifetime isn't used in the impl
-  --> tests/ui/extra_unused_lifetimes.rs:89:10
+  --> tests/ui/extra_unused_lifetimes.rs:93:10
    |
 LL |     impl<'b> Scalar {
    |          ^^
 
 error: this lifetime isn't used in the function definition
-  --> tests/ui/extra_unused_lifetimes.rs:90:26
+  --> tests/ui/extra_unused_lifetimes.rs:95:26
    |
 LL |         pub fn something<'c>() -> Self {
    |                          ^^
 
 error: this lifetime isn't used in the impl
-  --> tests/ui/extra_unused_lifetimes.rs:119:10
+  --> tests/ui/extra_unused_lifetimes.rs:125:10
    |
 LL |     impl<'a, T: Source + ?Sized + 'a> Source for Box<T> {
    |          ^^
diff --git a/src/tools/clippy/tests/ui/extra_unused_type_parameters.fixed b/src/tools/clippy/tests/ui/extra_unused_type_parameters.fixed
index c9bebabdf17a..32d4f6c69390 100644
--- a/src/tools/clippy/tests/ui/extra_unused_type_parameters.fixed
+++ b/src/tools/clippy/tests/ui/extra_unused_type_parameters.fixed
@@ -7,14 +7,17 @@ extern crate proc_macros;
 use proc_macros::with_span;
 
 fn unused_ty(x: u8) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
 fn unused_multi(x: u8) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
 fn unused_with_lt<'a>(x: &'a u8) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
@@ -27,10 +30,12 @@ fn used_ret<T: Default>(x: u8) -> T {
 }
 
 fn unused_bounded<U>(x: U) {
+    //~^ extra_unused_type_parameters
     unimplemented!();
 }
 
 fn some_unused<B, C>(b: B, c: C) {
+    //~^ extra_unused_type_parameters
     unimplemented!();
 }
 
@@ -56,6 +61,7 @@ struct S;
 
 impl S {
     fn unused_ty_impl(&self) {
+        //~^ extra_unused_type_parameters
         unimplemented!()
     }
 }
@@ -78,6 +84,7 @@ where
 }
 
 fn unused_opaque(dummy: impl Default) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
@@ -91,6 +98,7 @@ mod unexported_trait_bounds {
     }
 
     fn unused_with_priv_trait_bound<T: private::Private>() {
+        //~^ extra_unused_type_parameters
         unimplemented!();
     }
 }
diff --git a/src/tools/clippy/tests/ui/extra_unused_type_parameters.rs b/src/tools/clippy/tests/ui/extra_unused_type_parameters.rs
index 1bc0047adf01..c1e6f32ca12f 100644
--- a/src/tools/clippy/tests/ui/extra_unused_type_parameters.rs
+++ b/src/tools/clippy/tests/ui/extra_unused_type_parameters.rs
@@ -7,14 +7,17 @@ extern crate proc_macros;
 use proc_macros::with_span;
 
 fn unused_ty<T>(x: u8) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
 fn unused_multi<T, U>(x: u8) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
 fn unused_with_lt<'a, T>(x: &'a u8) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
@@ -27,10 +30,12 @@ fn used_ret<T: Default>(x: u8) -> T {
 }
 
 fn unused_bounded<T: Default, U, V: Default>(x: U) {
+    //~^ extra_unused_type_parameters
     unimplemented!();
 }
 
 fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
+    //~^ extra_unused_type_parameters
     unimplemented!();
 }
 
@@ -56,6 +61,7 @@ struct S;
 
 impl S {
     fn unused_ty_impl<T>(&self) {
+        //~^ extra_unused_type_parameters
         unimplemented!()
     }
 }
@@ -78,6 +84,7 @@ where
 }
 
 fn unused_opaque<A, B>(dummy: impl Default) {
+    //~^ extra_unused_type_parameters
     unimplemented!()
 }
 
@@ -91,6 +98,7 @@ mod unexported_trait_bounds {
     }
 
     fn unused_with_priv_trait_bound<T: private::Private, U>() {
+        //~^ extra_unused_type_parameters
         unimplemented!();
     }
 }
diff --git a/src/tools/clippy/tests/ui/extra_unused_type_parameters.stderr b/src/tools/clippy/tests/ui/extra_unused_type_parameters.stderr
index 928c0038c2c3..5086826ae5c0 100644
--- a/src/tools/clippy/tests/ui/extra_unused_type_parameters.stderr
+++ b/src/tools/clippy/tests/ui/extra_unused_type_parameters.stderr
@@ -8,19 +8,19 @@ LL | fn unused_ty<T>(x: u8) {
    = help: to override `-D warnings` add `#[allow(clippy::extra_unused_type_parameters)]`
 
 error: type parameters go unused in function definition: T, U
-  --> tests/ui/extra_unused_type_parameters.rs:13:16
+  --> tests/ui/extra_unused_type_parameters.rs:14:16
    |
 LL | fn unused_multi<T, U>(x: u8) {
    |                ^^^^^^ help: consider removing the parameters
 
 error: type parameter `T` goes unused in function definition
-  --> tests/ui/extra_unused_type_parameters.rs:17:21
+  --> tests/ui/extra_unused_type_parameters.rs:19:21
    |
 LL | fn unused_with_lt<'a, T>(x: &'a u8) {
    |                     ^^^ help: consider removing the parameter
 
 error: type parameters go unused in function definition: T, V
-  --> tests/ui/extra_unused_type_parameters.rs:29:19
+  --> tests/ui/extra_unused_type_parameters.rs:32:19
    |
 LL | fn unused_bounded<T: Default, U, V: Default>(x: U) {
    |                   ^^^^^^^^^^^^ ^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL + fn unused_bounded<U>(x: U) {
    |
 
 error: type parameters go unused in function definition: A, D, E
-  --> tests/ui/extra_unused_type_parameters.rs:33:16
+  --> tests/ui/extra_unused_type_parameters.rs:37:16
    |
 LL | fn some_unused<A, B, C, D: Iterator<Item = (B, C)>, E>(b: B, c: C) {
    |                ^^^    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,19 +44,19 @@ LL + fn some_unused<B, C>(b: B, c: C) {
    |
 
 error: type parameter `T` goes unused in function definition
-  --> tests/ui/extra_unused_type_parameters.rs:58:22
+  --> tests/ui/extra_unused_type_parameters.rs:63:22
    |
 LL |     fn unused_ty_impl<T>(&self) {
    |                      ^^^ help: consider removing the parameter
 
 error: type parameters go unused in function definition: A, B
-  --> tests/ui/extra_unused_type_parameters.rs:80:17
+  --> tests/ui/extra_unused_type_parameters.rs:86:17
    |
 LL | fn unused_opaque<A, B>(dummy: impl Default) {
    |                 ^^^^^^ help: consider removing the parameters
 
 error: type parameter `U` goes unused in function definition
-  --> tests/ui/extra_unused_type_parameters.rs:93:56
+  --> tests/ui/extra_unused_type_parameters.rs:100:56
    |
 LL |     fn unused_with_priv_trait_bound<T: private::Private, U>() {
    |                                                        ^^^ help: consider removing the parameter
diff --git a/src/tools/clippy/tests/ui/extra_unused_type_parameters_unfixable.rs b/src/tools/clippy/tests/ui/extra_unused_type_parameters_unfixable.rs
index 65b53eb2e4b3..87ce517a0a45 100644
--- a/src/tools/clippy/tests/ui/extra_unused_type_parameters_unfixable.rs
+++ b/src/tools/clippy/tests/ui/extra_unused_type_parameters_unfixable.rs
@@ -1,7 +1,7 @@
 #![warn(clippy::extra_unused_type_parameters)]
 
 fn unused_where_clause<T, U>(x: U)
-//~^ ERROR: type parameter `T` goes unused in function definition
+//~^ extra_unused_type_parameters
 where
     T: Default,
 {
@@ -9,7 +9,7 @@ where
 }
 
 fn unused_multi_where_clause<T, U, V: Default>(x: U)
-//~^ ERROR: type parameters go unused in function definition: T, V
+//~^ extra_unused_type_parameters
 where
     T: Default,
 {
@@ -17,7 +17,7 @@ where
 }
 
 fn unused_all_where_clause<T, U: Default, V: Default>()
-//~^ ERROR: type parameters go unused in function definition: T, U, V
+//~^ extra_unused_type_parameters
 where
     T: Default,
 {
diff --git a/src/tools/clippy/tests/ui/fallible_impl_from.rs b/src/tools/clippy/tests/ui/fallible_impl_from.rs
index a81e51fcac75..1c62c1e937b6 100644
--- a/src/tools/clippy/tests/ui/fallible_impl_from.rs
+++ b/src/tools/clippy/tests/ui/fallible_impl_from.rs
@@ -4,7 +4,8 @@
 // docs example
 struct Foo(i32);
 impl From<String> for Foo {
-    //~^ ERROR: consider implementing `TryFrom` instead
+    //~^ fallible_impl_from
+
     fn from(s: String) -> Self {
         Foo(s.parse().unwrap())
     }
@@ -26,7 +27,8 @@ impl From<usize> for Valid {
 struct Invalid;
 
 impl From<usize> for Invalid {
-    //~^ ERROR: consider implementing `TryFrom` instead
+    //~^ fallible_impl_from
+
     fn from(i: usize) -> Invalid {
         if i != 42 {
             panic!();
@@ -36,7 +38,8 @@ impl From<usize> for Invalid {
 }
 
 impl From<Option<String>> for Invalid {
-    //~^ ERROR: consider implementing `TryFrom` instead
+    //~^ fallible_impl_from
+
     fn from(s: Option<String>) -> Invalid {
         let s = s.unwrap();
         if !s.is_empty() {
@@ -55,7 +58,8 @@ impl<T> ProjStrTrait for Box<T> {
     type ProjString = String;
 }
 impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {
-    //~^ ERROR: consider implementing `TryFrom` instead
+    //~^ fallible_impl_from
+
     fn from(s: &'a mut <Box<u32> as ProjStrTrait>::ProjString) -> Invalid {
         if s.parse::<u32>().ok().unwrap() != 42 {
             panic!("{:?}", s);
diff --git a/src/tools/clippy/tests/ui/fallible_impl_from.stderr b/src/tools/clippy/tests/ui/fallible_impl_from.stderr
index cc3739031b76..d773fc3a6d7c 100644
--- a/src/tools/clippy/tests/ui/fallible_impl_from.stderr
+++ b/src/tools/clippy/tests/ui/fallible_impl_from.stderr
@@ -3,15 +3,15 @@ error: consider implementing `TryFrom` instead
    |
 LL | / impl From<String> for Foo {
 LL | |
+LL | |
 LL | |     fn from(s: String) -> Self {
-LL | |         Foo(s.parse().unwrap())
-LL | |     }
+...  |
 LL | | }
    | |_^
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:9:13
+  --> tests/ui/fallible_impl_from.rs:10:13
    |
 LL |         Foo(s.parse().unwrap())
    |             ^^^^^^^^^^^^^^^^^^
@@ -22,38 +22,38 @@ LL | #![deny(clippy::fallible_impl_from)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider implementing `TryFrom` instead
-  --> tests/ui/fallible_impl_from.rs:28:1
+  --> tests/ui/fallible_impl_from.rs:29:1
    |
 LL | / impl From<usize> for Invalid {
 LL | |
+LL | |
 LL | |     fn from(i: usize) -> Invalid {
-LL | |         if i != 42 {
 ...  |
 LL | | }
    | |_^
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:32:13
+  --> tests/ui/fallible_impl_from.rs:34:13
    |
 LL |             panic!();
    |             ^^^^^^^^
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> tests/ui/fallible_impl_from.rs:38:1
+  --> tests/ui/fallible_impl_from.rs:40:1
    |
 LL | / impl From<Option<String>> for Invalid {
 LL | |
+LL | |
 LL | |     fn from(s: Option<String>) -> Invalid {
-LL | |         let s = s.unwrap();
 ...  |
 LL | | }
    | |_^
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:41:17
+  --> tests/ui/fallible_impl_from.rs:44:17
    |
 LL |         let s = s.unwrap();
    |                 ^^^^^^^^^^
@@ -67,19 +67,19 @@ LL |             panic!("{:?}", s);
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: consider implementing `TryFrom` instead
-  --> tests/ui/fallible_impl_from.rs:57:1
+  --> tests/ui/fallible_impl_from.rs:60:1
    |
 LL | / impl<'a> From<&'a mut <Box<u32> as ProjStrTrait>::ProjString> for Invalid {
 LL | |
+LL | |
 LL | |     fn from(s: &'a mut <Box<u32> as ProjStrTrait>::ProjString) -> Invalid {
-LL | |         if s.parse::<u32>().ok().unwrap() != 42 {
 ...  |
 LL | | }
    | |_^
    |
    = help: `From` is intended for infallible conversions only. Use `TryFrom` if there's a possibility for the conversion to fail
 note: potential failure(s)
-  --> tests/ui/fallible_impl_from.rs:60:12
+  --> tests/ui/fallible_impl_from.rs:64:12
    |
 LL |         if s.parse::<u32>().ok().unwrap() != 42 {
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/field_reassign_with_default.rs b/src/tools/clippy/tests/ui/field_reassign_with_default.rs
index 2a432751952d..f3179b78ecb7 100644
--- a/src/tools/clippy/tests/ui/field_reassign_with_default.rs
+++ b/src/tools/clippy/tests/ui/field_reassign_with_default.rs
@@ -55,6 +55,7 @@ fn main() {
     // wrong, produces first error in stderr
     let mut a: A = Default::default();
     a.i = 42;
+    //~^ field_reassign_with_default
 
     // right
     let mut a: A = Default::default();
@@ -95,17 +96,20 @@ fn main() {
     // wrong, produces second error in stderr
     let mut a: A = Default::default();
     a.j = 43;
+    //~^ field_reassign_with_default
     a.i = 42;
 
     // wrong, produces third error in stderr
     let mut a: A = Default::default();
     a.i = 42;
+    //~^ field_reassign_with_default
     a.j = 43;
     a.j = 44;
 
     // wrong, produces fourth error in stderr
     let mut a = A::default();
     a.i = 42;
+    //~^ field_reassign_with_default
 
     // wrong, but does not produce an error in stderr, because we can't produce a correct kind of
     // suggestion with current implementation
@@ -116,10 +120,12 @@ fn main() {
     // wrong, produces the fifth error in stderr
     let mut a: A = Default::default();
     a.i = Default::default();
+    //~^ field_reassign_with_default
 
     // wrong, produces the sixth error in stderr
     let mut a: A = Default::default();
     a.i = Default::default();
+    //~^ field_reassign_with_default
     a.j = 45;
 
     // right, because an assignment refers to another field
@@ -142,6 +148,7 @@ fn main() {
     // don't expand macros in the suggestion (#6522)
     let mut a: C = C::default();
     a.i = vec![1];
+    //~^ field_reassign_with_default
 
     // Don't lint in external macros
     external! {
@@ -160,9 +167,11 @@ fn main() {
     // be sure suggestion is correct with generics
     let mut a: Wrapper<bool> = Default::default();
     a.i = true;
+    //~^ field_reassign_with_default
 
     let mut a: WrapperMulti<i32, i64> = Default::default();
     a.i = 42;
+    //~^ field_reassign_with_default
 
     // Don't lint in macros
     inline!(
@@ -234,6 +243,7 @@ mod issue6312 {
         fn new(name: &str) -> Self {
             let mut f = ImplDropAllCopy::default();
             f.name = name.len();
+            //~^ field_reassign_with_default
             f
         }
         fn close(&self) {}
@@ -250,6 +260,7 @@ mod issue6312 {
         fn new(name: &str) -> Self {
             let mut f = NoDropAllCopy::default();
             f.name = name.len();
+            //~^ field_reassign_with_default
             f
         }
     }
diff --git a/src/tools/clippy/tests/ui/field_reassign_with_default.stderr b/src/tools/clippy/tests/ui/field_reassign_with_default.stderr
index ae909475c6f2..19382e671510 100644
--- a/src/tools/clippy/tests/ui/field_reassign_with_default.stderr
+++ b/src/tools/clippy/tests/ui/field_reassign_with_default.stderr
@@ -13,121 +13,121 @@ LL |     let mut a: A = Default::default();
    = help: to override `-D warnings` add `#[allow(clippy::field_reassign_with_default)]`
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:97:5
+  --> tests/ui/field_reassign_with_default.rs:98:5
    |
 LL |     a.j = 43;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { j: 43, i: 42 }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:96:5
+  --> tests/ui/field_reassign_with_default.rs:97:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:102:5
+  --> tests/ui/field_reassign_with_default.rs:104:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { i: 42, j: 44 }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:101:5
+  --> tests/ui/field_reassign_with_default.rs:103:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:108:5
+  --> tests/ui/field_reassign_with_default.rs:111:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `main::A { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:107:5
+  --> tests/ui/field_reassign_with_default.rs:110:5
    |
 LL |     let mut a = A::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:118:5
-   |
-LL |     a.i = Default::default();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-note: consider initializing the variable with `main::A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:117:5
-   |
-LL |     let mut a: A = Default::default();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: field assignment outside of initializer for an instance created with Default::default()
   --> tests/ui/field_reassign_with_default.rs:122:5
    |
 LL |     a.i = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
-note: consider initializing the variable with `main::A { i: Default::default(), j: 45 }` and removing relevant reassignments
+note: consider initializing the variable with `main::A { i: Default::default(), ..Default::default() }` and removing relevant reassignments
   --> tests/ui/field_reassign_with_default.rs:121:5
    |
 LL |     let mut a: A = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:144:5
+  --> tests/ui/field_reassign_with_default.rs:127:5
+   |
+LL |     a.i = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: consider initializing the variable with `main::A { i: Default::default(), j: 45 }` and removing relevant reassignments
+  --> tests/ui/field_reassign_with_default.rs:126:5
+   |
+LL |     let mut a: A = Default::default();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: field assignment outside of initializer for an instance created with Default::default()
+  --> tests/ui/field_reassign_with_default.rs:150:5
    |
 LL |     a.i = vec![1];
    |     ^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `C { i: vec![1], ..Default::default() }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:143:5
+  --> tests/ui/field_reassign_with_default.rs:149:5
    |
 LL |     let mut a: C = C::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:162:5
+  --> tests/ui/field_reassign_with_default.rs:169:5
    |
 LL |     a.i = true;
    |     ^^^^^^^^^^^
    |
 note: consider initializing the variable with `Wrapper::<bool> { i: true }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:161:5
+  --> tests/ui/field_reassign_with_default.rs:168:5
    |
 LL |     let mut a: Wrapper<bool> = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:165:5
+  --> tests/ui/field_reassign_with_default.rs:173:5
    |
 LL |     a.i = 42;
    |     ^^^^^^^^^
    |
 note: consider initializing the variable with `WrapperMulti::<i32, i64> { i: 42, ..Default::default() }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:164:5
+  --> tests/ui/field_reassign_with_default.rs:172:5
    |
 LL |     let mut a: WrapperMulti<i32, i64> = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:236:13
+  --> tests/ui/field_reassign_with_default.rs:245:13
    |
 LL |             f.name = name.len();
    |             ^^^^^^^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `issue6312::ImplDropAllCopy { name: name.len(), ..Default::default() }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:235:13
+  --> tests/ui/field_reassign_with_default.rs:244:13
    |
 LL |             let mut f = ImplDropAllCopy::default();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: field assignment outside of initializer for an instance created with Default::default()
-  --> tests/ui/field_reassign_with_default.rs:252:13
+  --> tests/ui/field_reassign_with_default.rs:262:13
    |
 LL |             f.name = name.len();
    |             ^^^^^^^^^^^^^^^^^^^^
    |
 note: consider initializing the variable with `issue6312::NoDropAllCopy { name: name.len(), ..Default::default() }` and removing relevant reassignments
-  --> tests/ui/field_reassign_with_default.rs:251:13
+  --> tests/ui/field_reassign_with_default.rs:261:13
    |
 LL |             let mut f = NoDropAllCopy::default();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.rs b/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.rs
index 5789dbf9b1d7..159cabad1b43 100644
--- a/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.rs
+++ b/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.rs
@@ -7,8 +7,11 @@ pub mod pub_module {
         private_field: bool,
         pub pub_field: bool,
         pub(crate) pub_crate_field: bool,
+        //~^ field_scoped_visibility_modifiers
         pub(in crate::pub_module) pub_in_path_field: bool,
+        //~^ field_scoped_visibility_modifiers
         pub(super) pub_super_field: bool,
+        //~^ field_scoped_visibility_modifiers
         #[allow(clippy::needless_pub_self)]
         pub(self) pub_self_field: bool,
     }
diff --git a/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.stderr b/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.stderr
index beea6c92107c..c0c202fd87af 100644
--- a/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.stderr
+++ b/src/tools/clippy/tests/ui/field_scoped_visibility_modifiers.stderr
@@ -9,7 +9,7 @@ LL |         pub(crate) pub_crate_field: bool,
    = help: to override `-D warnings` add `#[allow(clippy::field_scoped_visibility_modifiers)]`
 
 error: scoped visibility modifier on a field
-  --> tests/ui/field_scoped_visibility_modifiers.rs:10:9
+  --> tests/ui/field_scoped_visibility_modifiers.rs:11:9
    |
 LL |         pub(in crate::pub_module) pub_in_path_field: bool,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |         pub(in crate::pub_module) pub_in_path_field: bool,
    = help: consider making the field private and adding a scoped visibility method for it
 
 error: scoped visibility modifier on a field
-  --> tests/ui/field_scoped_visibility_modifiers.rs:11:9
+  --> tests/ui/field_scoped_visibility_modifiers.rs:13:9
    |
 LL |         pub(super) pub_super_field: bool,
    |         ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/filetype_is_file.rs b/src/tools/clippy/tests/ui/filetype_is_file.rs
index 9e8a4c04324b..8ca01b91210f 100644
--- a/src/tools/clippy/tests/ui/filetype_is_file.rs
+++ b/src/tools/clippy/tests/ui/filetype_is_file.rs
@@ -7,19 +7,22 @@ fn main() -> std::io::Result<()> {
 
     // !filetype.is_dir()
     if fs::metadata("foo.txt")?.file_type().is_file() {
-        //~^ ERROR: `FileType::is_file()` only covers regular files
+        //~^ filetype_is_file
+
         // read file
     }
 
     // positive of filetype.is_dir()
     if !fs::metadata("foo.txt")?.file_type().is_file() {
-        //~^ ERROR: `!FileType::is_file()` only denies regular files
+        //~^ filetype_is_file
+
         // handle dir
     }
 
     // false positive of filetype.is_dir()
     if !fs::metadata("foo.txt")?.file_type().is_file().bitor(true) {
-        //~^ ERROR: `FileType::is_file()` only covers regular files
+        //~^ filetype_is_file
+
         // ...
     }
 
diff --git a/src/tools/clippy/tests/ui/filetype_is_file.stderr b/src/tools/clippy/tests/ui/filetype_is_file.stderr
index 0c66910c1b61..b930ac929748 100644
--- a/src/tools/clippy/tests/ui/filetype_is_file.stderr
+++ b/src/tools/clippy/tests/ui/filetype_is_file.stderr
@@ -9,7 +9,7 @@ LL |     if fs::metadata("foo.txt")?.file_type().is_file() {
    = help: to override `-D warnings` add `#[allow(clippy::filetype_is_file)]`
 
 error: `!FileType::is_file()` only denies regular files
-  --> tests/ui/filetype_is_file.rs:15:8
+  --> tests/ui/filetype_is_file.rs:16:8
    |
 LL |     if !fs::metadata("foo.txt")?.file_type().is_file() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     if !fs::metadata("foo.txt")?.file_type().is_file() {
    = help: use `FileType::is_dir()` instead
 
 error: `FileType::is_file()` only covers regular files
-  --> tests/ui/filetype_is_file.rs:21:9
+  --> tests/ui/filetype_is_file.rs:23:9
    |
 LL |     if !fs::metadata("foo.txt")?.file_type().is_file().bitor(true) {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/filter_map_bool_then.fixed b/src/tools/clippy/tests/ui/filter_map_bool_then.fixed
index 6a1b81fdbcbe..b3e112f19eb4 100644
--- a/src/tools/clippy/tests/ui/filter_map_bool_then.fixed
+++ b/src/tools/clippy/tests/ui/filter_map_bool_then.fixed
@@ -17,24 +17,30 @@ struct NonCopy;
 fn main() {
     let v = vec![1, 2, 3, 4, 5, 6];
     v.clone().iter().filter(|&i| (i % 2 == 0)).map(|i| i + 1);
+    //~^ filter_map_bool_then
     v.clone().into_iter().filter(|&i| (i % 2 == 0)).map(|i| i + 1);
+    //~^ filter_map_bool_then
     v.clone()
         .into_iter()
         .filter(|&i| (i % 2 == 0)).map(|i| i + 1);
+    //~^ filter_map_bool_then
     v.clone()
         .into_iter()
         .filter(|&i| i != 1000)
         .filter(|&i| (i % 2 == 0)).map(|i| i + 1);
+    //~^ filter_map_bool_then
     v.iter()
         .copied()
         .filter(|&i| i != 1000)
         .filter(|&i| (i.clone() % 2 == 0)).map(|i| i + 1);
+    //~^ filter_map_bool_then
     // Despite this is non-copy, `is_copy` still returns true (at least now) because it's `&NonCopy`,
     // and any `&` is `Copy`. So since we can dereference it in `filter` (since it's then `&&NonCopy`),
     // we can lint this and still get the same input type.
     // See: <https://doc.rust-lang.org/std/primitive.reference.html#trait-implementations-1>
     let v = vec![NonCopy, NonCopy];
     v.clone().iter().filter(|&i| (i == &NonCopy)).map(|i| i);
+    //~^ filter_map_bool_then
     // Do not lint
     let v = vec![NonCopy, NonCopy];
     v.clone().into_iter().filter_map(|i| (i == NonCopy).then(|| i));
@@ -59,14 +65,17 @@ fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str
 fn issue11503() {
     let bools: &[bool] = &[true, false, false, true];
     let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| *b).map(|(i, b)| i).collect();
+    //~^ filter_map_bool_then
 
     // Need to insert multiple derefs if there is more than one layer of references
     let bools: &[&&bool] = &[&&true, &&false, &&false, &&true];
     let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| ***b).map(|(i, b)| i).collect();
+    //~^ filter_map_bool_then
 
     // Should also suggest derefs when going through a mutable reference
     let bools: &[&mut bool] = &[&mut true];
     let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| **b).map(|(i, b)| i).collect();
+    //~^ filter_map_bool_then
 
     // Should also suggest derefs when going through a custom deref
     struct DerefToBool;
@@ -78,4 +87,5 @@ fn issue11503() {
     }
     let bools: &[&&DerefToBool] = &[&&DerefToBool];
     let _: Vec<usize> = bools.iter().enumerate().filter(|&(i, b)| ****b).map(|(i, b)| i).collect();
+    //~^ filter_map_bool_then
 }
diff --git a/src/tools/clippy/tests/ui/filter_map_bool_then.rs b/src/tools/clippy/tests/ui/filter_map_bool_then.rs
index a41e88f8805d..d996b3cb3c52 100644
--- a/src/tools/clippy/tests/ui/filter_map_bool_then.rs
+++ b/src/tools/clippy/tests/ui/filter_map_bool_then.rs
@@ -17,24 +17,30 @@ struct NonCopy;
 fn main() {
     let v = vec![1, 2, 3, 4, 5, 6];
     v.clone().iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    //~^ filter_map_bool_then
     v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    //~^ filter_map_bool_then
     v.clone()
         .into_iter()
         .filter_map(|i| -> Option<_> { (i % 2 == 0).then(|| i + 1) });
+    //~^ filter_map_bool_then
     v.clone()
         .into_iter()
         .filter(|&i| i != 1000)
         .filter_map(|i| (i % 2 == 0).then(|| i + 1));
+    //~^ filter_map_bool_then
     v.iter()
         .copied()
         .filter(|&i| i != 1000)
         .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
+    //~^ filter_map_bool_then
     // Despite this is non-copy, `is_copy` still returns true (at least now) because it's `&NonCopy`,
     // and any `&` is `Copy`. So since we can dereference it in `filter` (since it's then `&&NonCopy`),
     // we can lint this and still get the same input type.
     // See: <https://doc.rust-lang.org/std/primitive.reference.html#trait-implementations-1>
     let v = vec![NonCopy, NonCopy];
     v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
+    //~^ filter_map_bool_then
     // Do not lint
     let v = vec![NonCopy, NonCopy];
     v.clone().into_iter().filter_map(|i| (i == NonCopy).then(|| i));
@@ -59,14 +65,17 @@ fn issue11309<'a>(iter: impl Iterator<Item = (&'a str, &'a str)>) -> Vec<&'a str
 fn issue11503() {
     let bools: &[bool] = &[true, false, false, true];
     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+    //~^ filter_map_bool_then
 
     // Need to insert multiple derefs if there is more than one layer of references
     let bools: &[&&bool] = &[&&true, &&false, &&false, &&true];
     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+    //~^ filter_map_bool_then
 
     // Should also suggest derefs when going through a mutable reference
     let bools: &[&mut bool] = &[&mut true];
     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+    //~^ filter_map_bool_then
 
     // Should also suggest derefs when going through a custom deref
     struct DerefToBool;
@@ -78,4 +87,5 @@ fn issue11503() {
     }
     let bools: &[&&DerefToBool] = &[&&DerefToBool];
     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
+    //~^ filter_map_bool_then
 }
diff --git a/src/tools/clippy/tests/ui/filter_map_bool_then.stderr b/src/tools/clippy/tests/ui/filter_map_bool_then.stderr
index 088b9ba12867..aeb1baeb35e6 100644
--- a/src/tools/clippy/tests/ui/filter_map_bool_then.stderr
+++ b/src/tools/clippy/tests/ui/filter_map_bool_then.stderr
@@ -8,55 +8,55 @@ LL |     v.clone().iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
    = help: to override `-D warnings` add `#[allow(clippy::filter_map_bool_then)]`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:20:27
+  --> tests/ui/filter_map_bool_then.rs:21:27
    |
 LL |     v.clone().into_iter().filter_map(|i| (i % 2 == 0).then(|| i + 1));
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:23:10
+  --> tests/ui/filter_map_bool_then.rs:25:10
    |
 LL |         .filter_map(|i| -> Option<_> { (i % 2 == 0).then(|| i + 1) });
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:27:10
+  --> tests/ui/filter_map_bool_then.rs:30:10
    |
 LL |         .filter_map(|i| (i % 2 == 0).then(|| i + 1));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:31:10
+  --> tests/ui/filter_map_bool_then.rs:35:10
    |
 LL |         .filter_map(|i| (i.clone() % 2 == 0).then(|| i + 1));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i.clone() % 2 == 0)).map(|i| i + 1)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:37:22
+  --> tests/ui/filter_map_bool_then.rs:42:22
    |
 LL |     v.clone().iter().filter_map(|i| (i == &NonCopy).then(|| i));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&i| (i == &NonCopy)).map(|i| i)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:61:50
+  --> tests/ui/filter_map_bool_then.rs:67:50
    |
 LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| *b).map(|(i, b)| i)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:65:50
+  --> tests/ui/filter_map_bool_then.rs:72:50
    |
 LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| ***b).map(|(i, b)| i)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:69:50
+  --> tests/ui/filter_map_bool_then.rs:77:50
    |
 LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| **b).map(|(i, b)| i)`
 
 error: usage of `bool::then` in `filter_map`
-  --> tests/ui/filter_map_bool_then.rs:80:50
+  --> tests/ui/filter_map_bool_then.rs:89:50
    |
 LL |     let _: Vec<usize> = bools.iter().enumerate().filter_map(|(i, b)| b.then(|| i)).collect();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `filter` then `map` instead: `filter(|&(i, b)| ****b).map(|(i, b)| i)`
diff --git a/src/tools/clippy/tests/ui/filter_map_identity.fixed b/src/tools/clippy/tests/ui/filter_map_identity.fixed
index fdd020fcd773..c9e2c5f5049f 100644
--- a/src/tools/clippy/tests/ui/filter_map_identity.fixed
+++ b/src/tools/clippy/tests/ui/filter_map_identity.fixed
@@ -26,59 +26,75 @@ fn main() {
     {
         // into_iter
         copy_vec_non_inferred().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         non_copy_vec().into_iter().flatten();
-        //~^ ERROR: use of
-        non_copy_vec().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         non_copy_vec().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         non_copy_vec().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         non_copy_vec().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         non_copy_vec().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
+        non_copy_vec().into_iter().flatten();
+        //~^ filter_map_identity
 
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         // we are forced to pass the type in the call.
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         #[rustfmt::skip]
             copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         #[rustfmt::skip]
             copy_vec::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         // note, the compiler requires that we pass the type to `opaque`. This is mostly for reference,
         // it behaves the same as copy_vec.
         opaque::<i32>().into_iter().flatten();
-        //~^ ERROR: use of
+        //~^ filter_map_identity
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/filter_map_identity.rs b/src/tools/clippy/tests/ui/filter_map_identity.rs
index a626de9f5bbd..4c8d48f5221f 100644
--- a/src/tools/clippy/tests/ui/filter_map_identity.rs
+++ b/src/tools/clippy/tests/ui/filter_map_identity.rs
@@ -26,59 +26,75 @@ fn main() {
     {
         // into_iter
         copy_vec_non_inferred().into_iter().filter_map(|x| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().filter_map(std::convert::identity);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().filter_map(identity);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().filter_map(|x| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec_non_inferred().into_iter().filter_map(|x| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         non_copy_vec().into_iter().filter_map(|x| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         non_copy_vec().into_iter().filter_map(|x| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         non_copy_vec().into_iter().filter_map(std::convert::identity);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         non_copy_vec().into_iter().filter_map(identity);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         non_copy_vec().into_iter().filter_map(|x| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         non_copy_vec().into_iter().filter_map(|x| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         // we are forced to pass the type in the call.
         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| return x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         #[rustfmt::skip]
             copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| -> Option<i32> {{ x }});
-        //~^ ERROR: use of
+        //~^ filter_map_identity
+
         #[rustfmt::skip]
             copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| -> Option<i32> {{ return x }});
-        //~^ ERROR: use of
+        //~^ filter_map_identity
 
         // note, the compiler requires that we pass the type to `opaque`. This is mostly for reference,
         // it behaves the same as copy_vec.
         opaque::<i32>().into_iter().filter_map(|x| x);
-        //~^ ERROR: use of
+        //~^ filter_map_identity
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/filter_map_identity.stderr b/src/tools/clippy/tests/ui/filter_map_identity.stderr
index 55068db4e9d0..26b6e0bc7b34 100644
--- a/src/tools/clippy/tests/ui/filter_map_identity.stderr
+++ b/src/tools/clippy/tests/ui/filter_map_identity.stderr
@@ -8,127 +8,127 @@ LL |         copy_vec_non_inferred().into_iter().filter_map(|x| x);
    = help: to override `-D warnings` add `#[allow(clippy::filter_map_identity)]`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:30:45
+  --> tests/ui/filter_map_identity.rs:31:45
    |
 LL |         copy_vec_non_inferred().into_iter().filter_map(std::convert::identity);
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:32:45
+  --> tests/ui/filter_map_identity.rs:34:45
    |
 LL |         copy_vec_non_inferred().into_iter().filter_map(identity);
    |                                             ^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:34:45
+  --> tests/ui/filter_map_identity.rs:37:45
    |
 LL |         copy_vec_non_inferred().into_iter().filter_map(|x| return x);
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:36:45
+  --> tests/ui/filter_map_identity.rs:40:45
    |
 LL |         copy_vec_non_inferred().into_iter().filter_map(|x| return x);
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:39:36
+  --> tests/ui/filter_map_identity.rs:43:36
    |
 LL |         non_copy_vec().into_iter().filter_map(|x| x);
    |                                    ^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:41:36
+  --> tests/ui/filter_map_identity.rs:46:36
    |
 LL |         non_copy_vec().into_iter().filter_map(|x| x);
    |                                    ^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:44:36
+  --> tests/ui/filter_map_identity.rs:49:36
    |
 LL |         non_copy_vec().into_iter().filter_map(std::convert::identity);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:46:36
+  --> tests/ui/filter_map_identity.rs:52:36
    |
 LL |         non_copy_vec().into_iter().filter_map(identity);
    |                                    ^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:48:36
+  --> tests/ui/filter_map_identity.rs:55:36
    |
 LL |         non_copy_vec().into_iter().filter_map(|x| return x);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:50:36
+  --> tests/ui/filter_map_identity.rs:58:36
    |
 LL |         non_copy_vec().into_iter().filter_map(|x| return x);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:53:39
+  --> tests/ui/filter_map_identity.rs:61:39
    |
 LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| x);
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:55:39
+  --> tests/ui/filter_map_identity.rs:64:39
    |
 LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| x);
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
-error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:57:39
-   |
-LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| return x);
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
-
-error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:59:39
-   |
-LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| return x);
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
-
-error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:63:39
-   |
-LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| x);
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
-
-error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:65:39
-   |
-LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| x);
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
-
 error: use of `filter_map` with an identity function
   --> tests/ui/filter_map_identity.rs:67:39
    |
-LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| return x);
-   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| return x);
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:69:39
+  --> tests/ui/filter_map_identity.rs:70:39
+   |
+LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<_>| return x);
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: use of `filter_map` with an identity function
+  --> tests/ui/filter_map_identity.rs:74:39
+   |
+LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| x);
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: use of `filter_map` with an identity function
+  --> tests/ui/filter_map_identity.rs:77:39
+   |
+LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| x);
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: use of `filter_map` with an identity function
+  --> tests/ui/filter_map_identity.rs:80:39
    |
 LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| return x);
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:72:43
+  --> tests/ui/filter_map_identity.rs:83:39
+   |
+LL |         copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| return x);
+   |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
+
+error: use of `filter_map` with an identity function
+  --> tests/ui/filter_map_identity.rs:87:43
    |
 LL |             copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| -> Option<i32> {{ x }});
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:75:43
+  --> tests/ui/filter_map_identity.rs:91:43
    |
 LL |             copy_vec::<i32>().into_iter().filter_map(|x: Option<i32>| -> Option<i32> {{ return x }});
    |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `filter_map` with an identity function
-  --> tests/ui/filter_map_identity.rs:80:37
+  --> tests/ui/filter_map_identity.rs:96:37
    |
 LL |         opaque::<i32>().into_iter().filter_map(|x| x);
    |                                     ^^^^^^^^^^^^^^^^^ help: try: `flatten()`
diff --git a/src/tools/clippy/tests/ui/filter_map_next.rs b/src/tools/clippy/tests/ui/filter_map_next.rs
index 9077b8fca23e..2a2237ed16cf 100644
--- a/src/tools/clippy/tests/ui/filter_map_next.rs
+++ b/src/tools/clippy/tests/ui/filter_map_next.rs
@@ -5,8 +5,9 @@ fn main() {
 
     #[rustfmt::skip]
     let _: Option<u32> = vec![1, 2, 3, 4, 5, 6]
-    //~^ ERROR: called `filter_map(..).next()` on an `Iterator`. This is more succinctly e
-    //~| NOTE: `-D clippy::filter-map-next` implied by `-D warnings`
+    //~^ filter_map_next
+
+
         .into_iter()
         .filter_map(|x| {
             if x == 2 {
diff --git a/src/tools/clippy/tests/ui/filter_map_next.stderr b/src/tools/clippy/tests/ui/filter_map_next.stderr
index cd3ffe3aa7f0..974bb946d46a 100644
--- a/src/tools/clippy/tests/ui/filter_map_next.stderr
+++ b/src/tools/clippy/tests/ui/filter_map_next.stderr
@@ -3,9 +3,6 @@ error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly
    |
 LL |       let _: Option<u32> = vec![1, 2, 3, 4, 5, 6]
    |  __________________________^
-LL | |
-LL | |
-LL | |         .into_iter()
 ...  |
 LL | |         })
 LL | |         .next();
diff --git a/src/tools/clippy/tests/ui/filter_map_next_fixable.fixed b/src/tools/clippy/tests/ui/filter_map_next_fixable.fixed
index 193ac3aea433..285863ef340d 100644
--- a/src/tools/clippy/tests/ui/filter_map_next_fixable.fixed
+++ b/src/tools/clippy/tests/ui/filter_map_next_fixable.fixed
@@ -5,6 +5,7 @@ fn main() {
     let a = ["1", "lol", "3", "NaN", "5"];
 
     let element: Option<i32> = a.iter().find_map(|s| s.parse().ok());
+    //~^ filter_map_next
     assert_eq!(element, Some(1));
 }
 
@@ -18,4 +19,5 @@ fn msrv_1_29() {
 fn msrv_1_30() {
     let a = ["1", "lol", "3", "NaN", "5"];
     let _: Option<i32> = a.iter().find_map(|s| s.parse().ok());
+    //~^ filter_map_next
 }
diff --git a/src/tools/clippy/tests/ui/filter_map_next_fixable.rs b/src/tools/clippy/tests/ui/filter_map_next_fixable.rs
index dab8d289817e..af911689b7c7 100644
--- a/src/tools/clippy/tests/ui/filter_map_next_fixable.rs
+++ b/src/tools/clippy/tests/ui/filter_map_next_fixable.rs
@@ -5,6 +5,7 @@ fn main() {
     let a = ["1", "lol", "3", "NaN", "5"];
 
     let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
+    //~^ filter_map_next
     assert_eq!(element, Some(1));
 }
 
@@ -18,4 +19,5 @@ fn msrv_1_29() {
 fn msrv_1_30() {
     let a = ["1", "lol", "3", "NaN", "5"];
     let _: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
+    //~^ filter_map_next
 }
diff --git a/src/tools/clippy/tests/ui/filter_map_next_fixable.stderr b/src/tools/clippy/tests/ui/filter_map_next_fixable.stderr
index 2c6148f3f4b6..707dec8687b1 100644
--- a/src/tools/clippy/tests/ui/filter_map_next_fixable.stderr
+++ b/src/tools/clippy/tests/ui/filter_map_next_fixable.stderr
@@ -8,7 +8,7 @@ LL |     let element: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next
    = help: to override `-D warnings` add `#[allow(clippy::filter_map_next)]`
 
 error: called `filter_map(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find_map(..)` instead
-  --> tests/ui/filter_map_next_fixable.rs:20:26
+  --> tests/ui/filter_map_next_fixable.rs:21:26
    |
 LL |     let _: Option<i32> = a.iter().filter_map(|s| s.parse().ok()).next();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.iter().find_map(|s| s.parse().ok())`
diff --git a/src/tools/clippy/tests/ui/find_map.rs b/src/tools/clippy/tests/ui/find_map.rs
index bbd395d50ef2..aba1f2cbe581 100644
--- a/src/tools/clippy/tests/ui/find_map.rs
+++ b/src/tools/clippy/tests/ui/find_map.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(clippy::useless_vec)]
 
diff --git a/src/tools/clippy/tests/ui/flat_map_identity.fixed b/src/tools/clippy/tests/ui/flat_map_identity.fixed
index c142cf719808..f62062326126 100644
--- a/src/tools/clippy/tests/ui/flat_map_identity.fixed
+++ b/src/tools/clippy/tests/ui/flat_map_identity.fixed
@@ -6,10 +6,13 @@ use std::convert;
 fn main() {
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flatten();
+    //~^ flat_map_identity
 
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flatten();
+    //~^ flat_map_identity
 
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flatten();
+    //~^ flat_map_identity
 }
diff --git a/src/tools/clippy/tests/ui/flat_map_identity.rs b/src/tools/clippy/tests/ui/flat_map_identity.rs
index 8505ba9005d3..c59e749474ee 100644
--- a/src/tools/clippy/tests/ui/flat_map_identity.rs
+++ b/src/tools/clippy/tests/ui/flat_map_identity.rs
@@ -6,10 +6,13 @@ use std::convert;
 fn main() {
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flat_map(|x| x);
+    //~^ flat_map_identity
 
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flat_map(convert::identity);
+    //~^ flat_map_identity
 
     let iterator = [[0, 1], [2, 3], [4, 5]].iter();
     let _ = iterator.flat_map(|x| return x);
+    //~^ flat_map_identity
 }
diff --git a/src/tools/clippy/tests/ui/flat_map_identity.stderr b/src/tools/clippy/tests/ui/flat_map_identity.stderr
index 496fd972a498..75137f5d9e57 100644
--- a/src/tools/clippy/tests/ui/flat_map_identity.stderr
+++ b/src/tools/clippy/tests/ui/flat_map_identity.stderr
@@ -8,13 +8,13 @@ LL |     let _ = iterator.flat_map(|x| x);
    = help: to override `-D warnings` add `#[allow(clippy::flat_map_identity)]`
 
 error: use of `flat_map` with an identity function
-  --> tests/ui/flat_map_identity.rs:11:22
+  --> tests/ui/flat_map_identity.rs:12:22
    |
 LL |     let _ = iterator.flat_map(convert::identity);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
 
 error: use of `flat_map` with an identity function
-  --> tests/ui/flat_map_identity.rs:14:22
+  --> tests/ui/flat_map_identity.rs:16:22
    |
 LL |     let _ = iterator.flat_map(|x| return x);
    |                      ^^^^^^^^^^^^^^^^^^^^^^ help: try: `flatten()`
diff --git a/src/tools/clippy/tests/ui/flat_map_option.fixed b/src/tools/clippy/tests/ui/flat_map_option.fixed
index e08d9a14533b..e65e77ab79dc 100644
--- a/src/tools/clippy/tests/ui/flat_map_option.fixed
+++ b/src/tools/clippy/tests/ui/flat_map_option.fixed
@@ -5,7 +5,9 @@ fn main() {
     // yay
     let c = |x| Some(x);
     let _ = [1].iter().filter_map(c);
+    //~^ flat_map_option
     let _ = [1].iter().filter_map(Some);
+    //~^ flat_map_option
 
     // nay
     let _ = [1].iter().flat_map(|_| &Some(1));
diff --git a/src/tools/clippy/tests/ui/flat_map_option.rs b/src/tools/clippy/tests/ui/flat_map_option.rs
index 4d0f32ac0fda..6784100a4fc9 100644
--- a/src/tools/clippy/tests/ui/flat_map_option.rs
+++ b/src/tools/clippy/tests/ui/flat_map_option.rs
@@ -5,7 +5,9 @@ fn main() {
     // yay
     let c = |x| Some(x);
     let _ = [1].iter().flat_map(c);
+    //~^ flat_map_option
     let _ = [1].iter().flat_map(Some);
+    //~^ flat_map_option
 
     // nay
     let _ = [1].iter().flat_map(|_| &Some(1));
diff --git a/src/tools/clippy/tests/ui/flat_map_option.stderr b/src/tools/clippy/tests/ui/flat_map_option.stderr
index 6e151965fad5..7f5f2c14ec8e 100644
--- a/src/tools/clippy/tests/ui/flat_map_option.stderr
+++ b/src/tools/clippy/tests/ui/flat_map_option.stderr
@@ -8,7 +8,7 @@ LL |     let _ = [1].iter().flat_map(c);
    = help: to override `-D warnings` add `#[allow(clippy::flat_map_option)]`
 
 error: used `flat_map` where `filter_map` could be used instead
-  --> tests/ui/flat_map_option.rs:8:24
+  --> tests/ui/flat_map_option.rs:9:24
    |
 LL |     let _ = [1].iter().flat_map(Some);
    |                        ^^^^^^^^ help: try: `filter_map`
diff --git a/src/tools/clippy/tests/ui/float_arithmetic.rs b/src/tools/clippy/tests/ui/float_arithmetic.rs
index 1647273c436d..3c447bc94c66 100644
--- a/src/tools/clippy/tests/ui/float_arithmetic.rs
+++ b/src/tools/clippy/tests/ui/float_arithmetic.rs
@@ -13,58 +13,70 @@ fn main() {
     let mut f = 1.0f32;
 
     f * 2.0;
-    //~^ ERROR: floating-point arithmetic detected
-    //~| NOTE: `-D clippy::float-arithmetic` implied by `-D warnings`
+    //~^ float_arithmetic
+
+
 
     1.0 + f;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     f * 2.0;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     f / 2.0;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     f - 2.0 * 4.2;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     -f;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
 
     f += 1.0;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     f -= 1.0;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     f *= 2.0;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     f /= 2.0;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
 }
 
 // also warn about floating point arith with references involved
 
 pub fn float_arith_ref() {
     3.1_f32 + &1.2_f32;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     &3.4_f32 + 1.5_f32;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
+
     &3.5_f32 + &1.3_f32;
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
 }
 
 pub fn float_foo(f: &f32) -> f32 {
     let a = 5.1;
     a + f
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
 }
 
 pub fn float_bar(f1: &f32, f2: &f32) -> f32 {
     f1 + f2
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
 }
 
 pub fn float_baz(f1: f32, f2: &f32) -> f32 {
     f1 + f2
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
 }
 
 pub fn float_qux(f1: f32, f2: f32) -> f32 {
     (&f1 + &f2)
-    //~^ ERROR: floating-point arithmetic detected
+    //~^ float_arithmetic
 }
diff --git a/src/tools/clippy/tests/ui/float_arithmetic.stderr b/src/tools/clippy/tests/ui/float_arithmetic.stderr
index 66455f061455..8704f7bbd7c4 100644
--- a/src/tools/clippy/tests/ui/float_arithmetic.stderr
+++ b/src/tools/clippy/tests/ui/float_arithmetic.stderr
@@ -8,97 +8,97 @@ LL |     f * 2.0;
    = help: to override `-D warnings` add `#[allow(clippy::float_arithmetic)]`
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:19:5
+  --> tests/ui/float_arithmetic.rs:20:5
    |
 LL |     1.0 + f;
    |     ^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:21:5
+  --> tests/ui/float_arithmetic.rs:23:5
    |
 LL |     f * 2.0;
    |     ^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:23:5
+  --> tests/ui/float_arithmetic.rs:26:5
    |
 LL |     f / 2.0;
    |     ^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:25:5
+  --> tests/ui/float_arithmetic.rs:29:5
    |
 LL |     f - 2.0 * 4.2;
    |     ^^^^^^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:27:5
+  --> tests/ui/float_arithmetic.rs:32:5
    |
 LL |     -f;
    |     ^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:30:5
+  --> tests/ui/float_arithmetic.rs:36:5
    |
 LL |     f += 1.0;
    |     ^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:32:5
+  --> tests/ui/float_arithmetic.rs:39:5
    |
 LL |     f -= 1.0;
    |     ^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:34:5
+  --> tests/ui/float_arithmetic.rs:42:5
    |
 LL |     f *= 2.0;
    |     ^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:36:5
+  --> tests/ui/float_arithmetic.rs:45:5
    |
 LL |     f /= 2.0;
    |     ^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:43:5
+  --> tests/ui/float_arithmetic.rs:53:5
    |
 LL |     3.1_f32 + &1.2_f32;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:45:5
+  --> tests/ui/float_arithmetic.rs:56:5
    |
 LL |     &3.4_f32 + 1.5_f32;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:47:5
+  --> tests/ui/float_arithmetic.rs:59:5
    |
 LL |     &3.5_f32 + &1.3_f32;
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:53:5
+  --> tests/ui/float_arithmetic.rs:65:5
    |
 LL |     a + f
    |     ^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:58:5
+  --> tests/ui/float_arithmetic.rs:70:5
    |
 LL |     f1 + f2
    |     ^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:63:5
+  --> tests/ui/float_arithmetic.rs:75:5
    |
 LL |     f1 + f2
    |     ^^^^^^^
 
 error: floating-point arithmetic detected
-  --> tests/ui/float_arithmetic.rs:68:5
+  --> tests/ui/float_arithmetic.rs:80:5
    |
 LL |     (&f1 + &f2)
    |     ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/float_cmp.rs b/src/tools/clippy/tests/ui/float_cmp.rs
index a1dfd1954fce..ce0ffd8a2192 100644
--- a/src/tools/clippy/tests/ui/float_cmp.rs
+++ b/src/tools/clippy/tests/ui/float_cmp.rs
@@ -70,17 +70,19 @@ fn main() {
     ONE != 0.0; // no error, comparison with zero is ok
     twice(ONE) != ONE;
     ONE as f64 != 2.0;
-    //~^ ERROR: strict comparison of `f32` or `f64`
+    //~^ float_cmp
+
     ONE as f64 != 0.0; // no error, comparison with zero is ok
 
     let x: f64 = 1.0;
 
     x == 1.0;
-    //~^ ERROR: strict comparison of `f32` or `f64`
+    //~^ float_cmp
+
     x != 0f64; // no error, comparison with zero is ok
 
     twice(x) != twice(ONE as f64);
-    //~^ ERROR: strict comparison of `f32` or `f64`
+    //~^ float_cmp
 
     x < 0.0; // no errors, lower or greater comparisons need no fuzzyness
     x > 0.0;
@@ -101,15 +103,16 @@ fn main() {
 
     ZERO_ARRAY[i] == NON_ZERO_ARRAY[j]; // ok, because lhs is zero regardless of i
     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
-    //~^ ERROR: strict comparison of `f32` or `f64`
+    //~^ float_cmp
 
     let a1: [f32; 1] = [0.0];
     let a2: [f32; 1] = [1.1];
 
     a1 == a2;
-    //~^ ERROR: strict comparison of `f32` or `f64` arrays
+    //~^ float_cmp
+
     a1[0] == a2[0];
-    //~^ ERROR: strict comparison of `f32` or `f64`
+    //~^ float_cmp
 
     // no errors - comparing signums is ok
     let x32 = 3.21f32;
diff --git a/src/tools/clippy/tests/ui/float_cmp.stderr b/src/tools/clippy/tests/ui/float_cmp.stderr
index d10da8a99a9d..e573c0baeac2 100644
--- a/src/tools/clippy/tests/ui/float_cmp.stderr
+++ b/src/tools/clippy/tests/ui/float_cmp.stderr
@@ -8,31 +8,31 @@ LL |     ONE as f64 != 2.0;
    = help: to override `-D warnings` add `#[allow(clippy::float_cmp)]`
 
 error: strict comparison of `f32` or `f64`
-  --> tests/ui/float_cmp.rs:78:5
+  --> tests/ui/float_cmp.rs:79:5
    |
 LL |     x == 1.0;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(x - 1.0).abs() < error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> tests/ui/float_cmp.rs:82:5
+  --> tests/ui/float_cmp.rs:84:5
    |
 LL |     twice(x) != twice(ONE as f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(twice(x) - twice(ONE as f64)).abs() > error_margin`
 
 error: strict comparison of `f32` or `f64`
-  --> tests/ui/float_cmp.rs:103:5
+  --> tests/ui/float_cmp.rs:105:5
    |
 LL |     NON_ZERO_ARRAY[i] == NON_ZERO_ARRAY[j];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(NON_ZERO_ARRAY[i] - NON_ZERO_ARRAY[j]).abs() < error_margin`
 
 error: strict comparison of `f32` or `f64` arrays
-  --> tests/ui/float_cmp.rs:109:5
+  --> tests/ui/float_cmp.rs:111:5
    |
 LL |     a1 == a2;
    |     ^^^^^^^^
 
 error: strict comparison of `f32` or `f64`
-  --> tests/ui/float_cmp.rs:111:5
+  --> tests/ui/float_cmp.rs:114:5
    |
 LL |     a1[0] == a2[0];
    |     ^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(a1[0] - a2[0]).abs() < error_margin`
diff --git a/src/tools/clippy/tests/ui/float_cmp_const.rs b/src/tools/clippy/tests/ui/float_cmp_const.rs
index ba760a18f28a..3af53f2e84a2 100644
--- a/src/tools/clippy/tests/ui/float_cmp_const.rs
+++ b/src/tools/clippy/tests/ui/float_cmp_const.rs
@@ -13,22 +13,27 @@ fn eq_one(x: f32) -> bool {
 fn main() {
     // has errors
     1f32 == ONE;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant
+    //~^ float_cmp_const
+
     TWO == ONE;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant
+    //~^ float_cmp_const
+
     TWO != ONE;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant
+    //~^ float_cmp_const
+
     ONE + ONE == TWO;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant
+    //~^ float_cmp_const
+
     let x = 1;
     x as f32 == ONE;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant
+    //~^ float_cmp_const
 
     let v = 0.9;
     v == ONE;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant
+    //~^ float_cmp_const
+
     v != ONE;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant
+    //~^ float_cmp_const
 
     // no errors, lower than or greater than comparisons
     v < ONE;
@@ -61,5 +66,5 @@ fn main() {
 
     // has errors
     NON_ZERO_ARRAY == NON_ZERO_ARRAY2;
-    //~^ ERROR: strict comparison of `f32` or `f64` constant arrays
+    //~^ float_cmp_const
 }
diff --git a/src/tools/clippy/tests/ui/float_cmp_const.stderr b/src/tools/clippy/tests/ui/float_cmp_const.stderr
index e0cd6faf4b3a..482a55a54be6 100644
--- a/src/tools/clippy/tests/ui/float_cmp_const.stderr
+++ b/src/tools/clippy/tests/ui/float_cmp_const.stderr
@@ -8,43 +8,43 @@ LL |     1f32 == ONE;
    = help: to override `-D warnings` add `#[allow(clippy::float_cmp_const)]`
 
 error: strict comparison of `f32` or `f64` constant
-  --> tests/ui/float_cmp_const.rs:17:5
+  --> tests/ui/float_cmp_const.rs:18:5
    |
 LL |     TWO == ONE;
    |     ^^^^^^^^^^ help: consider comparing them within some margin of error: `(TWO - ONE).abs() < error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> tests/ui/float_cmp_const.rs:19:5
+  --> tests/ui/float_cmp_const.rs:21:5
    |
 LL |     TWO != ONE;
    |     ^^^^^^^^^^ help: consider comparing them within some margin of error: `(TWO - ONE).abs() > error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> tests/ui/float_cmp_const.rs:21:5
+  --> tests/ui/float_cmp_const.rs:24:5
    |
 LL |     ONE + ONE == TWO;
    |     ^^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(ONE + ONE - TWO).abs() < error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> tests/ui/float_cmp_const.rs:24:5
+  --> tests/ui/float_cmp_const.rs:28:5
    |
 LL |     x as f32 == ONE;
    |     ^^^^^^^^^^^^^^^ help: consider comparing them within some margin of error: `(x as f32 - ONE).abs() < error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> tests/ui/float_cmp_const.rs:28:5
+  --> tests/ui/float_cmp_const.rs:32:5
    |
 LL |     v == ONE;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(v - ONE).abs() < error_margin`
 
 error: strict comparison of `f32` or `f64` constant
-  --> tests/ui/float_cmp_const.rs:30:5
+  --> tests/ui/float_cmp_const.rs:35:5
    |
 LL |     v != ONE;
    |     ^^^^^^^^ help: consider comparing them within some margin of error: `(v - ONE).abs() > error_margin`
 
 error: strict comparison of `f32` or `f64` constant arrays
-  --> tests/ui/float_cmp_const.rs:63:5
+  --> tests/ui/float_cmp_const.rs:68:5
    |
 LL |     NON_ZERO_ARRAY == NON_ZERO_ARRAY2;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/float_equality_without_abs.rs b/src/tools/clippy/tests/ui/float_equality_without_abs.rs
index 500b3035390f..a1548db6710d 100644
--- a/src/tools/clippy/tests/ui/float_equality_without_abs.rs
+++ b/src/tools/clippy/tests/ui/float_equality_without_abs.rs
@@ -5,8 +5,7 @@
 
 pub fn is_roughly_equal(a: f32, b: f32) -> bool {
     (a - b) < f32::EPSILON
-    //~^ ERROR: float equality check without `.abs()`
-    //~| NOTE: `-D clippy::float-equality-without-abs` implied by `-D warnings`
+    //~^ float_equality_without_abs
 }
 
 pub fn main() {
@@ -16,26 +15,34 @@ pub fn main() {
     let b = 0.0500001;
 
     let _ = (a - b) < f32::EPSILON;
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = a - b < f32::EPSILON;
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = a - b.abs() < f32::EPSILON;
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = (a as f64 - b as f64) < f64::EPSILON;
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = 1.0 - 2.0 < f32::EPSILON;
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
 
     let _ = f32::EPSILON > (a - b);
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = f32::EPSILON > a - b;
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = f32::EPSILON > a - b.abs();
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = f64::EPSILON > (a as f64 - b as f64);
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
+
     let _ = f32::EPSILON > 1.0 - 2.0;
-    //~^ ERROR: float equality check without `.abs()`
+    //~^ float_equality_without_abs
 
     // those are correct
     let _ = (a - b).abs() < f32::EPSILON;
diff --git a/src/tools/clippy/tests/ui/float_equality_without_abs.stderr b/src/tools/clippy/tests/ui/float_equality_without_abs.stderr
index cdaaf0cdbcf7..d4c89ce72ba9 100644
--- a/src/tools/clippy/tests/ui/float_equality_without_abs.stderr
+++ b/src/tools/clippy/tests/ui/float_equality_without_abs.stderr
@@ -10,7 +10,7 @@ LL |     (a - b) < f32::EPSILON
    = help: to override `-D warnings` add `#[allow(clippy::float_equality_without_abs)]`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:18:13
+  --> tests/ui/float_equality_without_abs.rs:17:13
    |
 LL |     let _ = (a - b) < f32::EPSILON;
    |             -------^^^^^^^^^^^^^^^
@@ -26,7 +26,7 @@ LL |     let _ = a - b < f32::EPSILON;
    |             help: add `.abs()`: `(a - b).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:22:13
+  --> tests/ui/float_equality_without_abs.rs:23:13
    |
 LL |     let _ = a - b.abs() < f32::EPSILON;
    |             -----------^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |     let _ = a - b.abs() < f32::EPSILON;
    |             help: add `.abs()`: `(a - b.abs()).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:24:13
+  --> tests/ui/float_equality_without_abs.rs:26:13
    |
 LL |     let _ = (a as f64 - b as f64) < f64::EPSILON;
    |             ---------------------^^^^^^^^^^^^^^^
@@ -42,7 +42,7 @@ LL |     let _ = (a as f64 - b as f64) < f64::EPSILON;
    |             help: add `.abs()`: `(a as f64 - b as f64).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:26:13
+  --> tests/ui/float_equality_without_abs.rs:29:13
    |
 LL |     let _ = 1.0 - 2.0 < f32::EPSILON;
    |             ---------^^^^^^^^^^^^^^^
@@ -50,7 +50,7 @@ LL |     let _ = 1.0 - 2.0 < f32::EPSILON;
    |             help: add `.abs()`: `(1.0 - 2.0).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:29:13
+  --> tests/ui/float_equality_without_abs.rs:32:13
    |
 LL |     let _ = f32::EPSILON > (a - b);
    |             ^^^^^^^^^^^^^^^-------
@@ -58,7 +58,7 @@ LL |     let _ = f32::EPSILON > (a - b);
    |                            help: add `.abs()`: `(a - b).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:31:13
+  --> tests/ui/float_equality_without_abs.rs:35:13
    |
 LL |     let _ = f32::EPSILON > a - b;
    |             ^^^^^^^^^^^^^^^-----
@@ -66,7 +66,7 @@ LL |     let _ = f32::EPSILON > a - b;
    |                            help: add `.abs()`: `(a - b).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:33:13
+  --> tests/ui/float_equality_without_abs.rs:38:13
    |
 LL |     let _ = f32::EPSILON > a - b.abs();
    |             ^^^^^^^^^^^^^^^-----------
@@ -74,7 +74,7 @@ LL |     let _ = f32::EPSILON > a - b.abs();
    |                            help: add `.abs()`: `(a - b.abs()).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:35:13
+  --> tests/ui/float_equality_without_abs.rs:41:13
    |
 LL |     let _ = f64::EPSILON > (a as f64 - b as f64);
    |             ^^^^^^^^^^^^^^^---------------------
@@ -82,7 +82,7 @@ LL |     let _ = f64::EPSILON > (a as f64 - b as f64);
    |                            help: add `.abs()`: `(a as f64 - b as f64).abs()`
 
 error: float equality check without `.abs()`
-  --> tests/ui/float_equality_without_abs.rs:37:13
+  --> tests/ui/float_equality_without_abs.rs:44:13
    |
 LL |     let _ = f32::EPSILON > 1.0 - 2.0;
    |             ^^^^^^^^^^^^^^^---------
diff --git a/src/tools/clippy/tests/ui/floating_point_abs.fixed b/src/tools/clippy/tests/ui/floating_point_abs.fixed
index 33183c769724..e8d64a3d7c29 100644
--- a/src/tools/clippy/tests/ui/floating_point_abs.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_abs.fixed
@@ -12,35 +12,43 @@ struct A {
 
 fn fake_abs1(num: f64) -> f64 {
     num.abs()
+    //~^ suboptimal_flops
 }
 
 fn fake_abs2(num: f64) -> f64 {
     num.abs()
+    //~^ suboptimal_flops
 }
 
 fn fake_abs3(a: A) -> f64 {
     a.a.abs()
+    //~^ suboptimal_flops
 }
 
 fn fake_abs4(num: f64) -> f64 {
     num.abs()
+    //~^ suboptimal_flops
 }
 
 fn fake_abs5(a: A) -> f64 {
     a.a.abs()
+    //~^ suboptimal_flops
 }
 
 fn fake_nabs1(num: f64) -> f64 {
     -num.abs()
+    //~^ suboptimal_flops
 }
 
 fn fake_nabs2(num: f64) -> f64 {
     -num.abs()
+    //~^ suboptimal_flops
 }
 
 fn fake_nabs3(a: A) -> A {
     A {
         a: -a.a.abs(),
+        //~^ suboptimal_flops
         b: a.b,
     }
 }
diff --git a/src/tools/clippy/tests/ui/floating_point_abs.rs b/src/tools/clippy/tests/ui/floating_point_abs.rs
index a08d5bbcef5c..a27279b0662f 100644
--- a/src/tools/clippy/tests/ui/floating_point_abs.rs
+++ b/src/tools/clippy/tests/ui/floating_point_abs.rs
@@ -12,35 +12,43 @@ struct A {
 
 fn fake_abs1(num: f64) -> f64 {
     if num >= 0.0 { num } else { -num }
+    //~^ suboptimal_flops
 }
 
 fn fake_abs2(num: f64) -> f64 {
     if 0.0 < num { num } else { -num }
+    //~^ suboptimal_flops
 }
 
 fn fake_abs3(a: A) -> f64 {
     if a.a > 0.0 { a.a } else { -a.a }
+    //~^ suboptimal_flops
 }
 
 fn fake_abs4(num: f64) -> f64 {
     if 0.0 >= num { -num } else { num }
+    //~^ suboptimal_flops
 }
 
 fn fake_abs5(a: A) -> f64 {
     if a.a < 0.0 { -a.a } else { a.a }
+    //~^ suboptimal_flops
 }
 
 fn fake_nabs1(num: f64) -> f64 {
     if num < 0.0 { num } else { -num }
+    //~^ suboptimal_flops
 }
 
 fn fake_nabs2(num: f64) -> f64 {
     if 0.0 >= num { num } else { -num }
+    //~^ suboptimal_flops
 }
 
 fn fake_nabs3(a: A) -> A {
     A {
         a: if a.a >= 0.0 { -a.a } else { a.a },
+        //~^ suboptimal_flops
         b: a.b,
     }
 }
diff --git a/src/tools/clippy/tests/ui/floating_point_abs.stderr b/src/tools/clippy/tests/ui/floating_point_abs.stderr
index 0c1f68f3b7fd..f031ac25114d 100644
--- a/src/tools/clippy/tests/ui/floating_point_abs.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_abs.stderr
@@ -8,43 +8,43 @@ LL |     if num >= 0.0 { num } else { -num }
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:18:5
+  --> tests/ui/floating_point_abs.rs:19:5
    |
 LL |     if 0.0 < num { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:22:5
+  --> tests/ui/floating_point_abs.rs:24:5
    |
 LL |     if a.a > 0.0 { a.a } else { -a.a }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:26:5
+  --> tests/ui/floating_point_abs.rs:29:5
    |
 LL |     if 0.0 >= num { -num } else { num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.abs()`
 
 error: manual implementation of `abs` method
-  --> tests/ui/floating_point_abs.rs:30:5
+  --> tests/ui/floating_point_abs.rs:34:5
    |
 LL |     if a.a < 0.0 { -a.a } else { a.a }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `a.a.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> tests/ui/floating_point_abs.rs:34:5
+  --> tests/ui/floating_point_abs.rs:39:5
    |
 LL |     if num < 0.0 { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> tests/ui/floating_point_abs.rs:38:5
+  --> tests/ui/floating_point_abs.rs:44:5
    |
 LL |     if 0.0 >= num { num } else { -num }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-num.abs()`
 
 error: manual implementation of negation of `abs` method
-  --> tests/ui/floating_point_abs.rs:43:12
+  --> tests/ui/floating_point_abs.rs:50:12
    |
 LL |         a: if a.a >= 0.0 { -a.a } else { a.a },
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-a.a.abs()`
diff --git a/src/tools/clippy/tests/ui/floating_point_arithmetic_nostd.rs b/src/tools/clippy/tests/ui/floating_point_arithmetic_nostd.rs
index 81e4e0380dad..c4456bf870cd 100644
--- a/src/tools/clippy/tests/ui/floating_point_arithmetic_nostd.rs
+++ b/src/tools/clippy/tests/ui/floating_point_arithmetic_nostd.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![crate_type = "lib"]
 #![warn(clippy::imprecise_flops)]
 #![warn(clippy::suboptimal_flops)]
diff --git a/src/tools/clippy/tests/ui/floating_point_exp.fixed b/src/tools/clippy/tests/ui/floating_point_exp.fixed
index fbd91cbc9d70..72a6f4fcfbd3 100644
--- a/src/tools/clippy/tests/ui/floating_point_exp.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_exp.fixed
@@ -6,15 +6,20 @@
 fn main() {
     let x = 2f32;
     let _ = x.exp_m1();
+    //~^ imprecise_flops
     let _ = x.exp_m1() + 2.0;
+    //~^ imprecise_flops
     let _ = (x as f32).exp_m1() + 2.0;
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = x.exp() - 2.0;
     let _ = x.exp() - 1.0 * 2.0;
 
     let x = 2f64;
     let _ = x.exp_m1();
+    //~^ imprecise_flops
     let _ = x.exp_m1() + 2.0;
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = x.exp() - 2.0;
     let _ = x.exp() - 1.0 * 2.0;
diff --git a/src/tools/clippy/tests/ui/floating_point_exp.rs b/src/tools/clippy/tests/ui/floating_point_exp.rs
index 340bacaf56b5..ce584c038a49 100644
--- a/src/tools/clippy/tests/ui/floating_point_exp.rs
+++ b/src/tools/clippy/tests/ui/floating_point_exp.rs
@@ -6,15 +6,20 @@
 fn main() {
     let x = 2f32;
     let _ = x.exp() - 1.0;
+    //~^ imprecise_flops
     let _ = x.exp() - 1.0 + 2.0;
+    //~^ imprecise_flops
     let _ = (x as f32).exp() - 1.0 + 2.0;
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = x.exp() - 2.0;
     let _ = x.exp() - 1.0 * 2.0;
 
     let x = 2f64;
     let _ = x.exp() - 1.0;
+    //~^ imprecise_flops
     let _ = x.exp() - 1.0 + 2.0;
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = x.exp() - 2.0;
     let _ = x.exp() - 1.0 * 2.0;
diff --git a/src/tools/clippy/tests/ui/floating_point_exp.stderr b/src/tools/clippy/tests/ui/floating_point_exp.stderr
index 6ce67254abc9..7736a8e7ac36 100644
--- a/src/tools/clippy/tests/ui/floating_point_exp.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_exp.stderr
@@ -8,25 +8,25 @@ LL |     let _ = x.exp() - 1.0;
    = help: to override `-D warnings` add `#[allow(clippy::imprecise_flops)]`
 
 error: (e.pow(x) - 1) can be computed more accurately
-  --> tests/ui/floating_point_exp.rs:9:13
+  --> tests/ui/floating_point_exp.rs:10:13
    |
 LL |     let _ = x.exp() - 1.0 + 2.0;
    |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
 
 error: (e.pow(x) - 1) can be computed more accurately
-  --> tests/ui/floating_point_exp.rs:10:13
+  --> tests/ui/floating_point_exp.rs:12:13
    |
 LL |     let _ = (x as f32).exp() - 1.0 + 2.0;
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).exp_m1()`
 
 error: (e.pow(x) - 1) can be computed more accurately
-  --> tests/ui/floating_point_exp.rs:16:13
+  --> tests/ui/floating_point_exp.rs:19:13
    |
 LL |     let _ = x.exp() - 1.0;
    |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
 
 error: (e.pow(x) - 1) can be computed more accurately
-  --> tests/ui/floating_point_exp.rs:17:13
+  --> tests/ui/floating_point_exp.rs:21:13
    |
 LL |     let _ = x.exp() - 1.0 + 2.0;
    |             ^^^^^^^^^^^^^ help: consider using: `x.exp_m1()`
diff --git a/src/tools/clippy/tests/ui/floating_point_hypot.fixed b/src/tools/clippy/tests/ui/floating_point_hypot.fixed
index 75a224440b0d..1fa684e78e0b 100644
--- a/src/tools/clippy/tests/ui/floating_point_hypot.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_hypot.fixed
@@ -4,8 +4,11 @@ fn main() {
     let x = 3f32;
     let y = 4f32;
     let _ = x.hypot(y);
+    //~^ imprecise_flops
     let _ = (x + 1f32).hypot(y);
+    //~^ imprecise_flops
     let _ = x.hypot(y);
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     // TODO: linting this adds some complexity, but could be done
     let _ = x.mul_add(x, y * y).sqrt();
diff --git a/src/tools/clippy/tests/ui/floating_point_hypot.rs b/src/tools/clippy/tests/ui/floating_point_hypot.rs
index ed4dbf6382e7..9b4e74d28d0f 100644
--- a/src/tools/clippy/tests/ui/floating_point_hypot.rs
+++ b/src/tools/clippy/tests/ui/floating_point_hypot.rs
@@ -4,8 +4,11 @@ fn main() {
     let x = 3f32;
     let y = 4f32;
     let _ = (x * x + y * y).sqrt();
+    //~^ imprecise_flops
     let _ = ((x + 1f32) * (x + 1f32) + y * y).sqrt();
+    //~^ imprecise_flops
     let _ = (x.powi(2) + y.powi(2)).sqrt();
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     // TODO: linting this adds some complexity, but could be done
     let _ = x.mul_add(x, y * y).sqrt();
diff --git a/src/tools/clippy/tests/ui/floating_point_hypot.stderr b/src/tools/clippy/tests/ui/floating_point_hypot.stderr
index 8942e86910da..3526df2cf265 100644
--- a/src/tools/clippy/tests/ui/floating_point_hypot.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_hypot.stderr
@@ -8,13 +8,13 @@ LL |     let _ = (x * x + y * y).sqrt();
    = help: to override `-D warnings` add `#[allow(clippy::imprecise_flops)]`
 
 error: hypotenuse can be computed more accurately
-  --> tests/ui/floating_point_hypot.rs:7:13
+  --> tests/ui/floating_point_hypot.rs:8:13
    |
 LL |     let _ = ((x + 1f32) * (x + 1f32) + y * y).sqrt();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 1f32).hypot(y)`
 
 error: hypotenuse can be computed more accurately
-  --> tests/ui/floating_point_hypot.rs:8:13
+  --> tests/ui/floating_point_hypot.rs:10:13
    |
 LL |     let _ = (x.powi(2) + y.powi(2)).sqrt();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.hypot(y)`
diff --git a/src/tools/clippy/tests/ui/floating_point_log.fixed b/src/tools/clippy/tests/ui/floating_point_log.fixed
index 75e9c40a5218..275c9b4a3ab9 100644
--- a/src/tools/clippy/tests/ui/floating_point_log.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_log.fixed
@@ -9,31 +9,51 @@ const E: f32 = std::f32::consts::E;
 fn check_log_base() {
     let x = 1f32;
     let _ = x.log2();
+    //~^ suboptimal_flops
     let _ = x.log10();
+    //~^ suboptimal_flops
     let _ = x.ln();
+    //~^ suboptimal_flops
     let _ = x.log2();
+    //~^ suboptimal_flops
     let _ = x.ln();
+    //~^ suboptimal_flops
     let _ = (x as f32).log2();
+    //~^ suboptimal_flops
 
     let x = 1f64;
     let _ = x.log2();
+    //~^ suboptimal_flops
     let _ = x.log10();
+    //~^ suboptimal_flops
     let _ = x.ln();
+    //~^ suboptimal_flops
 }
 
 fn check_ln1p() {
     let x = 1f32;
     let _ = 2.0f32.ln_1p();
+    //~^ imprecise_flops
     let _ = 2.0f32.ln_1p();
+    //~^ imprecise_flops
     let _ = x.ln_1p();
+    //~^ imprecise_flops
     let _ = (x / 2.0).ln_1p();
+    //~^ imprecise_flops
     let _ = x.powi(3).ln_1p();
+    //~^ imprecise_flops
     let _ = (x.powi(3) / 2.0).ln_1p();
+    //~^ imprecise_flops
     let _ = (std::f32::consts::E - 1.0).ln_1p();
+    //~^ imprecise_flops
     let _ = x.ln_1p();
+    //~^ imprecise_flops
     let _ = x.powi(3).ln_1p();
+    //~^ imprecise_flops
     let _ = (x + 2.0).ln_1p();
+    //~^ imprecise_flops
     let _ = (x / 2.0).ln_1p();
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
@@ -42,14 +62,23 @@ fn check_ln1p() {
 
     let x = 1f64;
     let _ = 2.0f64.ln_1p();
+    //~^ imprecise_flops
     let _ = 2.0f64.ln_1p();
+    //~^ imprecise_flops
     let _ = x.ln_1p();
+    //~^ imprecise_flops
     let _ = (x / 2.0).ln_1p();
+    //~^ imprecise_flops
     let _ = x.powi(3).ln_1p();
+    //~^ imprecise_flops
     let _ = x.ln_1p();
+    //~^ imprecise_flops
     let _ = x.powi(3).ln_1p();
+    //~^ imprecise_flops
     let _ = (x + 2.0).ln_1p();
+    //~^ imprecise_flops
     let _ = (x / 2.0).ln_1p();
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
diff --git a/src/tools/clippy/tests/ui/floating_point_log.rs b/src/tools/clippy/tests/ui/floating_point_log.rs
index d68369a38618..a372ccbb9fb0 100644
--- a/src/tools/clippy/tests/ui/floating_point_log.rs
+++ b/src/tools/clippy/tests/ui/floating_point_log.rs
@@ -9,31 +9,51 @@ const E: f32 = std::f32::consts::E;
 fn check_log_base() {
     let x = 1f32;
     let _ = x.log(2f32);
+    //~^ suboptimal_flops
     let _ = x.log(10f32);
+    //~^ suboptimal_flops
     let _ = x.log(std::f32::consts::E);
+    //~^ suboptimal_flops
     let _ = x.log(TWO);
+    //~^ suboptimal_flops
     let _ = x.log(E);
+    //~^ suboptimal_flops
     let _ = (x as f32).log(2f32);
+    //~^ suboptimal_flops
 
     let x = 1f64;
     let _ = x.log(2f64);
+    //~^ suboptimal_flops
     let _ = x.log(10f64);
+    //~^ suboptimal_flops
     let _ = x.log(std::f64::consts::E);
+    //~^ suboptimal_flops
 }
 
 fn check_ln1p() {
     let x = 1f32;
     let _ = (1f32 + 2.).ln();
+    //~^ imprecise_flops
     let _ = (1f32 + 2.0).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + x).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + x / 2.0).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + x.powi(3)).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + x.powi(3) / 2.0).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + (std::f32::consts::E - 1.0)).ln();
+    //~^ imprecise_flops
     let _ = (x + 1.0).ln();
+    //~^ imprecise_flops
     let _ = (x.powi(3) + 1.0).ln();
+    //~^ imprecise_flops
     let _ = (x + 2.0 + 1.0).ln();
+    //~^ imprecise_flops
     let _ = (x / 2.0 + 1.0).ln();
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
@@ -42,14 +62,23 @@ fn check_ln1p() {
 
     let x = 1f64;
     let _ = (1f64 + 2.).ln();
+    //~^ imprecise_flops
     let _ = (1f64 + 2.0).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + x).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + x / 2.0).ln();
+    //~^ imprecise_flops
     let _ = (1.0 + x.powi(3)).ln();
+    //~^ imprecise_flops
     let _ = (x + 1.0).ln();
+    //~^ imprecise_flops
     let _ = (x.powi(3) + 1.0).ln();
+    //~^ imprecise_flops
     let _ = (x + 2.0 + 1.0).ln();
+    //~^ imprecise_flops
     let _ = (x / 2.0 + 1.0).ln();
+    //~^ imprecise_flops
     // Cases where the lint shouldn't be applied
     let _ = (1.0 + x + 2.0).ln();
     let _ = (x + 1.0 + 2.0).ln();
diff --git a/src/tools/clippy/tests/ui/floating_point_log.stderr b/src/tools/clippy/tests/ui/floating_point_log.stderr
index 19c28de8e39a..e93b3af851cb 100644
--- a/src/tools/clippy/tests/ui/floating_point_log.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_log.stderr
@@ -8,55 +8,55 @@ LL |     let _ = x.log(2f32);
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:12:13
+  --> tests/ui/floating_point_log.rs:13:13
    |
 LL |     let _ = x.log(10f32);
    |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:13:13
+  --> tests/ui/floating_point_log.rs:15:13
    |
 LL |     let _ = x.log(std::f32::consts::E);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:14:13
+  --> tests/ui/floating_point_log.rs:17:13
    |
 LL |     let _ = x.log(TWO);
    |             ^^^^^^^^^^ help: consider using: `x.log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:15:13
+  --> tests/ui/floating_point_log.rs:19:13
    |
 LL |     let _ = x.log(E);
    |             ^^^^^^^^ help: consider using: `x.ln()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:16:13
+  --> tests/ui/floating_point_log.rs:21:13
    |
 LL |     let _ = (x as f32).log(2f32);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:19:13
+  --> tests/ui/floating_point_log.rs:25:13
    |
 LL |     let _ = x.log(2f64);
    |             ^^^^^^^^^^^ help: consider using: `x.log2()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:20:13
+  --> tests/ui/floating_point_log.rs:27:13
    |
 LL |     let _ = x.log(10f64);
    |             ^^^^^^^^^^^^ help: consider using: `x.log10()`
 
 error: logarithm for bases 2, 10 and e can be computed more accurately
-  --> tests/ui/floating_point_log.rs:21:13
+  --> tests/ui/floating_point_log.rs:29:13
    |
 LL |     let _ = x.log(std::f64::consts::E);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.ln()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:26:13
+  --> tests/ui/floating_point_log.rs:35:13
    |
 LL |     let _ = (1f32 + 2.).ln();
    |             ^^^^^^^^^^^^^^^^ help: consider using: `2.0f32.ln_1p()`
@@ -65,95 +65,41 @@ LL |     let _ = (1f32 + 2.).ln();
    = help: to override `-D warnings` add `#[allow(clippy::imprecise_flops)]`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:27:13
+  --> tests/ui/floating_point_log.rs:37:13
    |
 LL |     let _ = (1f32 + 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `2.0f32.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:28:13
+  --> tests/ui/floating_point_log.rs:39:13
    |
 LL |     let _ = (1.0 + x).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:29:13
+  --> tests/ui/floating_point_log.rs:41:13
    |
 LL |     let _ = (1.0 + x / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:30:13
+  --> tests/ui/floating_point_log.rs:43:13
    |
 LL |     let _ = (1.0 + x.powi(3)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:31:13
+  --> tests/ui/floating_point_log.rs:45:13
    |
 LL |     let _ = (1.0 + x.powi(3) / 2.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x.powi(3) / 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:32:13
+  --> tests/ui/floating_point_log.rs:47:13
    |
 LL |     let _ = (1.0 + (std::f32::consts::E - 1.0)).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(std::f32::consts::E - 1.0).ln_1p()`
 
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:33:13
-   |
-LL |     let _ = (x + 1.0).ln();
-   |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:34:13
-   |
-LL |     let _ = (x.powi(3) + 1.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:35:13
-   |
-LL |     let _ = (x + 2.0 + 1.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 2.0).ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:36:13
-   |
-LL |     let _ = (x / 2.0 + 1.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:44:13
-   |
-LL |     let _ = (1f64 + 2.).ln();
-   |             ^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:45:13
-   |
-LL |     let _ = (1f64 + 2.0).ln();
-   |             ^^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:46:13
-   |
-LL |     let _ = (1.0 + x).ln();
-   |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:47:13
-   |
-LL |     let _ = (1.0 + x / 2.0).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
-
-error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:48:13
-   |
-LL |     let _ = (1.0 + x.powi(3)).ln();
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
-
 error: ln(1 + x) can be computed more accurately
   --> tests/ui/floating_point_log.rs:49:13
    |
@@ -161,19 +107,73 @@ LL |     let _ = (x + 1.0).ln();
    |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:50:13
+  --> tests/ui/floating_point_log.rs:51:13
    |
 LL |     let _ = (x.powi(3) + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:51:13
+  --> tests/ui/floating_point_log.rs:53:13
    |
 LL |     let _ = (x + 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 2.0).ln_1p()`
 
 error: ln(1 + x) can be computed more accurately
-  --> tests/ui/floating_point_log.rs:52:13
+  --> tests/ui/floating_point_log.rs:55:13
+   |
+LL |     let _ = (x / 2.0 + 1.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:64:13
+   |
+LL |     let _ = (1f64 + 2.).ln();
+   |             ^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:66:13
+   |
+LL |     let _ = (1f64 + 2.0).ln();
+   |             ^^^^^^^^^^^^^^^^^ help: consider using: `2.0f64.ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:68:13
+   |
+LL |     let _ = (1.0 + x).ln();
+   |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:70:13
+   |
+LL |     let _ = (1.0 + x / 2.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:72:13
+   |
+LL |     let _ = (1.0 + x.powi(3)).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:74:13
+   |
+LL |     let _ = (x + 1.0).ln();
+   |             ^^^^^^^^^^^^^^ help: consider using: `x.ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:76:13
+   |
+LL |     let _ = (x.powi(3) + 1.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(3).ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:78:13
+   |
+LL |     let _ = (x + 2.0 + 1.0).ln();
+   |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x + 2.0).ln_1p()`
+
+error: ln(1 + x) can be computed more accurately
+  --> tests/ui/floating_point_log.rs:80:13
    |
 LL |     let _ = (x / 2.0 + 1.0).ln();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x / 2.0).ln_1p()`
diff --git a/src/tools/clippy/tests/ui/floating_point_logbase.fixed b/src/tools/clippy/tests/ui/floating_point_logbase.fixed
index 451673d109c6..d03882c774c0 100644
--- a/src/tools/clippy/tests/ui/floating_point_logbase.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_logbase.fixed
@@ -5,10 +5,15 @@ fn main() {
     let x = 3f32;
     let y = 5f32;
     let _ = x.log(y);
+    //~^ suboptimal_flops
     let _ = (x as f32).log(y);
+    //~^ suboptimal_flops
     let _ = x.log(y);
+    //~^ suboptimal_flops
     let _ = x.log(y);
+    //~^ suboptimal_flops
     let _ = x.log(y);
+    //~^ suboptimal_flops
     // Cases where the lint shouldn't be applied
     let _ = x.ln() / y.powf(3.2);
     let _ = x.powf(3.2) / y.powf(3.2);
diff --git a/src/tools/clippy/tests/ui/floating_point_logbase.rs b/src/tools/clippy/tests/ui/floating_point_logbase.rs
index c309114599d9..c29f4deb3738 100644
--- a/src/tools/clippy/tests/ui/floating_point_logbase.rs
+++ b/src/tools/clippy/tests/ui/floating_point_logbase.rs
@@ -5,10 +5,15 @@ fn main() {
     let x = 3f32;
     let y = 5f32;
     let _ = x.ln() / y.ln();
+    //~^ suboptimal_flops
     let _ = (x as f32).ln() / y.ln();
+    //~^ suboptimal_flops
     let _ = x.log2() / y.log2();
+    //~^ suboptimal_flops
     let _ = x.log10() / y.log10();
+    //~^ suboptimal_flops
     let _ = x.log(5f32) / y.log(5f32);
+    //~^ suboptimal_flops
     // Cases where the lint shouldn't be applied
     let _ = x.ln() / y.powf(3.2);
     let _ = x.powf(3.2) / y.powf(3.2);
diff --git a/src/tools/clippy/tests/ui/floating_point_logbase.stderr b/src/tools/clippy/tests/ui/floating_point_logbase.stderr
index 8dfc57b133c6..1f30e5cbc177 100644
--- a/src/tools/clippy/tests/ui/floating_point_logbase.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_logbase.stderr
@@ -8,25 +8,25 @@ LL |     let _ = x.ln() / y.ln();
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: log base can be expressed more clearly
-  --> tests/ui/floating_point_logbase.rs:8:13
+  --> tests/ui/floating_point_logbase.rs:9:13
    |
 LL |     let _ = (x as f32).ln() / y.ln();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).log(y)`
 
 error: log base can be expressed more clearly
-  --> tests/ui/floating_point_logbase.rs:9:13
+  --> tests/ui/floating_point_logbase.rs:11:13
    |
 LL |     let _ = x.log2() / y.log2();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: log base can be expressed more clearly
-  --> tests/ui/floating_point_logbase.rs:10:13
+  --> tests/ui/floating_point_logbase.rs:13:13
    |
 LL |     let _ = x.log10() / y.log10();
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
 
 error: log base can be expressed more clearly
-  --> tests/ui/floating_point_logbase.rs:11:13
+  --> tests/ui/floating_point_logbase.rs:15:13
    |
 LL |     let _ = x.log(5f32) / y.log(5f32);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.log(y)`
diff --git a/src/tools/clippy/tests/ui/floating_point_mul_add.fixed b/src/tools/clippy/tests/ui/floating_point_mul_add.fixed
index 164aac2601a5..83aeddb2a1f4 100644
--- a/src/tools/clippy/tests/ui/floating_point_mul_add.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_mul_add.fixed
@@ -17,23 +17,36 @@ fn main() {
     let d: f64 = 0.0001;
 
     let _ = a.mul_add(b, c);
+    //~^ suboptimal_flops
     let _ = a.mul_add(b, -c);
+    //~^ suboptimal_flops
     let _ = a.mul_add(b, c);
+    //~^ suboptimal_flops
     let _ = a.mul_add(-b, c);
+    //~^ suboptimal_flops
     let _ = 2.0f64.mul_add(4.0, a);
+    //~^ suboptimal_flops
     let _ = 2.0f64.mul_add(4., a);
+    //~^ suboptimal_flops
 
     let _ = a.mul_add(b, c);
+    //~^ suboptimal_flops
     let _ = a.mul_add(b, c);
+    //~^ suboptimal_flops
     let _ = (a * b).mul_add(c, d);
+    //~^ suboptimal_flops
 
     let _ = a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c)) + c;
+    //~^ suboptimal_flops
     let _ = 1234.567_f64.mul_add(45.67834_f64, 0.0004_f64);
+    //~^ suboptimal_flops
 
     let _ = a.mul_add(a, b).sqrt();
+    //~^ suboptimal_flops
 
     let u = 1usize;
     let _ = b.mul_add(-(u as f64), a);
+    //~^ suboptimal_flops
 
     // Cases where the lint shouldn't be applied
     let _ = (a * a + b * b).sqrt();
diff --git a/src/tools/clippy/tests/ui/floating_point_mul_add.rs b/src/tools/clippy/tests/ui/floating_point_mul_add.rs
index ae024b7f224b..039ee8d053fc 100644
--- a/src/tools/clippy/tests/ui/floating_point_mul_add.rs
+++ b/src/tools/clippy/tests/ui/floating_point_mul_add.rs
@@ -17,23 +17,36 @@ fn main() {
     let d: f64 = 0.0001;
 
     let _ = a * b + c;
+    //~^ suboptimal_flops
     let _ = a * b - c;
+    //~^ suboptimal_flops
     let _ = c + a * b;
+    //~^ suboptimal_flops
     let _ = c - a * b;
+    //~^ suboptimal_flops
     let _ = a + 2.0 * 4.0;
+    //~^ suboptimal_flops
     let _ = a + 2. * 4.;
+    //~^ suboptimal_flops
 
     let _ = (a * b) + c;
+    //~^ suboptimal_flops
     let _ = c + (a * b);
+    //~^ suboptimal_flops
     let _ = a * b * c + d;
+    //~^ suboptimal_flops
 
     let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
+    //~^ suboptimal_flops
     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
+    //~^ suboptimal_flops
 
     let _ = (a * a + b).sqrt();
+    //~^ suboptimal_flops
 
     let u = 1usize;
     let _ = a - (b * u as f64);
+    //~^ suboptimal_flops
 
     // Cases where the lint shouldn't be applied
     let _ = (a * a + b * b).sqrt();
diff --git a/src/tools/clippy/tests/ui/floating_point_mul_add.stderr b/src/tools/clippy/tests/ui/floating_point_mul_add.stderr
index 9c75909f7158..6482127bcc00 100644
--- a/src/tools/clippy/tests/ui/floating_point_mul_add.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_mul_add.stderr
@@ -8,73 +8,73 @@ LL |     let _ = a * b + c;
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:20:13
+  --> tests/ui/floating_point_mul_add.rs:21:13
    |
 LL |     let _ = a * b - c;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, -c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:21:13
+  --> tests/ui/floating_point_mul_add.rs:23:13
    |
 LL |     let _ = c + a * b;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:22:13
+  --> tests/ui/floating_point_mul_add.rs:25:13
    |
 LL |     let _ = c - a * b;
    |             ^^^^^^^^^ help: consider using: `a.mul_add(-b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:23:13
+  --> tests/ui/floating_point_mul_add.rs:27:13
    |
 LL |     let _ = a + 2.0 * 4.0;
    |             ^^^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4.0, a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:24:13
+  --> tests/ui/floating_point_mul_add.rs:29:13
    |
 LL |     let _ = a + 2. * 4.;
    |             ^^^^^^^^^^^ help: consider using: `2.0f64.mul_add(4., a)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:26:13
+  --> tests/ui/floating_point_mul_add.rs:32:13
    |
 LL |     let _ = (a * b) + c;
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:27:13
+  --> tests/ui/floating_point_mul_add.rs:34:13
    |
 LL |     let _ = c + (a * b);
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(b, c)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:28:13
+  --> tests/ui/floating_point_mul_add.rs:36:13
    |
 LL |     let _ = a * b * c + d;
    |             ^^^^^^^^^^^^^ help: consider using: `(a * b).mul_add(c, d)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:30:13
+  --> tests/ui/floating_point_mul_add.rs:39:13
    |
 LL |     let _ = a.mul_add(b, c) * a.mul_add(b, c) + a.mul_add(b, c) + c;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `a.mul_add(b, c).mul_add(a.mul_add(b, c), a.mul_add(b, c))`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:31:13
+  --> tests/ui/floating_point_mul_add.rs:41:13
    |
 LL |     let _ = 1234.567_f64 * 45.67834_f64 + 0.0004_f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1234.567_f64.mul_add(45.67834_f64, 0.0004_f64)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:33:13
+  --> tests/ui/floating_point_mul_add.rs:44:13
    |
 LL |     let _ = (a * a + b).sqrt();
    |             ^^^^^^^^^^^ help: consider using: `a.mul_add(a, b)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_mul_add.rs:36:13
+  --> tests/ui/floating_point_mul_add.rs:48:13
    |
 LL |     let _ = a - (b * u as f64);
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `b.mul_add(-(u as f64), a)`
diff --git a/src/tools/clippy/tests/ui/floating_point_powf.fixed b/src/tools/clippy/tests/ui/floating_point_powf.fixed
index 25f09a637951..293df9bfe9b9 100644
--- a/src/tools/clippy/tests/ui/floating_point_powf.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_powf.fixed
@@ -6,24 +6,43 @@
 fn main() {
     let x = 3f32;
     let _ = x.exp2();
+    //~^ suboptimal_flops
     let _ = 3.1f32.exp2();
+    //~^ suboptimal_flops
     let _ = (-3.1f32).exp2();
+    //~^ suboptimal_flops
     let _ = x.exp();
+    //~^ suboptimal_flops
     let _ = 3.1f32.exp();
+    //~^ suboptimal_flops
     let _ = (-3.1f32).exp();
+    //~^ suboptimal_flops
     let _ = x.sqrt();
+    //~^ suboptimal_flops
     let _ = x.cbrt();
+    //~^ imprecise_flops
     let _ = (x as f32).cbrt();
+    //~^ imprecise_flops
     let _ = x.powi(3);
+    //~^ suboptimal_flops
     let _ = x.powi(-2);
+    //~^ suboptimal_flops
     let _ = x.powi(16_777_215);
+    //~^ suboptimal_flops
     let _ = x.powi(-16_777_215);
+    //~^ suboptimal_flops
     let _ = (x as f32).powi(-16_777_215);
+    //~^ suboptimal_flops
     let _ = (x as f32).powi(3);
+    //~^ suboptimal_flops
     let _ = (1.5_f32 + 1.0).cbrt();
+    //~^ imprecise_flops
     let _ = 1.5_f64.cbrt();
+    //~^ imprecise_flops
     let _ = 1.5_f64.sqrt();
+    //~^ suboptimal_flops
     let _ = 1.5_f64.powi(3);
+    //~^ suboptimal_flops
 
     macro_rules! m {
         ($e:expr) => {
@@ -32,6 +51,7 @@ fn main() {
     }
 
     let _ = (1f32 + m!(2.0)).exp2();
+    //~^ suboptimal_flops
 
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
@@ -41,17 +61,29 @@ fn main() {
 
     let x = 3f64;
     let _ = x.exp2();
+    //~^ suboptimal_flops
     let _ = 3.1f64.exp2();
+    //~^ suboptimal_flops
     let _ = (-3.1f64).exp2();
+    //~^ suboptimal_flops
     let _ = x.exp();
+    //~^ suboptimal_flops
     let _ = 3.1f64.exp();
+    //~^ suboptimal_flops
     let _ = (-3.1f64).exp();
+    //~^ suboptimal_flops
     let _ = x.sqrt();
+    //~^ suboptimal_flops
     let _ = x.cbrt();
+    //~^ imprecise_flops
     let _ = x.powi(3);
+    //~^ suboptimal_flops
     let _ = x.powi(-2);
+    //~^ suboptimal_flops
     let _ = x.powi(-2_147_483_648);
+    //~^ suboptimal_flops
     let _ = x.powi(2_147_483_647);
+    //~^ suboptimal_flops
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
     let _ = x.powf(-2.1);
diff --git a/src/tools/clippy/tests/ui/floating_point_powf.rs b/src/tools/clippy/tests/ui/floating_point_powf.rs
index 9e9878de4bad..5b1940a369a5 100644
--- a/src/tools/clippy/tests/ui/floating_point_powf.rs
+++ b/src/tools/clippy/tests/ui/floating_point_powf.rs
@@ -6,24 +6,43 @@
 fn main() {
     let x = 3f32;
     let _ = 2f32.powf(x);
+    //~^ suboptimal_flops
     let _ = 2f32.powf(3.1);
+    //~^ suboptimal_flops
     let _ = 2f32.powf(-3.1);
+    //~^ suboptimal_flops
     let _ = std::f32::consts::E.powf(x);
+    //~^ suboptimal_flops
     let _ = std::f32::consts::E.powf(3.1);
+    //~^ suboptimal_flops
     let _ = std::f32::consts::E.powf(-3.1);
+    //~^ suboptimal_flops
     let _ = x.powf(1.0 / 2.0);
+    //~^ suboptimal_flops
     let _ = x.powf(1.0 / 3.0);
+    //~^ imprecise_flops
     let _ = (x as f32).powf(1.0 / 3.0);
+    //~^ imprecise_flops
     let _ = x.powf(3.0);
+    //~^ suboptimal_flops
     let _ = x.powf(-2.0);
+    //~^ suboptimal_flops
     let _ = x.powf(16_777_215.0);
+    //~^ suboptimal_flops
     let _ = x.powf(-16_777_215.0);
+    //~^ suboptimal_flops
     let _ = (x as f32).powf(-16_777_215.0);
+    //~^ suboptimal_flops
     let _ = (x as f32).powf(3.0);
+    //~^ suboptimal_flops
     let _ = (1.5_f32 + 1.0).powf(1.0 / 3.0);
+    //~^ imprecise_flops
     let _ = 1.5_f64.powf(1.0 / 3.0);
+    //~^ imprecise_flops
     let _ = 1.5_f64.powf(1.0 / 2.0);
+    //~^ suboptimal_flops
     let _ = 1.5_f64.powf(3.0);
+    //~^ suboptimal_flops
 
     macro_rules! m {
         ($e:expr) => {
@@ -32,6 +51,7 @@ fn main() {
     }
 
     let _ = 2f32.powf(1f32 + m!(2.0));
+    //~^ suboptimal_flops
 
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
@@ -41,17 +61,29 @@ fn main() {
 
     let x = 3f64;
     let _ = 2f64.powf(x);
+    //~^ suboptimal_flops
     let _ = 2f64.powf(3.1);
+    //~^ suboptimal_flops
     let _ = 2f64.powf(-3.1);
+    //~^ suboptimal_flops
     let _ = std::f64::consts::E.powf(x);
+    //~^ suboptimal_flops
     let _ = std::f64::consts::E.powf(3.1);
+    //~^ suboptimal_flops
     let _ = std::f64::consts::E.powf(-3.1);
+    //~^ suboptimal_flops
     let _ = x.powf(1.0 / 2.0);
+    //~^ suboptimal_flops
     let _ = x.powf(1.0 / 3.0);
+    //~^ imprecise_flops
     let _ = x.powf(3.0);
+    //~^ suboptimal_flops
     let _ = x.powf(-2.0);
+    //~^ suboptimal_flops
     let _ = x.powf(-2_147_483_648.0);
+    //~^ suboptimal_flops
     let _ = x.powf(2_147_483_647.0);
+    //~^ suboptimal_flops
     // Cases where the lint shouldn't be applied
     let _ = x.powf(2.1);
     let _ = x.powf(-2.1);
diff --git a/src/tools/clippy/tests/ui/floating_point_powf.stderr b/src/tools/clippy/tests/ui/floating_point_powf.stderr
index c944f14fa34d..dec30a94cc78 100644
--- a/src/tools/clippy/tests/ui/floating_point_powf.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_powf.stderr
@@ -8,43 +8,43 @@ LL |     let _ = 2f32.powf(x);
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:9:13
+  --> tests/ui/floating_point_powf.rs:10:13
    |
 LL |     let _ = 2f32.powf(3.1);
    |             ^^^^^^^^^^^^^^ help: consider using: `3.1f32.exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:10:13
+  --> tests/ui/floating_point_powf.rs:12:13
    |
 LL |     let _ = 2f32.powf(-3.1);
    |             ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f32).exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:11:13
+  --> tests/ui/floating_point_powf.rs:14:13
    |
 LL |     let _ = std::f32::consts::E.powf(x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:12:13
+  --> tests/ui/floating_point_powf.rs:16:13
    |
 LL |     let _ = std::f32::consts::E.powf(3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f32.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:13:13
+  --> tests/ui/floating_point_powf.rs:18:13
    |
 LL |     let _ = std::f32::consts::E.powf(-3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f32).exp()`
 
 error: square-root of a number can be computed more efficiently and accurately
-  --> tests/ui/floating_point_powf.rs:14:13
+  --> tests/ui/floating_point_powf.rs:20:13
    |
 LL |     let _ = x.powf(1.0 / 2.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
 
 error: cube-root of a number can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:15:13
+  --> tests/ui/floating_point_powf.rs:22:13
    |
 LL |     let _ = x.powf(1.0 / 3.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
@@ -53,145 +53,145 @@ LL |     let _ = x.powf(1.0 / 3.0);
    = help: to override `-D warnings` add `#[allow(clippy::imprecise_flops)]`
 
 error: cube-root of a number can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:16:13
+  --> tests/ui/floating_point_powf.rs:24:13
    |
 LL |     let _ = (x as f32).powf(1.0 / 3.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).cbrt()`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:17:13
+  --> tests/ui/floating_point_powf.rs:26:13
    |
 LL |     let _ = x.powf(3.0);
    |             ^^^^^^^^^^^ help: consider using: `x.powi(3)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:18:13
+  --> tests/ui/floating_point_powf.rs:28:13
    |
 LL |     let _ = x.powf(-2.0);
    |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:19:13
+  --> tests/ui/floating_point_powf.rs:30:13
    |
 LL |     let _ = x.powf(16_777_215.0);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(16_777_215)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:20:13
+  --> tests/ui/floating_point_powf.rs:32:13
    |
 LL |     let _ = x.powf(-16_777_215.0);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-16_777_215)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:21:13
+  --> tests/ui/floating_point_powf.rs:34:13
    |
 LL |     let _ = (x as f32).powf(-16_777_215.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(-16_777_215)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:22:13
+  --> tests/ui/floating_point_powf.rs:36:13
    |
 LL |     let _ = (x as f32).powf(3.0);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x as f32).powi(3)`
 
 error: cube-root of a number can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:23:13
+  --> tests/ui/floating_point_powf.rs:38:13
    |
 LL |     let _ = (1.5_f32 + 1.0).powf(1.0 / 3.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(1.5_f32 + 1.0).cbrt()`
 
 error: cube-root of a number can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:24:13
+  --> tests/ui/floating_point_powf.rs:40:13
    |
 LL |     let _ = 1.5_f64.powf(1.0 / 3.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.cbrt()`
 
 error: square-root of a number can be computed more efficiently and accurately
-  --> tests/ui/floating_point_powf.rs:25:13
+  --> tests/ui/floating_point_powf.rs:42:13
    |
 LL |     let _ = 1.5_f64.powf(1.0 / 2.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.sqrt()`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:26:13
+  --> tests/ui/floating_point_powf.rs:44:13
    |
 LL |     let _ = 1.5_f64.powf(3.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `1.5_f64.powi(3)`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:34:13
+  --> tests/ui/floating_point_powf.rs:53:13
    |
 LL |     let _ = 2f32.powf(1f32 + m!(2.0));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(1f32 + m!(2.0)).exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:43:13
+  --> tests/ui/floating_point_powf.rs:63:13
    |
 LL |     let _ = 2f64.powf(x);
    |             ^^^^^^^^^^^^ help: consider using: `x.exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:44:13
+  --> tests/ui/floating_point_powf.rs:65:13
    |
 LL |     let _ = 2f64.powf(3.1);
    |             ^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:45:13
+  --> tests/ui/floating_point_powf.rs:67:13
    |
 LL |     let _ = 2f64.powf(-3.1);
    |             ^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp2()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:46:13
+  --> tests/ui/floating_point_powf.rs:69:13
    |
 LL |     let _ = std::f64::consts::E.powf(x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:47:13
+  --> tests/ui/floating_point_powf.rs:71:13
    |
 LL |     let _ = std::f64::consts::E.powf(3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `3.1f64.exp()`
 
 error: exponent for bases 2 and e can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:48:13
+  --> tests/ui/floating_point_powf.rs:73:13
    |
 LL |     let _ = std::f64::consts::E.powf(-3.1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-3.1f64).exp()`
 
 error: square-root of a number can be computed more efficiently and accurately
-  --> tests/ui/floating_point_powf.rs:49:13
+  --> tests/ui/floating_point_powf.rs:75:13
    |
 LL |     let _ = x.powf(1.0 / 2.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.sqrt()`
 
 error: cube-root of a number can be computed more accurately
-  --> tests/ui/floating_point_powf.rs:50:13
+  --> tests/ui/floating_point_powf.rs:77:13
    |
 LL |     let _ = x.powf(1.0 / 3.0);
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `x.cbrt()`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:51:13
+  --> tests/ui/floating_point_powf.rs:79:13
    |
 LL |     let _ = x.powf(3.0);
    |             ^^^^^^^^^^^ help: consider using: `x.powi(3)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:52:13
+  --> tests/ui/floating_point_powf.rs:81:13
    |
 LL |     let _ = x.powf(-2.0);
    |             ^^^^^^^^^^^^ help: consider using: `x.powi(-2)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:53:13
+  --> tests/ui/floating_point_powf.rs:83:13
    |
 LL |     let _ = x.powf(-2_147_483_648.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(-2_147_483_648)`
 
 error: exponentiation with integer powers can be computed more efficiently
-  --> tests/ui/floating_point_powf.rs:54:13
+  --> tests/ui/floating_point_powf.rs:85:13
    |
 LL |     let _ = x.powf(2_147_483_647.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.powi(2_147_483_647)`
diff --git a/src/tools/clippy/tests/ui/floating_point_powi.fixed b/src/tools/clippy/tests/ui/floating_point_powi.fixed
index cb033c899f31..5f0618ab1c72 100644
--- a/src/tools/clippy/tests/ui/floating_point_powi.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_powi.fixed
@@ -7,20 +7,34 @@ fn main() {
 
     let y = 4f32;
     let _ = x.mul_add(x, y);
+    //~^ suboptimal_flops
     let _ = x.mul_add(x, -y);
+    //~^ suboptimal_flops
     let _ = y.mul_add(y, x);
+    //~^ suboptimal_flops
     let _ = y.mul_add(-y, x);
+    //~^ suboptimal_flops
     let _ = (y as f32).mul_add(y as f32, x);
+    //~^ suboptimal_flops
     let _ = x.mul_add(x, y).sqrt();
+    //~^ suboptimal_flops
     let _ = y.mul_add(y, x).sqrt();
+    //~^ suboptimal_flops
 
     let _ = (x - 1.0).mul_add(x - 1.0, -y);
+    //~^ suboptimal_flops
     let _ = (x - 1.0).mul_add(x - 1.0, -y) + 3.0;
+    //~^ suboptimal_flops
     let _ = (x - 1.0).mul_add(x - 1.0, -(y + 3.0));
+    //~^ suboptimal_flops
     let _ = (y + 1.0).mul_add(-(y + 1.0), x);
+    //~^ suboptimal_flops
     let _ = (3.0 * y).mul_add(-(3.0 * y), x);
+    //~^ suboptimal_flops
     let _ = (y + 1.0 + x).mul_add(-(y + 1.0 + x), x);
+    //~^ suboptimal_flops
     let _ = (y + 1.0 + 2.0).mul_add(-(y + 1.0 + 2.0), x);
+    //~^ suboptimal_flops
 
     // Cases where the lint shouldn't be applied
     let _ = x.powi(2);
diff --git a/src/tools/clippy/tests/ui/floating_point_powi.rs b/src/tools/clippy/tests/ui/floating_point_powi.rs
index f02e0e8ddb36..bb97a8eddf33 100644
--- a/src/tools/clippy/tests/ui/floating_point_powi.rs
+++ b/src/tools/clippy/tests/ui/floating_point_powi.rs
@@ -7,20 +7,34 @@ fn main() {
 
     let y = 4f32;
     let _ = x.powi(2) + y;
+    //~^ suboptimal_flops
     let _ = x.powi(2) - y;
+    //~^ suboptimal_flops
     let _ = x + y.powi(2);
+    //~^ suboptimal_flops
     let _ = x - y.powi(2);
+    //~^ suboptimal_flops
     let _ = x + (y as f32).powi(2);
+    //~^ suboptimal_flops
     let _ = (x.powi(2) + y).sqrt();
+    //~^ suboptimal_flops
     let _ = (x + y.powi(2)).sqrt();
+    //~^ suboptimal_flops
 
     let _ = (x - 1.0).powi(2) - y;
+    //~^ suboptimal_flops
     let _ = (x - 1.0).powi(2) - y + 3.0;
+    //~^ suboptimal_flops
     let _ = (x - 1.0).powi(2) - (y + 3.0);
+    //~^ suboptimal_flops
     let _ = x - (y + 1.0).powi(2);
+    //~^ suboptimal_flops
     let _ = x - (3.0 * y).powi(2);
+    //~^ suboptimal_flops
     let _ = x - (y + 1.0 + x).powi(2);
+    //~^ suboptimal_flops
     let _ = x - (y + 1.0 + 2.0).powi(2);
+    //~^ suboptimal_flops
 
     // Cases where the lint shouldn't be applied
     let _ = x.powi(2);
diff --git a/src/tools/clippy/tests/ui/floating_point_powi.stderr b/src/tools/clippy/tests/ui/floating_point_powi.stderr
index dfed20cb8c5a..211589382911 100644
--- a/src/tools/clippy/tests/ui/floating_point_powi.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_powi.stderr
@@ -8,79 +8,79 @@ LL |     let _ = x.powi(2) + y;
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:10:13
+  --> tests/ui/floating_point_powi.rs:11:13
    |
 LL |     let _ = x.powi(2) - y;
    |             ^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, -y)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:11:13
+  --> tests/ui/floating_point_powi.rs:13:13
    |
 LL |     let _ = x + y.powi(2);
    |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:12:13
+  --> tests/ui/floating_point_powi.rs:15:13
    |
 LL |     let _ = x - y.powi(2);
    |             ^^^^^^^^^^^^^ help: consider using: `y.mul_add(-y, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:13:13
+  --> tests/ui/floating_point_powi.rs:17:13
    |
 LL |     let _ = x + (y as f32).powi(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y as f32).mul_add(y as f32, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:14:13
+  --> tests/ui/floating_point_powi.rs:19:13
    |
 LL |     let _ = (x.powi(2) + y).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `x.mul_add(x, y)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:15:13
+  --> tests/ui/floating_point_powi.rs:21:13
    |
 LL |     let _ = (x + y.powi(2)).sqrt();
    |             ^^^^^^^^^^^^^^^ help: consider using: `y.mul_add(y, x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:17:13
+  --> tests/ui/floating_point_powi.rs:24:13
    |
 LL |     let _ = (x - 1.0).powi(2) - y;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x - 1.0).mul_add(x - 1.0, -y)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:18:13
+  --> tests/ui/floating_point_powi.rs:26:13
    |
 LL |     let _ = (x - 1.0).powi(2) - y + 3.0;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x - 1.0).mul_add(x - 1.0, -y)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:19:13
+  --> tests/ui/floating_point_powi.rs:28:13
    |
 LL |     let _ = (x - 1.0).powi(2) - (y + 3.0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(x - 1.0).mul_add(x - 1.0, -(y + 3.0))`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:20:13
+  --> tests/ui/floating_point_powi.rs:30:13
    |
 LL |     let _ = x - (y + 1.0).powi(2);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y + 1.0).mul_add(-(y + 1.0), x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:21:13
+  --> tests/ui/floating_point_powi.rs:32:13
    |
 LL |     let _ = x - (3.0 * y).powi(2);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(3.0 * y).mul_add(-(3.0 * y), x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:22:13
+  --> tests/ui/floating_point_powi.rs:34:13
    |
 LL |     let _ = x - (y + 1.0 + x).powi(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y + 1.0 + x).mul_add(-(y + 1.0 + x), x)`
 
 error: multiply and add expressions can be calculated more efficiently and accurately
-  --> tests/ui/floating_point_powi.rs:23:13
+  --> tests/ui/floating_point_powi.rs:36:13
    |
 LL |     let _ = x - (y + 1.0 + 2.0).powi(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(y + 1.0 + 2.0).mul_add(-(y + 1.0 + 2.0), x)`
diff --git a/src/tools/clippy/tests/ui/floating_point_rad.fixed b/src/tools/clippy/tests/ui/floating_point_rad.fixed
index 2f93d233cb40..61f3ccc8bd02 100644
--- a/src/tools/clippy/tests/ui/floating_point_rad.fixed
+++ b/src/tools/clippy/tests/ui/floating_point_rad.fixed
@@ -8,17 +8,25 @@ pub const fn const_context() {
 
 pub fn issue9391(degrees: i64) {
     let _ = (degrees as f64).to_radians();
+    //~^ suboptimal_flops
     let _ = (degrees as f64).to_degrees();
+    //~^ suboptimal_flops
 }
 
 fn main() {
     let x = 3f32;
     let _ = x.to_degrees();
+    //~^ suboptimal_flops
     let _ = 90.0_f64.to_degrees();
+    //~^ suboptimal_flops
     let _ = 90.5_f64.to_degrees();
+    //~^ suboptimal_flops
     let _ = x.to_radians();
+    //~^ suboptimal_flops
     let _ = 90.0_f64.to_radians();
+    //~^ suboptimal_flops
     let _ = 90.5_f64.to_radians();
+    //~^ suboptimal_flops
     // let _ = 90.5 * 80. * std::f32::consts::PI / 180f32;
     // Cases where the lint shouldn't be applied
     let _ = x * 90f32 / std::f32::consts::PI;
diff --git a/src/tools/clippy/tests/ui/floating_point_rad.rs b/src/tools/clippy/tests/ui/floating_point_rad.rs
index 9690effc4e10..f57359e15fe1 100644
--- a/src/tools/clippy/tests/ui/floating_point_rad.rs
+++ b/src/tools/clippy/tests/ui/floating_point_rad.rs
@@ -8,17 +8,25 @@ pub const fn const_context() {
 
 pub fn issue9391(degrees: i64) {
     let _ = degrees as f64 * std::f64::consts::PI / 180.0;
+    //~^ suboptimal_flops
     let _ = degrees as f64 * 180.0 / std::f64::consts::PI;
+    //~^ suboptimal_flops
 }
 
 fn main() {
     let x = 3f32;
     let _ = x * 180f32 / std::f32::consts::PI;
+    //~^ suboptimal_flops
     let _ = 90. * 180f64 / std::f64::consts::PI;
+    //~^ suboptimal_flops
     let _ = 90.5 * 180f64 / std::f64::consts::PI;
+    //~^ suboptimal_flops
     let _ = x * std::f32::consts::PI / 180f32;
+    //~^ suboptimal_flops
     let _ = 90. * std::f32::consts::PI / 180f32;
+    //~^ suboptimal_flops
     let _ = 90.5 * std::f32::consts::PI / 180f32;
+    //~^ suboptimal_flops
     // let _ = 90.5 * 80. * std::f32::consts::PI / 180f32;
     // Cases where the lint shouldn't be applied
     let _ = x * 90f32 / std::f32::consts::PI;
diff --git a/src/tools/clippy/tests/ui/floating_point_rad.stderr b/src/tools/clippy/tests/ui/floating_point_rad.stderr
index b834f5374e0b..b888edd59bfd 100644
--- a/src/tools/clippy/tests/ui/floating_point_rad.stderr
+++ b/src/tools/clippy/tests/ui/floating_point_rad.stderr
@@ -8,43 +8,43 @@ LL |     let _ = degrees as f64 * std::f64::consts::PI / 180.0;
    = help: to override `-D warnings` add `#[allow(clippy::suboptimal_flops)]`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:11:13
+  --> tests/ui/floating_point_rad.rs:12:13
    |
 LL |     let _ = degrees as f64 * 180.0 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(degrees as f64).to_degrees()`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:16:13
+  --> tests/ui/floating_point_rad.rs:18:13
    |
 LL |     let _ = x * 180f32 / std::f32::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_degrees()`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:17:13
+  --> tests/ui/floating_point_rad.rs:20:13
    |
 LL |     let _ = 90. * 180f64 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_degrees()`
 
 error: conversion to degrees can be done more accurately
-  --> tests/ui/floating_point_rad.rs:18:13
+  --> tests/ui/floating_point_rad.rs:22:13
    |
 LL |     let _ = 90.5 * 180f64 / std::f64::consts::PI;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_degrees()`
 
 error: conversion to radians can be done more accurately
-  --> tests/ui/floating_point_rad.rs:19:13
+  --> tests/ui/floating_point_rad.rs:24:13
    |
 LL |     let _ = x * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `x.to_radians()`
 
 error: conversion to radians can be done more accurately
-  --> tests/ui/floating_point_rad.rs:20:13
+  --> tests/ui/floating_point_rad.rs:26:13
    |
 LL |     let _ = 90. * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.0_f64.to_radians()`
 
 error: conversion to radians can be done more accurately
-  --> tests/ui/floating_point_rad.rs:21:13
+  --> tests/ui/floating_point_rad.rs:28:13
    |
 LL |     let _ = 90.5 * std::f32::consts::PI / 180f32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `90.5_f64.to_radians()`
diff --git a/src/tools/clippy/tests/ui/fn_to_numeric_cast.32bit.stderr b/src/tools/clippy/tests/ui/fn_to_numeric_cast.32bit.stderr
index 65991a3989ac..2affd0b7d6e9 100644
--- a/src/tools/clippy/tests/ui/fn_to_numeric_cast.32bit.stderr
+++ b/src/tools/clippy/tests/ui/fn_to_numeric_cast.32bit.stderr
@@ -1,5 +1,5 @@
 error: casting function pointer `foo` to `i8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:10:13
+  --> tests/ui/fn_to_numeric_cast.rs:12:13
    |
 LL |     let _ = foo as i8;
    |             ^^^^^^^^^ help: try: `foo as usize`
@@ -8,13 +8,13 @@ LL |     let _ = foo as i8;
    = help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast_with_truncation)]`
 
 error: casting function pointer `foo` to `i16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:11:13
+  --> tests/ui/fn_to_numeric_cast.rs:14:13
    |
 LL |     let _ = foo as i16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `i32`
-  --> tests/ui/fn_to_numeric_cast.rs:12:13
+  --> tests/ui/fn_to_numeric_cast.rs:16:13
    |
 LL |     let _ = foo as i32;
    |             ^^^^^^^^^^ help: try: `foo as usize`
@@ -23,121 +23,121 @@ LL |     let _ = foo as i32;
    = help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast)]`
 
 error: casting function pointer `foo` to `i64`
-  --> tests/ui/fn_to_numeric_cast.rs:13:13
+  --> tests/ui/fn_to_numeric_cast.rs:19:13
    |
 LL |     let _ = foo as i64;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `i128`
-  --> tests/ui/fn_to_numeric_cast.rs:14:13
+  --> tests/ui/fn_to_numeric_cast.rs:21:13
    |
 LL |     let _ = foo as i128;
    |             ^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `isize`
-  --> tests/ui/fn_to_numeric_cast.rs:15:13
+  --> tests/ui/fn_to_numeric_cast.rs:23:13
    |
 LL |     let _ = foo as isize;
    |             ^^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:17:13
+  --> tests/ui/fn_to_numeric_cast.rs:26:13
    |
 LL |     let _ = foo as u8;
    |             ^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:18:13
+  --> tests/ui/fn_to_numeric_cast.rs:28:13
    |
 LL |     let _ = foo as u16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u32`
-  --> tests/ui/fn_to_numeric_cast.rs:19:13
+  --> tests/ui/fn_to_numeric_cast.rs:30:13
    |
 LL |     let _ = foo as u32;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u64`
-  --> tests/ui/fn_to_numeric_cast.rs:20:13
+  --> tests/ui/fn_to_numeric_cast.rs:33:13
    |
 LL |     let _ = foo as u64;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u128`
-  --> tests/ui/fn_to_numeric_cast.rs:21:13
+  --> tests/ui/fn_to_numeric_cast.rs:35:13
    |
 LL |     let _ = foo as u128;
    |             ^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `abc` to `i8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:34:13
+  --> tests/ui/fn_to_numeric_cast.rs:49:13
    |
 LL |     let _ = abc as i8;
    |             ^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:35:13
+  --> tests/ui/fn_to_numeric_cast.rs:51:13
    |
 LL |     let _ = abc as i16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i32`
-  --> tests/ui/fn_to_numeric_cast.rs:36:13
+  --> tests/ui/fn_to_numeric_cast.rs:53:13
    |
 LL |     let _ = abc as i32;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i64`
-  --> tests/ui/fn_to_numeric_cast.rs:37:13
+  --> tests/ui/fn_to_numeric_cast.rs:56:13
    |
 LL |     let _ = abc as i64;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i128`
-  --> tests/ui/fn_to_numeric_cast.rs:38:13
+  --> tests/ui/fn_to_numeric_cast.rs:58:13
    |
 LL |     let _ = abc as i128;
    |             ^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `isize`
-  --> tests/ui/fn_to_numeric_cast.rs:39:13
+  --> tests/ui/fn_to_numeric_cast.rs:60:13
    |
 LL |     let _ = abc as isize;
    |             ^^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:41:13
+  --> tests/ui/fn_to_numeric_cast.rs:63:13
    |
 LL |     let _ = abc as u8;
    |             ^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:42:13
+  --> tests/ui/fn_to_numeric_cast.rs:65:13
    |
 LL |     let _ = abc as u16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u32`
-  --> tests/ui/fn_to_numeric_cast.rs:43:13
+  --> tests/ui/fn_to_numeric_cast.rs:67:13
    |
 LL |     let _ = abc as u32;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u64`
-  --> tests/ui/fn_to_numeric_cast.rs:44:13
+  --> tests/ui/fn_to_numeric_cast.rs:70:13
    |
 LL |     let _ = abc as u64;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u128`
-  --> tests/ui/fn_to_numeric_cast.rs:45:13
+  --> tests/ui/fn_to_numeric_cast.rs:72:13
    |
 LL |     let _ = abc as u128;
    |             ^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `f` to `i32`
-  --> tests/ui/fn_to_numeric_cast.rs:52:5
+  --> tests/ui/fn_to_numeric_cast.rs:80:5
    |
 LL |     f as i32
    |     ^^^^^^^^ help: try: `f as usize`
diff --git a/src/tools/clippy/tests/ui/fn_to_numeric_cast.64bit.stderr b/src/tools/clippy/tests/ui/fn_to_numeric_cast.64bit.stderr
index 58f55f19a745..48961d14f2bb 100644
--- a/src/tools/clippy/tests/ui/fn_to_numeric_cast.64bit.stderr
+++ b/src/tools/clippy/tests/ui/fn_to_numeric_cast.64bit.stderr
@@ -1,5 +1,5 @@
 error: casting function pointer `foo` to `i8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:10:13
+  --> tests/ui/fn_to_numeric_cast.rs:12:13
    |
 LL |     let _ = foo as i8;
    |             ^^^^^^^^^ help: try: `foo as usize`
@@ -8,19 +8,19 @@ LL |     let _ = foo as i8;
    = help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast_with_truncation)]`
 
 error: casting function pointer `foo` to `i16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:11:13
+  --> tests/ui/fn_to_numeric_cast.rs:14:13
    |
 LL |     let _ = foo as i16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `i32`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:12:13
+  --> tests/ui/fn_to_numeric_cast.rs:16:13
    |
 LL |     let _ = foo as i32;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `i64`
-  --> tests/ui/fn_to_numeric_cast.rs:13:13
+  --> tests/ui/fn_to_numeric_cast.rs:19:13
    |
 LL |     let _ = foo as i64;
    |             ^^^^^^^^^^ help: try: `foo as usize`
@@ -29,115 +29,115 @@ LL |     let _ = foo as i64;
    = help: to override `-D warnings` add `#[allow(clippy::fn_to_numeric_cast)]`
 
 error: casting function pointer `foo` to `i128`
-  --> tests/ui/fn_to_numeric_cast.rs:14:13
+  --> tests/ui/fn_to_numeric_cast.rs:21:13
    |
 LL |     let _ = foo as i128;
    |             ^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `isize`
-  --> tests/ui/fn_to_numeric_cast.rs:15:13
+  --> tests/ui/fn_to_numeric_cast.rs:23:13
    |
 LL |     let _ = foo as isize;
    |             ^^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:17:13
+  --> tests/ui/fn_to_numeric_cast.rs:26:13
    |
 LL |     let _ = foo as u8;
    |             ^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:18:13
+  --> tests/ui/fn_to_numeric_cast.rs:28:13
    |
 LL |     let _ = foo as u16;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u32`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:19:13
+  --> tests/ui/fn_to_numeric_cast.rs:30:13
    |
 LL |     let _ = foo as u32;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u64`
-  --> tests/ui/fn_to_numeric_cast.rs:20:13
+  --> tests/ui/fn_to_numeric_cast.rs:33:13
    |
 LL |     let _ = foo as u64;
    |             ^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `foo` to `u128`
-  --> tests/ui/fn_to_numeric_cast.rs:21:13
+  --> tests/ui/fn_to_numeric_cast.rs:35:13
    |
 LL |     let _ = foo as u128;
    |             ^^^^^^^^^^^ help: try: `foo as usize`
 
 error: casting function pointer `abc` to `i8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:34:13
+  --> tests/ui/fn_to_numeric_cast.rs:49:13
    |
 LL |     let _ = abc as i8;
    |             ^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:35:13
+  --> tests/ui/fn_to_numeric_cast.rs:51:13
    |
 LL |     let _ = abc as i16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i32`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:36:13
+  --> tests/ui/fn_to_numeric_cast.rs:53:13
    |
 LL |     let _ = abc as i32;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i64`
-  --> tests/ui/fn_to_numeric_cast.rs:37:13
+  --> tests/ui/fn_to_numeric_cast.rs:56:13
    |
 LL |     let _ = abc as i64;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `i128`
-  --> tests/ui/fn_to_numeric_cast.rs:38:13
+  --> tests/ui/fn_to_numeric_cast.rs:58:13
    |
 LL |     let _ = abc as i128;
    |             ^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `isize`
-  --> tests/ui/fn_to_numeric_cast.rs:39:13
+  --> tests/ui/fn_to_numeric_cast.rs:60:13
    |
 LL |     let _ = abc as isize;
    |             ^^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u8`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:41:13
+  --> tests/ui/fn_to_numeric_cast.rs:63:13
    |
 LL |     let _ = abc as u8;
    |             ^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u16`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:42:13
+  --> tests/ui/fn_to_numeric_cast.rs:65:13
    |
 LL |     let _ = abc as u16;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u32`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:43:13
+  --> tests/ui/fn_to_numeric_cast.rs:67:13
    |
 LL |     let _ = abc as u32;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u64`
-  --> tests/ui/fn_to_numeric_cast.rs:44:13
+  --> tests/ui/fn_to_numeric_cast.rs:70:13
    |
 LL |     let _ = abc as u64;
    |             ^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `abc` to `u128`
-  --> tests/ui/fn_to_numeric_cast.rs:45:13
+  --> tests/ui/fn_to_numeric_cast.rs:72:13
    |
 LL |     let _ = abc as u128;
    |             ^^^^^^^^^^^ help: try: `abc as usize`
 
 error: casting function pointer `f` to `i32`, which truncates the value
-  --> tests/ui/fn_to_numeric_cast.rs:52:5
+  --> tests/ui/fn_to_numeric_cast.rs:80:5
    |
 LL |     f as i32
    |     ^^^^^^^^ help: try: `f as usize`
diff --git a/src/tools/clippy/tests/ui/fn_to_numeric_cast.rs b/src/tools/clippy/tests/ui/fn_to_numeric_cast.rs
index 9501eb5da4b2..f53cbacdb377 100644
--- a/src/tools/clippy/tests/ui/fn_to_numeric_cast.rs
+++ b/src/tools/clippy/tests/ui/fn_to_numeric_cast.rs
@@ -1,4 +1,6 @@
-//@stderr-per-bitwidth
+//@revisions: 32bit 64bit
+//@[32bit]ignore-bitwidth: 64
+//@[64bit]ignore-bitwidth: 32
 //@no-rustfix
 #![warn(clippy::fn_to_numeric_cast, clippy::fn_to_numeric_cast_with_truncation)]
 
@@ -8,17 +10,30 @@ fn foo() -> String {
 
 fn test_function_to_numeric_cast() {
     let _ = foo as i8;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = foo as i16;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = foo as i32;
+    //~[64bit]^ fn_to_numeric_cast_with_truncation
+    //~[32bit]^^ fn_to_numeric_cast
     let _ = foo as i64;
+    //~^ fn_to_numeric_cast
     let _ = foo as i128;
+    //~^ fn_to_numeric_cast
     let _ = foo as isize;
+    //~^ fn_to_numeric_cast
 
     let _ = foo as u8;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = foo as u16;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = foo as u32;
+    //~[64bit]^ fn_to_numeric_cast_with_truncation
+    //~[32bit]^^ fn_to_numeric_cast
     let _ = foo as u64;
+    //~^ fn_to_numeric_cast
     let _ = foo as u128;
+    //~^ fn_to_numeric_cast
 
     // Casting to usize is OK and should not warn
     let _ = foo as usize;
@@ -32,17 +47,30 @@ fn test_function_var_to_numeric_cast() {
     let abc: fn() -> String = foo;
 
     let _ = abc as i8;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = abc as i16;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = abc as i32;
+    //~[64bit]^ fn_to_numeric_cast_with_truncation
+    //~[32bit]^^ fn_to_numeric_cast
     let _ = abc as i64;
+    //~^ fn_to_numeric_cast
     let _ = abc as i128;
+    //~^ fn_to_numeric_cast
     let _ = abc as isize;
+    //~^ fn_to_numeric_cast
 
     let _ = abc as u8;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = abc as u16;
+    //~^ fn_to_numeric_cast_with_truncation
     let _ = abc as u32;
+    //~[64bit]^ fn_to_numeric_cast_with_truncation
+    //~[32bit]^^ fn_to_numeric_cast
     let _ = abc as u64;
+    //~^ fn_to_numeric_cast
     let _ = abc as u128;
+    //~^ fn_to_numeric_cast
 
     // Casting to usize is OK and should not warn
     let _ = abc as usize;
@@ -50,6 +78,8 @@ fn test_function_var_to_numeric_cast() {
 
 fn fn_with_fn_args(f: fn(i32) -> i32) -> i32 {
     f as i32
+    //~[64bit]^ fn_to_numeric_cast_with_truncation
+    //~[32bit]^^ fn_to_numeric_cast
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.rs b/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.rs
index 95abc0ac68dd..42f2128cd378 100644
--- a/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.rs
+++ b/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.rs
@@ -21,58 +21,67 @@ impl Trait for Struct {}
 
 fn fn_pointer_to_integer() {
     let _ = foo as i8;
-    //~^ ERROR: casting function pointer `foo` to `i8`
-    //~| NOTE: `-D clippy::fn-to-numeric-cast-any` implied by `-D warnings`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as i16;
-    //~^ ERROR: casting function pointer `foo` to `i16`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as i32;
-    //~^ ERROR: casting function pointer `foo` to `i32`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as i64;
-    //~^ ERROR: casting function pointer `foo` to `i64`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as i128;
-    //~^ ERROR: casting function pointer `foo` to `i128`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as isize;
-    //~^ ERROR: casting function pointer `foo` to `isize`
+    //~^ fn_to_numeric_cast_any
 
     let _ = foo as u8;
-    //~^ ERROR: casting function pointer `foo` to `u8`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as u16;
-    //~^ ERROR: casting function pointer `foo` to `u16`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as u32;
-    //~^ ERROR: casting function pointer `foo` to `u32`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as u64;
-    //~^ ERROR: casting function pointer `foo` to `u64`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as u128;
-    //~^ ERROR: casting function pointer `foo` to `u128`
+    //~^ fn_to_numeric_cast_any
+
     let _ = foo as usize;
-    //~^ ERROR: casting function pointer `foo` to `usize`
+    //~^ fn_to_numeric_cast_any
 }
 
 fn static_method_to_integer() {
     let _ = Struct::static_method as usize;
-    //~^ ERROR: casting function pointer `Struct::static_method` to `usize`
+    //~^ fn_to_numeric_cast_any
 }
 
 fn fn_with_fn_arg(f: fn(i32) -> u32) -> usize {
     f as usize
-    //~^ ERROR: casting function pointer `f` to `usize`
+    //~^ fn_to_numeric_cast_any
 }
 
 fn fn_with_generic_static_trait_method<T: Trait>() -> usize {
     T::static_method as usize
-    //~^ ERROR: casting function pointer `T::static_method` to `usize`
+    //~^ fn_to_numeric_cast_any
 }
 
 fn closure_to_fn_to_integer() {
     let clos = |x| x * 2_u32;
 
     let _ = (clos as fn(u32) -> u32) as usize;
-    //~^ ERROR: casting function pointer `(clos as fn(u32) -> u32)` to `usize`
+    //~^ fn_to_numeric_cast_any
 }
 
 fn fn_to_raw_ptr() {
     let _ = foo as *const ();
-    //~^ ERROR: casting function pointer `foo` to `*const ()`
+    //~^ fn_to_numeric_cast_any
 }
 
 fn cast_fn_to_self() {
diff --git a/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr b/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr
index 0238e3a91369..58fac2d406a0 100644
--- a/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr
+++ b/src/tools/clippy/tests/ui/fn_to_numeric_cast_any.stderr
@@ -23,7 +23,7 @@ LL |     let _ = foo() as i16;
    |                ++
 
 error: casting function pointer `foo` to `i32`
-  --> tests/ui/fn_to_numeric_cast_any.rs:28:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:29:13
    |
 LL |     let _ = foo as i32;
    |             ^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |     let _ = foo() as i32;
    |                ++
 
 error: casting function pointer `foo` to `i64`
-  --> tests/ui/fn_to_numeric_cast_any.rs:30:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:32:13
    |
 LL |     let _ = foo as i64;
    |             ^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |     let _ = foo() as i64;
    |                ++
 
 error: casting function pointer `foo` to `i128`
-  --> tests/ui/fn_to_numeric_cast_any.rs:32:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:35:13
    |
 LL |     let _ = foo as i128;
    |             ^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |     let _ = foo() as i128;
    |                ++
 
 error: casting function pointer `foo` to `isize`
-  --> tests/ui/fn_to_numeric_cast_any.rs:34:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:38:13
    |
 LL |     let _ = foo as isize;
    |             ^^^^^^^^^^^^
@@ -67,7 +67,7 @@ LL |     let _ = foo() as isize;
    |                ++
 
 error: casting function pointer `foo` to `u8`
-  --> tests/ui/fn_to_numeric_cast_any.rs:37:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:41:13
    |
 LL |     let _ = foo as u8;
    |             ^^^^^^^^^
@@ -78,7 +78,7 @@ LL |     let _ = foo() as u8;
    |                ++
 
 error: casting function pointer `foo` to `u16`
-  --> tests/ui/fn_to_numeric_cast_any.rs:39:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:44:13
    |
 LL |     let _ = foo as u16;
    |             ^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     let _ = foo() as u16;
    |                ++
 
 error: casting function pointer `foo` to `u32`
-  --> tests/ui/fn_to_numeric_cast_any.rs:41:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:47:13
    |
 LL |     let _ = foo as u32;
    |             ^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     let _ = foo() as u32;
    |                ++
 
 error: casting function pointer `foo` to `u64`
-  --> tests/ui/fn_to_numeric_cast_any.rs:43:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:50:13
    |
 LL |     let _ = foo as u64;
    |             ^^^^^^^^^^
@@ -111,7 +111,7 @@ LL |     let _ = foo() as u64;
    |                ++
 
 error: casting function pointer `foo` to `u128`
-  --> tests/ui/fn_to_numeric_cast_any.rs:45:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:53:13
    |
 LL |     let _ = foo as u128;
    |             ^^^^^^^^^^^
@@ -122,7 +122,7 @@ LL |     let _ = foo() as u128;
    |                ++
 
 error: casting function pointer `foo` to `usize`
-  --> tests/ui/fn_to_numeric_cast_any.rs:47:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:56:13
    |
 LL |     let _ = foo as usize;
    |             ^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL |     let _ = foo() as usize;
    |                ++
 
 error: casting function pointer `Struct::static_method` to `usize`
-  --> tests/ui/fn_to_numeric_cast_any.rs:52:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:61:13
    |
 LL |     let _ = Struct::static_method as usize;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL |     let _ = Struct::static_method() as usize;
    |                                  ++
 
 error: casting function pointer `f` to `usize`
-  --> tests/ui/fn_to_numeric_cast_any.rs:57:5
+  --> tests/ui/fn_to_numeric_cast_any.rs:66:5
    |
 LL |     f as usize
    |     ^^^^^^^^^^
@@ -155,7 +155,7 @@ LL |     f() as usize
    |      ++
 
 error: casting function pointer `T::static_method` to `usize`
-  --> tests/ui/fn_to_numeric_cast_any.rs:62:5
+  --> tests/ui/fn_to_numeric_cast_any.rs:71:5
    |
 LL |     T::static_method as usize
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -166,7 +166,7 @@ LL |     T::static_method() as usize
    |                     ++
 
 error: casting function pointer `(clos as fn(u32) -> u32)` to `usize`
-  --> tests/ui/fn_to_numeric_cast_any.rs:69:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:78:13
    |
 LL |     let _ = (clos as fn(u32) -> u32) as usize;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -177,7 +177,7 @@ LL |     let _ = (clos as fn(u32) -> u32)() as usize;
    |                                     ++
 
 error: casting function pointer `foo` to `*const ()`
-  --> tests/ui/fn_to_numeric_cast_any.rs:74:13
+  --> tests/ui/fn_to_numeric_cast_any.rs:83:13
    |
 LL |     let _ = foo as *const ();
    |             ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/for_kv_map.fixed b/src/tools/clippy/tests/ui/for_kv_map.fixed
index 1733b29128fe..2a68b7443fbf 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.fixed
+++ b/src/tools/clippy/tests/ui/for_kv_map.fixed
@@ -7,14 +7,15 @@ use std::rc::Rc;
 fn main() {
     let m: HashMap<u64, u64> = HashMap::new();
     for v in m.values() {
-        //~^ ERROR: you seem to want to iterate on a map's values
-        //~| NOTE: `-D clippy::for-kv-map` implied by `-D warnings`
+        //~^ for_kv_map
+
         let _v = v;
     }
 
     let m: Rc<HashMap<u64, u64>> = Rc::new(HashMap::new());
     for v in (*m).values() {
-        //~^ ERROR: you seem to want to iterate on a map's values
+        //~^ for_kv_map
+
         let _v = v;
         // Here the `*` is not actually necessary, but the test tests that we don't
         // suggest
@@ -23,27 +24,31 @@ fn main() {
 
     let mut m: HashMap<u64, u64> = HashMap::new();
     for v in m.values_mut() {
-        //~^ ERROR: you seem to want to iterate on a map's values
+        //~^ for_kv_map
+
         let _v = v;
     }
 
     let m: &mut HashMap<u64, u64> = &mut HashMap::new();
     for v in (*m).values_mut() {
-        //~^ ERROR: you seem to want to iterate on a map's values
+        //~^ for_kv_map
+
         let _v = v;
     }
 
     let m: HashMap<u64, u64> = HashMap::new();
     let rm = &m;
     for k in rm.keys() {
-        //~^ ERROR: you seem to want to iterate on a map's keys
+        //~^ for_kv_map
+
         let _k = k;
     }
 
     let m: HashMap<u64, u64> = HashMap::new();
     let rm = &m;
     'label: for k in rm.keys() {
-        //~^ ERROR: you seem to want to iterate on a map's keys
+        //~^ for_kv_map
+
         let _k = k;
         if *k == 0u64 {
             break 'label;
diff --git a/src/tools/clippy/tests/ui/for_kv_map.rs b/src/tools/clippy/tests/ui/for_kv_map.rs
index de465a7c8e6e..485a97815e3c 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.rs
+++ b/src/tools/clippy/tests/ui/for_kv_map.rs
@@ -7,14 +7,15 @@ use std::rc::Rc;
 fn main() {
     let m: HashMap<u64, u64> = HashMap::new();
     for (_, v) in &m {
-        //~^ ERROR: you seem to want to iterate on a map's values
-        //~| NOTE: `-D clippy::for-kv-map` implied by `-D warnings`
+        //~^ for_kv_map
+
         let _v = v;
     }
 
     let m: Rc<HashMap<u64, u64>> = Rc::new(HashMap::new());
     for (_, v) in &*m {
-        //~^ ERROR: you seem to want to iterate on a map's values
+        //~^ for_kv_map
+
         let _v = v;
         // Here the `*` is not actually necessary, but the test tests that we don't
         // suggest
@@ -23,27 +24,31 @@ fn main() {
 
     let mut m: HashMap<u64, u64> = HashMap::new();
     for (_, v) in &mut m {
-        //~^ ERROR: you seem to want to iterate on a map's values
+        //~^ for_kv_map
+
         let _v = v;
     }
 
     let m: &mut HashMap<u64, u64> = &mut HashMap::new();
     for (_, v) in &mut *m {
-        //~^ ERROR: you seem to want to iterate on a map's values
+        //~^ for_kv_map
+
         let _v = v;
     }
 
     let m: HashMap<u64, u64> = HashMap::new();
     let rm = &m;
     for (k, _value) in rm {
-        //~^ ERROR: you seem to want to iterate on a map's keys
+        //~^ for_kv_map
+
         let _k = k;
     }
 
     let m: HashMap<u64, u64> = HashMap::new();
     let rm = &m;
     'label: for (k, _value) in rm {
-        //~^ ERROR: you seem to want to iterate on a map's keys
+        //~^ for_kv_map
+
         let _k = k;
         if *k == 0u64 {
             break 'label;
diff --git a/src/tools/clippy/tests/ui/for_kv_map.stderr b/src/tools/clippy/tests/ui/for_kv_map.stderr
index 11b61c8cbc64..0bd474a10682 100644
--- a/src/tools/clippy/tests/ui/for_kv_map.stderr
+++ b/src/tools/clippy/tests/ui/for_kv_map.stderr
@@ -25,7 +25,7 @@ LL +     for v in (*m).values() {
    |
 
 error: you seem to want to iterate on a map's values
-  --> tests/ui/for_kv_map.rs:25:19
+  --> tests/ui/for_kv_map.rs:26:19
    |
 LL |     for (_, v) in &mut m {
    |                   ^^^^^^
@@ -37,7 +37,7 @@ LL +     for v in m.values_mut() {
    |
 
 error: you seem to want to iterate on a map's values
-  --> tests/ui/for_kv_map.rs:31:19
+  --> tests/ui/for_kv_map.rs:33:19
    |
 LL |     for (_, v) in &mut *m {
    |                   ^^^^^^^
@@ -49,7 +49,7 @@ LL +     for v in (*m).values_mut() {
    |
 
 error: you seem to want to iterate on a map's keys
-  --> tests/ui/for_kv_map.rs:38:24
+  --> tests/ui/for_kv_map.rs:41:24
    |
 LL |     for (k, _value) in rm {
    |                        ^^
@@ -61,7 +61,7 @@ LL +     for k in rm.keys() {
    |
 
 error: you seem to want to iterate on a map's keys
-  --> tests/ui/for_kv_map.rs:45:32
+  --> tests/ui/for_kv_map.rs:49:32
    |
 LL |     'label: for (k, _value) in rm {
    |                                ^^
diff --git a/src/tools/clippy/tests/ui/forget_non_drop.rs b/src/tools/clippy/tests/ui/forget_non_drop.rs
index 2459f51a38da..0235709b1f1c 100644
--- a/src/tools/clippy/tests/ui/forget_non_drop.rs
+++ b/src/tools/clippy/tests/ui/forget_non_drop.rs
@@ -11,7 +11,7 @@ fn main() {
     struct Foo;
     // Lint
     forget(Foo);
-    //~^ ERROR: call to `std::mem::forget` with a value that does not implement `Drop`. Fo
+    //~^ forget_non_drop
 
     struct Bar;
     impl Drop for Bar {
@@ -23,7 +23,8 @@ fn main() {
     struct Baz<T>(T);
     // Lint
     forget(Baz(Foo));
-    //~^ ERROR: call to `std::mem::forget` with a value that does not implement `Drop`. Fo
+    //~^ forget_non_drop
+
     // Don't lint
     forget(Baz(Bar));
 }
diff --git a/src/tools/clippy/tests/ui/format.fixed b/src/tools/clippy/tests/ui/format.fixed
index 3dc8eb79ba28..16437c62094a 100644
--- a/src/tools/clippy/tests/ui/format.fixed
+++ b/src/tools/clippy/tests/ui/format.fixed
@@ -18,14 +18,19 @@ macro_rules! foo {
 
 fn main() {
     "foo".to_string();
+    //~^ useless_format
     "{}".to_string();
+    //~^ useless_format
     "{} abc {}".to_string();
+    //~^ useless_format
     r##"foo {}
 " bar"##.to_string();
 
     let _ = String::new();
+    //~^ useless_format
 
     "foo".to_string();
+    //~^ useless_format
     format!("{:?}", "foo"); // Don't warn about `Debug`.
     format!("{:8}", "foo");
     format!("{:width$}", "foo", width = 8);
@@ -34,6 +39,7 @@ fn main() {
 
     let arg = String::new();
     arg.to_string();
+    //~^ useless_format
     format!("{:?}", arg); // Don't warn about debug.
     format!("{:8}", arg);
     format!("{:width$}", arg, width = 8);
@@ -64,28 +70,36 @@ fn main() {
     format!("{:.prec$}", "foo", prec = 10);
 
     42.to_string();
+    //~^ useless_format
     let x = std::path::PathBuf::from("/bar/foo/qux");
     x.display().to_string();
+    //~^ useless_format
 
     // False positive
     let a = "foo".to_string();
     let _ = Some(a + "bar");
+    //~^ useless_format
 
     // Wrap it with braces
     let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
     let _s: String = (&*v.join("\n")).to_string();
+    //~^ useless_format
 
     format!("prepend {:+}", "s");
 
     // Issue #8290
     let x = "foo";
     let _ = x.to_string();
+    //~^ useless_format
     let _ = format!("{x:?}"); // Don't lint on debug
     let _ = x.to_string();
+    //~^ useless_format
 
     // Issue #9234
     let abc = "abc";
     let _ = abc.to_string();
+    //~^ useless_format
     let xx = "xx";
     let _ = xx.to_string();
+    //~^ useless_format
 }
diff --git a/src/tools/clippy/tests/ui/format.rs b/src/tools/clippy/tests/ui/format.rs
index eaf33c2a6c92..06371378f27e 100644
--- a/src/tools/clippy/tests/ui/format.rs
+++ b/src/tools/clippy/tests/ui/format.rs
@@ -18,16 +18,22 @@ macro_rules! foo {
 
 fn main() {
     format!("foo");
+    //~^ useless_format
     format!("{{}}");
+    //~^ useless_format
     format!("{{}} abc {{}}");
+    //~^ useless_format
     format!(
+        //~^ useless_format
         r##"foo {{}}
 " bar"##
     );
 
     let _ = format!("");
+    //~^ useless_format
 
     format!("{}", "foo");
+    //~^ useless_format
     format!("{:?}", "foo"); // Don't warn about `Debug`.
     format!("{:8}", "foo");
     format!("{:width$}", "foo", width = 8);
@@ -36,6 +42,7 @@ fn main() {
 
     let arg = String::new();
     format!("{}", arg);
+    //~^ useless_format
     format!("{:?}", arg); // Don't warn about debug.
     format!("{:8}", arg);
     format!("{:width$}", arg, width = 8);
@@ -66,28 +73,36 @@ fn main() {
     format!("{:.prec$}", "foo", prec = 10);
 
     format!("{}", 42.to_string());
+    //~^ useless_format
     let x = std::path::PathBuf::from("/bar/foo/qux");
     format!("{}", x.display().to_string());
+    //~^ useless_format
 
     // False positive
     let a = "foo".to_string();
     let _ = Some(format!("{}", a + "bar"));
+    //~^ useless_format
 
     // Wrap it with braces
     let v: Vec<String> = vec!["foo".to_string(), "bar".to_string()];
     let _s: String = format!("{}", &*v.join("\n"));
+    //~^ useless_format
 
     format!("prepend {:+}", "s");
 
     // Issue #8290
     let x = "foo";
     let _ = format!("{x}");
+    //~^ useless_format
     let _ = format!("{x:?}"); // Don't lint on debug
     let _ = format!("{y}", y = x);
+    //~^ useless_format
 
     // Issue #9234
     let abc = "abc";
     let _ = format!("{abc}");
+    //~^ useless_format
     let xx = "xx";
     let _ = format!("{xx}");
+    //~^ useless_format
 }
diff --git a/src/tools/clippy/tests/ui/format.stderr b/src/tools/clippy/tests/ui/format.stderr
index 1368c8cd77e0..da990d32cb80 100644
--- a/src/tools/clippy/tests/ui/format.stderr
+++ b/src/tools/clippy/tests/ui/format.stderr
@@ -8,21 +8,22 @@ LL |     format!("foo");
    = help: to override `-D warnings` add `#[allow(clippy::useless_format)]`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:21:5
+  --> tests/ui/format.rs:22:5
    |
 LL |     format!("{{}}");
    |     ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{}".to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:22:5
+  --> tests/ui/format.rs:24:5
    |
 LL |     format!("{{}} abc {{}}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"{} abc {}".to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:23:5
+  --> tests/ui/format.rs:26:5
    |
 LL | /     format!(
+LL | |
 LL | |         r##"foo {{}}
 LL | | " bar"##
 LL | |     );
@@ -35,67 +36,67 @@ LL ~ " bar"##.to_string();
    |
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:28:13
+  --> tests/ui/format.rs:32:13
    |
 LL |     let _ = format!("");
    |             ^^^^^^^^^^^ help: consider using `String::new()`: `String::new()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:30:5
+  --> tests/ui/format.rs:35:5
    |
 LL |     format!("{}", "foo");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `"foo".to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:38:5
+  --> tests/ui/format.rs:44:5
    |
 LL |     format!("{}", arg);
    |     ^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `arg.to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:68:5
+  --> tests/ui/format.rs:75:5
    |
 LL |     format!("{}", 42.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `42.to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:70:5
+  --> tests/ui/format.rs:78:5
    |
 LL |     format!("{}", x.display().to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.display().to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:74:18
+  --> tests/ui/format.rs:83:18
    |
 LL |     let _ = Some(format!("{}", a + "bar"));
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `a + "bar"`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:78:22
+  --> tests/ui/format.rs:88:22
    |
 LL |     let _s: String = format!("{}", &*v.join("\n"));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `(&*v.join("\n")).to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:84:13
+  --> tests/ui/format.rs:95:13
    |
 LL |     let _ = format!("{x}");
    |             ^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:86:13
+  --> tests/ui/format.rs:98:13
    |
 LL |     let _ = format!("{y}", y = x);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `x.to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:90:13
+  --> tests/ui/format.rs:103:13
    |
 LL |     let _ = format!("{abc}");
    |             ^^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `abc.to_string()`
 
 error: useless use of `format!`
-  --> tests/ui/format.rs:92:13
+  --> tests/ui/format.rs:106:13
    |
 LL |     let _ = format!("{xx}");
    |             ^^^^^^^^^^^^^^^ help: consider using `.to_string()`: `xx.to_string()`
diff --git a/src/tools/clippy/tests/ui/format_args.fixed b/src/tools/clippy/tests/ui/format_args.fixed
index 20d1e3d90504..edfdaa23ca12 100644
--- a/src/tools/clippy/tests/ui/format_args.fixed
+++ b/src/tools/clippy/tests/ui/format_args.fixed
@@ -75,36 +75,58 @@ fn main() {
     let x_ref = &x;
 
     let _ = format!("error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     let _ = write!(
         stdout(),
         "error: something failed at {}",
-        Location::caller()
+        Location::caller(),
+        //~^ to_string_in_format_args
     );
     let _ = writeln!(
         stdout(),
         "error: something failed at {}",
-        Location::caller()
+        Location::caller(),
+        //~^ to_string_in_format_args
     );
     print!("error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     println!("error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     eprint!("error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     eprintln!("error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     let _ = format_args!("error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     assert!(true, "error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     assert_eq!(0, 0, "error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     assert_ne!(0, 0, "error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     panic!("error: something failed at {}", Location::caller());
+    //~^ to_string_in_format_args
     println!("{}", *X(1));
+    //~^ to_string_in_format_args
     println!("{}", ***Y(&X(1)));
+    //~^ to_string_in_format_args
     println!("{}", Z(1));
+    //~^ to_string_in_format_args
     println!("{}", **x);
+    //~^ to_string_in_format_args
     println!("{}", ***x_ref);
+    //~^ to_string_in_format_args
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{bar}", foo = "foo", bar = "bar");
+    //~^ to_string_in_format_args
     println!("{foo}{bar}", foo = "foo", bar = "bar");
+    //~^ to_string_in_format_args
     println!("{foo}{bar}", bar = "bar", foo = "foo");
+    //~^ to_string_in_format_args
     println!("{foo}{bar}", bar = "bar", foo = "foo");
+    //~^ to_string_in_format_args
     println!("{}", my_other_macro!());
+    //~^ to_string_in_format_args
 
     // negative tests
     println!("error: something failed at {}", Somewhere.to_string());
@@ -117,7 +139,9 @@ fn main() {
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{foo:?}", foo = "foo".to_string());
     print!("{}", (Location::caller()));
+    //~^ to_string_in_format_args
     print!("{}", ((Location::caller())));
+    //~^ to_string_in_format_args
 }
 
 fn issue8643(vendor_id: usize, product_id: usize, name: &str) {
@@ -146,6 +170,7 @@ mod issue_8855 {
         let b = A {};
 
         let x = format!("{} {}", a, b);
+        //~^ to_string_in_format_args
         dbg!(x);
 
         let x = format!("{:>6} {:>6}", a, b.to_string());
@@ -160,6 +185,7 @@ mod issue_9256 {
     fn print_substring(original: &str) {
         assert!(original.len() > 10);
         println!("{}", &original[..10]);
+        //~^ to_string_in_format_args
     }
 
     fn main() {
diff --git a/src/tools/clippy/tests/ui/format_args.rs b/src/tools/clippy/tests/ui/format_args.rs
index 18ab223db78a..367560d577dd 100644
--- a/src/tools/clippy/tests/ui/format_args.rs
+++ b/src/tools/clippy/tests/ui/format_args.rs
@@ -75,36 +75,58 @@ fn main() {
     let x_ref = &x;
 
     let _ = format!("error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     let _ = write!(
         stdout(),
         "error: something failed at {}",
-        Location::caller().to_string()
+        Location::caller().to_string(),
+        //~^ to_string_in_format_args
     );
     let _ = writeln!(
         stdout(),
         "error: something failed at {}",
-        Location::caller().to_string()
+        Location::caller().to_string(),
+        //~^ to_string_in_format_args
     );
     print!("error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     println!("error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     eprint!("error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     eprintln!("error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     let _ = format_args!("error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     assert!(true, "error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     assert_eq!(0, 0, "error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     assert_ne!(0, 0, "error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     panic!("error: something failed at {}", Location::caller().to_string());
+    //~^ to_string_in_format_args
     println!("{}", X(1).to_string());
+    //~^ to_string_in_format_args
     println!("{}", Y(&X(1)).to_string());
+    //~^ to_string_in_format_args
     println!("{}", Z(1).to_string());
+    //~^ to_string_in_format_args
     println!("{}", x.to_string());
+    //~^ to_string_in_format_args
     println!("{}", x_ref.to_string());
+    //~^ to_string_in_format_args
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{bar}", foo = "foo".to_string(), bar = "bar");
+    //~^ to_string_in_format_args
     println!("{foo}{bar}", foo = "foo", bar = "bar".to_string());
+    //~^ to_string_in_format_args
     println!("{foo}{bar}", bar = "bar".to_string(), foo = "foo");
+    //~^ to_string_in_format_args
     println!("{foo}{bar}", bar = "bar", foo = "foo".to_string());
+    //~^ to_string_in_format_args
     println!("{}", my_other_macro!().to_string());
+    //~^ to_string_in_format_args
 
     // negative tests
     println!("error: something failed at {}", Somewhere.to_string());
@@ -117,7 +139,9 @@ fn main() {
     // https://github.com/rust-lang/rust-clippy/issues/7903
     println!("{foo}{foo:?}", foo = "foo".to_string());
     print!("{}", (Location::caller().to_string()));
+    //~^ to_string_in_format_args
     print!("{}", ((Location::caller()).to_string()));
+    //~^ to_string_in_format_args
 }
 
 fn issue8643(vendor_id: usize, product_id: usize, name: &str) {
@@ -146,6 +170,7 @@ mod issue_8855 {
         let b = A {};
 
         let x = format!("{} {}", a, b.to_string());
+        //~^ to_string_in_format_args
         dbg!(x);
 
         let x = format!("{:>6} {:>6}", a, b.to_string());
@@ -160,6 +185,7 @@ mod issue_9256 {
     fn print_substring(original: &str) {
         assert!(original.len() > 10);
         println!("{}", original[..10].to_string());
+        //~^ to_string_in_format_args
     }
 
     fn main() {
diff --git a/src/tools/clippy/tests/ui/format_args.stderr b/src/tools/clippy/tests/ui/format_args.stderr
index 91a45e270081..589c341ce859 100644
--- a/src/tools/clippy/tests/ui/format_args.stderr
+++ b/src/tools/clippy/tests/ui/format_args.stderr
@@ -8,151 +8,151 @@ LL |     let _ = format!("error: something failed at {}", Location::caller().to_
    = help: to override `-D warnings` add `#[allow(clippy::to_string_in_format_args)]`
 
 error: `to_string` applied to a type that implements `Display` in `write!` args
-  --> tests/ui/format_args.rs:81:27
+  --> tests/ui/format_args.rs:82:27
    |
-LL |         Location::caller().to_string()
+LL |         Location::caller().to_string(),
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `writeln!` args
-  --> tests/ui/format_args.rs:86:27
+  --> tests/ui/format_args.rs:88:27
    |
-LL |         Location::caller().to_string()
+LL |         Location::caller().to_string(),
    |                           ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> tests/ui/format_args.rs:88:63
+  --> tests/ui/format_args.rs:91:63
    |
 LL |     print!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:89:65
+  --> tests/ui/format_args.rs:93:65
    |
 LL |     println!("error: something failed at {}", Location::caller().to_string());
    |                                                                 ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprint!` args
-  --> tests/ui/format_args.rs:90:64
+  --> tests/ui/format_args.rs:95:64
    |
 LL |     eprint!("error: something failed at {}", Location::caller().to_string());
    |                                                                ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `eprintln!` args
-  --> tests/ui/format_args.rs:91:66
+  --> tests/ui/format_args.rs:97:66
    |
 LL |     eprintln!("error: something failed at {}", Location::caller().to_string());
    |                                                                  ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `format_args!` args
-  --> tests/ui/format_args.rs:92:77
+  --> tests/ui/format_args.rs:99:77
    |
 LL |     let _ = format_args!("error: something failed at {}", Location::caller().to_string());
    |                                                                             ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert!` args
-  --> tests/ui/format_args.rs:93:70
+  --> tests/ui/format_args.rs:101:70
    |
 LL |     assert!(true, "error: something failed at {}", Location::caller().to_string());
    |                                                                      ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_eq!` args
-  --> tests/ui/format_args.rs:94:73
+  --> tests/ui/format_args.rs:103:73
    |
 LL |     assert_eq!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `assert_ne!` args
-  --> tests/ui/format_args.rs:95:73
+  --> tests/ui/format_args.rs:105:73
    |
 LL |     assert_ne!(0, 0, "error: something failed at {}", Location::caller().to_string());
    |                                                                         ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `panic!` args
-  --> tests/ui/format_args.rs:96:63
+  --> tests/ui/format_args.rs:107:63
    |
 LL |     panic!("error: something failed at {}", Location::caller().to_string());
    |                                                               ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:97:20
+  --> tests/ui/format_args.rs:109:20
    |
 LL |     println!("{}", X(1).to_string());
    |                    ^^^^^^^^^^^^^^^^ help: use this: `*X(1)`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:98:20
+  --> tests/ui/format_args.rs:111:20
    |
 LL |     println!("{}", Y(&X(1)).to_string());
    |                    ^^^^^^^^^^^^^^^^^^^^ help: use this: `***Y(&X(1))`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:99:24
+  --> tests/ui/format_args.rs:113:24
    |
 LL |     println!("{}", Z(1).to_string());
    |                        ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:100:20
+  --> tests/ui/format_args.rs:115:20
    |
 LL |     println!("{}", x.to_string());
    |                    ^^^^^^^^^^^^^ help: use this: `**x`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:101:20
+  --> tests/ui/format_args.rs:117:20
    |
 LL |     println!("{}", x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^ help: use this: `***x_ref`
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:103:39
+  --> tests/ui/format_args.rs:120:39
    |
 LL |     println!("{foo}{bar}", foo = "foo".to_string(), bar = "bar");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:104:52
+  --> tests/ui/format_args.rs:122:52
    |
 LL |     println!("{foo}{bar}", foo = "foo", bar = "bar".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:105:39
+  --> tests/ui/format_args.rs:124:39
    |
 LL |     println!("{foo}{bar}", bar = "bar".to_string(), foo = "foo");
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:106:52
+  --> tests/ui/format_args.rs:126:52
    |
 LL |     println!("{foo}{bar}", bar = "bar", foo = "foo".to_string());
    |                                                    ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:107:37
+  --> tests/ui/format_args.rs:128:37
    |
 LL |     println!("{}", my_other_macro!().to_string());
    |                                     ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> tests/ui/format_args.rs:119:37
+  --> tests/ui/format_args.rs:141:37
    |
 LL |     print!("{}", (Location::caller().to_string()));
    |                                     ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `print!` args
-  --> tests/ui/format_args.rs:120:39
+  --> tests/ui/format_args.rs:143:39
    |
 LL |     print!("{}", ((Location::caller()).to_string()));
    |                                       ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `format!` args
-  --> tests/ui/format_args.rs:148:38
+  --> tests/ui/format_args.rs:172:38
    |
 LL |         let x = format!("{} {}", a, b.to_string());
    |                                      ^^^^^^^^^^^^ help: remove this
 
 error: `to_string` applied to a type that implements `Display` in `println!` args
-  --> tests/ui/format_args.rs:162:24
+  --> tests/ui/format_args.rs:187:24
    |
 LL |         println!("{}", original[..10].to_string());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use this: `&original[..10]`
diff --git a/src/tools/clippy/tests/ui/format_args_unfixable.rs b/src/tools/clippy/tests/ui/format_args_unfixable.rs
index 7590de3751a8..9e1d6a649c35 100644
--- a/src/tools/clippy/tests/ui/format_args_unfixable.rs
+++ b/src/tools/clippy/tests/ui/format_args_unfixable.rs
@@ -2,7 +2,7 @@
 #![allow(unused)]
 #![allow(clippy::assertions_on_constants, clippy::eq_op, clippy::uninlined_format_args)]
 
-use std::io::{Error, ErrorKind, Write, stdout};
+use std::io::{Error, Write, stdout};
 use std::ops::Deref;
 use std::panic::Location;
 
@@ -20,53 +20,68 @@ macro_rules! my_other_macro {
 }
 
 fn main() {
-    let error = Error::new(ErrorKind::Other, "bad thing");
+    let error = Error::other("bad thing");
     let x = 'x';
 
     println!("error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `println!` args
+    //~^ format_in_format_args
+
     println!("{}: {}", error, format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `println!` args
+    //~^ format_in_format_args
+
     println!("{:?}: {}", error, format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `println!` args
+    //~^ format_in_format_args
+
     println!("{{}}: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `println!` args
+    //~^ format_in_format_args
+
     println!(r#"error: "{}""#, format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `println!` args
+    //~^ format_in_format_args
+
     println!("error: {}", format!(r#"something failed at "{}""#, Location::caller()));
-    //~^ ERROR: `format!` in `println!` args
+    //~^ format_in_format_args
+
     println!("error: {}", format!("something failed at {} {0}", Location::caller()));
-    //~^ ERROR: `format!` in `println!` args
+    //~^ format_in_format_args
+
     let _ = format!("error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `format!` args
+    //~^ format_in_format_args
+
     let _ = write!(
-        //~^ ERROR: `format!` in `write!` args
+        //~^ format_in_format_args
         stdout(),
         "error: {}",
         format!("something failed at {}", Location::caller())
     );
     let _ = writeln!(
-        //~^ ERROR: `format!` in `writeln!` args
+        //~^ format_in_format_args
         stdout(),
         "error: {}",
         format!("something failed at {}", Location::caller())
     );
     print!("error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `print!` args
+    //~^ format_in_format_args
+
     eprint!("error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `eprint!` args
+    //~^ format_in_format_args
+
     eprintln!("error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `eprintln!` args
+    //~^ format_in_format_args
+
     let _ = format_args!("error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `format_args!` args
+    //~^ format_in_format_args
+
     assert!(true, "error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `assert!` args
+    //~^ format_in_format_args
+
     assert_eq!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `assert_eq!` args
+    //~^ format_in_format_args
+
     assert_ne!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `assert_ne!` args
+    //~^ format_in_format_args
+
     panic!("error: {}", format!("something failed at {}", Location::caller()));
-    //~^ ERROR: `format!` in `panic!` args
+    //~^ format_in_format_args
 
     // negative tests
     println!("error: {}", format_args!("something failed at {}", Location::caller()));
@@ -100,7 +115,7 @@ macro_rules! my_println2_args {
 }
 
 fn test2() {
-    let error = Error::new(ErrorKind::Other, "bad thing");
+    let error = Error::other("bad thing");
 
     // None of these should be linted without the config change
     my_println2!(true, "error: {}", format!("something failed at {}", Location::caller()));
@@ -130,21 +145,27 @@ macro_rules! usr_println {
 }
 
 fn user_format() {
-    let error = Error::new(ErrorKind::Other, "bad thing");
+    let error = Error::other("bad thing");
     let x = 'x';
 
     usr_println!(true, "error: {}", format!("boom at {}", Location::caller()));
-    //~^ ERROR: `format!` in `usr_println!` args
+    //~^ format_in_format_args
+
     usr_println!(true, "{}: {}", error, format!("boom at {}", Location::caller()));
-    //~^ ERROR: `format!` in `usr_println!` args
+    //~^ format_in_format_args
+
     usr_println!(true, "{:?}: {}", error, format!("boom at {}", Location::caller()));
-    //~^ ERROR: `format!` in `usr_println!` args
+    //~^ format_in_format_args
+
     usr_println!(true, "{{}}: {}", format!("boom at {}", Location::caller()));
-    //~^ ERROR: `format!` in `usr_println!` args
+    //~^ format_in_format_args
+
     usr_println!(true, r#"error: "{}""#, format!("boom at {}", Location::caller()));
-    //~^ ERROR: `format!` in `usr_println!` args
+    //~^ format_in_format_args
+
     usr_println!(true, "error: {}", format!(r#"boom at "{}""#, Location::caller()));
-    //~^ ERROR: `format!` in `usr_println!` args
+    //~^ format_in_format_args
+
     usr_println!(true, "error: {}", format!("boom at {} {0}", Location::caller()));
-    //~^ ERROR: `format!` in `usr_println!` args
+    //~^ format_in_format_args
 }
diff --git a/src/tools/clippy/tests/ui/format_args_unfixable.stderr b/src/tools/clippy/tests/ui/format_args_unfixable.stderr
index 1b4b683fd6c6..1271e80b60a7 100644
--- a/src/tools/clippy/tests/ui/format_args_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/format_args_unfixable.stderr
@@ -10,7 +10,7 @@ LL |     println!("error: {}", format!("something failed at {}", Location::calle
    = help: to override `-D warnings` add `#[allow(clippy::format_in_format_args)]`
 
 error: `format!` in `println!` args
-  --> tests/ui/format_args_unfixable.rs:28:5
+  --> tests/ui/format_args_unfixable.rs:29:5
    |
 LL |     println!("{}: {}", error, format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     println!("{}: {}", error, format!("something failed at {}", Location::c
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `println!` args
-  --> tests/ui/format_args_unfixable.rs:30:5
+  --> tests/ui/format_args_unfixable.rs:32:5
    |
 LL |     println!("{:?}: {}", error, format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     println!("{:?}: {}", error, format!("something failed at {}", Location:
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `println!` args
-  --> tests/ui/format_args_unfixable.rs:32:5
+  --> tests/ui/format_args_unfixable.rs:35:5
    |
 LL |     println!("{{}}: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL |     println!("{{}}: {}", format!("something failed at {}", Location::caller
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `println!` args
-  --> tests/ui/format_args_unfixable.rs:34:5
+  --> tests/ui/format_args_unfixable.rs:38:5
    |
 LL |     println!(r#"error: "{}""#, format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,7 +46,7 @@ LL |     println!(r#"error: "{}""#, format!("something failed at {}", Location::
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `println!` args
-  --> tests/ui/format_args_unfixable.rs:36:5
+  --> tests/ui/format_args_unfixable.rs:41:5
    |
 LL |     println!("error: {}", format!(r#"something failed at "{}""#, Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     println!("error: {}", format!(r#"something failed at "{}""#, Location::
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `println!` args
-  --> tests/ui/format_args_unfixable.rs:38:5
+  --> tests/ui/format_args_unfixable.rs:44:5
    |
 LL |     println!("error: {}", format!("something failed at {} {0}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     println!("error: {}", format!("something failed at {} {0}", Location::c
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `format!` args
-  --> tests/ui/format_args_unfixable.rs:40:13
+  --> tests/ui/format_args_unfixable.rs:47:13
    |
 LL |     let _ = format!("error: {}", format!("something failed at {}", Location::caller()));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     let _ = format!("error: {}", format!("something failed at {}", Location
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `write!` args
-  --> tests/ui/format_args_unfixable.rs:42:13
+  --> tests/ui/format_args_unfixable.rs:50:13
    |
 LL |       let _ = write!(
    |  _____________^
@@ -88,7 +88,7 @@ LL | |     );
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `writeln!` args
-  --> tests/ui/format_args_unfixable.rs:48:13
+  --> tests/ui/format_args_unfixable.rs:56:13
    |
 LL |       let _ = writeln!(
    |  _____________^
@@ -103,7 +103,7 @@ LL | |     );
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `print!` args
-  --> tests/ui/format_args_unfixable.rs:54:5
+  --> tests/ui/format_args_unfixable.rs:62:5
    |
 LL |     print!("error: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL |     print!("error: {}", format!("something failed at {}", Location::caller(
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `eprint!` args
-  --> tests/ui/format_args_unfixable.rs:56:5
+  --> tests/ui/format_args_unfixable.rs:65:5
    |
 LL |     eprint!("error: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     eprint!("error: {}", format!("something failed at {}", Location::caller
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `eprintln!` args
-  --> tests/ui/format_args_unfixable.rs:58:5
+  --> tests/ui/format_args_unfixable.rs:68:5
    |
 LL |     eprintln!("error: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -130,7 +130,7 @@ LL |     eprintln!("error: {}", format!("something failed at {}", Location::call
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `format_args!` args
-  --> tests/ui/format_args_unfixable.rs:60:13
+  --> tests/ui/format_args_unfixable.rs:71:13
    |
 LL |     let _ = format_args!("error: {}", format!("something failed at {}", Location::caller()));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -139,7 +139,7 @@ LL |     let _ = format_args!("error: {}", format!("something failed at {}", Loc
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `assert!` args
-  --> tests/ui/format_args_unfixable.rs:62:5
+  --> tests/ui/format_args_unfixable.rs:74:5
    |
 LL |     assert!(true, "error: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -148,7 +148,7 @@ LL |     assert!(true, "error: {}", format!("something failed at {}", Location::
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `assert_eq!` args
-  --> tests/ui/format_args_unfixable.rs:64:5
+  --> tests/ui/format_args_unfixable.rs:77:5
    |
 LL |     assert_eq!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL |     assert_eq!(0, 0, "error: {}", format!("something failed at {}", Locatio
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `assert_ne!` args
-  --> tests/ui/format_args_unfixable.rs:66:5
+  --> tests/ui/format_args_unfixable.rs:80:5
    |
 LL |     assert_ne!(0, 0, "error: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -166,7 +166,7 @@ LL |     assert_ne!(0, 0, "error: {}", format!("something failed at {}", Locatio
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `panic!` args
-  --> tests/ui/format_args_unfixable.rs:68:5
+  --> tests/ui/format_args_unfixable.rs:83:5
    |
 LL |     panic!("error: {}", format!("something failed at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -175,7 +175,7 @@ LL |     panic!("error: {}", format!("something failed at {}", Location::caller(
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `usr_println!` args
-  --> tests/ui/format_args_unfixable.rs:136:5
+  --> tests/ui/format_args_unfixable.rs:151:5
    |
 LL |     usr_println!(true, "error: {}", format!("boom at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -184,7 +184,7 @@ LL |     usr_println!(true, "error: {}", format!("boom at {}", Location::caller(
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `usr_println!` args
-  --> tests/ui/format_args_unfixable.rs:138:5
+  --> tests/ui/format_args_unfixable.rs:154:5
    |
 LL |     usr_println!(true, "{}: {}", error, format!("boom at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL |     usr_println!(true, "{}: {}", error, format!("boom at {}", Location::cal
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `usr_println!` args
-  --> tests/ui/format_args_unfixable.rs:140:5
+  --> tests/ui/format_args_unfixable.rs:157:5
    |
 LL |     usr_println!(true, "{:?}: {}", error, format!("boom at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -202,7 +202,7 @@ LL |     usr_println!(true, "{:?}: {}", error, format!("boom at {}", Location::c
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `usr_println!` args
-  --> tests/ui/format_args_unfixable.rs:142:5
+  --> tests/ui/format_args_unfixable.rs:160:5
    |
 LL |     usr_println!(true, "{{}}: {}", format!("boom at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -211,7 +211,7 @@ LL |     usr_println!(true, "{{}}: {}", format!("boom at {}", Location::caller()
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `usr_println!` args
-  --> tests/ui/format_args_unfixable.rs:144:5
+  --> tests/ui/format_args_unfixable.rs:163:5
    |
 LL |     usr_println!(true, r#"error: "{}""#, format!("boom at {}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -220,7 +220,7 @@ LL |     usr_println!(true, r#"error: "{}""#, format!("boom at {}", Location::ca
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `usr_println!` args
-  --> tests/ui/format_args_unfixable.rs:146:5
+  --> tests/ui/format_args_unfixable.rs:166:5
    |
 LL |     usr_println!(true, "error: {}", format!(r#"boom at "{}""#, Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL |     usr_println!(true, "error: {}", format!(r#"boom at "{}""#, Location::ca
    = help: or consider changing `format!` to `format_args!`
 
 error: `format!` in `usr_println!` args
-  --> tests/ui/format_args_unfixable.rs:148:5
+  --> tests/ui/format_args_unfixable.rs:169:5
    |
 LL |     usr_println!(true, "error: {}", format!("boom at {} {0}", Location::caller()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/format_collect.rs b/src/tools/clippy/tests/ui/format_collect.rs
index 26ebdc6c0cb6..8f8633a52d86 100644
--- a/src/tools/clippy/tests/ui/format_collect.rs
+++ b/src/tools/clippy/tests/ui/format_collect.rs
@@ -3,13 +3,14 @@
 
 fn hex_encode(bytes: &[u8]) -> String {
     bytes.iter().map(|b| format!("{b:02X}")).collect()
-    //~^ ERROR: use of `format!` to build up a string from an iterator
+    //~^ format_collect
 }
 
 #[rustfmt::skip]
 fn hex_encode_deep(bytes: &[u8]) -> String {
     bytes.iter().map(|b| {{{{{ format!("{b:02X}") }}}}}).collect()
-    //~^ ERROR: use of `format!` to build up a string from an iterator
+    //~^ format_collect
+
 }
 
 macro_rules! fmt {
@@ -24,7 +25,7 @@ fn from_macro(bytes: &[u8]) -> String {
 
 fn with_block() -> String {
     (1..10)
-        //~^ ERROR: use of `format!` to build up a string from an iterator
+        //~^ format_collect
         .map(|s| {
             let y = 1;
             format!("{s} {y}")
diff --git a/src/tools/clippy/tests/ui/format_collect.stderr b/src/tools/clippy/tests/ui/format_collect.stderr
index 863b457a7905..343e38a87b71 100644
--- a/src/tools/clippy/tests/ui/format_collect.stderr
+++ b/src/tools/clippy/tests/ui/format_collect.stderr
@@ -37,7 +37,7 @@ LL |     bytes.iter().map(|b| {{{{{ format!("{b:02X}") }}}}}).collect()
    = note: this can be written more efficiently by appending to a `String` directly
 
 error: use of `format!` to build up a string from an iterator
-  --> tests/ui/format_collect.rs:26:5
+  --> tests/ui/format_collect.rs:27:5
    |
 LL | /     (1..10)
 LL | |
@@ -49,12 +49,12 @@ LL | |         .collect()
    | |__________________^
    |
 help: call `fold` instead
-  --> tests/ui/format_collect.rs:28:10
+  --> tests/ui/format_collect.rs:29:10
    |
 LL |         .map(|s| {
    |          ^^^
 help: ... and use the `write!` macro here
-  --> tests/ui/format_collect.rs:30:13
+  --> tests/ui/format_collect.rs:31:13
    |
 LL |             format!("{s} {y}")
    |             ^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/format_push_string.rs b/src/tools/clippy/tests/ui/format_push_string.rs
index 735ae3393289..056ef59ff0e2 100644
--- a/src/tools/clippy/tests/ui/format_push_string.rs
+++ b/src/tools/clippy/tests/ui/format_push_string.rs
@@ -3,9 +3,10 @@
 fn main() {
     let mut string = String::new();
     string += &format!("{:?}", 1234);
-    //~^ ERROR: `format!(..)` appended to existing `String`
+    //~^ format_push_string
+
     string.push_str(&format!("{:?}", 5678));
-    //~^ ERROR: `format!(..)` appended to existing `String`
+    //~^ format_push_string
 }
 
 mod issue9493 {
@@ -13,7 +14,8 @@ mod issue9493 {
         let mut hex = String::with_capacity(vector.len() * 2);
         for byte in vector {
             hex += &(if upper {
-                //~^ ERROR: `format!(..)` appended to existing `String`
+                //~^ format_push_string
+
                 format!("{byte:02X}")
             } else {
                 format!("{byte:02x}")
@@ -26,14 +28,15 @@ mod issue9493 {
         let mut s = String::new();
         // if let
         s += &(if let Some(_a) = Some(1234) {
-            //~^ ERROR: `format!(..)` appended to existing `String`
+            //~^ format_push_string
+
             format!("{}", 1234)
         } else {
             format!("{}", 1234)
         });
         // match
         s += &(match Some(1234) {
-            //~^ ERROR: `format!(..)` appended to existing `String`
+            //~^ format_push_string
             Some(_) => format!("{}", 1234),
             None => format!("{}", 1234),
         });
diff --git a/src/tools/clippy/tests/ui/format_push_string.stderr b/src/tools/clippy/tests/ui/format_push_string.stderr
index a9520600f52a..bba2a8947c43 100644
--- a/src/tools/clippy/tests/ui/format_push_string.stderr
+++ b/src/tools/clippy/tests/ui/format_push_string.stderr
@@ -9,7 +9,7 @@ LL |     string += &format!("{:?}", 1234);
    = help: to override `-D warnings` add `#[allow(clippy::format_push_string)]`
 
 error: `format!(..)` appended to existing `String`
-  --> tests/ui/format_push_string.rs:7:5
+  --> tests/ui/format_push_string.rs:8:5
    |
 LL |     string.push_str(&format!("{:?}", 5678));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,10 +17,11 @@ LL |     string.push_str(&format!("{:?}", 5678));
    = help: consider using `write!` to avoid the extra allocation
 
 error: `format!(..)` appended to existing `String`
-  --> tests/ui/format_push_string.rs:15:13
+  --> tests/ui/format_push_string.rs:16:13
    |
 LL | /             hex += &(if upper {
 LL | |
+LL | |
 LL | |                 format!("{byte:02X}")
 LL | |             } else {
 LL | |                 format!("{byte:02x}")
@@ -30,10 +31,11 @@ LL | |             });
    = help: consider using `write!` to avoid the extra allocation
 
 error: `format!(..)` appended to existing `String`
-  --> tests/ui/format_push_string.rs:28:9
+  --> tests/ui/format_push_string.rs:30:9
    |
 LL | /         s += &(if let Some(_a) = Some(1234) {
 LL | |
+LL | |
 LL | |             format!("{}", 1234)
 LL | |         } else {
 LL | |             format!("{}", 1234)
@@ -43,7 +45,7 @@ LL | |         });
    = help: consider using `write!` to avoid the extra allocation
 
 error: `format!(..)` appended to existing `String`
-  --> tests/ui/format_push_string.rs:35:9
+  --> tests/ui/format_push_string.rs:38:9
    |
 LL | /         s += &(match Some(1234) {
 LL | |
diff --git a/src/tools/clippy/tests/ui/formatting.rs b/src/tools/clippy/tests/ui/formatting.rs
index 312fa2aa40ad..4e84dcf7d5b7 100644
--- a/src/tools/clippy/tests/ui/formatting.rs
+++ b/src/tools/clippy/tests/ui/formatting.rs
@@ -14,16 +14,19 @@ fn main() {
     // weird op_eq formatting:
     let mut a = 42;
     a =- 35;
-    //~^ ERROR: this looks like you are trying to use `.. -= ..`, but you really are doing
-    //~| NOTE: to remove this lint, use either `-=` or `= -`
+    //~^ suspicious_assignment_formatting
+
+
     a =* &191;
-    //~^ ERROR: this looks like you are trying to use `.. *= ..`, but you really are doing
-    //~| NOTE: to remove this lint, use either `*=` or `= *`
+    //~^ suspicious_assignment_formatting
+
+
 
     let mut b = true;
     b =! false;
-    //~^ ERROR: this looks like you are trying to use `.. != ..`, but you really are doing
-    //~| NOTE: to remove this lint, use either `!=` or `= !`
+    //~^ suspicious_assignment_formatting
+
+
 
     // those are ok:
     a = -35;
@@ -33,14 +36,16 @@ fn main() {
     // possible missing comma in an array
     let _ = &[
         -1, -2, -3 // <= no comma here
-        //~^ ERROR: possibly missing a comma here
-        //~| NOTE: to remove this lint, add a comma or write the expr in a single line
+        //~^ possible_missing_comma
+
+
         -4, -5, -6
     ];
     let _ = &[
         -1, -2, -3 // <= no comma here
-        //~^ ERROR: possibly missing a comma here
-        //~| NOTE: to remove this lint, add a comma or write the expr in a single line
+        //~^ possible_missing_comma
+
+
         *4, -5, -6
     ];
 
@@ -78,8 +83,9 @@ fn main() {
     // lint if it doesn't
     let _ = &[
         -1
-        //~^ ERROR: possibly missing a comma here
-        //~| NOTE: to remove this lint, add a comma or write the expr in a single line
+        //~^ possible_missing_comma
+
+
         -4,
     ];
 }
diff --git a/src/tools/clippy/tests/ui/formatting.stderr b/src/tools/clippy/tests/ui/formatting.stderr
index e823e6512b8d..972bd3a6a2e6 100644
--- a/src/tools/clippy/tests/ui/formatting.stderr
+++ b/src/tools/clippy/tests/ui/formatting.stderr
@@ -9,7 +9,7 @@ LL |     a =- 35;
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_assignment_formatting)]`
 
 error: this looks like you are trying to use `.. *= ..`, but you really are doing `.. = (* ..)`
-  --> tests/ui/formatting.rs:19:6
+  --> tests/ui/formatting.rs:20:6
    |
 LL |     a =* &191;
    |      ^^^^
@@ -17,7 +17,7 @@ LL |     a =* &191;
    = note: to remove this lint, use either `*=` or `= *`
 
 error: this looks like you are trying to use `.. != ..`, but you really are doing `.. = (! ..)`
-  --> tests/ui/formatting.rs:24:6
+  --> tests/ui/formatting.rs:26:6
    |
 LL |     b =! false;
    |      ^^^^
@@ -25,7 +25,7 @@ LL |     b =! false;
    = note: to remove this lint, use either `!=` or `= !`
 
 error: possibly missing a comma here
-  --> tests/ui/formatting.rs:35:19
+  --> tests/ui/formatting.rs:38:19
    |
 LL |         -1, -2, -3 // <= no comma here
    |                   ^
@@ -35,7 +35,7 @@ LL |         -1, -2, -3 // <= no comma here
    = help: to override `-D warnings` add `#[allow(clippy::possible_missing_comma)]`
 
 error: possibly missing a comma here
-  --> tests/ui/formatting.rs:41:19
+  --> tests/ui/formatting.rs:45:19
    |
 LL |         -1, -2, -3 // <= no comma here
    |                   ^
@@ -43,7 +43,7 @@ LL |         -1, -2, -3 // <= no comma here
    = note: to remove this lint, add a comma or write the expr in a single line
 
 error: possibly missing a comma here
-  --> tests/ui/formatting.rs:80:11
+  --> tests/ui/formatting.rs:85:11
    |
 LL |         -1
    |           ^
diff --git a/src/tools/clippy/tests/ui/four_forward_slashes.fixed b/src/tools/clippy/tests/ui/four_forward_slashes.fixed
index 6d31c543d727..6f387b67ccbf 100644
--- a/src/tools/clippy/tests/ui/four_forward_slashes.fixed
+++ b/src/tools/clippy/tests/ui/four_forward_slashes.fixed
@@ -1,4 +1,3 @@
-
 //@aux-build:proc_macros.rs
 #![feature(custom_inner_attributes)]
 #![allow(unused)]
@@ -10,14 +9,17 @@
 extern crate proc_macros;
 
 /// whoops
+//~^ four_forward_slashes
 fn a() {}
 
 /// whoops
+//~^ four_forward_slashes
 #[allow(dead_code)]
 fn b() {}
 
 /// whoops
 /// two borked comments!
+//~^^ four_forward_slashes
 #[track_caller]
 fn c() {}
 
@@ -25,10 +27,12 @@ fn d() {}
 
 #[test]
 /// between attributes
+//~^ four_forward_slashes
 #[allow(dead_code)]
 fn g() {}
 
 /// not very start of contents
+    //~^ four_forward_slashes
 fn h() {}
 
 fn i() {
diff --git a/src/tools/clippy/tests/ui/four_forward_slashes.rs b/src/tools/clippy/tests/ui/four_forward_slashes.rs
index 458b8de53e15..fae07e7d6094 100644
--- a/src/tools/clippy/tests/ui/four_forward_slashes.rs
+++ b/src/tools/clippy/tests/ui/four_forward_slashes.rs
@@ -1,4 +1,3 @@
-
 //@aux-build:proc_macros.rs
 #![feature(custom_inner_attributes)]
 #![allow(unused)]
@@ -10,14 +9,17 @@
 extern crate proc_macros;
 
 //// whoops
+//~^ four_forward_slashes
 fn a() {}
 
 //// whoops
+//~^ four_forward_slashes
 #[allow(dead_code)]
 fn b() {}
 
 //// whoops
 //// two borked comments!
+//~^^ four_forward_slashes
 #[track_caller]
 fn c() {}
 
@@ -25,10 +27,12 @@ fn d() {}
 
 #[test]
 //// between attributes
+//~^ four_forward_slashes
 #[allow(dead_code)]
 fn g() {}
 
     //// not very start of contents
+    //~^ four_forward_slashes
 fn h() {}
 
 fn i() {
diff --git a/src/tools/clippy/tests/ui/four_forward_slashes.stderr b/src/tools/clippy/tests/ui/four_forward_slashes.stderr
index d5bf71fadc7d..95c860b29fba 100644
--- a/src/tools/clippy/tests/ui/four_forward_slashes.stderr
+++ b/src/tools/clippy/tests/ui/four_forward_slashes.stderr
@@ -1,7 +1,8 @@
 error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
-  --> tests/ui/four_forward_slashes.rs:12:1
+  --> tests/ui/four_forward_slashes.rs:11:1
    |
 LL | / //// whoops
+LL | |
 LL | | fn a() {}
    | |_^
    |
@@ -10,7 +11,7 @@ LL | | fn a() {}
 help: make this a doc comment by removing one `/`
    |
 LL - //// whoops
-LL - fn a() {}
+LL -
 LL + /// whoops
    |
 
@@ -18,6 +19,7 @@ error: this item has comments with 4 forward slashes (`////`). These look like d
   --> tests/ui/four_forward_slashes.rs:15:1
    |
 LL | / //// whoops
+LL | |
 LL | | #[allow(dead_code)]
 LL | | fn b() {}
    | |_^
@@ -25,15 +27,16 @@ LL | | fn b() {}
 help: make this a doc comment by removing one `/`
    |
 LL - //// whoops
-LL - #[allow(dead_code)]
+LL -
 LL + /// whoops
    |
 
 error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
-  --> tests/ui/four_forward_slashes.rs:19:1
+  --> tests/ui/four_forward_slashes.rs:20:1
    |
 LL | / //// whoops
 LL | | //// two borked comments!
+LL | |
 LL | | #[track_caller]
 LL | | fn c() {}
    | |_^
@@ -45,9 +48,10 @@ LL ~ /// two borked comments!
    |
 
 error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
-  --> tests/ui/four_forward_slashes.rs:27:1
+  --> tests/ui/four_forward_slashes.rs:29:1
    |
 LL | / //// between attributes
+LL | |
 LL | | #[allow(dead_code)]
 LL | | fn g() {}
    | |_^
@@ -55,21 +59,22 @@ LL | | fn g() {}
 help: make this a doc comment by removing one `/`
    |
 LL - //// between attributes
-LL - #[allow(dead_code)]
+LL -
 LL + /// between attributes
    |
 
 error: this item has comments with 4 forward slashes (`////`). These look like doc comments, but they aren't
-  --> tests/ui/four_forward_slashes.rs:31:1
+  --> tests/ui/four_forward_slashes.rs:34:1
    |
 LL | /     //// not very start of contents
+LL | |
 LL | | fn h() {}
    | |_^
    |
 help: make this a doc comment by removing one `/`
    |
 LL -     //// not very start of contents
-LL - fn h() {}
+LL -
 LL + /// not very start of contents
    |
 
diff --git a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.fixed b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.fixed
index 5ef40015d88b..34604a6461b9 100644
--- a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.fixed
+++ b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.fixed
@@ -1,4 +1,5 @@
 /// borked doc comment on the first line. doesn't combust!
+//~^ four_forward_slashes
 fn a() {}
 
 // This test's entire purpose is to make sure we don't panic if the comment with four slashes
diff --git a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.rs b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.rs
index 9c835e745f65..150e9ba2711c 100644
--- a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.rs
+++ b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.rs
@@ -1,4 +1,5 @@
 //// borked doc comment on the first line. doesn't combust!
+//~^ four_forward_slashes
 fn a() {}
 
 // This test's entire purpose is to make sure we don't panic if the comment with four slashes
diff --git a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr
index 83bfb60eb16f..6fcd3e2c1b73 100644
--- a/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr
+++ b/src/tools/clippy/tests/ui/four_forward_slashes_first_line.stderr
@@ -2,6 +2,7 @@ error: this item has comments with 4 forward slashes (`////`). These look like d
   --> tests/ui/four_forward_slashes_first_line.rs:1:1
    |
 LL | / //// borked doc comment on the first line. doesn't combust!
+LL | |
 LL | | fn a() {}
    | |_^
    |
@@ -10,7 +11,7 @@ LL | | fn a() {}
 help: make this a doc comment by removing one `/`
    |
 LL - //// borked doc comment on the first line. doesn't combust!
-LL - fn a() {}
+LL -
 LL + /// borked doc comment on the first line. doesn't combust!
    |
 
diff --git a/src/tools/clippy/tests/ui/from_iter_instead_of_collect.fixed b/src/tools/clippy/tests/ui/from_iter_instead_of_collect.fixed
index 67da45a348f9..8618004efb89 100644
--- a/src/tools/clippy/tests/ui/from_iter_instead_of_collect.fixed
+++ b/src/tools/clippy/tests/ui/from_iter_instead_of_collect.fixed
@@ -15,46 +15,61 @@ impl FromIterator<bool> for Foo {
 impl<'a> FromIterator<&'a bool> for Foo {
     fn from_iter<T: IntoIterator<Item = &'a bool>>(iter: T) -> Self {
         iter.into_iter().copied().collect::<Self>()
+        //~^ from_iter_instead_of_collect
     }
 }
 
 fn main() {
     let iter_expr = std::iter::repeat(5).take(5);
     let _ = iter_expr.collect::<Vec<_>>();
+    //~^ from_iter_instead_of_collect
 
     let _ = vec![5, 5, 5, 5].iter().enumerate().collect::<HashMap<usize, &i8>>();
+    //~^ from_iter_instead_of_collect
 
     Vec::from_iter(vec![42u32]);
 
     let a = vec![0, 1, 2];
     assert_eq!(a, (0..3).collect::<Vec<_>>());
+    //~^ from_iter_instead_of_collect
     assert_eq!(a, (0..3).collect::<Vec<i32>>());
+    //~^ from_iter_instead_of_collect
 
     let mut b = (0..3).collect::<VecDeque<_>>();
+    //~^ from_iter_instead_of_collect
     b.push_back(4);
 
     let mut b = (0..3).collect::<VecDeque<i32>>();
+    //~^ from_iter_instead_of_collect
     b.push_back(4);
 
     {
         use std::collections;
         let mut b = (0..3).collect::<collections::VecDeque<i32>>();
+        //~^ from_iter_instead_of_collect
         b.push_back(4);
     }
 
     let values = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')];
     let bm = values.iter().cloned().collect::<BTreeMap<_, _>>();
+    //~^ from_iter_instead_of_collect
     let mut bar = bm.range(0..2).collect::<BTreeMap<_, _>>();
+    //~^ from_iter_instead_of_collect
     bar.insert(&4, &'e');
 
     let mut bts = (0..3).collect::<BTreeSet<_>>();
+    //~^ from_iter_instead_of_collect
     bts.insert(2);
     {
         use std::collections;
         let _ = (0..3).collect::<collections::BTreeSet<_>>();
+        //~^ from_iter_instead_of_collect
         let _ = (0..3).collect::<collections::BTreeSet<u32>>();
+        //~^ from_iter_instead_of_collect
     }
 
     for _i in [1, 2, 3].iter().collect::<Vec<_>>() {}
+    //~^ from_iter_instead_of_collect
     for _i in [1, 2, 3].iter().collect::<Vec<&i32>>() {}
+    //~^ from_iter_instead_of_collect
 }
diff --git a/src/tools/clippy/tests/ui/from_iter_instead_of_collect.rs b/src/tools/clippy/tests/ui/from_iter_instead_of_collect.rs
index 423a7454bed7..c46397e8ff56 100644
--- a/src/tools/clippy/tests/ui/from_iter_instead_of_collect.rs
+++ b/src/tools/clippy/tests/ui/from_iter_instead_of_collect.rs
@@ -15,46 +15,61 @@ impl FromIterator<bool> for Foo {
 impl<'a> FromIterator<&'a bool> for Foo {
     fn from_iter<T: IntoIterator<Item = &'a bool>>(iter: T) -> Self {
         <Self as FromIterator<bool>>::from_iter(iter.into_iter().copied())
+        //~^ from_iter_instead_of_collect
     }
 }
 
 fn main() {
     let iter_expr = std::iter::repeat(5).take(5);
     let _ = Vec::from_iter(iter_expr);
+    //~^ from_iter_instead_of_collect
 
     let _ = HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
+    //~^ from_iter_instead_of_collect
 
     Vec::from_iter(vec![42u32]);
 
     let a = vec![0, 1, 2];
     assert_eq!(a, Vec::from_iter(0..3));
+    //~^ from_iter_instead_of_collect
     assert_eq!(a, Vec::<i32>::from_iter(0..3));
+    //~^ from_iter_instead_of_collect
 
     let mut b = VecDeque::from_iter(0..3);
+    //~^ from_iter_instead_of_collect
     b.push_back(4);
 
     let mut b = VecDeque::<i32>::from_iter(0..3);
+    //~^ from_iter_instead_of_collect
     b.push_back(4);
 
     {
         use std::collections;
         let mut b = collections::VecDeque::<i32>::from_iter(0..3);
+        //~^ from_iter_instead_of_collect
         b.push_back(4);
     }
 
     let values = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'd')];
     let bm = BTreeMap::from_iter(values.iter().cloned());
+    //~^ from_iter_instead_of_collect
     let mut bar = BTreeMap::from_iter(bm.range(0..2));
+    //~^ from_iter_instead_of_collect
     bar.insert(&4, &'e');
 
     let mut bts = BTreeSet::from_iter(0..3);
+    //~^ from_iter_instead_of_collect
     bts.insert(2);
     {
         use std::collections;
         let _ = collections::BTreeSet::from_iter(0..3);
+        //~^ from_iter_instead_of_collect
         let _ = collections::BTreeSet::<u32>::from_iter(0..3);
+        //~^ from_iter_instead_of_collect
     }
 
     for _i in Vec::from_iter([1, 2, 3].iter()) {}
+    //~^ from_iter_instead_of_collect
     for _i in Vec::<&i32>::from_iter([1, 2, 3].iter()) {}
+    //~^ from_iter_instead_of_collect
 }
diff --git a/src/tools/clippy/tests/ui/from_iter_instead_of_collect.stderr b/src/tools/clippy/tests/ui/from_iter_instead_of_collect.stderr
index 0824a526b793..b46d97af152f 100644
--- a/src/tools/clippy/tests/ui/from_iter_instead_of_collect.stderr
+++ b/src/tools/clippy/tests/ui/from_iter_instead_of_collect.stderr
@@ -8,85 +8,85 @@ LL |         <Self as FromIterator<bool>>::from_iter(iter.into_iter().copied())
    = help: to override `-D warnings` add `#[allow(clippy::from_iter_instead_of_collect)]`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:23:13
+  --> tests/ui/from_iter_instead_of_collect.rs:24:13
    |
 LL |     let _ = Vec::from_iter(iter_expr);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `iter_expr.collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:25:13
+  --> tests/ui/from_iter_instead_of_collect.rs:27:13
    |
 LL |     let _ = HashMap::<usize, &i8>::from_iter(vec![5, 5, 5, 5].iter().enumerate());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `vec![5, 5, 5, 5].iter().enumerate().collect::<HashMap<usize, &i8>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:30:19
+  --> tests/ui/from_iter_instead_of_collect.rs:33:19
    |
 LL |     assert_eq!(a, Vec::from_iter(0..3));
    |                   ^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:31:19
+  --> tests/ui/from_iter_instead_of_collect.rs:35:19
    |
 LL |     assert_eq!(a, Vec::<i32>::from_iter(0..3));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<Vec<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:33:17
+  --> tests/ui/from_iter_instead_of_collect.rs:38:17
    |
 LL |     let mut b = VecDeque::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:36:17
+  --> tests/ui/from_iter_instead_of_collect.rs:42:17
    |
 LL |     let mut b = VecDeque::<i32>::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<VecDeque<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:41:21
+  --> tests/ui/from_iter_instead_of_collect.rs:48:21
    |
 LL |         let mut b = collections::VecDeque::<i32>::from_iter(0..3);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::VecDeque<i32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:46:14
+  --> tests/ui/from_iter_instead_of_collect.rs:54:14
    |
 LL |     let bm = BTreeMap::from_iter(values.iter().cloned());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `values.iter().cloned().collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:47:19
+  --> tests/ui/from_iter_instead_of_collect.rs:56:19
    |
 LL |     let mut bar = BTreeMap::from_iter(bm.range(0..2));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `bm.range(0..2).collect::<BTreeMap<_, _>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:50:19
+  --> tests/ui/from_iter_instead_of_collect.rs:60:19
    |
 LL |     let mut bts = BTreeSet::from_iter(0..3);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<BTreeSet<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:54:17
+  --> tests/ui/from_iter_instead_of_collect.rs:65:17
    |
 LL |         let _ = collections::BTreeSet::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:55:17
+  --> tests/ui/from_iter_instead_of_collect.rs:67:17
    |
 LL |         let _ = collections::BTreeSet::<u32>::from_iter(0..3);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `(0..3).collect::<collections::BTreeSet<u32>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:58:15
+  --> tests/ui/from_iter_instead_of_collect.rs:71:15
    |
 LL |     for _i in Vec::from_iter([1, 2, 3].iter()) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<_>>()`
 
 error: usage of `FromIterator::from_iter`
-  --> tests/ui/from_iter_instead_of_collect.rs:59:15
+  --> tests/ui/from_iter_instead_of_collect.rs:73:15
    |
 LL |     for _i in Vec::<&i32>::from_iter([1, 2, 3].iter()) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `.collect()` instead of `::from_iter()`: `[1, 2, 3].iter().collect::<Vec<&i32>>()`
diff --git a/src/tools/clippy/tests/ui/from_over_into.fixed b/src/tools/clippy/tests/ui/from_over_into.fixed
index a33c1ea5738b..7d6780a0e02c 100644
--- a/src/tools/clippy/tests/ui/from_over_into.fixed
+++ b/src/tools/clippy/tests/ui/from_over_into.fixed
@@ -7,6 +7,7 @@
 struct StringWrapper(String);
 
 impl From<String> for StringWrapper {
+    //~^ from_over_into
     fn from(val: String) -> Self {
         StringWrapper(val)
     }
@@ -15,6 +16,7 @@ impl From<String> for StringWrapper {
 struct SelfType(String);
 
 impl From<String> for SelfType {
+    //~^ from_over_into
     fn from(val: String) -> Self {
         SelfType(String::new())
     }
@@ -30,6 +32,7 @@ impl X {
 struct SelfKeywords;
 
 impl From<X> for SelfKeywords {
+    //~^ from_over_into
     fn from(val: X) -> Self {
         let _ = X;
         let _ = X::FOO;
@@ -42,6 +45,7 @@ impl From<X> for SelfKeywords {
 struct ExplicitPaths(bool);
 
 impl core::convert::From<crate::ExplicitPaths> for bool {
+    //~^ from_over_into
     fn from(mut val: crate::ExplicitPaths) -> Self {
         let in_closure = || val.0;
 
@@ -62,6 +66,7 @@ impl From<String> for A {
 struct PathInExpansion;
 
 impl From<PathInExpansion> for String {
+    //~^ from_over_into
     fn from(val: PathInExpansion) -> Self {
         // non self/Self paths in expansions are fine
         panic!()
@@ -84,6 +89,7 @@ fn msrv_1_41() {
     struct FromOverInto<T>(Vec<T>);
 
     impl<T> From<Vec<T>> for FromOverInto<T> {
+        //~^ from_over_into
         fn from(val: Vec<T>) -> Self {
             FromOverInto(val)
         }
@@ -94,6 +100,7 @@ fn issue_12138() {
     struct Hello;
 
     impl From<Hello> for () {
+        //~^ from_over_into
         fn from(val: Hello) {}
     }
 }
diff --git a/src/tools/clippy/tests/ui/from_over_into.rs b/src/tools/clippy/tests/ui/from_over_into.rs
index 6cd811ae401e..387ddde359c1 100644
--- a/src/tools/clippy/tests/ui/from_over_into.rs
+++ b/src/tools/clippy/tests/ui/from_over_into.rs
@@ -7,6 +7,7 @@
 struct StringWrapper(String);
 
 impl Into<StringWrapper> for String {
+    //~^ from_over_into
     fn into(self) -> StringWrapper {
         StringWrapper(self)
     }
@@ -15,6 +16,7 @@ impl Into<StringWrapper> for String {
 struct SelfType(String);
 
 impl Into<SelfType> for String {
+    //~^ from_over_into
     fn into(self) -> SelfType {
         SelfType(Self::new())
     }
@@ -30,6 +32,7 @@ impl X {
 struct SelfKeywords;
 
 impl Into<SelfKeywords> for X {
+    //~^ from_over_into
     fn into(self) -> SelfKeywords {
         let _ = Self;
         let _ = Self::FOO;
@@ -42,6 +45,7 @@ impl Into<SelfKeywords> for X {
 struct ExplicitPaths(bool);
 
 impl core::convert::Into<bool> for crate::ExplicitPaths {
+    //~^ from_over_into
     fn into(mut self) -> bool {
         let in_closure = || self.0;
 
@@ -62,6 +66,7 @@ impl From<String> for A {
 struct PathInExpansion;
 
 impl Into<String> for PathInExpansion {
+    //~^ from_over_into
     fn into(self) -> String {
         // non self/Self paths in expansions are fine
         panic!()
@@ -84,6 +89,7 @@ fn msrv_1_41() {
     struct FromOverInto<T>(Vec<T>);
 
     impl<T> Into<FromOverInto<T>> for Vec<T> {
+        //~^ from_over_into
         fn into(self) -> FromOverInto<T> {
             FromOverInto(self)
         }
@@ -94,6 +100,7 @@ fn issue_12138() {
     struct Hello;
 
     impl Into<()> for Hello {
+        //~^ from_over_into
         fn into(self) {}
     }
 }
diff --git a/src/tools/clippy/tests/ui/from_over_into.stderr b/src/tools/clippy/tests/ui/from_over_into.stderr
index f913ae0bb506..a564bccbaf71 100644
--- a/src/tools/clippy/tests/ui/from_over_into.stderr
+++ b/src/tools/clippy/tests/ui/from_over_into.stderr
@@ -9,12 +9,13 @@ LL | impl Into<StringWrapper> for String {
 help: replace the `Into` implementation with `From<std::string::String>`
    |
 LL ~ impl From<String> for StringWrapper {
+LL |
 LL ~     fn from(val: String) -> Self {
 LL ~         StringWrapper(val)
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into.rs:17:1
+  --> tests/ui/from_over_into.rs:18:1
    |
 LL | impl Into<SelfType> for String {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,12 +23,13 @@ LL | impl Into<SelfType> for String {
 help: replace the `Into` implementation with `From<std::string::String>`
    |
 LL ~ impl From<String> for SelfType {
+LL |
 LL ~     fn from(val: String) -> Self {
 LL ~         SelfType(String::new())
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into.rs:32:1
+  --> tests/ui/from_over_into.rs:34:1
    |
 LL | impl Into<SelfKeywords> for X {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -35,6 +37,7 @@ LL | impl Into<SelfKeywords> for X {
 help: replace the `Into` implementation with `From<X>`
    |
 LL ~ impl From<X> for SelfKeywords {
+LL |
 LL ~     fn from(val: X) -> Self {
 LL ~         let _ = X;
 LL ~         let _ = X::FOO;
@@ -42,7 +45,7 @@ LL ~         let _: X = val;
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into.rs:44:1
+  --> tests/ui/from_over_into.rs:47:1
    |
 LL | impl core::convert::Into<bool> for crate::ExplicitPaths {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,6 +55,7 @@ LL | impl core::convert::Into<bool> for crate::ExplicitPaths {
 help: replace the `Into` implementation with `From<ExplicitPaths>`
    |
 LL ~ impl core::convert::From<crate::ExplicitPaths> for bool {
+LL |
 LL ~     fn from(mut val: crate::ExplicitPaths) -> Self {
 LL ~         let in_closure = || val.0;
 LL |
@@ -60,7 +64,7 @@ LL ~         val.0
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into.rs:64:1
+  --> tests/ui/from_over_into.rs:68:1
    |
 LL | impl Into<String> for PathInExpansion {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -70,11 +74,12 @@ LL | impl Into<String> for PathInExpansion {
 help: replace the `Into` implementation with `From<PathInExpansion>`
    |
 LL ~ impl From<PathInExpansion> for String {
+LL |
 LL ~     fn from(val: PathInExpansion) -> Self {
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into.rs:86:5
+  --> tests/ui/from_over_into.rs:91:5
    |
 LL |     impl<T> Into<FromOverInto<T>> for Vec<T> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -82,12 +87,13 @@ LL |     impl<T> Into<FromOverInto<T>> for Vec<T> {
 help: replace the `Into` implementation with `From<std::vec::Vec<T>>`
    |
 LL ~     impl<T> From<Vec<T>> for FromOverInto<T> {
+LL |
 LL ~         fn from(val: Vec<T>) -> Self {
 LL ~             FromOverInto(val)
    |
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into.rs:96:5
+  --> tests/ui/from_over_into.rs:102:5
    |
 LL |     impl Into<()> for Hello {
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,6 +103,7 @@ LL |     impl Into<()> for Hello {
 help: replace the `Into` implementation with `From<issue_12138::Hello>`
    |
 LL ~     impl From<Hello> for () {
+LL |
 LL ~         fn from(val: Hello) {}
    |
 
diff --git a/src/tools/clippy/tests/ui/from_over_into_unfixable.rs b/src/tools/clippy/tests/ui/from_over_into_unfixable.rs
index 0c1f39f93fd3..de90c7c21a65 100644
--- a/src/tools/clippy/tests/ui/from_over_into_unfixable.rs
+++ b/src/tools/clippy/tests/ui/from_over_into_unfixable.rs
@@ -9,7 +9,8 @@ macro_rules! in_macro {
 }
 
 impl Into<InMacro> for String {
-    //~^ ERROR: an implementation of `From` is preferred since it gives you `Into<_>` for free
+    //~^ from_over_into
+
     fn into(self) -> InMacro {
         InMacro(in_macro!())
     }
@@ -18,7 +19,8 @@ impl Into<InMacro> for String {
 struct WeirdUpperSelf;
 
 impl Into<WeirdUpperSelf> for &'static [u8] {
-    //~^ ERROR: an implementation of `From` is preferred since it gives you `Into<_>` for free
+    //~^ from_over_into
+
     fn into(self) -> WeirdUpperSelf {
         let _ = Self::default();
         WeirdUpperSelf
@@ -28,7 +30,8 @@ impl Into<WeirdUpperSelf> for &'static [u8] {
 struct ContainsVal;
 
 impl Into<u8> for ContainsVal {
-    //~^ ERROR: an implementation of `From` is preferred since it gives you `Into<_>` for free
+    //~^ from_over_into
+
     fn into(self) -> u8 {
         let val = 1;
         val + 1
@@ -40,7 +43,8 @@ pub struct Lval<T>(T);
 pub struct Rval<T>(T);
 
 impl<T> Into<Rval<Self>> for Lval<T> {
-    //~^ ERROR: an implementation of `From` is preferred since it gives you `Into<_>` for free
+    //~^ from_over_into
+
     fn into(self) -> Rval<Self> {
         Rval(self)
     }
diff --git a/src/tools/clippy/tests/ui/from_over_into_unfixable.stderr b/src/tools/clippy/tests/ui/from_over_into_unfixable.stderr
index 1776b86e40dd..0e9264a153bb 100644
--- a/src/tools/clippy/tests/ui/from_over_into_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/from_over_into_unfixable.stderr
@@ -9,7 +9,7 @@ LL | impl Into<InMacro> for String {
    = help: to override `-D warnings` add `#[allow(clippy::from_over_into)]`
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into_unfixable.rs:20:1
+  --> tests/ui/from_over_into_unfixable.rs:21:1
    |
 LL | impl Into<WeirdUpperSelf> for &'static [u8] {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | impl Into<WeirdUpperSelf> for &'static [u8] {
    = help: replace the `Into` implementation with `From<&'static [u8]>`
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into_unfixable.rs:30:1
+  --> tests/ui/from_over_into_unfixable.rs:32:1
    |
 LL | impl Into<u8> for ContainsVal {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -27,7 +27,7 @@ LL | impl Into<u8> for ContainsVal {
    = help: replace the `Into` implementation with `From<ContainsVal>`
 
 error: an implementation of `From` is preferred since it gives you `Into<_>` for free where the reverse isn't true
-  --> tests/ui/from_over_into_unfixable.rs:42:1
+  --> tests/ui/from_over_into_unfixable.rs:45:1
    |
 LL | impl<T> Into<Rval<Self>> for Lval<T> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/from_raw_with_void_ptr.rs b/src/tools/clippy/tests/ui/from_raw_with_void_ptr.rs
index 81472070eb4c..390313884433 100644
--- a/src/tools/clippy/tests/ui/from_raw_with_void_ptr.rs
+++ b/src/tools/clippy/tests/ui/from_raw_with_void_ptr.rs
@@ -9,7 +9,7 @@ fn main() {
     // must lint
     let ptr = Box::into_raw(Box::new(42usize)) as *mut c_void;
     let _ = unsafe { Box::from_raw(ptr) };
-    //~^ ERROR: creating a `Box` from a void raw pointer
+    //~^ from_raw_with_void_ptr
 
     // shouldn't be linted
     let _ = unsafe { Box::from_raw(ptr as *mut usize) };
@@ -21,20 +21,20 @@ fn main() {
     // must lint
     let ptr = Rc::into_raw(Rc::new(42usize)) as *mut c_void;
     let _ = unsafe { Rc::from_raw(ptr) };
-    //~^ ERROR: creating a `Rc` from a void raw pointer
+    //~^ from_raw_with_void_ptr
 
     // must lint
     let ptr = Arc::into_raw(Arc::new(42usize)) as *mut c_void;
     let _ = unsafe { Arc::from_raw(ptr) };
-    //~^ ERROR: creating a `Arc` from a void raw pointer
+    //~^ from_raw_with_void_ptr
 
     // must lint
     let ptr = std::rc::Weak::into_raw(Rc::downgrade(&Rc::new(42usize))) as *mut c_void;
     let _ = unsafe { std::rc::Weak::from_raw(ptr) };
-    //~^ ERROR: creating a `Weak` from a void raw pointer
+    //~^ from_raw_with_void_ptr
 
     // must lint
     let ptr = std::sync::Weak::into_raw(Arc::downgrade(&Arc::new(42usize))) as *mut c_void;
     let _ = unsafe { std::sync::Weak::from_raw(ptr) };
-    //~^ ERROR: creating a `Weak` from a void raw pointer
+    //~^ from_raw_with_void_ptr
 }
diff --git a/src/tools/clippy/tests/ui/from_str_radix_10.fixed b/src/tools/clippy/tests/ui/from_str_radix_10.fixed
index 6c582190b442..4b8fd778685e 100644
--- a/src/tools/clippy/tests/ui/from_str_radix_10.fixed
+++ b/src/tools/clippy/tests/ui/from_str_radix_10.fixed
@@ -26,26 +26,30 @@ impl std::ops::Add<Test> for Test {
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // all of these should trigger the lint
     "30".parse::<u32>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
-    //~| NOTE: `-D clippy::from-str-radix-10` implied by `-D warnings`
+    //~^ from_str_radix_10
+
     "24".parse::<i64>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     "100".parse::<isize>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     "7".parse::<u8>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     ("10".to_owned() + "5").parse::<u16>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     (Test + Test).parse::<i128>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
 
     let string = "300";
     string.parse::<i32>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
 
     let stringier = "400".to_string();
     stringier.parse::<i32>()?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
 
     // none of these should trigger the lint
     u16::from_str_radix("20", 3)?;
diff --git a/src/tools/clippy/tests/ui/from_str_radix_10.rs b/src/tools/clippy/tests/ui/from_str_radix_10.rs
index 0df6a0a202ae..89002b11a995 100644
--- a/src/tools/clippy/tests/ui/from_str_radix_10.rs
+++ b/src/tools/clippy/tests/ui/from_str_radix_10.rs
@@ -26,26 +26,30 @@ impl std::ops::Add<Test> for Test {
 fn main() -> Result<(), Box<dyn std::error::Error>> {
     // all of these should trigger the lint
     u32::from_str_radix("30", 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
-    //~| NOTE: `-D clippy::from-str-radix-10` implied by `-D warnings`
+    //~^ from_str_radix_10
+
     i64::from_str_radix("24", 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     isize::from_str_radix("100", 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     u8::from_str_radix("7", 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     u16::from_str_radix(&("10".to_owned() + "5"), 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
+
     i128::from_str_radix(Test + Test, 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
 
     let string = "300";
     i32::from_str_radix(string, 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
 
     let stringier = "400".to_string();
     i32::from_str_radix(&stringier, 10)?;
-    //~^ ERROR: this call to `from_str_radix` can be replaced with a call to `str::parse`
+    //~^ from_str_radix_10
 
     // none of these should trigger the lint
     u16::from_str_radix("20", 3)?;
diff --git a/src/tools/clippy/tests/ui/from_str_radix_10.stderr b/src/tools/clippy/tests/ui/from_str_radix_10.stderr
index 4aa84eca2612..c693e8f50ff6 100644
--- a/src/tools/clippy/tests/ui/from_str_radix_10.stderr
+++ b/src/tools/clippy/tests/ui/from_str_radix_10.stderr
@@ -14,37 +14,37 @@ LL |     i64::from_str_radix("24", 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"24".parse::<i64>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> tests/ui/from_str_radix_10.rs:33:5
+  --> tests/ui/from_str_radix_10.rs:34:5
    |
 LL |     isize::from_str_radix("100", 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"100".parse::<isize>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> tests/ui/from_str_radix_10.rs:35:5
+  --> tests/ui/from_str_radix_10.rs:37:5
    |
 LL |     u8::from_str_radix("7", 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"7".parse::<u8>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> tests/ui/from_str_radix_10.rs:37:5
+  --> tests/ui/from_str_radix_10.rs:40:5
    |
 LL |     u16::from_str_radix(&("10".to_owned() + "5"), 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `("10".to_owned() + "5").parse::<u16>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> tests/ui/from_str_radix_10.rs:39:5
+  --> tests/ui/from_str_radix_10.rs:43:5
    |
 LL |     i128::from_str_radix(Test + Test, 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(Test + Test).parse::<i128>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> tests/ui/from_str_radix_10.rs:43:5
+  --> tests/ui/from_str_radix_10.rs:47:5
    |
 LL |     i32::from_str_radix(string, 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.parse::<i32>()`
 
 error: this call to `from_str_radix` can be replaced with a call to `str::parse`
-  --> tests/ui/from_str_radix_10.rs:47:5
+  --> tests/ui/from_str_radix_10.rs:51:5
    |
 LL |     i32::from_str_radix(&stringier, 10)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `stringier.parse::<i32>()`
diff --git a/src/tools/clippy/tests/ui/functions.rs b/src/tools/clippy/tests/ui/functions.rs
index 0aef60959593..9c1ca8bf9300 100644
--- a/src/tools/clippy/tests/ui/functions.rs
+++ b/src/tools/clippy/tests/ui/functions.rs
@@ -6,12 +6,12 @@
 fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
 
 fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
-//~^ ERROR: this function has too many arguments (8/7)
-//~| NOTE: `-D clippy::too-many-arguments` implied by `-D warnings`
+//~^ too_many_arguments
 
 #[rustfmt::skip]
 fn bad_multiline(
-//~^ ERROR: this function has too many arguments (8/7)
+//~^ too_many_arguments
+
     one: u32,
     two: u32,
     three: &str,
@@ -46,7 +46,7 @@ extern "C" fn extern_fn(
 pub trait Foo {
     fn good(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool);
     fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ());
-    //~^ ERROR: this function has too many arguments (8/7)
+    //~^ too_many_arguments
 
     fn ptr(p: *const u8);
 }
@@ -56,7 +56,7 @@ pub struct Bar;
 impl Bar {
     fn good_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool) {}
     fn bad_method(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f32, _seven: bool, _eight: ()) {}
-    //~^ ERROR: this function has too many arguments (8/7)
+    //~^ too_many_arguments
 }
 
 // ok, we don’t want to warn implementations
@@ -66,12 +66,13 @@ impl Foo for Bar {
 
     fn ptr(p: *const u8) {
         println!("{}", unsafe { *p });
-        //~^ ERROR: this public function might dereference a raw pointer but is not marked
-        //~| NOTE: `-D clippy::not-unsafe-ptr-arg-deref` implied by `-D warnings`
+        //~^ not_unsafe_ptr_arg_deref
+
         println!("{:?}", unsafe { p.as_ref() });
-        //~^ ERROR: this public function might dereference a raw pointer but is not marked
+        //~^ not_unsafe_ptr_arg_deref
+
         unsafe { std::ptr::read(p) };
-        //~^ ERROR: this public function might dereference a raw pointer but is not marked
+        //~^ not_unsafe_ptr_arg_deref
     }
 }
 
@@ -83,22 +84,26 @@ fn private(p: *const u8) {
 
 pub fn public(p: *const u8) {
     println!("{}", unsafe { *p });
-    //~^ ERROR: this public function might dereference a raw pointer but is not marked `un
+    //~^ not_unsafe_ptr_arg_deref
+
     println!("{:?}", unsafe { p.as_ref() });
-    //~^ ERROR: this public function might dereference a raw pointer but is not marked `un
+    //~^ not_unsafe_ptr_arg_deref
+
     unsafe { std::ptr::read(p) };
-    //~^ ERROR: this public function might dereference a raw pointer but is not marked `un
+    //~^ not_unsafe_ptr_arg_deref
 }
 
 type Alias = *const u8;
 
 pub fn type_alias(p: Alias) {
     println!("{}", unsafe { *p });
-    //~^ ERROR: this public function might dereference a raw pointer but is not marked `un
+    //~^ not_unsafe_ptr_arg_deref
+
     println!("{:?}", unsafe { p.as_ref() });
-    //~^ ERROR: this public function might dereference a raw pointer but is not marked `un
+    //~^ not_unsafe_ptr_arg_deref
+
     unsafe { std::ptr::read(p) };
-    //~^ ERROR: this public function might dereference a raw pointer but is not marked `un
+    //~^ not_unsafe_ptr_arg_deref
 }
 
 impl Bar {
@@ -108,11 +113,13 @@ impl Bar {
 
     pub fn public(self, p: *const u8) {
         println!("{}", unsafe { *p });
-        //~^ ERROR: this public function might dereference a raw pointer but is not marked
+        //~^ not_unsafe_ptr_arg_deref
+
         println!("{:?}", unsafe { p.as_ref() });
-        //~^ ERROR: this public function might dereference a raw pointer but is not marked
+        //~^ not_unsafe_ptr_arg_deref
+
         unsafe { std::ptr::read(p) };
-        //~^ ERROR: this public function might dereference a raw pointer but is not marked
+        //~^ not_unsafe_ptr_arg_deref
     }
 
     pub fn public_ok(self, p: *const u8) {
diff --git a/src/tools/clippy/tests/ui/functions.stderr b/src/tools/clippy/tests/ui/functions.stderr
index 8fdceb8d8cd0..c8770023f77a 100644
--- a/src/tools/clippy/tests/ui/functions.stderr
+++ b/src/tools/clippy/tests/ui/functions.stderr
@@ -8,12 +8,12 @@ LL | fn bad(_one: u32, _two: u32, _three: &str, _four: bool, _five: f32, _six: f
    = help: to override `-D warnings` add `#[allow(clippy::too_many_arguments)]`
 
 error: this function has too many arguments (8/7)
-  --> tests/ui/functions.rs:13:1
+  --> tests/ui/functions.rs:12:1
    |
 LL | / fn bad_multiline(
 LL | |
+LL | |
 LL | |     one: u32,
-LL | |     two: u32,
 ...  |
 LL | |     eight: ()
 LL | | ) {
@@ -47,61 +47,61 @@ LL |         println!("{:?}", unsafe { p.as_ref() });
    |                                   ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:73:33
+  --> tests/ui/functions.rs:74:33
    |
 LL |         unsafe { std::ptr::read(p) };
    |                                 ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:85:30
+  --> tests/ui/functions.rs:86:30
    |
 LL |     println!("{}", unsafe { *p });
    |                              ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:87:31
+  --> tests/ui/functions.rs:89:31
    |
 LL |     println!("{:?}", unsafe { p.as_ref() });
    |                               ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:89:29
+  --> tests/ui/functions.rs:92:29
    |
 LL |     unsafe { std::ptr::read(p) };
    |                             ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:96:30
+  --> tests/ui/functions.rs:99:30
    |
 LL |     println!("{}", unsafe { *p });
    |                              ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:98:31
+  --> tests/ui/functions.rs:102:31
    |
 LL |     println!("{:?}", unsafe { p.as_ref() });
    |                               ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:100:29
+  --> tests/ui/functions.rs:105:29
    |
 LL |     unsafe { std::ptr::read(p) };
    |                             ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:110:34
+  --> tests/ui/functions.rs:115:34
    |
 LL |         println!("{}", unsafe { *p });
    |                                  ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:112:35
+  --> tests/ui/functions.rs:118:35
    |
 LL |         println!("{:?}", unsafe { p.as_ref() });
    |                                   ^
 
 error: this public function might dereference a raw pointer but is not marked `unsafe`
-  --> tests/ui/functions.rs:114:33
+  --> tests/ui/functions.rs:121:33
    |
 LL |         unsafe { std::ptr::read(p) };
    |                                 ^
diff --git a/src/tools/clippy/tests/ui/functions_maxlines.rs b/src/tools/clippy/tests/ui/functions_maxlines.rs
index a3496f56d4a6..e0990dadaaa9 100644
--- a/src/tools/clippy/tests/ui/functions_maxlines.rs
+++ b/src/tools/clippy/tests/ui/functions_maxlines.rs
@@ -56,8 +56,8 @@ fn good_lines() {
 }
 
 fn bad_lines() {
-    //~^ ERROR: this function has too many lines (102/100)
-    //~| NOTE: `-D clippy::too-many-lines` implied by `-D warnings`
+    //~^ too_many_lines
+
     println!("Dont get confused by braces: {{}}");
     println!("This is bad.");
     println!("This is bad.");
diff --git a/src/tools/clippy/tests/ui/future_not_send.rs b/src/tools/clippy/tests/ui/future_not_send.rs
index 626ee6de9e4f..662ecb9c955d 100644
--- a/src/tools/clippy/tests/ui/future_not_send.rs
+++ b/src/tools/clippy/tests/ui/future_not_send.rs
@@ -6,12 +6,14 @@ use std::rc::Rc;
 use std::sync::Arc;
 
 async fn private_future(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
-    //~^ ERROR: future cannot be sent between threads safely
+    //~^ future_not_send
+
     async { true }.await
 }
 
 pub async fn public_future(rc: Rc<[u8]>) {
-    //~^ ERROR: future cannot be sent between threads safely
+    //~^ future_not_send
+
     async { true }.await;
 }
 
@@ -20,12 +22,13 @@ pub async fn public_send(arc: Arc<[u8]>) -> bool {
 }
 
 async fn private_future2(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
-    //~^ ERROR: future cannot be sent between threads safely
+    //~^ future_not_send
+
     true
 }
 
 pub async fn public_future2(rc: Rc<[u8]>) {}
-//~^ ERROR: future cannot be sent between threads safely
+//~^ future_not_send
 
 pub async fn public_send2(arc: Arc<[u8]>) -> bool {
     false
@@ -37,13 +40,15 @@ struct Dummy {
 
 impl Dummy {
     async fn private_future(&self) -> usize {
-        //~^ ERROR: future cannot be sent between threads safely
+        //~^ future_not_send
+
         async { true }.await;
         self.rc.len()
     }
 
     pub async fn public_future(&self) {
-        //~^ ERROR: future cannot be sent between threads safely
+        //~^ future_not_send
+
         self.private_future().await;
     }
 
@@ -54,7 +59,7 @@ impl Dummy {
 }
 
 async fn generic_future<T>(t: T) -> T
-//~^ ERROR: future cannot be sent between threads safely
+//~^ future_not_send
 where
     T: Send,
 {
@@ -76,7 +81,8 @@ async fn maybe_send_generic_future2<F: Fn() -> Fut, Fut: Future>(f: F) {
 }
 
 async fn generic_future_always_unsend<T>(_: Rc<T>) {
-    //~^ ERROR: future cannot be sent between threads safely
+    //~^ future_not_send
+
     async { true }.await;
 }
 
diff --git a/src/tools/clippy/tests/ui/future_not_send.stderr b/src/tools/clippy/tests/ui/future_not_send.stderr
index 3807c7470136..e366dc2d2195 100644
--- a/src/tools/clippy/tests/ui/future_not_send.stderr
+++ b/src/tools/clippy/tests/ui/future_not_send.stderr
@@ -5,11 +5,11 @@ LL | async fn private_future(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `private_future` is not `Send`
    |
 note: future is not `Send` as this value is used across an await
-  --> tests/ui/future_not_send.rs:10:20
+  --> tests/ui/future_not_send.rs:11:20
    |
 LL | async fn private_future(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
    |                         -- has type `std::rc::Rc<[u8]>` which is not `Send`
-LL |
+...
 LL |     async { true }.await
    |                    ^^^^^ await occurs here, with `rc` maybe used later
    = note: `std::rc::Rc<[u8]>` doesn't implement `std::marker::Send`
@@ -23,84 +23,84 @@ LL | async fn private_future(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
    = help: to override `-D warnings` add `#[allow(clippy::future_not_send)]`
 
 error: future cannot be sent between threads safely
-  --> tests/ui/future_not_send.rs:13:1
+  --> tests/ui/future_not_send.rs:14:1
    |
 LL | pub async fn public_future(rc: Rc<[u8]>) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `public_future` is not `Send`
    |
 note: future is not `Send` as this value is used across an await
-  --> tests/ui/future_not_send.rs:15:20
+  --> tests/ui/future_not_send.rs:17:20
    |
 LL | pub async fn public_future(rc: Rc<[u8]>) {
    |                            -- has type `std::rc::Rc<[u8]>` which is not `Send`
-LL |
+...
 LL |     async { true }.await;
    |                    ^^^^^ await occurs here, with `rc` maybe used later
    = note: `std::rc::Rc<[u8]>` doesn't implement `std::marker::Send`
 
 error: future cannot be sent between threads safely
-  --> tests/ui/future_not_send.rs:22:1
+  --> tests/ui/future_not_send.rs:24:1
    |
 LL | async fn private_future2(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `private_future2` is not `Send`
    |
 note: captured value is not `Send`
-  --> tests/ui/future_not_send.rs:22:26
+  --> tests/ui/future_not_send.rs:24:26
    |
 LL | async fn private_future2(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
    |                          ^^ has type `std::rc::Rc<[u8]>` which is not `Send`
    = note: `std::rc::Rc<[u8]>` doesn't implement `std::marker::Send`
 note: captured value is not `Send` because `&` references cannot be sent unless their referent is `Sync`
-  --> tests/ui/future_not_send.rs:22:40
+  --> tests/ui/future_not_send.rs:24:40
    |
 LL | async fn private_future2(rc: Rc<[u8]>, cell: &Cell<usize>) -> bool {
    |                                        ^^^^ has type `&std::cell::Cell<usize>` which is not `Send`, because `std::cell::Cell<usize>` is not `Sync`
    = note: `std::cell::Cell<usize>` doesn't implement `std::marker::Sync`
 
 error: future cannot be sent between threads safely
-  --> tests/ui/future_not_send.rs:27:1
+  --> tests/ui/future_not_send.rs:30:1
    |
 LL | pub async fn public_future2(rc: Rc<[u8]>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `public_future2` is not `Send`
    |
 note: captured value is not `Send`
-  --> tests/ui/future_not_send.rs:27:29
+  --> tests/ui/future_not_send.rs:30:29
    |
 LL | pub async fn public_future2(rc: Rc<[u8]>) {}
    |                             ^^ has type `std::rc::Rc<[u8]>` which is not `Send`
    = note: `std::rc::Rc<[u8]>` doesn't implement `std::marker::Send`
 
 error: future cannot be sent between threads safely
-  --> tests/ui/future_not_send.rs:39:5
+  --> tests/ui/future_not_send.rs:42:5
    |
 LL |     async fn private_future(&self) -> usize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `private_future` is not `Send`
    |
 note: future is not `Send` as this value is used across an await
-  --> tests/ui/future_not_send.rs:41:24
+  --> tests/ui/future_not_send.rs:45:24
    |
 LL |     async fn private_future(&self) -> usize {
    |                             ----- has type `&Dummy` which is not `Send`
-LL |
+...
 LL |         async { true }.await;
    |                        ^^^^^ await occurs here, with `&self` maybe used later
    = note: `std::rc::Rc<[u8]>` doesn't implement `std::marker::Sync`
 
 error: future cannot be sent between threads safely
-  --> tests/ui/future_not_send.rs:45:5
+  --> tests/ui/future_not_send.rs:49:5
    |
 LL |     pub async fn public_future(&self) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `public_future` is not `Send`
    |
 note: captured value is not `Send` because `&` references cannot be sent unless their referent is `Sync`
-  --> tests/ui/future_not_send.rs:45:32
+  --> tests/ui/future_not_send.rs:49:32
    |
 LL |     pub async fn public_future(&self) {
    |                                ^^^^^ has type `&Dummy` which is not `Send`, because `Dummy` is not `Sync`
    = note: `std::rc::Rc<[u8]>` doesn't implement `std::marker::Sync`
 
 error: future cannot be sent between threads safely
-  --> tests/ui/future_not_send.rs:56:1
+  --> tests/ui/future_not_send.rs:61:1
    |
 LL | / async fn generic_future<T>(t: T) -> T
 LL | |
@@ -109,7 +109,7 @@ LL | |     T: Send,
    | |____________^ future returned by `generic_future` is not `Send`
    |
 note: future is not `Send` as this value is used across an await
-  --> tests/ui/future_not_send.rs:62:20
+  --> tests/ui/future_not_send.rs:67:20
    |
 LL |     let rt = &t;
    |         -- has type `&T` which is not `Send`
@@ -118,17 +118,17 @@ LL |     async { true }.await;
    = note: `T` doesn't implement `std::marker::Sync`
 
 error: future cannot be sent between threads safely
-  --> tests/ui/future_not_send.rs:78:1
+  --> tests/ui/future_not_send.rs:83:1
    |
 LL | async fn generic_future_always_unsend<T>(_: Rc<T>) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ future returned by `generic_future_always_unsend` is not `Send`
    |
 note: future is not `Send` as this value is used across an await
-  --> tests/ui/future_not_send.rs:80:20
+  --> tests/ui/future_not_send.rs:86:20
    |
 LL | async fn generic_future_always_unsend<T>(_: Rc<T>) {
    |                                          - has type `std::rc::Rc<T>` which is not `Send`
-LL |
+...
 LL |     async { true }.await;
    |                    ^^^^^ await occurs here, with `_` maybe used later
    = note: `std::rc::Rc<T>` doesn't implement `std::marker::Send`
diff --git a/src/tools/clippy/tests/ui/get_first.fixed b/src/tools/clippy/tests/ui/get_first.fixed
index 710ebab1ef2d..584080defa1e 100644
--- a/src/tools/clippy/tests/ui/get_first.fixed
+++ b/src/tools/clippy/tests/ui/get_first.fixed
@@ -15,25 +15,29 @@ impl Bar {
 fn main() {
     let x = vec![2, 3, 5];
     let _ = x.first();
-    //~^ ERROR: accessing first element with `x.get(0)`
+    //~^ get_first
+
     let _ = x.get(1);
     let _ = x[0];
 
     let y = [2, 3, 5];
     let _ = y.first();
-    //~^ ERROR: accessing first element with `y.get(0)`
+    //~^ get_first
+
     let _ = y.get(1);
     let _ = y[0];
 
     let z = &[2, 3, 5];
     let _ = z.first();
-    //~^ ERROR: accessing first element with `z.get(0)`
+    //~^ get_first
+
     let _ = z.get(1);
     let _ = z[0];
 
     let vecdeque: VecDeque<_> = x.iter().cloned().collect();
     let _ = vecdeque.front();
-    //~^ ERROR: accessing first element with `vecdeque.get(0)`
+    //~^ get_first
+
     let _ = vecdeque.get(1);
 
     let hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(0, 'a'), (1, 'b')]);
@@ -46,5 +50,5 @@ fn main() {
 
     let non_primitives = [vec![1, 2], vec![3, 4]];
     let _ = non_primitives.first();
-    //~^ ERROR: accessing first element with `non_primitives.get(0)`
+    //~^ get_first
 }
diff --git a/src/tools/clippy/tests/ui/get_first.rs b/src/tools/clippy/tests/ui/get_first.rs
index ad2ba6ce2c3b..f01fbdf43c6d 100644
--- a/src/tools/clippy/tests/ui/get_first.rs
+++ b/src/tools/clippy/tests/ui/get_first.rs
@@ -15,25 +15,29 @@ impl Bar {
 fn main() {
     let x = vec![2, 3, 5];
     let _ = x.get(0);
-    //~^ ERROR: accessing first element with `x.get(0)`
+    //~^ get_first
+
     let _ = x.get(1);
     let _ = x[0];
 
     let y = [2, 3, 5];
     let _ = y.get(0);
-    //~^ ERROR: accessing first element with `y.get(0)`
+    //~^ get_first
+
     let _ = y.get(1);
     let _ = y[0];
 
     let z = &[2, 3, 5];
     let _ = z.get(0);
-    //~^ ERROR: accessing first element with `z.get(0)`
+    //~^ get_first
+
     let _ = z.get(1);
     let _ = z[0];
 
     let vecdeque: VecDeque<_> = x.iter().cloned().collect();
     let _ = vecdeque.get(0);
-    //~^ ERROR: accessing first element with `vecdeque.get(0)`
+    //~^ get_first
+
     let _ = vecdeque.get(1);
 
     let hashmap: HashMap<u8, char> = HashMap::from_iter(vec![(0, 'a'), (1, 'b')]);
@@ -46,5 +50,5 @@ fn main() {
 
     let non_primitives = [vec![1, 2], vec![3, 4]];
     let _ = non_primitives.get(0);
-    //~^ ERROR: accessing first element with `non_primitives.get(0)`
+    //~^ get_first
 }
diff --git a/src/tools/clippy/tests/ui/get_first.stderr b/src/tools/clippy/tests/ui/get_first.stderr
index 155d341b5a77..4e19ebbc7589 100644
--- a/src/tools/clippy/tests/ui/get_first.stderr
+++ b/src/tools/clippy/tests/ui/get_first.stderr
@@ -8,25 +8,25 @@ LL |     let _ = x.get(0);
    = help: to override `-D warnings` add `#[allow(clippy::get_first)]`
 
 error: accessing first element with `y.get(0)`
-  --> tests/ui/get_first.rs:23:13
+  --> tests/ui/get_first.rs:24:13
    |
 LL |     let _ = y.get(0);
    |             ^^^^^^^^ help: try: `y.first()`
 
 error: accessing first element with `z.get(0)`
-  --> tests/ui/get_first.rs:29:13
+  --> tests/ui/get_first.rs:31:13
    |
 LL |     let _ = z.get(0);
    |             ^^^^^^^^ help: try: `z.first()`
 
 error: accessing first element with `vecdeque.get(0)`
-  --> tests/ui/get_first.rs:35:13
+  --> tests/ui/get_first.rs:38:13
    |
 LL |     let _ = vecdeque.get(0);
    |             ^^^^^^^^^^^^^^^ help: try: `vecdeque.front()`
 
 error: accessing first element with `non_primitives.get(0)`
-  --> tests/ui/get_first.rs:48:13
+  --> tests/ui/get_first.rs:52:13
    |
 LL |     let _ = non_primitives.get(0);
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try: `non_primitives.first()`
diff --git a/src/tools/clippy/tests/ui/get_last_with_len.fixed b/src/tools/clippy/tests/ui/get_last_with_len.fixed
index 377906cb2448..15b6e1666af2 100644
--- a/src/tools/clippy/tests/ui/get_last_with_len.fixed
+++ b/src/tools/clippy/tests/ui/get_last_with_len.fixed
@@ -6,6 +6,7 @@ use std::collections::VecDeque;
 fn dont_use_last() {
     let x = vec![2, 3, 5];
     let _ = x.last();
+    //~^ get_last_with_len
 }
 
 fn indexing_two_from_end() {
@@ -30,18 +31,23 @@ struct S {
 
 fn in_field(s: &S) {
     let _ = s.field.last();
+    //~^ get_last_with_len
 }
 
 fn main() {
     let slice = &[1, 2, 3];
     let _ = slice.last();
+    //~^ get_last_with_len
 
     let array = [4, 5, 6];
     let _ = array.last();
+    //~^ get_last_with_len
 
     let deq = VecDeque::from([7, 8, 9]);
     let _ = deq.back();
+    //~^ get_last_with_len
 
     let nested = [[1]];
     let _ = nested[0].last();
+    //~^ get_last_with_len
 }
diff --git a/src/tools/clippy/tests/ui/get_last_with_len.rs b/src/tools/clippy/tests/ui/get_last_with_len.rs
index 2735932043a3..5b132e001e7b 100644
--- a/src/tools/clippy/tests/ui/get_last_with_len.rs
+++ b/src/tools/clippy/tests/ui/get_last_with_len.rs
@@ -6,6 +6,7 @@ use std::collections::VecDeque;
 fn dont_use_last() {
     let x = vec![2, 3, 5];
     let _ = x.get(x.len() - 1);
+    //~^ get_last_with_len
 }
 
 fn indexing_two_from_end() {
@@ -30,18 +31,23 @@ struct S {
 
 fn in_field(s: &S) {
     let _ = s.field.get(s.field.len() - 1);
+    //~^ get_last_with_len
 }
 
 fn main() {
     let slice = &[1, 2, 3];
     let _ = slice.get(slice.len() - 1);
+    //~^ get_last_with_len
 
     let array = [4, 5, 6];
     let _ = array.get(array.len() - 1);
+    //~^ get_last_with_len
 
     let deq = VecDeque::from([7, 8, 9]);
     let _ = deq.get(deq.len() - 1);
+    //~^ get_last_with_len
 
     let nested = [[1]];
     let _ = nested[0].get(nested[0].len() - 1);
+    //~^ get_last_with_len
 }
diff --git a/src/tools/clippy/tests/ui/get_last_with_len.stderr b/src/tools/clippy/tests/ui/get_last_with_len.stderr
index ba08f5db7cfa..83a03a438e44 100644
--- a/src/tools/clippy/tests/ui/get_last_with_len.stderr
+++ b/src/tools/clippy/tests/ui/get_last_with_len.stderr
@@ -8,31 +8,31 @@ LL |     let _ = x.get(x.len() - 1);
    = help: to override `-D warnings` add `#[allow(clippy::get_last_with_len)]`
 
 error: accessing last element with `s.field.get(s.field.len() - 1)`
-  --> tests/ui/get_last_with_len.rs:32:13
+  --> tests/ui/get_last_with_len.rs:33:13
    |
 LL |     let _ = s.field.get(s.field.len() - 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.field.last()`
 
 error: accessing last element with `slice.get(slice.len() - 1)`
-  --> tests/ui/get_last_with_len.rs:37:13
+  --> tests/ui/get_last_with_len.rs:39:13
    |
 LL |     let _ = slice.get(slice.len() - 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `slice.last()`
 
 error: accessing last element with `array.get(array.len() - 1)`
-  --> tests/ui/get_last_with_len.rs:40:13
+  --> tests/ui/get_last_with_len.rs:43:13
    |
 LL |     let _ = array.get(array.len() - 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array.last()`
 
 error: accessing last element with `deq.get(deq.len() - 1)`
-  --> tests/ui/get_last_with_len.rs:43:13
+  --> tests/ui/get_last_with_len.rs:47:13
    |
 LL |     let _ = deq.get(deq.len() - 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `deq.back()`
 
 error: accessing last element with `nested[0].get(nested[0].len() - 1)`
-  --> tests/ui/get_last_with_len.rs:46:13
+  --> tests/ui/get_last_with_len.rs:51:13
    |
 LL |     let _ = nested[0].get(nested[0].len() - 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `nested[0].last()`
diff --git a/src/tools/clippy/tests/ui/get_unwrap.fixed b/src/tools/clippy/tests/ui/get_unwrap.fixed
index 2dd3c30a4e29..3115c1462f5a 100644
--- a/src/tools/clippy/tests/ui/get_unwrap.fixed
+++ b/src/tools/clippy/tests/ui/get_unwrap.fixed
@@ -35,23 +35,45 @@ fn main() {
     {
         // Test `get().unwrap()`
         let _ = &boxed_slice[1];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_slice[0];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_vec[0];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_vecdeque[0];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_hashmap[&1];
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = &some_btreemap[&1];
+        //~^ get_unwrap
+        //~| unwrap_used
         #[allow(clippy::unwrap_used)]
         let _ = false_positive.get(0).unwrap();
         // Test with deref
         let _: u8 = boxed_slice[1];
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 
     {
         // Test `get_mut().unwrap()`
         boxed_slice[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         some_slice[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         some_vec[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         some_vecdeque[0] = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         // Check false positives
         #[allow(clippy::unwrap_used)]
         {
@@ -64,7 +86,11 @@ fn main() {
     {
         // Test `get().unwrap().foo()` and `get_mut().unwrap().bar()`
         let _ = some_vec[0..1].to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vec[0..1].to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 }
 mod issue9909 {
@@ -76,12 +102,15 @@ mod issue9909 {
 
         // include a borrow in the suggestion, even if the argument is not just a numeric literal
         let _x: &i32 = &f[1 + 2];
+        //~^ get_unwrap
 
         // don't include a borrow here
         let _x = f[1 + 2].to_string();
+        //~^ get_unwrap
 
         // don't include a borrow here
         let _x = f[1 + 2].abs();
+        //~^ get_unwrap
     }
 
     // original code:
@@ -99,6 +128,7 @@ mod issue9909 {
                         let (x, rest) = mat.split_at_mut(linidx(i, k) + 1);
                         let a = x.last_mut().unwrap();
                         let b = &mut rest[linidx(j, k) - linidx(i, k) - 1];
+                        //~^ get_unwrap
                         ::std::mem::swap(a, b);
                     }
                 }
diff --git a/src/tools/clippy/tests/ui/get_unwrap.rs b/src/tools/clippy/tests/ui/get_unwrap.rs
index 94226564cacb..963238a88983 100644
--- a/src/tools/clippy/tests/ui/get_unwrap.rs
+++ b/src/tools/clippy/tests/ui/get_unwrap.rs
@@ -35,23 +35,45 @@ fn main() {
     {
         // Test `get().unwrap()`
         let _ = boxed_slice.get(1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_slice.get(0).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vec.get(0).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vecdeque.get(0).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_hashmap.get(&1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_btreemap.get(&1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
         #[allow(clippy::unwrap_used)]
         let _ = false_positive.get(0).unwrap();
         // Test with deref
         let _: u8 = *boxed_slice.get(1).unwrap();
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 
     {
         // Test `get_mut().unwrap()`
         *boxed_slice.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         *some_slice.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         *some_vec.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         *some_vecdeque.get_mut(0).unwrap() = 1;
+        //~^ get_unwrap
+        //~| unwrap_used
         // Check false positives
         #[allow(clippy::unwrap_used)]
         {
@@ -64,7 +86,11 @@ fn main() {
     {
         // Test `get().unwrap().foo()` and `get_mut().unwrap().bar()`
         let _ = some_vec.get(0..1).unwrap().to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
+        //~^ get_unwrap
+        //~| unwrap_used
     }
 }
 mod issue9909 {
@@ -76,12 +102,15 @@ mod issue9909 {
 
         // include a borrow in the suggestion, even if the argument is not just a numeric literal
         let _x: &i32 = f.get(1 + 2).unwrap();
+        //~^ get_unwrap
 
         // don't include a borrow here
         let _x = f.get(1 + 2).unwrap().to_string();
+        //~^ get_unwrap
 
         // don't include a borrow here
         let _x = f.get(1 + 2).unwrap().abs();
+        //~^ get_unwrap
     }
 
     // original code:
@@ -99,6 +128,7 @@ mod issue9909 {
                         let (x, rest) = mat.split_at_mut(linidx(i, k) + 1);
                         let a = x.last_mut().unwrap();
                         let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
+                        //~^ get_unwrap
                         ::std::mem::swap(a, b);
                     }
                 }
diff --git a/src/tools/clippy/tests/ui/get_unwrap.stderr b/src/tools/clippy/tests/ui/get_unwrap.stderr
index fc6c0b9299c4..72a575654af9 100644
--- a/src/tools/clippy/tests/ui/get_unwrap.stderr
+++ b/src/tools/clippy/tests/ui/get_unwrap.stderr
@@ -27,7 +27,7 @@ LL |         let _ = boxed_slice.get(1).unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:38:17
+  --> tests/ui/get_unwrap.rs:40:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL +         let _ = &some_slice[0];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:38:17
+  --> tests/ui/get_unwrap.rs:40:17
    |
 LL |         let _ = some_slice.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |         let _ = some_slice.get(0).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec
-  --> tests/ui/get_unwrap.rs:39:17
+  --> tests/ui/get_unwrap.rs:43:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL +         let _ = &some_vec[0];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:39:17
+  --> tests/ui/get_unwrap.rs:43:17
    |
 LL |         let _ = some_vec.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL |         let _ = some_vec.get(0).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a VecDeque
-  --> tests/ui/get_unwrap.rs:40:17
+  --> tests/ui/get_unwrap.rs:46:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL +         let _ = &some_vecdeque[0];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:40:17
+  --> tests/ui/get_unwrap.rs:46:17
    |
 LL |         let _ = some_vecdeque.get(0).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -90,7 +90,7 @@ LL |         let _ = some_vecdeque.get(0).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a HashMap
-  --> tests/ui/get_unwrap.rs:41:17
+  --> tests/ui/get_unwrap.rs:49:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -102,7 +102,7 @@ LL +         let _ = &some_hashmap[&1];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:41:17
+  --> tests/ui/get_unwrap.rs:49:17
    |
 LL |         let _ = some_hashmap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -111,7 +111,7 @@ LL |         let _ = some_hashmap.get(&1).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a BTreeMap
-  --> tests/ui/get_unwrap.rs:42:17
+  --> tests/ui/get_unwrap.rs:52:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -123,7 +123,7 @@ LL +         let _ = &some_btreemap[&1];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:42:17
+  --> tests/ui/get_unwrap.rs:52:17
    |
 LL |         let _ = some_btreemap.get(&1).unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL |         let _ = some_btreemap.get(&1).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:46:21
+  --> tests/ui/get_unwrap.rs:58:21
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL +         let _: u8 = boxed_slice[1];
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:46:22
+  --> tests/ui/get_unwrap.rs:58:22
    |
 LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -153,7 +153,7 @@ LL |         let _: u8 = *boxed_slice.get(1).unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:51:9
+  --> tests/ui/get_unwrap.rs:65:9
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -165,7 +165,7 @@ LL +         boxed_slice[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:51:10
+  --> tests/ui/get_unwrap.rs:65:10
    |
 LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -174,7 +174,7 @@ LL |         *boxed_slice.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:52:9
+  --> tests/ui/get_unwrap.rs:68:9
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -186,7 +186,7 @@ LL +         some_slice[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:52:10
+  --> tests/ui/get_unwrap.rs:68:10
    |
 LL |         *some_slice.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -195,7 +195,7 @@ LL |         *some_slice.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec
-  --> tests/ui/get_unwrap.rs:53:9
+  --> tests/ui/get_unwrap.rs:71:9
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -207,7 +207,7 @@ LL +         some_vec[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:53:10
+  --> tests/ui/get_unwrap.rs:71:10
    |
 LL |         *some_vec.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -216,7 +216,7 @@ LL |         *some_vec.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a VecDeque
-  --> tests/ui/get_unwrap.rs:54:9
+  --> tests/ui/get_unwrap.rs:74:9
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -228,7 +228,7 @@ LL +         some_vecdeque[0] = 1;
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:54:10
+  --> tests/ui/get_unwrap.rs:74:10
    |
 LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -237,7 +237,7 @@ LL |         *some_vecdeque.get_mut(0).unwrap() = 1;
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a Vec
-  --> tests/ui/get_unwrap.rs:66:17
+  --> tests/ui/get_unwrap.rs:88:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -249,7 +249,7 @@ LL +         let _ = some_vec[0..1].to_vec();
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:66:17
+  --> tests/ui/get_unwrap.rs:88:17
    |
 LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -258,7 +258,7 @@ LL |         let _ = some_vec.get(0..1).unwrap().to_vec();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get_mut().unwrap()` on a Vec
-  --> tests/ui/get_unwrap.rs:67:17
+  --> tests/ui/get_unwrap.rs:91:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -270,7 +270,7 @@ LL +         let _ = some_vec[0..1].to_vec();
    |
 
 error: used `unwrap()` on an `Option` value
-  --> tests/ui/get_unwrap.rs:67:17
+  --> tests/ui/get_unwrap.rs:91:17
    |
 LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -279,7 +279,7 @@ LL |         let _ = some_vec.get_mut(0..1).unwrap().to_vec();
    = help: consider using `expect()` to provide a better panic message
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:78:24
+  --> tests/ui/get_unwrap.rs:104:24
    |
 LL |         let _x: &i32 = f.get(1 + 2).unwrap();
    |                        ^^^^^^^^^^^^^^^^^^^^^
@@ -291,7 +291,7 @@ LL +         let _x: &i32 = &f[1 + 2];
    |
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:81:18
+  --> tests/ui/get_unwrap.rs:108:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().to_string();
    |                  ^^^^^^^^^^^^^^^^^^^^^
@@ -303,7 +303,7 @@ LL +         let _x = f[1 + 2].to_string();
    |
 
 error: called `.get().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:84:18
+  --> tests/ui/get_unwrap.rs:112:18
    |
 LL |         let _x = f.get(1 + 2).unwrap().abs();
    |                  ^^^^^^^^^^^^^^^^^^^^^
@@ -315,7 +315,7 @@ LL +         let _x = f[1 + 2].abs();
    |
 
 error: called `.get_mut().unwrap()` on a slice
-  --> tests/ui/get_unwrap.rs:101:33
+  --> tests/ui/get_unwrap.rs:130:33
    |
 LL |                         let b = rest.get_mut(linidx(j, k) - linidx(i, k) - 1).unwrap();
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/identity_op.fixed b/src/tools/clippy/tests/ui/identity_op.fixed
index 2e8e2366de6f..a1b556029987 100644
--- a/src/tools/clippy/tests/ui/identity_op.fixed
+++ b/src/tools/clippy/tests/ui/identity_op.fixed
@@ -42,45 +42,58 @@ fn main() {
     let x = 0;
 
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x + 1;
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1 + x;
     x - ZERO; //no error, as we skip lookups (for now)
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     ((ZERO)) | x; //no error, as we skip lookups (for now)
 
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x / ONE; //no error, as we skip lookups (for now)
 
     x / 2; //no false positive
 
     x & NEG_ONE; //no error, as we skip lookups (for now)
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     let u: u8 = 0;
     u;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     1 << 0; // no error, this case is allowed, see issue 3430
     42;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     42;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     let mut a = A(String::new());
     let b = a << 0; // no error: non-integer
@@ -88,15 +101,20 @@ fn main() {
     1 * Meter; // no error: non-integer
 
     2;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     -2;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     2 + x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     -2 + x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x + 1;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (x + 1) % 3; // no error
     4 % 3; // no error
     4 % -3; // no error
@@ -105,63 +123,85 @@ fn main() {
     let a = 0;
     let b = true;
     (if b { 1 } else { 2 });
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (if b { 1 } else { 2 }) + if b { 3 } else { 4 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (match a { 0 => 10, _ => 20 });
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (match a { 0 => 10, _ => 20 }) + match a { 0 => 30, _ => 40 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (if b { 1 } else { 2 }) + match a { 0 => 30, _ => 40 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (match a { 0 => 10, _ => 20 }) + if b { 3 } else { 4 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     ((if b { 1 } else { 2 }));
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     ({ a }) + 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     ({ a } * 2);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (loop { let mut c = 0; if c == 10 { break c; } c += 1; }) + { a * 2 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     fn f(_: i32) {
         todo!();
     }
 
     f(a + { 8 * 5 });
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     f(if b { 1 } else { 2 } + 3);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     const _: i32 = { 2 * 4 } + 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     const _: i32 = { 1 + 2 * 3 } + 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     a as usize;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     let _ = a as usize;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     ({ a } as usize);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     2 * { a };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (({ a } + 4));
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     // Issue #9904
     let x = 0i32;
     let _: i32 = x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 }
 
 pub fn decide(a: bool, b: bool) -> u32 {
     (if a { 1 } else { 2 }) + if b { 3 } else { 5 }
+    //~^ identity_op
 }
 
 /// The following tests are from / for issue #12050
@@ -173,43 +213,51 @@ fn issue_12050() {
     {
         let x = &0i32;
         let _: i32 = *x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = *x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
     {
         let x = &&0i32;
         let _: i32 = **x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let x = &&0i32;
         let _: i32 = **x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
     {
         // this is just silly
         let x = &&&0i32;
         let _: i32 = ***x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = ***x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let x = 0i32;
         let _: i32 = *&x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = **&&x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = *&*&x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = **&&*&x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
     {
         // this is getting ridiculous, but we should still see the same
         // error message so let's just keep going
         let x = &0i32;
         let _: i32 = ***&&*&x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = ***&&*&x;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
 }
 
@@ -218,41 +266,49 @@ fn issue_13470() {
     let y = 1i32;
     // Removes the + 0i32 while keeping the parentheses around x + y so the cast operation works
     let _: u64 = (x + y) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // both of the next two lines should look the same after rustfix
     let _: u64 = 1u64 & (x + y) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Same as above, but with extra redundant parenthesis
     let _: u64 = 1u64 & ((x + y)) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Should maintain parenthesis even if the surrounding expr has the same precedence
     let _: u64 = 5u64 + ((x + y)) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
 
     // If we don't maintain the parens here, the behavior changes
     let _ = -(x + y);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Similarly, we need to maintain parens here
     let _ = -(x / y);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Maintain parenthesis if the parent expr is of higher precedence
     let _ = 2i32 * (x + y);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Maintain parenthesis if the parent expr is the same precedence
     // as not all operations are associative
     let _ = 2i32 - (x - y);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // But make sure that inner parens still exist
     let z = 1i32;
     let _ = 2 + (x + (y * z));
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Maintain parenthesis if the parent expr is of lower precedence
     // This is for clarity, and clippy will not warn on these being unnecessary
     let _ = 2i32 + (x * y);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
 
     let x = 1i16;
     let y = 1i16;
     let _: u64 = 1u64 + ((x as i32 + y as i32) as u64);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
 }
diff --git a/src/tools/clippy/tests/ui/identity_op.rs b/src/tools/clippy/tests/ui/identity_op.rs
index 3e20fa6f2b89..f603e1078e4e 100644
--- a/src/tools/clippy/tests/ui/identity_op.rs
+++ b/src/tools/clippy/tests/ui/identity_op.rs
@@ -42,45 +42,58 @@ fn main() {
     let x = 0;
 
     x + 0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x + (1 - 1);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x + 1;
     0 + x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1 + x;
     x - ZERO; //no error, as we skip lookups (for now)
     x | (0);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     ((ZERO)) | x; //no error, as we skip lookups (for now)
 
     x * 1;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1 * x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x / ONE; //no error, as we skip lookups (for now)
 
     x / 2; //no false positive
 
     x & NEG_ONE; //no error, as we skip lookups (for now)
     -1 & x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     let u: u8 = 0;
     u & 255;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     1 << 0; // no error, this case is allowed, see issue 3430
     42 << 0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1 >> 0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     42 >> 0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     &x >> 0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x >> &0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     let mut a = A(String::new());
     let b = a << 0; // no error: non-integer
@@ -88,15 +101,20 @@ fn main() {
     1 * Meter; // no error: non-integer
 
     2 % 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     -2 % 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     2 % -3 + x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     -2 % -3 + x;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     x + 1 % 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (x + 1) % 3; // no error
     4 % 3; // no error
     4 % -3; // no error
@@ -105,63 +123,85 @@ fn main() {
     let a = 0;
     let b = true;
     0 + if b { 1 } else { 2 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + if b { 1 } else { 2 } + if b { 3 } else { 4 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + match a { 0 => 10, _ => 20 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     (if b { 1 } else { 2 }) + 0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     0 + { a } + 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + { a } * 2;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 };
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     fn f(_: i32) {
         todo!();
     }
 
     f(1 * a + { 8 * 5 });
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     f(0 + if b { 1 } else { 2 } + 3);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     const _: i32 = { 2 * 4 } + 0 + 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     const _: i32 = 0 + { 1 + 2 * 3 } + 3;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     0 + a as usize;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     let _ = 0 + a as usize;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     0 + { a } as usize;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     2 * (0 + { a });
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1 * ({ a } + 4);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     1 * 1;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 
     // Issue #9904
     let x = 0i32;
     let _: i32 = &x + 0;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
 }
 
 pub fn decide(a: bool, b: bool) -> u32 {
     0 + if a { 1 } else { 2 } + if b { 3 } else { 5 }
+    //~^ identity_op
 }
 
 /// The following tests are from / for issue #12050
@@ -173,43 +213,51 @@ fn issue_12050() {
     {
         let x = &0i32;
         let _: i32 = *x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
     {
         let x = &&0i32;
         let _: i32 = **x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let x = &&0i32;
         let _: i32 = *x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
     {
         // this is just silly
         let x = &&&0i32;
         let _: i32 = ***x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = **x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let x = 0i32;
         let _: i32 = *&x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = **&&x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = *&*&x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = **&&*&x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
     {
         // this is getting ridiculous, but we should still see the same
         // error message so let's just keep going
         let x = &0i32;
         let _: i32 = **&&*&x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
+
         let _: i32 = **&&*&x + 0;
-        //~^ ERROR: this operation has no effect
+        //~^ identity_op
     }
 }
 
@@ -218,41 +266,49 @@ fn issue_13470() {
     let y = 1i32;
     // Removes the + 0i32 while keeping the parentheses around x + y so the cast operation works
     let _: u64 = (x + y + 0i32) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // both of the next two lines should look the same after rustfix
     let _: u64 = 1u64 & (x + y + 0i32) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Same as above, but with extra redundant parenthesis
     let _: u64 = 1u64 & ((x + y) + 0i32) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Should maintain parenthesis even if the surrounding expr has the same precedence
     let _: u64 = 5u64 + ((x + y) + 0i32) as u64;
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
 
     // If we don't maintain the parens here, the behavior changes
     let _ = -(x + y + 0i32);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Similarly, we need to maintain parens here
     let _ = -(x / y / 1i32);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Maintain parenthesis if the parent expr is of higher precedence
     let _ = 2i32 * (x + y + 0i32);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Maintain parenthesis if the parent expr is the same precedence
     // as not all operations are associative
     let _ = 2i32 - (x - y - 0i32);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // But make sure that inner parens still exist
     let z = 1i32;
     let _ = 2 + (x + (y * z) + 0);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
+
     // Maintain parenthesis if the parent expr is of lower precedence
     // This is for clarity, and clippy will not warn on these being unnecessary
     let _ = 2i32 + (x * y * 1i32);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
 
     let x = 1i16;
     let y = 1i16;
     let _: u64 = 1u64 + ((x as i32 + y as i32) as u64 + 0u64);
-    //~^ ERROR: this operation has no effect
+    //~^ identity_op
 }
diff --git a/src/tools/clippy/tests/ui/identity_op.stderr b/src/tools/clippy/tests/ui/identity_op.stderr
index 99a58ef2c1b5..8f9c2b603c49 100644
--- a/src/tools/clippy/tests/ui/identity_op.stderr
+++ b/src/tools/clippy/tests/ui/identity_op.stderr
@@ -8,373 +8,373 @@ LL |     x + 0;
    = help: to override `-D warnings` add `#[allow(clippy::identity_op)]`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:46:5
+  --> tests/ui/identity_op.rs:47:5
    |
 LL |     x + (1 - 1);
    |     ^^^^^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:49:5
+  --> tests/ui/identity_op.rs:51:5
    |
 LL |     0 + x;
    |     ^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:53:5
+  --> tests/ui/identity_op.rs:56:5
    |
 LL |     x | (0);
    |     ^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:57:5
+  --> tests/ui/identity_op.rs:61:5
    |
 LL |     x * 1;
    |     ^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:59:5
+  --> tests/ui/identity_op.rs:64:5
    |
 LL |     1 * x;
    |     ^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:66:5
+  --> tests/ui/identity_op.rs:72:5
    |
 LL |     -1 & x;
    |     ^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:70:5
+  --> tests/ui/identity_op.rs:77:5
    |
 LL |     u & 255;
    |     ^^^^^^^ help: consider reducing it to: `u`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:74:5
+  --> tests/ui/identity_op.rs:82:5
    |
 LL |     42 << 0;
    |     ^^^^^^^ help: consider reducing it to: `42`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:76:5
+  --> tests/ui/identity_op.rs:85:5
    |
 LL |     1 >> 0;
    |     ^^^^^^ help: consider reducing it to: `1`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:78:5
+  --> tests/ui/identity_op.rs:88:5
    |
 LL |     42 >> 0;
    |     ^^^^^^^ help: consider reducing it to: `42`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:80:5
+  --> tests/ui/identity_op.rs:91:5
    |
 LL |     &x >> 0;
    |     ^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:82:5
+  --> tests/ui/identity_op.rs:94:5
    |
 LL |     x >> &0;
    |     ^^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:90:5
+  --> tests/ui/identity_op.rs:103:5
    |
 LL |     2 % 3;
    |     ^^^^^ help: consider reducing it to: `2`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:92:5
+  --> tests/ui/identity_op.rs:106:5
    |
 LL |     -2 % 3;
    |     ^^^^^^ help: consider reducing it to: `-2`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:94:5
+  --> tests/ui/identity_op.rs:109:5
    |
 LL |     2 % -3 + x;
    |     ^^^^^^ help: consider reducing it to: `2`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:96:5
+  --> tests/ui/identity_op.rs:112:5
    |
 LL |     -2 % -3 + x;
    |     ^^^^^^^ help: consider reducing it to: `-2`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:98:9
+  --> tests/ui/identity_op.rs:115:9
    |
 LL |     x + 1 % 3;
    |         ^^^^^ help: consider reducing it to: `1`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:107:5
+  --> tests/ui/identity_op.rs:125:5
    |
 LL |     0 + if b { 1 } else { 2 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:109:5
+  --> tests/ui/identity_op.rs:128:5
    |
 LL |     0 + if b { 1 } else { 2 } + if b { 3 } else { 4 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:111:5
+  --> tests/ui/identity_op.rs:131:5
    |
 LL |     0 + match a { 0 => 10, _ => 20 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:113:5
+  --> tests/ui/identity_op.rs:134:5
    |
 LL |     0 + match a { 0 => 10, _ => 20 } + match a { 0 => 30, _ => 40 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:115:5
+  --> tests/ui/identity_op.rs:137:5
    |
 LL |     0 + if b { 1 } else { 2 } + match a { 0 => 30, _ => 40 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if b { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:117:5
+  --> tests/ui/identity_op.rs:140:5
    |
 LL |     0 + match a { 0 => 10, _ => 20 } + if b { 3 } else { 4 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(match a { 0 => 10, _ => 20 })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:119:5
+  --> tests/ui/identity_op.rs:143:5
    |
 LL |     (if b { 1 } else { 2 }) + 0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `((if b { 1 } else { 2 }))`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:122:5
+  --> tests/ui/identity_op.rs:147:5
    |
 LL |     0 + { a } + 3;
    |     ^^^^^^^^^ help: consider reducing it to: `({ a })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:124:5
+  --> tests/ui/identity_op.rs:150:5
    |
 LL |     0 + { a } * 2;
    |     ^^^^^^^^^^^^^ help: consider reducing it to: `({ a } * 2)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:126:5
+  --> tests/ui/identity_op.rs:153:5
    |
 LL |     0 + loop { let mut c = 0; if c == 10 { break c; } c += 1; } + { a * 2 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(loop { let mut c = 0; if c == 10 { break c; } c += 1; })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:133:7
+  --> tests/ui/identity_op.rs:161:7
    |
 LL |     f(1 * a + { 8 * 5 });
    |       ^^^^^ help: consider reducing it to: `a`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:135:7
+  --> tests/ui/identity_op.rs:164:7
    |
 LL |     f(0 + if b { 1 } else { 2 } + 3);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `if b { 1 } else { 2 }`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:138:20
+  --> tests/ui/identity_op.rs:168:20
    |
 LL |     const _: i32 = { 2 * 4 } + 0 + 3;
    |                    ^^^^^^^^^^^^^ help: consider reducing it to: `{ 2 * 4 }`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:140:20
+  --> tests/ui/identity_op.rs:171:20
    |
 LL |     const _: i32 = 0 + { 1 + 2 * 3 } + 3;
    |                    ^^^^^^^^^^^^^^^^^ help: consider reducing it to: `{ 1 + 2 * 3 }`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:143:5
+  --> tests/ui/identity_op.rs:175:5
    |
 LL |     0 + a as usize;
    |     ^^^^^^^^^^^^^^ help: consider reducing it to: `a as usize`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:145:13
+  --> tests/ui/identity_op.rs:178:13
    |
 LL |     let _ = 0 + a as usize;
    |             ^^^^^^^^^^^^^^ help: consider reducing it to: `a as usize`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:147:5
+  --> tests/ui/identity_op.rs:181:5
    |
 LL |     0 + { a } as usize;
    |     ^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `({ a } as usize)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:150:9
+  --> tests/ui/identity_op.rs:185:9
    |
 LL |     2 * (0 + { a });
    |         ^^^^^^^^^^^ help: consider reducing it to: `{ a }`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:152:5
+  --> tests/ui/identity_op.rs:188:5
    |
 LL |     1 * ({ a } + 4);
    |     ^^^^^^^^^^^^^^^ help: consider reducing it to: `(({ a } + 4))`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:154:5
+  --> tests/ui/identity_op.rs:191:5
    |
 LL |     1 * 1;
    |     ^^^^^ help: consider reducing it to: `1`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:159:18
+  --> tests/ui/identity_op.rs:197:18
    |
 LL |     let _: i32 = &x + 0;
    |                  ^^^^^^ help: consider reducing it to: `x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:164:5
+  --> tests/ui/identity_op.rs:203:5
    |
 LL |     0 + if a { 1 } else { 2 } + if b { 3 } else { 5 }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(if a { 1 } else { 2 })`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:175:22
+  --> tests/ui/identity_op.rs:215:22
    |
 LL |         let _: i32 = *x + 0;
    |                      ^^^^^^ help: consider reducing it to: `*x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:177:22
+  --> tests/ui/identity_op.rs:218:22
    |
 LL |         let _: i32 = x + 0;
    |                      ^^^^^ help: consider reducing it to: `*x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:182:22
+  --> tests/ui/identity_op.rs:223:22
    |
 LL |         let _: i32 = **x + 0;
    |                      ^^^^^^^ help: consider reducing it to: `**x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:185:22
+  --> tests/ui/identity_op.rs:227:22
    |
 LL |         let _: i32 = *x + 0;
    |                      ^^^^^^ help: consider reducing it to: `**x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:191:22
+  --> tests/ui/identity_op.rs:233:22
    |
 LL |         let _: i32 = ***x + 0;
    |                      ^^^^^^^^ help: consider reducing it to: `***x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:193:22
+  --> tests/ui/identity_op.rs:236:22
    |
 LL |         let _: i32 = **x + 0;
    |                      ^^^^^^^ help: consider reducing it to: `***x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:196:22
+  --> tests/ui/identity_op.rs:240:22
    |
 LL |         let _: i32 = *&x + 0;
    |                      ^^^^^^^ help: consider reducing it to: `*&x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:198:22
+  --> tests/ui/identity_op.rs:243:22
    |
 LL |         let _: i32 = **&&x + 0;
    |                      ^^^^^^^^^ help: consider reducing it to: `**&&x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:200:22
+  --> tests/ui/identity_op.rs:246:22
    |
 LL |         let _: i32 = *&*&x + 0;
    |                      ^^^^^^^^^ help: consider reducing it to: `*&*&x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:202:22
+  --> tests/ui/identity_op.rs:249:22
    |
 LL |         let _: i32 = **&&*&x + 0;
    |                      ^^^^^^^^^^^ help: consider reducing it to: `**&&*&x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:209:22
+  --> tests/ui/identity_op.rs:256:22
    |
 LL |         let _: i32 = **&&*&x + 0;
    |                      ^^^^^^^^^^^ help: consider reducing it to: `***&&*&x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:211:22
+  --> tests/ui/identity_op.rs:259:22
    |
 LL |         let _: i32 = **&&*&x + 0;
    |                      ^^^^^^^^^^^ help: consider reducing it to: `***&&*&x`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:220:18
+  --> tests/ui/identity_op.rs:268:18
    |
 LL |     let _: u64 = (x + y + 0i32) as u64;
    |                  ^^^^^^^^^^^^^^ help: consider reducing it to: `(x + y)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:223:25
+  --> tests/ui/identity_op.rs:272:25
    |
 LL |     let _: u64 = 1u64 & (x + y + 0i32) as u64;
    |                         ^^^^^^^^^^^^^^ help: consider reducing it to: `(x + y)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:226:25
+  --> tests/ui/identity_op.rs:276:25
    |
 LL |     let _: u64 = 1u64 & ((x + y) + 0i32) as u64;
    |                         ^^^^^^^^^^^^^^^^ help: consider reducing it to: `((x + y))`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:229:25
+  --> tests/ui/identity_op.rs:280:25
    |
 LL |     let _: u64 = 5u64 + ((x + y) + 0i32) as u64;
    |                         ^^^^^^^^^^^^^^^^ help: consider reducing it to: `((x + y))`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:233:14
+  --> tests/ui/identity_op.rs:284:14
    |
 LL |     let _ = -(x + y + 0i32);
    |              ^^^^^^^^^^^^^^ help: consider reducing it to: `(x + y)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:236:14
+  --> tests/ui/identity_op.rs:288:14
    |
 LL |     let _ = -(x / y / 1i32);
    |              ^^^^^^^^^^^^^^ help: consider reducing it to: `(x / y)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:239:20
+  --> tests/ui/identity_op.rs:292:20
    |
 LL |     let _ = 2i32 * (x + y + 0i32);
    |                    ^^^^^^^^^^^^^^ help: consider reducing it to: `(x + y)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:243:20
+  --> tests/ui/identity_op.rs:297:20
    |
 LL |     let _ = 2i32 - (x - y - 0i32);
    |                    ^^^^^^^^^^^^^^ help: consider reducing it to: `(x - y)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:247:17
+  --> tests/ui/identity_op.rs:302:17
    |
 LL |     let _ = 2 + (x + (y * z) + 0);
    |                 ^^^^^^^^^^^^^^^^^ help: consider reducing it to: `(x + (y * z))`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:251:20
+  --> tests/ui/identity_op.rs:307:20
    |
 LL |     let _ = 2i32 + (x * y * 1i32);
    |                    ^^^^^^^^^^^^^^ help: consider reducing it to: `(x * y)`
 
 error: this operation has no effect
-  --> tests/ui/identity_op.rs:256:25
+  --> tests/ui/identity_op.rs:312:25
    |
 LL |     let _: u64 = 1u64 + ((x as i32 + y as i32) as u64 + 0u64);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider reducing it to: `((x as i32 + y as i32) as u64)`
diff --git a/src/tools/clippy/tests/ui/if_let_mutex.edition2021.stderr b/src/tools/clippy/tests/ui/if_let_mutex.edition2021.stderr
index 984d6adbb2a4..58afd03c8c24 100644
--- a/src/tools/clippy/tests/ui/if_let_mutex.edition2021.stderr
+++ b/src/tools/clippy/tests/ui/if_let_mutex.edition2021.stderr
@@ -1,5 +1,5 @@
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
-  --> tests/ui/if_let_mutex.rs:16:5
+  --> tests/ui/if_let_mutex.rs:17:5
    |
 LL |       if let Err(locked) = m.lock() {
    |       ^                    - this Mutex will remain locked for the entire `if let`-block...
@@ -19,7 +19,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::if_let_mutex)]`
 
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
-  --> tests/ui/if_let_mutex.rs:29:5
+  --> tests/ui/if_let_mutex.rs:30:5
    |
 LL |       if let Some(locked) = m.lock().unwrap().deref() {
    |       ^                     - this Mutex will remain locked for the entire `if let`-block...
@@ -37,7 +37,7 @@ LL | |     };
    = help: move the lock call outside of the `if let ...` expression
 
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
-  --> tests/ui/if_let_mutex.rs:51:5
+  --> tests/ui/if_let_mutex.rs:52:5
    |
 LL |       if let Ok(i) = mutex.lock() {
    |       ^              ----- this Mutex will remain locked for the entire `if let`-block...
@@ -54,7 +54,7 @@ LL | |     };
    = help: move the lock call outside of the `if let ...` expression
 
 error: calling `Mutex::lock` inside the scope of another `Mutex::lock` causes a deadlock
-  --> tests/ui/if_let_mutex.rs:60:5
+  --> tests/ui/if_let_mutex.rs:61:5
    |
 LL |       if let Ok(_) = m1.lock() {
    |       ^              -- this Mutex will remain locked for the entire `if let`-block...
diff --git a/src/tools/clippy/tests/ui/if_let_mutex.rs b/src/tools/clippy/tests/ui/if_let_mutex.rs
index 80eee2939890..72058ea33ee7 100644
--- a/src/tools/clippy/tests/ui/if_let_mutex.rs
+++ b/src/tools/clippy/tests/ui/if_let_mutex.rs
@@ -3,6 +3,7 @@
 //@revisions: edition2021 edition2024
 //@[edition2021] edition:2021
 //@[edition2024] edition:2024
+//@[edition2024] check-pass
 #![warn(clippy::if_let_mutex)]
 #![allow(clippy::redundant_pattern_matching)]
 
@@ -62,6 +63,7 @@ fn multiple_mutexes(m1: &Mutex<()>, m2: &Mutex<()>) {
     } else {
         m1.lock();
     }
+    //~[edition2021]^^^^^ if_let_mutex
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/if_not_else.fixed b/src/tools/clippy/tests/ui/if_not_else.fixed
index 11d1e13179c4..d26a15156cd8 100644
--- a/src/tools/clippy/tests/ui/if_not_else.fixed
+++ b/src/tools/clippy/tests/ui/if_not_else.fixed
@@ -12,13 +12,15 @@ fn main() {
     if bla() {
         println!("Bunny");
     } else {
-        //~^ ERROR: unnecessary boolean `not` operation
+        //~^ if_not_else
+
         println!("Bugs");
     }
     if 4 == 5 {
         println!("Bunny");
     } else {
-        //~^ ERROR: unnecessary `!=` operation
+        //~^ if_not_else
+
         println!("Bugs");
     }
     if !foo() {
@@ -32,6 +34,7 @@ fn main() {
     if (foo() && bla()) {
         println!("both true");
     } else {
+        //~^ if_not_else
         #[cfg(not(debug_assertions))]
         println!("not debug");
         #[cfg(debug_assertions)]
@@ -50,6 +53,7 @@ fn with_comments() {
     if foo() {
         println!("foo"); /* foo */
     } else {
+        //~^ if_not_else
         /* foo is false */
         println!("foo is false");
     }
@@ -57,6 +61,7 @@ fn with_comments() {
     if bla() {
         println!("bla"); // bla
     } else {
+        //~^ if_not_else
         // bla is false
         println!("bla");
     }
@@ -67,6 +72,7 @@ fn with_annotations() {
     if foo() {
         println!("foo"); /* foo */
     } else {
+        //~^ if_not_else
         /* foo is false */
         println!("foo is false");
     }
diff --git a/src/tools/clippy/tests/ui/if_not_else.rs b/src/tools/clippy/tests/ui/if_not_else.rs
index fcc67e163e8a..6171cf116495 100644
--- a/src/tools/clippy/tests/ui/if_not_else.rs
+++ b/src/tools/clippy/tests/ui/if_not_else.rs
@@ -10,13 +10,15 @@ fn bla() -> bool {
 
 fn main() {
     if !bla() {
-        //~^ ERROR: unnecessary boolean `not` operation
+        //~^ if_not_else
+
         println!("Bugs");
     } else {
         println!("Bunny");
     }
     if 4 != 5 {
-        //~^ ERROR: unnecessary `!=` operation
+        //~^ if_not_else
+
         println!("Bugs");
     } else {
         println!("Bunny");
@@ -30,6 +32,7 @@ fn main() {
     }
 
     if !(foo() && bla()) {
+        //~^ if_not_else
         #[cfg(not(debug_assertions))]
         println!("not debug");
         #[cfg(debug_assertions)]
@@ -48,6 +51,7 @@ fn main() {
 
 fn with_comments() {
     if !foo() {
+        //~^ if_not_else
         /* foo is false */
         println!("foo is false");
     } else {
@@ -55,6 +59,7 @@ fn with_comments() {
     }
 
     if !bla() {
+        //~^ if_not_else
         // bla is false
         println!("bla");
     } else {
@@ -65,6 +70,7 @@ fn with_comments() {
 fn with_annotations() {
     #[cfg(debug_assertions)]
     if !foo() {
+        //~^ if_not_else
         /* foo is false */
         println!("foo is false");
     } else {
diff --git a/src/tools/clippy/tests/ui/if_not_else.stderr b/src/tools/clippy/tests/ui/if_not_else.stderr
index b01cb5af11f7..f44dd0aabc86 100644
--- a/src/tools/clippy/tests/ui/if_not_else.stderr
+++ b/src/tools/clippy/tests/ui/if_not_else.stderr
@@ -3,6 +3,7 @@ error: unnecessary boolean `not` operation
    |
 LL | /     if !bla() {
 LL | |
+LL | |
 LL | |         println!("Bugs");
 LL | |     } else {
 LL | |         println!("Bunny");
@@ -17,15 +18,17 @@ LL ~     if bla() {
 LL +         println!("Bunny");
 LL +     } else {
 LL +
+LL + 
 LL +         println!("Bugs");
 LL +     }
    |
 
 error: unnecessary `!=` operation
-  --> tests/ui/if_not_else.rs:18:5
+  --> tests/ui/if_not_else.rs:19:5
    |
 LL | /     if 4 != 5 {
 LL | |
+LL | |
 LL | |         println!("Bugs");
 LL | |     } else {
 LL | |         println!("Bunny");
@@ -38,17 +41,18 @@ LL ~     if 4 == 5 {
 LL +         println!("Bunny");
 LL +     } else {
 LL +
+LL + 
 LL +         println!("Bugs");
 LL +     }
    |
 
 error: unnecessary boolean `not` operation
-  --> tests/ui/if_not_else.rs:32:5
+  --> tests/ui/if_not_else.rs:34:5
    |
 LL | /     if !(foo() && bla()) {
+LL | |
 LL | |         #[cfg(not(debug_assertions))]
 LL | |         println!("not debug");
-LL | |         #[cfg(debug_assertions)]
 ...  |
 LL | |         println!("both true");
 LL | |     }
@@ -59,6 +63,7 @@ help: try
 LL ~     if (foo() && bla()) {
 LL +         println!("both true");
 LL +     } else {
+LL +
 LL +         #[cfg(not(debug_assertions))]
 LL +         println!("not debug");
 LL +         #[cfg(debug_assertions)]
@@ -74,9 +79,10 @@ LL +     }
    |
 
 error: unnecessary boolean `not` operation
-  --> tests/ui/if_not_else.rs:50:5
+  --> tests/ui/if_not_else.rs:53:5
    |
 LL | /     if !foo() {
+LL | |
 LL | |         /* foo is false */
 LL | |         println!("foo is false");
 LL | |     } else {
@@ -89,15 +95,17 @@ help: try
 LL ~     if foo() {
 LL +         println!("foo"); /* foo */
 LL +     } else {
+LL +
 LL +         /* foo is false */
 LL +         println!("foo is false");
 LL +     }
    |
 
 error: unnecessary boolean `not` operation
-  --> tests/ui/if_not_else.rs:57:5
+  --> tests/ui/if_not_else.rs:61:5
    |
 LL | /     if !bla() {
+LL | |
 LL | |         // bla is false
 LL | |         println!("bla");
 LL | |     } else {
@@ -110,15 +118,17 @@ help: try
 LL ~     if bla() {
 LL +         println!("bla"); // bla
 LL +     } else {
+LL +
 LL +         // bla is false
 LL +         println!("bla");
 LL +     }
    |
 
 error: unnecessary boolean `not` operation
-  --> tests/ui/if_not_else.rs:67:5
+  --> tests/ui/if_not_else.rs:72:5
    |
 LL | /     if !foo() {
+LL | |
 LL | |         /* foo is false */
 LL | |         println!("foo is false");
 LL | |     } else {
@@ -131,6 +141,7 @@ help: try
 LL ~     if foo() {
 LL +         println!("foo"); /* foo */
 LL +     } else {
+LL +
 LL +         /* foo is false */
 LL +         println!("foo is false");
 LL +     }
diff --git a/src/tools/clippy/tests/ui/if_not_else_bittest.rs b/src/tools/clippy/tests/ui/if_not_else_bittest.rs
index 586ce6ce1bcc..205823c5a8ab 100644
--- a/src/tools/clippy/tests/ui/if_not_else_bittest.rs
+++ b/src/tools/clippy/tests/ui/if_not_else_bittest.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![deny(clippy::if_not_else)]
 
 fn show_permissions(flags: u32) {
diff --git a/src/tools/clippy/tests/ui/if_same_then_else.rs b/src/tools/clippy/tests/ui/if_same_then_else.rs
index d53e1383d845..6d2e63e7299a 100644
--- a/src/tools/clippy/tests/ui/if_same_then_else.rs
+++ b/src/tools/clippy/tests/ui/if_same_then_else.rs
@@ -37,7 +37,7 @@ fn if_same_then_else() {
         0..=10;
         foo();
     }
-    //~^^^^^^^^^^^^^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^^^^^^^^^^^^^ if_same_then_else
 
     if true {
         Foo { bar: 42 };
@@ -65,10 +65,10 @@ fn if_same_then_else() {
     }
 
     let _ = if true { 0.0 } else { 0.0 };
-    //~^ ERROR: this `if` has identical blocks
+    //~^ if_same_then_else
 
     let _ = if true { -0.0 } else { -0.0 };
-    //~^ ERROR: this `if` has identical blocks
+    //~^ if_same_then_else
 
     let _ = if true { 0.0 } else { -0.0 };
 
@@ -80,7 +80,7 @@ fn if_same_then_else() {
     }
 
     let _ = if true { 42 } else { 42 };
-    //~^ ERROR: this `if` has identical blocks
+    //~^ if_same_then_else
 
     if true {
         let bar = if true { 42 } else { 43 };
@@ -97,7 +97,7 @@ fn if_same_then_else() {
         }
         bar + 1;
     }
-    //~^^^^^^^^^^^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^^^^^^^^^^^ if_same_then_else
 
     if true {
         let _ = match 42 {
@@ -240,6 +240,7 @@ mod issue_11213 {
         } else {
             0_u8.is_power_of_two()
         }
+        //~^^^^^ if_same_then_else
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/if_same_then_else2.rs b/src/tools/clippy/tests/ui/if_same_then_else2.rs
index e23c77b08274..5b74aecdacbe 100644
--- a/src/tools/clippy/tests/ui/if_same_then_else2.rs
+++ b/src/tools/clippy/tests/ui/if_same_then_else2.rs
@@ -31,21 +31,21 @@ fn if_same_then_else2() -> Result<&'static str, ()> {
             }
         }
     }
-    //~^^^^^^^^^^^^^^^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^^^^^^^^^^^^^^^ if_same_then_else
 
     if true {
         if let Some(a) = Some(42) {}
     } else {
         if let Some(a) = Some(42) {}
     }
-    //~^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^ if_same_then_else
 
     if true {
         if let (1, .., 3) = (1, 2, 3) {}
     } else {
         if let (1, .., 3) = (1, 2, 3) {}
     }
-    //~^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^ if_same_then_else
 
     if true {
         if let (1, .., 3) = (1, 2, 3) {}
@@ -91,14 +91,14 @@ fn if_same_then_else2() -> Result<&'static str, ()> {
 
     // Same NaNs
     let _ = if true { f32::NAN } else { f32::NAN };
-    //~^ ERROR: this `if` has identical blocks
+    //~^ if_same_then_else
 
     if true {
         Ok("foo")?;
     } else {
         Ok("foo")?;
     }
-    //~^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^ if_same_then_else
 
     if true {
         let foo = "";
@@ -124,7 +124,7 @@ fn if_same_then_else2() -> Result<&'static str, ()> {
         let foo = "";
         return Ok(&foo[0..]);
     }
-    //~^^^^^^^ ERROR: this `if` has identical blocks
+    //~^^^^^^^ if_same_then_else
 
     // False positive `if_same_then_else`: `let (x, y)` vs. `let (y, x)`; see issue #3559.
     if true {
diff --git a/src/tools/clippy/tests/ui/if_then_some_else_none.fixed b/src/tools/clippy/tests/ui/if_then_some_else_none.fixed
index 1f47dddcbc40..f774608712d1 100644
--- a/src/tools/clippy/tests/ui/if_then_some_else_none.fixed
+++ b/src/tools/clippy/tests/ui/if_then_some_else_none.fixed
@@ -11,12 +11,12 @@ fn main() {
     // Should issue an error. Binary expression `o < 32` should be parenthesized.
     let x = Some(5);
     let _ = x.and_then(|o| (o < 32).then_some(o));
-    //~^ ERROR: this could be simplified with `bool::then_some`
+    //~^ if_then_some_else_none
 
     // Should issue an error. Unary expression `!x` should be parenthesized.
     let x = true;
     let _ = (!x).then_some(0);
-    //~^ ERROR: this could be simplified with `bool::then_some`
+    //~^ if_then_some_else_none
 
     // Should not issue an error since the `else` block has a statement besides `None`.
     let _ = if foo() {
@@ -115,6 +115,7 @@ fn issue11394(b: bool, v: Result<(), ()>) -> Result<(), ()> {
 
 fn issue13407(s: &str) -> Option<bool> {
     (s == "1").then(|| true)
+    //~^ if_then_some_else_none
 }
 
 const fn issue12103(x: u32) -> Option<u32> {
diff --git a/src/tools/clippy/tests/ui/if_then_some_else_none.rs b/src/tools/clippy/tests/ui/if_then_some_else_none.rs
index 499f008fb876..8b8ff0a6ea00 100644
--- a/src/tools/clippy/tests/ui/if_then_some_else_none.rs
+++ b/src/tools/clippy/tests/ui/if_then_some_else_none.rs
@@ -4,7 +4,8 @@
 fn main() {
     // Should issue an error.
     let _ = if foo() {
-        //~^ ERROR: this could be simplified with `bool::then`
+        //~^ if_then_some_else_none
+
         println!("true!");
         Some("foo")
     } else {
@@ -13,7 +14,8 @@ fn main() {
 
     // Should issue an error when macros are used.
     let _ = if matches!(true, true) {
-        //~^ ERROR: this could be simplified with `bool::then`
+        //~^ if_then_some_else_none
+
         println!("true!");
         Some(matches!(true, false))
     } else {
@@ -23,12 +25,12 @@ fn main() {
     // Should issue an error. Binary expression `o < 32` should be parenthesized.
     let x = Some(5);
     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
-    //~^ ERROR: this could be simplified with `bool::then_some`
+    //~^ if_then_some_else_none
 
     // Should issue an error. Unary expression `!x` should be parenthesized.
     let x = true;
     let _ = if !x { Some(0) } else { None };
-    //~^ ERROR: this could be simplified with `bool::then_some`
+    //~^ if_then_some_else_none
 
     // Should not issue an error since the `else` block has a statement besides `None`.
     let _ = if foo() {
@@ -84,7 +86,8 @@ fn _msrv_1_49() {
 #[clippy::msrv = "1.50"]
 fn _msrv_1_50() {
     let _ = if foo() {
-        //~^ ERROR: this could be simplified with `bool::then`
+        //~^ if_then_some_else_none
+
         println!("true!");
         Some(150)
     } else {
@@ -133,6 +136,7 @@ fn issue11394(b: bool, v: Result<(), ()>) -> Result<(), ()> {
 
 fn issue13407(s: &str) -> Option<bool> {
     if s == "1" { Some(true) } else { None }
+    //~^ if_then_some_else_none
 }
 
 const fn issue12103(x: u32) -> Option<u32> {
diff --git a/src/tools/clippy/tests/ui/if_then_some_else_none.stderr b/src/tools/clippy/tests/ui/if_then_some_else_none.stderr
index e7bc66b3ee88..71285574ef24 100644
--- a/src/tools/clippy/tests/ui/if_then_some_else_none.stderr
+++ b/src/tools/clippy/tests/ui/if_then_some_else_none.stderr
@@ -4,9 +4,9 @@ error: this could be simplified with `bool::then`
 LL |       let _ = if foo() {
    |  _____________^
 LL | |
+LL | |
 LL | |         println!("true!");
-LL | |         Some("foo")
-LL | |     } else {
+...  |
 LL | |         None
 LL | |     };
    | |_____^ help: try: `foo().then(||  { println!("true!"); "foo" })`
@@ -15,45 +15,45 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::if_then_some_else_none)]`
 
 error: this could be simplified with `bool::then`
-  --> tests/ui/if_then_some_else_none.rs:15:13
+  --> tests/ui/if_then_some_else_none.rs:16:13
    |
 LL |       let _ = if matches!(true, true) {
    |  _____________^
 LL | |
+LL | |
 LL | |         println!("true!");
-LL | |         Some(matches!(true, false))
-LL | |     } else {
+...  |
 LL | |         None
 LL | |     };
    | |_____^ help: try: `matches!(true, true).then(||  { println!("true!"); matches!(true, false) })`
 
 error: this could be simplified with `bool::then_some`
-  --> tests/ui/if_then_some_else_none.rs:25:28
+  --> tests/ui/if_then_some_else_none.rs:27:28
    |
 LL |     let _ = x.and_then(|o| if o < 32 { Some(o) } else { None });
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(o < 32).then_some(o)`
 
 error: this could be simplified with `bool::then_some`
-  --> tests/ui/if_then_some_else_none.rs:30:13
+  --> tests/ui/if_then_some_else_none.rs:32:13
    |
 LL |     let _ = if !x { Some(0) } else { None };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(!x).then_some(0)`
 
 error: this could be simplified with `bool::then`
-  --> tests/ui/if_then_some_else_none.rs:86:13
+  --> tests/ui/if_then_some_else_none.rs:88:13
    |
 LL |       let _ = if foo() {
    |  _____________^
 LL | |
+LL | |
 LL | |         println!("true!");
-LL | |         Some(150)
-LL | |     } else {
+...  |
 LL | |         None
 LL | |     };
    | |_____^ help: try: `foo().then(||  { println!("true!"); 150 })`
 
 error: this could be simplified with `bool::then`
-  --> tests/ui/if_then_some_else_none.rs:135:5
+  --> tests/ui/if_then_some_else_none.rs:138:5
    |
 LL |     if s == "1" { Some(true) } else { None }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(s == "1").then(|| true)`
diff --git a/src/tools/clippy/tests/ui/ifs_same_cond.rs b/src/tools/clippy/tests/ui/ifs_same_cond.rs
index ad77346b75f2..6ecb7cb1eba9 100644
--- a/src/tools/clippy/tests/ui/ifs_same_cond.rs
+++ b/src/tools/clippy/tests/ui/ifs_same_cond.rs
@@ -12,18 +12,18 @@ fn ifs_same_cond() {
 
     if b {
     } else if b {
-        //~^ ERROR: this `if` has the same condition as a previous `if`
+        //~^ ifs_same_cond
     }
 
     if a == 1 {
     } else if a == 1 {
-        //~^ ERROR: this `if` has the same condition as a previous `if`
+        //~^ ifs_same_cond
     }
 
     if 2 * a == 1 {
     } else if 2 * a == 2 {
     } else if 2 * a == 1 {
-        //~^ ERROR: this `if` has the same condition as a previous `if`
+        //~^ ifs_same_cond
     } else if a == 1 {
     }
 
@@ -56,7 +56,8 @@ fn issue10272() {
     let a = String::from("ha");
     if a.contains("ah") {
     } else if a.contains("ah") {
-        //~^ ERROR: this `if` has the same condition as a previous `if`
+        //~^ ifs_same_cond
+
         // Trigger this lint
     } else if a.contains("ha") {
     } else if a == "wow" {
diff --git a/src/tools/clippy/tests/ui/impl.rs b/src/tools/clippy/tests/ui/impl.rs
index 7f452cb46e06..1b9e4a5cdee1 100644
--- a/src/tools/clippy/tests/ui/impl.rs
+++ b/src/tools/clippy/tests/ui/impl.rs
@@ -8,7 +8,8 @@ impl MyStruct {
 }
 
 impl MyStruct {
-    //~^ ERROR: multiple implementations of this structure
+    //~^ multiple_inherent_impl
+
     fn second() {}
 }
 
@@ -23,7 +24,8 @@ mod submod {
     }
 
     impl super::MyStruct {
-        //~^ ERROR: multiple implementations of this structure
+        //~^ multiple_inherent_impl
+
         fn third() {}
     }
 }
@@ -44,7 +46,8 @@ impl WithArgs<u64> {
     fn f2() {}
 }
 impl WithArgs<u64> {
-    //~^ ERROR: multiple implementations of this structure
+    //~^ multiple_inherent_impl
+
     fn f3() {}
 }
 
@@ -66,6 +69,6 @@ impl OneAllowedImpl {}
 #[allow(clippy::multiple_inherent_impl)]
 impl OneAllowedImpl {}
 impl OneAllowedImpl {} // Lint, only one of the three blocks is allowed.
-//~^ ERROR: multiple implementations of this structure
+//~^ multiple_inherent_impl
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/impl.stderr b/src/tools/clippy/tests/ui/impl.stderr
index bb906957a0d3..355927b78253 100644
--- a/src/tools/clippy/tests/ui/impl.stderr
+++ b/src/tools/clippy/tests/ui/impl.stderr
@@ -3,6 +3,7 @@ error: multiple implementations of this structure
    |
 LL | / impl MyStruct {
 LL | |
+LL | |
 LL | |     fn second() {}
 LL | | }
    | |_^
@@ -18,10 +19,11 @@ LL | | }
    = help: to override `-D warnings` add `#[allow(clippy::multiple_inherent_impl)]`
 
 error: multiple implementations of this structure
-  --> tests/ui/impl.rs:25:5
+  --> tests/ui/impl.rs:26:5
    |
 LL | /     impl super::MyStruct {
 LL | |
+LL | |
 LL | |         fn third() {}
 LL | |     }
    | |_____^
@@ -35,16 +37,17 @@ LL | | }
    | |_^
 
 error: multiple implementations of this structure
-  --> tests/ui/impl.rs:46:1
+  --> tests/ui/impl.rs:48:1
    |
 LL | / impl WithArgs<u64> {
 LL | |
+LL | |
 LL | |     fn f3() {}
 LL | | }
    | |_^
    |
 note: first implementation here
-  --> tests/ui/impl.rs:43:1
+  --> tests/ui/impl.rs:45:1
    |
 LL | / impl WithArgs<u64> {
 LL | |     fn f2() {}
@@ -52,13 +55,13 @@ LL | | }
    | |_^
 
 error: multiple implementations of this structure
-  --> tests/ui/impl.rs:68:1
+  --> tests/ui/impl.rs:71:1
    |
 LL | impl OneAllowedImpl {} // Lint, only one of the three blocks is allowed.
    | ^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first implementation here
-  --> tests/ui/impl.rs:65:1
+  --> tests/ui/impl.rs:68:1
    |
 LL | impl OneAllowedImpl {}
    | ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/impl_trait_in_params.rs b/src/tools/clippy/tests/ui/impl_trait_in_params.rs
index a6251a370d1d..2039f6339a87 100644
--- a/src/tools/clippy/tests/ui/impl_trait_in_params.rs
+++ b/src/tools/clippy/tests/ui/impl_trait_in_params.rs
@@ -7,9 +7,10 @@ pub trait AnotherTrait<T> {}
 
 // Should warn
 pub fn a(_: impl Trait) {}
-//~^ ERROR: `impl Trait` used as a function parameter
+//~^ impl_trait_in_params
+
 pub fn c<C: Trait>(_: C, _: impl Trait) {}
-//~^ ERROR: `impl Trait` used as a function parameter
+//~^ impl_trait_in_params
 
 // Shouldn't warn
 
@@ -33,10 +34,12 @@ trait Private {
 
 struct S;
 impl S {
-    pub fn h(_: impl Trait) {} //~ ERROR: `impl Trait` used as a function parameter
+    pub fn h(_: impl Trait) {}
+    //~^ impl_trait_in_params
     fn i(_: impl Trait) {}
     pub fn j<J: Trait>(_: J) {}
-    pub fn k<K: AnotherTrait<u32>>(_: K, _: impl AnotherTrait<u32>) {} //~ ERROR: `impl Trait` used as a function parameter
+    pub fn k<K: AnotherTrait<u32>>(_: K, _: impl AnotherTrait<u32>) {}
+    //~^ impl_trait_in_params
 }
 
 // Trying with traits
diff --git a/src/tools/clippy/tests/ui/impl_trait_in_params.stderr b/src/tools/clippy/tests/ui/impl_trait_in_params.stderr
index 0ec0a34ea8db..c904d5843c93 100644
--- a/src/tools/clippy/tests/ui/impl_trait_in_params.stderr
+++ b/src/tools/clippy/tests/ui/impl_trait_in_params.stderr
@@ -12,7 +12,7 @@ LL | pub fn a<{ /* Generic name */ }: Trait>(_: impl Trait) {}
    |         +++++++++++++++++++++++++++++++
 
 error: `impl Trait` used as a function parameter
-  --> tests/ui/impl_trait_in_params.rs:11:29
+  --> tests/ui/impl_trait_in_params.rs:12:29
    |
 LL | pub fn c<C: Trait>(_: C, _: impl Trait) {}
    |                             ^^^^^^^^^^
@@ -23,7 +23,7 @@ LL | pub fn c<C: Trait, { /* Generic name */ }: Trait>(_: C, _: impl Trait) {}
    |                  +++++++++++++++++++++++++++++++
 
 error: `impl Trait` used as a function parameter
-  --> tests/ui/impl_trait_in_params.rs:36:17
+  --> tests/ui/impl_trait_in_params.rs:37:17
    |
 LL |     pub fn h(_: impl Trait) {}
    |                 ^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |     pub fn h<{ /* Generic name */ }: Trait>(_: impl Trait) {}
    |             +++++++++++++++++++++++++++++++
 
 error: `impl Trait` used as a function parameter
-  --> tests/ui/impl_trait_in_params.rs:39:45
+  --> tests/ui/impl_trait_in_params.rs:41:45
    |
 LL |     pub fn k<K: AnotherTrait<u32>>(_: K, _: impl AnotherTrait<u32>) {}
    |                                             ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/implicit_clone.fixed b/src/tools/clippy/tests/ui/implicit_clone.fixed
index 98556b4dd303..d60d1cb0ec04 100644
--- a/src/tools/clippy/tests/ui/implicit_clone.fixed
+++ b/src/tools/clippy/tests/ui/implicit_clone.fixed
@@ -63,12 +63,15 @@ fn main() {
     let vec = vec![5];
     let _ = return_owned_from_slice(&vec);
     let _ = vec.clone();
+    //~^ implicit_clone
     let _ = vec.clone();
+    //~^ implicit_clone
 
     let vec_ref = &vec;
     let _ = return_owned_from_slice(vec_ref);
     let _ = vec_ref.to_owned();
     let _ = vec_ref.clone();
+    //~^ implicit_clone
 
     // we expect no lint for this
     let _ = weird::to_vec(&vec);
@@ -81,10 +84,12 @@ fn main() {
 
     let str = "hello world".to_string();
     let _ = str.clone();
+    //~^ implicit_clone
 
     // testing w/ an arbitrary type
     let kitten = Kitten {};
     let _ = kitten.clone();
+    //~^ implicit_clone
     let _ = own_same_from_ref(&kitten);
     // this shouldn't lint
     let _ = kitten.to_vec();
@@ -95,11 +100,15 @@ fn main() {
 
     let pathbuf = PathBuf::new();
     let _ = pathbuf.clone();
+    //~^ implicit_clone
     let _ = pathbuf.clone();
+    //~^ implicit_clone
 
     let os_string = OsString::from("foo");
     let _ = os_string.clone();
+    //~^ implicit_clone
     let _ = os_string.clone();
+    //~^ implicit_clone
 
     // we expect no lints for this
     let os_str = OsStr::new("foo");
@@ -111,9 +120,11 @@ fn main() {
     let pathbuf_ref = &pathbuf_ref;
     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&PathBuf`
     let _ = (*pathbuf_ref).clone();
+    //~^ implicit_clone
     let pathbuf_ref = &pathbuf_ref;
     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&&PathBuf`
     let _ = (**pathbuf_ref).clone();
+    //~^ implicit_clone
 
     struct NoClone;
     impl ToOwned for NoClone {
diff --git a/src/tools/clippy/tests/ui/implicit_clone.rs b/src/tools/clippy/tests/ui/implicit_clone.rs
index a064bd23a338..b96828f28c82 100644
--- a/src/tools/clippy/tests/ui/implicit_clone.rs
+++ b/src/tools/clippy/tests/ui/implicit_clone.rs
@@ -63,12 +63,15 @@ fn main() {
     let vec = vec![5];
     let _ = return_owned_from_slice(&vec);
     let _ = vec.to_owned();
+    //~^ implicit_clone
     let _ = vec.to_vec();
+    //~^ implicit_clone
 
     let vec_ref = &vec;
     let _ = return_owned_from_slice(vec_ref);
     let _ = vec_ref.to_owned();
     let _ = vec_ref.to_vec();
+    //~^ implicit_clone
 
     // we expect no lint for this
     let _ = weird::to_vec(&vec);
@@ -81,10 +84,12 @@ fn main() {
 
     let str = "hello world".to_string();
     let _ = str.to_owned();
+    //~^ implicit_clone
 
     // testing w/ an arbitrary type
     let kitten = Kitten {};
     let _ = kitten.to_owned();
+    //~^ implicit_clone
     let _ = own_same_from_ref(&kitten);
     // this shouldn't lint
     let _ = kitten.to_vec();
@@ -95,11 +100,15 @@ fn main() {
 
     let pathbuf = PathBuf::new();
     let _ = pathbuf.to_owned();
+    //~^ implicit_clone
     let _ = pathbuf.to_path_buf();
+    //~^ implicit_clone
 
     let os_string = OsString::from("foo");
     let _ = os_string.to_owned();
+    //~^ implicit_clone
     let _ = os_string.to_os_string();
+    //~^ implicit_clone
 
     // we expect no lints for this
     let os_str = OsStr::new("foo");
@@ -111,9 +120,11 @@ fn main() {
     let pathbuf_ref = &pathbuf_ref;
     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&PathBuf`
     let _ = pathbuf_ref.to_path_buf();
+    //~^ implicit_clone
     let pathbuf_ref = &pathbuf_ref;
     let _ = pathbuf_ref.to_owned(); // Don't lint. Returns `&&PathBuf`
     let _ = pathbuf_ref.to_path_buf();
+    //~^ implicit_clone
 
     struct NoClone;
     impl ToOwned for NoClone {
diff --git a/src/tools/clippy/tests/ui/implicit_clone.stderr b/src/tools/clippy/tests/ui/implicit_clone.stderr
index 31c212eba2c8..1eb6ff1fe429 100644
--- a/src/tools/clippy/tests/ui/implicit_clone.stderr
+++ b/src/tools/clippy/tests/ui/implicit_clone.stderr
@@ -8,61 +8,61 @@ LL |     let _ = vec.to_owned();
    = help: to override `-D warnings` add `#[allow(clippy::implicit_clone)]`
 
 error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:66:13
+  --> tests/ui/implicit_clone.rs:67:13
    |
 LL |     let _ = vec.to_vec();
    |             ^^^^^^^^^^^^ help: consider using: `vec.clone()`
 
 error: implicitly cloning a `Vec` by calling `to_vec` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:71:13
+  --> tests/ui/implicit_clone.rs:73:13
    |
 LL |     let _ = vec_ref.to_vec();
    |             ^^^^^^^^^^^^^^^^ help: consider using: `vec_ref.clone()`
 
 error: implicitly cloning a `String` by calling `to_owned` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:83:13
+  --> tests/ui/implicit_clone.rs:86:13
    |
 LL |     let _ = str.to_owned();
    |             ^^^^^^^^^^^^^^ help: consider using: `str.clone()`
 
 error: implicitly cloning a `Kitten` by calling `to_owned` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:87:13
+  --> tests/ui/implicit_clone.rs:91:13
    |
 LL |     let _ = kitten.to_owned();
    |             ^^^^^^^^^^^^^^^^^ help: consider using: `kitten.clone()`
 
 error: implicitly cloning a `PathBuf` by calling `to_owned` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:97:13
+  --> tests/ui/implicit_clone.rs:102:13
    |
 LL |     let _ = pathbuf.to_owned();
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `pathbuf.clone()`
 
 error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:98:13
+  --> tests/ui/implicit_clone.rs:104:13
    |
 LL |     let _ = pathbuf.to_path_buf();
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `pathbuf.clone()`
 
 error: implicitly cloning a `OsString` by calling `to_owned` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:101:13
+  --> tests/ui/implicit_clone.rs:108:13
    |
 LL |     let _ = os_string.to_owned();
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider using: `os_string.clone()`
 
 error: implicitly cloning a `OsString` by calling `to_os_string` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:102:13
+  --> tests/ui/implicit_clone.rs:110:13
    |
 LL |     let _ = os_string.to_os_string();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `os_string.clone()`
 
 error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:113:13
+  --> tests/ui/implicit_clone.rs:122:13
    |
 LL |     let _ = pathbuf_ref.to_path_buf();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(*pathbuf_ref).clone()`
 
 error: implicitly cloning a `PathBuf` by calling `to_path_buf` on its dereferenced type
-  --> tests/ui/implicit_clone.rs:116:13
+  --> tests/ui/implicit_clone.rs:126:13
    |
 LL |     let _ = pathbuf_ref.to_path_buf();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(**pathbuf_ref).clone()`
diff --git a/src/tools/clippy/tests/ui/implicit_hasher.fixed b/src/tools/clippy/tests/ui/implicit_hasher.fixed
index 971746ae95d7..bea5b9afc43a 100644
--- a/src/tools/clippy/tests/ui/implicit_hasher.fixed
+++ b/src/tools/clippy/tests/ui/implicit_hasher.fixed
@@ -13,6 +13,7 @@ pub trait Foo<T>: Sized {
 }
 
 impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashMap<K, V, S> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         // OK, don't suggest to modify these
         let _: HashMap<i32, i32> = HashMap::new();
@@ -22,11 +23,13 @@ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashMap
     }
 }
 impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for (HashMap<K, V, S>,) {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         ((HashMap::default(),), (HashMap::with_capacity_and_hasher(10, Default::default()),))
     }
 }
 impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashMap<String, String, S> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
     }
@@ -44,11 +47,13 @@ impl<S: BuildHasher + Default> Foo<i64> for HashMap<String, String, S> {
 }
 
 impl<T: Hash + Eq, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashSet<T, S> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
     }
 }
 impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashSet<String, S> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
     }
@@ -66,14 +71,17 @@ impl<S: BuildHasher + Default> Foo<i64> for HashSet<String, S> {
 }
 
 pub fn map<S: ::std::hash::BuildHasher>(map: &mut HashMap<i32, i32, S>) {}
+//~^ implicit_hasher
 
 pub fn set<S: ::std::hash::BuildHasher>(set: &mut HashSet<i32, S>) {}
+//~^ implicit_hasher
 
 #[inline_macros]
 pub mod gen_ {
     use super::*;
     inline! {
         impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<u8> for HashMap<K, V, S> {
+        //~^ implicit_hasher
             fn make() -> (Self, Self) {
                 (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
             }
@@ -98,5 +106,6 @@ external! {
 
 // #7712
 pub async fn election_vote<S: ::std::hash::BuildHasher>(_data: HashMap<i32, i32, S>) {}
+//~^ implicit_hasher
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/implicit_hasher.rs b/src/tools/clippy/tests/ui/implicit_hasher.rs
index b34aa1f81374..afdf4da61650 100644
--- a/src/tools/clippy/tests/ui/implicit_hasher.rs
+++ b/src/tools/clippy/tests/ui/implicit_hasher.rs
@@ -13,6 +13,7 @@ pub trait Foo<T>: Sized {
 }
 
 impl<K: Hash + Eq, V> Foo<i8> for HashMap<K, V> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         // OK, don't suggest to modify these
         let _: HashMap<i32, i32> = HashMap::new();
@@ -22,11 +23,13 @@ impl<K: Hash + Eq, V> Foo<i8> for HashMap<K, V> {
     }
 }
 impl<K: Hash + Eq, V> Foo<i8> for (HashMap<K, V>,) {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         ((HashMap::new(),), (HashMap::with_capacity(10),))
     }
 }
 impl Foo<i16> for HashMap<String, String> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         (HashMap::new(), HashMap::with_capacity(10))
     }
@@ -44,11 +47,13 @@ impl<S: BuildHasher + Default> Foo<i64> for HashMap<String, String, S> {
 }
 
 impl<T: Hash + Eq> Foo<i8> for HashSet<T> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         (HashSet::new(), HashSet::with_capacity(10))
     }
 }
 impl Foo<i16> for HashSet<String> {
+    //~^ implicit_hasher
     fn make() -> (Self, Self) {
         (HashSet::new(), HashSet::with_capacity(10))
     }
@@ -66,14 +71,17 @@ impl<S: BuildHasher + Default> Foo<i64> for HashSet<String, S> {
 }
 
 pub fn map(map: &mut HashMap<i32, i32>) {}
+//~^ implicit_hasher
 
 pub fn set(set: &mut HashSet<i32>) {}
+//~^ implicit_hasher
 
 #[inline_macros]
 pub mod gen_ {
     use super::*;
     inline! {
         impl<K: Hash + Eq, V> Foo<u8> for HashMap<K, V> {
+        //~^ implicit_hasher
             fn make() -> (Self, Self) {
                 (HashMap::new(), HashMap::with_capacity(10))
             }
@@ -98,5 +106,6 @@ external! {
 
 // #7712
 pub async fn election_vote(_data: HashMap<i32, i32>) {}
+//~^ implicit_hasher
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/implicit_hasher.stderr b/src/tools/clippy/tests/ui/implicit_hasher.stderr
index 01d08a1bd9b2..6735998ed654 100644
--- a/src/tools/clippy/tests/ui/implicit_hasher.stderr
+++ b/src/tools/clippy/tests/ui/implicit_hasher.stderr
@@ -12,14 +12,14 @@ LL | #![deny(clippy::implicit_hasher)]
 help: add a type parameter for `BuildHasher`
    |
 LL ~ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashMap<K, V, S> {
-LL |     fn make() -> (Self, Self) {
+LL |
 ...
 LL |
 LL ~         (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
    |
 
 error: impl for `HashMap` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:24:36
+  --> tests/ui/implicit_hasher.rs:25:36
    |
 LL | impl<K: Hash + Eq, V> Foo<i8> for (HashMap<K, V>,) {
    |                                    ^^^^^^^^^^^^^
@@ -27,12 +27,13 @@ LL | impl<K: Hash + Eq, V> Foo<i8> for (HashMap<K, V>,) {
 help: add a type parameter for `BuildHasher`
    |
 LL ~ impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<i8> for (HashMap<K, V, S>,) {
+LL |
 LL |     fn make() -> (Self, Self) {
 LL ~         ((HashMap::default(),), (HashMap::with_capacity_and_hasher(10, Default::default()),))
    |
 
 error: impl for `HashMap` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:29:19
+  --> tests/ui/implicit_hasher.rs:31:19
    |
 LL | impl Foo<i16> for HashMap<String, String> {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,12 +41,13 @@ LL | impl Foo<i16> for HashMap<String, String> {
 help: add a type parameter for `BuildHasher`
    |
 LL ~ impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashMap<String, String, S> {
+LL |
 LL |     fn make() -> (Self, Self) {
 LL ~         (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
    |
 
 error: impl for `HashSet` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:46:32
+  --> tests/ui/implicit_hasher.rs:49:32
    |
 LL | impl<T: Hash + Eq> Foo<i8> for HashSet<T> {
    |                                ^^^^^^^^^^
@@ -53,12 +55,13 @@ LL | impl<T: Hash + Eq> Foo<i8> for HashSet<T> {
 help: add a type parameter for `BuildHasher`
    |
 LL ~ impl<T: Hash + Eq, S: ::std::hash::BuildHasher + Default> Foo<i8> for HashSet<T, S> {
+LL |
 LL |     fn make() -> (Self, Self) {
 LL ~         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
    |
 
 error: impl for `HashSet` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:51:19
+  --> tests/ui/implicit_hasher.rs:55:19
    |
 LL | impl Foo<i16> for HashSet<String> {
    |                   ^^^^^^^^^^^^^^^
@@ -66,12 +69,13 @@ LL | impl Foo<i16> for HashSet<String> {
 help: add a type parameter for `BuildHasher`
    |
 LL ~ impl<S: ::std::hash::BuildHasher + Default> Foo<i16> for HashSet<String, S> {
+LL |
 LL |     fn make() -> (Self, Self) {
 LL ~         (HashSet::default(), HashSet::with_capacity_and_hasher(10, Default::default()))
    |
 
 error: parameter of type `HashMap` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:68:22
+  --> tests/ui/implicit_hasher.rs:73:22
    |
 LL | pub fn map(map: &mut HashMap<i32, i32>) {}
    |                      ^^^^^^^^^^^^^^^^^
@@ -82,7 +86,7 @@ LL | pub fn map<S: ::std::hash::BuildHasher>(map: &mut HashMap<i32, i32, S>) {}
    |           +++++++++++++++++++++++++++++                           +++
 
 error: parameter of type `HashSet` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:70:22
+  --> tests/ui/implicit_hasher.rs:76:22
    |
 LL | pub fn set(set: &mut HashSet<i32>) {}
    |                      ^^^^^^^^^^^^
@@ -93,7 +97,7 @@ LL | pub fn set<S: ::std::hash::BuildHasher>(set: &mut HashSet<i32, S>) {}
    |           +++++++++++++++++++++++++++++                      +++
 
 error: impl for `HashMap` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:76:43
+  --> tests/ui/implicit_hasher.rs:83:43
    |
 LL |         impl<K: Hash + Eq, V> Foo<u8> for HashMap<K, V> {
    |                                           ^^^^^^^^^^^^^
@@ -102,12 +106,13 @@ LL |         impl<K: Hash + Eq, V> Foo<u8> for HashMap<K, V> {
 help: add a type parameter for `BuildHasher`
    |
 LL ~         impl<K: Hash + Eq, V, S: ::std::hash::BuildHasher + Default> Foo<u8> for HashMap<K, V, S> {
+LL |
 LL |             fn make() -> (Self, Self) {
 LL ~                 (HashMap::default(), HashMap::with_capacity_and_hasher(10, Default::default()))
    |
 
 error: parameter of type `HashMap` should be generalized over different hashers
-  --> tests/ui/implicit_hasher.rs:100:35
+  --> tests/ui/implicit_hasher.rs:108:35
    |
 LL | pub async fn election_vote(_data: HashMap<i32, i32>) {}
    |                                   ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/implicit_return.fixed b/src/tools/clippy/tests/ui/implicit_return.fixed
index 56fe29b4e677..1cb639b60a9a 100644
--- a/src/tools/clippy/tests/ui/implicit_return.fixed
+++ b/src/tools/clippy/tests/ui/implicit_return.fixed
@@ -13,17 +13,22 @@ fn test_end_of_fn() -> bool {
     }
 
     return true
+    //~^ implicit_return
 }
 
 fn test_if_block() -> bool {
     if true { return true } else { return false }
+    //~^ implicit_return
+    //~| implicit_return
 }
 
 #[rustfmt::skip]
 fn test_match(x: bool) -> bool {
     match x {
         true => return false,
+        //~^ implicit_return
         false => { return true },
+        //~^ implicit_return
     }
 }
 
@@ -37,6 +42,7 @@ fn test_match_with_unreachable(x: bool) -> bool {
 fn test_loop() -> bool {
     loop {
         return true;
+        //~^ implicit_return
     }
 }
 
@@ -44,6 +50,7 @@ fn test_loop_with_block() -> bool {
     loop {
         {
             return true;
+            //~^ implicit_return
         }
     }
 }
@@ -52,6 +59,7 @@ fn test_loop_with_nests() -> bool {
     loop {
         if true {
             return true;
+            //~^ implicit_return
         } else {
             let _ = true;
         }
@@ -70,7 +78,9 @@ fn test_loop_with_if_let() -> bool {
 fn test_closure() {
     #[rustfmt::skip]
     let _ = || { return true };
+    //~^ implicit_return
     let _ = || return true;
+    //~^ implicit_return
 }
 
 fn test_panic() -> bool {
@@ -79,6 +89,7 @@ fn test_panic() -> bool {
 
 fn test_return_macro() -> String {
     return format!("test {}", "test")
+    //~^ implicit_return
 }
 
 fn macro_branch_test() -> bool {
@@ -88,17 +99,20 @@ fn macro_branch_test() -> bool {
         };
     }
     return m!(true, false)
+    //~^ implicit_return
 }
 
 fn loop_test() -> bool {
     'outer: loop {
         if true {
             return true;
+            //~^ implicit_return
         }
 
         let _ = loop {
             if false {
                 return false;
+                //~^ implicit_return
             }
             if true {
                 break true;
@@ -117,6 +131,7 @@ fn loop_macro_test() -> bool {
         m!(true);
     }
 }
+//~^^^^ implicit_return
 
 fn divergent_test() -> bool {
     fn diverge() -> ! {
@@ -128,6 +143,7 @@ fn divergent_test() -> bool {
 // issue #6940
 async fn foo() -> bool {
     return true
+    //~^ implicit_return
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/implicit_return.rs b/src/tools/clippy/tests/ui/implicit_return.rs
index f066ce20cfd1..99d75e4987e4 100644
--- a/src/tools/clippy/tests/ui/implicit_return.rs
+++ b/src/tools/clippy/tests/ui/implicit_return.rs
@@ -13,17 +13,22 @@ fn test_end_of_fn() -> bool {
     }
 
     true
+    //~^ implicit_return
 }
 
 fn test_if_block() -> bool {
     if true { true } else { false }
+    //~^ implicit_return
+    //~| implicit_return
 }
 
 #[rustfmt::skip]
 fn test_match(x: bool) -> bool {
     match x {
         true => false,
+        //~^ implicit_return
         false => { true },
+        //~^ implicit_return
     }
 }
 
@@ -37,6 +42,7 @@ fn test_match_with_unreachable(x: bool) -> bool {
 fn test_loop() -> bool {
     loop {
         break true;
+        //~^ implicit_return
     }
 }
 
@@ -44,6 +50,7 @@ fn test_loop_with_block() -> bool {
     loop {
         {
             break true;
+            //~^ implicit_return
         }
     }
 }
@@ -52,6 +59,7 @@ fn test_loop_with_nests() -> bool {
     loop {
         if true {
             break true;
+            //~^ implicit_return
         } else {
             let _ = true;
         }
@@ -70,7 +78,9 @@ fn test_loop_with_if_let() -> bool {
 fn test_closure() {
     #[rustfmt::skip]
     let _ = || { true };
+    //~^ implicit_return
     let _ = || true;
+    //~^ implicit_return
 }
 
 fn test_panic() -> bool {
@@ -79,6 +89,7 @@ fn test_panic() -> bool {
 
 fn test_return_macro() -> String {
     format!("test {}", "test")
+    //~^ implicit_return
 }
 
 fn macro_branch_test() -> bool {
@@ -88,17 +99,20 @@ fn macro_branch_test() -> bool {
         };
     }
     m!(true, false)
+    //~^ implicit_return
 }
 
 fn loop_test() -> bool {
     'outer: loop {
         if true {
             break true;
+            //~^ implicit_return
         }
 
         let _ = loop {
             if false {
                 break 'outer false;
+                //~^ implicit_return
             }
             if true {
                 break true;
@@ -117,6 +131,7 @@ fn loop_macro_test() -> bool {
         m!(true);
     }
 }
+//~^^^^ implicit_return
 
 fn divergent_test() -> bool {
     fn diverge() -> ! {
@@ -128,6 +143,7 @@ fn divergent_test() -> bool {
 // issue #6940
 async fn foo() -> bool {
     true
+    //~^ implicit_return
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/implicit_return.stderr b/src/tools/clippy/tests/ui/implicit_return.stderr
index 936a779fa747..02044df47ac3 100644
--- a/src/tools/clippy/tests/ui/implicit_return.stderr
+++ b/src/tools/clippy/tests/ui/implicit_return.stderr
@@ -12,7 +12,7 @@ LL |     return true
    |     ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:19:15
+  --> tests/ui/implicit_return.rs:20:15
    |
 LL |     if true { true } else { false }
    |               ^^^^
@@ -23,7 +23,7 @@ LL |     if true { return true } else { false }
    |               ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:19:29
+  --> tests/ui/implicit_return.rs:20:29
    |
 LL |     if true { true } else { false }
    |                             ^^^^^
@@ -34,7 +34,7 @@ LL |     if true { true } else { return false }
    |                             ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:25:17
+  --> tests/ui/implicit_return.rs:28:17
    |
 LL |         true => false,
    |                 ^^^^^
@@ -45,7 +45,7 @@ LL |         true => return false,
    |                 ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:26:20
+  --> tests/ui/implicit_return.rs:30:20
    |
 LL |         false => { true },
    |                    ^^^^
@@ -56,7 +56,7 @@ LL |         false => { return true },
    |                    ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:39:9
+  --> tests/ui/implicit_return.rs:44:9
    |
 LL |         break true;
    |         ^^^^^^^^^^
@@ -68,7 +68,7 @@ LL +         return true;
    |
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:46:13
+  --> tests/ui/implicit_return.rs:52:13
    |
 LL |             break true;
    |             ^^^^^^^^^^
@@ -80,7 +80,7 @@ LL +             return true;
    |
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:54:13
+  --> tests/ui/implicit_return.rs:61:13
    |
 LL |             break true;
    |             ^^^^^^^^^^
@@ -92,7 +92,7 @@ LL +             return true;
    |
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:72:18
+  --> tests/ui/implicit_return.rs:80:18
    |
 LL |     let _ = || { true };
    |                  ^^^^
@@ -103,7 +103,7 @@ LL |     let _ = || { return true };
    |                  ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:73:16
+  --> tests/ui/implicit_return.rs:82:16
    |
 LL |     let _ = || true;
    |                ^^^^
@@ -114,7 +114,7 @@ LL |     let _ = || return true;
    |                ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:81:5
+  --> tests/ui/implicit_return.rs:91:5
    |
 LL |     format!("test {}", "test")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -125,7 +125,7 @@ LL |     return format!("test {}", "test")
    |     ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:90:5
+  --> tests/ui/implicit_return.rs:101:5
    |
 LL |     m!(true, false)
    |     ^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL |     return m!(true, false)
    |     ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:96:13
+  --> tests/ui/implicit_return.rs:108:13
    |
 LL |             break true;
    |             ^^^^^^^^^^
@@ -148,7 +148,7 @@ LL +             return true;
    |
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:101:17
+  --> tests/ui/implicit_return.rs:114:17
    |
 LL |                 break 'outer false;
    |                 ^^^^^^^^^^^^^^^^^^
@@ -160,7 +160,7 @@ LL +                 return false;
    |
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:116:5
+  --> tests/ui/implicit_return.rs:130:5
    |
 LL | /     loop {
 LL | |         m!(true);
@@ -173,7 +173,7 @@ LL |     return loop {
    |     ++++++
 
 error: missing `return` statement
-  --> tests/ui/implicit_return.rs:130:5
+  --> tests/ui/implicit_return.rs:145:5
    |
 LL |     true
    |     ^^^^
diff --git a/src/tools/clippy/tests/ui/implicit_saturating_add.rs b/src/tools/clippy/tests/ui/implicit_saturating_add.rs
index 94513f34c262..d9d035bdcd31 100644
--- a/src/tools/clippy/tests/ui/implicit_saturating_add.rs
+++ b/src/tools/clippy/tests/ui/implicit_saturating_add.rs
@@ -19,10 +19,12 @@ fn main() {
     }
 
     if u_8 != u8::MAX {
+        //~^ implicit_saturating_add
         u_8 += 1;
     }
 
     if u_8 < u8::MAX {
+        //~^ implicit_saturating_add
         u_8 += 1;
     }
 
@@ -31,86 +33,107 @@ fn main() {
     }
 
     if u_16 != u16::MAX {
+        //~^ implicit_saturating_add
         u_16 += 1;
     }
 
     if u_16 < u16::MAX {
+        //~^ implicit_saturating_add
         u_16 += 1;
     }
 
     if u16::MAX > u_16 {
+        //~^ implicit_saturating_add
         u_16 += 1;
     }
 
     if u_32 != u32::MAX {
+        //~^ implicit_saturating_add
         u_32 += 1;
     }
 
     if u_32 < u32::MAX {
+        //~^ implicit_saturating_add
         u_32 += 1;
     }
 
     if u32::MAX > u_32 {
+        //~^ implicit_saturating_add
         u_32 += 1;
     }
 
     if u_64 != u64::MAX {
+        //~^ implicit_saturating_add
         u_64 += 1;
     }
 
     if u_64 < u64::MAX {
+        //~^ implicit_saturating_add
         u_64 += 1;
     }
 
     if u64::MAX > u_64 {
+        //~^ implicit_saturating_add
         u_64 += 1;
     }
 
     if i_8 != i8::MAX {
+        //~^ implicit_saturating_add
         i_8 += 1;
     }
 
     if i_8 < i8::MAX {
+        //~^ implicit_saturating_add
         i_8 += 1;
     }
 
     if i8::MAX > i_8 {
+        //~^ implicit_saturating_add
         i_8 += 1;
     }
 
     if i_16 != i16::MAX {
+        //~^ implicit_saturating_add
         i_16 += 1;
     }
 
     if i_16 < i16::MAX {
+        //~^ implicit_saturating_add
         i_16 += 1;
     }
 
     if i16::MAX > i_16 {
+        //~^ implicit_saturating_add
         i_16 += 1;
     }
 
     if i_32 != i32::MAX {
+        //~^ implicit_saturating_add
         i_32 += 1;
     }
 
     if i_32 < i32::MAX {
+        //~^ implicit_saturating_add
         i_32 += 1;
     }
 
     if i32::MAX > i_32 {
+        //~^ implicit_saturating_add
         i_32 += 1;
     }
 
     if i_64 != i64::MAX {
+        //~^ implicit_saturating_add
         i_64 += 1;
     }
 
     if i_64 < i64::MAX {
+        //~^ implicit_saturating_add
         i_64 += 1;
     }
 
     if i64::MAX > i_64 {
+        //~^ implicit_saturating_add
         i_64 += 1;
     }
 
@@ -147,6 +170,7 @@ fn main() {
     if u_32 < 42 {
         println!("brace yourself!");
     } else if u_32 < u32::MAX {
+        //~^ implicit_saturating_add
         u_32 += 1;
     }
 }
diff --git a/src/tools/clippy/tests/ui/implicit_saturating_add.stderr b/src/tools/clippy/tests/ui/implicit_saturating_add.stderr
index 4fb9282bc91d..8ae7dc4b884b 100644
--- a/src/tools/clippy/tests/ui/implicit_saturating_add.stderr
+++ b/src/tools/clippy/tests/ui/implicit_saturating_add.stderr
@@ -2,6 +2,7 @@ error: manual saturating add detected
   --> tests/ui/implicit_saturating_add.rs:21:5
    |
 LL | /     if u_8 != u8::MAX {
+LL | |
 LL | |         u_8 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_8 = u_8.saturating_add(1);`
@@ -10,33 +11,28 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::implicit_saturating_add)]`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:25:5
+  --> tests/ui/implicit_saturating_add.rs:26:5
    |
 LL | /     if u_8 < u8::MAX {
+LL | |
 LL | |         u_8 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_8 = u_8.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:33:5
+  --> tests/ui/implicit_saturating_add.rs:35:5
    |
 LL | /     if u_16 != u16::MAX {
+LL | |
 LL | |         u_16 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_16 = u_16.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:37:5
+  --> tests/ui/implicit_saturating_add.rs:40:5
    |
 LL | /     if u_16 < u16::MAX {
-LL | |         u_16 += 1;
-LL | |     }
-   | |_____^ help: use instead: `u_16 = u_16.saturating_add(1);`
-
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:41:5
-   |
-LL | /     if u16::MAX > u_16 {
+LL | |
 LL | |         u_16 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_16 = u_16.saturating_add(1);`
@@ -44,152 +40,180 @@ LL | |     }
 error: manual saturating add detected
   --> tests/ui/implicit_saturating_add.rs:45:5
    |
+LL | /     if u16::MAX > u_16 {
+LL | |
+LL | |         u_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_16 = u_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:50:5
+   |
 LL | /     if u_32 != u32::MAX {
+LL | |
 LL | |         u_32 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_32 = u_32.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:49:5
+  --> tests/ui/implicit_saturating_add.rs:55:5
    |
 LL | /     if u_32 < u32::MAX {
+LL | |
 LL | |         u_32 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_32 = u_32.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:53:5
+  --> tests/ui/implicit_saturating_add.rs:60:5
    |
 LL | /     if u32::MAX > u_32 {
+LL | |
 LL | |         u_32 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_32 = u_32.saturating_add(1);`
 
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:57:5
-   |
-LL | /     if u_64 != u64::MAX {
-LL | |         u_64 += 1;
-LL | |     }
-   | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
-
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:61:5
-   |
-LL | /     if u_64 < u64::MAX {
-LL | |         u_64 += 1;
-LL | |     }
-   | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
-
 error: manual saturating add detected
   --> tests/ui/implicit_saturating_add.rs:65:5
    |
-LL | /     if u64::MAX > u_64 {
+LL | /     if u_64 != u64::MAX {
+LL | |
 LL | |         u_64 += 1;
 LL | |     }
    | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:69:5
+  --> tests/ui/implicit_saturating_add.rs:70:5
+   |
+LL | /     if u_64 < u64::MAX {
+LL | |
+LL | |         u_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:75:5
+   |
+LL | /     if u64::MAX > u_64 {
+LL | |
+LL | |         u_64 += 1;
+LL | |     }
+   | |_____^ help: use instead: `u_64 = u_64.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:80:5
    |
 LL | /     if i_8 != i8::MAX {
+LL | |
 LL | |         i_8 += 1;
 LL | |     }
    | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
 
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:73:5
-   |
-LL | /     if i_8 < i8::MAX {
-LL | |         i_8 += 1;
-LL | |     }
-   | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
-
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:77:5
-   |
-LL | /     if i8::MAX > i_8 {
-LL | |         i_8 += 1;
-LL | |     }
-   | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
-
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:81:5
-   |
-LL | /     if i_16 != i16::MAX {
-LL | |         i_16 += 1;
-LL | |     }
-   | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
-
 error: manual saturating add detected
   --> tests/ui/implicit_saturating_add.rs:85:5
    |
+LL | /     if i_8 < i8::MAX {
+LL | |
+LL | |         i_8 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:90:5
+   |
+LL | /     if i8::MAX > i_8 {
+LL | |
+LL | |         i_8 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_8 = i_8.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:95:5
+   |
+LL | /     if i_16 != i16::MAX {
+LL | |
+LL | |         i_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:100:5
+   |
 LL | /     if i_16 < i16::MAX {
+LL | |
 LL | |         i_16 += 1;
 LL | |     }
    | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
 
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:89:5
-   |
-LL | /     if i16::MAX > i_16 {
-LL | |         i_16 += 1;
-LL | |     }
-   | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
-
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:93:5
-   |
-LL | /     if i_32 != i32::MAX {
-LL | |         i_32 += 1;
-LL | |     }
-   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
-
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:97:5
-   |
-LL | /     if i_32 < i32::MAX {
-LL | |         i_32 += 1;
-LL | |     }
-   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
-
-error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:101:5
-   |
-LL | /     if i32::MAX > i_32 {
-LL | |         i_32 += 1;
-LL | |     }
-   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
-
 error: manual saturating add detected
   --> tests/ui/implicit_saturating_add.rs:105:5
    |
+LL | /     if i16::MAX > i_16 {
+LL | |
+LL | |         i_16 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_16 = i_16.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:110:5
+   |
+LL | /     if i_32 != i32::MAX {
+LL | |
+LL | |         i_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:115:5
+   |
+LL | /     if i_32 < i32::MAX {
+LL | |
+LL | |         i_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:120:5
+   |
+LL | /     if i32::MAX > i_32 {
+LL | |
+LL | |         i_32 += 1;
+LL | |     }
+   | |_____^ help: use instead: `i_32 = i_32.saturating_add(1);`
+
+error: manual saturating add detected
+  --> tests/ui/implicit_saturating_add.rs:125:5
+   |
 LL | /     if i_64 != i64::MAX {
+LL | |
 LL | |         i_64 += 1;
 LL | |     }
    | |_____^ help: use instead: `i_64 = i_64.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:109:5
+  --> tests/ui/implicit_saturating_add.rs:130:5
    |
 LL | /     if i_64 < i64::MAX {
+LL | |
 LL | |         i_64 += 1;
 LL | |     }
    | |_____^ help: use instead: `i_64 = i_64.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:113:5
+  --> tests/ui/implicit_saturating_add.rs:135:5
    |
 LL | /     if i64::MAX > i_64 {
+LL | |
 LL | |         i_64 += 1;
 LL | |     }
    | |_____^ help: use instead: `i_64 = i_64.saturating_add(1);`
 
 error: manual saturating add detected
-  --> tests/ui/implicit_saturating_add.rs:149:12
+  --> tests/ui/implicit_saturating_add.rs:172:12
    |
 LL |       } else if u_32 < u32::MAX {
    |  ____________^
+LL | |
 LL | |         u_32 += 1;
 LL | |     }
    | |_____^ help: use instead: `{u_32 = u_32.saturating_add(1); }`
diff --git a/src/tools/clippy/tests/ui/implicit_saturating_sub.rs b/src/tools/clippy/tests/ui/implicit_saturating_sub.rs
index e371e37fb2f6..140cf0338602 100644
--- a/src/tools/clippy/tests/ui/implicit_saturating_sub.rs
+++ b/src/tools/clippy/tests/ui/implicit_saturating_sub.rs
@@ -25,6 +25,7 @@ fn main() {
 
     // Lint
     if u_8 > 0 {
+        //~^ implicit_saturating_sub
         u_8 = u_8 - 1;
     }
 
@@ -32,6 +33,7 @@ fn main() {
         10 => {
             // Lint
             if u_8 > 0 {
+                //~^ implicit_saturating_sub
                 u_8 -= 1;
             }
         },
@@ -46,6 +48,7 @@ fn main() {
 
     // Lint
     if u_16 > 0 {
+        //~^ implicit_saturating_sub
         u_16 -= 1;
     }
 
@@ -56,6 +59,7 @@ fn main() {
 
     // Lint
     if u_32 != 0 {
+        //~^ implicit_saturating_sub
         u_32 -= 1;
     }
 
@@ -77,16 +81,19 @@ fn main() {
 
     // Lint
     if u_64 > 0 {
+        //~^ implicit_saturating_sub
         u_64 -= 1;
     }
 
     // Lint
     if 0 < u_64 {
+        //~^ implicit_saturating_sub
         u_64 -= 1;
     }
 
     // Lint
     if 0 != u_64 {
+        //~^ implicit_saturating_sub
         u_64 -= 1;
     }
 
@@ -108,6 +115,7 @@ fn main() {
 
     // Lint
     if u_usize > 0 {
+        //~^ implicit_saturating_sub
         u_usize -= 1;
     }
 
@@ -120,21 +128,25 @@ fn main() {
 
     // Lint
     if i_8 > i8::MIN {
+        //~^ implicit_saturating_sub
         i_8 -= 1;
     }
 
     // Lint
     if i_8 > i8::MIN {
+        //~^ implicit_saturating_sub
         i_8 -= 1;
     }
 
     // Lint
     if i_8 != i8::MIN {
+        //~^ implicit_saturating_sub
         i_8 -= 1;
     }
 
     // Lint
     if i_8 != i8::MIN {
+        //~^ implicit_saturating_sub
         i_8 -= 1;
     }
 
@@ -145,21 +157,25 @@ fn main() {
 
     // Lint
     if i_16 > i16::MIN {
+        //~^ implicit_saturating_sub
         i_16 -= 1;
     }
 
     // Lint
     if i_16 > i16::MIN {
+        //~^ implicit_saturating_sub
         i_16 -= 1;
     }
 
     // Lint
     if i_16 != i16::MIN {
+        //~^ implicit_saturating_sub
         i_16 -= 1;
     }
 
     // Lint
     if i_16 != i16::MIN {
+        //~^ implicit_saturating_sub
         i_16 -= 1;
     }
 
@@ -170,21 +186,25 @@ fn main() {
 
     // Lint
     if i_32 > i32::MIN {
+        //~^ implicit_saturating_sub
         i_32 -= 1;
     }
 
     // Lint
     if i_32 > i32::MIN {
+        //~^ implicit_saturating_sub
         i_32 -= 1;
     }
 
     // Lint
     if i_32 != i32::MIN {
+        //~^ implicit_saturating_sub
         i_32 -= 1;
     }
 
     // Lint
     if i_32 != i32::MIN {
+        //~^ implicit_saturating_sub
         i_32 -= 1;
     }
 
@@ -195,16 +215,19 @@ fn main() {
 
     // Lint
     if i64::MIN < i_64 {
+        //~^ implicit_saturating_sub
         i_64 -= 1;
     }
 
     // Lint
     if i64::MIN != i_64 {
+        //~^ implicit_saturating_sub
         i_64 -= 1;
     }
 
     // Lint
     if i64::MIN < i_64 {
+        //~^ implicit_saturating_sub
         i_64 -= 1;
     }
 
@@ -273,6 +296,7 @@ fn regression_13524(a: usize, b: usize, c: bool) -> usize {
     if c {
         123
     } else if a >= b {
+        //~^ implicit_saturating_sub
         0
     } else {
         b - a
diff --git a/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr b/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr
index 613198512280..f9c94d3ad841 100644
--- a/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr
+++ b/src/tools/clippy/tests/ui/implicit_saturating_sub.stderr
@@ -2,6 +2,7 @@ error: implicitly performing saturating subtraction
   --> tests/ui/implicit_saturating_sub.rs:27:5
    |
 LL | /     if u_8 > 0 {
+LL | |
 LL | |         u_8 = u_8 - 1;
 LL | |     }
    | |_____^ help: try: `u_8 = u_8.saturating_sub(1);`
@@ -10,41 +11,37 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::implicit_saturating_sub)]`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:34:13
+  --> tests/ui/implicit_saturating_sub.rs:35:13
    |
 LL | /             if u_8 > 0 {
+LL | |
 LL | |                 u_8 -= 1;
 LL | |             }
    | |_____________^ help: try: `u_8 = u_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:48:5
+  --> tests/ui/implicit_saturating_sub.rs:50:5
    |
 LL | /     if u_16 > 0 {
+LL | |
 LL | |         u_16 -= 1;
 LL | |     }
    | |_____^ help: try: `u_16 = u_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:58:5
+  --> tests/ui/implicit_saturating_sub.rs:61:5
    |
 LL | /     if u_32 != 0 {
+LL | |
 LL | |         u_32 -= 1;
 LL | |     }
    | |_____^ help: try: `u_32 = u_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:79:5
+  --> tests/ui/implicit_saturating_sub.rs:83:5
    |
 LL | /     if u_64 > 0 {
-LL | |         u_64 -= 1;
-LL | |     }
-   | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
-
-error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:84:5
-   |
-LL | /     if 0 < u_64 {
+LL | |
 LL | |         u_64 -= 1;
 LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
@@ -52,144 +49,171 @@ LL | |     }
 error: implicitly performing saturating subtraction
   --> tests/ui/implicit_saturating_sub.rs:89:5
    |
-LL | /     if 0 != u_64 {
+LL | /     if 0 < u_64 {
+LL | |
 LL | |         u_64 -= 1;
 LL | |     }
    | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:110:5
+  --> tests/ui/implicit_saturating_sub.rs:95:5
+   |
+LL | /     if 0 != u_64 {
+LL | |
+LL | |         u_64 -= 1;
+LL | |     }
+   | |_____^ help: try: `u_64 = u_64.saturating_sub(1);`
+
+error: implicitly performing saturating subtraction
+  --> tests/ui/implicit_saturating_sub.rs:117:5
    |
 LL | /     if u_usize > 0 {
+LL | |
 LL | |         u_usize -= 1;
 LL | |     }
    | |_____^ help: try: `u_usize = u_usize.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:122:5
+  --> tests/ui/implicit_saturating_sub.rs:130:5
    |
 LL | /     if i_8 > i8::MIN {
+LL | |
 LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:127:5
+  --> tests/ui/implicit_saturating_sub.rs:136:5
    |
 LL | /     if i_8 > i8::MIN {
+LL | |
 LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:132:5
+  --> tests/ui/implicit_saturating_sub.rs:142:5
    |
 LL | /     if i_8 != i8::MIN {
+LL | |
 LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:137:5
+  --> tests/ui/implicit_saturating_sub.rs:148:5
    |
 LL | /     if i_8 != i8::MIN {
+LL | |
 LL | |         i_8 -= 1;
 LL | |     }
    | |_____^ help: try: `i_8 = i_8.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:147:5
+  --> tests/ui/implicit_saturating_sub.rs:159:5
    |
 LL | /     if i_16 > i16::MIN {
+LL | |
 LL | |         i_16 -= 1;
 LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:152:5
+  --> tests/ui/implicit_saturating_sub.rs:165:5
    |
 LL | /     if i_16 > i16::MIN {
+LL | |
 LL | |         i_16 -= 1;
 LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:157:5
+  --> tests/ui/implicit_saturating_sub.rs:171:5
    |
 LL | /     if i_16 != i16::MIN {
+LL | |
 LL | |         i_16 -= 1;
 LL | |     }
    | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
 
-error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:162:5
-   |
-LL | /     if i_16 != i16::MIN {
-LL | |         i_16 -= 1;
-LL | |     }
-   | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
-
-error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:172:5
-   |
-LL | /     if i_32 > i32::MIN {
-LL | |         i_32 -= 1;
-LL | |     }
-   | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
-
 error: implicitly performing saturating subtraction
   --> tests/ui/implicit_saturating_sub.rs:177:5
    |
+LL | /     if i_16 != i16::MIN {
+LL | |
+LL | |         i_16 -= 1;
+LL | |     }
+   | |_____^ help: try: `i_16 = i_16.saturating_sub(1);`
+
+error: implicitly performing saturating subtraction
+  --> tests/ui/implicit_saturating_sub.rs:188:5
+   |
 LL | /     if i_32 > i32::MIN {
+LL | |
 LL | |         i_32 -= 1;
 LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:182:5
+  --> tests/ui/implicit_saturating_sub.rs:194:5
+   |
+LL | /     if i_32 > i32::MIN {
+LL | |
+LL | |         i_32 -= 1;
+LL | |     }
+   | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
+
+error: implicitly performing saturating subtraction
+  --> tests/ui/implicit_saturating_sub.rs:200:5
    |
 LL | /     if i_32 != i32::MIN {
+LL | |
 LL | |         i_32 -= 1;
 LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:187:5
+  --> tests/ui/implicit_saturating_sub.rs:206:5
    |
 LL | /     if i_32 != i32::MIN {
+LL | |
 LL | |         i_32 -= 1;
 LL | |     }
    | |_____^ help: try: `i_32 = i_32.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:197:5
+  --> tests/ui/implicit_saturating_sub.rs:217:5
    |
 LL | /     if i64::MIN < i_64 {
+LL | |
 LL | |         i_64 -= 1;
 LL | |     }
    | |_____^ help: try: `i_64 = i_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:202:5
+  --> tests/ui/implicit_saturating_sub.rs:223:5
    |
 LL | /     if i64::MIN != i_64 {
+LL | |
 LL | |         i_64 -= 1;
 LL | |     }
    | |_____^ help: try: `i_64 = i_64.saturating_sub(1);`
 
 error: implicitly performing saturating subtraction
-  --> tests/ui/implicit_saturating_sub.rs:207:5
+  --> tests/ui/implicit_saturating_sub.rs:229:5
    |
 LL | /     if i64::MIN < i_64 {
+LL | |
 LL | |         i_64 -= 1;
 LL | |     }
    | |_____^ help: try: `i_64 = i_64.saturating_sub(1);`
 
 error: manual arithmetic check found
-  --> tests/ui/implicit_saturating_sub.rs:275:12
+  --> tests/ui/implicit_saturating_sub.rs:298:12
    |
 LL |       } else if a >= b {
    |  ____________^
+LL | |
 LL | |         0
 LL | |     } else {
 LL | |         b - a
diff --git a/src/tools/clippy/tests/ui/implied_bounds_in_impls.fixed b/src/tools/clippy/tests/ui/implied_bounds_in_impls.fixed
index 6fd4cbd80fe4..bac7af59491f 100644
--- a/src/tools/clippy/tests/ui/implied_bounds_in_impls.fixed
+++ b/src/tools/clippy/tests/ui/implied_bounds_in_impls.fixed
@@ -11,6 +11,7 @@ fn normal_deref<T>(x: T) -> impl Deref<Target = T> {
 
 // Deref implied by DerefMut
 fn deref_derefmut<T>(x: T) -> impl DerefMut<Target = T> {
+    //~^ implied_bounds_in_impls
     Box::new(x)
 }
 
@@ -28,14 +29,19 @@ impl<V> GenericSubtrait<(), i32, V> for () {}
 impl<V> GenericSubtrait<(), i64, V> for () {}
 
 fn generics_implied<U, W>() -> impl GenericSubtrait<U, W, U>
+//~^ implied_bounds_in_impls
 where
     (): GenericSubtrait<U, W, U>,
 {
 }
 
 fn generics_implied_multi<V>() -> impl GenericSubtrait<(), i32, V> {}
+//~^ implied_bounds_in_impls
+//~| implied_bounds_in_impls
 
 fn generics_implied_multi2<T, V>() -> impl GenericSubtrait<(), T, V>
+//~^ implied_bounds_in_impls
+//~| implied_bounds_in_impls
 where
     (): GenericSubtrait<(), T, V> + GenericTrait<T>,
 {
@@ -46,21 +52,25 @@ fn generics_different() -> impl GenericTrait<i32> + GenericSubtrait<(), i64, ()>
 
 // i32 == i32, GenericSubtrait<_, i32, _> does imply GenericTrait<i32>, lint
 fn generics_same() -> impl GenericSubtrait<(), i32, ()> {}
+//~^ implied_bounds_in_impls
 
 trait SomeTrait {
     // Check that it works in trait declarations.
     fn f() -> impl DerefMut<Target = u8>;
+    //~^ implied_bounds_in_impls
 }
 struct SomeStruct;
 impl SomeStruct {
     // Check that it works in inherent impl blocks.
     fn f() -> impl DerefMut<Target = u8> {
+        //~^ implied_bounds_in_impls
         Box::new(123)
     }
 }
 impl SomeTrait for SomeStruct {
     // Check that it works in trait impls.
     fn f() -> impl DerefMut<Target = u8> {
+        //~^ implied_bounds_in_impls
         Box::new(42)
     }
 }
@@ -72,7 +82,9 @@ mod issue11422 {
     // `PartialOrd` has a default generic parameter and does not need to be explicitly specified.
     // This needs special handling.
     fn default_generic_param1() -> impl PartialOrd + Debug {}
+    //~^ implied_bounds_in_impls
     fn default_generic_param2() -> impl PartialOrd + Debug {}
+    //~^ implied_bounds_in_impls
 
     // Referring to `Self` in the supertrait clause needs special handling.
     trait Trait1<X: ?Sized> {}
@@ -86,11 +98,13 @@ mod issue11422 {
 mod issue11435 {
     // Associated type needs to be included on DoubleEndedIterator in the suggestion
     fn my_iter() -> impl DoubleEndedIterator<Item = u32> {
+        //~^ implied_bounds_in_impls
         0..5
     }
 
     // Removing the `Clone` bound should include the `+` behind it in its remove suggestion
     fn f() -> impl Copy {
+        //~^ implied_bounds_in_impls
         1
     }
 
@@ -105,6 +119,7 @@ mod issue11435 {
 
     // When the other trait has generics, it shouldn't add another pair of `<>`
     fn f2() -> impl Trait2<i32, U = i64> {}
+    //~^ implied_bounds_in_impls
 
     trait Trait3<T, U, V> {
         type X;
@@ -120,6 +135,7 @@ mod issue11435 {
     // Associated type `X` is specified, but `Y` is not, so only that associated type should be moved
     // over
     fn f3() -> impl Trait4<i8, X = i32, Y = i128> {}
+    //~^ implied_bounds_in_impls
 }
 
 fn issue11880() {
@@ -147,14 +163,19 @@ fn issue11880() {
     // X::T is never constrained in the first place, so it can be omitted
     // and left unconstrained
     fn f3() -> impl Y {}
+    //~^ implied_bounds_in_impls
     fn f4() -> impl Y<T = u32> {}
+    //~^ implied_bounds_in_impls
     fn f5() -> impl Y<T = u32, U = String> {}
+    //~^ implied_bounds_in_impls
 }
 
 fn apit(_: impl DerefMut) {}
+//~^ implied_bounds_in_impls
 
 trait Rpitit {
     fn f() -> impl DerefMut;
+    //~^ implied_bounds_in_impls
 }
 
 trait Atpit {
@@ -163,12 +184,14 @@ trait Atpit {
 }
 impl Atpit for () {
     type Assoc = impl DerefMut;
+    //~^ implied_bounds_in_impls
     fn define() -> Self::Assoc {
         &mut [] as &mut [()]
     }
 }
 
 type Tait = impl DerefMut;
+//~^ implied_bounds_in_impls
 fn define() -> Tait {
     &mut [] as &mut [()]
 }
diff --git a/src/tools/clippy/tests/ui/implied_bounds_in_impls.rs b/src/tools/clippy/tests/ui/implied_bounds_in_impls.rs
index 52076c9f998e..2014cd46ada7 100644
--- a/src/tools/clippy/tests/ui/implied_bounds_in_impls.rs
+++ b/src/tools/clippy/tests/ui/implied_bounds_in_impls.rs
@@ -11,6 +11,7 @@ fn normal_deref<T>(x: T) -> impl Deref<Target = T> {
 
 // Deref implied by DerefMut
 fn deref_derefmut<T>(x: T) -> impl Deref<Target = T> + DerefMut<Target = T> {
+    //~^ implied_bounds_in_impls
     Box::new(x)
 }
 
@@ -28,14 +29,19 @@ impl<V> GenericSubtrait<(), i32, V> for () {}
 impl<V> GenericSubtrait<(), i64, V> for () {}
 
 fn generics_implied<U, W>() -> impl GenericTrait<W> + GenericSubtrait<U, W, U>
+//~^ implied_bounds_in_impls
 where
     (): GenericSubtrait<U, W, U>,
 {
 }
 
 fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
+//~^ implied_bounds_in_impls
+//~| implied_bounds_in_impls
 
 fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
+//~^ implied_bounds_in_impls
+//~| implied_bounds_in_impls
 where
     (): GenericSubtrait<(), T, V> + GenericTrait<T>,
 {
@@ -46,21 +52,25 @@ fn generics_different() -> impl GenericTrait<i32> + GenericSubtrait<(), i64, ()>
 
 // i32 == i32, GenericSubtrait<_, i32, _> does imply GenericTrait<i32>, lint
 fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
+//~^ implied_bounds_in_impls
 
 trait SomeTrait {
     // Check that it works in trait declarations.
     fn f() -> impl Deref + DerefMut<Target = u8>;
+    //~^ implied_bounds_in_impls
 }
 struct SomeStruct;
 impl SomeStruct {
     // Check that it works in inherent impl blocks.
     fn f() -> impl Deref + DerefMut<Target = u8> {
+        //~^ implied_bounds_in_impls
         Box::new(123)
     }
 }
 impl SomeTrait for SomeStruct {
     // Check that it works in trait impls.
     fn f() -> impl Deref + DerefMut<Target = u8> {
+        //~^ implied_bounds_in_impls
         Box::new(42)
     }
 }
@@ -72,7 +82,9 @@ mod issue11422 {
     // `PartialOrd` has a default generic parameter and does not need to be explicitly specified.
     // This needs special handling.
     fn default_generic_param1() -> impl PartialEq + PartialOrd + Debug {}
+    //~^ implied_bounds_in_impls
     fn default_generic_param2() -> impl PartialOrd + PartialEq + Debug {}
+    //~^ implied_bounds_in_impls
 
     // Referring to `Self` in the supertrait clause needs special handling.
     trait Trait1<X: ?Sized> {}
@@ -86,11 +98,13 @@ mod issue11422 {
 mod issue11435 {
     // Associated type needs to be included on DoubleEndedIterator in the suggestion
     fn my_iter() -> impl Iterator<Item = u32> + DoubleEndedIterator {
+        //~^ implied_bounds_in_impls
         0..5
     }
 
     // Removing the `Clone` bound should include the `+` behind it in its remove suggestion
     fn f() -> impl Copy + Clone {
+        //~^ implied_bounds_in_impls
         1
     }
 
@@ -105,6 +119,7 @@ mod issue11435 {
 
     // When the other trait has generics, it shouldn't add another pair of `<>`
     fn f2() -> impl Trait1<i32, U = i64> + Trait2<i32> {}
+    //~^ implied_bounds_in_impls
 
     trait Trait3<T, U, V> {
         type X;
@@ -120,6 +135,7 @@ mod issue11435 {
     // Associated type `X` is specified, but `Y` is not, so only that associated type should be moved
     // over
     fn f3() -> impl Trait3<i8, i16, i64, X = i32, Y = i128> + Trait4<i8, X = i32> {}
+    //~^ implied_bounds_in_impls
 }
 
 fn issue11880() {
@@ -147,14 +163,19 @@ fn issue11880() {
     // X::T is never constrained in the first place, so it can be omitted
     // and left unconstrained
     fn f3() -> impl X + Y {}
+    //~^ implied_bounds_in_impls
     fn f4() -> impl X + Y<T = u32> {}
+    //~^ implied_bounds_in_impls
     fn f5() -> impl X<U = String> + Y<T = u32> {}
+    //~^ implied_bounds_in_impls
 }
 
 fn apit(_: impl Deref + DerefMut) {}
+//~^ implied_bounds_in_impls
 
 trait Rpitit {
     fn f() -> impl Deref + DerefMut;
+    //~^ implied_bounds_in_impls
 }
 
 trait Atpit {
@@ -163,12 +184,14 @@ trait Atpit {
 }
 impl Atpit for () {
     type Assoc = impl Deref + DerefMut;
+    //~^ implied_bounds_in_impls
     fn define() -> Self::Assoc {
         &mut [] as &mut [()]
     }
 }
 
 type Tait = impl Deref + DerefMut;
+//~^ implied_bounds_in_impls
 fn define() -> Tait {
     &mut [] as &mut [()]
 }
diff --git a/src/tools/clippy/tests/ui/implied_bounds_in_impls.stderr b/src/tools/clippy/tests/ui/implied_bounds_in_impls.stderr
index 805532a56802..e2888d86f315 100644
--- a/src/tools/clippy/tests/ui/implied_bounds_in_impls.stderr
+++ b/src/tools/clippy/tests/ui/implied_bounds_in_impls.stderr
@@ -13,7 +13,7 @@ LL + fn deref_derefmut<T>(x: T) -> impl DerefMut<Target = T> {
    |
 
 error: this bound is already specified as the supertrait of `GenericSubtrait<U, W, U>`
-  --> tests/ui/implied_bounds_in_impls.rs:30:37
+  --> tests/ui/implied_bounds_in_impls.rs:31:37
    |
 LL | fn generics_implied<U, W>() -> impl GenericTrait<W> + GenericSubtrait<U, W, U>
    |                                     ^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL + fn generics_implied<U, W>() -> impl GenericSubtrait<U, W, U>
    |
 
 error: this bound is already specified as the supertrait of `GenericSubtrait<(), i32, V>`
-  --> tests/ui/implied_bounds_in_impls.rs:36:40
+  --> tests/ui/implied_bounds_in_impls.rs:38:40
    |
 LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
    |                                        ^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL + fn generics_implied_multi<V>() -> impl GenericTrait2<V> + GenericSubtrait<(
    |
 
 error: this bound is already specified as the supertrait of `GenericSubtrait<(), i32, V>`
-  --> tests/ui/implied_bounds_in_impls.rs:36:60
+  --> tests/ui/implied_bounds_in_impls.rs:38:60
    |
 LL | fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericTrait2<V> + GenericSubtrait<(), i32, V> {}
    |                                                            ^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL + fn generics_implied_multi<V>() -> impl GenericTrait<i32> + GenericSubtrait<
    |
 
 error: this bound is already specified as the supertrait of `GenericSubtrait<(), T, V>`
-  --> tests/ui/implied_bounds_in_impls.rs:38:44
+  --> tests/ui/implied_bounds_in_impls.rs:42:44
    |
 LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
    |                                            ^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL + fn generics_implied_multi2<T, V>() -> impl GenericTrait2<V> + GenericSubtra
    |
 
 error: this bound is already specified as the supertrait of `GenericSubtrait<(), T, V>`
-  --> tests/ui/implied_bounds_in_impls.rs:38:62
+  --> tests/ui/implied_bounds_in_impls.rs:42:62
    |
 LL | fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericTrait2<V> + GenericSubtrait<(), T, V>
    |                                                              ^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL + fn generics_implied_multi2<T, V>() -> impl GenericTrait<T> + GenericSubtrai
    |
 
 error: this bound is already specified as the supertrait of `GenericSubtrait<(), i32, ()>`
-  --> tests/ui/implied_bounds_in_impls.rs:48:28
+  --> tests/ui/implied_bounds_in_impls.rs:54:28
    |
 LL | fn generics_same() -> impl GenericTrait<i32> + GenericSubtrait<(), i32, ()> {}
    |                            ^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL + fn generics_same() -> impl GenericSubtrait<(), i32, ()> {}
    |
 
 error: this bound is already specified as the supertrait of `DerefMut<Target = u8>`
-  --> tests/ui/implied_bounds_in_impls.rs:52:20
+  --> tests/ui/implied_bounds_in_impls.rs:59:20
    |
 LL |     fn f() -> impl Deref + DerefMut<Target = u8>;
    |                    ^^^^^
@@ -97,7 +97,7 @@ LL +     fn f() -> impl DerefMut<Target = u8>;
    |
 
 error: this bound is already specified as the supertrait of `DerefMut<Target = u8>`
-  --> tests/ui/implied_bounds_in_impls.rs:57:20
+  --> tests/ui/implied_bounds_in_impls.rs:65:20
    |
 LL |     fn f() -> impl Deref + DerefMut<Target = u8> {
    |                    ^^^^^
@@ -109,7 +109,7 @@ LL +     fn f() -> impl DerefMut<Target = u8> {
    |
 
 error: this bound is already specified as the supertrait of `DerefMut<Target = u8>`
-  --> tests/ui/implied_bounds_in_impls.rs:63:20
+  --> tests/ui/implied_bounds_in_impls.rs:72:20
    |
 LL |     fn f() -> impl Deref + DerefMut<Target = u8> {
    |                    ^^^^^
@@ -121,7 +121,7 @@ LL +     fn f() -> impl DerefMut<Target = u8> {
    |
 
 error: this bound is already specified as the supertrait of `PartialOrd`
-  --> tests/ui/implied_bounds_in_impls.rs:74:41
+  --> tests/ui/implied_bounds_in_impls.rs:84:41
    |
 LL |     fn default_generic_param1() -> impl PartialEq + PartialOrd + Debug {}
    |                                         ^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     fn default_generic_param1() -> impl PartialOrd + Debug {}
    |
 
 error: this bound is already specified as the supertrait of `PartialOrd`
-  --> tests/ui/implied_bounds_in_impls.rs:75:54
+  --> tests/ui/implied_bounds_in_impls.rs:86:54
    |
 LL |     fn default_generic_param2() -> impl PartialOrd + PartialEq + Debug {}
    |                                                      ^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     fn default_generic_param2() -> impl PartialOrd + Debug {}
    |
 
 error: this bound is already specified as the supertrait of `DoubleEndedIterator`
-  --> tests/ui/implied_bounds_in_impls.rs:88:26
+  --> tests/ui/implied_bounds_in_impls.rs:100:26
    |
 LL |     fn my_iter() -> impl Iterator<Item = u32> + DoubleEndedIterator {
    |                          ^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     fn my_iter() -> impl DoubleEndedIterator<Item = u32> {
    |
 
 error: this bound is already specified as the supertrait of `Copy`
-  --> tests/ui/implied_bounds_in_impls.rs:93:27
+  --> tests/ui/implied_bounds_in_impls.rs:106:27
    |
 LL |     fn f() -> impl Copy + Clone {
    |                           ^^^^^
@@ -169,7 +169,7 @@ LL +     fn f() -> impl Copy {
    |
 
 error: this bound is already specified as the supertrait of `Trait2<i32>`
-  --> tests/ui/implied_bounds_in_impls.rs:107:21
+  --> tests/ui/implied_bounds_in_impls.rs:121:21
    |
 LL |     fn f2() -> impl Trait1<i32, U = i64> + Trait2<i32> {}
    |                     ^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     fn f2() -> impl Trait2<i32, U = i64> {}
    |
 
 error: this bound is already specified as the supertrait of `Trait4<i8, X = i32>`
-  --> tests/ui/implied_bounds_in_impls.rs:122:21
+  --> tests/ui/implied_bounds_in_impls.rs:137:21
    |
 LL |     fn f3() -> impl Trait3<i8, i16, i64, X = i32, Y = i128> + Trait4<i8, X = i32> {}
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     fn f3() -> impl Trait4<i8, X = i32, Y = i128> {}
    |
 
 error: this bound is already specified as the supertrait of `Y`
-  --> tests/ui/implied_bounds_in_impls.rs:149:21
+  --> tests/ui/implied_bounds_in_impls.rs:165:21
    |
 LL |     fn f3() -> impl X + Y {}
    |                     ^
@@ -205,7 +205,7 @@ LL +     fn f3() -> impl Y {}
    |
 
 error: this bound is already specified as the supertrait of `Y<T = u32>`
-  --> tests/ui/implied_bounds_in_impls.rs:150:21
+  --> tests/ui/implied_bounds_in_impls.rs:167:21
    |
 LL |     fn f4() -> impl X + Y<T = u32> {}
    |                     ^
@@ -217,7 +217,7 @@ LL +     fn f4() -> impl Y<T = u32> {}
    |
 
 error: this bound is already specified as the supertrait of `Y<T = u32>`
-  --> tests/ui/implied_bounds_in_impls.rs:151:21
+  --> tests/ui/implied_bounds_in_impls.rs:169:21
    |
 LL |     fn f5() -> impl X<U = String> + Y<T = u32> {}
    |                     ^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL +     fn f5() -> impl Y<T = u32, U = String> {}
    |
 
 error: this bound is already specified as the supertrait of `DerefMut`
-  --> tests/ui/implied_bounds_in_impls.rs:154:17
+  --> tests/ui/implied_bounds_in_impls.rs:173:17
    |
 LL | fn apit(_: impl Deref + DerefMut) {}
    |                 ^^^^^
@@ -241,7 +241,7 @@ LL + fn apit(_: impl DerefMut) {}
    |
 
 error: this bound is already specified as the supertrait of `DerefMut`
-  --> tests/ui/implied_bounds_in_impls.rs:157:20
+  --> tests/ui/implied_bounds_in_impls.rs:177:20
    |
 LL |     fn f() -> impl Deref + DerefMut;
    |                    ^^^^^
@@ -253,7 +253,7 @@ LL +     fn f() -> impl DerefMut;
    |
 
 error: this bound is already specified as the supertrait of `DerefMut`
-  --> tests/ui/implied_bounds_in_impls.rs:165:23
+  --> tests/ui/implied_bounds_in_impls.rs:186:23
    |
 LL |     type Assoc = impl Deref + DerefMut;
    |                       ^^^^^
@@ -265,7 +265,7 @@ LL +     type Assoc = impl DerefMut;
    |
 
 error: this bound is already specified as the supertrait of `DerefMut`
-  --> tests/ui/implied_bounds_in_impls.rs:171:18
+  --> tests/ui/implied_bounds_in_impls.rs:193:18
    |
 LL | type Tait = impl Deref + DerefMut;
    |                  ^^^^^
diff --git a/src/tools/clippy/tests/ui/incompatible_msrv.rs b/src/tools/clippy/tests/ui/incompatible_msrv.rs
index c23df223d508..b4fea4cae5ed 100644
--- a/src/tools/clippy/tests/ui/incompatible_msrv.rs
+++ b/src/tools/clippy/tests/ui/incompatible_msrv.rs
@@ -11,14 +11,15 @@ use std::time::Duration;
 fn foo() {
     let mut map: HashMap<&str, u32> = HashMap::new();
     assert_eq!(map.entry("poneyland").key(), &"poneyland");
-    //~^ ERROR: is `1.3.0` but this item is stable since `1.10.0`
+    //~^ incompatible_msrv
+
     if let Entry::Vacant(v) = map.entry("poneyland") {
         v.into_key();
-        //~^ ERROR: is `1.3.0` but this item is stable since `1.12.0`
+        //~^ incompatible_msrv
     }
     // Should warn for `sleep` but not for `Duration` (which was added in `1.3.0`).
     sleep(Duration::new(1, 0));
-    //~^ ERROR: is `1.3.0` but this item is stable since `1.4.0`
+    //~^ incompatible_msrv
 }
 
 #[test]
diff --git a/src/tools/clippy/tests/ui/incompatible_msrv.stderr b/src/tools/clippy/tests/ui/incompatible_msrv.stderr
index 34f01c3e14a1..56c9eae5aafa 100644
--- a/src/tools/clippy/tests/ui/incompatible_msrv.stderr
+++ b/src/tools/clippy/tests/ui/incompatible_msrv.stderr
@@ -8,13 +8,13 @@ LL |     assert_eq!(map.entry("poneyland").key(), &"poneyland");
    = help: to override `-D warnings` add `#[allow(clippy::incompatible_msrv)]`
 
 error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.12.0`
-  --> tests/ui/incompatible_msrv.rs:16:11
+  --> tests/ui/incompatible_msrv.rs:17:11
    |
 LL |         v.into_key();
    |           ^^^^^^^^^^
 
 error: current MSRV (Minimum Supported Rust Version) is `1.3.0` but this item is stable since `1.4.0`
-  --> tests/ui/incompatible_msrv.rs:20:5
+  --> tests/ui/incompatible_msrv.rs:21:5
    |
 LL |     sleep(Duration::new(1, 0));
    |     ^^^^^
diff --git a/src/tools/clippy/tests/ui/inconsistent_digit_grouping.fixed b/src/tools/clippy/tests/ui/inconsistent_digit_grouping.fixed
index 3f1dfbbae97b..23d2d7cc0aa4 100644
--- a/src/tools/clippy/tests/ui/inconsistent_digit_grouping.fixed
+++ b/src/tools/clippy/tests/ui/inconsistent_digit_grouping.fixed
@@ -23,15 +23,25 @@ fn main() {
         1.123_456_7_f32,
     );
     let bad = (123_456, 12_345_678, 1_234_567, 1_234.567_8_f32, 1.234_567_8_f32);
+    //~^ inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
 
     // Test padding
     let _ = 0x0010_0000;
+    //~^ unreadable_literal
     let _ = 0x0100_0000;
+    //~^ unreadable_literal
     let _ = 0x1000_0000;
+    //~^ unreadable_literal
     let _ = 0x0001_0000_0000_u64;
+    //~^ unreadable_literal
 
     // Test suggestion when fraction has no digits
     let _: f32 = 123_456.;
+    //~^ inconsistent_digit_grouping
 
     // Test UUID formatted literal
     let _: u128 = 0x12345678_1234_1234_1234_123456789012;
diff --git a/src/tools/clippy/tests/ui/inconsistent_digit_grouping.rs b/src/tools/clippy/tests/ui/inconsistent_digit_grouping.rs
index ac47ae175948..a172c5450ef8 100644
--- a/src/tools/clippy/tests/ui/inconsistent_digit_grouping.rs
+++ b/src/tools/clippy/tests/ui/inconsistent_digit_grouping.rs
@@ -23,15 +23,25 @@ fn main() {
         1.123_456_7_f32,
     );
     let bad = (1_23_456, 1_234_5678, 1234_567, 1_234.5678_f32, 1.234_5678_f32);
+    //~^ inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
+    //~| inconsistent_digit_grouping
 
     // Test padding
     let _ = 0x100000;
+    //~^ unreadable_literal
     let _ = 0x1000000;
+    //~^ unreadable_literal
     let _ = 0x10000000;
+    //~^ unreadable_literal
     let _ = 0x100000000_u64;
+    //~^ unreadable_literal
 
     // Test suggestion when fraction has no digits
     let _: f32 = 1_23_456.;
+    //~^ inconsistent_digit_grouping
 
     // Test UUID formatted literal
     let _: u128 = 0x12345678_1234_1234_1234_123456789012;
diff --git a/src/tools/clippy/tests/ui/inconsistent_digit_grouping.stderr b/src/tools/clippy/tests/ui/inconsistent_digit_grouping.stderr
index 173b824935c8..be54de5e7c16 100644
--- a/src/tools/clippy/tests/ui/inconsistent_digit_grouping.stderr
+++ b/src/tools/clippy/tests/ui/inconsistent_digit_grouping.stderr
@@ -32,7 +32,7 @@ LL |     let bad = (1_23_456, 1_234_5678, 1234_567, 1_234.5678_f32, 1.234_5678_f
    |                                                                ^^^^^^^^^^^^^^ help: consider: `1.234_567_8_f32`
 
 error: long literal lacking separators
-  --> tests/ui/inconsistent_digit_grouping.rs:28:13
+  --> tests/ui/inconsistent_digit_grouping.rs:33:13
    |
 LL |     let _ = 0x100000;
    |             ^^^^^^^^ help: consider: `0x0010_0000`
@@ -44,25 +44,25 @@ LL | #[deny(clippy::unreadable_literal)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: long literal lacking separators
-  --> tests/ui/inconsistent_digit_grouping.rs:29:13
+  --> tests/ui/inconsistent_digit_grouping.rs:35:13
    |
 LL |     let _ = 0x1000000;
    |             ^^^^^^^^^ help: consider: `0x0100_0000`
 
 error: long literal lacking separators
-  --> tests/ui/inconsistent_digit_grouping.rs:30:13
+  --> tests/ui/inconsistent_digit_grouping.rs:37:13
    |
 LL |     let _ = 0x10000000;
    |             ^^^^^^^^^^ help: consider: `0x1000_0000`
 
 error: long literal lacking separators
-  --> tests/ui/inconsistent_digit_grouping.rs:31:13
+  --> tests/ui/inconsistent_digit_grouping.rs:39:13
    |
 LL |     let _ = 0x100000000_u64;
    |             ^^^^^^^^^^^^^^^ help: consider: `0x0001_0000_0000_u64`
 
 error: digits grouped inconsistently by underscores
-  --> tests/ui/inconsistent_digit_grouping.rs:34:18
+  --> tests/ui/inconsistent_digit_grouping.rs:43:18
    |
 LL |     let _: f32 = 1_23_456.;
    |                  ^^^^^^^^^ help: consider: `123_456.`
diff --git a/src/tools/clippy/tests/ui/inconsistent_struct_constructor.fixed b/src/tools/clippy/tests/ui/inconsistent_struct_constructor.fixed
index 67bd3e4d2797..66232c0b9d8e 100644
--- a/src/tools/clippy/tests/ui/inconsistent_struct_constructor.fixed
+++ b/src/tools/clippy/tests/ui/inconsistent_struct_constructor.fixed
@@ -34,6 +34,7 @@ mod without_base {
 
         // Should lint.
         Foo { x, y, z };
+        //~^ inconsistent_struct_constructor
 
         // Should NOT lint.
         // issue #7069.
@@ -65,6 +66,7 @@ mod with_base {
             z,
             ..Default::default()
         };
+        //~^^^^ inconsistent_struct_constructor
 
         // Should NOT lint because the order is consistent with the definition.
         Foo {
diff --git a/src/tools/clippy/tests/ui/inconsistent_struct_constructor.rs b/src/tools/clippy/tests/ui/inconsistent_struct_constructor.rs
index d49f236b9b07..8dd228e72ed7 100644
--- a/src/tools/clippy/tests/ui/inconsistent_struct_constructor.rs
+++ b/src/tools/clippy/tests/ui/inconsistent_struct_constructor.rs
@@ -34,6 +34,7 @@ mod without_base {
 
         // Should lint.
         Foo { y, x, z };
+        //~^ inconsistent_struct_constructor
 
         // Should NOT lint.
         // issue #7069.
@@ -65,6 +66,7 @@ mod with_base {
             x,
             ..Default::default()
         };
+        //~^^^^ inconsistent_struct_constructor
 
         // Should NOT lint because the order is consistent with the definition.
         Foo {
diff --git a/src/tools/clippy/tests/ui/inconsistent_struct_constructor.stderr b/src/tools/clippy/tests/ui/inconsistent_struct_constructor.stderr
index c145eb2a239e..2f48a011d26f 100644
--- a/src/tools/clippy/tests/ui/inconsistent_struct_constructor.stderr
+++ b/src/tools/clippy/tests/ui/inconsistent_struct_constructor.stderr
@@ -8,7 +8,7 @@ LL |         Foo { y, x, z };
    = help: to override `-D warnings` add `#[allow(clippy::inconsistent_struct_constructor)]`
 
 error: struct constructor field order is inconsistent with struct definition field order
-  --> tests/ui/inconsistent_struct_constructor.rs:64:13
+  --> tests/ui/inconsistent_struct_constructor.rs:65:13
    |
 LL | /             z,
 LL | |             x,
diff --git a/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.fixed b/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.fixed
index ea8e56e18b08..e19aa4acb4c1 100644
--- a/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.fixed
+++ b/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.fixed
@@ -12,21 +12,24 @@ fn lintable_examples() {
     // Try with reference
     let slice: Option<&[u32]> = Some(&[1, 2, 3]);
     if let Some([slice_0, ..]) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice_0);
     }
 
     // Try with copy
     let slice: Option<[u32; 3]> = Some([1, 2, 3]);
     if let Some([slice_0, ..]) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice_0);
     }
 
     // Try with long slice and small indices
     let slice: Option<[u32; 9]> = Some([1, 2, 3, 4, 5, 6, 7, 8, 9]);
     if let Some([slice_0, _, slice_2, ..]) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice_2);
         println!("{}", slice_0);
     }
@@ -34,7 +37,8 @@ fn lintable_examples() {
     // Multiple bindings
     let slice_wrapped: SomeEnum<[u32; 3]> = SomeEnum::One([5, 6, 7]);
     if let SomeEnum::One([slice_0, ..]) | SomeEnum::Three([slice_0, ..]) = slice_wrapped {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice_0);
     }
 
@@ -42,8 +46,9 @@ fn lintable_examples() {
     let a_wrapped: SomeEnum<[u32; 3]> = SomeEnum::One([9, 5, 1]);
     let b_wrapped: Option<[u32; 2]> = Some([4, 6]);
     if let (SomeEnum::Three([_, _, a_2, ..]), Some([_, b_1, ..])) = (a_wrapped, b_wrapped) {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
-        //~| ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+        //~| index_refutable_slice
+
         println!("{} -> {}", a_2, b_1);
     }
 
@@ -51,7 +56,8 @@ fn lintable_examples() {
     // borrowed and `String` doesn't implement copy
     let slice: Option<[String; 2]> = Some([String::from("1"), String::from("2")]);
     if let Some([_, ref slice_1, ..]) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{:?}", slice_1);
     }
     println!("{:?}", slice);
@@ -60,7 +66,8 @@ fn lintable_examples() {
     // a reference
     let slice: Option<[String; 2]> = Some([String::from("1"), String::from("2")]);
     if let Some([slice_0, ..]) = &slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{:?}", slice_0);
     }
     println!("{:?}", slice);
@@ -130,7 +137,8 @@ fn check_slice_in_struct() {
 
     // Test 1: Field access
     if let Some([slice_0, ..]) = wrap.inner {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         if wrap.is_awesome {
             println!("This is awesome! {}", slice_0);
         }
@@ -138,7 +146,8 @@ fn check_slice_in_struct() {
 
     // Test 2: function access
     if let Some([slice_0, ..]) = wrap.inner {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         if wrap.is_super_awesome() {
             println!("This is super awesome! {}", slice_0);
         }
diff --git a/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.rs b/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.rs
index 1c1d1c4cbe46..290393568554 100644
--- a/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.rs
+++ b/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.rs
@@ -12,21 +12,24 @@ fn lintable_examples() {
     // Try with reference
     let slice: Option<&[u32]> = Some(&[1, 2, 3]);
     if let Some(slice) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice[0]);
     }
 
     // Try with copy
     let slice: Option<[u32; 3]> = Some([1, 2, 3]);
     if let Some(slice) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice[0]);
     }
 
     // Try with long slice and small indices
     let slice: Option<[u32; 9]> = Some([1, 2, 3, 4, 5, 6, 7, 8, 9]);
     if let Some(slice) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice[2]);
         println!("{}", slice[0]);
     }
@@ -34,7 +37,8 @@ fn lintable_examples() {
     // Multiple bindings
     let slice_wrapped: SomeEnum<[u32; 3]> = SomeEnum::One([5, 6, 7]);
     if let SomeEnum::One(slice) | SomeEnum::Three(slice) = slice_wrapped {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{}", slice[0]);
     }
 
@@ -42,8 +46,9 @@ fn lintable_examples() {
     let a_wrapped: SomeEnum<[u32; 3]> = SomeEnum::One([9, 5, 1]);
     let b_wrapped: Option<[u32; 2]> = Some([4, 6]);
     if let (SomeEnum::Three(a), Some(b)) = (a_wrapped, b_wrapped) {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
-        //~| ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+        //~| index_refutable_slice
+
         println!("{} -> {}", a[2], b[1]);
     }
 
@@ -51,7 +56,8 @@ fn lintable_examples() {
     // borrowed and `String` doesn't implement copy
     let slice: Option<[String; 2]> = Some([String::from("1"), String::from("2")]);
     if let Some(ref slice) = slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{:?}", slice[1]);
     }
     println!("{:?}", slice);
@@ -60,7 +66,8 @@ fn lintable_examples() {
     // a reference
     let slice: Option<[String; 2]> = Some([String::from("1"), String::from("2")]);
     if let Some(slice) = &slice {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         println!("{:?}", slice[0]);
     }
     println!("{:?}", slice);
@@ -130,7 +137,8 @@ fn check_slice_in_struct() {
 
     // Test 1: Field access
     if let Some(slice) = wrap.inner {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         if wrap.is_awesome {
             println!("This is awesome! {}", slice[0]);
         }
@@ -138,7 +146,8 @@ fn check_slice_in_struct() {
 
     // Test 2: function access
     if let Some(slice) = wrap.inner {
-        //~^ ERROR: this binding can be a slice pattern to avoid indexing
+        //~^ index_refutable_slice
+
         if wrap.is_super_awesome() {
             println!("This is super awesome! {}", slice[0]);
         }
diff --git a/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.stderr b/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.stderr
index 14ee2e54cab1..04bc9838d0c2 100644
--- a/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.stderr
+++ b/src/tools/clippy/tests/ui/index_refutable_slice/if_let_slice_binding.stderr
@@ -13,11 +13,12 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let Some([slice_0, ..]) = slice {
 LL |
+LL |
 LL ~         println!("{}", slice_0);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:21:17
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:22:17
    |
 LL |     if let Some(slice) = slice {
    |                 ^^^^^
@@ -26,11 +27,12 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let Some([slice_0, ..]) = slice {
 LL |
+LL |
 LL ~         println!("{}", slice_0);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:28:17
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:30:17
    |
 LL |     if let Some(slice) = slice {
    |                 ^^^^^
@@ -39,12 +41,13 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let Some([slice_0, _, slice_2, ..]) = slice {
 LL |
+LL |
 LL ~         println!("{}", slice_2);
 LL ~         println!("{}", slice_0);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:36:26
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:39:26
    |
 LL |     if let SomeEnum::One(slice) | SomeEnum::Three(slice) = slice_wrapped {
    |                          ^^^^^
@@ -53,11 +56,12 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let SomeEnum::One([slice_0, ..]) | SomeEnum::Three([slice_0, ..]) = slice_wrapped {
 LL |
+LL |
 LL ~         println!("{}", slice_0);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:44:29
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:48:29
    |
 LL |     if let (SomeEnum::Three(a), Some(b)) = (a_wrapped, b_wrapped) {
    |                             ^
@@ -67,11 +71,12 @@ help: replace the binding and indexed access with a slice pattern
 LL ~     if let (SomeEnum::Three([_, _, a_2, ..]), Some(b)) = (a_wrapped, b_wrapped) {
 LL |
 LL |
+LL |
 LL ~         println!("{} -> {}", a_2, b[1]);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:44:38
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:48:38
    |
 LL |     if let (SomeEnum::Three(a), Some(b)) = (a_wrapped, b_wrapped) {
    |                                      ^
@@ -81,11 +86,12 @@ help: replace the binding and indexed access with a slice pattern
 LL ~     if let (SomeEnum::Three(a), Some([_, b_1, ..])) = (a_wrapped, b_wrapped) {
 LL |
 LL |
+LL |
 LL ~         println!("{} -> {}", a[2], b_1);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:53:21
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:58:21
    |
 LL |     if let Some(ref slice) = slice {
    |                     ^^^^^
@@ -94,11 +100,12 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let Some([_, ref slice_1, ..]) = slice {
 LL |
+LL |
 LL ~         println!("{:?}", slice_1);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:62:17
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:68:17
    |
 LL |     if let Some(slice) = &slice {
    |                 ^^^^^
@@ -107,11 +114,12 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let Some([slice_0, ..]) = &slice {
 LL |
+LL |
 LL ~         println!("{:?}", slice_0);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:132:17
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:139:17
    |
 LL |     if let Some(slice) = wrap.inner {
    |                 ^^^^^
@@ -120,12 +128,13 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let Some([slice_0, ..]) = wrap.inner {
 LL |
+LL |
 LL |         if wrap.is_awesome {
 LL ~             println!("This is awesome! {}", slice_0);
    |
 
 error: this binding can be a slice pattern to avoid indexing
-  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:140:17
+  --> tests/ui/index_refutable_slice/if_let_slice_binding.rs:148:17
    |
 LL |     if let Some(slice) = wrap.inner {
    |                 ^^^^^
@@ -134,6 +143,7 @@ help: replace the binding and indexed access with a slice pattern
    |
 LL ~     if let Some([slice_0, ..]) = wrap.inner {
 LL |
+LL |
 LL |         if wrap.is_super_awesome() {
 LL ~             println!("This is super awesome! {}", slice_0);
    |
diff --git a/src/tools/clippy/tests/ui/indexing_slicing_index.rs b/src/tools/clippy/tests/ui/indexing_slicing_index.rs
index 2af5fcc82a9b..cfa1c2f7c75f 100644
--- a/src/tools/clippy/tests/ui/indexing_slicing_index.rs
+++ b/src/tools/clippy/tests/ui/indexing_slicing_index.rs
@@ -49,8 +49,10 @@ fn main() {
     //~^ ERROR: indexing may panic
     // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
     x[4];
+    //~^ out_of_bounds_indexing
     // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
     x[1 << 3];
+    //~^ out_of_bounds_indexing
 
     // Ok, should not produce stderr.
     x[0];
@@ -66,12 +68,14 @@ fn main() {
     // This should be linted, since `suppress-restriction-lint-in-const` default is false.
     const { &ARR[idx4()] };
     //~^ ERROR: indexing may panic
+    //~| ERROR: evaluation of `main
 
     let y = &x;
     // Ok, referencing shouldn't affect this lint. See the issue 6021
     y[0];
     // Ok, rustc will handle references too.
     y[4];
+    //~^ out_of_bounds_indexing
 
     let v = vec![0; 5];
     v[0];
@@ -87,6 +91,7 @@ fn main() {
     const M: usize = 3;
     // Ok, let rustc's `unconditional_panic` lint handle `usize` indexing on arrays.
     x[N];
+    //~^ out_of_bounds_indexing
     // Ok, should not produce stderr.
     x[M];
     v[N];
@@ -96,4 +101,5 @@ fn main() {
 
     let slice = &x;
     let _ = x[4];
+    //~^ out_of_bounds_indexing
 }
diff --git a/src/tools/clippy/tests/ui/indexing_slicing_index.stderr b/src/tools/clippy/tests/ui/indexing_slicing_index.stderr
index 71677584d25b..50ee9b9edc75 100644
--- a/src/tools/clippy/tests/ui/indexing_slicing_index.stderr
+++ b/src/tools/clippy/tests/ui/indexing_slicing_index.stderr
@@ -10,13 +10,13 @@ LL | const REF: &i32 = &ARR[idx()]; // This should be linted, since `suppress-re
    = help: to override `-D warnings` add `#[allow(clippy::indexing_slicing)]`
 
 error[E0080]: evaluation of `main::{constant#3}` failed
-  --> tests/ui/indexing_slicing_index.rs:67:14
+  --> tests/ui/indexing_slicing_index.rs:69:14
    |
 LL |     const { &ARR[idx4()] };
    |              ^^^^^^^^^^^ index out of bounds: the length is 2 but the index is 4
 
 note: erroneous constant encountered
-  --> tests/ui/indexing_slicing_index.rs:67:5
+  --> tests/ui/indexing_slicing_index.rs:69:5
    |
 LL |     const { &ARR[idx4()] };
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -39,13 +39,13 @@ LL |     x[4];
    = help: to override `-D warnings` add `#[allow(clippy::out_of_bounds_indexing)]`
 
 error: index is out of bounds
-  --> tests/ui/indexing_slicing_index.rs:53:5
+  --> tests/ui/indexing_slicing_index.rs:54:5
    |
 LL |     x[1 << 3];
    |     ^^^^^^^^^
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_index.rs:64:14
+  --> tests/ui/indexing_slicing_index.rs:66:14
    |
 LL |     const { &ARR[idx()] };
    |              ^^^^^^^^^^
@@ -54,7 +54,7 @@ LL |     const { &ARR[idx()] };
    = note: the suggestion might not be applicable in constant blocks
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_index.rs:67:14
+  --> tests/ui/indexing_slicing_index.rs:69:14
    |
 LL |     const { &ARR[idx4()] };
    |              ^^^^^^^^^^^
@@ -63,13 +63,13 @@ LL |     const { &ARR[idx4()] };
    = note: the suggestion might not be applicable in constant blocks
 
 error: index is out of bounds
-  --> tests/ui/indexing_slicing_index.rs:74:5
+  --> tests/ui/indexing_slicing_index.rs:77:5
    |
 LL |     y[4];
    |     ^^^^
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_index.rs:77:5
+  --> tests/ui/indexing_slicing_index.rs:81:5
    |
 LL |     v[0];
    |     ^^^^
@@ -77,7 +77,7 @@ LL |     v[0];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_index.rs:79:5
+  --> tests/ui/indexing_slicing_index.rs:83:5
    |
 LL |     v[10];
    |     ^^^^^
@@ -85,7 +85,7 @@ LL |     v[10];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_index.rs:81:5
+  --> tests/ui/indexing_slicing_index.rs:85:5
    |
 LL |     v[1 << 3];
    |     ^^^^^^^^^
@@ -93,13 +93,13 @@ LL |     v[1 << 3];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: index is out of bounds
-  --> tests/ui/indexing_slicing_index.rs:89:5
+  --> tests/ui/indexing_slicing_index.rs:93:5
    |
 LL |     x[N];
    |     ^^^^
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_index.rs:92:5
+  --> tests/ui/indexing_slicing_index.rs:97:5
    |
 LL |     v[N];
    |     ^^^^
@@ -107,7 +107,7 @@ LL |     v[N];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_index.rs:94:5
+  --> tests/ui/indexing_slicing_index.rs:99:5
    |
 LL |     v[M];
    |     ^^^^
@@ -115,7 +115,7 @@ LL |     v[M];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: index is out of bounds
-  --> tests/ui/indexing_slicing_index.rs:98:13
+  --> tests/ui/indexing_slicing_index.rs:103:13
    |
 LL |     let _ = x[4];
    |             ^^^^
diff --git a/src/tools/clippy/tests/ui/indexing_slicing_slice.rs b/src/tools/clippy/tests/ui/indexing_slicing_slice.rs
index f37bcc4aa0ca..cad77f56d03a 100644
--- a/src/tools/clippy/tests/ui/indexing_slicing_slice.rs
+++ b/src/tools/clippy/tests/ui/indexing_slicing_slice.rs
@@ -113,22 +113,21 @@ fn main() {
     let index_from: usize = 2;
     let index_to: usize = 3;
     &x[index..];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
     &x[..index];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
     &x[index_from..index_to];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
     &x[index_from..][..index_to];
-    //~^ ERROR: slicing may panic
-    //~| ERROR: slicing may panic
+    //~^ indexing_slicing
+    //~| indexing_slicing
     &x[5..][..10];
-    //~^ ERROR: slicing may panic
-    //~| ERROR: range is out of bounds
-    //~| NOTE: `-D clippy::out-of-bounds-indexing` implied by `-D warnings`
+    //~^ indexing_slicing
+    //~| out_of_bounds_indexing
     &x[0..][..3];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
     &x[1..][..5];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
 
     &x[0..].get(..3); // Ok, should not produce stderr.
     &x[0..3]; // Ok, should not produce stderr.
@@ -136,22 +135,22 @@ fn main() {
     let y = &x;
     &y[1..2];
     &y[0..=4];
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
     &y[..=4];
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
 
     &y[..]; // Ok, should not produce stderr.
 
     let v = vec![0; 5];
     &v[10..100];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
     &x[10..][..100];
-    //~^ ERROR: slicing may panic
-    //~| ERROR: range is out of bounds
+    //~^ indexing_slicing
+    //~| out_of_bounds_indexing
     &v[10..];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
     &v[..100];
-    //~^ ERROR: slicing may panic
+    //~^ indexing_slicing
 
     &v[..]; // Ok, should not produce stderr.
 
@@ -169,12 +168,15 @@ fn main() {
 
     // Lint on this, because `get` does exist with same signature
     map_with_get[true];
+    //~^ indexing_slicing
 
     let s = S::<i32>(1);
     s[0];
+    //~^ indexing_slicing
 
     let y = Y::<i32>(1);
     y[0];
+    //~^ indexing_slicing
 
     let z = Z::<i32>(1);
     z[0];
diff --git a/src/tools/clippy/tests/ui/indexing_slicing_slice.stderr b/src/tools/clippy/tests/ui/indexing_slicing_slice.stderr
index 1e72506746ec..e3ef89823e3d 100644
--- a/src/tools/clippy/tests/ui/indexing_slicing_slice.stderr
+++ b/src/tools/clippy/tests/ui/indexing_slicing_slice.stderr
@@ -58,7 +58,7 @@ LL |     &x[5..][..10];
    = help: to override `-D warnings` add `#[allow(clippy::out_of_bounds_indexing)]`
 
 error: slicing may panic
-  --> tests/ui/indexing_slicing_slice.rs:128:6
+  --> tests/ui/indexing_slicing_slice.rs:127:6
    |
 LL |     &x[0..][..3];
    |      ^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     &x[0..][..3];
    = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: slicing may panic
-  --> tests/ui/indexing_slicing_slice.rs:130:6
+  --> tests/ui/indexing_slicing_slice.rs:129:6
    |
 LL |     &x[1..][..5];
    |      ^^^^^^^^^^^
@@ -74,19 +74,19 @@ LL |     &x[1..][..5];
    = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
-  --> tests/ui/indexing_slicing_slice.rs:138:12
+  --> tests/ui/indexing_slicing_slice.rs:137:12
    |
 LL |     &y[0..=4];
    |            ^
 
 error: range is out of bounds
-  --> tests/ui/indexing_slicing_slice.rs:140:11
+  --> tests/ui/indexing_slicing_slice.rs:139:11
    |
 LL |     &y[..=4];
    |           ^
 
 error: slicing may panic
-  --> tests/ui/indexing_slicing_slice.rs:146:6
+  --> tests/ui/indexing_slicing_slice.rs:145:6
    |
 LL |     &v[10..100];
    |      ^^^^^^^^^^
@@ -94,7 +94,7 @@ LL |     &v[10..100];
    = help: consider using `.get(n..m)` or `.get_mut(n..m)` instead
 
 error: slicing may panic
-  --> tests/ui/indexing_slicing_slice.rs:148:6
+  --> tests/ui/indexing_slicing_slice.rs:147:6
    |
 LL |     &x[10..][..100];
    |      ^^^^^^^^^^^^^^
@@ -102,13 +102,13 @@ LL |     &x[10..][..100];
    = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: range is out of bounds
-  --> tests/ui/indexing_slicing_slice.rs:148:8
+  --> tests/ui/indexing_slicing_slice.rs:147:8
    |
 LL |     &x[10..][..100];
    |        ^^
 
 error: slicing may panic
-  --> tests/ui/indexing_slicing_slice.rs:151:6
+  --> tests/ui/indexing_slicing_slice.rs:150:6
    |
 LL |     &v[10..];
    |      ^^^^^^^
@@ -116,7 +116,7 @@ LL |     &v[10..];
    = help: consider using `.get(n..)` or .get_mut(n..)` instead
 
 error: slicing may panic
-  --> tests/ui/indexing_slicing_slice.rs:153:6
+  --> tests/ui/indexing_slicing_slice.rs:152:6
    |
 LL |     &v[..100];
    |      ^^^^^^^^
@@ -124,7 +124,7 @@ LL |     &v[..100];
    = help: consider using `.get(..n)`or `.get_mut(..n)` instead
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_slice.rs:171:5
+  --> tests/ui/indexing_slicing_slice.rs:170:5
    |
 LL |     map_with_get[true];
    |     ^^^^^^^^^^^^^^^^^^
@@ -140,7 +140,7 @@ LL |     s[0];
    = help: consider using `.get(n)` or `.get_mut(n)` instead
 
 error: indexing may panic
-  --> tests/ui/indexing_slicing_slice.rs:177:5
+  --> tests/ui/indexing_slicing_slice.rs:178:5
    |
 LL |     y[0];
    |     ^^^^
diff --git a/src/tools/clippy/tests/ui/ineffective_open_options.fixed b/src/tools/clippy/tests/ui/ineffective_open_options.fixed
index 88489dc46bbb..03b73f99961a 100644
--- a/src/tools/clippy/tests/ui/ineffective_open_options.fixed
+++ b/src/tools/clippy/tests/ui/ineffective_open_options.fixed
@@ -5,7 +5,8 @@ use std::fs::OpenOptions;
 fn main() {
     let file = OpenOptions::new()
         .create(true)
-         //~ ERROR: unnecessary use of `.write(true)`
+        
+        //~^ ineffective_open_options
         .append(true)
         .open("dump.json")
         .unwrap();
@@ -13,7 +14,8 @@ fn main() {
     let file = OpenOptions::new()
         .create(true)
         .append(true)
-         //~ ERROR: unnecessary use of `.write(true)`
+        
+        //~^ ineffective_open_options
         .open("dump.json")
         .unwrap();
 
diff --git a/src/tools/clippy/tests/ui/ineffective_open_options.rs b/src/tools/clippy/tests/ui/ineffective_open_options.rs
index db8bca3e2acd..e333a71490fb 100644
--- a/src/tools/clippy/tests/ui/ineffective_open_options.rs
+++ b/src/tools/clippy/tests/ui/ineffective_open_options.rs
@@ -5,7 +5,8 @@ use std::fs::OpenOptions;
 fn main() {
     let file = OpenOptions::new()
         .create(true)
-        .write(true) //~ ERROR: unnecessary use of `.write(true)`
+        .write(true)
+        //~^ ineffective_open_options
         .append(true)
         .open("dump.json")
         .unwrap();
@@ -13,7 +14,8 @@ fn main() {
     let file = OpenOptions::new()
         .create(true)
         .append(true)
-        .write(true) //~ ERROR: unnecessary use of `.write(true)`
+        .write(true)
+        //~^ ineffective_open_options
         .open("dump.json")
         .unwrap();
 
diff --git a/src/tools/clippy/tests/ui/ineffective_open_options.stderr b/src/tools/clippy/tests/ui/ineffective_open_options.stderr
index 0d6933bb449e..42bb0438dcee 100644
--- a/src/tools/clippy/tests/ui/ineffective_open_options.stderr
+++ b/src/tools/clippy/tests/ui/ineffective_open_options.stderr
@@ -8,7 +8,7 @@ LL |         .write(true)
    = help: to override `-D warnings` add `#[allow(clippy::ineffective_open_options)]`
 
 error: unnecessary use of `.write(true)` because there is `.append(true)`
-  --> tests/ui/ineffective_open_options.rs:16:9
+  --> tests/ui/ineffective_open_options.rs:17:9
    |
 LL |         .write(true)
    |         ^^^^^^^^^^^^ help: remove `.write(true)`
diff --git a/src/tools/clippy/tests/ui/inefficient_to_string.fixed b/src/tools/clippy/tests/ui/inefficient_to_string.fixed
index 1e19323113c5..a0d34e58a925 100644
--- a/src/tools/clippy/tests/ui/inefficient_to_string.fixed
+++ b/src/tools/clippy/tests/ui/inefficient_to_string.fixed
@@ -8,7 +8,9 @@ fn main() {
     let rrrstr: &&&str = &rrstr;
     let _: String = rstr.to_string();
     let _: String = (*rrstr).to_string();
+    //~^ inefficient_to_string
     let _: String = (**rrrstr).to_string();
+    //~^ inefficient_to_string
 
     let string: String = String::from("hello");
     let rstring: &String = &string;
@@ -17,7 +19,9 @@ fn main() {
     let _: String = string.to_string();
     let _: String = rstring.to_string();
     let _: String = (*rrstring).to_string();
+    //~^ inefficient_to_string
     let _: String = (**rrrstring).to_string();
+    //~^ inefficient_to_string
 
     let cow: Cow<'_, str> = Cow::Borrowed("hello");
     let rcow: &Cow<'_, str> = &cow;
@@ -26,5 +30,7 @@ fn main() {
     let _: String = cow.to_string();
     let _: String = rcow.to_string();
     let _: String = (*rrcow).to_string();
+    //~^ inefficient_to_string
     let _: String = (**rrrcow).to_string();
+    //~^ inefficient_to_string
 }
diff --git a/src/tools/clippy/tests/ui/inefficient_to_string.rs b/src/tools/clippy/tests/ui/inefficient_to_string.rs
index f027bae6fe34..cbe90d4a125b 100644
--- a/src/tools/clippy/tests/ui/inefficient_to_string.rs
+++ b/src/tools/clippy/tests/ui/inefficient_to_string.rs
@@ -8,7 +8,9 @@ fn main() {
     let rrrstr: &&&str = &rrstr;
     let _: String = rstr.to_string();
     let _: String = rrstr.to_string();
+    //~^ inefficient_to_string
     let _: String = rrrstr.to_string();
+    //~^ inefficient_to_string
 
     let string: String = String::from("hello");
     let rstring: &String = &string;
@@ -17,7 +19,9 @@ fn main() {
     let _: String = string.to_string();
     let _: String = rstring.to_string();
     let _: String = rrstring.to_string();
+    //~^ inefficient_to_string
     let _: String = rrrstring.to_string();
+    //~^ inefficient_to_string
 
     let cow: Cow<'_, str> = Cow::Borrowed("hello");
     let rcow: &Cow<'_, str> = &cow;
@@ -26,5 +30,7 @@ fn main() {
     let _: String = cow.to_string();
     let _: String = rcow.to_string();
     let _: String = rrcow.to_string();
+    //~^ inefficient_to_string
     let _: String = rrrcow.to_string();
+    //~^ inefficient_to_string
 }
diff --git a/src/tools/clippy/tests/ui/inefficient_to_string.stderr b/src/tools/clippy/tests/ui/inefficient_to_string.stderr
index e71e667cf0cf..8593c0addc5f 100644
--- a/src/tools/clippy/tests/ui/inefficient_to_string.stderr
+++ b/src/tools/clippy/tests/ui/inefficient_to_string.stderr
@@ -12,7 +12,7 @@ LL | #![deny(clippy::inefficient_to_string)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `to_string` on `&&&str`
-  --> tests/ui/inefficient_to_string.rs:11:21
+  --> tests/ui/inefficient_to_string.rs:12:21
    |
 LL |     let _: String = rrrstr.to_string();
    |                     ^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrstr).to_string()`
@@ -20,7 +20,7 @@ LL |     let _: String = rrrstr.to_string();
    = help: `&&str` implements `ToString` through a slower blanket impl, but `str` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&std::string::String`
-  --> tests/ui/inefficient_to_string.rs:19:21
+  --> tests/ui/inefficient_to_string.rs:21:21
    |
 LL |     let _: String = rrstring.to_string();
    |                     ^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(*rrstring).to_string()`
@@ -28,7 +28,7 @@ LL |     let _: String = rrstring.to_string();
    = help: `&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&&std::string::String`
-  --> tests/ui/inefficient_to_string.rs:20:21
+  --> tests/ui/inefficient_to_string.rs:23:21
    |
 LL |     let _: String = rrrstring.to_string();
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrstring).to_string()`
@@ -36,7 +36,7 @@ LL |     let _: String = rrrstring.to_string();
    = help: `&&std::string::String` implements `ToString` through a slower blanket impl, but `std::string::String` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&std::borrow::Cow<'_, str>`
-  --> tests/ui/inefficient_to_string.rs:28:21
+  --> tests/ui/inefficient_to_string.rs:32:21
    |
 LL |     let _: String = rrcow.to_string();
    |                     ^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(*rrcow).to_string()`
@@ -44,7 +44,7 @@ LL |     let _: String = rrcow.to_string();
    = help: `&std::borrow::Cow<'_, str>` implements `ToString` through a slower blanket impl, but `std::borrow::Cow<'_, str>` has a fast specialization of `ToString`
 
 error: calling `to_string` on `&&&std::borrow::Cow<'_, str>`
-  --> tests/ui/inefficient_to_string.rs:29:21
+  --> tests/ui/inefficient_to_string.rs:34:21
    |
 LL |     let _: String = rrrcow.to_string();
    |                     ^^^^^^^^^^^^^^^^^^ help: try dereferencing the receiver: `(**rrrcow).to_string()`
diff --git a/src/tools/clippy/tests/ui/infallible_destructuring_match.rs b/src/tools/clippy/tests/ui/infallible_destructuring_match.rs
index 7cc7cb9d6878..5db30ebca88f 100644
--- a/src/tools/clippy/tests/ui/infallible_destructuring_match.rs
+++ b/src/tools/clippy/tests/ui/infallible_destructuring_match.rs
@@ -26,6 +26,7 @@ fn infallible_destructuring_match_enum() {
 
     // This should lint!
     let data = match wrapper {
+        //~^ infallible_destructuring_match
         SingleVariantEnum::Variant(i) => i,
     };
 
@@ -58,6 +59,7 @@ fn infallible_destructuring_match_struct() {
 
     // This should lint!
     let data = match wrapper {
+        //~^ infallible_destructuring_match
         TupleStruct(i) => i,
     };
 
@@ -82,6 +84,7 @@ fn infallible_destructuring_match_struct_with_noncopy() {
 
     // This should lint! (keeping `ref` in the suggestion)
     let data = match wrapper {
+        //~^ infallible_destructuring_match
         TupleStructWithNonCopy(ref n) => n,
     };
 
@@ -101,6 +104,7 @@ fn never_enum() {
 
     // This should lint!
     let data = match wrapper {
+        //~^ infallible_destructuring_match
         Ok(i) => i,
     };
 
diff --git a/src/tools/clippy/tests/ui/infallible_destructuring_match.stderr b/src/tools/clippy/tests/ui/infallible_destructuring_match.stderr
index b709fd8630e9..1e784bc598bf 100644
--- a/src/tools/clippy/tests/ui/infallible_destructuring_match.stderr
+++ b/src/tools/clippy/tests/ui/infallible_destructuring_match.stderr
@@ -2,6 +2,7 @@ error: you seem to be trying to use `match` to destructure a single infallible p
   --> tests/ui/infallible_destructuring_match.rs:28:5
    |
 LL | /     let data = match wrapper {
+LL | |
 LL | |         SingleVariantEnum::Variant(i) => i,
 LL | |     };
    | |______^ help: try: `let SingleVariantEnum::Variant(data) = wrapper;`
@@ -10,25 +11,28 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::infallible_destructuring_match)]`
 
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
-  --> tests/ui/infallible_destructuring_match.rs:60:5
+  --> tests/ui/infallible_destructuring_match.rs:61:5
    |
 LL | /     let data = match wrapper {
+LL | |
 LL | |         TupleStruct(i) => i,
 LL | |     };
    | |______^ help: try: `let TupleStruct(data) = wrapper;`
 
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
-  --> tests/ui/infallible_destructuring_match.rs:84:5
+  --> tests/ui/infallible_destructuring_match.rs:86:5
    |
 LL | /     let data = match wrapper {
+LL | |
 LL | |         TupleStructWithNonCopy(ref n) => n,
 LL | |     };
    | |______^ help: try: `let TupleStructWithNonCopy(ref data) = wrapper;`
 
 error: you seem to be trying to use `match` to destructure a single infallible pattern. Consider using `let`
-  --> tests/ui/infallible_destructuring_match.rs:103:5
+  --> tests/ui/infallible_destructuring_match.rs:106:5
    |
 LL | /     let data = match wrapper {
+LL | |
 LL | |         Ok(i) => i,
 LL | |     };
    | |______^ help: try: `let Ok(data) = wrapper;`
diff --git a/src/tools/clippy/tests/ui/infinite_iter.rs b/src/tools/clippy/tests/ui/infinite_iter.rs
index 178e300ff5bf..002a791a6579 100644
--- a/src/tools/clippy/tests/ui/infinite_iter.rs
+++ b/src/tools/clippy/tests/ui/infinite_iter.rs
@@ -9,13 +9,16 @@ fn square_is_lower_64(x: &u32) -> bool {
 #[deny(clippy::infinite_iter)]
 fn infinite_iters() {
     repeat(0_u8).collect::<Vec<_>>();
-    //~^ ERROR: infinite iteration detected
+    //~^ infinite_iter
+
     // infinite iter
     (0..8_u32).take_while(square_is_lower_64).cycle().count();
-    //~^ ERROR: infinite iteration detected
+    //~^ infinite_iter
+
     // infinite iter
     (0..8_u64).chain(0..).max();
-    //~^ ERROR: infinite iteration detected
+    //~^ infinite_iter
+
     // infinite iter
     (0_usize..)
         .chain([0usize, 1, 2].iter().cloned())
@@ -23,7 +26,7 @@ fn infinite_iters() {
         .min();
     // infinite iter
     (0..8_u32)
-        //~^ ERROR: infinite iteration detected
+        //~^ infinite_iter
         .rev()
         .cycle()
         .map(|x| x + 1_u32)
@@ -32,10 +35,12 @@ fn infinite_iters() {
     (0..3_u32).flat_map(|x| x..).sum::<u32>();
     // infinite iter
     (0_usize..).flat_map(|x| 0..x).product::<usize>();
-    //~^ ERROR: infinite iteration detected
+    //~^ infinite_iter
+
     // infinite iter
     (0_u64..).filter(|x| x % 2 == 0).last();
-    //~^ ERROR: infinite iteration detected
+    //~^ infinite_iter
+
     // not an infinite, because ranges are double-ended
     (0..42_u64).by_ref().last();
     // iterator is not exhausted
@@ -46,13 +51,15 @@ fn infinite_iters() {
 fn potential_infinite_iters() {
     // maybe infinite iter
     (0..).zip((0..).take_while(square_is_lower_64)).count();
-    //~^ ERROR: possible infinite iteration detected
+    //~^ maybe_infinite_iter
+
     // maybe infinite iter
     repeat(42).take_while(|x| *x == 42).chain(0..42).max();
-    //~^ ERROR: possible infinite iteration detected
+    //~^ maybe_infinite_iter
+
     // maybe infinite iter
     (1..)
-        //~^ ERROR: possible infinite iteration detected
+        //~^ maybe_infinite_iter
         .scan(0, |state, x| {
             *state += x;
             Some(*state)
@@ -60,16 +67,19 @@ fn potential_infinite_iters() {
         .min();
     // maybe infinite iter
     (0..).find(|x| *x == 24);
-    //~^ ERROR: possible infinite iteration detected
+    //~^ maybe_infinite_iter
+
     // maybe infinite iter
     (0..).position(|x| x == 24);
-    //~^ ERROR: possible infinite iteration detected
+    //~^ maybe_infinite_iter
+
     // maybe infinite iter
     (0..).any(|x| x == 24);
-    //~^ ERROR: possible infinite iteration detected
+    //~^ maybe_infinite_iter
+
     // maybe infinite iter
     (0..).all(|x| x == 24);
-    //~^ ERROR: possible infinite iteration detected
+    //~^ maybe_infinite_iter
 
     // not infinite
     (0..).zip(0..42).take_while(|&(x, _)| x != 42).count();
@@ -95,8 +105,7 @@ mod finite_collect {
     fn check_collect() {
         // Infinite iter
         let _: HashSet<i32> = (0..).collect();
-        //~^ ERROR: infinite iteration detected
-        //~| NOTE: `#[deny(clippy::infinite_iter)]` on by default
+        //~^ infinite_iter
 
         // Some data structures don't collect infinitely, such as `ArrayVec`
         let _: C = (0..).collect();
diff --git a/src/tools/clippy/tests/ui/infinite_iter.stderr b/src/tools/clippy/tests/ui/infinite_iter.stderr
index e33d83b75edb..47133a2ea62e 100644
--- a/src/tools/clippy/tests/ui/infinite_iter.stderr
+++ b/src/tools/clippy/tests/ui/infinite_iter.stderr
@@ -11,19 +11,19 @@ LL | #[deny(clippy::infinite_iter)]
    |        ^^^^^^^^^^^^^^^^^^^^^
 
 error: infinite iteration detected
-  --> tests/ui/infinite_iter.rs:14:5
+  --> tests/ui/infinite_iter.rs:15:5
    |
 LL |     (0..8_u32).take_while(square_is_lower_64).cycle().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: infinite iteration detected
-  --> tests/ui/infinite_iter.rs:17:5
+  --> tests/ui/infinite_iter.rs:19:5
    |
 LL |     (0..8_u64).chain(0..).max();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: infinite iteration detected
-  --> tests/ui/infinite_iter.rs:25:5
+  --> tests/ui/infinite_iter.rs:28:5
    |
 LL | /     (0..8_u32)
 LL | |
@@ -34,37 +34,37 @@ LL | |         .for_each(|x| println!("{}", x));
    | |________________________________________^
 
 error: infinite iteration detected
-  --> tests/ui/infinite_iter.rs:34:5
+  --> tests/ui/infinite_iter.rs:37:5
    |
 LL |     (0_usize..).flat_map(|x| 0..x).product::<usize>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: infinite iteration detected
-  --> tests/ui/infinite_iter.rs:37:5
+  --> tests/ui/infinite_iter.rs:41:5
    |
 LL |     (0_u64..).filter(|x| x % 2 == 0).last();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: possible infinite iteration detected
-  --> tests/ui/infinite_iter.rs:48:5
+  --> tests/ui/infinite_iter.rs:53:5
    |
 LL |     (0..).zip((0..).take_while(square_is_lower_64)).count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the lint level is defined here
-  --> tests/ui/infinite_iter.rs:45:8
+  --> tests/ui/infinite_iter.rs:50:8
    |
 LL | #[deny(clippy::maybe_infinite_iter)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: possible infinite iteration detected
-  --> tests/ui/infinite_iter.rs:51:5
+  --> tests/ui/infinite_iter.rs:57:5
    |
 LL |     repeat(42).take_while(|x| *x == 42).chain(0..42).max();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: possible infinite iteration detected
-  --> tests/ui/infinite_iter.rs:54:5
+  --> tests/ui/infinite_iter.rs:61:5
    |
 LL | /     (1..)
 LL | |
@@ -76,31 +76,31 @@ LL | |         .min();
    | |______________^
 
 error: possible infinite iteration detected
-  --> tests/ui/infinite_iter.rs:62:5
+  --> tests/ui/infinite_iter.rs:69:5
    |
 LL |     (0..).find(|x| *x == 24);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: possible infinite iteration detected
-  --> tests/ui/infinite_iter.rs:65:5
+  --> tests/ui/infinite_iter.rs:73:5
    |
 LL |     (0..).position(|x| x == 24);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: possible infinite iteration detected
-  --> tests/ui/infinite_iter.rs:68:5
+  --> tests/ui/infinite_iter.rs:77:5
    |
 LL |     (0..).any(|x| x == 24);
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: possible infinite iteration detected
-  --> tests/ui/infinite_iter.rs:71:5
+  --> tests/ui/infinite_iter.rs:81:5
    |
 LL |     (0..).all(|x| x == 24);
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: infinite iteration detected
-  --> tests/ui/infinite_iter.rs:97:31
+  --> tests/ui/infinite_iter.rs:107:31
    |
 LL |         let _: HashSet<i32> = (0..).collect();
    |                               ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/infinite_loop.rs b/src/tools/clippy/tests/ui/infinite_loop.rs
index 765c67011474..4a0968918bfb 100644
--- a/src/tools/clippy/tests/ui/infinite_loop.rs
+++ b/src/tools/clippy/tests/ui/infinite_loop.rs
@@ -20,15 +20,15 @@ fn immutable_condition() {
     // Should warn when all vars mentioned are immutable
     let y = 0;
     while y < 10 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         println!("KO - y is immutable");
     }
 
     let x = 0;
     while y < 10 && x < 3 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         let mut k = 1;
         k += 2;
         println!("KO - x and y immutable");
@@ -36,8 +36,8 @@ fn immutable_condition() {
 
     let cond = false;
     while !cond {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         println!("KO - cond immutable");
     }
 
@@ -82,21 +82,21 @@ fn unused_var() {
     let (mut i, mut j) = (0, 0);
 
     while i < 3 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         j = 3;
         println!("KO - i not mentioned");
     }
 
     while i < 3 && j > 0 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         println!("KO - i and j not mentioned");
     }
 
     while i < 3 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         let mut i = 5;
         fn_mutref(&mut i);
         println!("KO - shadowed");
@@ -112,15 +112,15 @@ fn used_immutable() {
     let mut i = 0;
 
     while i < 3 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         fn_constref(&i);
         println!("KO - const reference");
     }
 
     while i < 3 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         fn_val(i);
         println!("KO - passed by value");
     }
@@ -187,8 +187,8 @@ impl Counter {
 
     fn print_n(&self, n: usize) {
         while self.count < n {
-            //~^ ERROR: variables in the condition are not mutated in the loop body
-            //~| NOTE: this may lead to an infinite or to a never running loop
+            //~^ while_immutable_condition
+
             println!("KO - {} is not mutated", self.count);
         }
     }
@@ -197,8 +197,8 @@ impl Counter {
 fn while_loop_with_break_and_return() {
     let y = 0;
     while y < 10 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         if y == 0 {
             break;
         }
@@ -206,8 +206,8 @@ fn while_loop_with_break_and_return() {
     }
 
     while y < 10 {
-        //~^ ERROR: variables in the condition are not mutated in the loop body
-        //~| NOTE: this may lead to an infinite or to a never running loop
+        //~^ while_immutable_condition
+
         if y == 0 {
             return;
         }
diff --git a/src/tools/clippy/tests/ui/infinite_loops.rs b/src/tools/clippy/tests/ui/infinite_loops.rs
index d7be6f9ce7e9..eaa8d0088068 100644
--- a/src/tools/clippy/tests/ui/infinite_loops.rs
+++ b/src/tools/clippy/tests/ui/infinite_loops.rs
@@ -11,18 +11,18 @@ fn do_something() {}
 
 fn no_break() {
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         do_something();
     }
 }
 
 fn all_inf() {
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         loop {
-            //~^ ERROR: infinite loop detected
+            //~^ infinite_loop
             loop {
-                //~^ ERROR: infinite loop detected
+                //~^ infinite_loop
                 do_something();
             }
         }
@@ -36,7 +36,7 @@ fn no_break_return_some_ty() -> Option<u8> {
         return None;
     }
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         do_something();
     }
 }
@@ -49,6 +49,7 @@ fn no_break_never_ret() -> ! {
 
 fn no_break_never_ret_noise() {
     loop {
+        //~^ infinite_loop
         fn inner_fn() -> ! {
             std::process::exit(0);
         }
@@ -92,7 +93,7 @@ fn has_indirect_break_2(stop_num: i32) {
 
 fn break_inner_but_not_outer_1(cond: bool) {
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         loop {
             if cond {
                 break;
@@ -103,7 +104,7 @@ fn break_inner_but_not_outer_1(cond: bool) {
 
 fn break_inner_but_not_outer_2(cond: bool) {
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         'inner: loop {
             loop {
                 if cond {
@@ -117,7 +118,7 @@ fn break_inner_but_not_outer_2(cond: bool) {
 fn break_outer_but_not_inner() {
     loop {
         loop {
-            //~^ ERROR: infinite loop detected
+            //~^ infinite_loop
             do_something();
         }
         break;
@@ -140,7 +141,7 @@ fn break_wrong_loop(cond: bool) {
     // 'inner has statement to break 'outer loop, but it was broken out of early by a labeled child loop
     'outer: loop {
         loop {
-            //~^ ERROR: infinite loop detected
+            //~^ infinite_loop
             'inner: loop {
                 loop {
                     loop {
@@ -180,7 +181,7 @@ enum Foo {
 fn match_like() {
     let opt: Option<u8> = Some(1);
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         match opt {
             Some(v) => {
                 println!("{v}");
@@ -221,12 +222,12 @@ fn match_like() {
     }
 
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         let _x = matches!(result, Ok(v) if v != 0).then_some(0);
     }
 
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         // This `return` does not return the function, so it doesn't count
         let _x = matches!(result, Ok(v) if v != 0).then(|| {
             if true {
@@ -331,7 +332,7 @@ fn exit_directly(cond: bool) {
 trait MyTrait {
     fn problematic_trait_method() {
         loop {
-            //~^ ERROR: infinite loop detected
+            //~^ infinite_loop
             do_something();
         }
     }
@@ -341,7 +342,7 @@ trait MyTrait {
 impl MyTrait for String {
     fn could_be_problematic() {
         loop {
-            //~^ ERROR: infinite loop detected
+            //~^ infinite_loop
             do_something();
         }
     }
@@ -350,7 +351,7 @@ impl MyTrait for String {
 fn inf_loop_in_closure() {
     let _loop_forever = || {
         loop {
-            //~^ ERROR: infinite loop detected
+            //~^ infinite_loop
             do_something();
         }
     };
@@ -364,6 +365,7 @@ fn inf_loop_in_closure() {
 
 fn inf_loop_in_res() -> Result<(), i32> {
     Ok(loop {
+        //~^ infinite_loop
         do_something()
     })
 }
@@ -406,15 +408,16 @@ fn continue_outer() {
 
     // This should lint as we continue the loop itself
     'infinite: loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         loop {
             continue 'infinite;
         }
     }
     // This should lint as we continue an inner loop
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         'inner: loop {
+            //~^ infinite_loop
             loop {
                 continue 'inner;
             }
@@ -423,7 +426,7 @@ fn continue_outer() {
 
     // This should lint as we continue the loop itself
     loop {
-        //~^ ERROR: infinite loop detected
+        //~^ infinite_loop
         continue;
     }
 }
diff --git a/src/tools/clippy/tests/ui/infinite_loops.stderr b/src/tools/clippy/tests/ui/infinite_loops.stderr
index 3b5705d5f21d..4d02636ef4ae 100644
--- a/src/tools/clippy/tests/ui/infinite_loops.stderr
+++ b/src/tools/clippy/tests/ui/infinite_loops.stderr
@@ -74,9 +74,11 @@ error: infinite loop detected
   --> tests/ui/infinite_loops.rs:51:5
    |
 LL | /     loop {
+LL | |
 LL | |         fn inner_fn() -> ! {
 LL | |             std::process::exit(0);
-...  |
+LL | |         }
+LL | |         do_something();
 LL | |     }
    | |_____^
    |
@@ -86,7 +88,7 @@ LL | fn no_break_never_ret_noise() -> ! {
    |                               ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:94:5
+  --> tests/ui/infinite_loops.rs:95:5
    |
 LL | /     loop {
 LL | |
@@ -102,7 +104,7 @@ LL | fn break_inner_but_not_outer_1(cond: bool) -> ! {
    |                                            ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:105:5
+  --> tests/ui/infinite_loops.rs:106:5
    |
 LL | /     loop {
 LL | |
@@ -118,7 +120,7 @@ LL | fn break_inner_but_not_outer_2(cond: bool) -> ! {
    |                                            ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:119:9
+  --> tests/ui/infinite_loops.rs:120:9
    |
 LL | /         loop {
 LL | |
@@ -132,7 +134,7 @@ LL | fn break_outer_but_not_inner() -> ! {
    |                                ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:142:9
+  --> tests/ui/infinite_loops.rs:143:9
    |
 LL | /         loop {
 LL | |
@@ -148,7 +150,7 @@ LL | fn break_wrong_loop(cond: bool) -> ! {
    |                                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:182:5
+  --> tests/ui/infinite_loops.rs:183:5
    |
 LL | /     loop {
 LL | |
@@ -164,7 +166,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:223:5
+  --> tests/ui/infinite_loops.rs:224:5
    |
 LL | /     loop {
 LL | |
@@ -178,7 +180,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:228:5
+  --> tests/ui/infinite_loops.rs:229:5
    |
 LL | /     loop {
 LL | |
@@ -195,7 +197,7 @@ LL | fn match_like() -> ! {
    |                 ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:333:9
+  --> tests/ui/infinite_loops.rs:334:9
    |
 LL | /         loop {
 LL | |
@@ -209,7 +211,7 @@ LL |     fn problematic_trait_method() -> ! {
    |                                   ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:343:9
+  --> tests/ui/infinite_loops.rs:344:9
    |
 LL | /         loop {
 LL | |
@@ -223,7 +225,7 @@ LL |     fn could_be_problematic() -> ! {
    |                               ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:352:9
+  --> tests/ui/infinite_loops.rs:353:9
    |
 LL | /         loop {
 LL | |
@@ -237,10 +239,11 @@ LL |     let _loop_forever = || -> ! {
    |                            ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:366:8
+  --> tests/ui/infinite_loops.rs:367:8
    |
 LL |       Ok(loop {
    |  ________^
+LL | |
 LL | |         do_something()
 LL | |     })
    | |_____^
@@ -248,7 +251,7 @@ LL | |     })
    = help: if this is not intended, try adding a `break` or `return` condition in the loop
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:408:5
+  --> tests/ui/infinite_loops.rs:410:5
    |
 LL | /     'infinite: loop {
 LL | |
@@ -264,12 +267,11 @@ LL | fn continue_outer() -> ! {
    |                     ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:415:5
+  --> tests/ui/infinite_loops.rs:417:5
    |
 LL | /     loop {
 LL | |
 LL | |         'inner: loop {
-LL | |             loop {
 ...  |
 LL | |     }
    | |_____^
@@ -280,9 +282,10 @@ LL | fn continue_outer() -> ! {
    |                     ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:417:9
+  --> tests/ui/infinite_loops.rs:419:9
    |
 LL | /         'inner: loop {
+LL | |
 LL | |             loop {
 LL | |                 continue 'inner;
 LL | |             }
@@ -295,7 +298,7 @@ LL | fn continue_outer() -> ! {
    |                     ++++
 
 error: infinite loop detected
-  --> tests/ui/infinite_loops.rs:425:5
+  --> tests/ui/infinite_loops.rs:428:5
    |
 LL | /     loop {
 LL | |
diff --git a/src/tools/clippy/tests/ui/inherent_to_string.rs b/src/tools/clippy/tests/ui/inherent_to_string.rs
index 7b938cdd758c..30977f2d93ac 100644
--- a/src/tools/clippy/tests/ui/inherent_to_string.rs
+++ b/src/tools/clippy/tests/ui/inherent_to_string.rs
@@ -20,7 +20,8 @@ struct J;
 impl A {
     // Should be detected; emit warning
     fn to_string(&self) -> String {
-        //~^ ERROR: implementation of inherent method `to_string(&self) -> String` for type `A
+        //~^ inherent_to_string
+
         "A.to_string()".to_string()
     }
 
@@ -45,7 +46,8 @@ impl B {
 impl C {
     // Should be detected and emit error as C also implements Display
     fn to_string(&self) -> String {
-        //~^ ERROR: type `C` implements inherent method `to_string(&self) -> String` which sha
+        //~^ inherent_to_string_shadow_display
+
         "C.to_string()".to_string()
     }
 }
diff --git a/src/tools/clippy/tests/ui/inherent_to_string.stderr b/src/tools/clippy/tests/ui/inherent_to_string.stderr
index eb22525a2491..f1d415a45755 100644
--- a/src/tools/clippy/tests/ui/inherent_to_string.stderr
+++ b/src/tools/clippy/tests/ui/inherent_to_string.stderr
@@ -3,6 +3,7 @@ error: implementation of inherent method `to_string(&self) -> String` for type `
    |
 LL | /     fn to_string(&self) -> String {
 LL | |
+LL | |
 LL | |         "A.to_string()".to_string()
 LL | |     }
    | |_____^
@@ -12,10 +13,11 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::inherent_to_string)]`
 
 error: type `C` implements inherent method `to_string(&self) -> String` which shadows the implementation of `Display`
-  --> tests/ui/inherent_to_string.rs:47:5
+  --> tests/ui/inherent_to_string.rs:48:5
    |
 LL | /     fn to_string(&self) -> String {
 LL | |
+LL | |
 LL | |         "C.to_string()".to_string()
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/init_numbered_fields.fixed b/src/tools/clippy/tests/ui/init_numbered_fields.fixed
index dca4e8da4d2f..b4c5fa83ce95 100644
--- a/src/tools/clippy/tests/ui/init_numbered_fields.fixed
+++ b/src/tools/clippy/tests/ui/init_numbered_fields.fixed
@@ -39,6 +39,7 @@ fn main() {
     struct TupleStructVec(Vec<usize>);
 
     let _ = TupleStructVec(vec![0, 1, 2, 3]);
+    //~^ init_numbered_fields
 
     {
         struct S(i32, i32);
diff --git a/src/tools/clippy/tests/ui/init_numbered_fields.rs b/src/tools/clippy/tests/ui/init_numbered_fields.rs
index 8cb34705b4f6..ae5dfe889575 100644
--- a/src/tools/clippy/tests/ui/init_numbered_fields.rs
+++ b/src/tools/clippy/tests/ui/init_numbered_fields.rs
@@ -15,6 +15,7 @@ fn main() {
 
     // This should lint
     let _ = TupleStruct {
+        //~^ init_numbered_fields
         0: 1u32,
         1: 42,
         2: 23u8,
@@ -22,6 +23,7 @@ fn main() {
 
     // This should also lint and order the fields correctly
     let _ = TupleStruct {
+        //~^ init_numbered_fields
         0: 1u32,
         2: 2u8,
         1: 3u32,
@@ -47,6 +49,7 @@ fn main() {
     struct TupleStructVec(Vec<usize>);
 
     let _ = TupleStructVec { 0: vec![0, 1, 2, 3] };
+    //~^ init_numbered_fields
 
     {
         struct S(i32, i32);
diff --git a/src/tools/clippy/tests/ui/init_numbered_fields.stderr b/src/tools/clippy/tests/ui/init_numbered_fields.stderr
index f176e0c2ff30..89828b7e2fce 100644
--- a/src/tools/clippy/tests/ui/init_numbered_fields.stderr
+++ b/src/tools/clippy/tests/ui/init_numbered_fields.stderr
@@ -3,6 +3,7 @@ error: used a field initializer for a tuple struct
    |
 LL |       let _ = TupleStruct {
    |  _____________^
+LL | |
 LL | |         0: 1u32,
 LL | |         1: 42,
 LL | |         2: 23u8,
@@ -13,10 +14,11 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::init_numbered_fields)]`
 
 error: used a field initializer for a tuple struct
-  --> tests/ui/init_numbered_fields.rs:24:13
+  --> tests/ui/init_numbered_fields.rs:25:13
    |
 LL |       let _ = TupleStruct {
    |  _____________^
+LL | |
 LL | |         0: 1u32,
 LL | |         2: 2u8,
 LL | |         1: 3u32,
@@ -24,7 +26,7 @@ LL | |     };
    | |_____^ help: use tuple initialization: `TupleStruct(1u32, 3u32, 2u8)`
 
 error: used a field initializer for a tuple struct
-  --> tests/ui/init_numbered_fields.rs:49:13
+  --> tests/ui/init_numbered_fields.rs:51:13
    |
 LL |     let _ = TupleStructVec { 0: vec![0, 1, 2, 3] };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use tuple initialization: `TupleStructVec(vec![0, 1, 2, 3])`
diff --git a/src/tools/clippy/tests/ui/inline_fn_without_body.fixed b/src/tools/clippy/tests/ui/inline_fn_without_body.fixed
index acd808ed49bb..3567209b41f7 100644
--- a/src/tools/clippy/tests/ui/inline_fn_without_body.fixed
+++ b/src/tools/clippy/tests/ui/inline_fn_without_body.fixed
@@ -2,10 +2,13 @@
 #![allow(clippy::inline_always)]
 
 trait Foo {
+    //~^ inline_fn_without_body
     fn default_inline();
 
+    //~^ inline_fn_without_body
     fn always_inline();
 
+    //~^ inline_fn_without_body
     fn never_inline();
 
     #[inline]
diff --git a/src/tools/clippy/tests/ui/inline_fn_without_body.rs b/src/tools/clippy/tests/ui/inline_fn_without_body.rs
index af81feaa374a..9ca90e637f15 100644
--- a/src/tools/clippy/tests/ui/inline_fn_without_body.rs
+++ b/src/tools/clippy/tests/ui/inline_fn_without_body.rs
@@ -3,12 +3,15 @@
 
 trait Foo {
     #[inline]
+    //~^ inline_fn_without_body
     fn default_inline();
 
     #[inline(always)]
+    //~^ inline_fn_without_body
     fn always_inline();
 
     #[inline(never)]
+    //~^ inline_fn_without_body
     fn never_inline();
 
     #[inline]
diff --git a/src/tools/clippy/tests/ui/inline_fn_without_body.stderr b/src/tools/clippy/tests/ui/inline_fn_without_body.stderr
index 89db710fabe7..61bc5505ea30 100644
--- a/src/tools/clippy/tests/ui/inline_fn_without_body.stderr
+++ b/src/tools/clippy/tests/ui/inline_fn_without_body.stderr
@@ -3,26 +3,26 @@ error: use of `#[inline]` on trait method `default_inline` which has no body
    |
 LL |       #[inline]
    |  _____-^^^^^^^^
-LL | |     fn default_inline();
+LL | |
    | |____- help: remove
    |
    = note: `-D clippy::inline-fn-without-body` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::inline_fn_without_body)]`
 
 error: use of `#[inline]` on trait method `always_inline` which has no body
-  --> tests/ui/inline_fn_without_body.rs:8:5
+  --> tests/ui/inline_fn_without_body.rs:9:5
    |
 LL |       #[inline(always)]
    |  _____-^^^^^^^^^^^^^^^^
-LL | |     fn always_inline();
+LL | |
    | |____- help: remove
 
 error: use of `#[inline]` on trait method `never_inline` which has no body
-  --> tests/ui/inline_fn_without_body.rs:11:5
+  --> tests/ui/inline_fn_without_body.rs:13:5
    |
 LL |       #[inline(never)]
    |  _____-^^^^^^^^^^^^^^^
-LL | |     fn never_inline();
+LL | |
    | |____- help: remove
 
 error: aborting due to 3 previous errors
diff --git a/src/tools/clippy/tests/ui/inspect_for_each.rs b/src/tools/clippy/tests/ui/inspect_for_each.rs
index 974690eaa8e4..8bfd9cec66dc 100644
--- a/src/tools/clippy/tests/ui/inspect_for_each.rs
+++ b/src/tools/clippy/tests/ui/inspect_for_each.rs
@@ -5,7 +5,8 @@ fn main() {
 
     let mut b: Vec<usize> = Vec::new();
     a.into_iter().inspect(|x| assert!(*x > 0)).for_each(|x| {
-        //~^ ERROR: called `inspect(..).for_each(..)` on an `Iterator`
+        //~^ inspect_for_each
+
         let y = do_some(x);
         let z = do_more(y);
         b.push(z);
diff --git a/src/tools/clippy/tests/ui/inspect_for_each.stderr b/src/tools/clippy/tests/ui/inspect_for_each.stderr
index 3c2dee15ebd5..6a715c9c4efc 100644
--- a/src/tools/clippy/tests/ui/inspect_for_each.stderr
+++ b/src/tools/clippy/tests/ui/inspect_for_each.stderr
@@ -4,6 +4,7 @@ error: called `inspect(..).for_each(..)` on an `Iterator`
 LL |       a.into_iter().inspect(|x| assert!(*x > 0)).for_each(|x| {
    |  ___________________^
 LL | |
+LL | |
 LL | |         let y = do_some(x);
 LL | |         let z = do_more(y);
 LL | |         b.push(z);
diff --git a/src/tools/clippy/tests/ui/int_plus_one.fixed b/src/tools/clippy/tests/ui/int_plus_one.fixed
index 77d9cd3f773a..a1aba6bf7f64 100644
--- a/src/tools/clippy/tests/ui/int_plus_one.fixed
+++ b/src/tools/clippy/tests/ui/int_plus_one.fixed
@@ -5,10 +5,14 @@ fn main() {
     let y = 0i32;
 
     let _ = x > y;
+    //~^ int_plus_one
     let _ = y < x;
+    //~^ int_plus_one
 
     let _ = x > y;
+    //~^ int_plus_one
     let _ = y < x;
+    //~^ int_plus_one
 
     let _ = x > y; // should be ok
     let _ = y < x; // should be ok
diff --git a/src/tools/clippy/tests/ui/int_plus_one.rs b/src/tools/clippy/tests/ui/int_plus_one.rs
index 57c87819dbfe..f804fc9047de 100644
--- a/src/tools/clippy/tests/ui/int_plus_one.rs
+++ b/src/tools/clippy/tests/ui/int_plus_one.rs
@@ -5,10 +5,14 @@ fn main() {
     let y = 0i32;
 
     let _ = x >= y + 1;
+    //~^ int_plus_one
     let _ = y + 1 <= x;
+    //~^ int_plus_one
 
     let _ = x - 1 >= y;
+    //~^ int_plus_one
     let _ = y <= x - 1;
+    //~^ int_plus_one
 
     let _ = x > y; // should be ok
     let _ = y < x; // should be ok
diff --git a/src/tools/clippy/tests/ui/int_plus_one.stderr b/src/tools/clippy/tests/ui/int_plus_one.stderr
index cedac14f350d..052706028141 100644
--- a/src/tools/clippy/tests/ui/int_plus_one.stderr
+++ b/src/tools/clippy/tests/ui/int_plus_one.stderr
@@ -8,19 +8,19 @@ LL |     let _ = x >= y + 1;
    = help: to override `-D warnings` add `#[allow(clippy::int_plus_one)]`
 
 error: unnecessary `>= y + 1` or `x - 1 >=`
-  --> tests/ui/int_plus_one.rs:8:13
+  --> tests/ui/int_plus_one.rs:9:13
    |
 LL |     let _ = y + 1 <= x;
    |             ^^^^^^^^^^ help: change it to: `y < x`
 
 error: unnecessary `>= y + 1` or `x - 1 >=`
-  --> tests/ui/int_plus_one.rs:10:13
+  --> tests/ui/int_plus_one.rs:12:13
    |
 LL |     let _ = x - 1 >= y;
    |             ^^^^^^^^^^ help: change it to: `x > y`
 
 error: unnecessary `>= y + 1` or `x - 1 >=`
-  --> tests/ui/int_plus_one.rs:11:13
+  --> tests/ui/int_plus_one.rs:14:13
    |
 LL |     let _ = y <= x - 1;
    |             ^^^^^^^^^^ help: change it to: `y < x`
diff --git a/src/tools/clippy/tests/ui/integer_division.rs b/src/tools/clippy/tests/ui/integer_division.rs
index 137548fecf4a..632fedc9e8fe 100644
--- a/src/tools/clippy/tests/ui/integer_division.rs
+++ b/src/tools/clippy/tests/ui/integer_division.rs
@@ -3,10 +3,13 @@
 fn main() {
     let two = 2;
     let n = 1 / 2;
-    //~^ ERROR: integer division
+    //~^ integer_division
+
     let o = 1 / two;
-    //~^ ERROR: integer division
+    //~^ integer_division
+
     let p = two / 4;
-    //~^ ERROR: integer division
+    //~^ integer_division
+
     let x = 1. / 2.0;
 }
diff --git a/src/tools/clippy/tests/ui/integer_division.stderr b/src/tools/clippy/tests/ui/integer_division.stderr
index 5f0d905a48b6..0fe2021a1a9c 100644
--- a/src/tools/clippy/tests/ui/integer_division.stderr
+++ b/src/tools/clippy/tests/ui/integer_division.stderr
@@ -9,7 +9,7 @@ LL |     let n = 1 / 2;
    = help: to override `-D warnings` add `#[allow(clippy::integer_division)]`
 
 error: integer division
-  --> tests/ui/integer_division.rs:7:13
+  --> tests/ui/integer_division.rs:8:13
    |
 LL |     let o = 1 / two;
    |             ^^^^^^^
@@ -17,7 +17,7 @@ LL |     let o = 1 / two;
    = help: division of integers may cause loss of precision. consider using floats
 
 error: integer division
-  --> tests/ui/integer_division.rs:9:13
+  --> tests/ui/integer_division.rs:11:13
    |
 LL |     let p = two / 4;
    |             ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/integer_division_remainder_used.rs b/src/tools/clippy/tests/ui/integer_division_remainder_used.rs
index 5d1b02095d18..4d3a7c5eaa15 100644
--- a/src/tools/clippy/tests/ui/integer_division_remainder_used.rs
+++ b/src/tools/clippy/tests/ui/integer_division_remainder_used.rs
@@ -8,6 +8,7 @@ impl std::ops::Div for CustomOps {
 
     fn div(self, rhs: Self) -> Self::Output {
         Self(self.0 / rhs.0)
+        //~^ integer_division_remainder_used
     }
 }
 impl std::ops::Rem for CustomOps {
@@ -15,6 +16,7 @@ impl std::ops::Rem for CustomOps {
 
     fn rem(self, rhs: Self) -> Self::Output {
         Self(self.0 % rhs.0)
+        //~^ integer_division_remainder_used
     }
 }
 
@@ -23,12 +25,19 @@ fn main() {
     let a = 10;
     let b = 5;
     let c = a / b;
+    //~^ integer_division_remainder_used
     let d = a % b;
+    //~^ integer_division_remainder_used
     let e = &a / b;
+    //~^ integer_division_remainder_used
     let f = a % &b;
+    //~^ integer_division_remainder_used
     let g = &a / &b;
+    //~^ integer_division_remainder_used
     let h = &10 % b;
+    //~^ integer_division_remainder_used
     let i = a / &4;
+    //~^ integer_division_remainder_used
 
     // should not trigger on custom Div and Rem
     let w = CustomOps(3);
diff --git a/src/tools/clippy/tests/ui/integer_division_remainder_used.stderr b/src/tools/clippy/tests/ui/integer_division_remainder_used.stderr
index 8adfda28893d..ea9f0e716c7d 100644
--- a/src/tools/clippy/tests/ui/integer_division_remainder_used.stderr
+++ b/src/tools/clippy/tests/ui/integer_division_remainder_used.stderr
@@ -8,49 +8,49 @@ LL |         Self(self.0 / rhs.0)
    = help: to override `-D warnings` add `#[allow(clippy::integer_division_remainder_used)]`
 
 error: use of % has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:17:14
+  --> tests/ui/integer_division_remainder_used.rs:18:14
    |
 LL |         Self(self.0 % rhs.0)
    |              ^^^^^^^^^^^^^^
 
 error: use of / has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:25:13
+  --> tests/ui/integer_division_remainder_used.rs:27:13
    |
 LL |     let c = a / b;
    |             ^^^^^
 
 error: use of % has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:26:13
+  --> tests/ui/integer_division_remainder_used.rs:29:13
    |
 LL |     let d = a % b;
    |             ^^^^^
 
 error: use of / has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:27:13
+  --> tests/ui/integer_division_remainder_used.rs:31:13
    |
 LL |     let e = &a / b;
    |             ^^^^^^
 
 error: use of % has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:28:13
+  --> tests/ui/integer_division_remainder_used.rs:33:13
    |
 LL |     let f = a % &b;
    |             ^^^^^^
 
 error: use of / has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:29:13
+  --> tests/ui/integer_division_remainder_used.rs:35:13
    |
 LL |     let g = &a / &b;
    |             ^^^^^^^
 
 error: use of % has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:30:13
+  --> tests/ui/integer_division_remainder_used.rs:37:13
    |
 LL |     let h = &10 % b;
    |             ^^^^^^^
 
 error: use of / has been disallowed in this context
-  --> tests/ui/integer_division_remainder_used.rs:31:13
+  --> tests/ui/integer_division_remainder_used.rs:39:13
    |
 LL |     let i = a / &4;
    |             ^^^^^^
diff --git a/src/tools/clippy/tests/ui/into_iter_on_ref.fixed b/src/tools/clippy/tests/ui/into_iter_on_ref.fixed
index 72b39c982bf7..7626569fd422 100644
--- a/src/tools/clippy/tests/ui/into_iter_on_ref.fixed
+++ b/src/tools/clippy/tests/ui/into_iter_on_ref.fixed
@@ -10,34 +10,60 @@ fn main() {
     for _ in &vec![X, X] {}
 
     let _ = vec![1, 2, 3].into_iter();
-    let _ = (&vec![1, 2, 3]).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::rc::Rc::from(&[X][..]).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::sync::Arc::from(&[X][..]).iter(); //~ ERROR: equivalent to `.iter()
+    let _ = (&vec![1, 2, 3]).iter();
+    //~^ into_iter_on_ref
+    let _ = std::rc::Rc::from(&[X][..]).iter();
+    //~^ into_iter_on_ref
+    let _ = std::sync::Arc::from(&[X][..]).iter();
+    //~^ into_iter_on_ref
 
-    let _ = (&&&&&&&[1, 2, 3]).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&&&&mut &&&[1, 2, 3]).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut &mut &mut [1, 2, 3]).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
+    let _ = (&&&&&&&[1, 2, 3]).iter();
+    //~^ into_iter_on_ref
+    let _ = (&&&&mut &&&[1, 2, 3]).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut &mut &mut [1, 2, 3]).iter_mut();
+    //~^ into_iter_on_ref
 
-    let _ = (&Some(4)).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut Some(5)).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&Ok::<_, i32>(6)).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut Err::<i32, _>(7)).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&Vec::<i32>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut Vec::<i32>::new()).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&BTreeMap::<i32, u64>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut BTreeMap::<i32, u64>::new()).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&VecDeque::<i32>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut VecDeque::<i32>::new()).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&LinkedList::<i32>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut LinkedList::<i32>::new()).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&HashMap::<i32, u64>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut HashMap::<i32, u64>::new()).iter_mut(); //~ ERROR: equivalent to `.iter_mut()
+    let _ = (&Some(4)).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut Some(5)).iter_mut();
+    //~^ into_iter_on_ref
+    let _ = (&Ok::<_, i32>(6)).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut Err::<i32, _>(7)).iter_mut();
+    //~^ into_iter_on_ref
+    let _ = (&Vec::<i32>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut Vec::<i32>::new()).iter_mut();
+    //~^ into_iter_on_ref
+    let _ = (&BTreeMap::<i32, u64>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut BTreeMap::<i32, u64>::new()).iter_mut();
+    //~^ into_iter_on_ref
+    let _ = (&VecDeque::<i32>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut VecDeque::<i32>::new()).iter_mut();
+    //~^ into_iter_on_ref
+    let _ = (&LinkedList::<i32>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut LinkedList::<i32>::new()).iter_mut();
+    //~^ into_iter_on_ref
+    let _ = (&HashMap::<i32, u64>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut HashMap::<i32, u64>::new()).iter_mut();
+    //~^ into_iter_on_ref
 
-    let _ = (&BTreeSet::<i32>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&BinaryHeap::<i32>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&HashSet::<i32>::new()).iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::path::Path::new("12/34").iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::path::PathBuf::from("12/34").iter(); //~ ERROR: equivalent to `.iter()
+    let _ = (&BTreeSet::<i32>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = (&BinaryHeap::<i32>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = (&HashSet::<i32>::new()).iter();
+    //~^ into_iter_on_ref
+    let _ = std::path::Path::new("12/34").iter();
+    //~^ into_iter_on_ref
+    let _ = std::path::PathBuf::from("12/34").iter();
+    //~^ into_iter_on_ref
 
-    let _ = (&[1, 2, 3]).iter().next(); //~ ERROR: equivalent to `.iter()
+    let _ = (&[1, 2, 3]).iter().next();
+    //~^ into_iter_on_ref
 }
diff --git a/src/tools/clippy/tests/ui/into_iter_on_ref.rs b/src/tools/clippy/tests/ui/into_iter_on_ref.rs
index 5ba224720d34..286a62c69ce5 100644
--- a/src/tools/clippy/tests/ui/into_iter_on_ref.rs
+++ b/src/tools/clippy/tests/ui/into_iter_on_ref.rs
@@ -10,34 +10,60 @@ fn main() {
     for _ in &vec![X, X] {}
 
     let _ = vec![1, 2, 3].into_iter();
-    let _ = (&vec![1, 2, 3]).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::rc::Rc::from(&[X][..]).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::sync::Arc::from(&[X][..]).into_iter(); //~ ERROR: equivalent to `.iter()
+    let _ = (&vec![1, 2, 3]).into_iter();
+    //~^ into_iter_on_ref
+    let _ = std::rc::Rc::from(&[X][..]).into_iter();
+    //~^ into_iter_on_ref
+    let _ = std::sync::Arc::from(&[X][..]).into_iter();
+    //~^ into_iter_on_ref
 
-    let _ = (&&&&&&&[1, 2, 3]).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&&&&mut &&&[1, 2, 3]).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut &mut &mut [1, 2, 3]).into_iter(); //~ ERROR: equivalent to `.iter_mut()
+    let _ = (&&&&&&&[1, 2, 3]).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&&&&mut &&&[1, 2, 3]).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut &mut &mut [1, 2, 3]).into_iter();
+    //~^ into_iter_on_ref
 
-    let _ = (&Some(4)).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut Some(5)).into_iter(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&Ok::<_, i32>(6)).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut Err::<i32, _>(7)).into_iter(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&Vec::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut Vec::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&BTreeMap::<i32, u64>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut BTreeMap::<i32, u64>::new()).into_iter(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&VecDeque::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut VecDeque::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&LinkedList::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut LinkedList::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter_mut()
-    let _ = (&HashMap::<i32, u64>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&mut HashMap::<i32, u64>::new()).into_iter(); //~ ERROR: equivalent to `.iter_mut()
+    let _ = (&Some(4)).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut Some(5)).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&Ok::<_, i32>(6)).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut Err::<i32, _>(7)).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&Vec::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut Vec::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&BTreeMap::<i32, u64>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut BTreeMap::<i32, u64>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&VecDeque::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut VecDeque::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&LinkedList::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut LinkedList::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&HashMap::<i32, u64>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&mut HashMap::<i32, u64>::new()).into_iter();
+    //~^ into_iter_on_ref
 
-    let _ = (&BTreeSet::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&BinaryHeap::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = (&HashSet::<i32>::new()).into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::path::Path::new("12/34").into_iter(); //~ ERROR: equivalent to `.iter()
-    let _ = std::path::PathBuf::from("12/34").into_iter(); //~ ERROR: equivalent to `.iter()
+    let _ = (&BTreeSet::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&BinaryHeap::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = (&HashSet::<i32>::new()).into_iter();
+    //~^ into_iter_on_ref
+    let _ = std::path::Path::new("12/34").into_iter();
+    //~^ into_iter_on_ref
+    let _ = std::path::PathBuf::from("12/34").into_iter();
+    //~^ into_iter_on_ref
 
-    let _ = (&[1, 2, 3]).into_iter().next(); //~ ERROR: equivalent to `.iter()
+    let _ = (&[1, 2, 3]).into_iter().next();
+    //~^ into_iter_on_ref
 }
diff --git a/src/tools/clippy/tests/ui/into_iter_on_ref.stderr b/src/tools/clippy/tests/ui/into_iter_on_ref.stderr
index 64d814074da4..57ff097a6ca2 100644
--- a/src/tools/clippy/tests/ui/into_iter_on_ref.stderr
+++ b/src/tools/clippy/tests/ui/into_iter_on_ref.stderr
@@ -8,151 +8,151 @@ LL |     let _ = (&vec![1, 2, 3]).into_iter();
    = help: to override `-D warnings` add `#[allow(clippy::into_iter_on_ref)]`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
-  --> tests/ui/into_iter_on_ref.rs:14:41
+  --> tests/ui/into_iter_on_ref.rs:15:41
    |
 LL |     let _ = std::rc::Rc::from(&[X][..]).into_iter();
    |                                         ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `slice`
-  --> tests/ui/into_iter_on_ref.rs:15:44
+  --> tests/ui/into_iter_on_ref.rs:17:44
    |
 LL |     let _ = std::sync::Arc::from(&[X][..]).into_iter();
    |                                            ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
-  --> tests/ui/into_iter_on_ref.rs:17:32
+  --> tests/ui/into_iter_on_ref.rs:20:32
    |
 LL |     let _ = (&&&&&&&[1, 2, 3]).into_iter();
    |                                ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
-  --> tests/ui/into_iter_on_ref.rs:18:36
+  --> tests/ui/into_iter_on_ref.rs:22:36
    |
 LL |     let _ = (&&&&mut &&&[1, 2, 3]).into_iter();
    |                                    ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `array`
-  --> tests/ui/into_iter_on_ref.rs:19:40
+  --> tests/ui/into_iter_on_ref.rs:24:40
    |
 LL |     let _ = (&mut &mut &mut [1, 2, 3]).into_iter();
    |                                        ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Option`
-  --> tests/ui/into_iter_on_ref.rs:21:24
+  --> tests/ui/into_iter_on_ref.rs:27:24
    |
 LL |     let _ = (&Some(4)).into_iter();
    |                        ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Option`
-  --> tests/ui/into_iter_on_ref.rs:22:28
+  --> tests/ui/into_iter_on_ref.rs:29:28
    |
 LL |     let _ = (&mut Some(5)).into_iter();
    |                            ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Result`
-  --> tests/ui/into_iter_on_ref.rs:23:32
+  --> tests/ui/into_iter_on_ref.rs:31:32
    |
 LL |     let _ = (&Ok::<_, i32>(6)).into_iter();
    |                                ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Result`
-  --> tests/ui/into_iter_on_ref.rs:24:37
+  --> tests/ui/into_iter_on_ref.rs:33:37
    |
 LL |     let _ = (&mut Err::<i32, _>(7)).into_iter();
    |                                     ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Vec`
-  --> tests/ui/into_iter_on_ref.rs:25:34
+  --> tests/ui/into_iter_on_ref.rs:35:34
    |
 LL |     let _ = (&Vec::<i32>::new()).into_iter();
    |                                  ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `Vec`
-  --> tests/ui/into_iter_on_ref.rs:26:38
+  --> tests/ui/into_iter_on_ref.rs:37:38
    |
 LL |     let _ = (&mut Vec::<i32>::new()).into_iter();
    |                                      ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeMap`
-  --> tests/ui/into_iter_on_ref.rs:27:44
+  --> tests/ui/into_iter_on_ref.rs:39:44
    |
 LL |     let _ = (&BTreeMap::<i32, u64>::new()).into_iter();
    |                                            ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `BTreeMap`
-  --> tests/ui/into_iter_on_ref.rs:28:48
+  --> tests/ui/into_iter_on_ref.rs:41:48
    |
 LL |     let _ = (&mut BTreeMap::<i32, u64>::new()).into_iter();
    |                                                ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `VecDeque`
-  --> tests/ui/into_iter_on_ref.rs:29:39
+  --> tests/ui/into_iter_on_ref.rs:43:39
    |
 LL |     let _ = (&VecDeque::<i32>::new()).into_iter();
    |                                       ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `VecDeque`
-  --> tests/ui/into_iter_on_ref.rs:30:43
+  --> tests/ui/into_iter_on_ref.rs:45:43
    |
 LL |     let _ = (&mut VecDeque::<i32>::new()).into_iter();
    |                                           ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `LinkedList`
-  --> tests/ui/into_iter_on_ref.rs:31:41
+  --> tests/ui/into_iter_on_ref.rs:47:41
    |
 LL |     let _ = (&LinkedList::<i32>::new()).into_iter();
    |                                         ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `LinkedList`
-  --> tests/ui/into_iter_on_ref.rs:32:45
+  --> tests/ui/into_iter_on_ref.rs:49:45
    |
 LL |     let _ = (&mut LinkedList::<i32>::new()).into_iter();
    |                                             ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashMap`
-  --> tests/ui/into_iter_on_ref.rs:33:43
+  --> tests/ui/into_iter_on_ref.rs:51:43
    |
 LL |     let _ = (&HashMap::<i32, u64>::new()).into_iter();
    |                                           ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter_mut()` and will not consume the `HashMap`
-  --> tests/ui/into_iter_on_ref.rs:34:47
+  --> tests/ui/into_iter_on_ref.rs:53:47
    |
 LL |     let _ = (&mut HashMap::<i32, u64>::new()).into_iter();
    |                                               ^^^^^^^^^ help: call directly: `iter_mut`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BTreeSet`
-  --> tests/ui/into_iter_on_ref.rs:36:39
+  --> tests/ui/into_iter_on_ref.rs:56:39
    |
 LL |     let _ = (&BTreeSet::<i32>::new()).into_iter();
    |                                       ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `BinaryHeap`
-  --> tests/ui/into_iter_on_ref.rs:37:41
+  --> tests/ui/into_iter_on_ref.rs:58:41
    |
 LL |     let _ = (&BinaryHeap::<i32>::new()).into_iter();
    |                                         ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `HashSet`
-  --> tests/ui/into_iter_on_ref.rs:38:38
+  --> tests/ui/into_iter_on_ref.rs:60:38
    |
 LL |     let _ = (&HashSet::<i32>::new()).into_iter();
    |                                      ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `Path`
-  --> tests/ui/into_iter_on_ref.rs:39:43
+  --> tests/ui/into_iter_on_ref.rs:62:43
    |
 LL |     let _ = std::path::Path::new("12/34").into_iter();
    |                                           ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `PathBuf`
-  --> tests/ui/into_iter_on_ref.rs:40:47
+  --> tests/ui/into_iter_on_ref.rs:64:47
    |
 LL |     let _ = std::path::PathBuf::from("12/34").into_iter();
    |                                               ^^^^^^^^^ help: call directly: `iter`
 
 error: this `.into_iter()` call is equivalent to `.iter()` and will not consume the `array`
-  --> tests/ui/into_iter_on_ref.rs:42:26
+  --> tests/ui/into_iter_on_ref.rs:67:26
    |
 LL |     let _ = (&[1, 2, 3]).into_iter().next();
    |                          ^^^^^^^^^ help: call directly: `iter`
diff --git a/src/tools/clippy/tests/ui/into_iter_without_iter.rs b/src/tools/clippy/tests/ui/into_iter_without_iter.rs
index 109259d6975c..45e34b3930ad 100644
--- a/src/tools/clippy/tests/ui/into_iter_without_iter.rs
+++ b/src/tools/clippy/tests/ui/into_iter_without_iter.rs
@@ -7,7 +7,7 @@ use std::iter::IntoIterator;
 
 pub struct S1;
 impl<'a> IntoIterator for &'a S1 {
-    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
+    //~^ into_iter_without_iter
     type IntoIter = std::slice::Iter<'a, u8>;
     type Item = &'a u8;
     fn into_iter(self) -> Self::IntoIter {
@@ -15,7 +15,7 @@ impl<'a> IntoIterator for &'a S1 {
     }
 }
 impl<'a> IntoIterator for &'a mut S1 {
-    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+    //~^ into_iter_without_iter
     type IntoIter = std::slice::IterMut<'a, u8>;
     type Item = &'a mut u8;
     fn into_iter(self) -> Self::IntoIter {
@@ -25,7 +25,7 @@ impl<'a> IntoIterator for &'a mut S1 {
 
 pub struct S2<T>(T);
 impl<'a, T> IntoIterator for &'a S2<T> {
-    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter` method
+    //~^ into_iter_without_iter
     type IntoIter = std::slice::Iter<'a, T>;
     type Item = &'a T;
     fn into_iter(self) -> Self::IntoIter {
@@ -33,7 +33,7 @@ impl<'a, T> IntoIterator for &'a S2<T> {
     }
 }
 impl<'a, T> IntoIterator for &'a mut S2<T> {
-    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+    //~^ into_iter_without_iter
     type IntoIter = std::slice::IterMut<'a, T>;
     type Item = &'a mut T;
     fn into_iter(self) -> Self::IntoIter {
@@ -84,7 +84,7 @@ impl<'a, T> IntoIterator for &S4<'a, T> {
 }
 
 impl<'a, T> IntoIterator for &mut S4<'a, T> {
-    //~^ ERROR: `IntoIterator` implemented for a reference type without an `iter_mut` method
+    //~^ into_iter_without_iter
     type IntoIter = std::slice::IterMut<'a, T>;
     type Item = &'a mut T;
     fn into_iter(self) -> Self::IntoIter {
@@ -118,6 +118,7 @@ pub struct Issue12037;
 macro_rules! generate_impl {
     () => {
         impl<'a> IntoIterator for &'a Issue12037 {
+            //~^ into_iter_without_iter
             type IntoIter = std::slice::Iter<'a, u8>;
             type Item = &'a u8;
             fn into_iter(self) -> Self::IntoIter {
diff --git a/src/tools/clippy/tests/ui/into_iter_without_iter.stderr b/src/tools/clippy/tests/ui/into_iter_without_iter.stderr
index cde1b60c2abc..a033ff645f49 100644
--- a/src/tools/clippy/tests/ui/into_iter_without_iter.stderr
+++ b/src/tools/clippy/tests/ui/into_iter_without_iter.stderr
@@ -109,9 +109,9 @@ error: `IntoIterator` implemented for a reference type without an `iter` method
   --> tests/ui/into_iter_without_iter.rs:120:9
    |
 LL | /         impl<'a> IntoIterator for &'a Issue12037 {
+LL | |
 LL | |             type IntoIter = std::slice::Iter<'a, u8>;
 LL | |             type Item = &'a u8;
-LL | |             fn into_iter(self) -> Self::IntoIter {
 ...  |
 LL | |         }
    | |_________^
diff --git a/src/tools/clippy/tests/ui/invalid_null_ptr_usage.fixed b/src/tools/clippy/tests/ui/invalid_null_ptr_usage.fixed
index ba225102c984..ce78e89ee829 100644
--- a/src/tools/clippy/tests/ui/invalid_null_ptr_usage.fixed
+++ b/src/tools/clippy/tests/ui/invalid_null_ptr_usage.fixed
@@ -1,44 +1,66 @@
 fn main() {
     unsafe {
         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         let _slice: &[usize] = std::slice::from_raw_parts_mut(std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::copy::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         std::ptr::copy::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::copy_nonoverlapping::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         std::ptr::copy_nonoverlapping::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         struct A; // zero sized struct
         assert_eq!(std::mem::size_of::<A>(), 0);
 
         let _a: A = std::ptr::read(std::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
         let _a: A = std::ptr::read(std::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = std::ptr::read_unaligned(std::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
         let _a: A = std::ptr::read_unaligned(std::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = std::ptr::read_volatile(std::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
         let _a: A = std::ptr::read_volatile(std::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = std::ptr::replace(std::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
         let _slice: *const [usize] = std::ptr::slice_from_raw_parts(std::ptr::null_mut(), 0); // shouldn't lint
         let _slice: *const [usize] = std::ptr::slice_from_raw_parts_mut(std::ptr::null_mut(), 0);
 
         std::ptr::swap::<A>(std::ptr::NonNull::dangling().as_ptr(), &mut A);
+        //~^ invalid_null_ptr_usage
         std::ptr::swap::<A>(&mut A, std::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         std::ptr::swap_nonoverlapping::<A>(std::ptr::NonNull::dangling().as_ptr(), &mut A, 0);
+        //~^ invalid_null_ptr_usage
         std::ptr::swap_nonoverlapping::<A>(&mut A, std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write(std::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write_unaligned(std::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write_volatile(std::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write_bytes::<usize>(std::ptr::NonNull::dangling().as_ptr(), 42, 0);
+        //~^ invalid_null_ptr_usage
     }
 }
diff --git a/src/tools/clippy/tests/ui/invalid_null_ptr_usage.rs b/src/tools/clippy/tests/ui/invalid_null_ptr_usage.rs
index 480b6642a3e3..361865fbd960 100644
--- a/src/tools/clippy/tests/ui/invalid_null_ptr_usage.rs
+++ b/src/tools/clippy/tests/ui/invalid_null_ptr_usage.rs
@@ -1,44 +1,66 @@
 fn main() {
     unsafe {
         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null(), 0);
+        //~^ invalid_null_ptr_usage
         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         let _slice: &[usize] = std::slice::from_raw_parts_mut(std::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::copy::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         std::ptr::copy::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::copy_nonoverlapping::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         std::ptr::copy_nonoverlapping::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         struct A; // zero sized struct
         assert_eq!(std::mem::size_of::<A>(), 0);
 
         let _a: A = std::ptr::read(std::ptr::null());
+        //~^ invalid_null_ptr_usage
         let _a: A = std::ptr::read(std::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = std::ptr::read_unaligned(std::ptr::null());
+        //~^ invalid_null_ptr_usage
         let _a: A = std::ptr::read_unaligned(std::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = std::ptr::read_volatile(std::ptr::null());
+        //~^ invalid_null_ptr_usage
         let _a: A = std::ptr::read_volatile(std::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = std::ptr::replace(std::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
         let _slice: *const [usize] = std::ptr::slice_from_raw_parts(std::ptr::null_mut(), 0); // shouldn't lint
         let _slice: *const [usize] = std::ptr::slice_from_raw_parts_mut(std::ptr::null_mut(), 0);
 
         std::ptr::swap::<A>(std::ptr::null_mut(), &mut A);
+        //~^ invalid_null_ptr_usage
         std::ptr::swap::<A>(&mut A, std::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         std::ptr::swap_nonoverlapping::<A>(std::ptr::null_mut(), &mut A, 0);
+        //~^ invalid_null_ptr_usage
         std::ptr::swap_nonoverlapping::<A>(&mut A, std::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write(std::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write_unaligned(std::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write_volatile(std::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
 
         std::ptr::write_bytes::<usize>(std::ptr::null_mut(), 42, 0);
+        //~^ invalid_null_ptr_usage
     }
 }
diff --git a/src/tools/clippy/tests/ui/invalid_null_ptr_usage.stderr b/src/tools/clippy/tests/ui/invalid_null_ptr_usage.stderr
index 613a2cc36885..3f9d15b90401 100644
--- a/src/tools/clippy/tests/ui/invalid_null_ptr_usage.stderr
+++ b/src/tools/clippy/tests/ui/invalid_null_ptr_usage.stderr
@@ -7,127 +7,127 @@ LL |         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null(),
    = note: `#[deny(clippy::invalid_null_ptr_usage)]` on by default
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:4:59
+  --> tests/ui/invalid_null_ptr_usage.rs:5:59
    |
 LL |         let _slice: &[usize] = std::slice::from_raw_parts(std::ptr::null_mut(), 0);
    |                                                           ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:6:63
+  --> tests/ui/invalid_null_ptr_usage.rs:8:63
    |
 LL |         let _slice: &[usize] = std::slice::from_raw_parts_mut(std::ptr::null_mut(), 0);
    |                                                               ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:8:33
+  --> tests/ui/invalid_null_ptr_usage.rs:11:33
    |
 LL |         std::ptr::copy::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
    |                                 ^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:9:73
+  --> tests/ui/invalid_null_ptr_usage.rs:13:73
    |
 LL |         std::ptr::copy::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
    |                                                                         ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:11:48
+  --> tests/ui/invalid_null_ptr_usage.rs:16:48
    |
 LL |         std::ptr::copy_nonoverlapping::<usize>(std::ptr::null(), std::ptr::NonNull::dangling().as_ptr(), 0);
    |                                                ^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:12:88
+  --> tests/ui/invalid_null_ptr_usage.rs:18:88
    |
 LL |         std::ptr::copy_nonoverlapping::<usize>(std::ptr::NonNull::dangling().as_ptr(), std::ptr::null_mut(), 0);
    |                                                                                        ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:17:36
+  --> tests/ui/invalid_null_ptr_usage.rs:24:36
    |
 LL |         let _a: A = std::ptr::read(std::ptr::null());
    |                                    ^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:18:36
+  --> tests/ui/invalid_null_ptr_usage.rs:26:36
    |
 LL |         let _a: A = std::ptr::read(std::ptr::null_mut());
    |                                    ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:20:46
+  --> tests/ui/invalid_null_ptr_usage.rs:29:46
    |
 LL |         let _a: A = std::ptr::read_unaligned(std::ptr::null());
    |                                              ^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:21:46
+  --> tests/ui/invalid_null_ptr_usage.rs:31:46
    |
 LL |         let _a: A = std::ptr::read_unaligned(std::ptr::null_mut());
    |                                              ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:23:45
+  --> tests/ui/invalid_null_ptr_usage.rs:34:45
    |
 LL |         let _a: A = std::ptr::read_volatile(std::ptr::null());
    |                                             ^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:24:45
+  --> tests/ui/invalid_null_ptr_usage.rs:36:45
    |
 LL |         let _a: A = std::ptr::read_volatile(std::ptr::null_mut());
    |                                             ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:26:39
+  --> tests/ui/invalid_null_ptr_usage.rs:39:39
    |
 LL |         let _a: A = std::ptr::replace(std::ptr::null_mut(), A);
    |                                       ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:30:29
+  --> tests/ui/invalid_null_ptr_usage.rs:44:29
    |
 LL |         std::ptr::swap::<A>(std::ptr::null_mut(), &mut A);
    |                             ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:31:37
+  --> tests/ui/invalid_null_ptr_usage.rs:46:37
    |
 LL |         std::ptr::swap::<A>(&mut A, std::ptr::null_mut());
    |                                     ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:33:44
+  --> tests/ui/invalid_null_ptr_usage.rs:49:44
    |
 LL |         std::ptr::swap_nonoverlapping::<A>(std::ptr::null_mut(), &mut A, 0);
    |                                            ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:34:52
+  --> tests/ui/invalid_null_ptr_usage.rs:51:52
    |
 LL |         std::ptr::swap_nonoverlapping::<A>(&mut A, std::ptr::null_mut(), 0);
    |                                                    ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:36:25
+  --> tests/ui/invalid_null_ptr_usage.rs:54:25
    |
 LL |         std::ptr::write(std::ptr::null_mut(), A);
    |                         ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:38:35
+  --> tests/ui/invalid_null_ptr_usage.rs:57:35
    |
 LL |         std::ptr::write_unaligned(std::ptr::null_mut(), A);
    |                                   ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:40:34
+  --> tests/ui/invalid_null_ptr_usage.rs:60:34
    |
 LL |         std::ptr::write_volatile(std::ptr::null_mut(), A);
    |                                  ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage.rs:42:40
+  --> tests/ui/invalid_null_ptr_usage.rs:63:40
    |
 LL |         std::ptr::write_bytes::<usize>(std::ptr::null_mut(), 42, 0);
    |                                        ^^^^^^^^^^^^^^^^^^^^ help: change this to: `std::ptr::NonNull::dangling().as_ptr()`
diff --git a/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.fixed b/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.fixed
index 2bbfe7274242..df7ab166187d 100644
--- a/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.fixed
+++ b/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.fixed
@@ -14,44 +14,66 @@ fn panic(info: &PanicInfo) -> ! {
 fn main() {
     unsafe {
         let _slice: &[usize] = core::slice::from_raw_parts(core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         let _slice: &[usize] = core::slice::from_raw_parts(core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         let _slice: &[usize] = core::slice::from_raw_parts_mut(core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::copy::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         core::ptr::copy::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::copy_nonoverlapping::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         core::ptr::copy_nonoverlapping::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         struct A; // zero sized struct
         assert_eq!(core::mem::size_of::<A>(), 0);
 
         let _a: A = core::ptr::read(core::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
         let _a: A = core::ptr::read(core::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = core::ptr::read_unaligned(core::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
         let _a: A = core::ptr::read_unaligned(core::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = core::ptr::read_volatile(core::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
         let _a: A = core::ptr::read_volatile(core::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = core::ptr::replace(core::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
         let _slice: *const [usize] = core::ptr::slice_from_raw_parts(core::ptr::null_mut(), 0); // shouldn't lint
         let _slice: *const [usize] = core::ptr::slice_from_raw_parts_mut(core::ptr::null_mut(), 0);
 
         core::ptr::swap::<A>(core::ptr::NonNull::dangling().as_ptr(), &mut A);
+        //~^ invalid_null_ptr_usage
         core::ptr::swap::<A>(&mut A, core::ptr::NonNull::dangling().as_ptr());
+        //~^ invalid_null_ptr_usage
 
         core::ptr::swap_nonoverlapping::<A>(core::ptr::NonNull::dangling().as_ptr(), &mut A, 0);
+        //~^ invalid_null_ptr_usage
         core::ptr::swap_nonoverlapping::<A>(&mut A, core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write(core::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write_unaligned(core::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write_volatile(core::ptr::NonNull::dangling().as_ptr(), A);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write_bytes::<usize>(core::ptr::NonNull::dangling().as_ptr(), 42, 0);
+        //~^ invalid_null_ptr_usage
     }
 }
diff --git a/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.rs b/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.rs
index cbce44f7c0d9..38ddfff05535 100644
--- a/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.rs
+++ b/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.rs
@@ -14,44 +14,66 @@ fn panic(info: &PanicInfo) -> ! {
 fn main() {
     unsafe {
         let _slice: &[usize] = core::slice::from_raw_parts(core::ptr::null(), 0);
+        //~^ invalid_null_ptr_usage
         let _slice: &[usize] = core::slice::from_raw_parts(core::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         let _slice: &[usize] = core::slice::from_raw_parts_mut(core::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::copy::<usize>(core::ptr::null(), core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         core::ptr::copy::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::copy_nonoverlapping::<usize>(core::ptr::null(), core::ptr::NonNull::dangling().as_ptr(), 0);
+        //~^ invalid_null_ptr_usage
         core::ptr::copy_nonoverlapping::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         struct A; // zero sized struct
         assert_eq!(core::mem::size_of::<A>(), 0);
 
         let _a: A = core::ptr::read(core::ptr::null());
+        //~^ invalid_null_ptr_usage
         let _a: A = core::ptr::read(core::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = core::ptr::read_unaligned(core::ptr::null());
+        //~^ invalid_null_ptr_usage
         let _a: A = core::ptr::read_unaligned(core::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = core::ptr::read_volatile(core::ptr::null());
+        //~^ invalid_null_ptr_usage
         let _a: A = core::ptr::read_volatile(core::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         let _a: A = core::ptr::replace(core::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
         let _slice: *const [usize] = core::ptr::slice_from_raw_parts(core::ptr::null_mut(), 0); // shouldn't lint
         let _slice: *const [usize] = core::ptr::slice_from_raw_parts_mut(core::ptr::null_mut(), 0);
 
         core::ptr::swap::<A>(core::ptr::null_mut(), &mut A);
+        //~^ invalid_null_ptr_usage
         core::ptr::swap::<A>(&mut A, core::ptr::null_mut());
+        //~^ invalid_null_ptr_usage
 
         core::ptr::swap_nonoverlapping::<A>(core::ptr::null_mut(), &mut A, 0);
+        //~^ invalid_null_ptr_usage
         core::ptr::swap_nonoverlapping::<A>(&mut A, core::ptr::null_mut(), 0);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write(core::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write_unaligned(core::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write_volatile(core::ptr::null_mut(), A);
+        //~^ invalid_null_ptr_usage
 
         core::ptr::write_bytes::<usize>(core::ptr::null_mut(), 42, 0);
+        //~^ invalid_null_ptr_usage
     }
 }
diff --git a/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.stderr b/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.stderr
index df0d40e9e072..b5dd21ce6248 100644
--- a/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.stderr
+++ b/src/tools/clippy/tests/ui/invalid_null_ptr_usage_no_std.stderr
@@ -7,127 +7,127 @@ LL |         let _slice: &[usize] = core::slice::from_raw_parts(core::ptr::null(
    = note: `#[deny(clippy::invalid_null_ptr_usage)]` on by default
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:17:60
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:18:60
    |
 LL |         let _slice: &[usize] = core::slice::from_raw_parts(core::ptr::null_mut(), 0);
    |                                                            ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:19:64
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:21:64
    |
 LL |         let _slice: &[usize] = core::slice::from_raw_parts_mut(core::ptr::null_mut(), 0);
    |                                                                ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:21:34
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:24:34
    |
 LL |         core::ptr::copy::<usize>(core::ptr::null(), core::ptr::NonNull::dangling().as_ptr(), 0);
    |                                  ^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:22:75
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:26:75
    |
 LL |         core::ptr::copy::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::null_mut(), 0);
    |                                                                           ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:24:49
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:29:49
    |
 LL |         core::ptr::copy_nonoverlapping::<usize>(core::ptr::null(), core::ptr::NonNull::dangling().as_ptr(), 0);
    |                                                 ^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:25:90
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:31:90
    |
 LL |         core::ptr::copy_nonoverlapping::<usize>(core::ptr::NonNull::dangling().as_ptr(), core::ptr::null_mut(), 0);
    |                                                                                          ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:30:37
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:37:37
    |
 LL |         let _a: A = core::ptr::read(core::ptr::null());
    |                                     ^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:31:37
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:39:37
    |
 LL |         let _a: A = core::ptr::read(core::ptr::null_mut());
    |                                     ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:33:47
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:42:47
    |
 LL |         let _a: A = core::ptr::read_unaligned(core::ptr::null());
    |                                               ^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:34:47
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:44:47
    |
 LL |         let _a: A = core::ptr::read_unaligned(core::ptr::null_mut());
    |                                               ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:36:46
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:47:46
    |
 LL |         let _a: A = core::ptr::read_volatile(core::ptr::null());
    |                                              ^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:37:46
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:49:46
    |
 LL |         let _a: A = core::ptr::read_volatile(core::ptr::null_mut());
    |                                              ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:39:40
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:52:40
    |
 LL |         let _a: A = core::ptr::replace(core::ptr::null_mut(), A);
    |                                        ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:43:30
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:57:30
    |
 LL |         core::ptr::swap::<A>(core::ptr::null_mut(), &mut A);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:44:38
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:59:38
    |
 LL |         core::ptr::swap::<A>(&mut A, core::ptr::null_mut());
    |                                      ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:46:45
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:62:45
    |
 LL |         core::ptr::swap_nonoverlapping::<A>(core::ptr::null_mut(), &mut A, 0);
    |                                             ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:47:53
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:64:53
    |
 LL |         core::ptr::swap_nonoverlapping::<A>(&mut A, core::ptr::null_mut(), 0);
    |                                                     ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:49:26
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:67:26
    |
 LL |         core::ptr::write(core::ptr::null_mut(), A);
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:51:36
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:70:36
    |
 LL |         core::ptr::write_unaligned(core::ptr::null_mut(), A);
    |                                    ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:53:35
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:73:35
    |
 LL |         core::ptr::write_volatile(core::ptr::null_mut(), A);
    |                                   ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
 
 error: pointer must be non-null
-  --> tests/ui/invalid_null_ptr_usage_no_std.rs:55:41
+  --> tests/ui/invalid_null_ptr_usage_no_std.rs:76:41
    |
 LL |         core::ptr::write_bytes::<usize>(core::ptr::null_mut(), 42, 0);
    |                                         ^^^^^^^^^^^^^^^^^^^^^ help: change this to: `core::ptr::NonNull::dangling().as_ptr()`
diff --git a/src/tools/clippy/tests/ui/invalid_upcast_comparisons.rs b/src/tools/clippy/tests/ui/invalid_upcast_comparisons.rs
index a9db15f20973..4f3194869f43 100644
--- a/src/tools/clippy/tests/ui/invalid_upcast_comparisons.rs
+++ b/src/tools/clippy/tests/ui/invalid_upcast_comparisons.rs
@@ -19,61 +19,81 @@ fn main() {
 
     // always false, since no u8 can be > 300
     (u8 as u32) > 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
-    //~| NOTE: `-D clippy::invalid-upcast-comparisons` implied by `-D warnings`
+    //~^ invalid_upcast_comparisons
+
     (u8 as i32) > 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     (u8 as u32) == 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     (u8 as i32) == 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 < (u8 as u32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 < (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 == (u8 as u32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 == (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     // inverted of the above
     (u8 as u32) <= 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     (u8 as i32) <= 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     (u8 as u32) != 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     (u8 as i32) != 300;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 >= (u8 as u32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 >= (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 != (u8 as u32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     300 != (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
 
     // always false, since u8 -> i32 doesn't wrap
     (u8 as i32) < 0;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     -5 != (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     // inverted of the above
     (u8 as i32) >= 0;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     -5 == (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
 
     // always false, since no u8 can be 1337
     1337 == (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     1337 == (u8 as u32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     // inverted of the above
     1337 != (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     1337 != (u8 as u32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
 
     // Those are Ok:
     (u8 as u32) > 20;
@@ -88,9 +108,11 @@ fn main() {
     (u8 as i8) == -1;
     (u8 as i8) != -1;
     (u8 as i32) > -1;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     (u8 as i32) < -1;
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
+
     (u32 as i32) < -5;
     (u32 as i32) < 10;
 
@@ -107,7 +129,7 @@ fn main() {
 
     -5 > (u32 as i32);
     -5 >= (u8 as i32);
-    //~^ ERROR: because of the numeric bounds on `u8` prior to casting, this expression is
+    //~^ invalid_upcast_comparisons
 
     -5 == (u32 as i32);
 }
diff --git a/src/tools/clippy/tests/ui/invalid_upcast_comparisons.stderr b/src/tools/clippy/tests/ui/invalid_upcast_comparisons.stderr
index b1fbe2951577..ef36f18eabc9 100644
--- a/src/tools/clippy/tests/ui/invalid_upcast_comparisons.stderr
+++ b/src/tools/clippy/tests/ui/invalid_upcast_comparisons.stderr
@@ -14,151 +14,151 @@ LL |     (u8 as i32) > 300;
    |     ^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:26:5
+  --> tests/ui/invalid_upcast_comparisons.rs:27:5
    |
 LL |     (u8 as u32) == 300;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:28:5
+  --> tests/ui/invalid_upcast_comparisons.rs:30:5
    |
 LL |     (u8 as i32) == 300;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:30:5
+  --> tests/ui/invalid_upcast_comparisons.rs:33:5
    |
 LL |     300 < (u8 as u32);
    |     ^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:32:5
+  --> tests/ui/invalid_upcast_comparisons.rs:36:5
    |
 LL |     300 < (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:34:5
+  --> tests/ui/invalid_upcast_comparisons.rs:39:5
    |
 LL |     300 == (u8 as u32);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:36:5
+  --> tests/ui/invalid_upcast_comparisons.rs:42:5
    |
 LL |     300 == (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:39:5
+  --> tests/ui/invalid_upcast_comparisons.rs:46:5
    |
 LL |     (u8 as u32) <= 300;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:41:5
+  --> tests/ui/invalid_upcast_comparisons.rs:49:5
    |
 LL |     (u8 as i32) <= 300;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:43:5
+  --> tests/ui/invalid_upcast_comparisons.rs:52:5
    |
 LL |     (u8 as u32) != 300;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:45:5
+  --> tests/ui/invalid_upcast_comparisons.rs:55:5
    |
 LL |     (u8 as i32) != 300;
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:47:5
+  --> tests/ui/invalid_upcast_comparisons.rs:58:5
    |
 LL |     300 >= (u8 as u32);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:49:5
+  --> tests/ui/invalid_upcast_comparisons.rs:61:5
    |
 LL |     300 >= (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:51:5
+  --> tests/ui/invalid_upcast_comparisons.rs:64:5
    |
 LL |     300 != (u8 as u32);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:53:5
+  --> tests/ui/invalid_upcast_comparisons.rs:67:5
    |
 LL |     300 != (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:57:5
+  --> tests/ui/invalid_upcast_comparisons.rs:71:5
    |
 LL |     (u8 as i32) < 0;
    |     ^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:59:5
+  --> tests/ui/invalid_upcast_comparisons.rs:74:5
    |
 LL |     -5 != (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:62:5
+  --> tests/ui/invalid_upcast_comparisons.rs:78:5
    |
 LL |     (u8 as i32) >= 0;
    |     ^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:64:5
+  --> tests/ui/invalid_upcast_comparisons.rs:81:5
    |
 LL |     -5 == (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:68:5
+  --> tests/ui/invalid_upcast_comparisons.rs:85:5
    |
 LL |     1337 == (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:70:5
+  --> tests/ui/invalid_upcast_comparisons.rs:88:5
    |
 LL |     1337 == (u8 as u32);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:73:5
+  --> tests/ui/invalid_upcast_comparisons.rs:92:5
    |
 LL |     1337 != (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:75:5
+  --> tests/ui/invalid_upcast_comparisons.rs:95:5
    |
 LL |     1337 != (u8 as u32);
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always true
-  --> tests/ui/invalid_upcast_comparisons.rs:90:5
+  --> tests/ui/invalid_upcast_comparisons.rs:110:5
    |
 LL |     (u8 as i32) > -1;
    |     ^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:92:5
+  --> tests/ui/invalid_upcast_comparisons.rs:113:5
    |
 LL |     (u8 as i32) < -1;
    |     ^^^^^^^^^^^^^^^^
 
 error: because of the numeric bounds on `u8` prior to casting, this expression is always false
-  --> tests/ui/invalid_upcast_comparisons.rs:109:5
+  --> tests/ui/invalid_upcast_comparisons.rs:131:5
    |
 LL |     -5 >= (u8 as i32);
    |     ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/io_other_error.fixed b/src/tools/clippy/tests/ui/io_other_error.fixed
new file mode 100644
index 000000000000..0054c56fb628
--- /dev/null
+++ b/src/tools/clippy/tests/ui/io_other_error.fixed
@@ -0,0 +1,55 @@
+#![warn(clippy::io_other_error)]
+use std::fmt;
+
+#[derive(Debug)]
+struct E;
+
+impl std::error::Error for E {}
+impl fmt::Display for E {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("E")
+    }
+}
+
+macro_rules! o {
+    {} => { std::io::ErrorKind::Other };
+}
+
+macro_rules! e {
+    { $kind:expr } => { std::io::Error::new($kind, E) };
+}
+
+fn main() {
+    let _err = std::io::Error::other(E);
+    //~^ ERROR: this can be `std::io::Error::other(_)`
+    let other = std::io::ErrorKind::Other;
+    let _err = std::io::Error::other(E);
+    //~^ ERROR: this can be `std::io::Error::other(_)`
+
+    // not other
+    let _err = std::io::Error::new(std::io::ErrorKind::TimedOut, E);
+
+    // from expansion
+    let _err = e!(other);
+    let _err = std::io::Error::new(o!(), E);
+    let _err = e!(o!());
+
+    paths::short();
+    under_msrv();
+}
+
+mod paths {
+    use std::io::{self, Error, ErrorKind};
+
+    pub fn short() {
+        let _err = Error::other(super::E);
+        //~^ ERROR: this can be `std::io::Error::other(_)`
+        let _err = io::Error::other(super::E);
+        //~^ ERROR: this can be `std::io::Error::other(_)`
+    }
+}
+
+#[clippy::msrv = "1.73"]
+fn under_msrv() {
+    let _err = std::io::Error::new(std::io::ErrorKind::Other, E);
+}
diff --git a/src/tools/clippy/tests/ui/io_other_error.rs b/src/tools/clippy/tests/ui/io_other_error.rs
new file mode 100644
index 000000000000..8529fb9a77f9
--- /dev/null
+++ b/src/tools/clippy/tests/ui/io_other_error.rs
@@ -0,0 +1,55 @@
+#![warn(clippy::io_other_error)]
+use std::fmt;
+
+#[derive(Debug)]
+struct E;
+
+impl std::error::Error for E {}
+impl fmt::Display for E {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+        f.write_str("E")
+    }
+}
+
+macro_rules! o {
+    {} => { std::io::ErrorKind::Other };
+}
+
+macro_rules! e {
+    { $kind:expr } => { std::io::Error::new($kind, E) };
+}
+
+fn main() {
+    let _err = std::io::Error::new(std::io::ErrorKind::Other, E);
+    //~^ ERROR: this can be `std::io::Error::other(_)`
+    let other = std::io::ErrorKind::Other;
+    let _err = std::io::Error::new(other, E);
+    //~^ ERROR: this can be `std::io::Error::other(_)`
+
+    // not other
+    let _err = std::io::Error::new(std::io::ErrorKind::TimedOut, E);
+
+    // from expansion
+    let _err = e!(other);
+    let _err = std::io::Error::new(o!(), E);
+    let _err = e!(o!());
+
+    paths::short();
+    under_msrv();
+}
+
+mod paths {
+    use std::io::{self, Error, ErrorKind};
+
+    pub fn short() {
+        let _err = Error::new(ErrorKind::Other, super::E);
+        //~^ ERROR: this can be `std::io::Error::other(_)`
+        let _err = io::Error::new(io::ErrorKind::Other, super::E);
+        //~^ ERROR: this can be `std::io::Error::other(_)`
+    }
+}
+
+#[clippy::msrv = "1.73"]
+fn under_msrv() {
+    let _err = std::io::Error::new(std::io::ErrorKind::Other, E);
+}
diff --git a/src/tools/clippy/tests/ui/io_other_error.stderr b/src/tools/clippy/tests/ui/io_other_error.stderr
new file mode 100644
index 000000000000..e79e05ecd406
--- /dev/null
+++ b/src/tools/clippy/tests/ui/io_other_error.stderr
@@ -0,0 +1,52 @@
+error: this can be `std::io::Error::other(_)`
+  --> tests/ui/io_other_error.rs:23:16
+   |
+LL |     let _err = std::io::Error::new(std::io::ErrorKind::Other, E);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: `-D clippy::io-other-error` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::io_other_error)]`
+help: use `std::io::Error::other`
+   |
+LL -     let _err = std::io::Error::new(std::io::ErrorKind::Other, E);
+LL +     let _err = std::io::Error::other(E);
+   |
+
+error: this can be `std::io::Error::other(_)`
+  --> tests/ui/io_other_error.rs:26:16
+   |
+LL |     let _err = std::io::Error::new(other, E);
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `std::io::Error::other`
+   |
+LL -     let _err = std::io::Error::new(other, E);
+LL +     let _err = std::io::Error::other(E);
+   |
+
+error: this can be `std::io::Error::other(_)`
+  --> tests/ui/io_other_error.rs:45:20
+   |
+LL |         let _err = Error::new(ErrorKind::Other, super::E);
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `std::io::Error::other`
+   |
+LL -         let _err = Error::new(ErrorKind::Other, super::E);
+LL +         let _err = Error::other(super::E);
+   |
+
+error: this can be `std::io::Error::other(_)`
+  --> tests/ui/io_other_error.rs:47:20
+   |
+LL |         let _err = io::Error::new(io::ErrorKind::Other, super::E);
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use `std::io::Error::other`
+   |
+LL -         let _err = io::Error::new(io::ErrorKind::Other, super::E);
+LL +         let _err = io::Error::other(super::E);
+   |
+
+error: aborting due to 4 previous errors
+
diff --git a/src/tools/clippy/tests/ui/is_digit_ascii_radix.fixed b/src/tools/clippy/tests/ui/is_digit_ascii_radix.fixed
index 62953ff74cfc..b0509ed2a751 100644
--- a/src/tools/clippy/tests/ui/is_digit_ascii_radix.fixed
+++ b/src/tools/clippy/tests/ui/is_digit_ascii_radix.fixed
@@ -7,8 +7,11 @@ fn main() {
 
     // Should trigger the lint.
     let _ = c.is_ascii_digit();
+    //~^ is_digit_ascii_radix
     let _ = c.is_ascii_hexdigit();
+    //~^ is_digit_ascii_radix
     let _ = c.is_ascii_hexdigit();
+    //~^ is_digit_ascii_radix
 
     // Should not trigger the lint.
     let _ = c.is_digit(11);
diff --git a/src/tools/clippy/tests/ui/is_digit_ascii_radix.rs b/src/tools/clippy/tests/ui/is_digit_ascii_radix.rs
index 229f530f611d..68d4b56063b5 100644
--- a/src/tools/clippy/tests/ui/is_digit_ascii_radix.rs
+++ b/src/tools/clippy/tests/ui/is_digit_ascii_radix.rs
@@ -7,8 +7,11 @@ fn main() {
 
     // Should trigger the lint.
     let _ = c.is_digit(10);
+    //~^ is_digit_ascii_radix
     let _ = c.is_digit(16);
+    //~^ is_digit_ascii_radix
     let _ = c.is_digit(0x10);
+    //~^ is_digit_ascii_radix
 
     // Should not trigger the lint.
     let _ = c.is_digit(11);
diff --git a/src/tools/clippy/tests/ui/is_digit_ascii_radix.stderr b/src/tools/clippy/tests/ui/is_digit_ascii_radix.stderr
index f26183ddab84..b6e53eb5829f 100644
--- a/src/tools/clippy/tests/ui/is_digit_ascii_radix.stderr
+++ b/src/tools/clippy/tests/ui/is_digit_ascii_radix.stderr
@@ -8,13 +8,13 @@ LL |     let _ = c.is_digit(10);
    = help: to override `-D warnings` add `#[allow(clippy::is_digit_ascii_radix)]`
 
 error: use of `char::is_digit` with literal radix of 16
-  --> tests/ui/is_digit_ascii_radix.rs:10:13
+  --> tests/ui/is_digit_ascii_radix.rs:11:13
    |
 LL |     let _ = c.is_digit(16);
    |             ^^^^^^^^^^^^^^ help: try: `c.is_ascii_hexdigit()`
 
 error: use of `char::is_digit` with literal radix of 16
-  --> tests/ui/is_digit_ascii_radix.rs:11:13
+  --> tests/ui/is_digit_ascii_radix.rs:13:13
    |
 LL |     let _ = c.is_digit(0x10);
    |             ^^^^^^^^^^^^^^^^ help: try: `c.is_ascii_hexdigit()`
diff --git a/src/tools/clippy/tests/ui/issue-111399.rs b/src/tools/clippy/tests/ui/issue-111399.rs
index b65e6c7261a5..2a6436b4b4eb 100644
--- a/src/tools/clippy/tests/ui/issue-111399.rs
+++ b/src/tools/clippy/tests/ui/issue-111399.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![feature(inherent_associated_types)]
 #![allow(incomplete_features)]
 
diff --git a/src/tools/clippy/tests/ui/issue-7447.rs b/src/tools/clippy/tests/ui/issue-7447.rs
index 7e7ef209d485..452011de1195 100644
--- a/src/tools/clippy/tests/ui/issue-7447.rs
+++ b/src/tools/clippy/tests/ui/issue-7447.rs
@@ -24,8 +24,8 @@ pub struct ByteView<'a> {
 
 fn main() {
     byte_view(panic!());
-    //~^ ERROR: sub-expression diverges
-    //~| NOTE: `-D clippy::diverging-sub-expression` implied by `-D warnings`
+    //~^ diverging_sub_expression
+
     group_entries(panic!());
-    //~^ ERROR: sub-expression diverges
+    //~^ diverging_sub_expression
 }
diff --git a/src/tools/clippy/tests/ui/issue_2356.fixed b/src/tools/clippy/tests/ui/issue_2356.fixed
index 892aa4e34216..46ba653eba2c 100644
--- a/src/tools/clippy/tests/ui/issue_2356.fixed
+++ b/src/tools/clippy/tests/ui/issue_2356.fixed
@@ -15,6 +15,7 @@ impl Foo {
 
     fn foo2<I: Iterator<Item = usize>>(mut it: I) {
         for e in it {
+            //~^ while_let_on_iterator
             println!("{:?}", e);
         }
     }
diff --git a/src/tools/clippy/tests/ui/issue_2356.rs b/src/tools/clippy/tests/ui/issue_2356.rs
index da0eead15b39..defe2584a93e 100644
--- a/src/tools/clippy/tests/ui/issue_2356.rs
+++ b/src/tools/clippy/tests/ui/issue_2356.rs
@@ -15,6 +15,7 @@ impl Foo {
 
     fn foo2<I: Iterator<Item = usize>>(mut it: I) {
         while let Some(e) = it.next() {
+            //~^ while_let_on_iterator
             println!("{:?}", e);
         }
     }
diff --git a/src/tools/clippy/tests/ui/issue_4266.rs b/src/tools/clippy/tests/ui/issue_4266.rs
index 23453207b4e5..664f0b84a207 100644
--- a/src/tools/clippy/tests/ui/issue_4266.rs
+++ b/src/tools/clippy/tests/ui/issue_4266.rs
@@ -2,13 +2,14 @@
 #![allow(clippy::uninlined_format_args)]
 
 async fn sink1<'a>(_: &'a str) {} // lint
-//~^ ERROR: the following explicit lifetimes could be elided: 'a
-//~| NOTE: `-D clippy::needless-lifetimes` implied by `-D warnings`
+//~^ needless_lifetimes
+
 async fn sink1_elided(_: &str) {} // ok
 
 // lint
 async fn one_to_one<'a>(s: &'a str) -> &'a str {
-    //~^ ERROR: the following explicit lifetimes could be elided: 'a
+    //~^ needless_lifetimes
+
     s
 }
 
@@ -29,7 +30,8 @@ struct Foo;
 impl Foo {
     // ok
     pub async fn new(&mut self) -> Self {
-        //~^ ERROR: methods called `new` usually take no `self`
+        //~^ wrong_self_convention
+
         Foo {}
     }
 }
diff --git a/src/tools/clippy/tests/ui/issue_4266.stderr b/src/tools/clippy/tests/ui/issue_4266.stderr
index 63c568a153b2..0e181025430f 100644
--- a/src/tools/clippy/tests/ui/issue_4266.stderr
+++ b/src/tools/clippy/tests/ui/issue_4266.stderr
@@ -14,7 +14,7 @@ LL | async fn one_to_one<'a>(s: &'a str) -> &'a str {
    |                     ^^      ^^          ^^
 
 error: methods called `new` usually take no `self`
-  --> tests/ui/issue_4266.rs:31:22
+  --> tests/ui/issue_4266.rs:32:22
    |
 LL |     pub async fn new(&mut self) -> Self {
    |                      ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/items_after_statement.rs b/src/tools/clippy/tests/ui/items_after_statement.rs
index 943e7c116760..b97c831f37ec 100644
--- a/src/tools/clippy/tests/ui/items_after_statement.rs
+++ b/src/tools/clippy/tests/ui/items_after_statement.rs
@@ -11,8 +11,8 @@ fn ok() {
 fn last() {
     foo();
     fn foo() {
-        //~^ ERROR: adding items after statements is confusing, since items exist from the sta
-        //~| NOTE: `-D clippy::items-after-statements` implied by `-D warnings`
+        //~^ items_after_statements
+
         println!("foo");
     }
 }
@@ -20,7 +20,8 @@ fn last() {
 fn main() {
     foo();
     fn foo() {
-        //~^ ERROR: adding items after statements is confusing, since items exist from the sta
+        //~^ items_after_statements
+
         println!("foo");
     }
     foo();
@@ -34,6 +35,7 @@ fn mac() {
         () => {{
             a = 6;
             fn say_something() {
+                //~^ items_after_statements
                 println!("something");
             }
         }};
diff --git a/src/tools/clippy/tests/ui/items_after_statement.stderr b/src/tools/clippy/tests/ui/items_after_statement.stderr
index 0f1989d4c9fc..7a5ae2c8d47d 100644
--- a/src/tools/clippy/tests/ui/items_after_statement.stderr
+++ b/src/tools/clippy/tests/ui/items_after_statement.stderr
@@ -16,14 +16,16 @@ error: adding items after statements is confusing, since items exist from the st
    |
 LL | /     fn foo() {
 LL | |
+LL | |
 LL | |         println!("foo");
 LL | |     }
    | |_____^
 
 error: adding items after statements is confusing, since items exist from the start of the scope
-  --> tests/ui/items_after_statement.rs:36:13
+  --> tests/ui/items_after_statement.rs:37:13
    |
 LL | /             fn say_something() {
+LL | |
 LL | |                 println!("something");
 LL | |             }
    | |_____________^
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/after_proc_macros.rs b/src/tools/clippy/tests/ui/items_after_test_module/after_proc_macros.rs
index d9c0aef88c8c..54a04988cda0 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/after_proc_macros.rs
+++ b/src/tools/clippy/tests/ui/items_after_test_module/after_proc_macros.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build:../auxiliary/proc_macros.rs
 extern crate proc_macros;
 
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/imported_module.rs b/src/tools/clippy/tests/ui/items_after_test_module/imported_module.rs
index 6a757aef48e7..d756be5b433e 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/imported_module.rs
+++ b/src/tools/clippy/tests/ui/items_after_test_module/imported_module.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@compile-flags: --test
 #![allow(unused)]
 #![warn(clippy::items_after_test_module)]
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.rs b/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.rs
index 7132e71764eb..6ca100c07f96 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.rs
+++ b/src/tools/clippy/tests/ui/items_after_test_module/in_submodule.rs
@@ -1,3 +1,4 @@
+//@error-in-other-file:
 #[path = "auxiliary/submodule.rs"]
 mod submodule;
 
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/multiple_modules.rs b/src/tools/clippy/tests/ui/items_after_test_module/multiple_modules.rs
index 8ab9e8200f18..8618710654a5 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/multiple_modules.rs
+++ b/src/tools/clippy/tests/ui/items_after_test_module/multiple_modules.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #[cfg(test)]
 mod tests {
     #[test]
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/root_module.fixed b/src/tools/clippy/tests/ui/items_after_test_module/root_module.fixed
index d444100a76b9..f036b368a667 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/root_module.fixed
+++ b/src/tools/clippy/tests/ui/items_after_test_module/root_module.fixed
@@ -17,6 +17,7 @@ macro_rules! should_lint {
 #[allow(clippy::allow_attributes)]
 #[cfg(test)]
 mod tests {
+    //~^ items_after_test_module
     #[test]
     fn hi() {}
 }
diff --git a/src/tools/clippy/tests/ui/items_after_test_module/root_module.rs b/src/tools/clippy/tests/ui/items_after_test_module/root_module.rs
index 57da01639cca..de0cbb120330 100644
--- a/src/tools/clippy/tests/ui/items_after_test_module/root_module.rs
+++ b/src/tools/clippy/tests/ui/items_after_test_module/root_module.rs
@@ -10,6 +10,7 @@ fn should_not_lint() {}
 #[allow(clippy::allow_attributes)]
 #[cfg(test)]
 mod tests {
+    //~^ items_after_test_module
     #[test]
     fn hi() {}
 }
diff --git a/src/tools/clippy/tests/ui/iter_cloned_collect.fixed b/src/tools/clippy/tests/ui/iter_cloned_collect.fixed
index 1d623642a713..e9fb44e89598 100644
--- a/src/tools/clippy/tests/ui/iter_cloned_collect.fixed
+++ b/src/tools/clippy/tests/ui/iter_cloned_collect.fixed
@@ -6,11 +6,13 @@ use std::collections::{HashSet, VecDeque};
 fn main() {
     let v = [1, 2, 3, 4, 5];
     let v2: Vec<isize> = v.to_vec();
+    //~^ iter_cloned_collect
     let v3: HashSet<isize> = v.iter().cloned().collect();
     let v4: VecDeque<isize> = v.iter().cloned().collect();
 
     // Handle macro expansion in suggestion
     let _: Vec<isize> = vec![1, 2, 3].to_vec();
+    //~^ iter_cloned_collect
 
     // Issue #3704
     unsafe {
@@ -21,7 +23,9 @@ fn main() {
     // Issue #6808
     let arr: [u8; 64] = [0; 64];
     let _: Vec<_> = arr.to_vec();
+    //~^ iter_cloned_collect
 
     // Issue #6703
     let _: Vec<isize> = v.to_vec();
+    //~^ iter_cloned_collect
 }
diff --git a/src/tools/clippy/tests/ui/iter_cloned_collect.rs b/src/tools/clippy/tests/ui/iter_cloned_collect.rs
index 091bd9eaf081..c9b8abcc9a0d 100644
--- a/src/tools/clippy/tests/ui/iter_cloned_collect.rs
+++ b/src/tools/clippy/tests/ui/iter_cloned_collect.rs
@@ -6,16 +6,19 @@ use std::collections::{HashSet, VecDeque};
 fn main() {
     let v = [1, 2, 3, 4, 5];
     let v2: Vec<isize> = v.iter().cloned().collect();
+    //~^ iter_cloned_collect
     let v3: HashSet<isize> = v.iter().cloned().collect();
     let v4: VecDeque<isize> = v.iter().cloned().collect();
 
     // Handle macro expansion in suggestion
     let _: Vec<isize> = vec![1, 2, 3].iter().cloned().collect();
+    //~^ iter_cloned_collect
 
     // Issue #3704
     unsafe {
         let _: Vec<u8> = std::ffi::CStr::from_ptr(std::ptr::null())
             .to_bytes()
+            //~^ iter_cloned_collect
             .iter()
             .cloned()
             .collect();
@@ -24,7 +27,9 @@ fn main() {
     // Issue #6808
     let arr: [u8; 64] = [0; 64];
     let _: Vec<_> = arr.iter().cloned().collect();
+    //~^ iter_cloned_collect
 
     // Issue #6703
     let _: Vec<isize> = v.iter().copied().collect();
+    //~^ iter_cloned_collect
 }
diff --git a/src/tools/clippy/tests/ui/iter_cloned_collect.stderr b/src/tools/clippy/tests/ui/iter_cloned_collect.stderr
index e8d82ec2c1b3..119698cb4634 100644
--- a/src/tools/clippy/tests/ui/iter_cloned_collect.stderr
+++ b/src/tools/clippy/tests/ui/iter_cloned_collect.stderr
@@ -8,29 +8,30 @@ LL |     let v2: Vec<isize> = v.iter().cloned().collect();
    = help: to override `-D warnings` add `#[allow(clippy::iter_cloned_collect)]`
 
 error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> tests/ui/iter_cloned_collect.rs:13:38
+  --> tests/ui/iter_cloned_collect.rs:14:38
    |
 LL |     let _: Vec<isize> = vec![1, 2, 3].iter().cloned().collect();
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
 
 error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> tests/ui/iter_cloned_collect.rs:18:24
+  --> tests/ui/iter_cloned_collect.rs:20:24
    |
 LL |               .to_bytes()
    |  ________________________^
+LL | |
 LL | |             .iter()
 LL | |             .cloned()
 LL | |             .collect();
    | |______________________^ help: try: `.to_vec()`
 
 error: called `iter().cloned().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> tests/ui/iter_cloned_collect.rs:26:24
+  --> tests/ui/iter_cloned_collect.rs:29:24
    |
 LL |     let _: Vec<_> = arr.iter().cloned().collect();
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
 
 error: called `iter().copied().collect()` on a slice to create a `Vec`. Calling `to_vec()` is both faster and more readable
-  --> tests/ui/iter_cloned_collect.rs:29:26
+  --> tests/ui/iter_cloned_collect.rs:33:26
    |
 LL |     let _: Vec<isize> = v.iter().copied().collect();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `.to_vec()`
diff --git a/src/tools/clippy/tests/ui/iter_count.fixed b/src/tools/clippy/tests/ui/iter_count.fixed
index 75c007bb0c99..2e187e5bfa75 100644
--- a/src/tools/clippy/tests/ui/iter_count.fixed
+++ b/src/tools/clippy/tests/ui/iter_count.fixed
@@ -52,32 +52,57 @@ fn main() {
     binary_heap.push(1);
 
     &vec[..].len();
+    //~^ iter_count
     vec.len();
+    //~^ iter_count
     boxed_slice.len();
+    //~^ iter_count
     vec_deque.len();
+    //~^ iter_count
     hash_set.len();
+    //~^ iter_count
     hash_map.len();
+    //~^ iter_count
     b_tree_map.len();
+    //~^ iter_count
     b_tree_set.len();
+    //~^ iter_count
     linked_list.len();
+    //~^ iter_count
     binary_heap.len();
+    //~^ iter_count
 
     vec.len();
+    //~^ iter_count
     &vec[..].len();
+    //~^ iter_count
     vec_deque.len();
+    //~^ iter_count
     hash_map.len();
+    //~^ iter_count
     b_tree_map.len();
+    //~^ iter_count
     linked_list.len();
+    //~^ iter_count
 
     &vec[..].len();
+    //~^ iter_count
     vec.len();
+    //~^ iter_count
     vec_deque.len();
+    //~^ iter_count
     hash_set.len();
+    //~^ iter_count
     hash_map.len();
+    //~^ iter_count
     b_tree_map.len();
+    //~^ iter_count
     b_tree_set.len();
+    //~^ iter_count
     linked_list.len();
+    //~^ iter_count
     binary_heap.len();
+    //~^ iter_count
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
diff --git a/src/tools/clippy/tests/ui/iter_count.rs b/src/tools/clippy/tests/ui/iter_count.rs
index cd8207b2c5dc..e941892136ec 100644
--- a/src/tools/clippy/tests/ui/iter_count.rs
+++ b/src/tools/clippy/tests/ui/iter_count.rs
@@ -52,32 +52,57 @@ fn main() {
     binary_heap.push(1);
 
     &vec[..].iter().count();
+    //~^ iter_count
     vec.iter().count();
+    //~^ iter_count
     boxed_slice.iter().count();
+    //~^ iter_count
     vec_deque.iter().count();
+    //~^ iter_count
     hash_set.iter().count();
+    //~^ iter_count
     hash_map.iter().count();
+    //~^ iter_count
     b_tree_map.iter().count();
+    //~^ iter_count
     b_tree_set.iter().count();
+    //~^ iter_count
     linked_list.iter().count();
+    //~^ iter_count
     binary_heap.iter().count();
+    //~^ iter_count
 
     vec.iter_mut().count();
+    //~^ iter_count
     &vec[..].iter_mut().count();
+    //~^ iter_count
     vec_deque.iter_mut().count();
+    //~^ iter_count
     hash_map.iter_mut().count();
+    //~^ iter_count
     b_tree_map.iter_mut().count();
+    //~^ iter_count
     linked_list.iter_mut().count();
+    //~^ iter_count
 
     &vec[..].into_iter().count();
+    //~^ iter_count
     vec.into_iter().count();
+    //~^ iter_count
     vec_deque.into_iter().count();
+    //~^ iter_count
     hash_set.into_iter().count();
+    //~^ iter_count
     hash_map.into_iter().count();
+    //~^ iter_count
     b_tree_map.into_iter().count();
+    //~^ iter_count
     b_tree_set.into_iter().count();
+    //~^ iter_count
     linked_list.into_iter().count();
+    //~^ iter_count
     binary_heap.into_iter().count();
+    //~^ iter_count
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
diff --git a/src/tools/clippy/tests/ui/iter_count.stderr b/src/tools/clippy/tests/ui/iter_count.stderr
index b703310731f3..a5ccefd9048d 100644
--- a/src/tools/clippy/tests/ui/iter_count.stderr
+++ b/src/tools/clippy/tests/ui/iter_count.stderr
@@ -8,145 +8,145 @@ LL |     &vec[..].iter().count();
    = help: to override `-D warnings` add `#[allow(clippy::iter_count)]`
 
 error: called `.iter().count()` on a `Vec`
-  --> tests/ui/iter_count.rs:55:5
+  --> tests/ui/iter_count.rs:56:5
    |
 LL |     vec.iter().count();
    |     ^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.iter().count()` on a `slice`
-  --> tests/ui/iter_count.rs:56:5
+  --> tests/ui/iter_count.rs:58:5
    |
 LL |     boxed_slice.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `boxed_slice.len()`
 
 error: called `.iter().count()` on a `VecDeque`
-  --> tests/ui/iter_count.rs:57:5
+  --> tests/ui/iter_count.rs:60:5
    |
 LL |     vec_deque.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
 error: called `.iter().count()` on a `HashSet`
-  --> tests/ui/iter_count.rs:58:5
+  --> tests/ui/iter_count.rs:62:5
    |
 LL |     hash_set.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_set.len()`
 
 error: called `.iter().count()` on a `HashMap`
-  --> tests/ui/iter_count.rs:59:5
+  --> tests/ui/iter_count.rs:64:5
    |
 LL |     hash_map.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_map.len()`
 
 error: called `.iter().count()` on a `BTreeMap`
-  --> tests/ui/iter_count.rs:60:5
+  --> tests/ui/iter_count.rs:66:5
    |
 LL |     b_tree_map.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_map.len()`
 
 error: called `.iter().count()` on a `BTreeSet`
-  --> tests/ui/iter_count.rs:61:5
+  --> tests/ui/iter_count.rs:68:5
    |
 LL |     b_tree_set.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_set.len()`
 
 error: called `.iter().count()` on a `LinkedList`
-  --> tests/ui/iter_count.rs:62:5
+  --> tests/ui/iter_count.rs:70:5
    |
 LL |     linked_list.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `linked_list.len()`
 
 error: called `.iter().count()` on a `BinaryHeap`
-  --> tests/ui/iter_count.rs:63:5
+  --> tests/ui/iter_count.rs:72:5
    |
 LL |     binary_heap.iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `binary_heap.len()`
 
 error: called `.iter_mut().count()` on a `Vec`
-  --> tests/ui/iter_count.rs:65:5
+  --> tests/ui/iter_count.rs:75:5
    |
 LL |     vec.iter_mut().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.iter_mut().count()` on a `slice`
-  --> tests/ui/iter_count.rs:66:6
+  --> tests/ui/iter_count.rs:77:6
    |
 LL |     &vec[..].iter_mut().count();
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
 
 error: called `.iter_mut().count()` on a `VecDeque`
-  --> tests/ui/iter_count.rs:67:5
+  --> tests/ui/iter_count.rs:79:5
    |
 LL |     vec_deque.iter_mut().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
 error: called `.iter_mut().count()` on a `HashMap`
-  --> tests/ui/iter_count.rs:68:5
+  --> tests/ui/iter_count.rs:81:5
    |
 LL |     hash_map.iter_mut().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_map.len()`
 
 error: called `.iter_mut().count()` on a `BTreeMap`
-  --> tests/ui/iter_count.rs:69:5
+  --> tests/ui/iter_count.rs:83:5
    |
 LL |     b_tree_map.iter_mut().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_map.len()`
 
 error: called `.iter_mut().count()` on a `LinkedList`
-  --> tests/ui/iter_count.rs:70:5
+  --> tests/ui/iter_count.rs:85:5
    |
 LL |     linked_list.iter_mut().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `linked_list.len()`
 
 error: called `.into_iter().count()` on a `slice`
-  --> tests/ui/iter_count.rs:72:6
+  --> tests/ui/iter_count.rs:88:6
    |
 LL |     &vec[..].into_iter().count();
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec[..].len()`
 
 error: called `.into_iter().count()` on a `Vec`
-  --> tests/ui/iter_count.rs:73:5
+  --> tests/ui/iter_count.rs:90:5
    |
 LL |     vec.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.len()`
 
 error: called `.into_iter().count()` on a `VecDeque`
-  --> tests/ui/iter_count.rs:74:5
+  --> tests/ui/iter_count.rs:92:5
    |
 LL |     vec_deque.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec_deque.len()`
 
 error: called `.into_iter().count()` on a `HashSet`
-  --> tests/ui/iter_count.rs:75:5
+  --> tests/ui/iter_count.rs:94:5
    |
 LL |     hash_set.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_set.len()`
 
 error: called `.into_iter().count()` on a `HashMap`
-  --> tests/ui/iter_count.rs:76:5
+  --> tests/ui/iter_count.rs:96:5
    |
 LL |     hash_map.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `hash_map.len()`
 
 error: called `.into_iter().count()` on a `BTreeMap`
-  --> tests/ui/iter_count.rs:77:5
+  --> tests/ui/iter_count.rs:98:5
    |
 LL |     b_tree_map.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_map.len()`
 
 error: called `.into_iter().count()` on a `BTreeSet`
-  --> tests/ui/iter_count.rs:78:5
+  --> tests/ui/iter_count.rs:100:5
    |
 LL |     b_tree_set.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b_tree_set.len()`
 
 error: called `.into_iter().count()` on a `LinkedList`
-  --> tests/ui/iter_count.rs:79:5
+  --> tests/ui/iter_count.rs:102:5
    |
 LL |     linked_list.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `linked_list.len()`
 
 error: called `.into_iter().count()` on a `BinaryHeap`
-  --> tests/ui/iter_count.rs:80:5
+  --> tests/ui/iter_count.rs:104:5
    |
 LL |     binary_heap.into_iter().count();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `binary_heap.len()`
diff --git a/src/tools/clippy/tests/ui/iter_filter_is_ok.fixed b/src/tools/clippy/tests/ui/iter_filter_is_ok.fixed
index 80db8b29c18e..3223e19d23a7 100644
--- a/src/tools/clippy/tests/ui/iter_filter_is_ok.fixed
+++ b/src/tools/clippy/tests/ui/iter_filter_is_ok.fixed
@@ -9,51 +9,54 @@
 fn main() {
     {
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
+
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
+
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 
     {
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 
     {
         let _ = vec![Ok(1), Err(2), Ok(3)]
             .into_iter()
             .flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         let _ = vec![Ok(1), Err(2), Ok(3)]
             .into_iter()
             .flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
+
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 
     {
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/iter_filter_is_ok.rs b/src/tools/clippy/tests/ui/iter_filter_is_ok.rs
index 89b083b84f32..973653819850 100644
--- a/src/tools/clippy/tests/ui/iter_filter_is_ok.rs
+++ b/src/tools/clippy/tests/ui/iter_filter_is_ok.rs
@@ -9,51 +9,54 @@
 fn main() {
     {
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok);
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
+
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
+
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| { o.is_ok() });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 
     {
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2)].into_iter().filter(|&o| { o.is_ok() });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 
     {
         let _ = vec![Ok(1), Err(2), Ok(3)]
             .into_iter()
             .filter(std::result::Result::is_ok);
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         let _ = vec![Ok(1), Err(2), Ok(3)]
             .into_iter()
             .filter(|a| std::result::Result::is_ok(a));
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
+
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| { std::result::Result::is_ok(a) });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 
     {
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
 
         #[rustfmt::skip]
         let _ = vec![Ok(1), Err(2)].into_iter().filter(|ref o| { o.is_ok() });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_ok
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/iter_filter_is_ok.stderr b/src/tools/clippy/tests/ui/iter_filter_is_ok.stderr
index 0aff60224e0e..b7fd0d25cc23 100644
--- a/src/tools/clippy/tests/ui/iter_filter_is_ok.stderr
+++ b/src/tools/clippy/tests/ui/iter_filter_is_ok.stderr
@@ -8,59 +8,53 @@ LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(Result::is_ok
    = help: to override `-D warnings` add `#[allow(clippy::iter_filter_is_ok)]`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:13:56
+  --> tests/ui/iter_filter_is_ok.rs:14:56
    |
 LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| a.is_ok());
    |                                                        ^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:16:49
+  --> tests/ui/iter_filter_is_ok.rs:18:49
    |
 LL |         let _ = vec![Ok(1), Err(2)].into_iter().filter(|o| { o.is_ok() });
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:21:56
+  --> tests/ui/iter_filter_is_ok.rs:23:56
    |
 LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
    |                                                        ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:24:56
+  --> tests/ui/iter_filter_is_ok.rs:26:56
    |
 LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|&a| a.is_ok());
    |                                                        ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:28:49
+  --> tests/ui/iter_filter_is_ok.rs:30:49
    |
 LL |         let _ = vec![Ok(1), Err(2)].into_iter().filter(|&o| { o.is_ok() });
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:35:14
+  --> tests/ui/iter_filter_is_ok.rs:37:14
    |
 LL |             .filter(std::result::Result::is_ok);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:40:14
+  --> tests/ui/iter_filter_is_ok.rs:42:14
    |
 LL |             .filter(|a| std::result::Result::is_ok(a));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:43:56
+  --> tests/ui/iter_filter_is_ok.rs:46:56
    |
 LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|a| { std::result::Result::is_ok(a) });
    |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
-error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:48:56
-   |
-LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
-   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
-
 error: `filter` for `is_ok` on iterator over `Result`s
   --> tests/ui/iter_filter_is_ok.rs:51:56
    |
@@ -68,7 +62,13 @@ LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_
    |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_ok` on iterator over `Result`s
-  --> tests/ui/iter_filter_is_ok.rs:55:49
+  --> tests/ui/iter_filter_is_ok.rs:54:56
+   |
+LL |         let _ = vec![Ok(1), Err(2), Ok(3)].into_iter().filter(|ref a| a.is_ok());
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
+
+error: `filter` for `is_ok` on iterator over `Result`s
+  --> tests/ui/iter_filter_is_ok.rs:58:49
    |
 LL |         let _ = vec![Ok(1), Err(2)].into_iter().filter(|ref o| { o.is_ok() });
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
diff --git a/src/tools/clippy/tests/ui/iter_filter_is_some.fixed b/src/tools/clippy/tests/ui/iter_filter_is_some.fixed
index 8a818c0c6728..99e764e957fb 100644
--- a/src/tools/clippy/tests/ui/iter_filter_is_some.fixed
+++ b/src/tools/clippy/tests/ui/iter_filter_is_some.fixed
@@ -13,45 +13,48 @@ use std::collections::HashMap;
 fn main() {
     {
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
+
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
+
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 
     {
         let _ = vec![Some(1), None, Some(3)]
             .into_iter()
             .flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
 
         let _ = vec![Some(1), None, Some(3)]
             .into_iter()
             .flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
+
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 
     {
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
 
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 
     {
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
 
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().flatten();
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/iter_filter_is_some.rs b/src/tools/clippy/tests/ui/iter_filter_is_some.rs
index 9eda93a25921..ecb7a04ab4df 100644
--- a/src/tools/clippy/tests/ui/iter_filter_is_some.rs
+++ b/src/tools/clippy/tests/ui/iter_filter_is_some.rs
@@ -13,45 +13,48 @@ use std::collections::HashMap;
 fn main() {
     {
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(Option::is_some);
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
+
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| a.is_some());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
+
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| { o.is_some() });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 
     {
         let _ = vec![Some(1), None, Some(3)]
             .into_iter()
             .filter(std::option::Option::is_some);
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
 
         let _ = vec![Some(1), None, Some(3)]
             .into_iter()
             .filter(|a| std::option::Option::is_some(a));
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
+
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| { std::option::Option::is_some(a) });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 
     {
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&a| a.is_some());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
 
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&o| { o.is_some() });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 
     {
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref a| a.is_some());
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
 
         #[rustfmt::skip]
         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref o| { o.is_some() });
-        //~^ HELP: consider using `flatten` instead
+        //~^ iter_filter_is_some
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/iter_filter_is_some.stderr b/src/tools/clippy/tests/ui/iter_filter_is_some.stderr
index 54aff892b1f0..cd01a3e05cd0 100644
--- a/src/tools/clippy/tests/ui/iter_filter_is_some.stderr
+++ b/src/tools/clippy/tests/ui/iter_filter_is_some.stderr
@@ -8,55 +8,55 @@ LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(Option::is_
    = help: to override `-D warnings` add `#[allow(clippy::iter_filter_is_some)]`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:17:58
+  --> tests/ui/iter_filter_is_some.rs:18:58
    |
 LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| a.is_some());
    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:20:58
+  --> tests/ui/iter_filter_is_some.rs:22:58
    |
 LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|o| { o.is_some() });
    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:27:14
+  --> tests/ui/iter_filter_is_some.rs:29:14
    |
 LL |             .filter(std::option::Option::is_some);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:32:14
+  --> tests/ui/iter_filter_is_some.rs:34:14
    |
 LL |             .filter(|a| std::option::Option::is_some(a));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:35:58
+  --> tests/ui/iter_filter_is_some.rs:38:58
    |
 LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|a| { std::option::Option::is_some(a) });
    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:40:58
+  --> tests/ui/iter_filter_is_some.rs:43:58
    |
 LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&a| a.is_some());
    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:44:58
+  --> tests/ui/iter_filter_is_some.rs:47:58
    |
 LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|&o| { o.is_some() });
    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:49:58
+  --> tests/ui/iter_filter_is_some.rs:52:58
    |
 LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref a| a.is_some());
    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `is_some` on iterator over `Option`
-  --> tests/ui/iter_filter_is_some.rs:53:58
+  --> tests/ui/iter_filter_is_some.rs:56:58
    |
 LL |         let _ = vec![Some(1), None, Some(3)].into_iter().filter(|ref o| { o.is_some() });
    |                                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
diff --git a/src/tools/clippy/tests/ui/iter_kv_map.fixed b/src/tools/clippy/tests/ui/iter_kv_map.fixed
index 2cbf972fca5f..7fcab6592e26 100644
--- a/src/tools/clippy/tests/ui/iter_kv_map.fixed
+++ b/src/tools/clippy/tests/ui/iter_kv_map.fixed
@@ -12,17 +12,26 @@ fn main() {
     let map: HashMap<u32, u32> = HashMap::new();
 
     let _ = map.keys().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.values().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_keys().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_keys().map(|key| key + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_values().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_values().map(|val| val + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().values().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.keys().filter(|x| *x % 2 == 0).count();
+    //~^ iter_kv_map
 
     // Don't lint
     let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
@@ -33,13 +42,17 @@ fn main() {
 
     // Lint
     let _ = map.keys().map(|key| key * 9).count();
+    //~^ iter_kv_map
     let _ = map.values().map(|value| value * 17).count();
+    //~^ iter_kv_map
 
     // Preserve the ref in the fix.
     let _ = map.clone().into_values().map(|ref val| ref_acceptor(val)).count();
+    //~^ iter_kv_map
 
     // Preserve the mut in the fix.
     let _ = map
+        //~^ iter_kv_map
         .clone().into_values().map(|mut val| {
             val += 2;
             val
@@ -48,21 +61,31 @@ fn main() {
 
     // Don't let a mut interfere.
     let _ = map.clone().into_values().count();
+    //~^ iter_kv_map
 
     let map: BTreeMap<u32, u32> = BTreeMap::new();
 
     let _ = map.keys().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.values().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_keys().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_keys().map(|key| key + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_values().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_values().map(|val| val + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().values().collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.keys().filter(|x| *x % 2 == 0).count();
+    //~^ iter_kv_map
 
     // Don't lint
     let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
@@ -73,13 +96,17 @@ fn main() {
 
     // Lint
     let _ = map.keys().map(|key| key * 9).count();
+    //~^ iter_kv_map
     let _ = map.values().map(|value| value * 17).count();
+    //~^ iter_kv_map
 
     // Preserve the ref in the fix.
     let _ = map.clone().into_values().map(|ref val| ref_acceptor(val)).count();
+    //~^ iter_kv_map
 
     // Preserve the mut in the fix.
     let _ = map
+        //~^ iter_kv_map
         .clone().into_values().map(|mut val| {
             val += 2;
             val
@@ -88,6 +115,7 @@ fn main() {
 
     // Don't let a mut interfere.
     let _ = map.clone().into_values().count();
+    //~^ iter_kv_map
 }
 
 #[clippy::msrv = "1.53"]
@@ -103,11 +131,13 @@ fn msrv_1_53() {
 
     // Lint
     let _ = map.keys().collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
+
     let _ = map.values().collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
+
     let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
 }
 
 #[clippy::msrv = "1.54"]
@@ -116,19 +146,23 @@ fn msrv_1_54() {
     let map: HashMap<u32, u32> = HashMap::new();
 
     let _ = map.clone().into_keys().collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
+
     let _ = map.clone().into_keys().map(|key| key + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
 
     let _ = map.clone().into_values().collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
+
     let _ = map.clone().into_values().map(|val| val + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
 
     let _ = map.keys().collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
+
     let _ = map.values().collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
+
     let _ = map.values().map(|v| v + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
 }
diff --git a/src/tools/clippy/tests/ui/iter_kv_map.rs b/src/tools/clippy/tests/ui/iter_kv_map.rs
index 6a9a4267a765..b590aef7b803 100644
--- a/src/tools/clippy/tests/ui/iter_kv_map.rs
+++ b/src/tools/clippy/tests/ui/iter_kv_map.rs
@@ -12,17 +12,26 @@ fn main() {
     let map: HashMap<u32, u32> = HashMap::new();
 
     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+    //~^ iter_kv_map
 
     // Don't lint
     let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
@@ -33,13 +42,17 @@ fn main() {
 
     // Lint
     let _ = map.iter().map(|(key, _value)| key * 9).count();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(_key, value)| value * 17).count();
+    //~^ iter_kv_map
 
     // Preserve the ref in the fix.
     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
+    //~^ iter_kv_map
 
     // Preserve the mut in the fix.
     let _ = map
+        //~^ iter_kv_map
         .clone()
         .into_iter()
         .map(|(_, mut val)| {
@@ -50,21 +63,31 @@ fn main() {
 
     // Don't let a mut interfere.
     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
+    //~^ iter_kv_map
 
     let map: BTreeMap<u32, u32> = BTreeMap::new();
 
     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+    //~^ iter_kv_map
 
     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+    //~^ iter_kv_map
 
     // Don't lint
     let _ = map.iter().filter(|(_, val)| *val % 2 == 0).map(|(key, _)| key).count();
@@ -75,13 +98,17 @@ fn main() {
 
     // Lint
     let _ = map.iter().map(|(key, _value)| key * 9).count();
+    //~^ iter_kv_map
     let _ = map.iter().map(|(_key, value)| value * 17).count();
+    //~^ iter_kv_map
 
     // Preserve the ref in the fix.
     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
+    //~^ iter_kv_map
 
     // Preserve the mut in the fix.
     let _ = map
+        //~^ iter_kv_map
         .clone()
         .into_iter()
         .map(|(_, mut val)| {
@@ -92,6 +119,7 @@ fn main() {
 
     // Don't let a mut interfere.
     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
+    //~^ iter_kv_map
 }
 
 #[clippy::msrv = "1.53"]
@@ -107,11 +135,13 @@ fn msrv_1_53() {
 
     // Lint
     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
+
     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
+
     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
 }
 
 #[clippy::msrv = "1.54"]
@@ -120,19 +150,23 @@ fn msrv_1_54() {
     let map: HashMap<u32, u32> = HashMap::new();
 
     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
+
     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
 
     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
+
     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
 
     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's keys
+    //~^ iter_kv_map
+
     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
+
     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
-    //~^ ERROR: iterating on a map's values
+    //~^ iter_kv_map
 }
diff --git a/src/tools/clippy/tests/ui/iter_kv_map.stderr b/src/tools/clippy/tests/ui/iter_kv_map.stderr
index ad23dba55cb6..00d566ed14a2 100644
--- a/src/tools/clippy/tests/ui/iter_kv_map.stderr
+++ b/src/tools/clippy/tests/ui/iter_kv_map.stderr
@@ -8,80 +8,80 @@ LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    = help: to override `-D warnings` add `#[allow(clippy::iter_kv_map)]`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:15:13
+  --> tests/ui/iter_kv_map.rs:16:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:16:13
+  --> tests/ui/iter_kv_map.rs:18:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:18:13
+  --> tests/ui/iter_kv_map.rs:21:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:19:13
+  --> tests/ui/iter_kv_map.rs:23:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:21:13
+  --> tests/ui/iter_kv_map.rs:26:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:22:13
+  --> tests/ui/iter_kv_map.rs:28:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:24:13
+  --> tests/ui/iter_kv_map.rs:31:13
    |
 LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:25:13
+  --> tests/ui/iter_kv_map.rs:33:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:35:13
+  --> tests/ui/iter_kv_map.rs:44:13
    |
 LL |     let _ = map.iter().map(|(key, _value)| key * 9).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:36:13
+  --> tests/ui/iter_kv_map.rs:46:13
    |
 LL |     let _ = map.iter().map(|(_key, value)| value * 17).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:39:13
+  --> tests/ui/iter_kv_map.rs:50:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|ref val| ref_acceptor(val))`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:42:13
+  --> tests/ui/iter_kv_map.rs:54:13
    |
 LL |       let _ = map
    |  _____________^
+LL | |
 LL | |         .clone()
 LL | |         .into_iter()
-LL | |         .map(|(_, mut val)| {
-LL | |             val += 2;
+...  |
 LL | |             val
 LL | |         })
    | |__________^
@@ -89,6 +89,7 @@ LL | |         })
 help: try
    |
 LL ~     let _ = map
+LL +
 LL +         .clone().into_values().map(|mut val| {
 LL +             val += 2;
 LL +             val
@@ -96,92 +97,92 @@ LL +         })
    |
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:52:13
+  --> tests/ui/iter_kv_map.rs:65:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:56:13
+  --> tests/ui/iter_kv_map.rs:70:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:57:13
+  --> tests/ui/iter_kv_map.rs:72:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:58:13
+  --> tests/ui/iter_kv_map.rs:74:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
-error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:60:13
-   |
-LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
-
-error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:61:13
-   |
-LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
-
-error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:63:13
-   |
-LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
-
-error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:64:13
-   |
-LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
-
-error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:66:13
-   |
-LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
-
-error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:67:13
-   |
-LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
-
 error: iterating on a map's keys
   --> tests/ui/iter_kv_map.rs:77:13
    |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
+
+error: iterating on a map's keys
+  --> tests/ui/iter_kv_map.rs:79:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
+
+error: iterating on a map's values
+  --> tests/ui/iter_kv_map.rs:82:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
+
+error: iterating on a map's values
+  --> tests/ui/iter_kv_map.rs:84:13
+   |
+LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
+
+error: iterating on a map's values
+  --> tests/ui/iter_kv_map.rs:87:13
+   |
+LL |     let _ = map.clone().iter().map(|(_, val)| val).collect::<Vec<_>>();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().values()`
+
+error: iterating on a map's keys
+  --> tests/ui/iter_kv_map.rs:89:13
+   |
+LL |     let _ = map.iter().map(|(key, _)| key).filter(|x| *x % 2 == 0).count();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
+
+error: iterating on a map's keys
+  --> tests/ui/iter_kv_map.rs:100:13
+   |
 LL |     let _ = map.iter().map(|(key, _value)| key * 9).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys().map(|key| key * 9)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:78:13
+  --> tests/ui/iter_kv_map.rs:102:13
    |
 LL |     let _ = map.iter().map(|(_key, value)| value * 17).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|value| value * 17)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:81:13
+  --> tests/ui/iter_kv_map.rs:106:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, ref val)| ref_acceptor(val)).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|ref val| ref_acceptor(val))`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:84:13
+  --> tests/ui/iter_kv_map.rs:110:13
    |
 LL |       let _ = map
    |  _____________^
+LL | |
 LL | |         .clone()
 LL | |         .into_iter()
-LL | |         .map(|(_, mut val)| {
-LL | |             val += 2;
+...  |
 LL | |             val
 LL | |         })
    | |__________^
@@ -189,6 +190,7 @@ LL | |         })
 help: try
    |
 LL ~     let _ = map
+LL +
 LL +         .clone().into_values().map(|mut val| {
 LL +             val += 2;
 LL +             val
@@ -196,67 +198,67 @@ LL +         })
    |
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:94:13
+  --> tests/ui/iter_kv_map.rs:121:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, mut val)| val).count();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:109:13
+  --> tests/ui/iter_kv_map.rs:137:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:111:13
+  --> tests/ui/iter_kv_map.rs:140:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:113:13
+  --> tests/ui/iter_kv_map.rs:143:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:122:13
+  --> tests/ui/iter_kv_map.rs:152:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys()`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:124:13
+  --> tests/ui/iter_kv_map.rs:155:13
    |
 LL |     let _ = map.clone().into_iter().map(|(key, _)| key + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_keys().map(|key| key + 2)`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:127:13
+  --> tests/ui/iter_kv_map.rs:158:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:129:13
+  --> tests/ui/iter_kv_map.rs:161:13
    |
 LL |     let _ = map.clone().into_iter().map(|(_, val)| val + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.clone().into_values().map(|val| val + 2)`
 
 error: iterating on a map's keys
-  --> tests/ui/iter_kv_map.rs:132:13
+  --> tests/ui/iter_kv_map.rs:164:13
    |
 LL |     let _ = map.iter().map(|(key, _)| key).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.keys()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:134:13
+  --> tests/ui/iter_kv_map.rs:167:13
    |
 LL |     let _ = map.iter().map(|(_, value)| value).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values()`
 
 error: iterating on a map's values
-  --> tests/ui/iter_kv_map.rs:136:13
+  --> tests/ui/iter_kv_map.rs:170:13
    |
 LL |     let _ = map.iter().map(|(_, v)| v + 2).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `map.values().map(|v| v + 2)`
diff --git a/src/tools/clippy/tests/ui/iter_next_loop.rs b/src/tools/clippy/tests/ui/iter_next_loop.rs
index d425f4da0e81..32711c7ef623 100644
--- a/src/tools/clippy/tests/ui/iter_next_loop.rs
+++ b/src/tools/clippy/tests/ui/iter_next_loop.rs
@@ -4,6 +4,7 @@
 fn main() {
     let x = [1, 2, 3, 4];
     for _ in x.iter().next() {}
+    //~^ iter_next_loop
 
     struct Unrelated(&'static [u8]);
     impl Unrelated {
diff --git a/src/tools/clippy/tests/ui/iter_next_slice.fixed b/src/tools/clippy/tests/ui/iter_next_slice.fixed
index 83be12c4e254..2e7b4e632840 100644
--- a/src/tools/clippy/tests/ui/iter_next_slice.fixed
+++ b/src/tools/clippy/tests/ui/iter_next_slice.fixed
@@ -7,15 +7,19 @@ fn main() {
     let v = vec![1, 2, 3];
 
     let _ = s.first();
+    //~^ iter_next_slice
     // Should be replaced by s.first()
 
     let _ = s.get(2);
+    //~^ iter_next_slice
     // Should be replaced by s.get(2)
 
     let _ = v.get(5);
+    //~^ iter_next_slice
     // Should be replaced by v.get(5)
 
     let _ = v.first();
+    //~^ iter_next_slice
     // Should be replaced by v.first()
 
     let o = Some(5);
diff --git a/src/tools/clippy/tests/ui/iter_next_slice.rs b/src/tools/clippy/tests/ui/iter_next_slice.rs
index 1b257514d23e..b2e047f5d817 100644
--- a/src/tools/clippy/tests/ui/iter_next_slice.rs
+++ b/src/tools/clippy/tests/ui/iter_next_slice.rs
@@ -7,15 +7,19 @@ fn main() {
     let v = vec![1, 2, 3];
 
     let _ = s.iter().next();
+    //~^ iter_next_slice
     // Should be replaced by s.first()
 
     let _ = s[2..].iter().next();
+    //~^ iter_next_slice
     // Should be replaced by s.get(2)
 
     let _ = v[5..].iter().next();
+    //~^ iter_next_slice
     // Should be replaced by v.get(5)
 
     let _ = v.iter().next();
+    //~^ iter_next_slice
     // Should be replaced by v.first()
 
     let o = Some(5);
diff --git a/src/tools/clippy/tests/ui/iter_next_slice.stderr b/src/tools/clippy/tests/ui/iter_next_slice.stderr
index 55cce2b9103d..0a22ab7f6a15 100644
--- a/src/tools/clippy/tests/ui/iter_next_slice.stderr
+++ b/src/tools/clippy/tests/ui/iter_next_slice.stderr
@@ -8,19 +8,19 @@ LL |     let _ = s.iter().next();
    = help: to override `-D warnings` add `#[allow(clippy::iter_next_slice)]`
 
 error: using `.iter().next()` on a Slice without end index
-  --> tests/ui/iter_next_slice.rs:12:13
+  --> tests/ui/iter_next_slice.rs:13:13
    |
 LL |     let _ = s[2..].iter().next();
    |             ^^^^^^^^^^^^^^^^^^^^ help: try calling: `s.get(2)`
 
 error: using `.iter().next()` on a Slice without end index
-  --> tests/ui/iter_next_slice.rs:15:13
+  --> tests/ui/iter_next_slice.rs:17:13
    |
 LL |     let _ = v[5..].iter().next();
    |             ^^^^^^^^^^^^^^^^^^^^ help: try calling: `v.get(5)`
 
 error: using `.iter().next()` on an array
-  --> tests/ui/iter_next_slice.rs:18:13
+  --> tests/ui/iter_next_slice.rs:21:13
    |
 LL |     let _ = v.iter().next();
    |             ^^^^^^^^^^^^^^^ help: try calling: `v.first()`
diff --git a/src/tools/clippy/tests/ui/iter_not_returning_iterator.rs b/src/tools/clippy/tests/ui/iter_not_returning_iterator.rs
index e694bc7ac62f..5c8c8eb4a43d 100644
--- a/src/tools/clippy/tests/ui/iter_not_returning_iterator.rs
+++ b/src/tools/clippy/tests/ui/iter_not_returning_iterator.rs
@@ -28,13 +28,14 @@ struct Counter2 {
 
 impl Data2 {
     fn iter(&self) -> Counter2 {
-        //~^ ERROR: this method is named `iter` but its return type does not implement `Iterat
-        //~| NOTE: `-D clippy::iter-not-returning-iterator` implied by `-D warnings`
+        //~^ iter_not_returning_iterator
+
         todo!()
     }
 
     fn iter_mut(&self) -> Counter2 {
-        //~^ ERROR: this method is named `iter_mut` but its return type does not implement `It
+        //~^ iter_not_returning_iterator
+
         todo!()
     }
 }
@@ -51,7 +52,7 @@ impl Iterator for Counter {
 trait Iter {
     type I;
     fn iter(&self) -> Self::I;
-    //~^ ERROR: this method is named `iter` but its return type does not implement `Iterat
+    //~^ iter_not_returning_iterator
 }
 
 impl Iter for () {
diff --git a/src/tools/clippy/tests/ui/iter_not_returning_iterator.stderr b/src/tools/clippy/tests/ui/iter_not_returning_iterator.stderr
index c3ee8bae772d..74ee8325d53e 100644
--- a/src/tools/clippy/tests/ui/iter_not_returning_iterator.stderr
+++ b/src/tools/clippy/tests/ui/iter_not_returning_iterator.stderr
@@ -14,7 +14,7 @@ LL |     fn iter_mut(&self) -> Counter2 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this method is named `iter` but its return type does not implement `Iterator`
-  --> tests/ui/iter_not_returning_iterator.rs:53:5
+  --> tests/ui/iter_not_returning_iterator.rs:54:5
    |
 LL |     fn iter(&self) -> Self::I;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/iter_nth.fixed b/src/tools/clippy/tests/ui/iter_nth.fixed
index aff3731a8837..5650903a5dcb 100644
--- a/src/tools/clippy/tests/ui/iter_nth.fixed
+++ b/src/tools/clippy/tests/ui/iter_nth.fixed
@@ -32,24 +32,32 @@ fn iter_nth() {
     {
         // Make sure we lint `.iter()` for relevant types.
         let bad_vec = some_vec.get(3);
+        //~^ iter_nth
         let bad_slice = &some_vec[..].get(3);
+        //~^ iter_nth
         let bad_boxed_slice = boxed_slice.get(3);
+        //~^ iter_nth
         let bad_vec_deque = some_vec_deque.get(3);
+        //~^ iter_nth
     }
 
     {
         // Make sure we lint `.iter_mut()` for relevant types.
         let bad_vec = some_vec.get_mut(3);
+        //~^ iter_nth
     }
     {
         let bad_slice = &some_vec[..].get_mut(3);
+        //~^ iter_nth
     }
     {
         let bad_vec_deque = some_vec_deque.get_mut(3);
+        //~^ iter_nth
     }
 
     let vec_ref = &Vec::<String>::new();
     vec_ref.get(3);
+    //~^ iter_nth
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
diff --git a/src/tools/clippy/tests/ui/iter_nth.rs b/src/tools/clippy/tests/ui/iter_nth.rs
index 89d68044ddda..cfd0629420e1 100644
--- a/src/tools/clippy/tests/ui/iter_nth.rs
+++ b/src/tools/clippy/tests/ui/iter_nth.rs
@@ -32,24 +32,32 @@ fn iter_nth() {
     {
         // Make sure we lint `.iter()` for relevant types.
         let bad_vec = some_vec.iter().nth(3);
+        //~^ iter_nth
         let bad_slice = &some_vec[..].iter().nth(3);
+        //~^ iter_nth
         let bad_boxed_slice = boxed_slice.iter().nth(3);
+        //~^ iter_nth
         let bad_vec_deque = some_vec_deque.iter().nth(3);
+        //~^ iter_nth
     }
 
     {
         // Make sure we lint `.iter_mut()` for relevant types.
         let bad_vec = some_vec.iter_mut().nth(3);
+        //~^ iter_nth
     }
     {
         let bad_slice = &some_vec[..].iter_mut().nth(3);
+        //~^ iter_nth
     }
     {
         let bad_vec_deque = some_vec_deque.iter_mut().nth(3);
+        //~^ iter_nth
     }
 
     let vec_ref = &Vec::<String>::new();
     vec_ref.iter().nth(3);
+    //~^ iter_nth
 
     // Make sure we don't lint for non-relevant types.
     let false_positive = HasIter;
diff --git a/src/tools/clippy/tests/ui/iter_nth.stderr b/src/tools/clippy/tests/ui/iter_nth.stderr
index 1167a604ecdc..76ddfd9684e2 100644
--- a/src/tools/clippy/tests/ui/iter_nth.stderr
+++ b/src/tools/clippy/tests/ui/iter_nth.stderr
@@ -13,7 +13,7 @@ LL +         let bad_vec = some_vec.get(3);
    |
 
 error: called `.iter().nth()` on a slice
-  --> tests/ui/iter_nth.rs:35:26
+  --> tests/ui/iter_nth.rs:36:26
    |
 LL |         let bad_slice = &some_vec[..].iter().nth(3);
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +         let bad_slice = &some_vec[..].get(3);
    |
 
 error: called `.iter().nth()` on a slice
-  --> tests/ui/iter_nth.rs:36:31
+  --> tests/ui/iter_nth.rs:38:31
    |
 LL |         let bad_boxed_slice = boxed_slice.iter().nth(3);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +         let bad_boxed_slice = boxed_slice.get(3);
    |
 
 error: called `.iter().nth()` on a `VecDeque`
-  --> tests/ui/iter_nth.rs:37:29
+  --> tests/ui/iter_nth.rs:40:29
    |
 LL |         let bad_vec_deque = some_vec_deque.iter().nth(3);
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +         let bad_vec_deque = some_vec_deque.get(3);
    |
 
 error: called `.iter_mut().nth()` on a `Vec`
-  --> tests/ui/iter_nth.rs:42:23
+  --> tests/ui/iter_nth.rs:46:23
    |
 LL |         let bad_vec = some_vec.iter_mut().nth(3);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +         let bad_vec = some_vec.get_mut(3);
    |
 
 error: called `.iter_mut().nth()` on a slice
-  --> tests/ui/iter_nth.rs:45:26
+  --> tests/ui/iter_nth.rs:50:26
    |
 LL |         let bad_slice = &some_vec[..].iter_mut().nth(3);
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +         let bad_slice = &some_vec[..].get_mut(3);
    |
 
 error: called `.iter_mut().nth()` on a `VecDeque`
-  --> tests/ui/iter_nth.rs:48:29
+  --> tests/ui/iter_nth.rs:54:29
    |
 LL |         let bad_vec_deque = some_vec_deque.iter_mut().nth(3);
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +         let bad_vec_deque = some_vec_deque.get_mut(3);
    |
 
 error: called `.iter().nth()` on a `Vec`
-  --> tests/ui/iter_nth.rs:52:5
+  --> tests/ui/iter_nth.rs:59:5
    |
 LL |     vec_ref.iter().nth(3);
    |     ^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/iter_nth_zero.fixed b/src/tools/clippy/tests/ui/iter_nth_zero.fixed
index a3cdb2e59bff..07153db90c19 100644
--- a/src/tools/clippy/tests/ui/iter_nth_zero.fixed
+++ b/src/tools/clippy/tests/ui/iter_nth_zero.fixed
@@ -16,16 +16,19 @@ fn main() {
     let mut s = HashSet::new();
     s.insert(1);
     let _x = s.iter().next();
+    //~^ iter_nth_zero
 
     let mut s2 = HashSet::new();
     s2.insert(2);
     let mut iter = s2.iter();
     let _y = iter.next();
+    //~^ iter_nth_zero
 
     let mut s3 = HashSet::new();
     s3.insert(3);
     let mut iter2 = s3.iter();
     let _unwrapped = iter2.next().unwrap();
+    //~^ iter_nth_zero
 }
 
 struct Issue9820;
diff --git a/src/tools/clippy/tests/ui/iter_nth_zero.rs b/src/tools/clippy/tests/ui/iter_nth_zero.rs
index 64229b5128a3..45d008cd7040 100644
--- a/src/tools/clippy/tests/ui/iter_nth_zero.rs
+++ b/src/tools/clippy/tests/ui/iter_nth_zero.rs
@@ -16,16 +16,19 @@ fn main() {
     let mut s = HashSet::new();
     s.insert(1);
     let _x = s.iter().nth(0);
+    //~^ iter_nth_zero
 
     let mut s2 = HashSet::new();
     s2.insert(2);
     let mut iter = s2.iter();
     let _y = iter.nth(0);
+    //~^ iter_nth_zero
 
     let mut s3 = HashSet::new();
     s3.insert(3);
     let mut iter2 = s3.iter();
     let _unwrapped = iter2.nth(0).unwrap();
+    //~^ iter_nth_zero
 }
 
 struct Issue9820;
diff --git a/src/tools/clippy/tests/ui/iter_nth_zero.stderr b/src/tools/clippy/tests/ui/iter_nth_zero.stderr
index b5e5cf45c26b..edd44838b7ec 100644
--- a/src/tools/clippy/tests/ui/iter_nth_zero.stderr
+++ b/src/tools/clippy/tests/ui/iter_nth_zero.stderr
@@ -8,13 +8,13 @@ LL |     let _x = s.iter().nth(0);
    = help: to override `-D warnings` add `#[allow(clippy::iter_nth_zero)]`
 
 error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
-  --> tests/ui/iter_nth_zero.rs:23:14
+  --> tests/ui/iter_nth_zero.rs:24:14
    |
 LL |     let _y = iter.nth(0);
    |              ^^^^^^^^^^^ help: try calling `.next()` instead of `.nth(0)`: `iter.next()`
 
 error: called `.nth(0)` on a `std::iter::Iterator`, when `.next()` is equivalent
-  --> tests/ui/iter_nth_zero.rs:28:22
+  --> tests/ui/iter_nth_zero.rs:30:22
    |
 LL |     let _unwrapped = iter2.nth(0).unwrap();
    |                      ^^^^^^^^^^^^ help: try calling `.next()` instead of `.nth(0)`: `iter2.next()`
diff --git a/src/tools/clippy/tests/ui/iter_on_empty_collections.fixed b/src/tools/clippy/tests/ui/iter_on_empty_collections.fixed
index 0f28b48d9ab8..0c2100034e18 100644
--- a/src/tools/clippy/tests/ui/iter_on_empty_collections.fixed
+++ b/src/tools/clippy/tests/ui/iter_on_empty_collections.fixed
@@ -3,11 +3,17 @@
 
 fn array() {
     assert_eq!(std::iter::empty().next(), Option::<i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(std::iter::empty().next(), Option::<i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(std::iter::empty().next(), Option::<&mut i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(std::iter::empty().next(), Option::<&i32>::None);
+    //~^ iter_on_empty_collections
 
     // Don't trigger on non-iter methods
     let _: Option<String> = None.clone();
@@ -26,6 +32,7 @@ fn array() {
     // Don't trigger when the empty collection iter is relied upon for its concrete type
     // But do trigger if it is just an iterator, despite being an argument to a method
     for i in smth.as_ref().map_or([].iter(), |s| s.iter()).chain(std::iter::empty()) {
+        //~^ iter_on_empty_collections
         println!("{i}");
     }
 
diff --git a/src/tools/clippy/tests/ui/iter_on_empty_collections.rs b/src/tools/clippy/tests/ui/iter_on_empty_collections.rs
index 702da514df7d..0fb7a32d3691 100644
--- a/src/tools/clippy/tests/ui/iter_on_empty_collections.rs
+++ b/src/tools/clippy/tests/ui/iter_on_empty_collections.rs
@@ -3,11 +3,17 @@
 
 fn array() {
     assert_eq!([].into_iter().next(), Option::<i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!([].iter().next(), Option::<&i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(None.into_iter().next(), Option::<i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
+    //~^ iter_on_empty_collections
     assert_eq!(None.iter().next(), Option::<&i32>::None);
+    //~^ iter_on_empty_collections
 
     // Don't trigger on non-iter methods
     let _: Option<String> = None.clone();
@@ -26,6 +32,7 @@ fn array() {
     // Don't trigger when the empty collection iter is relied upon for its concrete type
     // But do trigger if it is just an iterator, despite being an argument to a method
     for i in smth.as_ref().map_or([].iter(), |s| s.iter()).chain([].iter()) {
+        //~^ iter_on_empty_collections
         println!("{i}");
     }
 
diff --git a/src/tools/clippy/tests/ui/iter_on_empty_collections.stderr b/src/tools/clippy/tests/ui/iter_on_empty_collections.stderr
index da9caa6925bd..2803999cc735 100644
--- a/src/tools/clippy/tests/ui/iter_on_empty_collections.stderr
+++ b/src/tools/clippy/tests/ui/iter_on_empty_collections.stderr
@@ -8,37 +8,37 @@ LL |     assert_eq!([].into_iter().next(), Option::<i32>::None);
    = help: to override `-D warnings` add `#[allow(clippy::iter_on_empty_collections)]`
 
 error: `iter_mut` call on an empty collection
-  --> tests/ui/iter_on_empty_collections.rs:6:16
+  --> tests/ui/iter_on_empty_collections.rs:7:16
    |
 LL |     assert_eq!([].iter_mut().next(), Option::<&mut i32>::None);
    |                ^^^^^^^^^^^^^ help: try: `std::iter::empty()`
 
 error: `iter` call on an empty collection
-  --> tests/ui/iter_on_empty_collections.rs:7:16
+  --> tests/ui/iter_on_empty_collections.rs:9:16
    |
 LL |     assert_eq!([].iter().next(), Option::<&i32>::None);
    |                ^^^^^^^^^ help: try: `std::iter::empty()`
 
 error: `into_iter` call on an empty collection
-  --> tests/ui/iter_on_empty_collections.rs:8:16
+  --> tests/ui/iter_on_empty_collections.rs:11:16
    |
 LL |     assert_eq!(None.into_iter().next(), Option::<i32>::None);
    |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
 
 error: `iter_mut` call on an empty collection
-  --> tests/ui/iter_on_empty_collections.rs:9:16
+  --> tests/ui/iter_on_empty_collections.rs:13:16
    |
 LL |     assert_eq!(None.iter_mut().next(), Option::<&mut i32>::None);
    |                ^^^^^^^^^^^^^^^ help: try: `std::iter::empty()`
 
 error: `iter` call on an empty collection
-  --> tests/ui/iter_on_empty_collections.rs:10:16
+  --> tests/ui/iter_on_empty_collections.rs:15:16
    |
 LL |     assert_eq!(None.iter().next(), Option::<&i32>::None);
    |                ^^^^^^^^^^^ help: try: `std::iter::empty()`
 
 error: `iter` call on an empty collection
-  --> tests/ui/iter_on_empty_collections.rs:28:66
+  --> tests/ui/iter_on_empty_collections.rs:34:66
    |
 LL |     for i in smth.as_ref().map_or([].iter(), |s| s.iter()).chain([].iter()) {
    |                                                                  ^^^^^^^^^ help: try: `std::iter::empty()`
diff --git a/src/tools/clippy/tests/ui/iter_on_single_items.fixed b/src/tools/clippy/tests/ui/iter_on_single_items.fixed
index 117ec8429c37..b43fad6449c1 100644
--- a/src/tools/clippy/tests/ui/iter_on_single_items.fixed
+++ b/src/tools/clippy/tests/ui/iter_on_single_items.fixed
@@ -3,11 +3,17 @@
 
 fn array() {
     assert_eq!(std::iter::once(123).next(), Some(123));
+    //~^ iter_on_single_items
     assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
+    //~^ iter_on_single_items
     assert_eq!(std::iter::once(&123).next(), Some(&123));
+    //~^ iter_on_single_items
     assert_eq!(std::iter::once(123).next(), Some(123));
+    //~^ iter_on_single_items
     assert_eq!(std::iter::once(&mut 123).next(), Some(&mut 123));
+    //~^ iter_on_single_items
     assert_eq!(std::iter::once(&123).next(), Some(&123));
+    //~^ iter_on_single_items
 
     // Don't trigger on non-iter methods
     let _: Option<String> = Some("test".to_string()).clone();
diff --git a/src/tools/clippy/tests/ui/iter_on_single_items.rs b/src/tools/clippy/tests/ui/iter_on_single_items.rs
index d059370d996c..625c96d3ef1f 100644
--- a/src/tools/clippy/tests/ui/iter_on_single_items.rs
+++ b/src/tools/clippy/tests/ui/iter_on_single_items.rs
@@ -3,11 +3,17 @@
 
 fn array() {
     assert_eq!([123].into_iter().next(), Some(123));
+    //~^ iter_on_single_items
     assert_eq!([123].iter_mut().next(), Some(&mut 123));
+    //~^ iter_on_single_items
     assert_eq!([123].iter().next(), Some(&123));
+    //~^ iter_on_single_items
     assert_eq!(Some(123).into_iter().next(), Some(123));
+    //~^ iter_on_single_items
     assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
+    //~^ iter_on_single_items
     assert_eq!(Some(123).iter().next(), Some(&123));
+    //~^ iter_on_single_items
 
     // Don't trigger on non-iter methods
     let _: Option<String> = Some("test".to_string()).clone();
diff --git a/src/tools/clippy/tests/ui/iter_on_single_items.stderr b/src/tools/clippy/tests/ui/iter_on_single_items.stderr
index 0252c859581b..536e9eb36d88 100644
--- a/src/tools/clippy/tests/ui/iter_on_single_items.stderr
+++ b/src/tools/clippy/tests/ui/iter_on_single_items.stderr
@@ -8,31 +8,31 @@ LL |     assert_eq!([123].into_iter().next(), Some(123));
    = help: to override `-D warnings` add `#[allow(clippy::iter_on_single_items)]`
 
 error: `iter_mut` call on a collection with only one item
-  --> tests/ui/iter_on_single_items.rs:6:16
+  --> tests/ui/iter_on_single_items.rs:7:16
    |
 LL |     assert_eq!([123].iter_mut().next(), Some(&mut 123));
    |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
 
 error: `iter` call on a collection with only one item
-  --> tests/ui/iter_on_single_items.rs:7:16
+  --> tests/ui/iter_on_single_items.rs:9:16
    |
 LL |     assert_eq!([123].iter().next(), Some(&123));
    |                ^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
 
 error: `into_iter` call on a collection with only one item
-  --> tests/ui/iter_on_single_items.rs:8:16
+  --> tests/ui/iter_on_single_items.rs:11:16
    |
 LL |     assert_eq!(Some(123).into_iter().next(), Some(123));
    |                ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(123)`
 
 error: `iter_mut` call on a collection with only one item
-  --> tests/ui/iter_on_single_items.rs:9:16
+  --> tests/ui/iter_on_single_items.rs:13:16
    |
 LL |     assert_eq!(Some(123).iter_mut().next(), Some(&mut 123));
    |                ^^^^^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&mut 123)`
 
 error: `iter` call on a collection with only one item
-  --> tests/ui/iter_on_single_items.rs:10:16
+  --> tests/ui/iter_on_single_items.rs:15:16
    |
 LL |     assert_eq!(Some(123).iter().next(), Some(&123));
    |                ^^^^^^^^^^^^^^^^ help: try: `std::iter::once(&123)`
diff --git a/src/tools/clippy/tests/ui/iter_out_of_bounds.rs b/src/tools/clippy/tests/ui/iter_out_of_bounds.rs
index 3cfe6e82fc1e..b34e4ad78240 100644
--- a/src/tools/clippy/tests/ui/iter_out_of_bounds.rs
+++ b/src/tools/clippy/tests/ui/iter_out_of_bounds.rs
@@ -10,57 +10,60 @@ fn opaque_empty_iter() -> impl Iterator<Item = ()> {
 fn main() {
     #[allow(clippy::never_loop)]
     for _ in [1, 2, 3].iter().skip(4) {
-        //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+        //~^ iter_out_of_bounds
+
         unreachable!();
     }
     for (i, _) in [1, 2, 3].iter().take(4).enumerate() {
-        //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+        //~^ iter_out_of_bounds
+
         assert!(i <= 2);
     }
 
     #[allow(clippy::needless_borrow)]
     for _ in (&&&&&&[1, 2, 3]).iter().take(4) {}
-    //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     for _ in [1, 2, 3].iter().skip(4) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     for _ in [1; 3].iter().skip(4) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     // Should not lint
     for _ in opaque_empty_iter().skip(1) {}
 
     for _ in vec![1, 2, 3].iter().skip(4) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     for _ in vec![1; 3].iter().skip(4) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     let x = [1, 2, 3];
     for _ in x.iter().skip(4) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     let n = 4;
     for _ in x.iter().skip(n) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     let empty = std::iter::empty::<i8>;
 
     for _ in empty().skip(1) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     for _ in empty().take(1) {}
-    //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     for _ in std::iter::once(1).skip(2) {}
-    //~^ ERROR: this `.skip()` call skips more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     for _ in std::iter::once(1).take(2) {}
-    //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+    //~^ iter_out_of_bounds
 
     for x in [].iter().take(1) {
-        //~^ ERROR: this `.take()` call takes more items than the iterator will produce
+        //~^ iter_out_of_bounds
+
         let _: &i32 = x;
     }
 
diff --git a/src/tools/clippy/tests/ui/iter_out_of_bounds.stderr b/src/tools/clippy/tests/ui/iter_out_of_bounds.stderr
index 96df04251fc9..19ac60b9d0ac 100644
--- a/src/tools/clippy/tests/ui/iter_out_of_bounds.stderr
+++ b/src/tools/clippy/tests/ui/iter_out_of_bounds.stderr
@@ -12,7 +12,7 @@ LL | #![deny(clippy::iter_out_of_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:16:19
+  --> tests/ui/iter_out_of_bounds.rs:17:19
    |
 LL |     for (i, _) in [1, 2, 3].iter().take(4).enumerate() {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     for (i, _) in [1, 2, 3].iter().take(4).enumerate() {
    = note: this operation is useless and the returned iterator will simply yield the same items
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:22:14
+  --> tests/ui/iter_out_of_bounds.rs:24:14
    |
 LL |     for _ in (&&&&&&[1, 2, 3]).iter().take(4) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     for _ in (&&&&&&[1, 2, 3]).iter().take(4) {}
    = note: this operation is useless and the returned iterator will simply yield the same items
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:25:14
+  --> tests/ui/iter_out_of_bounds.rs:27:14
    |
 LL |     for _ in [1, 2, 3].iter().skip(4) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     for _ in [1, 2, 3].iter().skip(4) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:28:14
+  --> tests/ui/iter_out_of_bounds.rs:30:14
    |
 LL |     for _ in [1; 3].iter().skip(4) {}
    |              ^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     for _ in [1; 3].iter().skip(4) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:34:14
+  --> tests/ui/iter_out_of_bounds.rs:36:14
    |
 LL |     for _ in vec![1, 2, 3].iter().skip(4) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     for _ in vec![1, 2, 3].iter().skip(4) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:37:14
+  --> tests/ui/iter_out_of_bounds.rs:39:14
    |
 LL |     for _ in vec![1; 3].iter().skip(4) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL |     for _ in vec![1; 3].iter().skip(4) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:41:14
+  --> tests/ui/iter_out_of_bounds.rs:43:14
    |
 LL |     for _ in x.iter().skip(4) {}
    |              ^^^^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |     for _ in x.iter().skip(4) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:45:14
+  --> tests/ui/iter_out_of_bounds.rs:47:14
    |
 LL |     for _ in x.iter().skip(n) {}
    |              ^^^^^^^^^^^^^^^^
@@ -76,7 +76,7 @@ LL |     for _ in x.iter().skip(n) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:50:14
+  --> tests/ui/iter_out_of_bounds.rs:52:14
    |
 LL |     for _ in empty().skip(1) {}
    |              ^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL |     for _ in empty().skip(1) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:53:14
+  --> tests/ui/iter_out_of_bounds.rs:55:14
    |
 LL |     for _ in empty().take(1) {}
    |              ^^^^^^^^^^^^^^^
@@ -92,7 +92,7 @@ LL |     for _ in empty().take(1) {}
    = note: this operation is useless and the returned iterator will simply yield the same items
 
 error: this `.skip()` call skips more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:56:14
+  --> tests/ui/iter_out_of_bounds.rs:58:14
    |
 LL |     for _ in std::iter::once(1).skip(2) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     for _ in std::iter::once(1).skip(2) {}
    = note: this operation is useless and will create an empty iterator
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:59:14
+  --> tests/ui/iter_out_of_bounds.rs:61:14
    |
 LL |     for _ in std::iter::once(1).take(2) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL |     for _ in std::iter::once(1).take(2) {}
    = note: this operation is useless and the returned iterator will simply yield the same items
 
 error: this `.take()` call takes more items than the iterator will produce
-  --> tests/ui/iter_out_of_bounds.rs:62:14
+  --> tests/ui/iter_out_of_bounds.rs:64:14
    |
 LL |     for x in [].iter().take(1) {
    |              ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/iter_over_hash_type.rs b/src/tools/clippy/tests/ui/iter_over_hash_type.rs
index 65bae1df4218..914cc9df0de9 100644
--- a/src/tools/clippy/tests/ui/iter_over_hash_type.rs
+++ b/src/tools/clippy/tests/ui/iter_over_hash_type.rs
@@ -16,46 +16,59 @@ fn main() {
 
     // test hashset
     for x in &hash_set {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in hash_set.iter() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in hash_set.clone() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in hash_set.drain() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
 
     // test hashmap
     for (x, y) in &hash_map {
+        //~^ iter_over_hash_type
         let _ = (x, y);
     }
     for x in hash_map.keys() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in hash_map.values() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in hash_map.values_mut() {
+        //~^ iter_over_hash_type
         *x += 1;
     }
     for x in hash_map.iter() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in hash_map.clone() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in hash_map.drain() {
+        //~^ iter_over_hash_type
         let _ = x;
     }
 
     // test type-aliased hashers
     for x in fx_hash_set {
+        //~^ iter_over_hash_type
         let _ = x;
     }
     for x in fx_hash_map {
+        //~^ iter_over_hash_type
         let _ = x;
     }
 
diff --git a/src/tools/clippy/tests/ui/iter_over_hash_type.stderr b/src/tools/clippy/tests/ui/iter_over_hash_type.stderr
index 6afe69ee20e1..1bc6f4588d44 100644
--- a/src/tools/clippy/tests/ui/iter_over_hash_type.stderr
+++ b/src/tools/clippy/tests/ui/iter_over_hash_type.stderr
@@ -2,6 +2,7 @@ error: iteration over unordered hash-based type
   --> tests/ui/iter_over_hash_type.rs:18:5
    |
 LL | /     for x in &hash_set {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
@@ -10,97 +11,109 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::iter_over_hash_type)]`
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:21:5
+  --> tests/ui/iter_over_hash_type.rs:22:5
    |
 LL | /     for x in hash_set.iter() {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:24:5
+  --> tests/ui/iter_over_hash_type.rs:26:5
    |
 LL | /     for x in hash_set.clone() {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:27:5
+  --> tests/ui/iter_over_hash_type.rs:30:5
    |
 LL | /     for x in hash_set.drain() {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:32:5
+  --> tests/ui/iter_over_hash_type.rs:36:5
    |
 LL | /     for (x, y) in &hash_map {
+LL | |
 LL | |         let _ = (x, y);
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:35:5
+  --> tests/ui/iter_over_hash_type.rs:40:5
    |
 LL | /     for x in hash_map.keys() {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
-error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:38:5
-   |
-LL | /     for x in hash_map.values() {
-LL | |         let _ = x;
-LL | |     }
-   | |_____^
-
-error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:41:5
-   |
-LL | /     for x in hash_map.values_mut() {
-LL | |         *x += 1;
-LL | |     }
-   | |_____^
-
 error: iteration over unordered hash-based type
   --> tests/ui/iter_over_hash_type.rs:44:5
    |
-LL | /     for x in hash_map.iter() {
+LL | /     for x in hash_map.values() {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:47:5
+  --> tests/ui/iter_over_hash_type.rs:48:5
+   |
+LL | /     for x in hash_map.values_mut() {
+LL | |
+LL | |         *x += 1;
+LL | |     }
+   | |_____^
+
+error: iteration over unordered hash-based type
+  --> tests/ui/iter_over_hash_type.rs:52:5
+   |
+LL | /     for x in hash_map.iter() {
+LL | |
+LL | |         let _ = x;
+LL | |     }
+   | |_____^
+
+error: iteration over unordered hash-based type
+  --> tests/ui/iter_over_hash_type.rs:56:5
    |
 LL | /     for x in hash_map.clone() {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:50:5
+  --> tests/ui/iter_over_hash_type.rs:60:5
    |
 LL | /     for x in hash_map.drain() {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:55:5
+  --> tests/ui/iter_over_hash_type.rs:66:5
    |
 LL | /     for x in fx_hash_set {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
 
 error: iteration over unordered hash-based type
-  --> tests/ui/iter_over_hash_type.rs:58:5
+  --> tests/ui/iter_over_hash_type.rs:70:5
    |
 LL | /     for x in fx_hash_map {
+LL | |
 LL | |         let _ = x;
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/iter_overeager_cloned.fixed b/src/tools/clippy/tests/ui/iter_overeager_cloned.fixed
index d7d3d299349e..999912690290 100644
--- a/src/tools/clippy/tests/ui/iter_overeager_cloned.fixed
+++ b/src/tools/clippy/tests/ui/iter_overeager_cloned.fixed
@@ -10,36 +10,49 @@ fn main() {
     let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
 
     let _: Option<String> = vec.iter().last().cloned();
+    //~^ iter_overeager_cloned
 
     let _: Option<String> = vec.iter().chain(vec.iter()).next().cloned();
+    //~^ iter_overeager_cloned
 
     let _: usize = vec.iter().filter(|x| x == &"2").count();
+    //~^ redundant_clone
 
     let _: Vec<_> = vec.iter().take(2).cloned().collect();
+    //~^ iter_overeager_cloned
 
     let _: Vec<_> = vec.iter().skip(2).cloned().collect();
+    //~^ iter_overeager_cloned
 
     let _ = vec.iter().filter(|x| x == &"2").nth(2).cloned();
+    //~^ iter_overeager_cloned
 
     let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
+        //~^ iter_overeager_cloned
         .iter()
         .flatten().cloned();
 
     let _ = vec.iter().filter(|&x| x.starts_with('2')).cloned();
+    //~^ iter_overeager_cloned
 
     let _ = vec.iter().find(|&x| x == "2").cloned();
+    //~^ iter_overeager_cloned
 
     {
         let f = |x: &String| x.starts_with('2');
         let _ = vec.iter().filter(|&x| f(x)).cloned();
+        //~^ iter_overeager_cloned
         let _ = vec.iter().find(|&x| f(x)).cloned();
+        //~^ iter_overeager_cloned
     }
 
     {
         let vec: Vec<(String, String)> = vec![];
         let f = move |x: &(String, String)| x.0.starts_with('2');
         let _ = vec.iter().filter(|&x| f(x)).cloned();
+        //~^ iter_overeager_cloned
         let _ = vec.iter().find(|&x| f(x)).cloned();
+        //~^ iter_overeager_cloned
     }
 
     fn test_move<'a>(
@@ -47,6 +60,7 @@ fn main() {
         target: String,
     ) -> impl Iterator<Item = (&'a u32, String)> + 'a {
         iter.filter(move |&(&a, b)| a == 1 && b == &target).cloned()
+        //~^ iter_overeager_cloned
     }
 
     {
@@ -58,19 +72,24 @@ fn main() {
 
         fn bar<'a>(iter: impl Iterator<Item = &'a S<'a>> + 'a, target: String) -> impl Iterator<Item = S<'a>> + 'a {
             iter.filter(move |&S { a, b }| **a == 1 && b == &target).cloned()
+            //~^ iter_overeager_cloned
         }
     }
 
     let _ = vec.iter().map(|x| x.len());
+    //~^ redundant_clone
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
     let _ = vec.iter().for_each(|x| assert!(!x.is_empty()));
+    //~^ redundant_clone
 
     let _ = vec.iter().all(|x| x.len() == 1);
+    //~^ redundant_clone
 
     let _ = vec.iter().any(|x| x.len() == 1);
+    //~^ redundant_clone
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
diff --git a/src/tools/clippy/tests/ui/iter_overeager_cloned.rs b/src/tools/clippy/tests/ui/iter_overeager_cloned.rs
index 45e1349febd0..6a860dad5afd 100644
--- a/src/tools/clippy/tests/ui/iter_overeager_cloned.rs
+++ b/src/tools/clippy/tests/ui/iter_overeager_cloned.rs
@@ -10,37 +10,50 @@ fn main() {
     let vec = vec!["1".to_string(), "2".to_string(), "3".to_string()];
 
     let _: Option<String> = vec.iter().cloned().last();
+    //~^ iter_overeager_cloned
 
     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
+    //~^ iter_overeager_cloned
 
     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
+    //~^ redundant_clone
 
     let _: Vec<_> = vec.iter().cloned().take(2).collect();
+    //~^ iter_overeager_cloned
 
     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
+    //~^ iter_overeager_cloned
 
     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
+    //~^ iter_overeager_cloned
 
     let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
+        //~^ iter_overeager_cloned
         .iter()
         .cloned()
         .flatten();
 
     let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
+    //~^ iter_overeager_cloned
 
     let _ = vec.iter().cloned().find(|x| x == "2");
+    //~^ iter_overeager_cloned
 
     {
         let f = |x: &String| x.starts_with('2');
         let _ = vec.iter().cloned().filter(f);
+        //~^ iter_overeager_cloned
         let _ = vec.iter().cloned().find(f);
+        //~^ iter_overeager_cloned
     }
 
     {
         let vec: Vec<(String, String)> = vec![];
         let f = move |x: &(String, String)| x.0.starts_with('2');
         let _ = vec.iter().cloned().filter(f);
+        //~^ iter_overeager_cloned
         let _ = vec.iter().cloned().find(f);
+        //~^ iter_overeager_cloned
     }
 
     fn test_move<'a>(
@@ -48,6 +61,7 @@ fn main() {
         target: String,
     ) -> impl Iterator<Item = (&'a u32, String)> + 'a {
         iter.cloned().filter(move |(&a, b)| a == 1 && b == &target)
+        //~^ iter_overeager_cloned
     }
 
     {
@@ -59,19 +73,24 @@ fn main() {
 
         fn bar<'a>(iter: impl Iterator<Item = &'a S<'a>> + 'a, target: String) -> impl Iterator<Item = S<'a>> + 'a {
             iter.cloned().filter(move |S { a, b }| **a == 1 && b == &target)
+            //~^ iter_overeager_cloned
         }
     }
 
     let _ = vec.iter().cloned().map(|x| x.len());
+    //~^ redundant_clone
 
     // This would fail if changed.
     let _ = vec.iter().cloned().map(|x| x + "2");
 
     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
+    //~^ redundant_clone
 
     let _ = vec.iter().cloned().all(|x| x.len() == 1);
+    //~^ redundant_clone
 
     let _ = vec.iter().cloned().any(|x| x.len() == 1);
+    //~^ redundant_clone
 
     // Should probably stay as it is.
     let _ = [0, 1, 2, 3, 4].iter().cloned().take(10);
diff --git a/src/tools/clippy/tests/ui/iter_overeager_cloned.stderr b/src/tools/clippy/tests/ui/iter_overeager_cloned.stderr
index e6680266f107..f3239b59582e 100644
--- a/src/tools/clippy/tests/ui/iter_overeager_cloned.stderr
+++ b/src/tools/clippy/tests/ui/iter_overeager_cloned.stderr
@@ -10,7 +10,7 @@ LL |     let _: Option<String> = vec.iter().cloned().last();
    = help: to override `-D warnings` add `#[allow(clippy::iter_overeager_cloned)]`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:14:29
+  --> tests/ui/iter_overeager_cloned.rs:15:29
    |
 LL |     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------
@@ -18,7 +18,7 @@ LL |     let _: Option<String> = vec.iter().chain(vec.iter()).cloned().next();
    |                                                         help: try: `.next().cloned()`
 
 error: unneeded cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:16:20
+  --> tests/ui/iter_overeager_cloned.rs:18:20
    |
 LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------------
@@ -29,7 +29,7 @@ LL |     let _: usize = vec.iter().filter(|x| x == &"2").cloned().count();
    = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:18:21
+  --> tests/ui/iter_overeager_cloned.rs:21:21
    |
 LL |     let _: Vec<_> = vec.iter().cloned().take(2).collect();
    |                     ^^^^^^^^^^-----------------
@@ -37,7 +37,7 @@ LL |     let _: Vec<_> = vec.iter().cloned().take(2).collect();
    |                               help: try: `.take(2).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:20:21
+  --> tests/ui/iter_overeager_cloned.rs:24:21
    |
 LL |     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
    |                     ^^^^^^^^^^-----------------
@@ -45,7 +45,7 @@ LL |     let _: Vec<_> = vec.iter().cloned().skip(2).collect();
    |                               help: try: `.skip(2).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:22:13
+  --> tests/ui/iter_overeager_cloned.rs:27:13
    |
 LL |     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------
@@ -53,10 +53,11 @@ LL |     let _ = vec.iter().filter(|x| x == &"2").cloned().nth(2);
    |                                             help: try: `.nth(2).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:24:13
+  --> tests/ui/iter_overeager_cloned.rs:30:13
    |
 LL |       let _ = [Some(Some("str".to_string())), Some(Some("str".to_string()))]
    |  _____________^
+LL | |
 LL | |         .iter()
 LL | |         .cloned()
 LL | |         .flatten();
@@ -69,7 +70,7 @@ LL ~         .flatten().cloned();
    |
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:29:13
+  --> tests/ui/iter_overeager_cloned.rs:36:13
    |
 LL |     let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
    |             ^^^^^^^^^^----------------------------------------
@@ -77,7 +78,7 @@ LL |     let _ = vec.iter().cloned().filter(|x| x.starts_with('2'));
    |                       help: try: `.filter(|&x| x.starts_with('2')).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:31:13
+  --> tests/ui/iter_overeager_cloned.rs:39:13
    |
 LL |     let _ = vec.iter().cloned().find(|x| x == "2");
    |             ^^^^^^^^^^----------------------------
@@ -85,7 +86,7 @@ LL |     let _ = vec.iter().cloned().find(|x| x == "2");
    |                       help: try: `.find(|&x| x == "2").cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:35:17
+  --> tests/ui/iter_overeager_cloned.rs:44:17
    |
 LL |         let _ = vec.iter().cloned().filter(f);
    |                 ^^^^^^^^^^-------------------
@@ -93,7 +94,7 @@ LL |         let _ = vec.iter().cloned().filter(f);
    |                           help: try: `.filter(|&x| f(x)).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:36:17
+  --> tests/ui/iter_overeager_cloned.rs:46:17
    |
 LL |         let _ = vec.iter().cloned().find(f);
    |                 ^^^^^^^^^^-----------------
@@ -101,7 +102,7 @@ LL |         let _ = vec.iter().cloned().find(f);
    |                           help: try: `.find(|&x| f(x)).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:42:17
+  --> tests/ui/iter_overeager_cloned.rs:53:17
    |
 LL |         let _ = vec.iter().cloned().filter(f);
    |                 ^^^^^^^^^^-------------------
@@ -109,7 +110,7 @@ LL |         let _ = vec.iter().cloned().filter(f);
    |                           help: try: `.filter(|&x| f(x)).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:43:17
+  --> tests/ui/iter_overeager_cloned.rs:55:17
    |
 LL |         let _ = vec.iter().cloned().find(f);
    |                 ^^^^^^^^^^-----------------
@@ -117,7 +118,7 @@ LL |         let _ = vec.iter().cloned().find(f);
    |                           help: try: `.find(|&x| f(x)).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:50:9
+  --> tests/ui/iter_overeager_cloned.rs:63:9
    |
 LL |         iter.cloned().filter(move |(&a, b)| a == 1 && b == &target)
    |         ^^^^-------------------------------------------------------
@@ -125,7 +126,7 @@ LL |         iter.cloned().filter(move |(&a, b)| a == 1 && b == &target)
    |             help: try: `.filter(move |&(&a, b)| a == 1 && b == &target).cloned()`
 
 error: unnecessarily eager cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:61:13
+  --> tests/ui/iter_overeager_cloned.rs:75:13
    |
 LL |             iter.cloned().filter(move |S { a, b }| **a == 1 && b == &target)
    |             ^^^^------------------------------------------------------------
@@ -133,7 +134,7 @@ LL |             iter.cloned().filter(move |S { a, b }| **a == 1 && b == &target
    |                 help: try: `.filter(move |&S { a, b }| **a == 1 && b == &target).cloned()`
 
 error: unneeded cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:65:13
+  --> tests/ui/iter_overeager_cloned.rs:80:13
    |
 LL |     let _ = vec.iter().cloned().map(|x| x.len());
    |             ^^^^^^^^^^--------------------------
@@ -141,7 +142,7 @@ LL |     let _ = vec.iter().cloned().map(|x| x.len());
    |                       help: try: `.map(|x| x.len())`
 
 error: unneeded cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:70:13
+  --> tests/ui/iter_overeager_cloned.rs:86:13
    |
 LL |     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
    |             ^^^^^^^^^^----------------------------------------------
@@ -149,7 +150,7 @@ LL |     let _ = vec.iter().cloned().for_each(|x| assert!(!x.is_empty()));
    |                       help: try: `.for_each(|x| assert!(!x.is_empty()))`
 
 error: unneeded cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:72:13
+  --> tests/ui/iter_overeager_cloned.rs:89:13
    |
 LL |     let _ = vec.iter().cloned().all(|x| x.len() == 1);
    |             ^^^^^^^^^^-------------------------------
@@ -157,7 +158,7 @@ LL |     let _ = vec.iter().cloned().all(|x| x.len() == 1);
    |                       help: try: `.all(|x| x.len() == 1)`
 
 error: unneeded cloning of iterator items
-  --> tests/ui/iter_overeager_cloned.rs:74:13
+  --> tests/ui/iter_overeager_cloned.rs:92:13
    |
 LL |     let _ = vec.iter().cloned().any(|x| x.len() == 1);
    |             ^^^^^^^^^^-------------------------------
diff --git a/src/tools/clippy/tests/ui/iter_skip_next.fixed b/src/tools/clippy/tests/ui/iter_skip_next.fixed
index 3e41b3632490..1d6a07f2d828 100644
--- a/src/tools/clippy/tests/ui/iter_skip_next.fixed
+++ b/src/tools/clippy/tests/ui/iter_skip_next.fixed
@@ -15,9 +15,13 @@ use option_helpers::IteratorFalsePositives;
 fn main() {
     let some_vec = vec![0, 1, 2, 3];
     let _ = some_vec.iter().nth(42);
+    //~^ iter_skip_next
     let _ = some_vec.iter().cycle().nth(42);
+    //~^ iter_skip_next
     let _ = (1..10).nth(10);
+    //~^ iter_skip_next
     let _ = &some_vec[..].iter().nth(3);
+    //~^ iter_skip_next
     let foo = IteratorFalsePositives { foo: 0 };
     let _ = foo.skip(42).next();
     let _ = foo.filter().skip(42).next();
@@ -26,13 +30,16 @@ fn main() {
     let test_string = "1|1 2";
     let mut sp = test_string.split('|').map(|s| s.trim());
     let _: Vec<&str> = sp.nth(1).unwrap().split(' ').collect();
+    //~^ iter_skip_next
     if let Some(mut s) = Some(test_string.split('|').map(|s| s.trim())) {
         let _: Vec<&str> = s.nth(1).unwrap().split(' ').collect();
+        //~^ iter_skip_next
     };
     fn check<T>(mut s: T)
     where
         T: Iterator<Item = String>,
     {
         let _: Vec<&str> = s.nth(1).unwrap().split(' ').collect();
+        //~^ iter_skip_next
     }
 }
diff --git a/src/tools/clippy/tests/ui/iter_skip_next.rs b/src/tools/clippy/tests/ui/iter_skip_next.rs
index 6d96441ca96f..7570e17a0925 100644
--- a/src/tools/clippy/tests/ui/iter_skip_next.rs
+++ b/src/tools/clippy/tests/ui/iter_skip_next.rs
@@ -15,9 +15,13 @@ use option_helpers::IteratorFalsePositives;
 fn main() {
     let some_vec = vec![0, 1, 2, 3];
     let _ = some_vec.iter().skip(42).next();
+    //~^ iter_skip_next
     let _ = some_vec.iter().cycle().skip(42).next();
+    //~^ iter_skip_next
     let _ = (1..10).skip(10).next();
+    //~^ iter_skip_next
     let _ = &some_vec[..].iter().skip(3).next();
+    //~^ iter_skip_next
     let foo = IteratorFalsePositives { foo: 0 };
     let _ = foo.skip(42).next();
     let _ = foo.filter().skip(42).next();
@@ -26,13 +30,16 @@ fn main() {
     let test_string = "1|1 2";
     let mut sp = test_string.split('|').map(|s| s.trim());
     let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
+    //~^ iter_skip_next
     if let Some(mut s) = Some(test_string.split('|').map(|s| s.trim())) {
         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+        //~^ iter_skip_next
     };
     fn check<T>(mut s: T)
     where
         T: Iterator<Item = String>,
     {
         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
+        //~^ iter_skip_next
     }
 }
diff --git a/src/tools/clippy/tests/ui/iter_skip_next.stderr b/src/tools/clippy/tests/ui/iter_skip_next.stderr
index 0fa04465ff15..9f6d708c2f41 100644
--- a/src/tools/clippy/tests/ui/iter_skip_next.stderr
+++ b/src/tools/clippy/tests/ui/iter_skip_next.stderr
@@ -8,37 +8,37 @@ LL |     let _ = some_vec.iter().skip(42).next();
    = help: to override `-D warnings` add `#[allow(clippy::iter_skip_next)]`
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next.rs:18:36
+  --> tests/ui/iter_skip_next.rs:19:36
    |
 LL |     let _ = some_vec.iter().cycle().skip(42).next();
    |                                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(42)`
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next.rs:19:20
+  --> tests/ui/iter_skip_next.rs:21:20
    |
 LL |     let _ = (1..10).skip(10).next();
    |                    ^^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(10)`
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next.rs:20:33
+  --> tests/ui/iter_skip_next.rs:23:33
    |
 LL |     let _ = &some_vec[..].iter().skip(3).next();
    |                                 ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(3)`
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next.rs:28:26
+  --> tests/ui/iter_skip_next.rs:32:26
    |
 LL |     let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
    |                          ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next.rs:30:29
+  --> tests/ui/iter_skip_next.rs:35:29
    |
 LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
    |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next.rs:36:29
+  --> tests/ui/iter_skip_next.rs:42:29
    |
 LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
    |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
diff --git a/src/tools/clippy/tests/ui/iter_skip_next_unfixable.rs b/src/tools/clippy/tests/ui/iter_skip_next_unfixable.rs
index 6c98bdc8c880..3f855b54d12a 100644
--- a/src/tools/clippy/tests/ui/iter_skip_next_unfixable.rs
+++ b/src/tools/clippy/tests/ui/iter_skip_next_unfixable.rs
@@ -7,16 +7,17 @@ fn main() {
     let test_string = "1|1 2";
     let sp = test_string.split('|').map(|s| s.trim());
     let _: Vec<&str> = sp.skip(1).next().unwrap().split(' ').collect();
-    //~^ ERROR: called `skip(..).next()` on an iterator
+    //~^ iter_skip_next
+
     if let Some(s) = Some(test_string.split('|').map(|s| s.trim())) {
         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
-        //~^ ERROR: called `skip(..).next()` on an iterator
+        //~^ iter_skip_next
     };
     fn check<T>(s: T)
     where
         T: Iterator<Item = String>,
     {
         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
-        //~^ ERROR: called `skip(..).next()` on an iterator
+        //~^ iter_skip_next
     }
 }
diff --git a/src/tools/clippy/tests/ui/iter_skip_next_unfixable.stderr b/src/tools/clippy/tests/ui/iter_skip_next_unfixable.stderr
index 9bfffb07ca62..44c5c1f85442 100644
--- a/src/tools/clippy/tests/ui/iter_skip_next_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/iter_skip_next_unfixable.stderr
@@ -13,25 +13,25 @@ LL |     let sp = test_string.split('|').map(|s| s.trim());
    = help: to override `-D warnings` add `#[allow(clippy::iter_skip_next)]`
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next_unfixable.rs:12:29
+  --> tests/ui/iter_skip_next_unfixable.rs:13:29
    |
 LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
    |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
    |
 help: for this change `s` has to be mutable
-  --> tests/ui/iter_skip_next_unfixable.rs:11:17
+  --> tests/ui/iter_skip_next_unfixable.rs:12:17
    |
 LL |     if let Some(s) = Some(test_string.split('|').map(|s| s.trim())) {
    |                 ^
 
 error: called `skip(..).next()` on an iterator
-  --> tests/ui/iter_skip_next_unfixable.rs:19:29
+  --> tests/ui/iter_skip_next_unfixable.rs:20:29
    |
 LL |         let _: Vec<&str> = s.skip(1).next().unwrap().split(' ').collect();
    |                             ^^^^^^^^^^^^^^^ help: use `nth` instead: `.nth(1)`
    |
 help: for this change `s` has to be mutable
-  --> tests/ui/iter_skip_next_unfixable.rs:15:17
+  --> tests/ui/iter_skip_next_unfixable.rs:16:17
    |
 LL |     fn check<T>(s: T)
    |                 ^
diff --git a/src/tools/clippy/tests/ui/iter_skip_zero.fixed b/src/tools/clippy/tests/ui/iter_skip_zero.fixed
index 447d07100e95..498af9bb4ff6 100644
--- a/src/tools/clippy/tests/ui/iter_skip_zero.fixed
+++ b/src/tools/clippy/tests/ui/iter_skip_zero.fixed
@@ -9,9 +9,14 @@ use std::iter::once;
 
 fn main() {
     let _ = [1, 2, 3].iter().skip(1);
+    //~^ iter_skip_zero
     let _ = vec![1, 2, 3].iter().skip(1);
+    //~^ iter_skip_zero
     let _ = once([1, 2, 3]).skip(1);
+    //~^ iter_skip_zero
     let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(1)).skip(1);
+    //~^ iter_skip_zero
+    //~| iter_skip_zero
     // Don't lint
     let _ = [1, 2, 3].iter().skip(1);
     let _ = vec![1, 2, 3].iter().skip(1);
diff --git a/src/tools/clippy/tests/ui/iter_skip_zero.rs b/src/tools/clippy/tests/ui/iter_skip_zero.rs
index ba63c3981808..f168e9109953 100644
--- a/src/tools/clippy/tests/ui/iter_skip_zero.rs
+++ b/src/tools/clippy/tests/ui/iter_skip_zero.rs
@@ -9,9 +9,14 @@ use std::iter::once;
 
 fn main() {
     let _ = [1, 2, 3].iter().skip(0);
+    //~^ iter_skip_zero
     let _ = vec![1, 2, 3].iter().skip(0);
+    //~^ iter_skip_zero
     let _ = once([1, 2, 3]).skip(0);
+    //~^ iter_skip_zero
     let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(0)).skip(0);
+    //~^ iter_skip_zero
+    //~| iter_skip_zero
     // Don't lint
     let _ = [1, 2, 3].iter().skip(1);
     let _ = vec![1, 2, 3].iter().skip(1);
diff --git a/src/tools/clippy/tests/ui/iter_skip_zero.stderr b/src/tools/clippy/tests/ui/iter_skip_zero.stderr
index ef46db843377..235074374aa1 100644
--- a/src/tools/clippy/tests/ui/iter_skip_zero.stderr
+++ b/src/tools/clippy/tests/ui/iter_skip_zero.stderr
@@ -9,7 +9,7 @@ LL |     let _ = [1, 2, 3].iter().skip(0);
    = help: to override `-D warnings` add `#[allow(clippy::iter_skip_zero)]`
 
 error: usage of `.skip(0)`
-  --> tests/ui/iter_skip_zero.rs:12:39
+  --> tests/ui/iter_skip_zero.rs:13:39
    |
 LL |     let _ = vec![1, 2, 3].iter().skip(0);
    |                                       ^ help: if you meant to skip the first element, use: `1`
@@ -17,7 +17,7 @@ LL |     let _ = vec![1, 2, 3].iter().skip(0);
    = note: this call to `skip` does nothing and is useless; remove it
 
 error: usage of `.skip(0)`
-  --> tests/ui/iter_skip_zero.rs:13:34
+  --> tests/ui/iter_skip_zero.rs:15:34
    |
 LL |     let _ = once([1, 2, 3]).skip(0);
    |                                  ^ help: if you meant to skip the first element, use: `1`
@@ -25,7 +25,7 @@ LL |     let _ = once([1, 2, 3]).skip(0);
    = note: this call to `skip` does nothing and is useless; remove it
 
 error: usage of `.skip(0)`
-  --> tests/ui/iter_skip_zero.rs:14:71
+  --> tests/ui/iter_skip_zero.rs:17:71
    |
 LL |     let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(0)).skip(0);
    |                                                                       ^ help: if you meant to skip the first element, use: `1`
@@ -33,7 +33,7 @@ LL |     let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(0)).skip(0);
    = note: this call to `skip` does nothing and is useless; remove it
 
 error: usage of `.skip(0)`
-  --> tests/ui/iter_skip_zero.rs:14:62
+  --> tests/ui/iter_skip_zero.rs:17:62
    |
 LL |     let _ = vec![1, 2, 3].iter().chain([1, 2, 3].iter().skip(0)).skip(0);
    |                                                              ^ help: if you meant to skip the first element, use: `1`
diff --git a/src/tools/clippy/tests/ui/iter_with_drain.fixed b/src/tools/clippy/tests/ui/iter_with_drain.fixed
index a03efceed4ca..b0661ffb981b 100644
--- a/src/tools/clippy/tests/ui/iter_with_drain.fixed
+++ b/src/tools/clippy/tests/ui/iter_with_drain.fixed
@@ -8,20 +8,26 @@ use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 fn full() {
     let mut a = vec!["aaa".to_string(), "bbb".to_string()];
     let mut a: BinaryHeap<_> = a.into_iter().collect();
+    //~^ iter_with_drain
     let mut a: HashSet<_> = a.drain().collect();
     let mut a: VecDeque<_> = a.drain().collect();
     let mut a: Vec<_> = a.into_iter().collect();
+    //~^ iter_with_drain
     let mut a: HashMap<_, _> = a.into_iter().map(|x| (x.clone(), x)).collect();
+    //~^ iter_with_drain
     let _: Vec<(String, String)> = a.drain().collect();
 }
 
 fn closed() {
     let mut a = vec!["aaa".to_string(), "bbb".to_string()];
     let mut a: BinaryHeap<_> = a.into_iter().collect();
+    //~^ iter_with_drain
     let mut a: HashSet<_> = a.drain().collect();
     let mut a: VecDeque<_> = a.drain().collect();
     let mut a: Vec<_> = a.into_iter().collect();
+    //~^ iter_with_drain
     let mut a: HashMap<_, _> = a.into_iter().map(|x| (x.clone(), x)).collect();
+    //~^ iter_with_drain
     let _: Vec<(String, String)> = a.drain().collect();
 }
 
diff --git a/src/tools/clippy/tests/ui/iter_with_drain.rs b/src/tools/clippy/tests/ui/iter_with_drain.rs
index a8cd47f83d04..746b0f9a5eda 100644
--- a/src/tools/clippy/tests/ui/iter_with_drain.rs
+++ b/src/tools/clippy/tests/ui/iter_with_drain.rs
@@ -8,20 +8,26 @@ use std::collections::{BinaryHeap, HashMap, HashSet, VecDeque};
 fn full() {
     let mut a = vec!["aaa".to_string(), "bbb".to_string()];
     let mut a: BinaryHeap<_> = a.drain(..).collect();
+    //~^ iter_with_drain
     let mut a: HashSet<_> = a.drain().collect();
     let mut a: VecDeque<_> = a.drain().collect();
     let mut a: Vec<_> = a.drain(..).collect();
+    //~^ iter_with_drain
     let mut a: HashMap<_, _> = a.drain(..).map(|x| (x.clone(), x)).collect();
+    //~^ iter_with_drain
     let _: Vec<(String, String)> = a.drain().collect();
 }
 
 fn closed() {
     let mut a = vec!["aaa".to_string(), "bbb".to_string()];
     let mut a: BinaryHeap<_> = a.drain(0..).collect();
+    //~^ iter_with_drain
     let mut a: HashSet<_> = a.drain().collect();
     let mut a: VecDeque<_> = a.drain().collect();
     let mut a: Vec<_> = a.drain(..a.len()).collect();
+    //~^ iter_with_drain
     let mut a: HashMap<_, _> = a.drain(0..a.len()).map(|x| (x.clone(), x)).collect();
+    //~^ iter_with_drain
     let _: Vec<(String, String)> = a.drain().collect();
 }
 
diff --git a/src/tools/clippy/tests/ui/iter_with_drain.stderr b/src/tools/clippy/tests/ui/iter_with_drain.stderr
index 265e18c263be..370658961b9b 100644
--- a/src/tools/clippy/tests/ui/iter_with_drain.stderr
+++ b/src/tools/clippy/tests/ui/iter_with_drain.stderr
@@ -8,31 +8,31 @@ LL |     let mut a: BinaryHeap<_> = a.drain(..).collect();
    = help: to override `-D warnings` add `#[allow(clippy::iter_with_drain)]`
 
 error: `drain(..)` used on a `VecDeque`
-  --> tests/ui/iter_with_drain.rs:13:27
+  --> tests/ui/iter_with_drain.rs:14:27
    |
 LL |     let mut a: Vec<_> = a.drain(..).collect();
    |                           ^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `Vec`
-  --> tests/ui/iter_with_drain.rs:14:34
+  --> tests/ui/iter_with_drain.rs:16:34
    |
 LL |     let mut a: HashMap<_, _> = a.drain(..).map(|x| (x.clone(), x)).collect();
    |                                  ^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `Vec`
-  --> tests/ui/iter_with_drain.rs:20:34
+  --> tests/ui/iter_with_drain.rs:23:34
    |
 LL |     let mut a: BinaryHeap<_> = a.drain(0..).collect();
    |                                  ^^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `VecDeque`
-  --> tests/ui/iter_with_drain.rs:23:27
+  --> tests/ui/iter_with_drain.rs:27:27
    |
 LL |     let mut a: Vec<_> = a.drain(..a.len()).collect();
    |                           ^^^^^^^^^^^^^^^^ help: try: `into_iter()`
 
 error: `drain(..)` used on a `Vec`
-  --> tests/ui/iter_with_drain.rs:24:34
+  --> tests/ui/iter_with_drain.rs:29:34
    |
 LL |     let mut a: HashMap<_, _> = a.drain(0..a.len()).map(|x| (x.clone(), x)).collect();
    |                                  ^^^^^^^^^^^^^^^^^ help: try: `into_iter()`
diff --git a/src/tools/clippy/tests/ui/iter_without_into_iter.rs b/src/tools/clippy/tests/ui/iter_without_into_iter.rs
index d5b28e45453b..dc3149be2cb4 100644
--- a/src/tools/clippy/tests/ui/iter_without_into_iter.rs
+++ b/src/tools/clippy/tests/ui/iter_without_into_iter.rs
@@ -7,11 +7,11 @@ extern crate proc_macros;
 pub struct S1;
 impl S1 {
     pub fn iter(&self) -> std::slice::Iter<'_, u8> {
-        //~^ ERROR: `iter` method without an `IntoIterator` impl
+        //~^ iter_without_into_iter
         [].iter()
     }
     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
-        //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+        //~^ iter_without_into_iter
         [].iter_mut()
     }
 }
@@ -27,11 +27,11 @@ impl S2 {
 pub struct S3<'a>(&'a mut [u8]);
 impl<'a> S3<'a> {
     pub fn iter(&self) -> std::slice::Iter<'_, u8> {
-        //~^ ERROR: `iter` method without an `IntoIterator` impl
+        //~^ iter_without_into_iter
         self.0.iter()
     }
     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, u8> {
-        //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+        //~^ iter_without_into_iter
         self.0.iter_mut()
     }
 }
@@ -68,6 +68,7 @@ impl<T> S7<T> {
 pub struct S8<T>(T);
 impl<T> S8<T> {
     pub fn iter(&self) -> std::slice::Iter<'static, T> {
+        //~^ iter_without_into_iter
         todo!()
     }
 }
@@ -76,11 +77,11 @@ impl<T> S8<T> {
 pub struct S9<T>(T);
 impl<T> S9<T> {
     pub fn iter(&self) -> std::slice::Iter<'_, T> {
-        //~^ ERROR: `iter` method without an `IntoIterator` impl
+        //~^ iter_without_into_iter
         todo!()
     }
     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
-        //~^ ERROR: `iter_mut` method without an `IntoIterator` impl
+        //~^ iter_without_into_iter
         todo!()
     }
 }
@@ -129,6 +130,7 @@ macro_rules! generate_impl {
     () => {
         impl Issue12037 {
             fn iter(&self) -> std::slice::Iter<'_, u8> {
+                //~^ iter_without_into_iter
                 todo!()
             }
         }
diff --git a/src/tools/clippy/tests/ui/iter_without_into_iter.stderr b/src/tools/clippy/tests/ui/iter_without_into_iter.stderr
index d748c85003bb..8f86bee09670 100644
--- a/src/tools/clippy/tests/ui/iter_without_into_iter.stderr
+++ b/src/tools/clippy/tests/ui/iter_without_into_iter.stderr
@@ -88,6 +88,7 @@ error: `iter` method without an `IntoIterator` impl for `&S8<T>`
   --> tests/ui/iter_without_into_iter.rs:70:5
    |
 LL | /     pub fn iter(&self) -> std::slice::Iter<'static, T> {
+LL | |
 LL | |         todo!()
 LL | |     }
    | |_____^
@@ -105,7 +106,7 @@ LL + }
    |
 
 error: `iter` method without an `IntoIterator` impl for `&S9<T>`
-  --> tests/ui/iter_without_into_iter.rs:78:5
+  --> tests/ui/iter_without_into_iter.rs:79:5
    |
 LL | /     pub fn iter(&self) -> std::slice::Iter<'_, T> {
 LL | |
@@ -126,7 +127,7 @@ LL + }
    |
 
 error: `iter_mut` method without an `IntoIterator` impl for `&mut S9<T>`
-  --> tests/ui/iter_without_into_iter.rs:82:5
+  --> tests/ui/iter_without_into_iter.rs:83:5
    |
 LL | /     pub fn iter_mut(&mut self) -> std::slice::IterMut<'_, T> {
 LL | |
@@ -147,9 +148,10 @@ LL + }
    |
 
 error: `iter` method without an `IntoIterator` impl for `&Issue12037`
-  --> tests/ui/iter_without_into_iter.rs:131:13
+  --> tests/ui/iter_without_into_iter.rs:132:13
    |
 LL | /             fn iter(&self) -> std::slice::Iter<'_, u8> {
+LL | |
 LL | |                 todo!()
 LL | |             }
    | |_____________^
diff --git a/src/tools/clippy/tests/ui/iterator_step_by_zero.rs b/src/tools/clippy/tests/ui/iterator_step_by_zero.rs
index 0b51842df2e3..a729101bd403 100644
--- a/src/tools/clippy/tests/ui/iterator_step_by_zero.rs
+++ b/src/tools/clippy/tests/ui/iterator_step_by_zero.rs
@@ -2,12 +2,13 @@
 #[warn(clippy::iterator_step_by_zero)]
 fn main() {
     let _ = vec!["A", "B", "B"].iter().step_by(0);
-    //~^ ERROR: `Iterator::step_by(0)` will panic at runtime
-    //~| NOTE: `-D clippy::iterator-step-by-zero` implied by `-D warnings`
+    //~^ iterator_step_by_zero
+
     let _ = "XXX".chars().step_by(0);
-    //~^ ERROR: `Iterator::step_by(0)` will panic at runtime
+    //~^ iterator_step_by_zero
+
     let _ = (0..1).step_by(0);
-    //~^ ERROR: `Iterator::step_by(0)` will panic at runtime
+    //~^ iterator_step_by_zero
 
     // No error, not an iterator.
     let y = NotIterator;
@@ -17,18 +18,19 @@ fn main() {
     let _ = (0..1).step_by(1);
 
     let _ = (1..).step_by(0);
-    //~^ ERROR: `Iterator::step_by(0)` will panic at runtime
+    //~^ iterator_step_by_zero
+
     let _ = (1..=2).step_by(0);
-    //~^ ERROR: `Iterator::step_by(0)` will panic at runtime
+    //~^ iterator_step_by_zero
 
     let x = 0..1;
     let _ = x.step_by(0);
-    //~^ ERROR: `Iterator::step_by(0)` will panic at runtime
+    //~^ iterator_step_by_zero
 
     // check const eval
     let v1 = vec![1, 2, 3];
     let _ = v1.iter().step_by(2 / 3);
-    //~^ ERROR: `Iterator::step_by(0)` will panic at runtime
+    //~^ iterator_step_by_zero
 }
 
 struct NotIterator;
diff --git a/src/tools/clippy/tests/ui/iterator_step_by_zero.stderr b/src/tools/clippy/tests/ui/iterator_step_by_zero.stderr
index 4156642d6dbb..0ff916b6dd5e 100644
--- a/src/tools/clippy/tests/ui/iterator_step_by_zero.stderr
+++ b/src/tools/clippy/tests/ui/iterator_step_by_zero.stderr
@@ -14,31 +14,31 @@ LL |     let _ = "XXX".chars().step_by(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `Iterator::step_by(0)` will panic at runtime
-  --> tests/ui/iterator_step_by_zero.rs:9:13
+  --> tests/ui/iterator_step_by_zero.rs:10:13
    |
 LL |     let _ = (0..1).step_by(0);
    |             ^^^^^^^^^^^^^^^^^
 
 error: `Iterator::step_by(0)` will panic at runtime
-  --> tests/ui/iterator_step_by_zero.rs:19:13
+  --> tests/ui/iterator_step_by_zero.rs:20:13
    |
 LL |     let _ = (1..).step_by(0);
    |             ^^^^^^^^^^^^^^^^
 
 error: `Iterator::step_by(0)` will panic at runtime
-  --> tests/ui/iterator_step_by_zero.rs:21:13
+  --> tests/ui/iterator_step_by_zero.rs:23:13
    |
 LL |     let _ = (1..=2).step_by(0);
    |             ^^^^^^^^^^^^^^^^^^
 
 error: `Iterator::step_by(0)` will panic at runtime
-  --> tests/ui/iterator_step_by_zero.rs:25:13
+  --> tests/ui/iterator_step_by_zero.rs:27:13
    |
 LL |     let _ = x.step_by(0);
    |             ^^^^^^^^^^^^
 
 error: `Iterator::step_by(0)` will panic at runtime
-  --> tests/ui/iterator_step_by_zero.rs:30:13
+  --> tests/ui/iterator_step_by_zero.rs:32:13
    |
 LL |     let _ = v1.iter().step_by(2 / 3);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/join_absolute_paths.rs b/src/tools/clippy/tests/ui/join_absolute_paths.rs
index efa77a0492e6..144c9147c2a1 100644
--- a/src/tools/clippy/tests/ui/join_absolute_paths.rs
+++ b/src/tools/clippy/tests/ui/join_absolute_paths.rs
@@ -8,19 +8,19 @@ use std::path::{Path, PathBuf};
 fn main() {
     let path = Path::new("/bin");
     path.join("/sh");
-    //~^ ERROR: argument to `Path::join` starts with a path separator
+    //~^ join_absolute_paths
 
     let path = Path::new("C:\\Users");
     path.join("\\user");
-    //~^ ERROR: argument to `Path::join` starts with a path separator
+    //~^ join_absolute_paths
 
     let path = PathBuf::from("/bin");
     path.join("/sh");
-    //~^ ERROR: argument to `Path::join` starts with a path separator
+    //~^ join_absolute_paths
 
     let path = PathBuf::from("/bin");
     path.join(r#"/sh"#);
-    //~^ ERROR: argument to `Path::join` starts with a path separator
+    //~^ join_absolute_paths
 
     let path: &[&str] = &["/bin"];
     path.join("/sh");
diff --git a/src/tools/clippy/tests/ui/large_const_arrays.fixed b/src/tools/clippy/tests/ui/large_const_arrays.fixed
index e5b28cb6a9dd..7c3868fc8ffd 100644
--- a/src/tools/clippy/tests/ui/large_const_arrays.fixed
+++ b/src/tools/clippy/tests/ui/large_const_arrays.fixed
@@ -8,9 +8,13 @@ pub struct S {
 
 // Should lint
 pub(crate) static FOO_PUB_CRATE: [u32; 1_000_000] = [0u32; 1_000_000];
+//~^ large_const_arrays
 pub static FOO_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
+//~^ large_const_arrays
 static FOO_COMPUTED: [u32; 1_000 * 100] = [0u32; 1_000 * 100];
+//~^ large_const_arrays
 static FOO: [u32; 1_000_000] = [0u32; 1_000_000];
+//~^ large_const_arrays
 
 // Good
 pub(crate) const G_FOO_PUB_CRATE: [u32; 250] = [0u32; 250];
@@ -21,11 +25,17 @@ const G_FOO: [u32; 250] = [0u32; 250];
 fn main() {
     // Should lint
     pub static BAR_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
+    //~^ large_const_arrays
     static BAR: [u32; 1_000_000] = [0u32; 1_000_000];
+    //~^ large_const_arrays
     pub static BAR_STRUCT_PUB: [S; 5_000] = [S { data: [0; 32] }; 5_000];
+    //~^ large_const_arrays
     static BAR_STRUCT: [S; 5_000] = [S { data: [0; 32] }; 5_000];
+    //~^ large_const_arrays
     pub static BAR_S_PUB: [Option<&str>; 200_000] = [Some("str"); 200_000];
+    //~^ large_const_arrays
     static BAR_S: [Option<&str>; 200_000] = [Some("str"); 200_000];
+    //~^ large_const_arrays
 
     // Good
     pub const G_BAR_PUB: [u32; 250] = [0u32; 250];
diff --git a/src/tools/clippy/tests/ui/large_const_arrays.rs b/src/tools/clippy/tests/ui/large_const_arrays.rs
index b9593225da2f..3e811520f063 100644
--- a/src/tools/clippy/tests/ui/large_const_arrays.rs
+++ b/src/tools/clippy/tests/ui/large_const_arrays.rs
@@ -8,9 +8,13 @@ pub struct S {
 
 // Should lint
 pub(crate) const FOO_PUB_CRATE: [u32; 1_000_000] = [0u32; 1_000_000];
+//~^ large_const_arrays
 pub const FOO_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
+//~^ large_const_arrays
 const FOO_COMPUTED: [u32; 1_000 * 100] = [0u32; 1_000 * 100];
+//~^ large_const_arrays
 const FOO: [u32; 1_000_000] = [0u32; 1_000_000];
+//~^ large_const_arrays
 
 // Good
 pub(crate) const G_FOO_PUB_CRATE: [u32; 250] = [0u32; 250];
@@ -21,11 +25,17 @@ const G_FOO: [u32; 250] = [0u32; 250];
 fn main() {
     // Should lint
     pub const BAR_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
+    //~^ large_const_arrays
     const BAR: [u32; 1_000_000] = [0u32; 1_000_000];
+    //~^ large_const_arrays
     pub const BAR_STRUCT_PUB: [S; 5_000] = [S { data: [0; 32] }; 5_000];
+    //~^ large_const_arrays
     const BAR_STRUCT: [S; 5_000] = [S { data: [0; 32] }; 5_000];
+    //~^ large_const_arrays
     pub const BAR_S_PUB: [Option<&str>; 200_000] = [Some("str"); 200_000];
+    //~^ large_const_arrays
     const BAR_S: [Option<&str>; 200_000] = [Some("str"); 200_000];
+    //~^ large_const_arrays
 
     // Good
     pub const G_BAR_PUB: [u32; 250] = [0u32; 250];
diff --git a/src/tools/clippy/tests/ui/large_const_arrays.stderr b/src/tools/clippy/tests/ui/large_const_arrays.stderr
index 271122053908..56cddeaf628d 100644
--- a/src/tools/clippy/tests/ui/large_const_arrays.stderr
+++ b/src/tools/clippy/tests/ui/large_const_arrays.stderr
@@ -10,7 +10,7 @@ LL | pub(crate) const FOO_PUB_CRATE: [u32; 1_000_000] = [0u32; 1_000_000];
    = help: to override `-D warnings` add `#[allow(clippy::large_const_arrays)]`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:11:1
+  --> tests/ui/large_const_arrays.rs:12:1
    |
 LL | pub const FOO_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
    | ^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -18,7 +18,7 @@ LL | pub const FOO_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
    |     help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:12:1
+  --> tests/ui/large_const_arrays.rs:14:1
    |
 LL | const FOO_COMPUTED: [u32; 1_000 * 100] = [0u32; 1_000 * 100];
    | -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -26,7 +26,7 @@ LL | const FOO_COMPUTED: [u32; 1_000 * 100] = [0u32; 1_000 * 100];
    | help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:13:1
+  --> tests/ui/large_const_arrays.rs:16:1
    |
 LL | const FOO: [u32; 1_000_000] = [0u32; 1_000_000];
    | -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL | const FOO: [u32; 1_000_000] = [0u32; 1_000_000];
    | help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:23:5
+  --> tests/ui/large_const_arrays.rs:27:5
    |
 LL |     pub const BAR_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
    |     ^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -42,7 +42,7 @@ LL |     pub const BAR_PUB: [u32; 1_000_000] = [0u32; 1_000_000];
    |         help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:24:5
+  --> tests/ui/large_const_arrays.rs:29:5
    |
 LL |     const BAR: [u32; 1_000_000] = [0u32; 1_000_000];
    |     -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -50,7 +50,7 @@ LL |     const BAR: [u32; 1_000_000] = [0u32; 1_000_000];
    |     help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:25:5
+  --> tests/ui/large_const_arrays.rs:31:5
    |
 LL |     pub const BAR_STRUCT_PUB: [S; 5_000] = [S { data: [0; 32] }; 5_000];
    |     ^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -58,7 +58,7 @@ LL |     pub const BAR_STRUCT_PUB: [S; 5_000] = [S { data: [0; 32] }; 5_000];
    |         help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:26:5
+  --> tests/ui/large_const_arrays.rs:33:5
    |
 LL |     const BAR_STRUCT: [S; 5_000] = [S { data: [0; 32] }; 5_000];
    |     -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     const BAR_STRUCT: [S; 5_000] = [S { data: [0; 32] }; 5_000];
    |     help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:27:5
+  --> tests/ui/large_const_arrays.rs:35:5
    |
 LL |     pub const BAR_S_PUB: [Option<&str>; 200_000] = [Some("str"); 200_000];
    |     ^^^^-----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL |     pub const BAR_S_PUB: [Option<&str>; 200_000] = [Some("str"); 200_000];
    |         help: make this a static item: `static`
 
 error: large array defined as const
-  --> tests/ui/large_const_arrays.rs:28:5
+  --> tests/ui/large_const_arrays.rs:37:5
    |
 LL |     const BAR_S: [Option<&str>; 200_000] = [Some("str"); 200_000];
    |     -----^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/large_digit_groups.fixed b/src/tools/clippy/tests/ui/large_digit_groups.fixed
index cdb001e47e2b..0ad2ebf522b8 100644
--- a/src/tools/clippy/tests/ui/large_digit_groups.fixed
+++ b/src/tools/clippy/tests/ui/large_digit_groups.fixed
@@ -20,10 +20,15 @@ fn main() {
     let _bad = (
         0b1_10110_i64,
         0xdead_beef_usize,
+        //~^ unusual_byte_groupings
         123_456_f32,
+        //~^ large_digit_groups
         123_456.12_f32,
+        //~^ large_digit_groups
         123_456.123_45_f64,
+        //~^ large_digit_groups
         123_456.123_456_f64,
+        //~^ large_digit_groups
     );
     // Ignore literals in macros
     let _ = mac!();
diff --git a/src/tools/clippy/tests/ui/large_digit_groups.rs b/src/tools/clippy/tests/ui/large_digit_groups.rs
index 3c30c8670284..1cf489fd69b2 100644
--- a/src/tools/clippy/tests/ui/large_digit_groups.rs
+++ b/src/tools/clippy/tests/ui/large_digit_groups.rs
@@ -20,10 +20,15 @@ fn main() {
     let _bad = (
         0b1_10110_i64,
         0xd_e_adbee_f_usize,
+        //~^ unusual_byte_groupings
         1_23456_f32,
+        //~^ large_digit_groups
         1_23456.12_f32,
+        //~^ large_digit_groups
         1_23456.12345_f64,
+        //~^ large_digit_groups
         1_23456.12345_6_f64,
+        //~^ large_digit_groups
     );
     // Ignore literals in macros
     let _ = mac!();
diff --git a/src/tools/clippy/tests/ui/large_digit_groups.stderr b/src/tools/clippy/tests/ui/large_digit_groups.stderr
index da34a91bc3bc..281a6267c8d6 100644
--- a/src/tools/clippy/tests/ui/large_digit_groups.stderr
+++ b/src/tools/clippy/tests/ui/large_digit_groups.stderr
@@ -8,7 +8,7 @@ LL |         0xd_e_adbee_f_usize,
    = help: to override `-D warnings` add `#[allow(clippy::unusual_byte_groupings)]`
 
 error: digit groups should be smaller
-  --> tests/ui/large_digit_groups.rs:23:9
+  --> tests/ui/large_digit_groups.rs:24:9
    |
 LL |         1_23456_f32,
    |         ^^^^^^^^^^^ help: consider: `123_456_f32`
@@ -17,19 +17,19 @@ LL |         1_23456_f32,
    = help: to override `-D warnings` add `#[allow(clippy::large_digit_groups)]`
 
 error: digit groups should be smaller
-  --> tests/ui/large_digit_groups.rs:24:9
+  --> tests/ui/large_digit_groups.rs:26:9
    |
 LL |         1_23456.12_f32,
    |         ^^^^^^^^^^^^^^ help: consider: `123_456.12_f32`
 
 error: digit groups should be smaller
-  --> tests/ui/large_digit_groups.rs:25:9
+  --> tests/ui/large_digit_groups.rs:28:9
    |
 LL |         1_23456.12345_f64,
    |         ^^^^^^^^^^^^^^^^^ help: consider: `123_456.123_45_f64`
 
 error: digit groups should be smaller
-  --> tests/ui/large_digit_groups.rs:26:9
+  --> tests/ui/large_digit_groups.rs:30:9
    |
 LL |         1_23456.12345_6_f64,
    |         ^^^^^^^^^^^^^^^^^^^ help: consider: `123_456.123_456_f64`
diff --git a/src/tools/clippy/tests/ui/large_enum_variant.32bit.stderr b/src/tools/clippy/tests/ui/large_enum_variant.32bit.stderr
index ff4f1a7f312c..80ca5daa1d57 100644
--- a/src/tools/clippy/tests/ui/large_enum_variant.32bit.stderr
+++ b/src/tools/clippy/tests/ui/large_enum_variant.32bit.stderr
@@ -1,7 +1,8 @@
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:11:1
+  --> tests/ui/large_enum_variant.rs:13:1
    |
 LL | / enum LargeEnum {
+LL | |
 LL | |     A(i32),
    | |     ------ the second-largest variant contains at least 4 bytes
 LL | |     B([i32; 8000]),
@@ -13,13 +14,15 @@ LL | | }
    = help: to override `-D warnings` add `#[allow(clippy::large_enum_variant)]`
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     B(Box<[i32; 8000]>),
-   |       ~~~~~~~~~~~~~~~~
+LL -     B([i32; 8000]),
+LL +     B(Box<[i32; 8000]>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:35:1
+  --> tests/ui/large_enum_variant.rs:38:1
    |
 LL | / enum LargeEnum2 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     ContainingLargeEnum(LargeEnum),
@@ -29,13 +32,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     ContainingLargeEnum(Box<LargeEnum>),
-   |                         ~~~~~~~~~~~~~~
+LL -     ContainingLargeEnum(LargeEnum),
+LL +     ContainingLargeEnum(Box<LargeEnum>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:40:1
+  --> tests/ui/large_enum_variant.rs:44:1
    |
 LL | / enum LargeEnum3 {
+LL | |
 LL | |     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
    | |     --------------------------------------------------------- the largest variant contains at least 70004 bytes
 LL | |     VoidVariant,
@@ -46,13 +51,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
-   |                                     ~~~~~~~~~~~~~~~~  ~~~~~~~~~~~~~~~~
+LL -     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
+LL +     ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:46:1
+  --> tests/ui/large_enum_variant.rs:51:1
    |
 LL | / enum LargeEnum4 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     StructLikeLarge { x: [i32; 8000], y: i32 },
@@ -62,13 +69,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
-   |                          ~~~~~~~~~~~~~~~~
+LL -     StructLikeLarge { x: [i32; 8000], y: i32 },
+LL +     StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:51:1
+  --> tests/ui/large_enum_variant.rs:57:1
    |
 LL | / enum LargeEnum5 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     StructLikeLarge2 { x: [i32; 8000] },
@@ -78,13 +87,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     StructLikeLarge2 { x: Box<[i32; 8000]> },
-   |                           ~~~~~~~~~~~~~~~~
+LL -     StructLikeLarge2 { x: [i32; 8000] },
+LL +     StructLikeLarge2 { x: Box<[i32; 8000]> },
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:67:1
+  --> tests/ui/large_enum_variant.rs:74:1
    |
 LL | / enum LargeEnum7 {
+LL | |
 LL | |     A,
 LL | |     B([u8; 1255]),
    | |     ------------- the largest variant contains at least 1255 bytes
@@ -95,13 +106,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     B(Box<[u8; 1255]>),
-   |       ~~~~~~~~~~~~~~~
+LL -     B([u8; 1255]),
+LL +     B(Box<[u8; 1255]>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:73:1
+  --> tests/ui/large_enum_variant.rs:81:1
    |
 LL | / enum LargeEnum8 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
@@ -111,13 +124,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>, [i32; 30]),
-   |                                ~~~~~~~~~~~~~~~~            ~~~~~~~~~~~~~~~~
+LL -     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
+LL +     ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>, [i32; 30]),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:78:1
+  --> tests/ui/large_enum_variant.rs:87:1
    |
 LL | / enum LargeEnum9 {
+LL | |
 LL | |     A(Struct<()>),
    | |     ------------- the second-largest variant contains at least 4 bytes
 LL | |     B(Struct2),
@@ -127,13 +142,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     B(Box<Struct2>),
-   |       ~~~~~~~~~~~~
+LL -     B(Struct2),
+LL +     B(Box<Struct2>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:83:1
+  --> tests/ui/large_enum_variant.rs:93:1
    |
 LL | / enum LargeEnumOk2<T> {
+LL | |
 LL | |     A(T),
    | |     ---- the second-largest variant contains at least 0 bytes
 LL | |     B(Struct2),
@@ -143,13 +160,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     B(Box<Struct2>),
-   |       ~~~~~~~~~~~~
+LL -     B(Struct2),
+LL +     B(Box<Struct2>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:88:1
+  --> tests/ui/large_enum_variant.rs:99:1
    |
 LL | / enum LargeEnumOk3<T> {
+LL | |
 LL | |     A(Struct<T>),
    | |     ------------ the second-largest variant contains at least 4 bytes
 LL | |     B(Struct2),
@@ -159,13 +178,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     B(Box<Struct2>),
-   |       ~~~~~~~~~~~~
+LL -     B(Struct2),
+LL +     B(Box<Struct2>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:103:1
+  --> tests/ui/large_enum_variant.rs:115:1
    |
 LL | / enum CopyableLargeEnum {
+LL | |
 LL | |     A(bool),
    | |     ------- the second-largest variant contains at least 1 bytes
 LL | |     B([u64; 8000]),
@@ -174,34 +195,12 @@ LL | | }
    | |_^ the entire enum is at least 64004 bytes
    |
 note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:103:6
+  --> tests/ui/large_enum_variant.rs:115:6
    |
 LL | enum CopyableLargeEnum {
    |      ^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:105:5
-   |
-LL |     B([u64; 8000]),
-   |     ^^^^^^^^^^^^^^
-
-error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:108:1
-   |
-LL | / enum ManuallyCopyLargeEnum {
-LL | |     A(bool),
-   | |     ------- the second-largest variant contains at least 1 bytes
-LL | |     B([u64; 8000]),
-   | |     -------------- the largest variant contains at least 64000 bytes
-LL | | }
-   | |_^ the entire enum is at least 64004 bytes
-   |
-note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:108:6
-   |
-LL | enum ManuallyCopyLargeEnum {
-   |      ^^^^^^^^^^^^^^^^^^^^^
-help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:110:5
+  --> tests/ui/large_enum_variant.rs:118:5
    |
 LL |     B([u64; 8000]),
    |     ^^^^^^^^^^^^^^
@@ -209,7 +208,31 @@ LL |     B([u64; 8000]),
 error: large size difference between variants
   --> tests/ui/large_enum_variant.rs:121:1
    |
+LL | / enum ManuallyCopyLargeEnum {
+LL | |
+LL | |     A(bool),
+   | |     ------- the second-largest variant contains at least 1 bytes
+LL | |     B([u64; 8000]),
+   | |     -------------- the largest variant contains at least 64000 bytes
+LL | | }
+   | |_^ the entire enum is at least 64004 bytes
+   |
+note: boxing a variant would require the type no longer be `Copy`
+  --> tests/ui/large_enum_variant.rs:121:6
+   |
+LL | enum ManuallyCopyLargeEnum {
+   |      ^^^^^^^^^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+  --> tests/ui/large_enum_variant.rs:124:5
+   |
+LL |     B([u64; 8000]),
+   |     ^^^^^^^^^^^^^^
+
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:135:1
+   |
 LL | / enum SomeGenericPossiblyCopyEnum<T> {
+LL | |
 LL | |     A(bool, std::marker::PhantomData<T>),
    | |     ------------------------------------ the second-largest variant contains at least 1 bytes
 LL | |     B([u64; 4000]),
@@ -218,20 +241,21 @@ LL | | }
    | |_^ the entire enum is at least 32004 bytes
    |
 note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:121:6
+  --> tests/ui/large_enum_variant.rs:135:6
    |
 LL | enum SomeGenericPossiblyCopyEnum<T> {
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:123:5
+  --> tests/ui/large_enum_variant.rs:138:5
    |
 LL |     B([u64; 4000]),
    |     ^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:134:1
+  --> tests/ui/large_enum_variant.rs:149:1
    |
 LL | / enum LargeEnumWithGenerics<T> {
+LL | |
 LL | |     Small,
    | |     ----- the second-largest variant carries no data at all
 LL | |     Large((T, [u8; 512])),
@@ -241,13 +265,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     Large(Box<(T, [u8; 512])>),
-   |           ~~~~~~~~~~~~~~~~~~~
+LL -     Large((T, [u8; 512])),
+LL +     Large(Box<(T, [u8; 512])>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:143:1
+  --> tests/ui/large_enum_variant.rs:159:1
    |
 LL | / enum WithGenerics {
+LL | |
 LL | |     Large([Foo<u64>; 64]),
    | |     --------------------- the largest variant contains at least 512 bytes
 LL | |     Small(u8),
@@ -257,13 +283,15 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     Large(Box<[Foo<u64>; 64]>),
-   |           ~~~~~~~~~~~~~~~~~~~
+LL -     Large([Foo<u64>; 64]),
+LL +     Large(Box<[Foo<u64>; 64]>),
+   |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:153:1
+  --> tests/ui/large_enum_variant.rs:170:1
    |
 LL | / enum LargeEnumOfConst {
+LL | |
 LL | |     Ok,
    | |     -- the second-largest variant carries no data at all
 LL | |     Error(PossiblyLargeEnumWithConst<256>),
@@ -273,8 +301,45 @@ LL | | }
    |
 help: consider boxing the large fields to reduce the total size of the enum
    |
-LL |     Error(Box<PossiblyLargeEnumWithConst<256>>),
-   |           ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+LL -     Error(PossiblyLargeEnumWithConst<256>),
+LL +     Error(Box<PossiblyLargeEnumWithConst<256>>),
+   |
 
-error: aborting due to 16 previous errors
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:176:1
+   |
+LL | / enum WithRecursion {
+LL | |
+LL | |     Large([u64; 64]),
+   | |     ---------------- the largest variant contains at least 512 bytes
+LL | |     Recursive(Box<WithRecursion>),
+   | |     ----------------------------- the second-largest variant contains at least 4 bytes
+LL | | }
+   | |_^ the entire enum is at least 516 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL -     Large([u64; 64]),
+LL +     Large(Box<[u64; 64]>),
+   |
+
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:187:1
+   |
+LL | / enum LargeEnumWithGenericsAndRecursive {
+LL | |
+LL | |     Ok(),
+   | |     ---- the second-largest variant carries no data at all
+LL | |     Error(WithRecursionAndGenerics<u64>),
+   | |     ------------------------------------ the largest variant contains at least 516 bytes
+LL | | }
+   | |_^ the entire enum is at least 516 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL -     Error(WithRecursionAndGenerics<u64>),
+LL +     Error(Box<WithRecursionAndGenerics<u64>>),
+   |
+
+error: aborting due to 18 previous errors
 
diff --git a/src/tools/clippy/tests/ui/large_enum_variant.64bit.stderr b/src/tools/clippy/tests/ui/large_enum_variant.64bit.stderr
index 60653b4abfb5..559bdf2a2f50 100644
--- a/src/tools/clippy/tests/ui/large_enum_variant.64bit.stderr
+++ b/src/tools/clippy/tests/ui/large_enum_variant.64bit.stderr
@@ -1,7 +1,8 @@
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:11:1
+  --> tests/ui/large_enum_variant.rs:13:1
    |
 LL | / enum LargeEnum {
+LL | |
 LL | |     A(i32),
    | |     ------ the second-largest variant contains at least 4 bytes
 LL | |     B([i32; 8000]),
@@ -18,9 +19,10 @@ LL +     B(Box<[i32; 8000]>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:35:1
+  --> tests/ui/large_enum_variant.rs:38:1
    |
 LL | / enum LargeEnum2 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     ContainingLargeEnum(LargeEnum),
@@ -35,9 +37,10 @@ LL +     ContainingLargeEnum(Box<LargeEnum>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:40:1
+  --> tests/ui/large_enum_variant.rs:44:1
    |
 LL | / enum LargeEnum3 {
+LL | |
 LL | |     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
    | |     --------------------------------------------------------- the largest variant contains at least 70004 bytes
 LL | |     VoidVariant,
@@ -53,9 +56,10 @@ LL +     ContainingMoreThanOneField(i32, Box<[i32; 8000]>, Box<[i32; 9500]>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:46:1
+  --> tests/ui/large_enum_variant.rs:51:1
    |
 LL | / enum LargeEnum4 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     StructLikeLarge { x: [i32; 8000], y: i32 },
@@ -70,9 +74,10 @@ LL +     StructLikeLarge { x: Box<[i32; 8000]>, y: i32 },
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:51:1
+  --> tests/ui/large_enum_variant.rs:57:1
    |
 LL | / enum LargeEnum5 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     StructLikeLarge2 { x: [i32; 8000] },
@@ -87,9 +92,10 @@ LL +     StructLikeLarge2 { x: Box<[i32; 8000]> },
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:67:1
+  --> tests/ui/large_enum_variant.rs:74:1
    |
 LL | / enum LargeEnum7 {
+LL | |
 LL | |     A,
 LL | |     B([u8; 1255]),
    | |     ------------- the largest variant contains at least 1255 bytes
@@ -105,9 +111,10 @@ LL +     B(Box<[u8; 1255]>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:73:1
+  --> tests/ui/large_enum_variant.rs:81:1
    |
 LL | / enum LargeEnum8 {
+LL | |
 LL | |     VariantOk(i32, u32),
    | |     ------------------- the second-largest variant contains at least 8 bytes
 LL | |     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
@@ -122,9 +129,10 @@ LL +     ContainingMoreThanOneField(Box<[i32; 8000]>, [i32; 2], Box<[i32; 9500]>
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:78:1
+  --> tests/ui/large_enum_variant.rs:87:1
    |
 LL | / enum LargeEnum9 {
+LL | |
 LL | |     A(Struct<()>),
    | |     ------------- the second-largest variant contains at least 4 bytes
 LL | |     B(Struct2),
@@ -139,9 +147,10 @@ LL +     B(Box<Struct2>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:83:1
+  --> tests/ui/large_enum_variant.rs:93:1
    |
 LL | / enum LargeEnumOk2<T> {
+LL | |
 LL | |     A(T),
    | |     ---- the second-largest variant contains at least 0 bytes
 LL | |     B(Struct2),
@@ -156,9 +165,10 @@ LL +     B(Box<Struct2>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:88:1
+  --> tests/ui/large_enum_variant.rs:99:1
    |
 LL | / enum LargeEnumOk3<T> {
+LL | |
 LL | |     A(Struct<T>),
    | |     ------------ the second-largest variant contains at least 4 bytes
 LL | |     B(Struct2),
@@ -173,9 +183,10 @@ LL +     B(Box<Struct2>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:103:1
+  --> tests/ui/large_enum_variant.rs:115:1
    |
 LL | / enum CopyableLargeEnum {
+LL | |
 LL | |     A(bool),
    | |     ------- the second-largest variant contains at least 1 bytes
 LL | |     B([u64; 8000]),
@@ -184,34 +195,12 @@ LL | | }
    | |_^ the entire enum is at least 64008 bytes
    |
 note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:103:6
+  --> tests/ui/large_enum_variant.rs:115:6
    |
 LL | enum CopyableLargeEnum {
    |      ^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:105:5
-   |
-LL |     B([u64; 8000]),
-   |     ^^^^^^^^^^^^^^
-
-error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:108:1
-   |
-LL | / enum ManuallyCopyLargeEnum {
-LL | |     A(bool),
-   | |     ------- the second-largest variant contains at least 1 bytes
-LL | |     B([u64; 8000]),
-   | |     -------------- the largest variant contains at least 64000 bytes
-LL | | }
-   | |_^ the entire enum is at least 64008 bytes
-   |
-note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:108:6
-   |
-LL | enum ManuallyCopyLargeEnum {
-   |      ^^^^^^^^^^^^^^^^^^^^^
-help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:110:5
+  --> tests/ui/large_enum_variant.rs:118:5
    |
 LL |     B([u64; 8000]),
    |     ^^^^^^^^^^^^^^
@@ -219,7 +208,31 @@ LL |     B([u64; 8000]),
 error: large size difference between variants
   --> tests/ui/large_enum_variant.rs:121:1
    |
+LL | / enum ManuallyCopyLargeEnum {
+LL | |
+LL | |     A(bool),
+   | |     ------- the second-largest variant contains at least 1 bytes
+LL | |     B([u64; 8000]),
+   | |     -------------- the largest variant contains at least 64000 bytes
+LL | | }
+   | |_^ the entire enum is at least 64008 bytes
+   |
+note: boxing a variant would require the type no longer be `Copy`
+  --> tests/ui/large_enum_variant.rs:121:6
+   |
+LL | enum ManuallyCopyLargeEnum {
+   |      ^^^^^^^^^^^^^^^^^^^^^
+help: consider boxing the large fields to reduce the total size of the enum
+  --> tests/ui/large_enum_variant.rs:124:5
+   |
+LL |     B([u64; 8000]),
+   |     ^^^^^^^^^^^^^^
+
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:135:1
+   |
 LL | / enum SomeGenericPossiblyCopyEnum<T> {
+LL | |
 LL | |     A(bool, std::marker::PhantomData<T>),
    | |     ------------------------------------ the second-largest variant contains at least 1 bytes
 LL | |     B([u64; 4000]),
@@ -228,20 +241,21 @@ LL | | }
    | |_^ the entire enum is at least 32008 bytes
    |
 note: boxing a variant would require the type no longer be `Copy`
-  --> tests/ui/large_enum_variant.rs:121:6
+  --> tests/ui/large_enum_variant.rs:135:6
    |
 LL | enum SomeGenericPossiblyCopyEnum<T> {
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 help: consider boxing the large fields to reduce the total size of the enum
-  --> tests/ui/large_enum_variant.rs:123:5
+  --> tests/ui/large_enum_variant.rs:138:5
    |
 LL |     B([u64; 4000]),
    |     ^^^^^^^^^^^^^^
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:134:1
+  --> tests/ui/large_enum_variant.rs:149:1
    |
 LL | / enum LargeEnumWithGenerics<T> {
+LL | |
 LL | |     Small,
    | |     ----- the second-largest variant carries no data at all
 LL | |     Large((T, [u8; 512])),
@@ -256,9 +270,10 @@ LL +     Large(Box<(T, [u8; 512])>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:143:1
+  --> tests/ui/large_enum_variant.rs:159:1
    |
 LL | / enum WithGenerics {
+LL | |
 LL | |     Large([Foo<u64>; 64]),
    | |     --------------------- the largest variant contains at least 512 bytes
 LL | |     Small(u8),
@@ -273,9 +288,10 @@ LL +     Large(Box<[Foo<u64>; 64]>),
    |
 
 error: large size difference between variants
-  --> tests/ui/large_enum_variant.rs:153:1
+  --> tests/ui/large_enum_variant.rs:170:1
    |
 LL | / enum LargeEnumOfConst {
+LL | |
 LL | |     Ok,
    | |     -- the second-largest variant carries no data at all
 LL | |     Error(PossiblyLargeEnumWithConst<256>),
@@ -289,5 +305,77 @@ LL -     Error(PossiblyLargeEnumWithConst<256>),
 LL +     Error(Box<PossiblyLargeEnumWithConst<256>>),
    |
 
-error: aborting due to 16 previous errors
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:176:1
+   |
+LL | / enum WithRecursion {
+LL | |
+LL | |     Large([u64; 64]),
+   | |     ---------------- the largest variant contains at least 512 bytes
+LL | |     Recursive(Box<WithRecursion>),
+   | |     ----------------------------- the second-largest variant contains at least 8 bytes
+LL | | }
+   | |_^ the entire enum is at least 520 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL -     Large([u64; 64]),
+LL +     Large(Box<[u64; 64]>),
+   |
+
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:187:1
+   |
+LL | / enum LargeEnumWithGenericsAndRecursive {
+LL | |
+LL | |     Ok(),
+   | |     ---- the second-largest variant carries no data at all
+LL | |     Error(WithRecursionAndGenerics<u64>),
+   | |     ------------------------------------ the largest variant contains at least 520 bytes
+LL | | }
+   | |_^ the entire enum is at least 520 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL -     Error(WithRecursionAndGenerics<u64>),
+LL +     Error(Box<WithRecursionAndGenerics<u64>>),
+   |
+
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:223:5
+   |
+LL | /     enum NoWarnings {
+LL | |
+LL | |         BigBoi(PublishWithBytes),
+   | |         ------------------------ the largest variant contains at least 296 bytes
+LL | |         _SmallBoi(u8),
+   | |         ------------- the second-largest variant contains at least 1 bytes
+LL | |     }
+   | |_____^ the entire enum is at least 296 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL -         BigBoi(PublishWithBytes),
+LL +         BigBoi(Box<PublishWithBytes>),
+   |
+
+error: large size difference between variants
+  --> tests/ui/large_enum_variant.rs:229:5
+   |
+LL | /     enum MakesClippyAngry {
+LL | |
+LL | |         BigBoi(PublishWithVec),
+   | |         ---------------------- the largest variant contains at least 224 bytes
+LL | |         _SmallBoi(u8),
+   | |         ------------- the second-largest variant contains at least 1 bytes
+LL | |     }
+   | |_____^ the entire enum is at least 224 bytes
+   |
+help: consider boxing the large fields to reduce the total size of the enum
+   |
+LL -         BigBoi(PublishWithVec),
+LL +         BigBoi(Box<PublishWithVec>),
+   |
+
+error: aborting due to 20 previous errors
 
diff --git a/src/tools/clippy/tests/ui/large_enum_variant.rs b/src/tools/clippy/tests/ui/large_enum_variant.rs
index 3625c011dbfa..9cf6318ca342 100644
--- a/src/tools/clippy/tests/ui/large_enum_variant.rs
+++ b/src/tools/clippy/tests/ui/large_enum_variant.rs
@@ -1,6 +1,8 @@
-//@stderr-per-bitwidth
+//@revisions: 32bit 64bit
 //@aux-build:proc_macros.rs
 //@no-rustfix
+//@[32bit]ignore-bitwidth: 64
+//@[64bit]ignore-bitwidth: 32
 #![allow(dead_code)]
 #![allow(unused_variables)]
 #![warn(clippy::large_enum_variant)]
@@ -9,6 +11,7 @@ extern crate proc_macros;
 use proc_macros::external;
 
 enum LargeEnum {
+    //~^ large_enum_variant
     A(i32),
     B([i32; 8000]),
 }
@@ -33,22 +36,26 @@ enum LargeEnumGeneric<A: SomeTrait> {
 }
 
 enum LargeEnum2 {
+    //~^ large_enum_variant
     VariantOk(i32, u32),
     ContainingLargeEnum(LargeEnum),
 }
 
 enum LargeEnum3 {
+    //~^ large_enum_variant
     ContainingMoreThanOneField(i32, [i32; 8000], [i32; 9500]),
     VoidVariant,
     StructLikeLittle { x: i32, y: i32 },
 }
 
 enum LargeEnum4 {
+    //~^ large_enum_variant
     VariantOk(i32, u32),
     StructLikeLarge { x: [i32; 8000], y: i32 },
 }
 
 enum LargeEnum5 {
+    //~^ large_enum_variant
     VariantOk(i32, u32),
     StructLikeLarge2 { x: [i32; 8000] },
 }
@@ -65,27 +72,32 @@ enum LargeEnum6 {
 }
 
 enum LargeEnum7 {
+    //~^ large_enum_variant
     A,
     B([u8; 1255]),
     C([u8; 200]),
 }
 
 enum LargeEnum8 {
+    //~^ large_enum_variant
     VariantOk(i32, u32),
     ContainingMoreThanOneField([i32; 8000], [i32; 2], [i32; 9500], [i32; 30]),
 }
 
 enum LargeEnum9 {
+    //~^ large_enum_variant
     A(Struct<()>),
     B(Struct2),
 }
 
 enum LargeEnumOk2<T> {
+    //~^ large_enum_variant
     A(T),
     B(Struct2),
 }
 
 enum LargeEnumOk3<T> {
+    //~^ large_enum_variant
     A(Struct<T>),
     B(Struct2),
 }
@@ -101,11 +113,13 @@ struct Struct2 {
 
 #[derive(Copy, Clone)]
 enum CopyableLargeEnum {
+    //~^ large_enum_variant
     A(bool),
     B([u64; 8000]),
 }
 
 enum ManuallyCopyLargeEnum {
+    //~^ large_enum_variant
     A(bool),
     B([u64; 8000]),
 }
@@ -119,6 +133,7 @@ impl Clone for ManuallyCopyLargeEnum {
 impl Copy for ManuallyCopyLargeEnum {}
 
 enum SomeGenericPossiblyCopyEnum<T> {
+    //~^ large_enum_variant
     A(bool, std::marker::PhantomData<T>),
     B([u64; 4000]),
 }
@@ -132,6 +147,7 @@ impl<T: Copy> Clone for SomeGenericPossiblyCopyEnum<T> {
 impl<T: Copy> Copy for SomeGenericPossiblyCopyEnum<T> {}
 
 enum LargeEnumWithGenerics<T> {
+    //~^ large_enum_variant
     Small,
     Large((T, [u8; 512])),
 }
@@ -141,6 +157,7 @@ struct Foo<T> {
 }
 
 enum WithGenerics {
+    //~^ large_enum_variant
     Large([Foo<u64>; 64]),
     Small(u8),
 }
@@ -151,10 +168,28 @@ enum PossiblyLargeEnumWithConst<const U: usize> {
 }
 
 enum LargeEnumOfConst {
+    //~^ large_enum_variant
     Ok,
     Error(PossiblyLargeEnumWithConst<256>),
 }
 
+enum WithRecursion {
+    //~^ large_enum_variant
+    Large([u64; 64]),
+    Recursive(Box<WithRecursion>),
+}
+
+enum WithRecursionAndGenerics<T> {
+    Large([T; 64]),
+    Recursive(Box<WithRecursionAndGenerics<T>>),
+}
+
+enum LargeEnumWithGenericsAndRecursive {
+    //~^ large_enum_variant
+    Ok(),
+    Error(WithRecursionAndGenerics<u64>),
+}
+
 fn main() {
     external!(
         enum LargeEnumInMacro {
@@ -163,3 +198,67 @@ fn main() {
         }
     );
 }
+
+mod issue11915 {
+    use std::sync::atomic::AtomicPtr;
+
+    pub struct Bytes {
+        ptr: *const u8,
+        len: usize,
+        // inlined "trait object"
+        data: AtomicPtr<()>,
+        vtable: &'static Vtable,
+    }
+    pub(crate) struct Vtable {
+        /// fn(data, ptr, len)
+        pub clone: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Bytes,
+        /// fn(data, ptr, len)
+        ///
+        /// takes `Bytes` to value
+        pub to_vec: unsafe fn(&AtomicPtr<()>, *const u8, usize) -> Vec<u8>,
+        /// fn(data, ptr, len)
+        pub drop: unsafe fn(&mut AtomicPtr<()>, *const u8, usize),
+    }
+
+    enum NoWarnings {
+        //~[64bit]^ large_enum_variant
+        BigBoi(PublishWithBytes),
+        _SmallBoi(u8),
+    }
+
+    enum MakesClippyAngry {
+        //~[64bit]^ large_enum_variant
+        BigBoi(PublishWithVec),
+        _SmallBoi(u8),
+    }
+
+    struct PublishWithBytes {
+        _dup: bool,
+        _retain: bool,
+        _topic: Bytes,
+        __topic: Bytes,
+        ___topic: Bytes,
+        ____topic: Bytes,
+        _pkid: u16,
+        _payload: Bytes,
+        __payload: Bytes,
+        ___payload: Bytes,
+        ____payload: Bytes,
+        _____payload: Bytes,
+    }
+
+    struct PublishWithVec {
+        _dup: bool,
+        _retain: bool,
+        _topic: Vec<u8>,
+        __topic: Vec<u8>,
+        ___topic: Vec<u8>,
+        ____topic: Vec<u8>,
+        _pkid: u16,
+        _payload: Vec<u8>,
+        __payload: Vec<u8>,
+        ___payload: Vec<u8>,
+        ____payload: Vec<u8>,
+        _____payload: Vec<u8>,
+    }
+}
diff --git a/src/tools/clippy/tests/ui/large_futures.fixed b/src/tools/clippy/tests/ui/large_futures.fixed
index 1e87859f4526..c2159c58de1e 100644
--- a/src/tools/clippy/tests/ui/large_futures.fixed
+++ b/src/tools/clippy/tests/ui/large_futures.fixed
@@ -8,21 +8,21 @@ async fn big_fut(_arg: [u8; 1024 * 16]) {}
 async fn wait() {
     let f = async {
         Box::pin(big_fut([0u8; 1024 * 16])).await;
-        //~^ ERROR: large future with a size of 16385 bytes
-        //~| NOTE: `-D clippy::large-futures` implied by `-D warnings`
+        //~^ large_futures
     };
     Box::pin(f).await
-    //~^ ERROR: large future with a size of 16386 bytes
+    //~^ large_futures
 }
 async fn calls_fut(fut: impl std::future::Future<Output = ()>) {
     loop {
         Box::pin(wait()).await;
-        //~^ ERROR: large future with a size of 16387 bytes
+        //~^ large_futures
+
         if true {
             return fut.await;
         } else {
             Box::pin(wait()).await;
-            //~^ ERROR: large future with a size of 16387 bytes
+            //~^ large_futures
         }
     }
 }
@@ -30,9 +30,10 @@ async fn calls_fut(fut: impl std::future::Future<Output = ()>) {
 pub async fn test() {
     let fut = big_fut([0u8; 1024 * 16]);
     Box::pin(foo()).await;
-    //~^ ERROR: large future with a size of 65540 bytes
+    //~^ large_futures
+
     Box::pin(calls_fut(fut)).await;
-    //~^ ERROR: large future with a size of 49159 bytes
+    //~^ large_futures
 }
 
 pub fn foo() -> impl std::future::Future<Output = ()> {
@@ -45,7 +46,8 @@ pub fn foo() -> impl std::future::Future<Output = ()> {
 
 pub async fn lines() {
     Box::pin(async {
-        //~^ ERROR: large future with a size of 65540 bytes
+        //~^ large_futures
+
         let x = [0i32; 1024 * 16];
         async {}.await;
         println!("{:?}", x);
@@ -57,6 +59,7 @@ pub async fn macro_expn() {
     macro_rules! macro_ {
         () => {
             Box::pin(async {
+                //~^ large_futures
                 let x = [0i32; 1024 * 16];
                 async {}.await;
                 println!("macro: {:?}", x);
diff --git a/src/tools/clippy/tests/ui/large_futures.rs b/src/tools/clippy/tests/ui/large_futures.rs
index 3f4ea2ebf8bb..567f6344afea 100644
--- a/src/tools/clippy/tests/ui/large_futures.rs
+++ b/src/tools/clippy/tests/ui/large_futures.rs
@@ -8,21 +8,21 @@ async fn big_fut(_arg: [u8; 1024 * 16]) {}
 async fn wait() {
     let f = async {
         big_fut([0u8; 1024 * 16]).await;
-        //~^ ERROR: large future with a size of 16385 bytes
-        //~| NOTE: `-D clippy::large-futures` implied by `-D warnings`
+        //~^ large_futures
     };
     f.await
-    //~^ ERROR: large future with a size of 16386 bytes
+    //~^ large_futures
 }
 async fn calls_fut(fut: impl std::future::Future<Output = ()>) {
     loop {
         wait().await;
-        //~^ ERROR: large future with a size of 16387 bytes
+        //~^ large_futures
+
         if true {
             return fut.await;
         } else {
             wait().await;
-            //~^ ERROR: large future with a size of 16387 bytes
+            //~^ large_futures
         }
     }
 }
@@ -30,9 +30,10 @@ async fn calls_fut(fut: impl std::future::Future<Output = ()>) {
 pub async fn test() {
     let fut = big_fut([0u8; 1024 * 16]);
     foo().await;
-    //~^ ERROR: large future with a size of 65540 bytes
+    //~^ large_futures
+
     calls_fut(fut).await;
-    //~^ ERROR: large future with a size of 49159 bytes
+    //~^ large_futures
 }
 
 pub fn foo() -> impl std::future::Future<Output = ()> {
@@ -45,7 +46,8 @@ pub fn foo() -> impl std::future::Future<Output = ()> {
 
 pub async fn lines() {
     async {
-        //~^ ERROR: large future with a size of 65540 bytes
+        //~^ large_futures
+
         let x = [0i32; 1024 * 16];
         async {}.await;
         println!("{:?}", x);
@@ -57,6 +59,7 @@ pub async fn macro_expn() {
     macro_rules! macro_ {
         () => {
             async {
+                //~^ large_futures
                 let x = [0i32; 1024 * 16];
                 async {}.await;
                 println!("macro: {:?}", x);
diff --git a/src/tools/clippy/tests/ui/large_futures.stderr b/src/tools/clippy/tests/ui/large_futures.stderr
index 00082e579c59..fd6ba4e3563d 100644
--- a/src/tools/clippy/tests/ui/large_futures.stderr
+++ b/src/tools/clippy/tests/ui/large_futures.stderr
@@ -8,13 +8,13 @@ LL |         big_fut([0u8; 1024 * 16]).await;
    = help: to override `-D warnings` add `#[allow(clippy::large_futures)]`
 
 error: large future with a size of 16386 bytes
-  --> tests/ui/large_futures.rs:14:5
+  --> tests/ui/large_futures.rs:13:5
    |
 LL |     f.await
    |     ^ help: consider `Box::pin` on it: `Box::pin(f)`
 
 error: large future with a size of 16387 bytes
-  --> tests/ui/large_futures.rs:19:9
+  --> tests/ui/large_futures.rs:18:9
    |
 LL |         wait().await;
    |         ^^^^^^ help: consider `Box::pin` on it: `Box::pin(wait())`
@@ -32,16 +32,17 @@ LL |     foo().await;
    |     ^^^^^ help: consider `Box::pin` on it: `Box::pin(foo())`
 
 error: large future with a size of 49159 bytes
-  --> tests/ui/large_futures.rs:34:5
+  --> tests/ui/large_futures.rs:35:5
    |
 LL |     calls_fut(fut).await;
    |     ^^^^^^^^^^^^^^ help: consider `Box::pin` on it: `Box::pin(calls_fut(fut))`
 
 error: large future with a size of 65540 bytes
-  --> tests/ui/large_futures.rs:47:5
+  --> tests/ui/large_futures.rs:48:5
    |
 LL | /     async {
 LL | |
+LL | |
 LL | |         let x = [0i32; 1024 * 16];
 LL | |         async {}.await;
 LL | |         println!("{:?}", x);
@@ -52,6 +53,7 @@ help: consider `Box::pin` on it
    |
 LL ~     Box::pin(async {
 LL +
+LL + 
 LL +         let x = [0i32; 1024 * 16];
 LL +         async {}.await;
 LL +         println!("{:?}", x);
@@ -59,9 +61,10 @@ LL +     })
    |
 
 error: large future with a size of 65540 bytes
-  --> tests/ui/large_futures.rs:59:13
+  --> tests/ui/large_futures.rs:61:13
    |
 LL | /             async {
+LL | |
 LL | |                 let x = [0i32; 1024 * 16];
 LL | |                 async {}.await;
 LL | |                 println!("macro: {:?}", x);
@@ -75,6 +78,7 @@ LL |       macro_!().await
 help: consider `Box::pin` on it
    |
 LL ~             Box::pin(async {
+LL +
 LL +                 let x = [0i32; 1024 * 16];
 LL +                 async {}.await;
 LL +                 println!("macro: {:?}", x);
diff --git a/src/tools/clippy/tests/ui/large_stack_frames.rs b/src/tools/clippy/tests/ui/large_stack_frames.rs
index e6c030b8a9e8..3ed124f69ef3 100644
--- a/src/tools/clippy/tests/ui/large_stack_frames.rs
+++ b/src/tools/clippy/tests/ui/large_stack_frames.rs
@@ -25,7 +25,8 @@ impl<const N: usize> Default for ArrayDefault<N> {
 }
 
 fn many_small_arrays() {
-    //~^ ERROR: this function may allocate
+    //~^ large_stack_frames
+
     let x = [0u8; 500_000];
     let x2 = [0u8; 500_000];
     let x3 = [0u8; 500_000];
@@ -35,18 +36,21 @@ fn many_small_arrays() {
 }
 
 fn large_return_value() -> ArrayDefault<1_000_000> {
-    //~^ ERROR: this function may allocate 1000000 bytes on the stack
+    //~^ large_stack_frames
+
     Default::default()
 }
 
 fn large_fn_arg(x: ArrayDefault<1_000_000>) {
-    //~^ ERROR: this function may allocate
+    //~^ large_stack_frames
+
     black_box(&x);
 }
 
 fn has_large_closure() {
     let f = || black_box(&[0u8; 1_000_000]);
-    //~^ ERROR: this function may allocate
+    //~^ large_stack_frames
+
     f();
 }
 
diff --git a/src/tools/clippy/tests/ui/large_stack_frames.stderr b/src/tools/clippy/tests/ui/large_stack_frames.stderr
index f2e0a127f5f5..0ff49e9f5b37 100644
--- a/src/tools/clippy/tests/ui/large_stack_frames.stderr
+++ b/src/tools/clippy/tests/ui/large_stack_frames.stderr
@@ -13,7 +13,7 @@ LL |     let x5 = [0u8; 500_000];
    = help: to override `-D warnings` add `#[allow(clippy::large_stack_frames)]`
 
 error: this function may allocate 1000000 bytes on the stack
-  --> tests/ui/large_stack_frames.rs:37:4
+  --> tests/ui/large_stack_frames.rs:38:4
    |
 LL | fn large_return_value() -> ArrayDefault<1_000_000> {
    |    ^^^^^^^^^^^^^^^^^^      ----------------------- this is the largest part, at 1000000 bytes for type `ArrayDefault<1000000>`
@@ -21,7 +21,7 @@ LL | fn large_return_value() -> ArrayDefault<1_000_000> {
    = note: 1000000 bytes is larger than Clippy's configured `stack-size-threshold` of 512000
 
 error: this function may allocate 100$PTR bytes on the stack
-  --> tests/ui/large_stack_frames.rs:42:4
+  --> tests/ui/large_stack_frames.rs:44:4
    |
 LL | fn large_fn_arg(x: ArrayDefault<1_000_000>) {
    |    ^^^^^^^^^^^^ - `x` is the largest part, at 1000000 bytes for type `ArrayDefault<1000000>`
@@ -29,7 +29,7 @@ LL | fn large_fn_arg(x: ArrayDefault<1_000_000>) {
    = note: 100$PTR bytes is larger than Clippy's configured `stack-size-threshold` of 512000
 
 error: this function may allocate 100$PTR bytes on the stack
-  --> tests/ui/large_stack_frames.rs:48:13
+  --> tests/ui/large_stack_frames.rs:51:13
    |
 LL |     let f = || black_box(&[0u8; 1_000_000]);
    |             ^^^^^^^^^^^^^^----------------^
diff --git a/src/tools/clippy/tests/ui/large_types_passed_by_value.rs b/src/tools/clippy/tests/ui/large_types_passed_by_value.rs
index 78994a2988a2..562a46306e06 100644
--- a/src/tools/clippy/tests/ui/large_types_passed_by_value.rs
+++ b/src/tools/clippy/tests/ui/large_types_passed_by_value.rs
@@ -18,19 +18,25 @@ fn not_copy(a: Large) {}
 fn by_ref(a: &Large, b: &LargeAndCopy) {}
 fn mutable(mut a: LargeAndCopy) {}
 fn bad(a: LargeAndCopy) {}
+//~^ large_types_passed_by_value
 pub fn bad_but_pub(a: LargeAndCopy) {}
 
 impl LargeAndCopy {
     fn self_is_ok(self) {}
     fn other_is_not_ok(self, other: LargeAndCopy) {}
+    //~^ large_types_passed_by_value
     fn unless_other_can_change(self, mut other: LargeAndCopy) {}
     pub fn or_were_in_public(self, other: LargeAndCopy) {}
 }
 
 trait LargeTypeDevourer {
     fn devoure_array(&self, array: [u8; 6666]);
+    //~^ large_types_passed_by_value
     fn devoure_tuple(&self, tup: (LargeAndCopy, LargeAndCopy));
+    //~^ large_types_passed_by_value
     fn devoure_array_and_tuple_wow(&self, array: [u8; 6666], tup: (LargeAndCopy, LargeAndCopy));
+    //~^ large_types_passed_by_value
+    //~| large_types_passed_by_value
 }
 
 pub trait PubLargeTypeDevourer {
@@ -56,10 +62,12 @@ fn foo_always(x: LargeAndCopy) {
 }
 #[inline(never)]
 fn foo_never(x: LargeAndCopy) {
+    //~^ large_types_passed_by_value
     todo!();
 }
 #[inline]
 fn foo(x: LargeAndCopy) {
+    //~^ large_types_passed_by_value
     todo!();
 }
 
diff --git a/src/tools/clippy/tests/ui/large_types_passed_by_value.stderr b/src/tools/clippy/tests/ui/large_types_passed_by_value.stderr
index 5b42ab9e02ac..0ad68bc326e0 100644
--- a/src/tools/clippy/tests/ui/large_types_passed_by_value.stderr
+++ b/src/tools/clippy/tests/ui/large_types_passed_by_value.stderr
@@ -8,43 +8,43 @@ LL | fn bad(a: LargeAndCopy) {}
    = help: to override `-D warnings` add `#[allow(clippy::large_types_passed_by_value)]`
 
 error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
-  --> tests/ui/large_types_passed_by_value.rs:25:37
+  --> tests/ui/large_types_passed_by_value.rs:26:37
    |
 LL |     fn other_is_not_ok(self, other: LargeAndCopy) {}
    |                                     ^^^^^^^^^^^^ help: consider passing by reference instead: `&LargeAndCopy`
 
 error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
-  --> tests/ui/large_types_passed_by_value.rs:31:36
+  --> tests/ui/large_types_passed_by_value.rs:33:36
    |
 LL |     fn devoure_array(&self, array: [u8; 6666]);
    |                                    ^^^^^^^^^^ help: consider passing by reference instead: `&[u8; 6666]`
 
 error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
-  --> tests/ui/large_types_passed_by_value.rs:32:34
+  --> tests/ui/large_types_passed_by_value.rs:35:34
    |
 LL |     fn devoure_tuple(&self, tup: (LargeAndCopy, LargeAndCopy));
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider passing by reference instead: `&(LargeAndCopy, LargeAndCopy)`
 
 error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
-  --> tests/ui/large_types_passed_by_value.rs:33:50
+  --> tests/ui/large_types_passed_by_value.rs:37:50
    |
 LL |     fn devoure_array_and_tuple_wow(&self, array: [u8; 6666], tup: (LargeAndCopy, LargeAndCopy));
    |                                                  ^^^^^^^^^^ help: consider passing by reference instead: `&[u8; 6666]`
 
 error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
-  --> tests/ui/large_types_passed_by_value.rs:33:67
+  --> tests/ui/large_types_passed_by_value.rs:37:67
    |
 LL |     fn devoure_array_and_tuple_wow(&self, array: [u8; 6666], tup: (LargeAndCopy, LargeAndCopy));
    |                                                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider passing by reference instead: `&(LargeAndCopy, LargeAndCopy)`
 
 error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
-  --> tests/ui/large_types_passed_by_value.rs:58:17
+  --> tests/ui/large_types_passed_by_value.rs:64:17
    |
 LL | fn foo_never(x: LargeAndCopy) {
    |                 ^^^^^^^^^^^^ help: consider passing by reference instead: `&LargeAndCopy`
 
 error: this argument (N byte) is passed by value, but might be more efficient if passed by reference (limit: N byte)
-  --> tests/ui/large_types_passed_by_value.rs:62:11
+  --> tests/ui/large_types_passed_by_value.rs:69:11
    |
 LL | fn foo(x: LargeAndCopy) {
    |           ^^^^^^^^^^^^ help: consider passing by reference instead: `&LargeAndCopy`
diff --git a/src/tools/clippy/tests/ui/legacy_numeric_constants.fixed b/src/tools/clippy/tests/ui/legacy_numeric_constants.fixed
index 3a2294ef4c59..30bb549a9d65 100644
--- a/src/tools/clippy/tests/ui/legacy_numeric_constants.fixed
+++ b/src/tools/clippy/tests/ui/legacy_numeric_constants.fixed
@@ -1,4 +1,5 @@
 //@aux-build:proc_macros.rs
+//@require-annotations-for-level: WARN
 #![allow(clippy::no_effect, deprecated, unused)]
 #![allow(clippy::legacy_numeric_constants)] // For imports.
 
diff --git a/src/tools/clippy/tests/ui/legacy_numeric_constants.rs b/src/tools/clippy/tests/ui/legacy_numeric_constants.rs
index 6cb3e694ea14..d3878199055f 100644
--- a/src/tools/clippy/tests/ui/legacy_numeric_constants.rs
+++ b/src/tools/clippy/tests/ui/legacy_numeric_constants.rs
@@ -1,4 +1,5 @@
 //@aux-build:proc_macros.rs
+//@require-annotations-for-level: WARN
 #![allow(clippy::no_effect, deprecated, unused)]
 #![allow(clippy::legacy_numeric_constants)] // For imports.
 
diff --git a/src/tools/clippy/tests/ui/legacy_numeric_constants.stderr b/src/tools/clippy/tests/ui/legacy_numeric_constants.stderr
index 91dfe79d55ba..4d69b8165a34 100644
--- a/src/tools/clippy/tests/ui/legacy_numeric_constants.stderr
+++ b/src/tools/clippy/tests/ui/legacy_numeric_constants.stderr
@@ -1,5 +1,5 @@
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:31:5
+  --> tests/ui/legacy_numeric_constants.rs:32:5
    |
 LL |     std::f32::EPSILON;
    |     ^^^^^^^^^^^^^^^^^
@@ -13,7 +13,7 @@ LL +     f32::EPSILON;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:34:5
+  --> tests/ui/legacy_numeric_constants.rs:35:5
    |
 LL |     std::u8::MIN;
    |     ^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     u8::MIN;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:37:5
+  --> tests/ui/legacy_numeric_constants.rs:38:5
    |
 LL |     std::usize::MIN;
    |     ^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     usize::MIN;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:40:5
+  --> tests/ui/legacy_numeric_constants.rs:41:5
    |
 LL |     std::u32::MAX;
    |     ^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     u32::MAX;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:43:5
+  --> tests/ui/legacy_numeric_constants.rs:44:5
    |
 LL |     core::u32::MAX;
    |     ^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     u32::MAX;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:46:5
+  --> tests/ui/legacy_numeric_constants.rs:47:5
    |
 LL |     MAX;
    |     ^^^
@@ -72,7 +72,7 @@ LL |     u32::MAX;
    |     +++++
 
 error: usage of a legacy numeric method
-  --> tests/ui/legacy_numeric_constants.rs:49:10
+  --> tests/ui/legacy_numeric_constants.rs:50:10
    |
 LL |     i32::max_value();
    |          ^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL +     i32::MAX;
    |
 
 error: usage of a legacy numeric method
-  --> tests/ui/legacy_numeric_constants.rs:52:9
+  --> tests/ui/legacy_numeric_constants.rs:53:9
    |
 LL |     u8::max_value();
    |         ^^^^^^^^^^^
@@ -96,7 +96,7 @@ LL +     u8::MAX;
    |
 
 error: usage of a legacy numeric method
-  --> tests/ui/legacy_numeric_constants.rs:55:9
+  --> tests/ui/legacy_numeric_constants.rs:56:9
    |
 LL |     u8::min_value();
    |         ^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL +     u8::MIN;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:58:5
+  --> tests/ui/legacy_numeric_constants.rs:59:5
    |
 LL |     ::std::u8::MIN;
    |     ^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL +     u8::MIN;
    |
 
 error: usage of a legacy numeric method
-  --> tests/ui/legacy_numeric_constants.rs:61:27
+  --> tests/ui/legacy_numeric_constants.rs:62:27
    |
 LL |     ::std::primitive::u8::min_value();
    |                           ^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL +     ::std::primitive::u8::MIN;
    |
 
 error: usage of a legacy numeric method
-  --> tests/ui/legacy_numeric_constants.rs:64:26
+  --> tests/ui/legacy_numeric_constants.rs:65:26
    |
 LL |     std::primitive::i32::max_value();
    |                          ^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL +     std::primitive::i32::MAX;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:67:5
+  --> tests/ui/legacy_numeric_constants.rs:68:5
    |
 LL |     self::a::u128::MAX;
    |     ^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL +     u128::MAX;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:17:25
+  --> tests/ui/legacy_numeric_constants.rs:18:25
    |
 LL |                 let x = std::u64::MAX;
    |                         ^^^^^^^^^^^^^
@@ -172,7 +172,7 @@ LL +                 let x = u64::MAX;
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:81:14
+  --> tests/ui/legacy_numeric_constants.rs:82:14
    |
 LL |     [(0, "", std::i128::MAX)];
    |              ^^^^^^^^^^^^^^
@@ -184,7 +184,7 @@ LL +     [(0, "", i128::MAX)];
    |
 
 error: usage of a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants.rs:115:5
+  --> tests/ui/legacy_numeric_constants.rs:116:5
    |
 LL |     std::u32::MAX;
    |     ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.rs b/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.rs
index 86738ede210c..9bf0f7f355ae 100644
--- a/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.rs
+++ b/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.rs
@@ -1,4 +1,5 @@
 //@no-rustfix
+//@require-annotations-for-level: WARN
 //@aux-build:proc_macros.rs
 #![allow(clippy::no_effect, deprecated, unused)]
 #![warn(clippy::legacy_numeric_constants)]
diff --git a/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.stderr b/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.stderr
index 2edcf7188362..96e6c9ef9759 100644
--- a/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/legacy_numeric_constants_unfixable.stderr
@@ -1,5 +1,5 @@
 error: importing legacy numeric constants
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:9:5
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:10:5
    |
 LL | use std::u128 as _;
    |     ^^^^^^^^^
@@ -9,7 +9,7 @@ LL | use std::u128 as _;
    = help: to override `-D warnings` add `#[allow(clippy::legacy_numeric_constants)]`
 
 error: importing legacy numeric constants
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:13:24
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:14:24
    |
 LL |     pub use std::{mem, u128};
    |                        ^^^^
@@ -18,7 +18,7 @@ LL |     pub use std::{mem, u128};
    = note: then `u128::<CONST>` will resolve to the respective associated constant
 
 error: importing a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:29:9
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:30:9
    |
 LL |     use std::u32::MAX;
    |         ^^^^^^^^^^^^^
@@ -26,7 +26,7 @@ LL |     use std::u32::MAX;
    = help: remove this import and use the associated constant `u32::MAX` from the primitive type instead
 
 error: importing a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:32:9
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:33:9
    |
 LL |     use std::u8::MIN;
    |         ^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |     use std::u8::MIN;
    = help: remove this import and use the associated constant `u8::MIN` from the primitive type instead
 
 error: importing legacy numeric constants
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:36:9
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:37:9
    |
 LL |     use std::u32;
    |         ^^^^^^^^
@@ -43,7 +43,7 @@ LL |     use std::u32;
    = note: then `u32::<CONST>` will resolve to the respective associated constant
 
 error: importing a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:40:9
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:41:9
    |
 LL |     use std::f32::MIN_POSITIVE;
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL |     use std::f32::MIN_POSITIVE;
    = help: remove this import and use the associated constant `f32::MIN_POSITIVE` from the primitive type instead
 
 error: importing legacy numeric constants
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:44:9
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:45:9
    |
 LL |     use std::i16::*;
    |         ^^^^^^^^
@@ -59,7 +59,7 @@ LL |     use std::i16::*;
    = help: remove this import and use associated constants `i16::<CONST>` from the primitive type instead
 
 error: importing legacy numeric constants
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:21:17
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:22:17
    |
 LL |             use std::u32;
    |                 ^^^^^^^^
@@ -72,7 +72,7 @@ LL |     b!();
    = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: importing a legacy numeric constant
-  --> tests/ui/legacy_numeric_constants_unfixable.rs:76:9
+  --> tests/ui/legacy_numeric_constants_unfixable.rs:77:9
    |
 LL |     use std::u32::MAX;
    |         ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/len_without_is_empty.rs b/src/tools/clippy/tests/ui/len_without_is_empty.rs
index d623601110e2..011833072d76 100644
--- a/src/tools/clippy/tests/ui/len_without_is_empty.rs
+++ b/src/tools/clippy/tests/ui/len_without_is_empty.rs
@@ -5,8 +5,8 @@ pub struct PubOne;
 
 impl PubOne {
     pub fn len(&self) -> isize {
-        //~^ ERROR: struct `PubOne` has a public `len` method, but no `is_empty` method
-        //~| NOTE: `-D clippy::len-without-is-empty` implied by `-D warnings`
+        //~^ len_without_is_empty
+
         1
     }
 }
@@ -55,7 +55,8 @@ impl PubAllowedStruct {
 }
 
 pub trait PubTraitsToo {
-    //~^ ERROR: trait `PubTraitsToo` has a `len` method but no (possibly inherited) `is_empty`
+    //~^ len_without_is_empty
+
     fn len(&self) -> isize;
 }
 
@@ -69,7 +70,8 @@ pub struct HasIsEmpty;
 
 impl HasIsEmpty {
     pub fn len(&self) -> isize {
-        //~^ ERROR: struct `HasIsEmpty` has a public `len` method, but a private `is_empty` me
+        //~^ len_without_is_empty
+
         1
     }
 
@@ -82,7 +84,8 @@ pub struct HasWrongIsEmpty;
 
 impl HasWrongIsEmpty {
     pub fn len(&self) -> isize {
-        //~^ ERROR: struct `HasWrongIsEmpty` has a public `len` method, but the `is_empty` met
+        //~^ len_without_is_empty
+
         1
     }
 
@@ -95,7 +98,8 @@ pub struct MismatchedSelf;
 
 impl MismatchedSelf {
     pub fn len(self) -> isize {
-        //~^ ERROR: struct `MismatchedSelf` has a public `len` method, but the `is_empty` meth
+        //~^ len_without_is_empty
+
         1
     }
 
@@ -175,7 +179,8 @@ pub trait InheritingEmpty: Empty {
 pub trait Foo: Sized {}
 
 pub trait DependsOnFoo: Foo {
-    //~^ ERROR: trait `DependsOnFoo` has a `len` method but no (possibly inherited) `is_empty`
+    //~^ len_without_is_empty
+
     fn len(&mut self) -> usize;
 }
 
@@ -221,7 +226,8 @@ impl OptionalLen2 {
 pub struct OptionalLen3;
 impl OptionalLen3 {
     pub fn len(&self) -> usize {
-        //~^ ERROR: struct `OptionalLen3` has a public `len` method, but the `is_empty` method
+        //~^ len_without_is_empty
+
         0
     }
 
@@ -234,8 +240,9 @@ impl OptionalLen3 {
 pub struct ResultLen;
 impl ResultLen {
     pub fn len(&self) -> Result<usize, ()> {
-        //~^ ERROR: struct `ResultLen` has a public `len` method, but the `is_empty` method ha
-        //~| ERROR: this returns a `Result<_, ()>`
+        //~^ len_without_is_empty
+        //~| result_unit_err
+
         Ok(0)
     }
 
@@ -248,12 +255,14 @@ impl ResultLen {
 pub struct ResultLen2;
 impl ResultLen2 {
     pub fn len(&self) -> Result<usize, ()> {
-        //~^ ERROR: this returns a `Result<_, ()>`
+        //~^ result_unit_err
+
         Ok(0)
     }
 
     pub fn is_empty(&self) -> Result<bool, ()> {
-        //~^ ERROR: this returns a `Result<_, ()>`
+        //~^ result_unit_err
+
         Ok(true)
     }
 }
@@ -261,7 +270,8 @@ impl ResultLen2 {
 pub struct ResultLen3;
 impl ResultLen3 {
     pub fn len(&self) -> Result<usize, ()> {
-        //~^ ERROR: this returns a `Result<_, ()>`
+        //~^ result_unit_err
+
         Ok(0)
     }
 
@@ -303,7 +313,8 @@ impl AsyncLenWithoutIsEmpty {
     }
 
     pub async fn len(&self) -> usize {
-        //~^ ERROR: struct `AsyncLenWithoutIsEmpty` has a public `len` method, but no `is_empt
+        //~^ len_without_is_empty
+
         usize::from(!self.async_task().await)
     }
 }
@@ -316,7 +327,8 @@ impl AsyncOptionLenWithoutIsEmpty {
     }
 
     pub async fn len(&self) -> Option<usize> {
-        //~^ ERROR: struct `AsyncOptionLenWithoutIsEmpty` has a public `len` method, but no `i
+        //~^ len_without_is_empty
+
         None
     }
 }
@@ -338,7 +350,8 @@ impl AsyncResultLenWithoutIsEmpty {
     }
 
     pub async fn len(&self) -> Result<usize, ()> {
-        //~^ ERROR: struct `AsyncResultLenWithoutIsEmpty` has a public `len` method, but no `i
+        //~^ len_without_is_empty
+
         Err(())
     }
 }
@@ -454,7 +467,8 @@ pub struct Aliased2;
 pub type Alias2 = Aliased2;
 impl Alias2 {
     pub fn len(&self) -> usize {
-        //~^ ERROR: type `Alias2` has a public `len` method, but no `is_empty` method
+        //~^ len_without_is_empty
+
         todo!()
     }
 }
diff --git a/src/tools/clippy/tests/ui/len_without_is_empty.stderr b/src/tools/clippy/tests/ui/len_without_is_empty.stderr
index 11d0d855fc0b..748a55712f88 100644
--- a/src/tools/clippy/tests/ui/len_without_is_empty.stderr
+++ b/src/tools/clippy/tests/ui/len_without_is_empty.stderr
@@ -12,85 +12,87 @@ error: trait `PubTraitsToo` has a `len` method but no (possibly inherited) `is_e
    |
 LL | / pub trait PubTraitsToo {
 LL | |
+LL | |
 LL | |     fn len(&self) -> isize;
 LL | | }
    | |_^
 
 error: struct `HasIsEmpty` has a public `len` method, but a private `is_empty` method
-  --> tests/ui/len_without_is_empty.rs:71:5
+  --> tests/ui/len_without_is_empty.rs:72:5
    |
 LL |     pub fn len(&self) -> isize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> tests/ui/len_without_is_empty.rs:76:5
+  --> tests/ui/len_without_is_empty.rs:78:5
    |
 LL |     fn is_empty(&self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: struct `HasWrongIsEmpty` has a public `len` method, but the `is_empty` method has an unexpected signature
-  --> tests/ui/len_without_is_empty.rs:84:5
+  --> tests/ui/len_without_is_empty.rs:86:5
    |
 LL |     pub fn len(&self) -> isize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> tests/ui/len_without_is_empty.rs:89:5
+  --> tests/ui/len_without_is_empty.rs:92:5
    |
 LL |     pub fn is_empty(&self, x: u32) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature: `(&self) -> bool`
 
 error: struct `MismatchedSelf` has a public `len` method, but the `is_empty` method has an unexpected signature
-  --> tests/ui/len_without_is_empty.rs:97:5
+  --> tests/ui/len_without_is_empty.rs:100:5
    |
 LL |     pub fn len(self) -> isize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> tests/ui/len_without_is_empty.rs:102:5
+  --> tests/ui/len_without_is_empty.rs:106:5
    |
 LL |     pub fn is_empty(&self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature: `(self) -> bool`
 
 error: trait `DependsOnFoo` has a `len` method but no (possibly inherited) `is_empty` method
-  --> tests/ui/len_without_is_empty.rs:177:1
+  --> tests/ui/len_without_is_empty.rs:181:1
    |
 LL | / pub trait DependsOnFoo: Foo {
 LL | |
+LL | |
 LL | |     fn len(&mut self) -> usize;
 LL | | }
    | |_^
 
 error: struct `OptionalLen3` has a public `len` method, but the `is_empty` method has an unexpected signature
-  --> tests/ui/len_without_is_empty.rs:223:5
+  --> tests/ui/len_without_is_empty.rs:228:5
    |
 LL |     pub fn len(&self) -> usize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> tests/ui/len_without_is_empty.rs:229:5
+  --> tests/ui/len_without_is_empty.rs:235:5
    |
 LL |     pub fn is_empty(&self) -> Option<bool> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature: `(&self) -> bool`
 
 error: struct `ResultLen` has a public `len` method, but the `is_empty` method has an unexpected signature
-  --> tests/ui/len_without_is_empty.rs:236:5
+  --> tests/ui/len_without_is_empty.rs:242:5
    |
 LL |     pub fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `is_empty` defined here
-  --> tests/ui/len_without_is_empty.rs:243:5
+  --> tests/ui/len_without_is_empty.rs:250:5
    |
 LL |     pub fn is_empty(&self) -> Option<bool> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: expected signature: `(&self) -> bool` or `(&self) -> Result<bool>
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/len_without_is_empty.rs:236:5
+  --> tests/ui/len_without_is_empty.rs:242:5
    |
 LL |     pub fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -100,7 +102,7 @@ LL |     pub fn len(&self) -> Result<usize, ()> {
    = help: to override `-D warnings` add `#[allow(clippy::result_unit_err)]`
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/len_without_is_empty.rs:250:5
+  --> tests/ui/len_without_is_empty.rs:257:5
    |
 LL |     pub fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +110,7 @@ LL |     pub fn len(&self) -> Result<usize, ()> {
    = help: use a custom `Error` type instead
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/len_without_is_empty.rs:255:5
+  --> tests/ui/len_without_is_empty.rs:263:5
    |
 LL |     pub fn is_empty(&self) -> Result<bool, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -116,7 +118,7 @@ LL |     pub fn is_empty(&self) -> Result<bool, ()> {
    = help: use a custom `Error` type instead
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/len_without_is_empty.rs:263:5
+  --> tests/ui/len_without_is_empty.rs:272:5
    |
 LL |     pub fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -124,25 +126,25 @@ LL |     pub fn len(&self) -> Result<usize, ()> {
    = help: use a custom `Error` type instead
 
 error: struct `AsyncLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
-  --> tests/ui/len_without_is_empty.rs:305:5
+  --> tests/ui/len_without_is_empty.rs:315:5
    |
 LL |     pub async fn len(&self) -> usize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: struct `AsyncOptionLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
-  --> tests/ui/len_without_is_empty.rs:318:5
+  --> tests/ui/len_without_is_empty.rs:329:5
    |
 LL |     pub async fn len(&self) -> Option<usize> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: struct `AsyncResultLenWithoutIsEmpty` has a public `len` method, but no `is_empty` method
-  --> tests/ui/len_without_is_empty.rs:340:5
+  --> tests/ui/len_without_is_empty.rs:352:5
    |
 LL |     pub async fn len(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: type `Alias2` has a public `len` method, but no `is_empty` method
-  --> tests/ui/len_without_is_empty.rs:456:5
+  --> tests/ui/len_without_is_empty.rs:469:5
    |
 LL |     pub fn len(&self) -> usize {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/len_zero.fixed b/src/tools/clippy/tests/ui/len_zero.fixed
index c9c476ba4214..b8573ef13b0e 100644
--- a/src/tools/clippy/tests/ui/len_zero.fixed
+++ b/src/tools/clippy/tests/ui/len_zero.fixed
@@ -86,10 +86,12 @@ impl Deref for DerefToString {
 fn main() {
     let x = [1, 2];
     if x.is_empty() {
+        //~^ len_zero
         println!("This should not happen!");
     }
 
     if "".is_empty() {}
+    //~^ len_zero
 
     let s = "Hello, world!";
     let s1 = &s;
@@ -99,16 +101,24 @@ fn main() {
     let s5 = &s4;
     let s6 = &s5;
     println!("{}", s1.is_empty());
+    //~^ comparison_to_empty
     println!("{}", s2.is_empty());
+    //~^ comparison_to_empty
     println!("{}", s3.is_empty());
+    //~^ comparison_to_empty
     println!("{}", s4.is_empty());
+    //~^ comparison_to_empty
     println!("{}", s5.is_empty());
+    //~^ comparison_to_empty
     println!("{}", (s6).is_empty());
+    //~^ comparison_to_empty
 
     let d2s = DerefToDerefToString {};
     println!("{}", (**d2s).is_empty());
+    //~^ comparison_to_empty
 
     println!("{}", std::borrow::Cow::Borrowed("").is_empty());
+    //~^ comparison_to_empty
 
     let y = One;
     if y.len() == 0 {
@@ -124,18 +134,23 @@ fn main() {
 
     let has_is_empty = HasIsEmpty;
     if has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if !has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if !has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if !has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.len() > 1 {
@@ -147,18 +162,23 @@ fn main() {
         println!("This can happen.");
     }
     if has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if !has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if !has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if !has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     if 1 < has_is_empty.len() {
@@ -173,6 +193,7 @@ fn main() {
 
     let with_is_empty: &dyn WithIsEmpty = &Wither;
     if with_is_empty.is_empty() {
+        //~^ len_zero
         println!("Or this!");
     }
     assert!(!with_is_empty.is_empty());
@@ -185,11 +206,14 @@ fn main() {
 
     // issue #10529
     (!has_is_empty.is_empty()).then(|| println!("This can happen."));
+    //~^ len_zero
     (has_is_empty.is_empty()).then(|| println!("Or this!"));
+    //~^ len_zero
 }
 
 fn test_slice(b: &[u8]) {
     if !b.is_empty() {}
+    //~^ len_zero
 }
 
 // issue #11992
@@ -224,9 +248,12 @@ fn binop_with_macros() {
     if has_is_empty.len() == compare_to!(1) {}
 
     if has_is_empty.is_empty() {}
+    //~^ len_zero
     if has_is_empty.is_empty() {}
+    //~^ len_zero
 
     (!has_is_empty.is_empty()).then(|| println!("This can happen."));
+    //~^ len_zero
 }
 
 fn no_infinite_recursion() -> bool {
diff --git a/src/tools/clippy/tests/ui/len_zero.rs b/src/tools/clippy/tests/ui/len_zero.rs
index 610a5448d10e..ef3c49c1ab30 100644
--- a/src/tools/clippy/tests/ui/len_zero.rs
+++ b/src/tools/clippy/tests/ui/len_zero.rs
@@ -86,10 +86,12 @@ impl Deref for DerefToString {
 fn main() {
     let x = [1, 2];
     if x.len() == 0 {
+        //~^ len_zero
         println!("This should not happen!");
     }
 
     if "".len() == 0 {}
+    //~^ len_zero
 
     let s = "Hello, world!";
     let s1 = &s;
@@ -99,16 +101,24 @@ fn main() {
     let s5 = &s4;
     let s6 = &s5;
     println!("{}", *s1 == "");
+    //~^ comparison_to_empty
     println!("{}", **s2 == "");
+    //~^ comparison_to_empty
     println!("{}", ***s3 == "");
+    //~^ comparison_to_empty
     println!("{}", ****s4 == "");
+    //~^ comparison_to_empty
     println!("{}", *****s5 == "");
+    //~^ comparison_to_empty
     println!("{}", ******(s6) == "");
+    //~^ comparison_to_empty
 
     let d2s = DerefToDerefToString {};
     println!("{}", &**d2s == "");
+    //~^ comparison_to_empty
 
     println!("{}", std::borrow::Cow::Borrowed("") == "");
+    //~^ comparison_to_empty
 
     let y = One;
     if y.len() == 0 {
@@ -124,18 +134,23 @@ fn main() {
 
     let has_is_empty = HasIsEmpty;
     if has_is_empty.len() == 0 {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.len() != 0 {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.len() > 0 {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.len() < 1 {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.len() >= 1 {
+        //~^ len_zero
         println!("Or this!");
     }
     if has_is_empty.len() > 1 {
@@ -147,18 +162,23 @@ fn main() {
         println!("This can happen.");
     }
     if 0 == has_is_empty.len() {
+        //~^ len_zero
         println!("Or this!");
     }
     if 0 != has_is_empty.len() {
+        //~^ len_zero
         println!("Or this!");
     }
     if 0 < has_is_empty.len() {
+        //~^ len_zero
         println!("Or this!");
     }
     if 1 <= has_is_empty.len() {
+        //~^ len_zero
         println!("Or this!");
     }
     if 1 > has_is_empty.len() {
+        //~^ len_zero
         println!("Or this!");
     }
     if 1 < has_is_empty.len() {
@@ -173,6 +193,7 @@ fn main() {
 
     let with_is_empty: &dyn WithIsEmpty = &Wither;
     if with_is_empty.len() == 0 {
+        //~^ len_zero
         println!("Or this!");
     }
     assert!(!with_is_empty.is_empty());
@@ -185,11 +206,14 @@ fn main() {
 
     // issue #10529
     (has_is_empty.len() > 0).then(|| println!("This can happen."));
+    //~^ len_zero
     (has_is_empty.len() == 0).then(|| println!("Or this!"));
+    //~^ len_zero
 }
 
 fn test_slice(b: &[u8]) {
     if b.len() != 0 {}
+    //~^ len_zero
 }
 
 // issue #11992
@@ -224,9 +248,12 @@ fn binop_with_macros() {
     if has_is_empty.len() == compare_to!(1) {}
 
     if has_is_empty.len() == compare_to!(0) {}
+    //~^ len_zero
     if has_is_empty.len() == zero!() {}
+    //~^ len_zero
 
     (compare_to!(0) < has_is_empty.len()).then(|| println!("This can happen."));
+    //~^ len_zero
 }
 
 fn no_infinite_recursion() -> bool {
diff --git a/src/tools/clippy/tests/ui/len_zero.stderr b/src/tools/clippy/tests/ui/len_zero.stderr
index 8d6b57e4b6d4..25052f39ad33 100644
--- a/src/tools/clippy/tests/ui/len_zero.stderr
+++ b/src/tools/clippy/tests/ui/len_zero.stderr
@@ -8,13 +8,13 @@ LL |     if x.len() == 0 {
    = help: to override `-D warnings` add `#[allow(clippy::len_zero)]`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:92:8
+  --> tests/ui/len_zero.rs:93:8
    |
 LL |     if "".len() == 0 {}
    |        ^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `"".is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:101:20
+  --> tests/ui/len_zero.rs:103:20
    |
 LL |     println!("{}", *s1 == "");
    |                    ^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s1.is_empty()`
@@ -23,145 +23,145 @@ LL |     println!("{}", *s1 == "");
    = help: to override `-D warnings` add `#[allow(clippy::comparison_to_empty)]`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:102:20
+  --> tests/ui/len_zero.rs:105:20
    |
 LL |     println!("{}", **s2 == "");
    |                    ^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s2.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:103:20
+  --> tests/ui/len_zero.rs:107:20
    |
 LL |     println!("{}", ***s3 == "");
    |                    ^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s3.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:104:20
+  --> tests/ui/len_zero.rs:109:20
    |
 LL |     println!("{}", ****s4 == "");
    |                    ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s4.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:105:20
+  --> tests/ui/len_zero.rs:111:20
    |
 LL |     println!("{}", *****s5 == "");
    |                    ^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `s5.is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:106:20
+  --> tests/ui/len_zero.rs:113:20
    |
 LL |     println!("{}", ******(s6) == "");
    |                    ^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(s6).is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:109:20
+  --> tests/ui/len_zero.rs:117:20
    |
 LL |     println!("{}", &**d2s == "");
    |                    ^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(**d2s).is_empty()`
 
 error: comparison to empty slice
-  --> tests/ui/len_zero.rs:111:20
+  --> tests/ui/len_zero.rs:120:20
    |
 LL |     println!("{}", std::borrow::Cow::Borrowed("") == "");
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `std::borrow::Cow::Borrowed("").is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:126:8
+  --> tests/ui/len_zero.rs:136:8
    |
 LL |     if has_is_empty.len() == 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:129:8
+  --> tests/ui/len_zero.rs:140:8
    |
 LL |     if has_is_empty.len() != 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:132:8
+  --> tests/ui/len_zero.rs:144:8
    |
 LL |     if has_is_empty.len() > 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> tests/ui/len_zero.rs:135:8
+  --> tests/ui/len_zero.rs:148:8
    |
 LL |     if has_is_empty.len() < 1 {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> tests/ui/len_zero.rs:138:8
+  --> tests/ui/len_zero.rs:152:8
    |
 LL |     if has_is_empty.len() >= 1 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:149:8
+  --> tests/ui/len_zero.rs:164:8
    |
 LL |     if 0 == has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:152:8
+  --> tests/ui/len_zero.rs:168:8
    |
 LL |     if 0 != has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:155:8
+  --> tests/ui/len_zero.rs:172:8
    |
 LL |     if 0 < has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> tests/ui/len_zero.rs:158:8
+  --> tests/ui/len_zero.rs:176:8
    |
 LL |     if 1 <= has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to one
-  --> tests/ui/len_zero.rs:161:8
+  --> tests/ui/len_zero.rs:180:8
    |
 LL |     if 1 > has_is_empty.len() {
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:175:8
+  --> tests/ui/len_zero.rs:195:8
    |
 LL |     if with_is_empty.len() == 0 {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `with_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:187:6
+  --> tests/ui/len_zero.rs:208:6
    |
 LL |     (has_is_empty.len() > 0).then(|| println!("This can happen."));
    |      ^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:188:6
+  --> tests/ui/len_zero.rs:210:6
    |
 LL |     (has_is_empty.len() == 0).then(|| println!("Or this!"));
    |      ^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:192:8
+  --> tests/ui/len_zero.rs:215:8
    |
 LL |     if b.len() != 0 {}
    |        ^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!b.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:226:8
+  --> tests/ui/len_zero.rs:250:8
    |
 LL |     if has_is_empty.len() == compare_to!(0) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:227:8
+  --> tests/ui/len_zero.rs:252:8
    |
 LL |     if has_is_empty.len() == zero!() {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `has_is_empty.is_empty()`
 
 error: length comparison to zero
-  --> tests/ui/len_zero.rs:229:6
+  --> tests/ui/len_zero.rs:255:6
    |
 LL |     (compare_to!(0) < has_is_empty.len()).then(|| println!("This can happen."));
    |      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: using `!is_empty` is clearer and more explicit: `!has_is_empty.is_empty()`
diff --git a/src/tools/clippy/tests/ui/len_zero_ranges.fixed b/src/tools/clippy/tests/ui/len_zero_ranges.fixed
index 1fdeb2c7a37b..d5b514d98113 100644
--- a/src/tools/clippy/tests/ui/len_zero_ranges.fixed
+++ b/src/tools/clippy/tests/ui/len_zero_ranges.fixed
@@ -5,10 +5,12 @@
 mod issue_3807 {
     fn suggestion_is_fine_range() {
         let _ = (0..42).is_empty();
+        //~^ len_zero
     }
 
     fn suggestion_is_fine_range_inclusive() {
         let _ = (0_u8..=42).is_empty();
+        //~^ len_zero
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/len_zero_ranges.rs b/src/tools/clippy/tests/ui/len_zero_ranges.rs
index a5c9a969aaa6..98c97ca02457 100644
--- a/src/tools/clippy/tests/ui/len_zero_ranges.rs
+++ b/src/tools/clippy/tests/ui/len_zero_ranges.rs
@@ -5,10 +5,12 @@
 mod issue_3807 {
     fn suggestion_is_fine_range() {
         let _ = (0..42).len() == 0;
+        //~^ len_zero
     }
 
     fn suggestion_is_fine_range_inclusive() {
         let _ = (0_u8..=42).len() == 0;
+        //~^ len_zero
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/len_zero_ranges.stderr b/src/tools/clippy/tests/ui/len_zero_ranges.stderr
index 0b2991e15ea3..10845bcade47 100644
--- a/src/tools/clippy/tests/ui/len_zero_ranges.stderr
+++ b/src/tools/clippy/tests/ui/len_zero_ranges.stderr
@@ -8,7 +8,7 @@ LL |         let _ = (0..42).len() == 0;
    = help: to override `-D warnings` add `#[allow(clippy::len_zero)]`
 
 error: length comparison to zero
-  --> tests/ui/len_zero_ranges.rs:11:17
+  --> tests/ui/len_zero_ranges.rs:12:17
    |
 LL |         let _ = (0_u8..=42).len() == 0;
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: using `is_empty` is clearer and more explicit: `(0_u8..=42).is_empty()`
diff --git a/src/tools/clippy/tests/ui/let_and_return.edition2021.fixed b/src/tools/clippy/tests/ui/let_and_return.edition2021.fixed
new file mode 100644
index 000000000000..70d503018e0f
--- /dev/null
+++ b/src/tools/clippy/tests/ui/let_and_return.edition2021.fixed
@@ -0,0 +1,264 @@
+//@revisions: edition2021 edition2024
+//@[edition2021] edition:2021
+//@[edition2024] edition:2024
+
+#![allow(unused)]
+#![warn(clippy::let_and_return)]
+
+use std::cell::RefCell;
+
+fn test() -> i32 {
+    let _y = 0; // no warning
+    
+    5
+    //~^ let_and_return
+}
+
+fn test_inner() -> i32 {
+    if true {
+        
+        5
+        //~^ let_and_return
+    } else {
+        0
+    }
+}
+
+fn test_nowarn_1() -> i32 {
+    let mut x = 5;
+    x += 1;
+    x
+}
+
+fn test_nowarn_2() -> i32 {
+    let x = 5;
+    x + 1
+}
+
+fn test_nowarn_3() -> (i32, i32) {
+    // this should technically warn, but we do not compare complex patterns
+    let (x, y) = (5, 9);
+    (x, y)
+}
+
+fn test_nowarn_4() -> i32 {
+    // this should technically warn, but not b/c of clippy::let_and_return, but b/c of useless type
+    let x: i32 = 5;
+    x
+}
+
+fn test_nowarn_5(x: i16) -> u16 {
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    let x = x as u16;
+    x
+}
+
+// False positive example
+trait Decode {
+    fn decode<D: std::io::Read>(d: D) -> Result<Self, ()>
+    where
+        Self: Sized;
+}
+
+macro_rules! tuple_encode {
+    ($($x:ident),*) => (
+        impl<$($x: Decode),*> Decode for ($($x),*) {
+            #[inline]
+            #[allow(non_snake_case)]
+            fn decode<D: std::io::Read>(mut d: D) -> Result<Self, ()> {
+                // Shouldn't trigger lint
+                Ok(($({let $x = Decode::decode(&mut d)?; $x }),*))
+            }
+        }
+    );
+}
+
+fn issue_3792() -> String {
+    use std::io::{self, BufRead, Stdin};
+
+    let stdin = io::stdin();
+    // `Stdin::lock` returns `StdinLock<'static>` so `line` doesn't borrow from `stdin`
+    // https://github.com/rust-lang/rust/pull/93965
+    
+    stdin.lock().lines().next().unwrap().unwrap()
+    //~^ let_and_return
+}
+
+tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
+
+mod no_lint_if_stmt_borrows {
+    use std::cell::RefCell;
+    use std::rc::{Rc, Weak};
+    struct Bar;
+
+    impl Bar {
+        fn new() -> Self {
+            Bar {}
+        }
+        fn baz(&self) -> u32 {
+            0
+        }
+    }
+
+    fn issue_3324(value: Weak<RefCell<Bar>>) -> u32 {
+        let value = value.upgrade().unwrap();
+        let ret = value.borrow().baz();
+        ret
+        //~[edition2024]^ let_and_return
+    }
+
+    fn borrows_in_closure(value: Weak<RefCell<Bar>>) -> u32 {
+        fn f(mut x: impl FnMut() -> u32) -> impl FnMut() -> u32 {
+            x
+        }
+
+        let value = value.upgrade().unwrap();
+        let ret = f(|| value.borrow().baz())();
+        ret
+        //~[edition2024]^ let_and_return
+    }
+
+    mod free_function {
+        struct Inner;
+
+        struct Foo<'a> {
+            inner: &'a Inner,
+        }
+
+        impl Drop for Foo<'_> {
+            fn drop(&mut self) {}
+        }
+
+        impl<'a> Foo<'a> {
+            fn new(inner: &'a Inner) -> Self {
+                Self { inner }
+            }
+
+            fn value(&self) -> i32 {
+                42
+            }
+        }
+
+        fn some_foo(inner: &Inner) -> Foo<'_> {
+            Foo { inner }
+        }
+
+        fn test() -> i32 {
+            let x = Inner {};
+            let value = some_foo(&x).value();
+            value
+            //~[edition2024]^ let_and_return
+        }
+
+        fn test2() -> i32 {
+            let x = Inner {};
+            let value = Foo::new(&x).value();
+            value
+            //~[edition2024]^ let_and_return
+        }
+    }
+}
+
+mod issue_5729 {
+    use std::sync::Arc;
+
+    trait Foo {}
+
+    trait FooStorage {
+        fn foo_cloned(&self) -> Arc<dyn Foo>;
+    }
+
+    struct FooStorageImpl<T: Foo> {
+        foo: Arc<T>,
+    }
+
+    impl<T: Foo + 'static> FooStorage for FooStorageImpl<T> {
+        fn foo_cloned(&self) -> Arc<dyn Foo> {
+            
+            (Arc::clone(&self.foo)) as _
+            //~^ let_and_return
+        }
+    }
+}
+
+mod issue_11335 {
+    pub enum E<T> {
+        A(T),
+        B(T),
+    }
+
+    impl<T> E<T> {
+        pub fn inner(&self) -> &T {
+            
+
+            (match self {
+                E::A(x) => x,
+                E::B(x) => x,
+            }) as _
+            //~^ let_and_return
+        }
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/issues/11167
+macro_rules! fn_in_macro {
+    ($b:block) => {
+        fn f() -> usize $b
+    }
+}
+fn_in_macro!({
+    return 1;
+});
+
+fn issue9150() -> usize {
+    let x = 1;
+    #[cfg(any())]
+    panic!("can't see me");
+    x
+}
+
+fn issue12801() {
+    fn left_is_if() -> String {
+        
+        (if true { "a".to_string() } else { "b".to_string() } + "c")
+        //~^ let_and_return
+    }
+
+    fn no_par_needed() -> String {
+        
+        "c".to_string() + if true { "a" } else { "b" }
+        //~^ let_and_return
+    }
+
+    fn conjunctive_blocks() -> String {
+        
+        ({ "a".to_string() } + "b" + { "c" } + "d")
+        //~^ let_and_return
+    }
+
+    #[allow(clippy::overly_complex_bool_expr)]
+    fn other_ops() {
+        let _ = || {
+            
+            (if true { 2 } else { 3 } << 4)
+            //~^ let_and_return
+        };
+        let _ = || {
+            
+            ({ true } || { false } && { 2 <= 3 })
+            //~^ let_and_return
+        };
+    }
+}
+
+fn issue14164() -> Result<u32, ()> {
+    let v = std::cell::RefCell::new(Some(vec![1]));
+    let r = match &*v.borrow() {
+        Some(v) => Ok(Ok(v[0])),
+        None => Ok(Ok(0)),
+    }?;
+    r
+    //~[edition2024]^ let_and_return
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/let_and_return.edition2021.stderr b/src/tools/clippy/tests/ui/let_and_return.edition2021.stderr
new file mode 100644
index 000000000000..f9536d1b5477
--- /dev/null
+++ b/src/tools/clippy/tests/ui/let_and_return.edition2021.stderr
@@ -0,0 +1,152 @@
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:13:5
+   |
+LL |     let x = 5;
+   |     ---------- unnecessary `let` binding
+LL |     x
+   |     ^
+   |
+   = note: `-D clippy::let-and-return` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::let_and_return)]`
+help: return the expression directly
+   |
+LL ~     
+LL ~     5
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:20:9
+   |
+LL |         let x = 5;
+   |         ---------- unnecessary `let` binding
+LL |         x
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         5
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:83:5
+   |
+LL |     let line = stdin.lock().lines().next().unwrap().unwrap();
+   |     --------------------------------------------------------- unnecessary `let` binding
+LL |     line
+   |     ^^^^
+   |
+help: return the expression directly
+   |
+LL ~     
+LL ~     stdin.lock().lines().next().unwrap().unwrap()
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:178:13
+   |
+LL |             let clone = Arc::clone(&self.foo);
+   |             ---------------------------------- unnecessary `let` binding
+LL |             clone
+   |             ^^^^^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             (Arc::clone(&self.foo)) as _
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:197:13
+   |
+LL | /             let result = match self {
+LL | |                 E::A(x) => x,
+LL | |                 E::B(x) => x,
+LL | |             };
+   | |______________- unnecessary `let` binding
+LL |
+LL |               result
+   |               ^^^^^^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL |
+LL ~             (match self {
+LL +                 E::A(x) => x,
+LL +                 E::B(x) => x,
+LL +             }) as _
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:223:9
+   |
+LL |         let s = if true { "a".to_string() } else { "b".to_string() } + "c";
+   |         ------------------------------------------------------------------- unnecessary `let` binding
+LL |         s
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         (if true { "a".to_string() } else { "b".to_string() } + "c")
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:229:9
+   |
+LL |         let s = "c".to_string() + if true { "a" } else { "b" };
+   |         ------------------------------------------------------- unnecessary `let` binding
+LL |         s
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         "c".to_string() + if true { "a" } else { "b" }
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:235:9
+   |
+LL |         let s = { "a".to_string() } + "b" + { "c" } + "d";
+   |         -------------------------------------------------- unnecessary `let` binding
+LL |         s
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         ({ "a".to_string() } + "b" + { "c" } + "d")
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:243:13
+   |
+LL |             let s = if true { 2 } else { 3 } << 4;
+   |             -------------------------------------- unnecessary `let` binding
+LL |             s
+   |             ^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             (if true { 2 } else { 3 } << 4)
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:248:13
+   |
+LL |             let s = { true } || { false } && { 2 <= 3 };
+   |             -------------------------------------------- unnecessary `let` binding
+LL |             s
+   |             ^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             ({ true } || { false } && { 2 <= 3 })
+   |
+
+error: aborting due to 10 previous errors
+
diff --git a/src/tools/clippy/tests/ui/let_and_return.edition2024.fixed b/src/tools/clippy/tests/ui/let_and_return.edition2024.fixed
new file mode 100644
index 000000000000..9990c3b71205
--- /dev/null
+++ b/src/tools/clippy/tests/ui/let_and_return.edition2024.fixed
@@ -0,0 +1,264 @@
+//@revisions: edition2021 edition2024
+//@[edition2021] edition:2021
+//@[edition2024] edition:2024
+
+#![allow(unused)]
+#![warn(clippy::let_and_return)]
+
+use std::cell::RefCell;
+
+fn test() -> i32 {
+    let _y = 0; // no warning
+    
+    5
+    //~^ let_and_return
+}
+
+fn test_inner() -> i32 {
+    if true {
+        
+        5
+        //~^ let_and_return
+    } else {
+        0
+    }
+}
+
+fn test_nowarn_1() -> i32 {
+    let mut x = 5;
+    x += 1;
+    x
+}
+
+fn test_nowarn_2() -> i32 {
+    let x = 5;
+    x + 1
+}
+
+fn test_nowarn_3() -> (i32, i32) {
+    // this should technically warn, but we do not compare complex patterns
+    let (x, y) = (5, 9);
+    (x, y)
+}
+
+fn test_nowarn_4() -> i32 {
+    // this should technically warn, but not b/c of clippy::let_and_return, but b/c of useless type
+    let x: i32 = 5;
+    x
+}
+
+fn test_nowarn_5(x: i16) -> u16 {
+    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    let x = x as u16;
+    x
+}
+
+// False positive example
+trait Decode {
+    fn decode<D: std::io::Read>(d: D) -> Result<Self, ()>
+    where
+        Self: Sized;
+}
+
+macro_rules! tuple_encode {
+    ($($x:ident),*) => (
+        impl<$($x: Decode),*> Decode for ($($x),*) {
+            #[inline]
+            #[allow(non_snake_case)]
+            fn decode<D: std::io::Read>(mut d: D) -> Result<Self, ()> {
+                // Shouldn't trigger lint
+                Ok(($({let $x = Decode::decode(&mut d)?; $x }),*))
+            }
+        }
+    );
+}
+
+fn issue_3792() -> String {
+    use std::io::{self, BufRead, Stdin};
+
+    let stdin = io::stdin();
+    // `Stdin::lock` returns `StdinLock<'static>` so `line` doesn't borrow from `stdin`
+    // https://github.com/rust-lang/rust/pull/93965
+    
+    stdin.lock().lines().next().unwrap().unwrap()
+    //~^ let_and_return
+}
+
+tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
+
+mod no_lint_if_stmt_borrows {
+    use std::cell::RefCell;
+    use std::rc::{Rc, Weak};
+    struct Bar;
+
+    impl Bar {
+        fn new() -> Self {
+            Bar {}
+        }
+        fn baz(&self) -> u32 {
+            0
+        }
+    }
+
+    fn issue_3324(value: Weak<RefCell<Bar>>) -> u32 {
+        let value = value.upgrade().unwrap();
+        
+        value.borrow().baz()
+        //~[edition2024]^ let_and_return
+    }
+
+    fn borrows_in_closure(value: Weak<RefCell<Bar>>) -> u32 {
+        fn f(mut x: impl FnMut() -> u32) -> impl FnMut() -> u32 {
+            x
+        }
+
+        let value = value.upgrade().unwrap();
+        
+        f(|| value.borrow().baz())()
+        //~[edition2024]^ let_and_return
+    }
+
+    mod free_function {
+        struct Inner;
+
+        struct Foo<'a> {
+            inner: &'a Inner,
+        }
+
+        impl Drop for Foo<'_> {
+            fn drop(&mut self) {}
+        }
+
+        impl<'a> Foo<'a> {
+            fn new(inner: &'a Inner) -> Self {
+                Self { inner }
+            }
+
+            fn value(&self) -> i32 {
+                42
+            }
+        }
+
+        fn some_foo(inner: &Inner) -> Foo<'_> {
+            Foo { inner }
+        }
+
+        fn test() -> i32 {
+            let x = Inner {};
+            
+            some_foo(&x).value()
+            //~[edition2024]^ let_and_return
+        }
+
+        fn test2() -> i32 {
+            let x = Inner {};
+            
+            Foo::new(&x).value()
+            //~[edition2024]^ let_and_return
+        }
+    }
+}
+
+mod issue_5729 {
+    use std::sync::Arc;
+
+    trait Foo {}
+
+    trait FooStorage {
+        fn foo_cloned(&self) -> Arc<dyn Foo>;
+    }
+
+    struct FooStorageImpl<T: Foo> {
+        foo: Arc<T>,
+    }
+
+    impl<T: Foo + 'static> FooStorage for FooStorageImpl<T> {
+        fn foo_cloned(&self) -> Arc<dyn Foo> {
+            
+            (Arc::clone(&self.foo)) as _
+            //~^ let_and_return
+        }
+    }
+}
+
+mod issue_11335 {
+    pub enum E<T> {
+        A(T),
+        B(T),
+    }
+
+    impl<T> E<T> {
+        pub fn inner(&self) -> &T {
+            
+
+            (match self {
+                E::A(x) => x,
+                E::B(x) => x,
+            }) as _
+            //~^ let_and_return
+        }
+    }
+}
+
+// https://github.com/rust-lang/rust-clippy/issues/11167
+macro_rules! fn_in_macro {
+    ($b:block) => {
+        fn f() -> usize $b
+    }
+}
+fn_in_macro!({
+    return 1;
+});
+
+fn issue9150() -> usize {
+    let x = 1;
+    #[cfg(any())]
+    panic!("can't see me");
+    x
+}
+
+fn issue12801() {
+    fn left_is_if() -> String {
+        
+        (if true { "a".to_string() } else { "b".to_string() } + "c")
+        //~^ let_and_return
+    }
+
+    fn no_par_needed() -> String {
+        
+        "c".to_string() + if true { "a" } else { "b" }
+        //~^ let_and_return
+    }
+
+    fn conjunctive_blocks() -> String {
+        
+        ({ "a".to_string() } + "b" + { "c" } + "d")
+        //~^ let_and_return
+    }
+
+    #[allow(clippy::overly_complex_bool_expr)]
+    fn other_ops() {
+        let _ = || {
+            
+            (if true { 2 } else { 3 } << 4)
+            //~^ let_and_return
+        };
+        let _ = || {
+            
+            ({ true } || { false } && { 2 <= 3 })
+            //~^ let_and_return
+        };
+    }
+}
+
+fn issue14164() -> Result<u32, ()> {
+    let v = std::cell::RefCell::new(Some(vec![1]));
+    
+    match &*v.borrow() {
+        Some(v) => Ok(Ok(v[0])),
+        None => Ok(Ok(0)),
+    }?
+    //~[edition2024]^ let_and_return
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/let_and_return.edition2024.stderr b/src/tools/clippy/tests/ui/let_and_return.edition2024.stderr
new file mode 100644
index 000000000000..ca378fa43232
--- /dev/null
+++ b/src/tools/clippy/tests/ui/let_and_return.edition2024.stderr
@@ -0,0 +1,228 @@
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:13:5
+   |
+LL |     let x = 5;
+   |     ---------- unnecessary `let` binding
+LL |     x
+   |     ^
+   |
+   = note: `-D clippy::let-and-return` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::let_and_return)]`
+help: return the expression directly
+   |
+LL ~     
+LL ~     5
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:20:9
+   |
+LL |         let x = 5;
+   |         ---------- unnecessary `let` binding
+LL |         x
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         5
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:83:5
+   |
+LL |     let line = stdin.lock().lines().next().unwrap().unwrap();
+   |     --------------------------------------------------------- unnecessary `let` binding
+LL |     line
+   |     ^^^^
+   |
+help: return the expression directly
+   |
+LL ~     
+LL ~     stdin.lock().lines().next().unwrap().unwrap()
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:106:9
+   |
+LL |         let ret = value.borrow().baz();
+   |         ------------------------------- unnecessary `let` binding
+LL |         ret
+   |         ^^^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         value.borrow().baz()
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:117:9
+   |
+LL |         let ret = f(|| value.borrow().baz())();
+   |         --------------------------------------- unnecessary `let` binding
+LL |         ret
+   |         ^^^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         f(|| value.borrow().baz())()
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:149:13
+   |
+LL |             let value = some_foo(&x).value();
+   |             --------------------------------- unnecessary `let` binding
+LL |             value
+   |             ^^^^^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             some_foo(&x).value()
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:156:13
+   |
+LL |             let value = Foo::new(&x).value();
+   |             --------------------------------- unnecessary `let` binding
+LL |             value
+   |             ^^^^^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             Foo::new(&x).value()
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:178:13
+   |
+LL |             let clone = Arc::clone(&self.foo);
+   |             ---------------------------------- unnecessary `let` binding
+LL |             clone
+   |             ^^^^^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             (Arc::clone(&self.foo)) as _
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:197:13
+   |
+LL | /             let result = match self {
+LL | |                 E::A(x) => x,
+LL | |                 E::B(x) => x,
+LL | |             };
+   | |______________- unnecessary `let` binding
+LL |
+LL |               result
+   |               ^^^^^^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL |
+LL ~             (match self {
+LL +                 E::A(x) => x,
+LL +                 E::B(x) => x,
+LL +             }) as _
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:223:9
+   |
+LL |         let s = if true { "a".to_string() } else { "b".to_string() } + "c";
+   |         ------------------------------------------------------------------- unnecessary `let` binding
+LL |         s
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         (if true { "a".to_string() } else { "b".to_string() } + "c")
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:229:9
+   |
+LL |         let s = "c".to_string() + if true { "a" } else { "b" };
+   |         ------------------------------------------------------- unnecessary `let` binding
+LL |         s
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         "c".to_string() + if true { "a" } else { "b" }
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:235:9
+   |
+LL |         let s = { "a".to_string() } + "b" + { "c" } + "d";
+   |         -------------------------------------------------- unnecessary `let` binding
+LL |         s
+   |         ^
+   |
+help: return the expression directly
+   |
+LL ~         
+LL ~         ({ "a".to_string() } + "b" + { "c" } + "d")
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:243:13
+   |
+LL |             let s = if true { 2 } else { 3 } << 4;
+   |             -------------------------------------- unnecessary `let` binding
+LL |             s
+   |             ^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             (if true { 2 } else { 3 } << 4)
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:248:13
+   |
+LL |             let s = { true } || { false } && { 2 <= 3 };
+   |             -------------------------------------------- unnecessary `let` binding
+LL |             s
+   |             ^
+   |
+help: return the expression directly
+   |
+LL ~             
+LL ~             ({ true } || { false } && { 2 <= 3 })
+   |
+
+error: returning the result of a `let` binding from a block
+  --> tests/ui/let_and_return.rs:260:5
+   |
+LL | /     let r = match &*v.borrow() {
+LL | |         Some(v) => Ok(Ok(v[0])),
+LL | |         None => Ok(Ok(0)),
+LL | |     }?;
+   | |_______- unnecessary `let` binding
+LL |       r
+   |       ^
+   |
+help: return the expression directly
+   |
+LL ~     
+LL ~     match &*v.borrow() {
+LL +         Some(v) => Ok(Ok(v[0])),
+LL +         None => Ok(Ok(0)),
+LL +     }?
+   |
+
+error: aborting due to 15 previous errors
+
diff --git a/src/tools/clippy/tests/ui/let_and_return.fixed b/src/tools/clippy/tests/ui/let_and_return.fixed
index b68b41cdca23..e22e66eb522e 100644
--- a/src/tools/clippy/tests/ui/let_and_return.fixed
+++ b/src/tools/clippy/tests/ui/let_and_return.fixed
@@ -244,4 +244,14 @@ fn issue12801() {
     }
 }
 
+// Do not lint
+fn issue14164() -> Result<u32, ()> {
+    let v = std::cell::RefCell::new(Some(vec![1]));
+    let r = match &*v.borrow() {
+        Some(v) => Ok(Ok(v[0])),
+        None => Ok(Ok(0)),
+    }?;
+    r
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/let_and_return.rs b/src/tools/clippy/tests/ui/let_and_return.rs
index 6b9035f94288..48c20cdd60db 100644
--- a/src/tools/clippy/tests/ui/let_and_return.rs
+++ b/src/tools/clippy/tests/ui/let_and_return.rs
@@ -1,3 +1,7 @@
+//@revisions: edition2021 edition2024
+//@[edition2021] edition:2021
+//@[edition2024] edition:2024
+
 #![allow(unused)]
 #![warn(clippy::let_and_return)]
 
@@ -7,15 +11,14 @@ fn test() -> i32 {
     let _y = 0; // no warning
     let x = 5;
     x
-    //~^ ERROR: returning the result of a `let` binding from a block
-    //~| NOTE: `-D clippy::let-and-return` implied by `-D warnings`
+    //~^ let_and_return
 }
 
 fn test_inner() -> i32 {
     if true {
         let x = 5;
         x
-        //~^ ERROR: returning the result of a `let` binding from a block
+        //~^ let_and_return
     } else {
         0
     }
@@ -78,7 +81,7 @@ fn issue_3792() -> String {
     // https://github.com/rust-lang/rust/pull/93965
     let line = stdin.lock().lines().next().unwrap().unwrap();
     line
-    //~^ ERROR: returning the result of a `let` binding from a block
+    //~^ let_and_return
 }
 
 tuple_encode!(T0, T1, T2, T3, T4, T5, T6, T7);
@@ -101,6 +104,7 @@ mod no_lint_if_stmt_borrows {
         let value = value.upgrade().unwrap();
         let ret = value.borrow().baz();
         ret
+        //~[edition2024]^ let_and_return
     }
 
     fn borrows_in_closure(value: Weak<RefCell<Bar>>) -> u32 {
@@ -111,6 +115,7 @@ mod no_lint_if_stmt_borrows {
         let value = value.upgrade().unwrap();
         let ret = f(|| value.borrow().baz())();
         ret
+        //~[edition2024]^ let_and_return
     }
 
     mod free_function {
@@ -142,12 +147,14 @@ mod no_lint_if_stmt_borrows {
             let x = Inner {};
             let value = some_foo(&x).value();
             value
+            //~[edition2024]^ let_and_return
         }
 
         fn test2() -> i32 {
             let x = Inner {};
             let value = Foo::new(&x).value();
             value
+            //~[edition2024]^ let_and_return
         }
     }
 }
@@ -169,7 +176,7 @@ mod issue_5729 {
         fn foo_cloned(&self) -> Arc<dyn Foo> {
             let clone = Arc::clone(&self.foo);
             clone
-            //~^ ERROR: returning the result of a `let` binding from a block
+            //~^ let_and_return
         }
     }
 }
@@ -188,7 +195,7 @@ mod issue_11335 {
             };
 
             result
-            //~^ ERROR: returning the result of a `let` binding from a block
+            //~^ let_and_return
         }
     }
 }
@@ -214,19 +221,19 @@ fn issue12801() {
     fn left_is_if() -> String {
         let s = if true { "a".to_string() } else { "b".to_string() } + "c";
         s
-        //~^ ERROR: returning the result of a `let` binding from a block
+        //~^ let_and_return
     }
 
     fn no_par_needed() -> String {
         let s = "c".to_string() + if true { "a" } else { "b" };
         s
-        //~^ ERROR: returning the result of a `let` binding from a block
+        //~^ let_and_return
     }
 
     fn conjunctive_blocks() -> String {
         let s = { "a".to_string() } + "b" + { "c" } + "d";
         s
-        //~^ ERROR: returning the result of a `let` binding from a block
+        //~^ let_and_return
     }
 
     #[allow(clippy::overly_complex_bool_expr)]
@@ -234,14 +241,24 @@ fn issue12801() {
         let _ = || {
             let s = if true { 2 } else { 3 } << 4;
             s
-            //~^ ERROR: returning the result of a `let` binding from a block
+            //~^ let_and_return
         };
         let _ = || {
             let s = { true } || { false } && { 2 <= 3 };
             s
-            //~^ ERROR: returning the result of a `let` binding from a block
+            //~^ let_and_return
         };
     }
 }
 
+fn issue14164() -> Result<u32, ()> {
+    let v = std::cell::RefCell::new(Some(vec![1]));
+    let r = match &*v.borrow() {
+        Some(v) => Ok(Ok(v[0])),
+        None => Ok(Ok(0)),
+    }?;
+    r
+    //~[edition2024]^ let_and_return
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/let_if_seq.rs b/src/tools/clippy/tests/ui/let_if_seq.rs
index a29d35880b8d..2db206212aa5 100644
--- a/src/tools/clippy/tests/ui/let_if_seq.rs
+++ b/src/tools/clippy/tests/ui/let_if_seq.rs
@@ -75,15 +75,15 @@ fn main() {
     issue985_alt();
 
     let mut foo = 0;
-    //~^ ERROR: `if _ { .. } else { .. }` is an expression
-    //~| NOTE: you might not need `mut` at all
+    //~^ useless_let_if_seq
+
     if f() {
         foo = 42;
     }
 
     let mut bar = 0;
-    //~^ ERROR: `if _ { .. } else { .. }` is an expression
-    //~| NOTE: you might not need `mut` at all
+    //~^ useless_let_if_seq
+
     if f() {
         f();
         bar = 42;
@@ -92,7 +92,8 @@ fn main() {
     }
 
     let quz;
-    //~^ ERROR: `if _ { .. } else { .. }` is an expression
+    //~^ useless_let_if_seq
+
     if f() {
         quz = 42;
     } else {
@@ -122,8 +123,8 @@ fn main() {
 
     // baz needs to be mut
     let mut baz = 0;
-    //~^ ERROR: `if _ { .. } else { .. }` is an expression
-    //~| NOTE: you might not need `mut` at all
+    //~^ useless_let_if_seq
+
     if f() {
         baz = 42;
     }
diff --git a/src/tools/clippy/tests/ui/let_if_seq.stderr b/src/tools/clippy/tests/ui/let_if_seq.stderr
index 41930108fb1a..f59d42bf4c8d 100644
--- a/src/tools/clippy/tests/ui/let_if_seq.stderr
+++ b/src/tools/clippy/tests/ui/let_if_seq.stderr
@@ -32,15 +32,15 @@ error: `if _ { .. } else { .. }` is an expression
    |
 LL | /     let quz;
 LL | |
+LL | |
 LL | |     if f() {
-LL | |         quz = 42;
-LL | |     } else {
+...  |
 LL | |         quz = 0;
 LL | |     }
    | |_____^ help: it is more idiomatic to write: `let quz = if f() { 42 } else { 0 };`
 
 error: `if _ { .. } else { .. }` is an expression
-  --> tests/ui/let_if_seq.rs:124:5
+  --> tests/ui/let_if_seq.rs:125:5
    |
 LL | /     let mut baz = 0;
 LL | |
diff --git a/src/tools/clippy/tests/ui/let_underscore_future.rs b/src/tools/clippy/tests/ui/let_underscore_future.rs
index c2185e9785d8..6347c792280e 100644
--- a/src/tools/clippy/tests/ui/let_underscore_future.rs
+++ b/src/tools/clippy/tests/ui/let_underscore_future.rs
@@ -12,12 +12,13 @@ fn do_something_to_future(future: &mut impl Future<Output = ()>) {}
 
 fn main() {
     let _ = some_async_fn();
-    //~^ ERROR: non-binding `let` on a future
+    //~^ let_underscore_future
+
     let _ = custom();
-    //~^ ERROR: non-binding `let` on a future
+    //~^ let_underscore_future
 
     let mut future = some_async_fn();
     do_something_to_future(&mut future);
     let _ = future;
-    //~^ ERROR: non-binding `let` on a future
+    //~^ let_underscore_future
 }
diff --git a/src/tools/clippy/tests/ui/let_underscore_future.stderr b/src/tools/clippy/tests/ui/let_underscore_future.stderr
index 66aeb5035394..baa489551d4a 100644
--- a/src/tools/clippy/tests/ui/let_underscore_future.stderr
+++ b/src/tools/clippy/tests/ui/let_underscore_future.stderr
@@ -9,7 +9,7 @@ LL |     let _ = some_async_fn();
    = help: to override `-D warnings` add `#[allow(clippy::let_underscore_future)]`
 
 error: non-binding `let` on a future
-  --> tests/ui/let_underscore_future.rs:16:5
+  --> tests/ui/let_underscore_future.rs:17:5
    |
 LL |     let _ = custom();
    |     ^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     let _ = custom();
    = help: consider awaiting the future or dropping explicitly with `std::mem::drop`
 
 error: non-binding `let` on a future
-  --> tests/ui/let_underscore_future.rs:21:5
+  --> tests/ui/let_underscore_future.rs:22:5
    |
 LL |     let _ = future;
    |     ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/let_underscore_must_use.rs b/src/tools/clippy/tests/ui/let_underscore_must_use.rs
index 3290d087724e..5cf31ec63c66 100644
--- a/src/tools/clippy/tests/ui/let_underscore_must_use.rs
+++ b/src/tools/clippy/tests/ui/let_underscore_must_use.rs
@@ -65,42 +65,47 @@ impl Trait for S {
 
 fn main() {
     let _ = f();
-    //~^ ERROR: non-binding `let` on a result of a `#[must_use]` function
+    //~^ let_underscore_must_use
+
     let _ = g();
-    //~^ ERROR: non-binding `let` on an expression with `#[must_use]` type
+    //~^ let_underscore_must_use
+
     let _ = h();
     let _ = l(0_u32);
-    //~^ ERROR: non-binding `let` on a result of a `#[must_use]` function
+    //~^ let_underscore_must_use
 
     let s = S {};
 
     let _ = s.f();
-    //~^ ERROR: non-binding `let` on a result of a `#[must_use]` function
+    //~^ let_underscore_must_use
+
     let _ = s.g();
-    //~^ ERROR: non-binding `let` on an expression with `#[must_use]` type
+    //~^ let_underscore_must_use
+
     let _ = s.k();
 
     let _ = S::h();
-    //~^ ERROR: non-binding `let` on a result of a `#[must_use]` function
+    //~^ let_underscore_must_use
+
     let _ = S::p();
-    //~^ ERROR: non-binding `let` on an expression with `#[must_use]` type
+    //~^ let_underscore_must_use
 
     let _ = S::a();
-    //~^ ERROR: non-binding `let` on a result of a `#[must_use]` function
+    //~^ let_underscore_must_use
 
     let _ = if true { Ok(()) } else { Err(()) };
-    //~^ ERROR: non-binding `let` on an expression with `#[must_use]` type
+    //~^ let_underscore_must_use
 
     let a = Result::<(), ()>::Ok(());
 
     let _ = a.is_ok();
-    //~^ ERROR: non-binding `let` on a result of a `#[must_use]` function
+    //~^ let_underscore_must_use
 
     let _ = a.map(|_| ());
-    //~^ ERROR: non-binding `let` on an expression with `#[must_use]` type
+    //~^ let_underscore_must_use
 
     let _ = a;
-    //~^ ERROR: non-binding `let` on an expression with `#[must_use]` type
+    //~^ let_underscore_must_use
 
     #[allow(clippy::let_underscore_must_use)]
     let _ = a;
diff --git a/src/tools/clippy/tests/ui/let_underscore_must_use.stderr b/src/tools/clippy/tests/ui/let_underscore_must_use.stderr
index e8785b92b815..130ea11646fd 100644
--- a/src/tools/clippy/tests/ui/let_underscore_must_use.stderr
+++ b/src/tools/clippy/tests/ui/let_underscore_must_use.stderr
@@ -9,7 +9,7 @@ LL |     let _ = f();
    = help: to override `-D warnings` add `#[allow(clippy::let_underscore_must_use)]`
 
 error: non-binding `let` on an expression with `#[must_use]` type
-  --> tests/ui/let_underscore_must_use.rs:69:5
+  --> tests/ui/let_underscore_must_use.rs:70:5
    |
 LL |     let _ = g();
    |     ^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     let _ = g();
    = help: consider explicitly using expression value
 
 error: non-binding `let` on a result of a `#[must_use]` function
-  --> tests/ui/let_underscore_must_use.rs:72:5
+  --> tests/ui/let_underscore_must_use.rs:74:5
    |
 LL |     let _ = l(0_u32);
    |     ^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     let _ = l(0_u32);
    = help: consider explicitly using function result
 
 error: non-binding `let` on a result of a `#[must_use]` function
-  --> tests/ui/let_underscore_must_use.rs:77:5
+  --> tests/ui/let_underscore_must_use.rs:79:5
    |
 LL |     let _ = s.f();
    |     ^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     let _ = s.f();
    = help: consider explicitly using function result
 
 error: non-binding `let` on an expression with `#[must_use]` type
-  --> tests/ui/let_underscore_must_use.rs:79:5
+  --> tests/ui/let_underscore_must_use.rs:82:5
    |
 LL |     let _ = s.g();
    |     ^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     let _ = s.g();
    = help: consider explicitly using expression value
 
 error: non-binding `let` on a result of a `#[must_use]` function
-  --> tests/ui/let_underscore_must_use.rs:83:5
+  --> tests/ui/let_underscore_must_use.rs:87:5
    |
 LL |     let _ = S::h();
    |     ^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     let _ = S::h();
    = help: consider explicitly using function result
 
 error: non-binding `let` on an expression with `#[must_use]` type
-  --> tests/ui/let_underscore_must_use.rs:85:5
+  --> tests/ui/let_underscore_must_use.rs:90:5
    |
 LL |     let _ = S::p();
    |     ^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     let _ = S::p();
    = help: consider explicitly using expression value
 
 error: non-binding `let` on a result of a `#[must_use]` function
-  --> tests/ui/let_underscore_must_use.rs:88:5
+  --> tests/ui/let_underscore_must_use.rs:93:5
    |
 LL |     let _ = S::a();
    |     ^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     let _ = S::a();
    = help: consider explicitly using function result
 
 error: non-binding `let` on an expression with `#[must_use]` type
-  --> tests/ui/let_underscore_must_use.rs:91:5
+  --> tests/ui/let_underscore_must_use.rs:96:5
    |
 LL |     let _ = if true { Ok(()) } else { Err(()) };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     let _ = if true { Ok(()) } else { Err(()) };
    = help: consider explicitly using expression value
 
 error: non-binding `let` on a result of a `#[must_use]` function
-  --> tests/ui/let_underscore_must_use.rs:96:5
+  --> tests/ui/let_underscore_must_use.rs:101:5
    |
 LL |     let _ = a.is_ok();
    |     ^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     let _ = a.is_ok();
    = help: consider explicitly using function result
 
 error: non-binding `let` on an expression with `#[must_use]` type
-  --> tests/ui/let_underscore_must_use.rs:99:5
+  --> tests/ui/let_underscore_must_use.rs:104:5
    |
 LL |     let _ = a.map(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     let _ = a.map(|_| ());
    = help: consider explicitly using expression value
 
 error: non-binding `let` on an expression with `#[must_use]` type
-  --> tests/ui/let_underscore_must_use.rs:102:5
+  --> tests/ui/let_underscore_must_use.rs:107:5
    |
 LL |     let _ = a;
    |     ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/let_underscore_untyped.rs b/src/tools/clippy/tests/ui/let_underscore_untyped.rs
index 6275b6f970a1..26ba8682dc2d 100644
--- a/src/tools/clippy/tests/ui/let_underscore_untyped.rs
+++ b/src/tools/clippy/tests/ui/let_underscore_untyped.rs
@@ -49,11 +49,16 @@ with_span!(
 
 fn main() {
     let _ = a();
+    //~^ let_underscore_untyped
     let _ = b(1);
+    //~^ let_underscore_untyped
     let _ = c();
     let _ = d(&1);
+    //~^ let_underscore_untyped
     let _ = e();
+    //~^ let_underscore_untyped
     let _ = f();
+    //~^ let_underscore_untyped
     let _ = g();
     let closure = || {};
 
diff --git a/src/tools/clippy/tests/ui/let_underscore_untyped.stderr b/src/tools/clippy/tests/ui/let_underscore_untyped.stderr
index 1dd51e1e59b1..86cdd5c662cc 100644
--- a/src/tools/clippy/tests/ui/let_underscore_untyped.stderr
+++ b/src/tools/clippy/tests/ui/let_underscore_untyped.stderr
@@ -13,49 +13,49 @@ LL |     let _ = a();
    = help: to override `-D warnings` add `#[allow(clippy::let_underscore_untyped)]`
 
 error: non-binding `let` without a type annotation
-  --> tests/ui/let_underscore_untyped.rs:52:5
+  --> tests/ui/let_underscore_untyped.rs:53:5
    |
 LL |     let _ = b(1);
    |     ^^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> tests/ui/let_underscore_untyped.rs:52:10
+  --> tests/ui/let_underscore_untyped.rs:53:10
    |
 LL |     let _ = b(1);
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> tests/ui/let_underscore_untyped.rs:54:5
+  --> tests/ui/let_underscore_untyped.rs:56:5
    |
 LL |     let _ = d(&1);
    |     ^^^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> tests/ui/let_underscore_untyped.rs:54:10
+  --> tests/ui/let_underscore_untyped.rs:56:10
    |
 LL |     let _ = d(&1);
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> tests/ui/let_underscore_untyped.rs:55:5
+  --> tests/ui/let_underscore_untyped.rs:58:5
    |
 LL |     let _ = e();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> tests/ui/let_underscore_untyped.rs:55:10
+  --> tests/ui/let_underscore_untyped.rs:58:10
    |
 LL |     let _ = e();
    |          ^
 
 error: non-binding `let` without a type annotation
-  --> tests/ui/let_underscore_untyped.rs:56:5
+  --> tests/ui/let_underscore_untyped.rs:60:5
    |
 LL |     let _ = f();
    |     ^^^^^^^^^^^^
    |
 help: consider adding a type annotation
-  --> tests/ui/let_underscore_untyped.rs:56:10
+  --> tests/ui/let_underscore_untyped.rs:60:10
    |
 LL |     let _ = f();
    |          ^
diff --git a/src/tools/clippy/tests/ui/let_unit.fixed b/src/tools/clippy/tests/ui/let_unit.fixed
index 3456e274f6a4..5e7a2ad37a84 100644
--- a/src/tools/clippy/tests/ui/let_unit.fixed
+++ b/src/tools/clippy/tests/ui/let_unit.fixed
@@ -9,6 +9,7 @@ macro_rules! let_and_return {
 
 fn main() {
     println!("x");
+    //~^ let_unit_value
     let _y = 1; // this is fine
     let _z = ((), 1); // this as well
     if true {
@@ -57,6 +58,7 @@ fn multiline_sugg() {
     let v: Vec<u8> = vec![2];
 
     v
+        //~^ let_unit_value
         .into_iter()
         .map(|i| i * 2)
         .filter(|i| i % 2 == 0)
@@ -106,6 +108,7 @@ fn _returns_generic() {
     let x: () = if true { f() } else { f2(0) };
 
     match Some(0) {
+        //~^ let_unit_value
         None => f2(1),
         Some(0) => f(),
         Some(1) => f2(3),
@@ -187,6 +190,7 @@ pub fn issue12594() {
     fn actual_test() {
         // create first a unit value'd value
         returns_unit();
+        //~^ let_unit_value
         returns_result(()).unwrap();
         returns_result(()).unwrap();
         // make sure we replace only the first variable
diff --git a/src/tools/clippy/tests/ui/let_unit.rs b/src/tools/clippy/tests/ui/let_unit.rs
index e2dafbcb7714..7b06f6940121 100644
--- a/src/tools/clippy/tests/ui/let_unit.rs
+++ b/src/tools/clippy/tests/ui/let_unit.rs
@@ -9,6 +9,7 @@ macro_rules! let_and_return {
 
 fn main() {
     let _x = println!("x");
+    //~^ let_unit_value
     let _y = 1; // this is fine
     let _z = ((), 1); // this as well
     if true {
@@ -57,6 +58,7 @@ fn multiline_sugg() {
     let v: Vec<u8> = vec![2];
 
     let _ = v
+        //~^ let_unit_value
         .into_iter()
         .map(|i| i * 2)
         .filter(|i| i % 2 == 0)
@@ -106,6 +108,7 @@ fn _returns_generic() {
     let x: () = if true { f() } else { f2(0) };
 
     let x = match Some(0) {
+        //~^ let_unit_value
         None => f2(1),
         Some(0) => f(),
         Some(1) => f2(3),
@@ -187,6 +190,7 @@ pub fn issue12594() {
     fn actual_test() {
         // create first a unit value'd value
         let res = returns_unit();
+        //~^ let_unit_value
         returns_result(res).unwrap();
         returns_result(res).unwrap();
         // make sure we replace only the first variable
diff --git a/src/tools/clippy/tests/ui/let_unit.stderr b/src/tools/clippy/tests/ui/let_unit.stderr
index a2f368f22e5b..d7d01d304cad 100644
--- a/src/tools/clippy/tests/ui/let_unit.stderr
+++ b/src/tools/clippy/tests/ui/let_unit.stderr
@@ -8,13 +8,13 @@ LL |     let _x = println!("x");
    = help: to override `-D warnings` add `#[allow(clippy::let_unit_value)]`
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:59:5
+  --> tests/ui/let_unit.rs:60:5
    |
 LL | /     let _ = v
+LL | |
 LL | |         .into_iter()
 LL | |         .map(|i| i * 2)
-LL | |         .filter(|i| i % 2 == 0)
-LL | |         .map(|_| ())
+...  |
 LL | |         .next()
 LL | |         .unwrap();
    | |__________________^
@@ -22,6 +22,7 @@ LL | |         .unwrap();
 help: omit the `let` binding
    |
 LL ~     v
+LL +
 LL +         .into_iter()
 LL +         .map(|i| i * 2)
 LL +         .filter(|i| i % 2 == 0)
@@ -31,9 +32,10 @@ LL +         .unwrap();
    |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:108:5
+  --> tests/ui/let_unit.rs:110:5
    |
 LL | /     let x = match Some(0) {
+LL | |
 LL | |         None => f2(1),
 LL | |         Some(0) => f(),
 LL | |         Some(1) => f2(3),
@@ -44,6 +46,7 @@ LL | |     };
 help: omit the `let` binding
    |
 LL ~     match Some(0) {
+LL +
 LL +         None => f2(1),
 LL +         Some(0) => f(),
 LL +         Some(1) => f2(3),
@@ -52,7 +55,7 @@ LL +     };
    |
 
 error: this let-binding has unit value
-  --> tests/ui/let_unit.rs:189:9
+  --> tests/ui/let_unit.rs:192:9
    |
 LL |         let res = returns_unit();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,6 +63,7 @@ LL |         let res = returns_unit();
 help: omit the `let` binding and replace variable usages with `()`
    |
 LL ~         returns_unit();
+LL |
 LL ~         returns_result(()).unwrap();
 LL ~         returns_result(()).unwrap();
    |
diff --git a/src/tools/clippy/tests/ui/let_with_type_underscore.rs b/src/tools/clippy/tests/ui/let_with_type_underscore.rs
index ae1a480bcfc5..a7c2f598b56d 100644
--- a/src/tools/clippy/tests/ui/let_with_type_underscore.rs
+++ b/src/tools/clippy/tests/ui/let_with_type_underscore.rs
@@ -13,9 +13,13 @@ fn func() -> &'static str {
 fn main() {
     // Will lint
     let x: _ = 1;
+    //~^ let_with_type_underscore
     let _: _ = 2;
+    //~^ let_with_type_underscore
     let x: _ = func();
+    //~^ let_with_type_underscore
     let x: _;
+    //~^ let_with_type_underscore
     x = ();
 
     let x = 1; // Will not lint, Rust infers this to an integer before Clippy
@@ -23,6 +27,7 @@ fn main() {
     let x: Vec<_> = Vec::<u32>::new();
     let x: [_; 1] = [1];
     let x : _ = 1;
+    //~^ let_with_type_underscore
 
     // Do not lint from procedural macros
     proc_macros::with_span! {
diff --git a/src/tools/clippy/tests/ui/let_with_type_underscore.stderr b/src/tools/clippy/tests/ui/let_with_type_underscore.stderr
index 29ec25a5b2ac..2284d1fe2e48 100644
--- a/src/tools/clippy/tests/ui/let_with_type_underscore.stderr
+++ b/src/tools/clippy/tests/ui/let_with_type_underscore.stderr
@@ -13,49 +13,49 @@ LL |     let x: _ = 1;
    = help: to override `-D warnings` add `#[allow(clippy::let_with_type_underscore)]`
 
 error: variable declared with type underscore
-  --> tests/ui/let_with_type_underscore.rs:16:5
+  --> tests/ui/let_with_type_underscore.rs:17:5
    |
 LL |     let _: _ = 2;
    |     ^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> tests/ui/let_with_type_underscore.rs:16:10
+  --> tests/ui/let_with_type_underscore.rs:17:10
    |
 LL |     let _: _ = 2;
    |          ^^^
 
 error: variable declared with type underscore
-  --> tests/ui/let_with_type_underscore.rs:17:5
+  --> tests/ui/let_with_type_underscore.rs:19:5
    |
 LL |     let x: _ = func();
    |     ^^^^^^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> tests/ui/let_with_type_underscore.rs:17:10
+  --> tests/ui/let_with_type_underscore.rs:19:10
    |
 LL |     let x: _ = func();
    |          ^^^
 
 error: variable declared with type underscore
-  --> tests/ui/let_with_type_underscore.rs:18:5
+  --> tests/ui/let_with_type_underscore.rs:21:5
    |
 LL |     let x: _;
    |     ^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> tests/ui/let_with_type_underscore.rs:18:10
+  --> tests/ui/let_with_type_underscore.rs:21:10
    |
 LL |     let x: _;
    |          ^^^
 
 error: variable declared with type underscore
-  --> tests/ui/let_with_type_underscore.rs:25:5
+  --> tests/ui/let_with_type_underscore.rs:29:5
    |
 LL |     let x : _ = 1;
    |     ^^^^^^^^^^^^^^
    |
 help: remove the explicit type `_` declaration
-  --> tests/ui/let_with_type_underscore.rs:25:10
+  --> tests/ui/let_with_type_underscore.rs:29:10
    |
 LL |     let x : _ = 1;
    |          ^^^^
diff --git a/src/tools/clippy/tests/ui/lines_filter_map_ok.fixed b/src/tools/clippy/tests/ui/lines_filter_map_ok.fixed
index 621115cc1325..977e31c744a2 100644
--- a/src/tools/clippy/tests/ui/lines_filter_map_ok.fixed
+++ b/src/tools/clippy/tests/ui/lines_filter_map_ok.fixed
@@ -7,20 +7,26 @@ fn main() -> io::Result<()> {
     let f = std::fs::File::open("/")?;
     // Lint
     BufReader::new(f).lines().map_while(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     let f = std::fs::File::open("/")?;
     BufReader::new(f).lines().map_while(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     let f = std::fs::File::open("/")?;
     BufReader::new(f).lines().map_while(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
 
     let s = "foo\nbar\nbaz\n";
     // Lint
     io::stdin().lines().map_while(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     io::stdin().lines().map_while(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     io::stdin().lines().map_while(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Do not lint (not a `Lines` iterator)
     io::stdin()
         .lines()
@@ -31,3 +37,10 @@ fn main() -> io::Result<()> {
     io::stdin().lines().filter_map(|x| x.err()).for_each(|_| ());
     Ok(())
 }
+
+#[clippy::msrv = "1.56"]
+fn msrv_check() {
+    let _lines = BufReader::new(std::fs::File::open("some-path").unwrap())
+        .lines()
+        .filter_map(Result::ok);
+}
diff --git a/src/tools/clippy/tests/ui/lines_filter_map_ok.rs b/src/tools/clippy/tests/ui/lines_filter_map_ok.rs
index a86efbd66862..2196075bc445 100644
--- a/src/tools/clippy/tests/ui/lines_filter_map_ok.rs
+++ b/src/tools/clippy/tests/ui/lines_filter_map_ok.rs
@@ -7,20 +7,26 @@ fn main() -> io::Result<()> {
     let f = std::fs::File::open("/")?;
     // Lint
     BufReader::new(f).lines().filter_map(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     let f = std::fs::File::open("/")?;
     BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     let f = std::fs::File::open("/")?;
     BufReader::new(f).lines().flatten().for_each(|_| ());
+    //~^ lines_filter_map_ok
 
     let s = "foo\nbar\nbaz\n";
     // Lint
     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Lint
     io::stdin().lines().flatten().for_each(|_| ());
+    //~^ lines_filter_map_ok
     // Do not lint (not a `Lines` iterator)
     io::stdin()
         .lines()
@@ -31,3 +37,10 @@ fn main() -> io::Result<()> {
     io::stdin().lines().filter_map(|x| x.err()).for_each(|_| ());
     Ok(())
 }
+
+#[clippy::msrv = "1.56"]
+fn msrv_check() {
+    let _lines = BufReader::new(std::fs::File::open("some-path").unwrap())
+        .lines()
+        .filter_map(Result::ok);
+}
diff --git a/src/tools/clippy/tests/ui/lines_filter_map_ok.stderr b/src/tools/clippy/tests/ui/lines_filter_map_ok.stderr
index 558c0532be95..f9038eec9fb2 100644
--- a/src/tools/clippy/tests/ui/lines_filter_map_ok.stderr
+++ b/src/tools/clippy/tests/ui/lines_filter_map_ok.stderr
@@ -13,61 +13,61 @@ LL |     BufReader::new(f).lines().filter_map(Result::ok).for_each(|_| ());
    = help: to override `-D warnings` add `#[allow(clippy::lines_filter_map_ok)]`
 
 error: `flat_map()` will run forever if the iterator repeatedly produces an `Err`
-  --> tests/ui/lines_filter_map_ok.rs:12:31
+  --> tests/ui/lines_filter_map_ok.rs:13:31
    |
 LL |     BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
    |
 note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
-  --> tests/ui/lines_filter_map_ok.rs:12:5
+  --> tests/ui/lines_filter_map_ok.rs:13:5
    |
 LL |     BufReader::new(f).lines().flat_map(Result::ok).for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `flatten()` will run forever if the iterator repeatedly produces an `Err`
-  --> tests/ui/lines_filter_map_ok.rs:15:31
+  --> tests/ui/lines_filter_map_ok.rs:17:31
    |
 LL |     BufReader::new(f).lines().flatten().for_each(|_| ());
    |                               ^^^^^^^^^ help: replace with: `map_while(Result::ok)`
    |
 note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
-  --> tests/ui/lines_filter_map_ok.rs:15:5
+  --> tests/ui/lines_filter_map_ok.rs:17:5
    |
 LL |     BufReader::new(f).lines().flatten().for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `filter_map()` will run forever if the iterator repeatedly produces an `Err`
-  --> tests/ui/lines_filter_map_ok.rs:19:25
+  --> tests/ui/lines_filter_map_ok.rs:22:25
    |
 LL |     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
    |                         ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
    |
 note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
-  --> tests/ui/lines_filter_map_ok.rs:19:5
+  --> tests/ui/lines_filter_map_ok.rs:22:5
    |
 LL |     io::stdin().lines().filter_map(Result::ok).for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: `filter_map()` will run forever if the iterator repeatedly produces an `Err`
-  --> tests/ui/lines_filter_map_ok.rs:21:25
+  --> tests/ui/lines_filter_map_ok.rs:25:25
    |
 LL |     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
    |                         ^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `map_while(Result::ok)`
    |
 note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
-  --> tests/ui/lines_filter_map_ok.rs:21:5
+  --> tests/ui/lines_filter_map_ok.rs:25:5
    |
 LL |     io::stdin().lines().filter_map(|x| x.ok()).for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: `flatten()` will run forever if the iterator repeatedly produces an `Err`
-  --> tests/ui/lines_filter_map_ok.rs:23:25
+  --> tests/ui/lines_filter_map_ok.rs:28:25
    |
 LL |     io::stdin().lines().flatten().for_each(|_| ());
    |                         ^^^^^^^^^ help: replace with: `map_while(Result::ok)`
    |
 note: this expression returning a `std::io::Lines` may produce an infinite number of `Err` in case of a read error
-  --> tests/ui/lines_filter_map_ok.rs:23:5
+  --> tests/ui/lines_filter_map_ok.rs:28:5
    |
 LL |     io::stdin().lines().flatten().for_each(|_| ());
    |     ^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/linkedlist.rs b/src/tools/clippy/tests/ui/linkedlist.rs
index e1e6cff98097..64a9ba0029da 100644
--- a/src/tools/clippy/tests/ui/linkedlist.rs
+++ b/src/tools/clippy/tests/ui/linkedlist.rs
@@ -6,17 +6,20 @@ extern crate alloc;
 use alloc::collections::linked_list::LinkedList;
 
 const C: LinkedList<i32> = LinkedList::new();
-//~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data structu
+//~^ linkedlist
+
 static S: LinkedList<i32> = LinkedList::new();
-//~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data structu
+//~^ linkedlist
 
 trait Foo {
     type Baz = LinkedList<u8>;
-    //~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data str
+    //~^ linkedlist
+
     fn foo(_: LinkedList<u8>);
-    //~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data str
+    //~^ linkedlist
+
     const BAR: Option<LinkedList<u8>>;
-    //~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data str
+    //~^ linkedlist
 }
 
 // Ok, we don’t want to warn for implementations; see issue #605.
@@ -27,20 +30,22 @@ impl Foo for LinkedList<u8> {
 
 pub struct Bar {
     priv_linked_list_field: LinkedList<u8>,
-    //~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data str
+    //~^ linkedlist
     pub pub_linked_list_field: LinkedList<u8>,
 }
 impl Bar {
     fn foo(_: LinkedList<u8>) {}
-    //~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data str
+    //~^ linkedlist
 }
 
 // All of these test should be trigger the lint because they are not
 // part of the public api
 fn test(my_favorite_linked_list: LinkedList<u8>) {}
-//~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data structu
+//~^ linkedlist
+
 fn test_ret() -> Option<LinkedList<u8>> {
-    //~^ ERROR: you seem to be using a `LinkedList`! Perhaps you meant some other data structu
+    //~^ linkedlist
+
     None
 }
 fn test_local_not_linted() {
diff --git a/src/tools/clippy/tests/ui/linkedlist.stderr b/src/tools/clippy/tests/ui/linkedlist.stderr
index d19176c7b0d2..419fbcc7e188 100644
--- a/src/tools/clippy/tests/ui/linkedlist.stderr
+++ b/src/tools/clippy/tests/ui/linkedlist.stderr
@@ -9,7 +9,7 @@ LL | const C: LinkedList<i32> = LinkedList::new();
    = help: to override `-D warnings` add `#[allow(clippy::linkedlist)]`
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:10:11
+  --> tests/ui/linkedlist.rs:11:11
    |
 LL | static S: LinkedList<i32> = LinkedList::new();
    |           ^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | static S: LinkedList<i32> = LinkedList::new();
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:14:16
+  --> tests/ui/linkedlist.rs:15:16
    |
 LL |     type Baz = LinkedList<u8>;
    |                ^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     type Baz = LinkedList<u8>;
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:16:15
+  --> tests/ui/linkedlist.rs:18:15
    |
 LL |     fn foo(_: LinkedList<u8>);
    |               ^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     fn foo(_: LinkedList<u8>);
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:18:23
+  --> tests/ui/linkedlist.rs:21:23
    |
 LL |     const BAR: Option<LinkedList<u8>>;
    |                       ^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     const BAR: Option<LinkedList<u8>>;
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:29:29
+  --> tests/ui/linkedlist.rs:32:29
    |
 LL |     priv_linked_list_field: LinkedList<u8>,
    |                             ^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     priv_linked_list_field: LinkedList<u8>,
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:34:15
+  --> tests/ui/linkedlist.rs:37:15
    |
 LL |     fn foo(_: LinkedList<u8>) {}
    |               ^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     fn foo(_: LinkedList<u8>) {}
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:40:34
+  --> tests/ui/linkedlist.rs:43:34
    |
 LL | fn test(my_favorite_linked_list: LinkedList<u8>) {}
    |                                  ^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL | fn test(my_favorite_linked_list: LinkedList<u8>) {}
    = help: a `VecDeque` might work
 
 error: you seem to be using a `LinkedList`! Perhaps you meant some other data structure?
-  --> tests/ui/linkedlist.rs:42:25
+  --> tests/ui/linkedlist.rs:46:25
    |
 LL | fn test_ret() -> Option<LinkedList<u8>> {
    |                         ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.rs b/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.rs
index f257c66f59d3..d54cceae53eb 100644
--- a/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.rs
+++ b/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.rs
@@ -1,6 +1,31 @@
 #![warn(clippy::literal_string_with_formatting_args)]
 #![allow(clippy::unnecessary_literal_unwrap)]
 
+// Regression test for <https://github.com/rust-lang/rust-clippy/issues/13885>.
+// It's not supposed to emit the lint in this case (in `assert!` expansion).
+fn compiler_macro() {
+    fn parse(_: &str) -> Result<(), i32> {
+        unimplemented!()
+    }
+
+    assert!(
+        parse(
+            #[allow(clippy::literal_string_with_formatting_args)]
+            "foo {:}"
+        )
+        .is_err()
+    );
+    let value = 0;
+    assert!(format!("{value}").is_ascii());
+}
+
+// Regression test for <https://github.com/rust-lang/rust-clippy/issues/14007>.
+fn regression_14007() {
+    let s = "{и}";
+    let ш = 12;
+    let s = "{ш}"; //~ literal_string_with_formatting_args
+}
+
 fn main() {
     let x: Option<usize> = None;
     let y = "hello";
@@ -13,8 +38,10 @@ fn main() {
     x.expect(r"{y:?}  {y:?} "); //~ literal_string_with_formatting_args
     x.expect(r"{y:?} y:?}"); //~ literal_string_with_formatting_args
     x.expect(r##" {y:?} {y:?} "##); //~ literal_string_with_formatting_args
+    assert!("{y}".is_ascii()); //~ literal_string_with_formatting_args
     // Ensure that it doesn't try to go in the middle of a unicode character.
-    x.expect("———{:?}"); //~ literal_string_with_formatting_args
+    x.expect("———{:?}");
+    //~^ literal_string_with_formatting_args
 
     // Should not lint!
     format!("{y:?}");
@@ -25,6 +52,8 @@ fn main() {
     x.expect("{{y:?}");
     x.expect(" {0}"); // If it only contains an integer, we ignore it.
     x.expect(r##" {x:?} "##); // `x` doesn't exist so we shoud not lint
+    //
+    //~^^ literal_string_with_formatting_args
     x.expect("{y:...}");
     let _ = "fn main {\n\
     }";
diff --git a/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.stderr b/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.stderr
index 32a84f600da7..55425d01c587 100644
--- a/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.stderr
+++ b/src/tools/clippy/tests/ui/literal_string_with_formatting_arg.stderr
@@ -1,71 +1,83 @@
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:7:15
+  --> tests/ui/literal_string_with_formatting_arg.rs:26:14
    |
-LL |     x.expect("{y} {}");
-   |               ^^^
+LL |     let s = "{ш}";
+   |              ^^^
    |
    = note: `-D clippy::literal-string-with-formatting-args` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::literal_string_with_formatting_args)]`
 
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:8:16
+  --> tests/ui/literal_string_with_formatting_arg.rs:32:15
+   |
+LL |     x.expect("{y} {}");
+   |               ^^^
+
+error: this looks like a formatting argument but it is not part of a formatting macro
+  --> tests/ui/literal_string_with_formatting_arg.rs:33:16
    |
 LL |     x.expect(" {y} bla");
    |                ^^^
 
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:9:15
+  --> tests/ui/literal_string_with_formatting_arg.rs:34:15
    |
 LL |     x.expect("{:?}");
    |               ^^^^
 
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:10:15
+  --> tests/ui/literal_string_with_formatting_arg.rs:35:15
    |
 LL |     x.expect("{y:?}");
    |               ^^^^^
 
 error: these look like formatting arguments but are not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:11:16
+  --> tests/ui/literal_string_with_formatting_arg.rs:36:16
    |
 LL |     x.expect(" {y:?} {y:?} ");
    |                ^^^^^ ^^^^^
 
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:12:23
+  --> tests/ui/literal_string_with_formatting_arg.rs:37:23
    |
 LL |     x.expect(" {y:..} {y:?} ");
    |                       ^^^^^
 
 error: these look like formatting arguments but are not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:13:16
+  --> tests/ui/literal_string_with_formatting_arg.rs:38:16
    |
 LL |     x.expect(r"{y:?}  {y:?} ");
    |                ^^^^^  ^^^^^
 
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:14:16
+  --> tests/ui/literal_string_with_formatting_arg.rs:39:16
    |
 LL |     x.expect(r"{y:?} y:?}");
    |                ^^^^^
 
 error: these look like formatting arguments but are not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:15:19
+  --> tests/ui/literal_string_with_formatting_arg.rs:40:19
    |
 LL |     x.expect(r##" {y:?} {y:?} "##);
    |                   ^^^^^ ^^^^^
 
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:17:18
+  --> tests/ui/literal_string_with_formatting_arg.rs:41:14
+   |
+LL |     assert!("{y}".is_ascii());
+   |              ^^^
+
+error: this looks like a formatting argument but it is not part of a formatting macro
+  --> tests/ui/literal_string_with_formatting_arg.rs:43:18
    |
 LL |     x.expect("———{:?}");
    |                  ^^^^
 
 error: this looks like a formatting argument but it is not part of a formatting macro
-  --> tests/ui/literal_string_with_formatting_arg.rs:27:19
+  --> tests/ui/literal_string_with_formatting_arg.rs:54:19
    |
 LL |     x.expect(r##" {x:?} "##); // `x` doesn't exist so we shoud not lint
    |                   ^^^^^
 
-error: aborting due to 11 previous errors
+error: aborting due to 13 previous errors
 
diff --git a/src/tools/clippy/tests/ui/literals.rs b/src/tools/clippy/tests/ui/literals.rs
index c275b04d886b..d21d49310a07 100644
--- a/src/tools/clippy/tests/ui/literals.rs
+++ b/src/tools/clippy/tests/ui/literals.rs
@@ -11,32 +11,35 @@ fn main() {
     let ok1 = 0xABCD;
     let ok3 = 0xab_cd;
     let ok4 = 0xab_cd_i32;
-    //~^ ERROR: integer type suffix should not be separated by an underscore
-    //~| NOTE: `-D clippy::separated-literal-suffix` implied by `-D warnings`
+    //~^ separated_literal_suffix
+
     let ok5 = 0xAB_CD_u32;
-    //~^ ERROR: integer type suffix should not be separated by an underscore
+    //~^ separated_literal_suffix
+
     let ok5 = 0xAB_CD_isize;
-    //~^ ERROR: integer type suffix should not be separated by an underscore
+    //~^ separated_literal_suffix
+
     let fail1 = 0xabCD;
-    //~^ ERROR: inconsistent casing in hexadecimal literal
-    //~| NOTE: `-D clippy::mixed-case-hex-literals` implied by `-D warnings`
+    //~^ mixed_case_hex_literals
+
     let fail2 = 0xabCD_u32;
-    //~^ ERROR: integer type suffix should not be separated by an underscore
-    //~| ERROR: inconsistent casing in hexadecimal literal
+    //~^ separated_literal_suffix
+    //~| mixed_case_hex_literals
+
     let fail2 = 0xabCD_isize;
-    //~^ ERROR: integer type suffix should not be separated by an underscore
-    //~| ERROR: inconsistent casing in hexadecimal literal
+    //~^ separated_literal_suffix
+    //~| mixed_case_hex_literals
+
     let fail_multi_zero = 000_123usize;
-    //~^ ERROR: integer type suffix should be separated by an underscore
-    //~| NOTE: `-D clippy::unseparated-literal-suffix` implied by `-D warnings`
-    //~| ERROR: this is a decimal constant
-    //~| NOTE: `-D clippy::zero-prefixed-literal` implied by `-D warnings`
+    //~^ unseparated_literal_suffix
+    //~| zero_prefixed_literal
 
     let ok9 = 0;
     let ok10 = 0_i64;
-    //~^ ERROR: integer type suffix should not be separated by an underscore
+    //~^ separated_literal_suffix
+
     let fail8 = 0123;
-    //~^ ERROR: this is a decimal constant
+    //~^ zero_prefixed_literal
 
     let ok11 = 0o123;
     let ok12 = 0b10_1010;
@@ -46,20 +49,22 @@ fn main() {
     let ok15 = 0xab_cabc_abca_bcab_cabc;
     let ok16 = 0xFE_BAFE_ABAB_ABCD;
     let ok17 = 0x123_4567_8901_usize;
-    //~^ ERROR: integer type suffix should not be separated by an underscore
+    //~^ separated_literal_suffix
+
     let ok18 = 0xF;
 
     let fail19 = 12_3456_21;
-    //~^ ERROR: digits grouped inconsistently by underscores
-    //~| NOTE: `-D clippy::inconsistent-digit-grouping` implied by `-D warnings`
+    //~^ inconsistent_digit_grouping
+
     let fail22 = 3__4___23;
-    //~^ ERROR: digits grouped inconsistently by underscores
+    //~^ inconsistent_digit_grouping
+
     let fail23 = 3__16___23;
-    //~^ ERROR: digits grouped inconsistently by underscores
+    //~^ inconsistent_digit_grouping
 
     let fail24 = 0xAB_ABC_AB;
-    //~^ ERROR: digits of hex, binary or octal literal not in groups of equal size
-    //~| NOTE: `-D clippy::unusual-byte-groupings` implied by `-D warnings`
+    //~^ unusual_byte_groupings
+
     let fail25 = 0b01_100_101;
     let ok26 = 0x6_A0_BF;
     let ok27 = 0b1_0010_0101;
@@ -68,9 +73,11 @@ fn main() {
 fn issue9651() {
     // lint but octal form is not possible here
     let _ = 08;
-    //~^ ERROR: this is a decimal constant
+    //~^ zero_prefixed_literal
+
     let _ = 09;
-    //~^ ERROR: this is a decimal constant
+    //~^ zero_prefixed_literal
+
     let _ = 089;
-    //~^ ERROR: this is a decimal constant
+    //~^ zero_prefixed_literal
 }
diff --git a/src/tools/clippy/tests/ui/literals.stderr b/src/tools/clippy/tests/ui/literals.stderr
index 576b38a47d2d..d65cd3c89ebb 100644
--- a/src/tools/clippy/tests/ui/literals.stderr
+++ b/src/tools/clippy/tests/ui/literals.stderr
@@ -14,13 +14,13 @@ LL |     let ok5 = 0xAB_CD_u32;
    |               ^^^^^^^^^^^ help: remove the underscore: `0xAB_CDu32`
 
 error: integer type suffix should not be separated by an underscore
-  --> tests/ui/literals.rs:18:15
+  --> tests/ui/literals.rs:19:15
    |
 LL |     let ok5 = 0xAB_CD_isize;
    |               ^^^^^^^^^^^^^ help: remove the underscore: `0xAB_CDisize`
 
 error: inconsistent casing in hexadecimal literal
-  --> tests/ui/literals.rs:20:17
+  --> tests/ui/literals.rs:22:17
    |
 LL |     let fail1 = 0xabCD;
    |                 ^^^^^^
@@ -29,31 +29,31 @@ LL |     let fail1 = 0xabCD;
    = help: to override `-D warnings` add `#[allow(clippy::mixed_case_hex_literals)]`
 
 error: integer type suffix should not be separated by an underscore
-  --> tests/ui/literals.rs:23:17
+  --> tests/ui/literals.rs:25:17
    |
 LL |     let fail2 = 0xabCD_u32;
    |                 ^^^^^^^^^^ help: remove the underscore: `0xabCDu32`
 
 error: inconsistent casing in hexadecimal literal
-  --> tests/ui/literals.rs:23:17
+  --> tests/ui/literals.rs:25:17
    |
 LL |     let fail2 = 0xabCD_u32;
    |                 ^^^^^^^^^^
 
 error: integer type suffix should not be separated by an underscore
-  --> tests/ui/literals.rs:26:17
+  --> tests/ui/literals.rs:29:17
    |
 LL |     let fail2 = 0xabCD_isize;
    |                 ^^^^^^^^^^^^ help: remove the underscore: `0xabCDisize`
 
 error: inconsistent casing in hexadecimal literal
-  --> tests/ui/literals.rs:26:17
+  --> tests/ui/literals.rs:29:17
    |
 LL |     let fail2 = 0xabCD_isize;
    |                 ^^^^^^^^^^^^
 
 error: integer type suffix should be separated by an underscore
-  --> tests/ui/literals.rs:29:27
+  --> tests/ui/literals.rs:33:27
    |
 LL |     let fail_multi_zero = 000_123usize;
    |                           ^^^^^^^^^^^^ help: add an underscore: `000_123_usize`
@@ -62,7 +62,7 @@ LL |     let fail_multi_zero = 000_123usize;
    = help: to override `-D warnings` add `#[allow(clippy::unseparated_literal_suffix)]`
 
 error: this is a decimal constant
-  --> tests/ui/literals.rs:29:27
+  --> tests/ui/literals.rs:33:27
    |
 LL |     let fail_multi_zero = 000_123usize;
    |                           ^^^^^^^^^^^^
@@ -81,13 +81,13 @@ LL +     let fail_multi_zero = 0o123usize;
    |
 
 error: integer type suffix should not be separated by an underscore
-  --> tests/ui/literals.rs:36:16
+  --> tests/ui/literals.rs:38:16
    |
 LL |     let ok10 = 0_i64;
    |                ^^^^^ help: remove the underscore: `0i64`
 
 error: this is a decimal constant
-  --> tests/ui/literals.rs:38:17
+  --> tests/ui/literals.rs:41:17
    |
 LL |     let fail8 = 0123;
    |                 ^^^^
@@ -103,13 +103,13 @@ LL |     let fail8 = 0o123;
    |                  +
 
 error: integer type suffix should not be separated by an underscore
-  --> tests/ui/literals.rs:48:16
+  --> tests/ui/literals.rs:51:16
    |
 LL |     let ok17 = 0x123_4567_8901_usize;
    |                ^^^^^^^^^^^^^^^^^^^^^ help: remove the underscore: `0x123_4567_8901usize`
 
 error: digits grouped inconsistently by underscores
-  --> tests/ui/literals.rs:52:18
+  --> tests/ui/literals.rs:56:18
    |
 LL |     let fail19 = 12_3456_21;
    |                  ^^^^^^^^^^ help: consider: `12_345_621`
@@ -118,19 +118,19 @@ LL |     let fail19 = 12_3456_21;
    = help: to override `-D warnings` add `#[allow(clippy::inconsistent_digit_grouping)]`
 
 error: digits grouped inconsistently by underscores
-  --> tests/ui/literals.rs:55:18
+  --> tests/ui/literals.rs:59:18
    |
 LL |     let fail22 = 3__4___23;
    |                  ^^^^^^^^^ help: consider: `3_423`
 
 error: digits grouped inconsistently by underscores
-  --> tests/ui/literals.rs:57:18
+  --> tests/ui/literals.rs:62:18
    |
 LL |     let fail23 = 3__16___23;
    |                  ^^^^^^^^^^ help: consider: `31_623`
 
 error: digits of hex, binary or octal literal not in groups of equal size
-  --> tests/ui/literals.rs:60:18
+  --> tests/ui/literals.rs:65:18
    |
 LL |     let fail24 = 0xAB_ABC_AB;
    |                  ^^^^^^^^^^^ help: consider: `0x0ABA_BCAB`
@@ -139,7 +139,7 @@ LL |     let fail24 = 0xAB_ABC_AB;
    = help: to override `-D warnings` add `#[allow(clippy::unusual_byte_groupings)]`
 
 error: this is a decimal constant
-  --> tests/ui/literals.rs:70:13
+  --> tests/ui/literals.rs:75:13
    |
 LL |     let _ = 08;
    |             ^^
@@ -151,7 +151,7 @@ LL +     let _ = 8;
    |
 
 error: this is a decimal constant
-  --> tests/ui/literals.rs:72:13
+  --> tests/ui/literals.rs:78:13
    |
 LL |     let _ = 09;
    |             ^^
@@ -163,7 +163,7 @@ LL +     let _ = 9;
    |
 
 error: this is a decimal constant
-  --> tests/ui/literals.rs:74:13
+  --> tests/ui/literals.rs:81:13
    |
 LL |     let _ = 089;
    |             ^^^
diff --git a/src/tools/clippy/tests/ui/lossy_float_literal.fixed b/src/tools/clippy/tests/ui/lossy_float_literal.fixed
index cc8c0b4a0d17..925a1465cc30 100644
--- a/src/tools/clippy/tests/ui/lossy_float_literal.fixed
+++ b/src/tools/clippy/tests/ui/lossy_float_literal.fixed
@@ -12,17 +12,28 @@ fn main() {
     let _: f16 = -4_097.0;
 
     let _: f32 = 16_777_216.0;
+    //~^ lossy_float_literal
     let _: f32 = 16_777_220.0;
+    //~^ lossy_float_literal
     let _: f32 = 16_777_220.0;
+    //~^ lossy_float_literal
     let _: f32 = 16_777_220.0;
+    //~^ lossy_float_literal
     let _ = 16_777_220_f32;
+    //~^ lossy_float_literal
     let _: f32 = -16_777_220.0;
+    //~^ lossy_float_literal
 
     let _: f64 = 9_007_199_254_740_992.0;
+    //~^ lossy_float_literal
     let _: f64 = 9_007_199_254_740_992.0;
+    //~^ lossy_float_literal
     let _: f64 = 9_007_199_254_740_992.0;
+    //~^ lossy_float_literal
     let _ = 9_007_199_254_740_992_f64;
+    //~^ lossy_float_literal
     let _: f64 = -9_007_199_254_740_992.0;
+    //~^ lossy_float_literal
 
     let _: f128 = 10_384_593_717_069_655_257_060_992_658_440_193.0;
     let _: f128 = 10_384_593_717_069_655_257_060_992_658_440_193.;
diff --git a/src/tools/clippy/tests/ui/lossy_float_literal.rs b/src/tools/clippy/tests/ui/lossy_float_literal.rs
index c84eef396d58..7341388d4816 100644
--- a/src/tools/clippy/tests/ui/lossy_float_literal.rs
+++ b/src/tools/clippy/tests/ui/lossy_float_literal.rs
@@ -12,17 +12,28 @@ fn main() {
     let _: f16 = -4_097.0;
 
     let _: f32 = 16_777_217.0;
+    //~^ lossy_float_literal
     let _: f32 = 16_777_219.0;
+    //~^ lossy_float_literal
     let _: f32 = 16_777_219.;
+    //~^ lossy_float_literal
     let _: f32 = 16_777_219.000;
+    //~^ lossy_float_literal
     let _ = 16_777_219f32;
+    //~^ lossy_float_literal
     let _: f32 = -16_777_219.0;
+    //~^ lossy_float_literal
 
     let _: f64 = 9_007_199_254_740_993.0;
+    //~^ lossy_float_literal
     let _: f64 = 9_007_199_254_740_993.;
+    //~^ lossy_float_literal
     let _: f64 = 9_007_199_254_740_993.00;
+    //~^ lossy_float_literal
     let _ = 9_007_199_254_740_993f64;
+    //~^ lossy_float_literal
     let _: f64 = -9_007_199_254_740_993.0;
+    //~^ lossy_float_literal
 
     let _: f128 = 10_384_593_717_069_655_257_060_992_658_440_193.0;
     let _: f128 = 10_384_593_717_069_655_257_060_992_658_440_193.;
diff --git a/src/tools/clippy/tests/ui/lossy_float_literal.stderr b/src/tools/clippy/tests/ui/lossy_float_literal.stderr
index 118351a62d00..33b650b19c8a 100644
--- a/src/tools/clippy/tests/ui/lossy_float_literal.stderr
+++ b/src/tools/clippy/tests/ui/lossy_float_literal.stderr
@@ -13,7 +13,7 @@ LL +     let _: f32 = 16_777_216.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:15:18
+  --> tests/ui/lossy_float_literal.rs:16:18
    |
 LL |     let _: f32 = 16_777_219.0;
    |                  ^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     let _: f32 = 16_777_220.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:16:18
+  --> tests/ui/lossy_float_literal.rs:18:18
    |
 LL |     let _: f32 = 16_777_219.;
    |                  ^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     let _: f32 = 16_777_220.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:17:18
+  --> tests/ui/lossy_float_literal.rs:20:18
    |
 LL |     let _: f32 = 16_777_219.000;
    |                  ^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     let _: f32 = 16_777_220.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:18:13
+  --> tests/ui/lossy_float_literal.rs:22:13
    |
 LL |     let _ = 16_777_219f32;
    |             ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     let _ = 16_777_220_f32;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:19:19
+  --> tests/ui/lossy_float_literal.rs:24:19
    |
 LL |     let _: f32 = -16_777_219.0;
    |                   ^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     let _: f32 = -16_777_220.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:21:18
+  --> tests/ui/lossy_float_literal.rs:27:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.0;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let _: f64 = 9_007_199_254_740_992.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:22:18
+  --> tests/ui/lossy_float_literal.rs:29:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.;
    |                  ^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let _: f64 = 9_007_199_254_740_992.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:23:18
+  --> tests/ui/lossy_float_literal.rs:31:18
    |
 LL |     let _: f64 = 9_007_199_254_740_993.00;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let _: f64 = 9_007_199_254_740_992.0;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:24:13
+  --> tests/ui/lossy_float_literal.rs:33:13
    |
 LL |     let _ = 9_007_199_254_740_993f64;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let _ = 9_007_199_254_740_992_f64;
    |
 
 error: literal cannot be represented as the underlying type without loss of precision
-  --> tests/ui/lossy_float_literal.rs:25:19
+  --> tests/ui/lossy_float_literal.rs:35:19
    |
 LL |     let _: f64 = -9_007_199_254_740_993.0;
    |                   ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/macro_use_imports.fixed b/src/tools/clippy/tests/ui/macro_use_imports.fixed
index 28844fab7479..d12222fce3eb 100644
--- a/src/tools/clippy/tests/ui/macro_use_imports.fixed
+++ b/src/tools/clippy/tests/ui/macro_use_imports.fixed
@@ -16,12 +16,16 @@ extern crate proc_macro_derive as mini_mac;
 
 mod a {
     use mac::{pub_macro, inner_mod_macro, function_macro, ty_macro, pub_in_private_macro};
+    //~^ macro_use_imports
     use mac;
     use mini_mac::ClippyMiniMacroTest;
+    //~^ macro_use_imports
     use mini_mac;
     use mac::{inner::mut_mut, inner::try_err};
+    //~^ macro_use_imports
     use mac::inner;
     use mac::inner::nested::string_add;
+    //~^ macro_use_imports
     use mac::inner::nested;
 
     #[derive(ClippyMiniMacroTest)]
diff --git a/src/tools/clippy/tests/ui/macro_use_imports.rs b/src/tools/clippy/tests/ui/macro_use_imports.rs
index 5381f2959898..3baa9f8b5e59 100644
--- a/src/tools/clippy/tests/ui/macro_use_imports.rs
+++ b/src/tools/clippy/tests/ui/macro_use_imports.rs
@@ -16,12 +16,16 @@ extern crate proc_macro_derive as mini_mac;
 
 mod a {
     #[macro_use]
+    //~^ macro_use_imports
     use mac;
     #[macro_use]
+    //~^ macro_use_imports
     use mini_mac;
     #[macro_use]
+    //~^ macro_use_imports
     use mac::inner;
     #[macro_use]
+    //~^ macro_use_imports
     use mac::inner::nested;
 
     #[derive(ClippyMiniMacroTest)]
diff --git a/src/tools/clippy/tests/ui/macro_use_imports.stderr b/src/tools/clippy/tests/ui/macro_use_imports.stderr
index ea0670d36667..cdef5bc79e0c 100644
--- a/src/tools/clippy/tests/ui/macro_use_imports.stderr
+++ b/src/tools/clippy/tests/ui/macro_use_imports.stderr
@@ -8,19 +8,19 @@ LL |     #[macro_use]
    = help: to override `-D warnings` add `#[allow(clippy::macro_use_imports)]`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> tests/ui/macro_use_imports.rs:22:5
+  --> tests/ui/macro_use_imports.rs:24:5
    |
 LL |     #[macro_use]
    |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::{inner::mut_mut, inner::try_err};`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> tests/ui/macro_use_imports.rs:24:5
+  --> tests/ui/macro_use_imports.rs:27:5
    |
 LL |     #[macro_use]
    |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mac::inner::nested::string_add;`
 
 error: `macro_use` attributes are no longer needed in the Rust 2018 edition
-  --> tests/ui/macro_use_imports.rs:20:5
+  --> tests/ui/macro_use_imports.rs:21:5
    |
 LL |     #[macro_use]
    |     ^^^^^^^^^^^^ help: remove the attribute and import the macro directly, try: `use mini_mac::ClippyMiniMacroTest;`
diff --git a/src/tools/clippy/tests/ui/macro_use_imports_expect.rs b/src/tools/clippy/tests/ui/macro_use_imports_expect.rs
index 60cce1d24a28..115b30d3877f 100644
--- a/src/tools/clippy/tests/ui/macro_use_imports_expect.rs
+++ b/src/tools/clippy/tests/ui/macro_use_imports_expect.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build:macro_rules.rs
 //@aux-build:macro_use_helper.rs
 //@aux-build:proc_macro_derive.rs
diff --git a/src/tools/clippy/tests/ui/manual_arithmetic_check-2.rs b/src/tools/clippy/tests/ui/manual_arithmetic_check-2.rs
index e97e3bdfef76..749d15f1cbd8 100644
--- a/src/tools/clippy/tests/ui/manual_arithmetic_check-2.rs
+++ b/src/tools/clippy/tests/ui/manual_arithmetic_check-2.rs
@@ -7,18 +7,22 @@ fn main() {
     let b = 13u32;
 
     let result = if a > b { b - a } else { 0 };
-    //~^ ERROR: inverted arithmetic check before subtraction
+    //~^ inverted_saturating_sub
+
     let result = if b < a { b - a } else { 0 };
-    //~^ ERROR: inverted arithmetic check before subtraction
+    //~^ inverted_saturating_sub
 
     let result = if a > b { 0 } else { a - b };
-    //~^ ERROR: inverted arithmetic check before subtraction
+    //~^ inverted_saturating_sub
+
     let result = if a >= b { 0 } else { a - b };
-    //~^ ERROR: inverted arithmetic check before subtraction
+    //~^ inverted_saturating_sub
+
     let result = if b < a { 0 } else { a - b };
-    //~^ ERROR: inverted arithmetic check before subtraction
+    //~^ inverted_saturating_sub
+
     let result = if b <= a { 0 } else { a - b };
-    //~^ ERROR: inverted arithmetic check before subtraction
+    //~^ inverted_saturating_sub
 
     let af = 12f32;
     let bf = 13f32;
diff --git a/src/tools/clippy/tests/ui/manual_arithmetic_check-2.stderr b/src/tools/clippy/tests/ui/manual_arithmetic_check-2.stderr
index 4121aa7464f0..8841210befda 100644
--- a/src/tools/clippy/tests/ui/manual_arithmetic_check-2.stderr
+++ b/src/tools/clippy/tests/ui/manual_arithmetic_check-2.stderr
@@ -12,61 +12,61 @@ LL |     let result = if a > b { b - a } else { 0 };
    = note: `#[deny(clippy::inverted_saturating_sub)]` on by default
 
 error: inverted arithmetic check before subtraction
-  --> tests/ui/manual_arithmetic_check-2.rs:11:23
+  --> tests/ui/manual_arithmetic_check-2.rs:12:23
    |
 LL |     let result = if b < a { b - a } else { 0 };
    |                       ^     ----- help: try replacing it with: `a - b`
    |
 note: this subtraction underflows when `b < a`
-  --> tests/ui/manual_arithmetic_check-2.rs:11:29
+  --> tests/ui/manual_arithmetic_check-2.rs:12:29
    |
 LL |     let result = if b < a { b - a } else { 0 };
    |                             ^^^^^
 
 error: inverted arithmetic check before subtraction
-  --> tests/ui/manual_arithmetic_check-2.rs:14:23
+  --> tests/ui/manual_arithmetic_check-2.rs:15:23
    |
 LL |     let result = if a > b { 0 } else { a - b };
    |                       ^                ----- help: try replacing it with: `b - a`
    |
 note: this subtraction underflows when `a < b`
-  --> tests/ui/manual_arithmetic_check-2.rs:14:40
+  --> tests/ui/manual_arithmetic_check-2.rs:15:40
    |
 LL |     let result = if a > b { 0 } else { a - b };
    |                                        ^^^^^
 
 error: inverted arithmetic check before subtraction
-  --> tests/ui/manual_arithmetic_check-2.rs:16:23
+  --> tests/ui/manual_arithmetic_check-2.rs:18:23
    |
 LL |     let result = if a >= b { 0 } else { a - b };
    |                       ^^                ----- help: try replacing it with: `b - a`
    |
 note: this subtraction underflows when `a < b`
-  --> tests/ui/manual_arithmetic_check-2.rs:16:41
+  --> tests/ui/manual_arithmetic_check-2.rs:18:41
    |
 LL |     let result = if a >= b { 0 } else { a - b };
    |                                         ^^^^^
 
 error: inverted arithmetic check before subtraction
-  --> tests/ui/manual_arithmetic_check-2.rs:18:23
+  --> tests/ui/manual_arithmetic_check-2.rs:21:23
    |
 LL |     let result = if b < a { 0 } else { a - b };
    |                       ^                ----- help: try replacing it with: `b - a`
    |
 note: this subtraction underflows when `a < b`
-  --> tests/ui/manual_arithmetic_check-2.rs:18:40
+  --> tests/ui/manual_arithmetic_check-2.rs:21:40
    |
 LL |     let result = if b < a { 0 } else { a - b };
    |                                        ^^^^^
 
 error: inverted arithmetic check before subtraction
-  --> tests/ui/manual_arithmetic_check-2.rs:20:23
+  --> tests/ui/manual_arithmetic_check-2.rs:24:23
    |
 LL |     let result = if b <= a { 0 } else { a - b };
    |                       ^^                ----- help: try replacing it with: `b - a`
    |
 note: this subtraction underflows when `a < b`
-  --> tests/ui/manual_arithmetic_check-2.rs:20:41
+  --> tests/ui/manual_arithmetic_check-2.rs:24:41
    |
 LL |     let result = if b <= a { 0 } else { a - b };
    |                                         ^^^^^
diff --git a/src/tools/clippy/tests/ui/manual_arithmetic_check.fixed b/src/tools/clippy/tests/ui/manual_arithmetic_check.fixed
index 29ecbb9ad2ad..99ed1faf90a6 100644
--- a/src/tools/clippy/tests/ui/manual_arithmetic_check.fixed
+++ b/src/tools/clippy/tests/ui/manual_arithmetic_check.fixed
@@ -7,14 +7,16 @@ fn main() {
     let c = 8u32;
 
     let result = a.saturating_sub(b);
-    //~^ ERROR: manual arithmetic check found
-    let result = a.saturating_sub(b);
-    //~^ ERROR: manual arithmetic check found
+    //~^ implicit_saturating_sub
 
     let result = a.saturating_sub(b);
-    //~^ ERROR: manual arithmetic check found
+    //~^ implicit_saturating_sub
+
     let result = a.saturating_sub(b);
-    //~^ ERROR: manual arithmetic check found
+    //~^ implicit_saturating_sub
+
+    let result = a.saturating_sub(b);
+    //~^ implicit_saturating_sub
 
     // Should not warn!
     let result = if a > b { a - b } else { a - c };
diff --git a/src/tools/clippy/tests/ui/manual_arithmetic_check.rs b/src/tools/clippy/tests/ui/manual_arithmetic_check.rs
index 69554c6b61ca..cf202fa35a6a 100644
--- a/src/tools/clippy/tests/ui/manual_arithmetic_check.rs
+++ b/src/tools/clippy/tests/ui/manual_arithmetic_check.rs
@@ -7,14 +7,16 @@ fn main() {
     let c = 8u32;
 
     let result = if a > b { a - b } else { 0 };
-    //~^ ERROR: manual arithmetic check found
+    //~^ implicit_saturating_sub
+
     let result = if b < a { a - b } else { 0 };
-    //~^ ERROR: manual arithmetic check found
+    //~^ implicit_saturating_sub
 
     let result = if a < b { 0 } else { a - b };
-    //~^ ERROR: manual arithmetic check found
+    //~^ implicit_saturating_sub
+
     let result = if b > a { 0 } else { a - b };
-    //~^ ERROR: manual arithmetic check found
+    //~^ implicit_saturating_sub
 
     // Should not warn!
     let result = if a > b { a - b } else { a - c };
diff --git a/src/tools/clippy/tests/ui/manual_arithmetic_check.stderr b/src/tools/clippy/tests/ui/manual_arithmetic_check.stderr
index b0cf73cd9151..b1598a5d06dc 100644
--- a/src/tools/clippy/tests/ui/manual_arithmetic_check.stderr
+++ b/src/tools/clippy/tests/ui/manual_arithmetic_check.stderr
@@ -8,19 +8,19 @@ LL |     let result = if a > b { a - b } else { 0 };
    = help: to override `-D warnings` add `#[allow(clippy::implicit_saturating_sub)]`
 
 error: manual arithmetic check found
-  --> tests/ui/manual_arithmetic_check.rs:11:18
+  --> tests/ui/manual_arithmetic_check.rs:12:18
    |
 LL |     let result = if b < a { a - b } else { 0 };
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a.saturating_sub(b)`
 
 error: manual arithmetic check found
-  --> tests/ui/manual_arithmetic_check.rs:14:18
+  --> tests/ui/manual_arithmetic_check.rs:15:18
    |
 LL |     let result = if a < b { 0 } else { a - b };
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a.saturating_sub(b)`
 
 error: manual arithmetic check found
-  --> tests/ui/manual_arithmetic_check.rs:16:18
+  --> tests/ui/manual_arithmetic_check.rs:18:18
    |
 LL |     let result = if b > a { 0 } else { a - b };
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a.saturating_sub(b)`
diff --git a/src/tools/clippy/tests/ui/manual_assert.edition2018.stderr b/src/tools/clippy/tests/ui/manual_assert.edition2018.stderr
index dfccf7e99396..8cedf2c68636 100644
--- a/src/tools/clippy/tests/ui/manual_assert.edition2018.stderr
+++ b/src/tools/clippy/tests/ui/manual_assert.edition2018.stderr
@@ -2,76 +2,155 @@ error: only a `panic!` in `if`-then statement
   --> tests/ui/manual_assert.rs:32:5
    |
 LL | /     if !a.is_empty() {
+LL | |
 LL | |         panic!("qaqaq{:?}", a);
 LL | |     }
-   | |_____^ help: try instead: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   | |_____^
    |
    = note: `-D clippy::manual-assert` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::manual_assert)]`
+help: try instead
+   |
+LL -     if !a.is_empty() {
+LL -
+LL -         panic!("qaqaq{:?}", a);
+LL -     }
+LL +     assert!(a.is_empty(), "qaqaq{:?}", a);
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:35:5
+  --> tests/ui/manual_assert.rs:36:5
    |
 LL | /     if !a.is_empty() {
+LL | |
 LL | |         panic!("qwqwq");
 LL | |     }
-   | |_____^ help: try instead: `assert!(a.is_empty(), "qwqwq");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if !a.is_empty() {
+LL -
+LL -         panic!("qwqwq");
+LL -     }
+LL +     assert!(a.is_empty(), "qwqwq");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:52:5
+  --> tests/ui/manual_assert.rs:54:5
    |
 LL | /     if b.is_empty() {
+LL | |
 LL | |         panic!("panic1");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!b.is_empty(), "panic1");`
-
-error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:55:5
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if b.is_empty() {
+LL -
+LL -         panic!("panic1");
+LL -     }
+LL +     assert!(!b.is_empty(), "panic1");
    |
-LL | /     if b.is_empty() && a.is_empty() {
-LL | |         panic!("panic2");
-LL | |     }
-   | |_____^ help: try instead: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
 
 error: only a `panic!` in `if`-then statement
   --> tests/ui/manual_assert.rs:58:5
    |
+LL | /     if b.is_empty() && a.is_empty() {
+LL | |
+LL | |         panic!("panic2");
+LL | |     }
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if b.is_empty() && a.is_empty() {
+LL -
+LL -         panic!("panic2");
+LL -     }
+LL +     assert!(!(b.is_empty() && a.is_empty()), "panic2");
+   |
+
+error: only a `panic!` in `if`-then statement
+  --> tests/ui/manual_assert.rs:62:5
+   |
 LL | /     if a.is_empty() && !b.is_empty() {
+LL | |
 LL | |         panic!("panic3");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if a.is_empty() && !b.is_empty() {
+LL -
+LL -         panic!("panic3");
+LL -     }
+LL +     assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:61:5
+  --> tests/ui/manual_assert.rs:66:5
    |
 LL | /     if b.is_empty() || a.is_empty() {
+LL | |
 LL | |         panic!("panic4");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if b.is_empty() || a.is_empty() {
+LL -
+LL -         panic!("panic4");
+LL -     }
+LL +     assert!(!(b.is_empty() || a.is_empty()), "panic4");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:64:5
+  --> tests/ui/manual_assert.rs:70:5
    |
 LL | /     if a.is_empty() || !b.is_empty() {
+LL | |
 LL | |         panic!("panic5");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if a.is_empty() || !b.is_empty() {
+LL -
+LL -         panic!("panic5");
+LL -     }
+LL +     assert!(!(a.is_empty() || !b.is_empty()), "panic5");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:67:5
+  --> tests/ui/manual_assert.rs:74:5
    |
 LL | /     if a.is_empty() {
+LL | |
 LL | |         panic!("with expansion {}", one!())
 LL | |     }
-   | |_____^ help: try instead: `assert!(!a.is_empty(), "with expansion {}", one!());`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if a.is_empty() {
+LL -
+LL -         panic!("with expansion {}", one!())
+LL -     }
+LL +     assert!(!a.is_empty(), "with expansion {}", one!());
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:79:5
+  --> tests/ui/manual_assert.rs:87:5
    |
 LL | /     if a > 2 {
+LL | |
 LL | |         // comment
 LL | |         /* this is a
-LL | |         multiline
 ...  |
 LL | |         panic!("panic with comment") // comment after `panic!`
 LL | |     }
@@ -80,6 +159,7 @@ LL | |     }
 help: try instead
    |
 LL -     if a > 2 {
+LL -
 LL -         // comment
 LL -         /* this is a
 LL -         multiline
@@ -91,13 +171,23 @@ LL +     assert!(!(a > 2), "panic with comment");
    |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:93:25
+  --> tests/ui/manual_assert.rs:102:25
    |
 LL |           const BAR: () = if N == 0 {
    |  _________________________^
+LL | |
 LL | |             panic!()
 LL | |         };
-   | |_________^ help: try instead: `assert!(!(N == 0), )`
+   | |_________^
+   |
+help: try instead
+   |
+LL -         const BAR: () = if N == 0 {
+LL -
+LL -             panic!()
+LL -         };
+LL +         const BAR: () = assert!(!(N == 0), );
+   |
 
 error: aborting due to 10 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_assert.edition2021.stderr b/src/tools/clippy/tests/ui/manual_assert.edition2021.stderr
index dfccf7e99396..8cedf2c68636 100644
--- a/src/tools/clippy/tests/ui/manual_assert.edition2021.stderr
+++ b/src/tools/clippy/tests/ui/manual_assert.edition2021.stderr
@@ -2,76 +2,155 @@ error: only a `panic!` in `if`-then statement
   --> tests/ui/manual_assert.rs:32:5
    |
 LL | /     if !a.is_empty() {
+LL | |
 LL | |         panic!("qaqaq{:?}", a);
 LL | |     }
-   | |_____^ help: try instead: `assert!(a.is_empty(), "qaqaq{:?}", a);`
+   | |_____^
    |
    = note: `-D clippy::manual-assert` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::manual_assert)]`
+help: try instead
+   |
+LL -     if !a.is_empty() {
+LL -
+LL -         panic!("qaqaq{:?}", a);
+LL -     }
+LL +     assert!(a.is_empty(), "qaqaq{:?}", a);
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:35:5
+  --> tests/ui/manual_assert.rs:36:5
    |
 LL | /     if !a.is_empty() {
+LL | |
 LL | |         panic!("qwqwq");
 LL | |     }
-   | |_____^ help: try instead: `assert!(a.is_empty(), "qwqwq");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if !a.is_empty() {
+LL -
+LL -         panic!("qwqwq");
+LL -     }
+LL +     assert!(a.is_empty(), "qwqwq");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:52:5
+  --> tests/ui/manual_assert.rs:54:5
    |
 LL | /     if b.is_empty() {
+LL | |
 LL | |         panic!("panic1");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!b.is_empty(), "panic1");`
-
-error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:55:5
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if b.is_empty() {
+LL -
+LL -         panic!("panic1");
+LL -     }
+LL +     assert!(!b.is_empty(), "panic1");
    |
-LL | /     if b.is_empty() && a.is_empty() {
-LL | |         panic!("panic2");
-LL | |     }
-   | |_____^ help: try instead: `assert!(!(b.is_empty() && a.is_empty()), "panic2");`
 
 error: only a `panic!` in `if`-then statement
   --> tests/ui/manual_assert.rs:58:5
    |
+LL | /     if b.is_empty() && a.is_empty() {
+LL | |
+LL | |         panic!("panic2");
+LL | |     }
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if b.is_empty() && a.is_empty() {
+LL -
+LL -         panic!("panic2");
+LL -     }
+LL +     assert!(!(b.is_empty() && a.is_empty()), "panic2");
+   |
+
+error: only a `panic!` in `if`-then statement
+  --> tests/ui/manual_assert.rs:62:5
+   |
 LL | /     if a.is_empty() && !b.is_empty() {
+LL | |
 LL | |         panic!("panic3");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!(a.is_empty() && !b.is_empty()), "panic3");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if a.is_empty() && !b.is_empty() {
+LL -
+LL -         panic!("panic3");
+LL -     }
+LL +     assert!(!(a.is_empty() && !b.is_empty()), "panic3");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:61:5
+  --> tests/ui/manual_assert.rs:66:5
    |
 LL | /     if b.is_empty() || a.is_empty() {
+LL | |
 LL | |         panic!("panic4");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!(b.is_empty() || a.is_empty()), "panic4");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if b.is_empty() || a.is_empty() {
+LL -
+LL -         panic!("panic4");
+LL -     }
+LL +     assert!(!(b.is_empty() || a.is_empty()), "panic4");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:64:5
+  --> tests/ui/manual_assert.rs:70:5
    |
 LL | /     if a.is_empty() || !b.is_empty() {
+LL | |
 LL | |         panic!("panic5");
 LL | |     }
-   | |_____^ help: try instead: `assert!(!(a.is_empty() || !b.is_empty()), "panic5");`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if a.is_empty() || !b.is_empty() {
+LL -
+LL -         panic!("panic5");
+LL -     }
+LL +     assert!(!(a.is_empty() || !b.is_empty()), "panic5");
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:67:5
+  --> tests/ui/manual_assert.rs:74:5
    |
 LL | /     if a.is_empty() {
+LL | |
 LL | |         panic!("with expansion {}", one!())
 LL | |     }
-   | |_____^ help: try instead: `assert!(!a.is_empty(), "with expansion {}", one!());`
+   | |_____^
+   |
+help: try instead
+   |
+LL -     if a.is_empty() {
+LL -
+LL -         panic!("with expansion {}", one!())
+LL -     }
+LL +     assert!(!a.is_empty(), "with expansion {}", one!());
+   |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:79:5
+  --> tests/ui/manual_assert.rs:87:5
    |
 LL | /     if a > 2 {
+LL | |
 LL | |         // comment
 LL | |         /* this is a
-LL | |         multiline
 ...  |
 LL | |         panic!("panic with comment") // comment after `panic!`
 LL | |     }
@@ -80,6 +159,7 @@ LL | |     }
 help: try instead
    |
 LL -     if a > 2 {
+LL -
 LL -         // comment
 LL -         /* this is a
 LL -         multiline
@@ -91,13 +171,23 @@ LL +     assert!(!(a > 2), "panic with comment");
    |
 
 error: only a `panic!` in `if`-then statement
-  --> tests/ui/manual_assert.rs:93:25
+  --> tests/ui/manual_assert.rs:102:25
    |
 LL |           const BAR: () = if N == 0 {
    |  _________________________^
+LL | |
 LL | |             panic!()
 LL | |         };
-   | |_________^ help: try instead: `assert!(!(N == 0), )`
+   | |_________^
+   |
+help: try instead
+   |
+LL -         const BAR: () = if N == 0 {
+LL -
+LL -             panic!()
+LL -         };
+LL +         const BAR: () = assert!(!(N == 0), );
+   |
 
 error: aborting due to 10 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_assert.rs b/src/tools/clippy/tests/ui/manual_assert.rs
index 6337920a3eea..46a42c3d00af 100644
--- a/src/tools/clippy/tests/ui/manual_assert.rs
+++ b/src/tools/clippy/tests/ui/manual_assert.rs
@@ -30,9 +30,11 @@ fn main() {
         panic!("qaqaq{:?}", a);
     }
     if !a.is_empty() {
+        //~^ manual_assert
         panic!("qaqaq{:?}", a);
     }
     if !a.is_empty() {
+        //~^ manual_assert
         panic!("qwqwq");
     }
     if a.len() == 3 {
@@ -50,21 +52,27 @@ fn main() {
     }
     let b = vec![1, 2, 3];
     if b.is_empty() {
+        //~^ manual_assert
         panic!("panic1");
     }
     if b.is_empty() && a.is_empty() {
+        //~^ manual_assert
         panic!("panic2");
     }
     if a.is_empty() && !b.is_empty() {
+        //~^ manual_assert
         panic!("panic3");
     }
     if b.is_empty() || a.is_empty() {
+        //~^ manual_assert
         panic!("panic4");
     }
     if a.is_empty() || !b.is_empty() {
+        //~^ manual_assert
         panic!("panic5");
     }
     if a.is_empty() {
+        //~^ manual_assert
         panic!("with expansion {}", one!())
     }
     if a.is_empty() {
@@ -77,6 +85,7 @@ fn main() {
 fn issue7730(a: u8) {
     // Suggestion should preserve comment
     if a > 2 {
+        //~^ manual_assert
         // comment
         /* this is a
         multiline
@@ -91,6 +100,7 @@ fn issue12505() {
 
     impl<T, const N: usize> Foo<T, N> {
         const BAR: () = if N == 0 {
+            //~^ manual_assert
             panic!()
         };
     }
diff --git a/src/tools/clippy/tests/ui/manual_async_fn.fixed b/src/tools/clippy/tests/ui/manual_async_fn.fixed
index dc1cb8e11fca..ad0266d39e98 100644
--- a/src/tools/clippy/tests/ui/manual_async_fn.fixed
+++ b/src/tools/clippy/tests/ui/manual_async_fn.fixed
@@ -113,4 +113,30 @@ pub(crate) async fn issue_10450_2() -> i32 { 42 }
 
 pub(self) async fn issue_10450_3() -> i32 { 42 }
 
+macro_rules! issue_12407 {
+    (
+        $(
+            $(#[$m:meta])*
+            $v:vis $(override($($overrides:tt),* $(,)?))? fn $name:ident $([$($params:tt)*])? (
+                $($arg_name:ident: $arg_typ:ty),* $(,)?
+            ) $(-> $ret_ty:ty)? = $e:expr;
+        )*
+    ) => {
+        $(
+            $(#[$m])*
+            $v $($($overrides)*)? fn $name$(<$($params)*>)?(
+                $($arg_name: $arg_typ),*
+            ) $(-> $ret_ty)? {
+                $e
+            }
+        )*
+    };
+}
+
+issue_12407! {
+    fn _hello() -> impl Future<Output = ()> = async {};
+    fn non_async() = println!("hello");
+    fn foo() = non_async();
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/manual_async_fn.rs b/src/tools/clippy/tests/ui/manual_async_fn.rs
index 9ca7654a3688..fe367b4bc7b9 100644
--- a/src/tools/clippy/tests/ui/manual_async_fn.rs
+++ b/src/tools/clippy/tests/ui/manual_async_fn.rs
@@ -4,34 +4,41 @@
 use std::future::Future;
 
 fn fut() -> impl Future<Output = i32> {
+    //~^ manual_async_fn
     async { 42 }
 }
 
 #[rustfmt::skip]
 fn fut2() ->impl Future<Output = i32> {
+//~^ manual_async_fn
     async { 42 }
 }
 
 #[rustfmt::skip]
 fn fut3()-> impl Future<Output = i32> {
+//~^ manual_async_fn
     async { 42 }
 }
 
 fn empty_fut() -> impl Future<Output = ()> {
+    //~^ manual_async_fn
     async {}
 }
 
 #[rustfmt::skip]
 fn empty_fut2() ->impl Future<Output = ()> {
+//~^ manual_async_fn
     async {}
 }
 
 #[rustfmt::skip]
 fn empty_fut3()-> impl Future<Output = ()> {
+//~^ manual_async_fn
     async {}
 }
 
 fn core_fut() -> impl core::future::Future<Output = i32> {
+    //~^ manual_async_fn
     async move { 42 }
 }
 
@@ -54,6 +61,7 @@ async fn already_async() -> impl Future<Output = i32> {
 struct S;
 impl S {
     fn inh_fut() -> impl Future<Output = i32> {
+        //~^ manual_async_fn
         async {
             // NOTE: this code is here just to check that the indentation is correct in the suggested fix
             let a = 42;
@@ -89,6 +97,7 @@ impl S {
 // Tests related to lifetime capture
 
 fn elided(_: &i32) -> impl Future<Output = i32> + '_ {
+    //~^ manual_async_fn
     async { 42 }
 }
 
@@ -99,6 +108,7 @@ fn elided_not_bound(_: &i32) -> impl Future<Output = i32> {
 
 #[allow(clippy::needless_lifetimes)]
 fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b {
+    //~^ manual_async_fn
     async { 42 }
 }
 
@@ -128,15 +138,44 @@ mod issue_5765 {
 }
 
 pub fn issue_10450() -> impl Future<Output = i32> {
+    //~^ manual_async_fn
     async { 42 }
 }
 
 pub(crate) fn issue_10450_2() -> impl Future<Output = i32> {
+    //~^ manual_async_fn
     async { 42 }
 }
 
 pub(self) fn issue_10450_3() -> impl Future<Output = i32> {
+    //~^ manual_async_fn
     async { 42 }
 }
 
+macro_rules! issue_12407 {
+    (
+        $(
+            $(#[$m:meta])*
+            $v:vis $(override($($overrides:tt),* $(,)?))? fn $name:ident $([$($params:tt)*])? (
+                $($arg_name:ident: $arg_typ:ty),* $(,)?
+            ) $(-> $ret_ty:ty)? = $e:expr;
+        )*
+    ) => {
+        $(
+            $(#[$m])*
+            $v $($($overrides)*)? fn $name$(<$($params)*>)?(
+                $($arg_name: $arg_typ),*
+            ) $(-> $ret_ty)? {
+                $e
+            }
+        )*
+    };
+}
+
+issue_12407! {
+    fn _hello() -> impl Future<Output = ()> = async {};
+    fn non_async() = println!("hello");
+    fn foo() = non_async();
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/manual_async_fn.stderr b/src/tools/clippy/tests/ui/manual_async_fn.stderr
index a7cfc30fb69c..54a9b1d40a11 100644
--- a/src/tools/clippy/tests/ui/manual_async_fn.stderr
+++ b/src/tools/clippy/tests/ui/manual_async_fn.stderr
@@ -13,7 +13,7 @@ LL + async fn fut() -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:11:1
+  --> tests/ui/manual_async_fn.rs:12:1
    |
 LL | fn fut2() ->impl Future<Output = i32> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL + async fn fut2() -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:16:1
+  --> tests/ui/manual_async_fn.rs:18:1
    |
 LL | fn fut3()-> impl Future<Output = i32> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL + async fn fut3() -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:20:1
+  --> tests/ui/manual_async_fn.rs:23:1
    |
 LL | fn empty_fut() -> impl Future<Output = ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL + async fn empty_fut() {}
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:25:1
+  --> tests/ui/manual_async_fn.rs:29:1
    |
 LL | fn empty_fut2() ->impl Future<Output = ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL + async fn empty_fut2() {}
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:30:1
+  --> tests/ui/manual_async_fn.rs:35:1
    |
 LL | fn empty_fut3()-> impl Future<Output = ()> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL + async fn empty_fut3() {}
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:34:1
+  --> tests/ui/manual_async_fn.rs:40:1
    |
 LL | fn core_fut() -> impl core::future::Future<Output = i32> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL + async fn core_fut() -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:56:5
+  --> tests/ui/manual_async_fn.rs:63:5
    |
 LL |     fn inh_fut() -> impl Future<Output = i32> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +108,7 @@ LL +     }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:91:1
+  --> tests/ui/manual_async_fn.rs:99:1
    |
 LL | fn elided(_: &i32) -> impl Future<Output = i32> + '_ {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL + async fn elided(_: &i32) -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:101:1
+  --> tests/ui/manual_async_fn.rs:110:1
    |
 LL | fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> impl Future<Output = i32> + 'a + 'b {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL + async fn explicit<'a, 'b>(_: &'a i32, _: &'b i32) -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:130:1
+  --> tests/ui/manual_async_fn.rs:140:1
    |
 LL | pub fn issue_10450() -> impl Future<Output = i32> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +144,7 @@ LL + pub async fn issue_10450() -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:134:1
+  --> tests/ui/manual_async_fn.rs:145:1
    |
 LL | pub(crate) fn issue_10450_2() -> impl Future<Output = i32> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL + pub(crate) async fn issue_10450_2() -> i32 { 42 }
    |
 
 error: this function can be simplified using the `async fn` syntax
-  --> tests/ui/manual_async_fn.rs:138:1
+  --> tests/ui/manual_async_fn.rs:150:1
    |
 LL | pub(self) fn issue_10450_3() -> impl Future<Output = i32> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/manual_bits.fixed b/src/tools/clippy/tests/ui/manual_bits.fixed
index 8e5cb7d38b9b..db2ad2ace625 100644
--- a/src/tools/clippy/tests/ui/manual_bits.fixed
+++ b/src/tools/clippy/tests/ui/manual_bits.fixed
@@ -12,32 +12,56 @@ use std::mem::{size_of, size_of_val};
 
 fn main() {
     i8::BITS as usize;
+    //~^ manual_bits
     i16::BITS as usize;
+    //~^ manual_bits
     i32::BITS as usize;
+    //~^ manual_bits
     i64::BITS as usize;
+    //~^ manual_bits
     i128::BITS as usize;
+    //~^ manual_bits
     isize::BITS as usize;
+    //~^ manual_bits
 
     u8::BITS as usize;
+    //~^ manual_bits
     u16::BITS as usize;
+    //~^ manual_bits
     u32::BITS as usize;
+    //~^ manual_bits
     u64::BITS as usize;
+    //~^ manual_bits
     u128::BITS as usize;
+    //~^ manual_bits
     usize::BITS as usize;
+    //~^ manual_bits
 
     i8::BITS as usize;
+    //~^ manual_bits
     i16::BITS as usize;
+    //~^ manual_bits
     i32::BITS as usize;
+    //~^ manual_bits
     i64::BITS as usize;
+    //~^ manual_bits
     i128::BITS as usize;
+    //~^ manual_bits
     isize::BITS as usize;
+    //~^ manual_bits
 
     u8::BITS as usize;
+    //~^ manual_bits
     u16::BITS as usize;
+    //~^ manual_bits
     u32::BITS as usize;
+    //~^ manual_bits
     u64::BITS as usize;
+    //~^ manual_bits
     u128::BITS as usize;
+    //~^ manual_bits
     usize::BITS as usize;
+    //~^ manual_bits
 
     size_of::<usize>() * 4;
     4 * size_of::<usize>();
@@ -48,13 +72,18 @@ fn main() {
 
     type Word = u32;
     Word::BITS as usize;
+    //~^ manual_bits
     type Bool = bool;
     size_of::<Bool>() * 8;
 
     let _: u32 = u128::BITS as u32;
+    //~^ manual_bits
     let _: u32 = u128::BITS.try_into().unwrap();
+    //~^ manual_bits
     let _ = (u128::BITS as usize).pow(5);
+    //~^ manual_bits
     let _ = &(u128::BITS as usize);
+    //~^ manual_bits
 }
 
 fn should_not_lint() {
diff --git a/src/tools/clippy/tests/ui/manual_bits.rs b/src/tools/clippy/tests/ui/manual_bits.rs
index 5e492ed15d21..6d1f0de1c19d 100644
--- a/src/tools/clippy/tests/ui/manual_bits.rs
+++ b/src/tools/clippy/tests/ui/manual_bits.rs
@@ -12,32 +12,56 @@ use std::mem::{size_of, size_of_val};
 
 fn main() {
     size_of::<i8>() * 8;
+    //~^ manual_bits
     size_of::<i16>() * 8;
+    //~^ manual_bits
     size_of::<i32>() * 8;
+    //~^ manual_bits
     size_of::<i64>() * 8;
+    //~^ manual_bits
     size_of::<i128>() * 8;
+    //~^ manual_bits
     size_of::<isize>() * 8;
+    //~^ manual_bits
 
     size_of::<u8>() * 8;
+    //~^ manual_bits
     size_of::<u16>() * 8;
+    //~^ manual_bits
     size_of::<u32>() * 8;
+    //~^ manual_bits
     size_of::<u64>() * 8;
+    //~^ manual_bits
     size_of::<u128>() * 8;
+    //~^ manual_bits
     size_of::<usize>() * 8;
+    //~^ manual_bits
 
     8 * size_of::<i8>();
+    //~^ manual_bits
     8 * size_of::<i16>();
+    //~^ manual_bits
     8 * size_of::<i32>();
+    //~^ manual_bits
     8 * size_of::<i64>();
+    //~^ manual_bits
     8 * size_of::<i128>();
+    //~^ manual_bits
     8 * size_of::<isize>();
+    //~^ manual_bits
 
     8 * size_of::<u8>();
+    //~^ manual_bits
     8 * size_of::<u16>();
+    //~^ manual_bits
     8 * size_of::<u32>();
+    //~^ manual_bits
     8 * size_of::<u64>();
+    //~^ manual_bits
     8 * size_of::<u128>();
+    //~^ manual_bits
     8 * size_of::<usize>();
+    //~^ manual_bits
 
     size_of::<usize>() * 4;
     4 * size_of::<usize>();
@@ -48,13 +72,18 @@ fn main() {
 
     type Word = u32;
     size_of::<Word>() * 8;
+    //~^ manual_bits
     type Bool = bool;
     size_of::<Bool>() * 8;
 
     let _: u32 = (size_of::<u128>() * 8) as u32;
+    //~^ manual_bits
     let _: u32 = (size_of::<u128>() * 8).try_into().unwrap();
+    //~^ manual_bits
     let _ = (size_of::<u128>() * 8).pow(5);
+    //~^ manual_bits
     let _ = &(size_of::<u128>() * 8);
+    //~^ manual_bits
 }
 
 fn should_not_lint() {
diff --git a/src/tools/clippy/tests/ui/manual_bits.stderr b/src/tools/clippy/tests/ui/manual_bits.stderr
index 4383aa49df9b..a50975ed474e 100644
--- a/src/tools/clippy/tests/ui/manual_bits.stderr
+++ b/src/tools/clippy/tests/ui/manual_bits.stderr
@@ -8,169 +8,169 @@ LL |     size_of::<i8>() * 8;
    = help: to override `-D warnings` add `#[allow(clippy::manual_bits)]`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:15:5
+  --> tests/ui/manual_bits.rs:16:5
    |
 LL |     size_of::<i16>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:16:5
+  --> tests/ui/manual_bits.rs:18:5
    |
 LL |     size_of::<i32>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:17:5
+  --> tests/ui/manual_bits.rs:20:5
    |
 LL |     size_of::<i64>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:18:5
+  --> tests/ui/manual_bits.rs:22:5
    |
 LL |     size_of::<i128>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:19:5
+  --> tests/ui/manual_bits.rs:24:5
    |
 LL |     size_of::<isize>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:21:5
+  --> tests/ui/manual_bits.rs:27:5
    |
 LL |     size_of::<u8>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:22:5
+  --> tests/ui/manual_bits.rs:29:5
    |
 LL |     size_of::<u16>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:23:5
+  --> tests/ui/manual_bits.rs:31:5
    |
 LL |     size_of::<u32>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:24:5
+  --> tests/ui/manual_bits.rs:33:5
    |
 LL |     size_of::<u64>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:25:5
+  --> tests/ui/manual_bits.rs:35:5
    |
 LL |     size_of::<u128>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:26:5
+  --> tests/ui/manual_bits.rs:37:5
    |
 LL |     size_of::<usize>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:28:5
+  --> tests/ui/manual_bits.rs:40:5
    |
 LL |     8 * size_of::<i8>();
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `i8::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:29:5
+  --> tests/ui/manual_bits.rs:42:5
    |
 LL |     8 * size_of::<i16>();
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:30:5
+  --> tests/ui/manual_bits.rs:44:5
    |
 LL |     8 * size_of::<i32>();
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:31:5
+  --> tests/ui/manual_bits.rs:46:5
    |
 LL |     8 * size_of::<i64>();
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `i64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:32:5
+  --> tests/ui/manual_bits.rs:48:5
    |
 LL |     8 * size_of::<i128>();
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `i128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:33:5
+  --> tests/ui/manual_bits.rs:50:5
    |
 LL |     8 * size_of::<isize>();
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `isize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:35:5
+  --> tests/ui/manual_bits.rs:53:5
    |
 LL |     8 * size_of::<u8>();
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `u8::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:36:5
+  --> tests/ui/manual_bits.rs:55:5
    |
 LL |     8 * size_of::<u16>();
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u16::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:37:5
+  --> tests/ui/manual_bits.rs:57:5
    |
 LL |     8 * size_of::<u32>();
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u32::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:38:5
+  --> tests/ui/manual_bits.rs:59:5
    |
 LL |     8 * size_of::<u64>();
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using: `u64::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:39:5
+  --> tests/ui/manual_bits.rs:61:5
    |
 LL |     8 * size_of::<u128>();
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:40:5
+  --> tests/ui/manual_bits.rs:63:5
    |
 LL |     8 * size_of::<usize>();
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `usize::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:50:5
+  --> tests/ui/manual_bits.rs:74:5
    |
 LL |     size_of::<Word>() * 8;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `Word::BITS as usize`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:54:18
+  --> tests/ui/manual_bits.rs:79:18
    |
 LL |     let _: u32 = (size_of::<u128>() * 8) as u32;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:55:18
+  --> tests/ui/manual_bits.rs:81:18
    |
 LL |     let _: u32 = (size_of::<u128>() * 8).try_into().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `u128::BITS`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:56:13
+  --> tests/ui/manual_bits.rs:83:13
    |
 LL |     let _ = (size_of::<u128>() * 8).pow(5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)`
 
 error: usage of `mem::size_of::<T>()` to obtain the size of `T` in bits
-  --> tests/ui/manual_bits.rs:57:14
+  --> tests/ui/manual_bits.rs:85:14
    |
 LL |     let _ = &(size_of::<u128>() * 8);
    |              ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(u128::BITS as usize)`
diff --git a/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.fixed b/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.fixed
index 391c63bb4b89..3ffaef0386ce 100644
--- a/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.fixed
+++ b/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.fixed
@@ -1,6 +1,7 @@
 //@revisions: edition2018 edition2021
 //@[edition2018] edition:2018
 //@[edition2021] edition:2021
+//@[edition2018] check-pass
 #![warn(clippy::manual_c_str_literals)]
 #![allow(clippy::no_effect)]
 
@@ -32,29 +33,42 @@ fn pre_stabilization() {
 #[clippy::msrv = "1.77.0"]
 fn post_stabilization() {
     c"foo";
+    //~[edition2021]^ manual_c_str_literals
 }
 
 fn main() {
     c"foo";
+    //~[edition2021]^ manual_c_str_literals
     c"foo";
+    //~[edition2021]^ manual_c_str_literals
     c"foo";
+    //~[edition2021]^ manual_c_str_literals
     c"foo\\0sdsd";
+    //~[edition2021]^ manual_c_str_literals
     CStr::from_bytes_with_nul(br"foo\\0sdsd\0").unwrap();
     CStr::from_bytes_with_nul(br"foo\x00").unwrap();
     CStr::from_bytes_with_nul(br##"foo#a\0"##).unwrap();
 
     unsafe { c"foo" };
+    //~[edition2021]^ manual_c_str_literals
     unsafe { c"foo" };
+    //~[edition2021]^ manual_c_str_literals
     let _: *const _ = c"foo".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _: *const _ = c"foo".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _: *const _ = "foo".as_ptr(); // not a C-string
     let _: *const _ = "".as_ptr();
     let _: *const _ = c"foo".as_ptr().cast::<i8>();
+    //~[edition2021]^ manual_c_str_literals
     let _ = "电脑".as_ptr();
     let _ = "电脑\\".as_ptr();
     let _ = c"电脑\\".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _ = c"电脑".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _ = c"电脑".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
 
     // Macro cases, don't lint:
     cstr!("foo");
diff --git a/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.stderr b/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.stderr
index beab29ccdda0..2119bbc5b425 100644
--- a/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.stderr
+++ b/src/tools/clippy/tests/ui/manual_c_str_literals.edition2021.stderr
@@ -1,5 +1,5 @@
 error: calling `CStr::new` with a byte string literal
-  --> tests/ui/manual_c_str_literals.rs:34:5
+  --> tests/ui/manual_c_str_literals.rs:35:5
    |
 LL |     CStr::from_bytes_with_nul(b"foo\0");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
@@ -8,73 +8,73 @@ LL |     CStr::from_bytes_with_nul(b"foo\0");
    = help: to override `-D warnings` add `#[allow(clippy::manual_c_str_literals)]`
 
 error: calling `CStr::new` with a byte string literal
-  --> tests/ui/manual_c_str_literals.rs:38:5
+  --> tests/ui/manual_c_str_literals.rs:40:5
    |
 LL |     CStr::from_bytes_with_nul(b"foo\0");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: calling `CStr::new` with a byte string literal
-  --> tests/ui/manual_c_str_literals.rs:39:5
+  --> tests/ui/manual_c_str_literals.rs:42:5
    |
 LL |     CStr::from_bytes_with_nul(b"foo\x00");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: calling `CStr::new` with a byte string literal
-  --> tests/ui/manual_c_str_literals.rs:40:5
+  --> tests/ui/manual_c_str_literals.rs:44:5
    |
 LL |     CStr::from_bytes_with_nul(b"foo\0").unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: calling `CStr::new` with a byte string literal
-  --> tests/ui/manual_c_str_literals.rs:41:5
+  --> tests/ui/manual_c_str_literals.rs:46:5
    |
 LL |     CStr::from_bytes_with_nul(b"foo\\0sdsd\0").unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo\\0sdsd"`
 
 error: calling `CStr::from_ptr` with a byte string literal
-  --> tests/ui/manual_c_str_literals.rs:46:14
+  --> tests/ui/manual_c_str_literals.rs:52:14
    |
 LL |     unsafe { CStr::from_ptr(b"foo\0".as_ptr().cast()) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: calling `CStr::from_ptr` with a byte string literal
-  --> tests/ui/manual_c_str_literals.rs:47:14
+  --> tests/ui/manual_c_str_literals.rs:54:14
    |
 LL |     unsafe { CStr::from_ptr(b"foo\0".as_ptr() as *const _) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: manually constructing a nul-terminated string
-  --> tests/ui/manual_c_str_literals.rs:48:23
+  --> tests/ui/manual_c_str_literals.rs:56:23
    |
 LL |     let _: *const _ = b"foo\0".as_ptr();
    |                       ^^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: manually constructing a nul-terminated string
-  --> tests/ui/manual_c_str_literals.rs:49:23
+  --> tests/ui/manual_c_str_literals.rs:58:23
    |
 LL |     let _: *const _ = "foo\0".as_ptr();
    |                       ^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: manually constructing a nul-terminated string
-  --> tests/ui/manual_c_str_literals.rs:52:23
+  --> tests/ui/manual_c_str_literals.rs:62:23
    |
 LL |     let _: *const _ = b"foo\0".as_ptr().cast::<i8>();
    |                       ^^^^^^^^ help: use a `c""` literal: `c"foo"`
 
 error: manually constructing a nul-terminated string
-  --> tests/ui/manual_c_str_literals.rs:55:13
+  --> tests/ui/manual_c_str_literals.rs:66:13
    |
 LL |     let _ = "电脑\\\0".as_ptr();
    |             ^^^^^^^^^^ help: use a `c""` literal: `c"电脑\\"`
 
 error: manually constructing a nul-terminated string
-  --> tests/ui/manual_c_str_literals.rs:56:13
+  --> tests/ui/manual_c_str_literals.rs:68:13
    |
 LL |     let _ = "电脑\0".as_ptr();
    |             ^^^^^^^^ help: use a `c""` literal: `c"电脑"`
 
 error: manually constructing a nul-terminated string
-  --> tests/ui/manual_c_str_literals.rs:57:13
+  --> tests/ui/manual_c_str_literals.rs:70:13
    |
 LL |     let _ = "电脑\x00".as_ptr();
    |             ^^^^^^^^^^ help: use a `c""` literal: `c"电脑"`
diff --git a/src/tools/clippy/tests/ui/manual_c_str_literals.rs b/src/tools/clippy/tests/ui/manual_c_str_literals.rs
index 39b622580774..ec3b8e587724 100644
--- a/src/tools/clippy/tests/ui/manual_c_str_literals.rs
+++ b/src/tools/clippy/tests/ui/manual_c_str_literals.rs
@@ -1,6 +1,7 @@
 //@revisions: edition2018 edition2021
 //@[edition2018] edition:2018
 //@[edition2021] edition:2021
+//@[edition2018] check-pass
 #![warn(clippy::manual_c_str_literals)]
 #![allow(clippy::no_effect)]
 
@@ -32,29 +33,42 @@ fn pre_stabilization() {
 #[clippy::msrv = "1.77.0"]
 fn post_stabilization() {
     CStr::from_bytes_with_nul(b"foo\0");
+    //~[edition2021]^ manual_c_str_literals
 }
 
 fn main() {
     CStr::from_bytes_with_nul(b"foo\0");
+    //~[edition2021]^ manual_c_str_literals
     CStr::from_bytes_with_nul(b"foo\x00");
+    //~[edition2021]^ manual_c_str_literals
     CStr::from_bytes_with_nul(b"foo\0").unwrap();
+    //~[edition2021]^ manual_c_str_literals
     CStr::from_bytes_with_nul(b"foo\\0sdsd\0").unwrap();
+    //~[edition2021]^ manual_c_str_literals
     CStr::from_bytes_with_nul(br"foo\\0sdsd\0").unwrap();
     CStr::from_bytes_with_nul(br"foo\x00").unwrap();
     CStr::from_bytes_with_nul(br##"foo#a\0"##).unwrap();
 
     unsafe { CStr::from_ptr(b"foo\0".as_ptr().cast()) };
+    //~[edition2021]^ manual_c_str_literals
     unsafe { CStr::from_ptr(b"foo\0".as_ptr() as *const _) };
+    //~[edition2021]^ manual_c_str_literals
     let _: *const _ = b"foo\0".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _: *const _ = "foo\0".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _: *const _ = "foo".as_ptr(); // not a C-string
     let _: *const _ = "".as_ptr();
     let _: *const _ = b"foo\0".as_ptr().cast::<i8>();
+    //~[edition2021]^ manual_c_str_literals
     let _ = "电脑".as_ptr();
     let _ = "电脑\\".as_ptr();
     let _ = "电脑\\\0".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _ = "电脑\0".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
     let _ = "电脑\x00".as_ptr();
+    //~[edition2021]^ manual_c_str_literals
 
     // Macro cases, don't lint:
     cstr!("foo");
diff --git a/src/tools/clippy/tests/ui/manual_clamp.fixed b/src/tools/clippy/tests/ui/manual_clamp.fixed
index 8d57cbbf51bf..2450a4f4c611 100644
--- a/src/tools/clippy/tests/ui/manual_clamp.fixed
+++ b/src/tools/clippy/tests/ui/manual_clamp.fixed
@@ -150,12 +150,10 @@ fn const_main() {
     let x3 = input.clamp(CONST_MIN, CONST_MAX);
 
     let x4 = input.clamp(CONST_MIN, CONST_MAX);
-    //~^ ERROR: clamp-like pattern without using clamp function
-    //~| NOTE: clamp will panic if max < min
+    //~^ manual_clamp
 
     let x5 = input.clamp(CONST_MIN, CONST_MAX);
-    //~^ ERROR: clamp-like pattern without using clamp function
-    //~| NOTE: clamp will panic if max < min
+    //~^ manual_clamp
 
     let x6 = input.clamp(CONST_MIN, CONST_MAX);
 
@@ -187,54 +185,53 @@ fn const_main() {
         let input: i32 = cmp_min_max(1);
         // These can only be detected if exactly one of the arguments to the inner function is const.
         let x16 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x17 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x18 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x19 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x20 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x21 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x22 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x23 = input.clamp(CONST_MIN, CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let input: f64 = cmp_min_max(1) as f64;
         let x24 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x25 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x26 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x27 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x28 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x29 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x30 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x31 = input.clamp(CONST_F64_MIN, CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
     }
     let mut x32 = input;
     x32 = x32.clamp(CONST_MIN, CONST_MAX);
diff --git a/src/tools/clippy/tests/ui/manual_clamp.rs b/src/tools/clippy/tests/ui/manual_clamp.rs
index 4d2a0c47bbd7..ee341d50768f 100644
--- a/src/tools/clippy/tests/ui/manual_clamp.rs
+++ b/src/tools/clippy/tests/ui/manual_clamp.rs
@@ -142,8 +142,8 @@ fn const_main() {
     let input = 0;
     // Min and max are const, so this should trigger the lint.
     let x0 = if CONST_MAX < input {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         CONST_MAX
     } else if CONST_MIN > input {
         CONST_MIN
@@ -152,8 +152,8 @@ fn const_main() {
     };
 
     let x1 = if input > CONST_MAX {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         CONST_MAX
     } else if input < CONST_MIN {
         CONST_MIN
@@ -162,8 +162,8 @@ fn const_main() {
     };
 
     let x2 = if input < CONST_MIN {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         CONST_MIN
     } else if input > CONST_MAX {
         CONST_MAX
@@ -172,8 +172,8 @@ fn const_main() {
     };
 
     let x3 = if CONST_MIN > input {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         CONST_MIN
     } else if CONST_MAX < input {
         CONST_MAX
@@ -182,32 +182,27 @@ fn const_main() {
     };
 
     let x4 = input.max(CONST_MIN).min(CONST_MAX);
-    //~^ ERROR: clamp-like pattern without using clamp function
-    //~| NOTE: clamp will panic if max < min
+    //~^ manual_clamp
 
     let x5 = input.min(CONST_MAX).max(CONST_MIN);
-    //~^ ERROR: clamp-like pattern without using clamp function
-    //~| NOTE: clamp will panic if max < min
+    //~^ manual_clamp
 
     let x6 = match input {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
         x if x > CONST_MAX => CONST_MAX,
         x if x < CONST_MIN => CONST_MIN,
         x => x,
     };
 
     let x7 = match input {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
         x if x < CONST_MIN => CONST_MIN,
         x if x > CONST_MAX => CONST_MAX,
         x => x,
     };
 
     let x8 = match input {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
         x if CONST_MAX < x => CONST_MAX,
         x if CONST_MIN > x => CONST_MIN,
         x => x,
@@ -215,8 +210,8 @@ fn const_main() {
 
     let mut x9 = input;
     if x9 < CONST_MIN {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         x9 = CONST_MIN;
     }
     if x9 > CONST_MAX {
@@ -224,8 +219,7 @@ fn const_main() {
     }
 
     let x10 = match input {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
         x if CONST_MIN > x => CONST_MIN,
         x if CONST_MAX < x => CONST_MAX,
         x => x,
@@ -234,8 +228,8 @@ fn const_main() {
     let mut x11 = input;
     let _ = 1;
     if x11 > CONST_MAX {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         x11 = CONST_MAX;
     }
     if x11 < CONST_MIN {
@@ -244,8 +238,8 @@ fn const_main() {
 
     let mut x12 = input;
     if CONST_MIN > x12 {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         x12 = CONST_MIN;
     }
     if CONST_MAX < x12 {
@@ -254,8 +248,8 @@ fn const_main() {
 
     let mut x13 = input;
     if CONST_MAX < x13 {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         x13 = CONST_MAX;
     }
     if CONST_MIN > x13 {
@@ -263,8 +257,8 @@ fn const_main() {
     }
 
     let x14 = if input > CONST_MAX {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         CONST_MAX
     } else if input < CONST_MIN {
         CONST_MIN
@@ -274,8 +268,8 @@ fn const_main() {
     {
         let input = 0.0f64;
         let x15 = if input > CONST_F64_MAX {
-            //~^ ERROR: clamp-like pattern without using clamp function
-            //~| NOTE: clamp will panic if max < min
+            //~^ manual_clamp
+
             CONST_F64_MAX
         } else if input < CONST_F64_MIN {
             CONST_F64_MIN
@@ -287,59 +281,58 @@ fn const_main() {
         let input: i32 = cmp_min_max(1);
         // These can only be detected if exactly one of the arguments to the inner function is const.
         let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         let input: f64 = cmp_min_max(1) as f64;
         let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
+
         let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min, min.is_nan(), or max.is_nan()
+        //~^ manual_clamp
     }
     let mut x32 = input;
     if x32 < CONST_MIN {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         x32 = CONST_MIN;
     } else if x32 > CONST_MAX {
         x32 = CONST_MAX;
@@ -368,8 +361,8 @@ fn const_main() {
     // It's important this be the last set of statements
     let mut x35 = input;
     if CONST_MAX < x35 {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         x35 = CONST_MAX;
     }
     if CONST_MIN > x35 {
@@ -530,8 +523,8 @@ fn msrv_1_49() {
 fn msrv_1_50() {
     let input = 0;
     let _ = if input > CONST_MAX {
-        //~^ ERROR: clamp-like pattern without using clamp function
-        //~| NOTE: clamp will panic if max < min
+        //~^ manual_clamp
+
         CONST_MAX
     } else if input < CONST_MIN {
         CONST_MIN
diff --git a/src/tools/clippy/tests/ui/manual_clamp.stderr b/src/tools/clippy/tests/ui/manual_clamp.stderr
index 459d46796d87..4a0e4fa51646 100644
--- a/src/tools/clippy/tests/ui/manual_clamp.stderr
+++ b/src/tools/clippy/tests/ui/manual_clamp.stderr
@@ -1,5 +1,5 @@
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:217:5
+  --> tests/ui/manual_clamp.rs:212:5
    |
 LL | /     if x9 < CONST_MIN {
 LL | |
@@ -15,7 +15,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::manual_clamp)]`
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:236:5
+  --> tests/ui/manual_clamp.rs:230:5
    |
 LL | /     if x11 > CONST_MAX {
 LL | |
@@ -29,7 +29,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:246:5
+  --> tests/ui/manual_clamp.rs:240:5
    |
 LL | /     if CONST_MIN > x12 {
 LL | |
@@ -43,7 +43,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:256:5
+  --> tests/ui/manual_clamp.rs:250:5
    |
 LL | /     if CONST_MAX < x13 {
 LL | |
@@ -57,7 +57,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:370:5
+  --> tests/ui/manual_clamp.rs:363:5
    |
 LL | /     if CONST_MAX < x35 {
 LL | |
@@ -139,7 +139,7 @@ LL |     let x4 = input.max(CONST_MIN).min(CONST_MAX);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:188:14
+  --> tests/ui/manual_clamp.rs:187:14
    |
 LL |     let x5 = input.min(CONST_MAX).max(CONST_MIN);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -147,12 +147,11 @@ LL |     let x5 = input.min(CONST_MAX).max(CONST_MIN);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:192:14
+  --> tests/ui/manual_clamp.rs:190:14
    |
 LL |       let x6 = match input {
    |  ______________^
 LL | |
-LL | |
 LL | |         x if x > CONST_MAX => CONST_MAX,
 LL | |         x if x < CONST_MIN => CONST_MIN,
 LL | |         x => x,
@@ -162,12 +161,11 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:200:14
+  --> tests/ui/manual_clamp.rs:197:14
    |
 LL |       let x7 = match input {
    |  ______________^
 LL | |
-LL | |
 LL | |         x if x < CONST_MIN => CONST_MIN,
 LL | |         x if x > CONST_MAX => CONST_MAX,
 LL | |         x => x,
@@ -177,12 +175,11 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:208:14
+  --> tests/ui/manual_clamp.rs:204:14
    |
 LL |       let x8 = match input {
    |  ______________^
 LL | |
-LL | |
 LL | |         x if CONST_MAX < x => CONST_MAX,
 LL | |         x if CONST_MIN > x => CONST_MIN,
 LL | |         x => x,
@@ -192,12 +189,11 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:226:15
+  --> tests/ui/manual_clamp.rs:221:15
    |
 LL |       let x10 = match input {
    |  _______________^
 LL | |
-LL | |
 LL | |         x if CONST_MIN > x => CONST_MIN,
 LL | |         x if CONST_MAX < x => CONST_MAX,
 LL | |         x => x,
@@ -207,7 +203,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:265:15
+  --> tests/ui/manual_clamp.rs:259:15
    |
 LL |       let x14 = if input > CONST_MAX {
    |  _______________^
@@ -222,7 +218,7 @@ LL | |     };
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:276:19
+  --> tests/ui/manual_clamp.rs:270:19
    |
 LL |           let x15 = if input > CONST_F64_MAX {
    |  ___________________^
@@ -238,7 +234,7 @@ LL | |         };
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:289:19
+  --> tests/ui/manual_clamp.rs:283:19
    |
 LL |         let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -246,7 +242,7 @@ LL |         let x16 = cmp_max(cmp_min(input, CONST_MAX), CONST_MIN);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:292:19
+  --> tests/ui/manual_clamp.rs:286:19
    |
 LL |         let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -254,7 +250,7 @@ LL |         let x17 = cmp_min(cmp_max(input, CONST_MIN), CONST_MAX);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:295:19
+  --> tests/ui/manual_clamp.rs:289:19
    |
 LL |         let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -262,7 +258,7 @@ LL |         let x18 = cmp_max(CONST_MIN, cmp_min(input, CONST_MAX));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:298:19
+  --> tests/ui/manual_clamp.rs:292:19
    |
 LL |         let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -270,7 +266,7 @@ LL |         let x19 = cmp_min(CONST_MAX, cmp_max(input, CONST_MIN));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:301:19
+  --> tests/ui/manual_clamp.rs:295:19
    |
 LL |         let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -278,7 +274,7 @@ LL |         let x20 = cmp_max(cmp_min(CONST_MAX, input), CONST_MIN);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:304:19
+  --> tests/ui/manual_clamp.rs:298:19
    |
 LL |         let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -286,7 +282,7 @@ LL |         let x21 = cmp_min(cmp_max(CONST_MIN, input), CONST_MAX);
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:307:19
+  --> tests/ui/manual_clamp.rs:301:19
    |
 LL |         let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -294,7 +290,7 @@ LL |         let x22 = cmp_max(CONST_MIN, cmp_min(CONST_MAX, input));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:310:19
+  --> tests/ui/manual_clamp.rs:304:19
    |
 LL |         let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_MIN, CONST_MAX)`
@@ -302,7 +298,7 @@ LL |         let x23 = cmp_min(CONST_MAX, cmp_max(CONST_MIN, input));
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:314:19
+  --> tests/ui/manual_clamp.rs:308:19
    |
 LL |         let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -311,7 +307,7 @@ LL |         let x24 = f64::max(f64::min(input, CONST_F64_MAX), CONST_F64_MIN);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:317:19
+  --> tests/ui/manual_clamp.rs:311:19
    |
 LL |         let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -320,7 +316,7 @@ LL |         let x25 = f64::min(f64::max(input, CONST_F64_MIN), CONST_F64_MAX);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:320:19
+  --> tests/ui/manual_clamp.rs:314:19
    |
 LL |         let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -329,7 +325,7 @@ LL |         let x26 = f64::max(CONST_F64_MIN, f64::min(input, CONST_F64_MAX));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:323:19
+  --> tests/ui/manual_clamp.rs:317:19
    |
 LL |         let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -338,7 +334,7 @@ LL |         let x27 = f64::min(CONST_F64_MAX, f64::max(input, CONST_F64_MIN));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:326:19
+  --> tests/ui/manual_clamp.rs:320:19
    |
 LL |         let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -347,7 +343,7 @@ LL |         let x28 = f64::max(f64::min(CONST_F64_MAX, input), CONST_F64_MIN);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:329:19
+  --> tests/ui/manual_clamp.rs:323:19
    |
 LL |         let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -356,7 +352,7 @@ LL |         let x29 = f64::min(f64::max(CONST_F64_MIN, input), CONST_F64_MAX);
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:332:19
+  --> tests/ui/manual_clamp.rs:326:19
    |
 LL |         let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -365,7 +361,7 @@ LL |         let x30 = f64::max(CONST_F64_MIN, f64::min(CONST_F64_MAX, input));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:335:19
+  --> tests/ui/manual_clamp.rs:329:19
    |
 LL |         let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with clamp: `input.clamp(CONST_F64_MIN, CONST_F64_MAX)`
@@ -374,7 +370,7 @@ LL |         let x31 = f64::min(CONST_F64_MAX, f64::max(CONST_F64_MIN, input));
    = note: clamp returns NaN if the input is NaN
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:340:5
+  --> tests/ui/manual_clamp.rs:333:5
    |
 LL | /     if x32 < CONST_MIN {
 LL | |
@@ -388,7 +384,7 @@ LL | |     }
    = note: clamp will panic if max < min
 
 error: clamp-like pattern without using clamp function
-  --> tests/ui/manual_clamp.rs:532:13
+  --> tests/ui/manual_clamp.rs:525:13
    |
 LL |       let _ = if input > CONST_MAX {
    |  _____________^
diff --git a/src/tools/clippy/tests/ui/manual_contains.fixed b/src/tools/clippy/tests/ui/manual_contains.fixed
new file mode 100644
index 000000000000..d26c948a7817
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_contains.fixed
@@ -0,0 +1,98 @@
+#![warn(clippy::manual_contains)]
+#![allow(clippy::eq_op, clippy::useless_vec)]
+
+fn should_lint() {
+    let vec: Vec<u8> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.contains(&4);
+    //~^ manual_contains
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.contains(&4);
+    //~^ manual_contains
+
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.contains(&10);
+    //~^ manual_contains
+
+    let num = 14;
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.contains(&num);
+    //~^ manual_contains
+
+    let num = 14;
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.contains(&num);
+    //~^ manual_contains
+
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.contains(&4);
+    //~^ manual_contains
+
+    let vec: Vec<u8> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.contains(&4);
+    //~^ manual_contains
+
+    let vec: Vec<u8> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let a = &4;
+    let _ = values.contains(a);
+    //~^ manual_contains
+
+    let vec = vec!["1", "2", "3", "4", "5", "6"];
+    let values = &vec[..];
+    let _ = values.contains(&"4");
+    //~^ manual_contains
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.contains(&(4 + 1));
+    //~^ manual_contains
+}
+
+fn should_not_lint() {
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.iter().any(|&v| v > 10);
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.iter().any(|&v| v % 2 == 0);
+    let _ = values.iter().any(|&v| v * 2 == 6);
+    let _ = values.iter().any(|&v| v == v);
+    let _ = values.iter().any(|&v| 4 == 4);
+    let _ = values.contains(&4);
+
+    let a = 1;
+    let b = 2;
+    let _ = values.iter().any(|&v| a == b);
+    let _ = values.iter().any(|&v| a == 4);
+
+    let vec: Vec<String> = vec!["1", "2", "3", "4", "5", "6"]
+        .iter()
+        .map(|&x| x.to_string())
+        .collect();
+    let values = &vec[..];
+    let _ = values.iter().any(|v| v == "4");
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let mut counter = 0;
+    let mut count = || {
+        counter += 1;
+        counter
+    };
+    let _ = values.iter().any(|&v| v == count());
+    let _ = values.iter().any(|&v| v == v * 2);
+}
+
+fn foo(values: &[u8]) -> bool {
+    values.contains(&10)
+    //~^ manual_contains
+}
+
+fn bar(values: [u8; 3]) -> bool {
+    values.contains(&10)
+    //~^ manual_contains
+}
diff --git a/src/tools/clippy/tests/ui/manual_contains.rs b/src/tools/clippy/tests/ui/manual_contains.rs
new file mode 100644
index 000000000000..fe67d2ee5d5c
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_contains.rs
@@ -0,0 +1,98 @@
+#![warn(clippy::manual_contains)]
+#![allow(clippy::eq_op, clippy::useless_vec)]
+
+fn should_lint() {
+    let vec: Vec<u8> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.iter().any(|&v| v == 4);
+    //~^ manual_contains
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.iter().any(|&v| v == 4);
+    //~^ manual_contains
+
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.iter().any(|&v| v == 10);
+    //~^ manual_contains
+
+    let num = 14;
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.iter().any(|&v| v == num);
+    //~^ manual_contains
+
+    let num = 14;
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.iter().any(|&v| num == v);
+    //~^ manual_contains
+
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.iter().any(|v| *v == 4);
+    //~^ manual_contains
+
+    let vec: Vec<u8> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.iter().any(|&v| 4 == v);
+    //~^ manual_contains
+
+    let vec: Vec<u8> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let a = &4;
+    let _ = values.iter().any(|v| *v == *a);
+    //~^ manual_contains
+
+    let vec = vec!["1", "2", "3", "4", "5", "6"];
+    let values = &vec[..];
+    let _ = values.iter().any(|&v| v == "4");
+    //~^ manual_contains
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.iter().any(|&v| v == 4 + 1);
+    //~^ manual_contains
+}
+
+fn should_not_lint() {
+    let values: [u8; 6] = [3, 14, 15, 92, 6, 5];
+    let _ = values.iter().any(|&v| v > 10);
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let _ = values.iter().any(|&v| v % 2 == 0);
+    let _ = values.iter().any(|&v| v * 2 == 6);
+    let _ = values.iter().any(|&v| v == v);
+    let _ = values.iter().any(|&v| 4 == 4);
+    let _ = values.contains(&4);
+
+    let a = 1;
+    let b = 2;
+    let _ = values.iter().any(|&v| a == b);
+    let _ = values.iter().any(|&v| a == 4);
+
+    let vec: Vec<String> = vec!["1", "2", "3", "4", "5", "6"]
+        .iter()
+        .map(|&x| x.to_string())
+        .collect();
+    let values = &vec[..];
+    let _ = values.iter().any(|v| v == "4");
+
+    let vec: Vec<u32> = vec![1, 2, 3, 4, 5, 6];
+    let values = &vec[..];
+    let mut counter = 0;
+    let mut count = || {
+        counter += 1;
+        counter
+    };
+    let _ = values.iter().any(|&v| v == count());
+    let _ = values.iter().any(|&v| v == v * 2);
+}
+
+fn foo(values: &[u8]) -> bool {
+    values.iter().any(|&v| v == 10)
+    //~^ manual_contains
+}
+
+fn bar(values: [u8; 3]) -> bool {
+    values.iter().any(|&v| v == 10)
+    //~^ manual_contains
+}
diff --git a/src/tools/clippy/tests/ui/manual_contains.stderr b/src/tools/clippy/tests/ui/manual_contains.stderr
new file mode 100644
index 000000000000..e6e2dea560c6
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_contains.stderr
@@ -0,0 +1,77 @@
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:7:13
+   |
+LL |     let _ = values.iter().any(|&v| v == 4);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&4)`
+   |
+   = note: `-D clippy::manual-contains` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_contains)]`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:12:13
+   |
+LL |     let _ = values.iter().any(|&v| v == 4);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&4)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:16:13
+   |
+LL |     let _ = values.iter().any(|&v| v == 10);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&10)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:21:13
+   |
+LL |     let _ = values.iter().any(|&v| v == num);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&num)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:26:13
+   |
+LL |     let _ = values.iter().any(|&v| num == v);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&num)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:30:13
+   |
+LL |     let _ = values.iter().any(|v| *v == 4);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&4)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:35:13
+   |
+LL |     let _ = values.iter().any(|&v| 4 == v);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&4)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:41:13
+   |
+LL |     let _ = values.iter().any(|v| *v == *a);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(a)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:46:13
+   |
+LL |     let _ = values.iter().any(|&v| v == "4");
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&"4")`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:51:13
+   |
+LL |     let _ = values.iter().any(|&v| v == 4 + 1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&(4 + 1))`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:91:5
+   |
+LL |     values.iter().any(|&v| v == 10)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&10)`
+
+error: using `contains()` instead of `iter().any()` is more efficient
+  --> tests/ui/manual_contains.rs:96:5
+   |
+LL |     values.iter().any(|&v| v == 10)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `values.contains(&10)`
+
+error: aborting due to 12 previous errors
+
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil.fixed b/src/tools/clippy/tests/ui/manual_div_ceil.fixed
index f6eb5a9784ac..57fe8917afe8 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil.fixed
+++ b/src/tools/clippy/tests/ui/manual_div_ceil.fixed
@@ -6,12 +6,17 @@ fn main() {
     let z = 11_u32;
 
     // Lint
-    let _ = x.div_ceil(y); //~ ERROR: manually reimplementing `div_ceil`
-    let _ = x.div_ceil(y); //~ ERROR: manually reimplementing `div_ceil`
-    let _ = x.div_ceil(y); //~ ERROR: manually reimplementing `div_ceil`
+    let _ = x.div_ceil(y);
+    //~^ manual_div_ceil
+    let _ = x.div_ceil(y);
+    //~^ manual_div_ceil
+    let _ = x.div_ceil(y);
+    //~^ manual_div_ceil
 
-    let _ = 7_u32.div_ceil(4); //~ ERROR: manually reimplementing `div_ceil`
-    let _ = (7_i32 as u32).div_ceil(4); //~ ERROR: manually reimplementing `div_ceil`
+    let _ = 7_u32.div_ceil(4);
+    //~^ manual_div_ceil
+    let _ = (7_i32 as u32).div_ceil(4);
+    //~^ manual_div_ceil
 
     // No lint
     let _ = (x + (y - 2)) / y;
@@ -32,29 +37,40 @@ fn main() {
 fn issue_13843() {
     let x = 3usize;
     let _ = 2048_usize.div_ceil(x);
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = 2048usize.div_ceil(x);
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = 2048_usize.div_ceil(x);
+    //~^ manual_div_ceil
 
     let x = 2048usize;
     let _ = x.div_ceil(4);
+    //~^ manual_div_ceil
 
     let _: u32 = 2048_u32.div_ceil(6);
+    //~^ manual_div_ceil
     let _: usize = 2048_usize.div_ceil(6);
+    //~^ manual_div_ceil
     let _: u32 = 0x2048_u32.div_ceil(0x6);
+    //~^ manual_div_ceil
 
     let _ = 2048_u32.div_ceil(6u32);
+    //~^ manual_div_ceil
 
     let _ = 1_000_000_u32.div_ceil(6u32);
+    //~^ manual_div_ceil
 }
 
 fn issue_13950() {
     let x = 33u32;
     let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
     let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
 
     let y = -33i32;
     let _ = (y + -8) / -7;
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil.rs b/src/tools/clippy/tests/ui/manual_div_ceil.rs
index 2f063afe787d..ec343513e5ce 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil.rs
+++ b/src/tools/clippy/tests/ui/manual_div_ceil.rs
@@ -6,12 +6,17 @@ fn main() {
     let z = 11_u32;
 
     // Lint
-    let _ = (x + (y - 1)) / y; //~ ERROR: manually reimplementing `div_ceil`
-    let _ = ((y - 1) + x) / y; //~ ERROR: manually reimplementing `div_ceil`
-    let _ = (x + y - 1) / y; //~ ERROR: manually reimplementing `div_ceil`
+    let _ = (x + (y - 1)) / y;
+    //~^ manual_div_ceil
+    let _ = ((y - 1) + x) / y;
+    //~^ manual_div_ceil
+    let _ = (x + y - 1) / y;
+    //~^ manual_div_ceil
 
-    let _ = (7_u32 + (4 - 1)) / 4; //~ ERROR: manually reimplementing `div_ceil`
-    let _ = (7_i32 as u32 + (4 - 1)) / 4; //~ ERROR: manually reimplementing `div_ceil`
+    let _ = (7_u32 + (4 - 1)) / 4;
+    //~^ manual_div_ceil
+    let _ = (7_i32 as u32 + (4 - 1)) / 4;
+    //~^ manual_div_ceil
 
     // No lint
     let _ = (x + (y - 2)) / y;
@@ -32,29 +37,40 @@ fn main() {
 fn issue_13843() {
     let x = 3usize;
     let _ = (2048 + x - 1) / x;
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = (2048usize + x - 1) / x;
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = (2048_usize + x - 1) / x;
+    //~^ manual_div_ceil
 
     let x = 2048usize;
     let _ = (x + 4 - 1) / 4;
+    //~^ manual_div_ceil
 
     let _: u32 = (2048 + 6 - 1) / 6;
+    //~^ manual_div_ceil
     let _: usize = (2048 + 6 - 1) / 6;
+    //~^ manual_div_ceil
     let _: u32 = (0x2048 + 0x6 - 1) / 0x6;
+    //~^ manual_div_ceil
 
     let _ = (2048 + 6u32 - 1) / 6u32;
+    //~^ manual_div_ceil
 
     let _ = (1_000_000 + 6u32 - 1) / 6u32;
+    //~^ manual_div_ceil
 }
 
 fn issue_13950() {
     let x = 33u32;
     let _ = (x + 7) / 8;
+    //~^ manual_div_ceil
     let _ = (7 + x) / 8;
+    //~^ manual_div_ceil
 
     let y = -33i32;
     let _ = (y + -8) / -7;
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil.stderr b/src/tools/clippy/tests/ui/manual_div_ceil.stderr
index 0bac5d8ef1c1..8e14ab274269 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil.stderr
+++ b/src/tools/clippy/tests/ui/manual_div_ceil.stderr
@@ -8,91 +8,91 @@ LL |     let _ = (x + (y - 1)) / y;
    = help: to override `-D warnings` add `#[allow(clippy::manual_div_ceil)]`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:10:13
+  --> tests/ui/manual_div_ceil.rs:11:13
    |
 LL |     let _ = ((y - 1) + x) / y;
    |             ^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(y)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:11:13
+  --> tests/ui/manual_div_ceil.rs:13:13
    |
 LL |     let _ = (x + y - 1) / y;
    |             ^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(y)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:13:13
+  --> tests/ui/manual_div_ceil.rs:16:13
    |
 LL |     let _ = (7_u32 + (4 - 1)) / 4;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `7_u32.div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:14:13
+  --> tests/ui/manual_div_ceil.rs:18:13
    |
 LL |     let _ = (7_i32 as u32 + (4 - 1)) / 4;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `(7_i32 as u32).div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:34:13
+  --> tests/ui/manual_div_ceil.rs:39:13
    |
 LL |     let _ = (2048 + x - 1) / x;
    |             ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_usize.div_ceil(x)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:37:13
+  --> tests/ui/manual_div_ceil.rs:43:13
    |
 LL |     let _ = (2048usize + x - 1) / x;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048usize.div_ceil(x)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:40:13
+  --> tests/ui/manual_div_ceil.rs:47:13
    |
 LL |     let _ = (2048_usize + x - 1) / x;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_usize.div_ceil(x)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:43:13
+  --> tests/ui/manual_div_ceil.rs:51:13
    |
 LL |     let _ = (x + 4 - 1) / 4;
    |             ^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:45:18
+  --> tests/ui/manual_div_ceil.rs:54:18
    |
 LL |     let _: u32 = (2048 + 6 - 1) / 6;
    |                  ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_u32.div_ceil(6)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:46:20
+  --> tests/ui/manual_div_ceil.rs:56:20
    |
 LL |     let _: usize = (2048 + 6 - 1) / 6;
    |                    ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_usize.div_ceil(6)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:47:18
+  --> tests/ui/manual_div_ceil.rs:58:18
    |
 LL |     let _: u32 = (0x2048 + 0x6 - 1) / 0x6;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `0x2048_u32.div_ceil(0x6)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:49:13
+  --> tests/ui/manual_div_ceil.rs:61:13
    |
 LL |     let _ = (2048 + 6u32 - 1) / 6u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_u32.div_ceil(6u32)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:51:13
+  --> tests/ui/manual_div_ceil.rs:64:13
    |
 LL |     let _ = (1_000_000 + 6u32 - 1) / 6u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `1_000_000_u32.div_ceil(6u32)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:56:13
+  --> tests/ui/manual_div_ceil.rs:70:13
    |
 LL |     let _ = (x + 7) / 8;
    |             ^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil.rs:57:13
+  --> tests/ui/manual_div_ceil.rs:72:13
    |
 LL |     let _ = (7 + x) / 8;
    |             ^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed
index 01c58151bc94..f55999c5ad08 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed
+++ b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.fixed
@@ -9,13 +9,20 @@ fn main() {
 
     // Lint.
     let _ = x.div_ceil(y);
+    //~^ manual_div_ceil
     let _ = x.div_ceil(y);
+    //~^ manual_div_ceil
     let _ = x.div_ceil(y);
+    //~^ manual_div_ceil
 
     let _ = 7_i32.div_ceil(4);
+    //~^ manual_div_ceil
     let _ = (7_i32 as u32).div_ceil(4);
+    //~^ manual_div_ceil
     let _ = (7_u32 as i32).div_ceil(4);
+    //~^ manual_div_ceil
     let _ = z_u.div_ceil(4);
+    //~^ manual_div_ceil
 
     // No lint.
     let _ = (x + (y - 2)) / y;
@@ -27,37 +34,53 @@ fn main() {
 fn issue_13843() {
     let x = 3usize;
     let _ = 2048_usize.div_ceil(x);
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = 2048usize.div_ceil(x);
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = 2048_usize.div_ceil(x);
+    //~^ manual_div_ceil
 
     let x = 2048usize;
     let _ = x.div_ceil(4);
+    //~^ manual_div_ceil
 
     let _ = 2048_i32.div_ceil(4);
+    //~^ manual_div_ceil
 
     let _: u32 = 2048_u32.div_ceil(6);
+    //~^ manual_div_ceil
     let _: usize = 2048_usize.div_ceil(6);
+    //~^ manual_div_ceil
     let _: u32 = 0x2048_u32.div_ceil(0x6);
+    //~^ manual_div_ceil
 
     let _ = 2048_u32.div_ceil(6u32);
+    //~^ manual_div_ceil
 
     let x = -2;
     let _ = (-2048_i32).div_ceil(x);
+    //~^ manual_div_ceil
 
     let _ = 1_000_000_u32.div_ceil(6u32);
+    //~^ manual_div_ceil
 }
 
 fn issue_13950() {
     let x = 33u32;
     let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
     let _ = x.div_ceil(8);
+    //~^ manual_div_ceil
 
     let y = -33i32;
     let _ = y.div_ceil(-7);
+    //~^ manual_div_ceil
     let _ = y.div_ceil(-7);
+    //~^ manual_div_ceil
     let _ = y.div_ceil(-7);
+    //~^ manual_div_ceil
 }
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs
index 048ff401581f..8a895f634cb4 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs
+++ b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.rs
@@ -9,13 +9,20 @@ fn main() {
 
     // Lint.
     let _ = (x + (y - 1)) / y;
+    //~^ manual_div_ceil
     let _ = ((y - 1) + x) / y;
+    //~^ manual_div_ceil
     let _ = (x + y - 1) / y;
+    //~^ manual_div_ceil
 
     let _ = (7_i32 + (4 - 1)) / 4;
+    //~^ manual_div_ceil
     let _ = (7_i32 as u32 + (4 - 1)) / 4;
+    //~^ manual_div_ceil
     let _ = (7_u32 as i32 + (4 - 1)) / 4;
+    //~^ manual_div_ceil
     let _ = (z_u + (4 - 1)) / 4;
+    //~^ manual_div_ceil
 
     // No lint.
     let _ = (x + (y - 2)) / y;
@@ -27,37 +34,53 @@ fn main() {
 fn issue_13843() {
     let x = 3usize;
     let _ = (2048 + x - 1) / x;
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = (2048usize + x - 1) / x;
+    //~^ manual_div_ceil
 
     let x = 5usize;
     let _ = (2048_usize + x - 1) / x;
+    //~^ manual_div_ceil
 
     let x = 2048usize;
     let _ = (x + 4 - 1) / 4;
+    //~^ manual_div_ceil
 
     let _ = (2048 + 4 - 1) / 4;
+    //~^ manual_div_ceil
 
     let _: u32 = (2048 + 6 - 1) / 6;
+    //~^ manual_div_ceil
     let _: usize = (2048 + 6 - 1) / 6;
+    //~^ manual_div_ceil
     let _: u32 = (0x2048 + 0x6 - 1) / 0x6;
+    //~^ manual_div_ceil
 
     let _ = (2048 + 6u32 - 1) / 6u32;
+    //~^ manual_div_ceil
 
     let x = -2;
     let _ = (-2048 + x - 1) / x;
+    //~^ manual_div_ceil
 
     let _ = (1_000_000 + 6u32 - 1) / 6u32;
+    //~^ manual_div_ceil
 }
 
 fn issue_13950() {
     let x = 33u32;
     let _ = (x + 7) / 8;
+    //~^ manual_div_ceil
     let _ = (7 + x) / 8;
+    //~^ manual_div_ceil
 
     let y = -33i32;
     let _ = (y + -8) / -7;
+    //~^ manual_div_ceil
     let _ = (-8 + y) / -7;
+    //~^ manual_div_ceil
     let _ = (y - 8) / -7;
+    //~^ manual_div_ceil
 }
diff --git a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr
index 807cfd82724e..e1160d962996 100644
--- a/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr
+++ b/src/tools/clippy/tests/ui/manual_div_ceil_with_feature.stderr
@@ -8,133 +8,133 @@ LL |     let _ = (x + (y - 1)) / y;
    = help: to override `-D warnings` add `#[allow(clippy::manual_div_ceil)]`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:12:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:13:13
    |
 LL |     let _ = ((y - 1) + x) / y;
    |             ^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(y)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:13:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:15:13
    |
 LL |     let _ = (x + y - 1) / y;
    |             ^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(y)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:15:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:18:13
    |
 LL |     let _ = (7_i32 + (4 - 1)) / 4;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `7_i32.div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:16:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:20:13
    |
 LL |     let _ = (7_i32 as u32 + (4 - 1)) / 4;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `(7_i32 as u32).div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:17:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:22:13
    |
 LL |     let _ = (7_u32 as i32 + (4 - 1)) / 4;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `(7_u32 as i32).div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:18:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:24:13
    |
 LL |     let _ = (z_u + (4 - 1)) / 4;
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `z_u.div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:29:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:36:13
    |
 LL |     let _ = (2048 + x - 1) / x;
    |             ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_usize.div_ceil(x)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:32:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:40:13
    |
 LL |     let _ = (2048usize + x - 1) / x;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048usize.div_ceil(x)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:35:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:44:13
    |
 LL |     let _ = (2048_usize + x - 1) / x;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_usize.div_ceil(x)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:38:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:48:13
    |
 LL |     let _ = (x + 4 - 1) / 4;
    |             ^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:40:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:51:13
    |
 LL |     let _ = (2048 + 4 - 1) / 4;
    |             ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_i32.div_ceil(4)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:42:18
+  --> tests/ui/manual_div_ceil_with_feature.rs:54:18
    |
 LL |     let _: u32 = (2048 + 6 - 1) / 6;
    |                  ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_u32.div_ceil(6)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:43:20
+  --> tests/ui/manual_div_ceil_with_feature.rs:56:20
    |
 LL |     let _: usize = (2048 + 6 - 1) / 6;
    |                    ^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_usize.div_ceil(6)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:44:18
+  --> tests/ui/manual_div_ceil_with_feature.rs:58:18
    |
 LL |     let _: u32 = (0x2048 + 0x6 - 1) / 0x6;
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `0x2048_u32.div_ceil(0x6)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:46:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:61:13
    |
 LL |     let _ = (2048 + 6u32 - 1) / 6u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `2048_u32.div_ceil(6u32)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:49:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:65:13
    |
 LL |     let _ = (-2048 + x - 1) / x;
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `(-2048_i32).div_ceil(x)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:51:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:68:13
    |
 LL |     let _ = (1_000_000 + 6u32 - 1) / 6u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `1_000_000_u32.div_ceil(6u32)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:56:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:74:13
    |
 LL |     let _ = (x + 7) / 8;
    |             ^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:57:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:76:13
    |
 LL |     let _ = (7 + x) / 8;
    |             ^^^^^^^^^^^ help: consider using `.div_ceil()`: `x.div_ceil(8)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:60:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:80:13
    |
 LL |     let _ = (y + -8) / -7;
    |             ^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `y.div_ceil(-7)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:61:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:82:13
    |
 LL |     let _ = (-8 + y) / -7;
    |             ^^^^^^^^^^^^^ help: consider using `.div_ceil()`: `y.div_ceil(-7)`
 
 error: manually reimplementing `div_ceil`
-  --> tests/ui/manual_div_ceil_with_feature.rs:62:13
+  --> tests/ui/manual_div_ceil_with_feature.rs:84:13
    |
 LL |     let _ = (y - 8) / -7;
    |             ^^^^^^^^^^^^ help: consider using `.div_ceil()`: `y.div_ceil(-7)`
diff --git a/src/tools/clippy/tests/ui/manual_filter.rs b/src/tools/clippy/tests/ui/manual_filter.rs
index 0ac6cbefc4ec..a9d0c35f8bb7 100644
--- a/src/tools/clippy/tests/ui/manual_filter.rs
+++ b/src/tools/clippy/tests/ui/manual_filter.rs
@@ -3,6 +3,7 @@
 
 fn main() {
     match Some(0) {
+        //~^ manual_filter
         None => None,
         Some(x) => {
             if x > 0 {
@@ -14,6 +15,7 @@ fn main() {
     };
 
     match Some(1) {
+        //~^ manual_filter
         Some(x) => {
             if x > 0 {
                 None
@@ -25,6 +27,7 @@ fn main() {
     };
 
     match Some(2) {
+        //~^ manual_filter
         Some(x) => {
             if x > 0 {
                 None
@@ -36,6 +39,7 @@ fn main() {
     };
 
     match Some(3) {
+        //~^ manual_filter
         Some(x) => {
             if x > 0 {
                 Some(x)
@@ -48,6 +52,7 @@ fn main() {
 
     let y = Some(4);
     match y {
+        //~^ manual_filter
         // Some(4)
         None => None,
         Some(x) => {
@@ -60,6 +65,7 @@ fn main() {
     };
 
     match Some(5) {
+        //~^ manual_filter
         Some(x) => {
             if x > 0 {
                 Some(x)
@@ -71,6 +77,7 @@ fn main() {
     };
 
     match Some(6) {
+        //~^ manual_filter
         Some(ref x) => {
             if x > &0 {
                 Some(x)
@@ -83,6 +90,7 @@ fn main() {
 
     let external_cond = true;
     match Some(String::new()) {
+        //~^ manual_filter
         Some(x) => {
             if external_cond {
                 Some(x)
@@ -94,12 +102,14 @@ fn main() {
     };
 
     if let Some(x) = Some(7) {
+        //~^ manual_filter
         if external_cond { Some(x) } else { None }
     } else {
         None
     };
 
     match &Some(8) {
+        //~^ manual_filter
         &Some(x) => {
             if x != 0 {
                 Some(x)
@@ -111,6 +121,7 @@ fn main() {
     };
 
     match Some(9) {
+        //~^ manual_filter
         Some(x) => {
             if x > 10 && x < 100 {
                 Some(x)
@@ -137,6 +148,7 @@ fn main() {
 
     #[allow(clippy::blocks_in_conditions)]
     match Some(11) {
+        //~^ manual_filter
         // Lint, statement is preserved by `.filter`
         Some(x) => {
             if {
@@ -181,6 +193,7 @@ fn main() {
         true
     }
     let _ = match Some(14) {
+        //~^ manual_filter
         Some(x) => {
             if unsafe { f(x) } {
                 Some(x)
@@ -191,6 +204,7 @@ fn main() {
         None => None,
     };
     let _ = match Some(15) {
+        //~^ manual_filter
         Some(x) => unsafe { if f(x) { Some(x) } else { None } },
         None => None,
     };
@@ -199,6 +213,7 @@ fn main() {
     if let Some(_) = Some(16) {
         Some(16)
     } else if let Some(x) = Some(16) {
+        //~^ manual_filter
         // Lint starting from here
         if x % 2 == 0 { Some(x) } else { None }
     } else {
diff --git a/src/tools/clippy/tests/ui/manual_filter.stderr b/src/tools/clippy/tests/ui/manual_filter.stderr
index 3add706d7f73..63463997f435 100644
--- a/src/tools/clippy/tests/ui/manual_filter.stderr
+++ b/src/tools/clippy/tests/ui/manual_filter.stderr
@@ -2,9 +2,9 @@ error: manual implementation of `Option::filter`
   --> tests/ui/manual_filter.rs:5:5
    |
 LL | /     match Some(0) {
+LL | |
 LL | |         None => None,
 LL | |         Some(x) => {
-LL | |             if x > 0 {
 ...  |
 LL | |         },
 LL | |     };
@@ -14,93 +14,94 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::manual_filter)]`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:16:5
+  --> tests/ui/manual_filter.rs:17:5
    |
 LL | /     match Some(1) {
+LL | |
 LL | |         Some(x) => {
 LL | |             if x > 0 {
-LL | |                 None
 ...  |
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(1).filter(|&x| x <= 0)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:27:5
+  --> tests/ui/manual_filter.rs:29:5
    |
 LL | /     match Some(2) {
+LL | |
 LL | |         Some(x) => {
 LL | |             if x > 0 {
-LL | |                 None
 ...  |
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(2).filter(|&x| x <= 0)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:38:5
+  --> tests/ui/manual_filter.rs:41:5
    |
 LL | /     match Some(3) {
+LL | |
 LL | |         Some(x) => {
 LL | |             if x > 0 {
-LL | |                 Some(x)
 ...  |
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(3).filter(|&x| x > 0)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:50:5
+  --> tests/ui/manual_filter.rs:54:5
    |
 LL | /     match y {
+LL | |
 LL | |         // Some(4)
 LL | |         None => None,
-LL | |         Some(x) => {
 ...  |
 LL | |         },
 LL | |     };
    | |_____^ help: try: `y.filter(|&x| x <= 0)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:62:5
+  --> tests/ui/manual_filter.rs:67:5
    |
 LL | /     match Some(5) {
+LL | |
 LL | |         Some(x) => {
 LL | |             if x > 0 {
-LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(5).filter(|&x| x > 0)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:73:5
+  --> tests/ui/manual_filter.rs:79:5
    |
 LL | /     match Some(6) {
+LL | |
 LL | |         Some(ref x) => {
 LL | |             if x > &0 {
-LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(6).as_ref().filter(|&x| x > &0)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:85:5
+  --> tests/ui/manual_filter.rs:92:5
    |
 LL | /     match Some(String::new()) {
+LL | |
 LL | |         Some(x) => {
 LL | |             if external_cond {
-LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(String::new()).filter(|x| external_cond)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:96:5
+  --> tests/ui/manual_filter.rs:104:5
    |
 LL | /     if let Some(x) = Some(7) {
+LL | |
 LL | |         if external_cond { Some(x) } else { None }
 LL | |     } else {
 LL | |         None
@@ -108,36 +109,36 @@ LL | |     };
    | |_____^ help: try: `Some(7).filter(|&x| external_cond)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:102:5
+  --> tests/ui/manual_filter.rs:111:5
    |
 LL | /     match &Some(8) {
+LL | |
 LL | |         &Some(x) => {
 LL | |             if x != 0 {
-LL | |                 Some(x)
 ...  |
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(8).filter(|&x| x != 0)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:113:5
+  --> tests/ui/manual_filter.rs:123:5
    |
 LL | /     match Some(9) {
+LL | |
 LL | |         Some(x) => {
 LL | |             if x > 10 && x < 100 {
-LL | |                 Some(x)
 ...  |
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(9).filter(|&x| x > 10 && x < 100)`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:139:5
+  --> tests/ui/manual_filter.rs:150:5
    |
 LL | /     match Some(11) {
+LL | |
 LL | |         // Lint, statement is preserved by `.filter`
 LL | |         Some(x) => {
-LL | |             if {
 ...  |
 LL | |         None => None,
 LL | |     };
@@ -152,33 +153,35 @@ LL ~             });
    |
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:183:13
+  --> tests/ui/manual_filter.rs:195:13
    |
 LL |       let _ = match Some(14) {
    |  _____________^
+LL | |
 LL | |         Some(x) => {
 LL | |             if unsafe { f(x) } {
-LL | |                 Some(x)
 ...  |
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(14).filter(|&x| unsafe { f(x) })`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:193:13
+  --> tests/ui/manual_filter.rs:206:13
    |
 LL |       let _ = match Some(15) {
    |  _____________^
+LL | |
 LL | |         Some(x) => unsafe { if f(x) { Some(x) } else { None } },
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(15).filter(|&x| unsafe { f(x) })`
 
 error: manual implementation of `Option::filter`
-  --> tests/ui/manual_filter.rs:201:12
+  --> tests/ui/manual_filter.rs:215:12
    |
 LL |       } else if let Some(x) = Some(16) {
    |  ____________^
+LL | |
 LL | |         // Lint starting from here
 LL | |         if x % 2 == 0 { Some(x) } else { None }
 LL | |     } else {
diff --git a/src/tools/clippy/tests/ui/manual_filter_map.fixed b/src/tools/clippy/tests/ui/manual_filter_map.fixed
index a44c46c145c6..caf82289031f 100644
--- a/src/tools/clippy/tests/ui/manual_filter_map.fixed
+++ b/src/tools/clippy/tests/ui/manual_filter_map.fixed
@@ -7,12 +7,15 @@
 fn main() {
     // is_some(), unwrap()
     let _ = (0..).filter_map(|a| to_opt(a));
+    //~^ manual_filter_map
 
     // ref pattern, expect()
     let _ = (0..).filter_map(|a| to_opt(a));
+    //~^ manual_filter_map
 
     // is_ok(), unwrap_or()
     let _ = (0..).filter_map(|a| to_res(a).ok());
+    //~^ manual_filter_map
 
     let _ = (1..5)
         .filter_map(|y| *to_ref(to_opt(y)));
@@ -28,17 +31,28 @@ fn main() {
 #[rustfmt::skip]
 fn simple_equal() {
     iter::<Option<&u8>>().find_map(|x| x.cloned());
+    //~^ manual_find_map
     iter::<&Option<&u8>>().find_map(|x| x.cloned());
+    //~^ manual_find_map
     iter::<&Option<String>>().find_map(|x| x.as_deref());
+    //~^ manual_find_map
     iter::<Option<&String>>().find_map(|y| to_ref(y).cloned());
+    //~^ manual_find_map
 
     iter::<Result<u8, ()>>().find_map(|x| x.ok());
+    //~^ manual_find_map
     iter::<&Result<u8, ()>>().find_map(|x| x.ok());
+    //~^ manual_find_map
     iter::<&&Result<u8, ()>>().find_map(|x| x.ok());
+    //~^ manual_find_map
     iter::<Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    //~^ manual_find_map
     iter::<&Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    //~^ manual_find_map
     iter::<&Result<String, ()>>().find_map(|x| x.as_deref().ok());
+    //~^ manual_find_map
     iter::<Result<&String, ()>>().find_map(|y| to_ref(y).cloned().ok());
+    //~^ manual_find_map
 }
 
 fn no_lint() {
diff --git a/src/tools/clippy/tests/ui/manual_filter_map.rs b/src/tools/clippy/tests/ui/manual_filter_map.rs
index e72d0c4305b3..013c88da6b36 100644
--- a/src/tools/clippy/tests/ui/manual_filter_map.rs
+++ b/src/tools/clippy/tests/ui/manual_filter_map.rs
@@ -7,42 +7,60 @@
 fn main() {
     // is_some(), unwrap()
     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+    //~^ manual_filter_map
 
     // ref pattern, expect()
     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+    //~^ manual_filter_map
 
     // is_ok(), unwrap_or()
     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+    //~^ manual_filter_map
 
     let _ = (1..5)
         .filter(|&x| to_ref(to_opt(x)).is_some())
+        //~^ manual_filter_map
         .map(|y| to_ref(to_opt(y)).unwrap());
     let _ = (1..5)
         .filter(|x| to_ref(to_opt(*x)).is_some())
+        //~^ manual_filter_map
         .map(|y| to_ref(to_opt(y)).unwrap());
 
     let _ = (1..5)
         .filter(|&x| to_ref(to_res(x)).is_ok())
+        //~^ manual_filter_map
         .map(|y| to_ref(to_res(y)).unwrap());
     let _ = (1..5)
         .filter(|x| to_ref(to_res(*x)).is_ok())
+        //~^ manual_filter_map
         .map(|y| to_ref(to_res(y)).unwrap());
 }
 
 #[rustfmt::skip]
 fn simple_equal() {
     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
+    //~^ manual_find_map
     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+    //~^ manual_find_map
 
     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
+    //~^ manual_find_map
     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
+    //~^ manual_find_map
 }
 
 fn no_lint() {
@@ -91,46 +109,55 @@ fn issue_8920() {
     let _ = vec
         .iter()
         .filter(|f| f.option_field.is_some())
+        //~^ manual_filter_map
         .map(|f| f.option_field.clone().unwrap());
 
     let _ = vec
         .iter()
         .filter(|f| f.ref_field.is_some())
+        //~^ manual_filter_map
         .map(|f| f.ref_field.cloned().unwrap());
 
     let _ = vec
         .iter()
         .filter(|f| f.ref_field.is_some())
+        //~^ manual_filter_map
         .map(|f| f.ref_field.copied().unwrap());
 
     let _ = vec
         .iter()
         .filter(|f| f.result_field.is_ok())
+        //~^ manual_filter_map
         .map(|f| f.result_field.clone().unwrap());
 
     let _ = vec
         .iter()
         .filter(|f| f.result_field.is_ok())
+        //~^ manual_filter_map
         .map(|f| f.result_field.as_ref().unwrap());
 
     let _ = vec
         .iter()
         .filter(|f| f.result_field.is_ok())
+        //~^ manual_filter_map
         .map(|f| f.result_field.as_deref().unwrap());
 
     let _ = vec
         .iter_mut()
         .filter(|f| f.result_field.is_ok())
+        //~^ manual_filter_map
         .map(|f| f.result_field.as_mut().unwrap());
 
     let _ = vec
         .iter_mut()
         .filter(|f| f.result_field.is_ok())
+        //~^ manual_filter_map
         .map(|f| f.result_field.as_deref_mut().unwrap());
 
     let _ = vec
         .iter()
         .filter(|f| f.result_field.is_ok())
+        //~^ manual_filter_map
         .map(|f| f.result_field.to_owned().unwrap());
 }
 
@@ -144,6 +171,7 @@ fn issue8010() {
     let iter = [Enum::A(123), Enum::B].into_iter();
 
     let _x = iter.clone().filter(|x| matches!(x, Enum::A(_))).map(|x| match x {
+        //~^ manual_filter_map
         Enum::A(s) => s,
         _ => unreachable!(),
     });
@@ -154,6 +182,7 @@ fn issue8010() {
     let _x = iter
         .clone()
         .filter(|x| matches!(x, Enum::A(_)))
+        //~^ manual_filter_map
         .map(|x| if let Enum::A(s) = x { s } else { unreachable!() });
     #[allow(clippy::unused_unit)]
     let _x = iter
diff --git a/src/tools/clippy/tests/ui/manual_filter_map.stderr b/src/tools/clippy/tests/ui/manual_filter_map.stderr
index 2e5056727831..07c894bf0e66 100644
--- a/src/tools/clippy/tests/ui/manual_filter_map.stderr
+++ b/src/tools/clippy/tests/ui/manual_filter_map.stderr
@@ -13,87 +13,91 @@ LL |     let _ = (0..).filter(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap
    = help: to override `-D warnings` add `#[allow(clippy::manual_filter_map)]`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:12:19
+  --> tests/ui/manual_filter_map.rs:13:19
    |
 LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_opt(a))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:12:31
+  --> tests/ui/manual_filter_map.rs:13:31
    |
 LL |     let _ = (0..).filter(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                               ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:15:19
+  --> tests/ui/manual_filter_map.rs:17:19
    |
 LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `filter_map(|a| to_res(a).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:15:31
+  --> tests/ui/manual_filter_map.rs:17:31
    |
 LL |     let _ = (0..).filter(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                               ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:18:10
+  --> tests/ui/manual_filter_map.rs:21:10
    |
 LL |           .filter(|&x| to_ref(to_opt(x)).is_some())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:18:22
+  --> tests/ui/manual_filter_map.rs:21:22
    |
 LL |         .filter(|&x| to_ref(to_opt(x)).is_some())
    |                      ^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:21:10
+  --> tests/ui/manual_filter_map.rs:25:10
    |
 LL |           .filter(|x| to_ref(to_opt(*x)).is_some())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:21:21
+  --> tests/ui/manual_filter_map.rs:25:21
    |
 LL |         .filter(|x| to_ref(to_opt(*x)).is_some())
    |                     ^^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:25:10
+  --> tests/ui/manual_filter_map.rs:30:10
    |
 LL |           .filter(|&x| to_ref(to_res(x)).is_ok())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:25:22
+  --> tests/ui/manual_filter_map.rs:30:22
    |
 LL |         .filter(|&x| to_ref(to_res(x)).is_ok())
    |                      ^^^^^^^^^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:28:10
+  --> tests/ui/manual_filter_map.rs:34:10
    |
 LL |           .filter(|x| to_ref(to_res(*x)).is_ok())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `filter_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:28:21
+  --> tests/ui/manual_filter_map.rs:34:21
    |
 LL |         .filter(|x| to_ref(to_res(*x)).is_ok())
    |                     ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:34:27
+  --> tests/ui/manual_filter_map.rs:41:27
    |
 LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
@@ -102,164 +106,175 @@ LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap()
    = help: to override `-D warnings` add `#[allow(clippy::manual_find_map)]`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:35:28
+  --> tests/ui/manual_filter_map.rs:43:28
    |
 LL |     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:36:31
+  --> tests/ui/manual_filter_map.rs:45:31
    |
 LL |     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:37:31
+  --> tests/ui/manual_filter_map.rs:47:31
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:37:41
+  --> tests/ui/manual_filter_map.rs:47:41
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                                         ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:39:30
+  --> tests/ui/manual_filter_map.rs:50:30
    |
 LL |     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:40:31
+  --> tests/ui/manual_filter_map.rs:52:31
    |
 LL |     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:41:32
+  --> tests/ui/manual_filter_map.rs:54:32
    |
 LL |     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:42:31
+  --> tests/ui/manual_filter_map.rs:56:31
    |
 LL |     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:43:32
+  --> tests/ui/manual_filter_map.rs:58:32
    |
 LL |     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:44:35
+  --> tests/ui/manual_filter_map.rs:60:35
    |
 LL |     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_filter_map.rs:45:35
+  --> tests/ui/manual_filter_map.rs:62:35
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_filter_map.rs:45:45
+  --> tests/ui/manual_filter_map.rs:62:45
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                             ^^^^^^^^^
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:93:10
+  --> tests/ui/manual_filter_map.rs:111:10
    |
 LL |           .filter(|f| f.option_field.is_some())
    |  __________^
+LL | |
 LL | |         .map(|f| f.option_field.clone().unwrap());
    | |_________________________________________________^ help: try: `filter_map(|f| f.option_field.clone())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:98:10
+  --> tests/ui/manual_filter_map.rs:117:10
    |
 LL |           .filter(|f| f.ref_field.is_some())
    |  __________^
+LL | |
 LL | |         .map(|f| f.ref_field.cloned().unwrap());
    | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.cloned())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:103:10
+  --> tests/ui/manual_filter_map.rs:123:10
    |
 LL |           .filter(|f| f.ref_field.is_some())
    |  __________^
+LL | |
 LL | |         .map(|f| f.ref_field.copied().unwrap());
    | |_______________________________________________^ help: try: `filter_map(|f| f.ref_field.copied())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:108:10
+  --> tests/ui/manual_filter_map.rs:129:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.clone().unwrap());
    | |_________________________________________________^ help: try: `filter_map(|f| f.result_field.clone().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:113:10
+  --> tests/ui/manual_filter_map.rs:135:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_ref().unwrap());
    | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_ref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:118:10
+  --> tests/ui/manual_filter_map.rs:141:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_deref().unwrap());
    | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:123:10
+  --> tests/ui/manual_filter_map.rs:147:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_mut().unwrap());
    | |__________________________________________________^ help: try: `filter_map(|f| f.result_field.as_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:128:10
+  --> tests/ui/manual_filter_map.rs:153:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
    | |________________________________________________________^ help: try: `filter_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:133:10
+  --> tests/ui/manual_filter_map.rs:159:10
    |
 LL |           .filter(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.to_owned().unwrap());
    | |____________________________________________________^ help: try: `filter_map(|f| f.result_field.to_owned().ok())`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:146:27
+  --> tests/ui/manual_filter_map.rs:173:27
    |
 LL |       let _x = iter.clone().filter(|x| matches!(x, Enum::A(_))).map(|x| match x {
    |  ___________________________^
+LL | |
 LL | |         Enum::A(s) => s,
 LL | |         _ => unreachable!(),
 LL | |     });
    | |______^ help: try: `filter_map(|x| match x { Enum::A(s) => Some(s), _ => None })`
 
 error: `filter(..).map(..)` can be simplified as `filter_map(..)`
-  --> tests/ui/manual_filter_map.rs:156:10
+  --> tests/ui/manual_filter_map.rs:184:10
    |
 LL |           .filter(|x| matches!(x, Enum::A(_)))
    |  __________^
+LL | |
 LL | |         .map(|x| if let Enum::A(s) = x { s } else { unreachable!() });
    | |_____________________________________________________________________^ help: try: `filter_map(|x| match x { Enum::A(s) => Some(s), _ => None })`
 
diff --git a/src/tools/clippy/tests/ui/manual_find.rs b/src/tools/clippy/tests/ui/manual_find.rs
index 0a105b0359e5..20b557f21d14 100644
--- a/src/tools/clippy/tests/ui/manual_find.rs
+++ b/src/tools/clippy/tests/ui/manual_find.rs
@@ -3,8 +3,8 @@
 //@no-rustfix
 fn vec_string(strings: Vec<String>) -> Option<String> {
     for s in strings {
-        //~^ ERROR: manual implementation of `Iterator::find`
-        //~| NOTE: you may need to dereference some variables
+        //~^ manual_find
+
         if s == String::new() {
             return Some(s);
         }
@@ -14,8 +14,8 @@ fn vec_string(strings: Vec<String>) -> Option<String> {
 
 fn tuple(arr: Vec<(String, i32)>) -> Option<String> {
     for (s, _) in arr {
-        //~^ ERROR: manual implementation of `Iterator::find`
-        //~| NOTE: you may need to dereference some variables
+        //~^ manual_find
+
         if s == String::new() {
             return Some(s);
         }
diff --git a/src/tools/clippy/tests/ui/manual_find_fixable.rs b/src/tools/clippy/tests/ui/manual_find_fixable.rs
index 56c3f2629c7a..08a7dd2c6eee 100644
--- a/src/tools/clippy/tests/ui/manual_find_fixable.rs
+++ b/src/tools/clippy/tests/ui/manual_find_fixable.rs
@@ -8,6 +8,7 @@ const ARRAY: &[u32; 5] = &[2, 7, 1, 9, 3];
 
 fn lookup(n: u32) -> Option<u32> {
     for &v in ARRAY {
+        //~^ manual_find
         if v == n {
             return Some(v);
         }
@@ -17,6 +18,7 @@ fn lookup(n: u32) -> Option<u32> {
 
 fn with_pat(arr: Vec<(u32, u32)>) -> Option<u32> {
     for (a, _) in arr {
+        //~^ manual_find
         if a % 2 == 0 {
             return Some(a);
         }
@@ -30,6 +32,7 @@ struct Data {
 }
 fn with_struct(arr: Vec<Data>) -> Option<Data> {
     for el in arr {
+        //~^ manual_find
         if el.name.len() == 10 {
             return Some(el);
         }
@@ -40,6 +43,7 @@ fn with_struct(arr: Vec<Data>) -> Option<Data> {
 struct Tuple(usize, usize);
 fn with_tuple_struct(arr: Vec<Tuple>) -> Option<usize> {
     for Tuple(a, _) in arr {
+        //~^ manual_find
         if a >= 3 {
             return Some(a);
         }
@@ -55,6 +59,7 @@ impl A {
 }
 fn with_method_call(arr: Vec<A>) -> Option<A> {
     for el in arr {
+        //~^ manual_find
         if el.should_keep() {
             return Some(el);
         }
@@ -65,6 +70,7 @@ fn with_method_call(arr: Vec<A>) -> Option<A> {
 fn with_closure(arr: Vec<u32>) -> Option<u32> {
     let f = |el: u32| -> u32 { el + 10 };
     for el in arr {
+        //~^ manual_find
         if f(el) == 20 {
             return Some(el);
         }
@@ -75,6 +81,7 @@ fn with_closure(arr: Vec<u32>) -> Option<u32> {
 fn with_closure2(arr: HashMap<String, i32>) -> Option<i32> {
     let f = |el: i32| -> bool { el == 10 };
     for &el in arr.values() {
+        //~^ manual_find
         if f(el) {
             return Some(el);
         }
@@ -84,6 +91,7 @@ fn with_closure2(arr: HashMap<String, i32>) -> Option<i32> {
 
 fn with_bool(arr: Vec<Data>) -> Option<Data> {
     for el in arr {
+        //~^ manual_find
         if el.is_true {
             return Some(el);
         }
@@ -114,6 +122,7 @@ fn with_else(arr: Vec<u32>) -> Option<u32> {
 
 fn tuple_with_ref(v: [(u8, &u8); 3]) -> Option<u8> {
     for (_, &x) in v {
+        //~^ manual_find
         if x > 10 {
             return Some(x);
         }
@@ -123,6 +132,7 @@ fn tuple_with_ref(v: [(u8, &u8); 3]) -> Option<u8> {
 
 fn ref_to_tuple_with_ref(v: &[(u8, &u8)]) -> Option<u8> {
     for &(_, &x) in v {
+        //~^ manual_find
         if x > 10 {
             return Some(x);
         }
@@ -132,6 +142,7 @@ fn ref_to_tuple_with_ref(v: &[(u8, &u8)]) -> Option<u8> {
 
 fn explicit_ret(arr: Vec<i32>) -> Option<i32> {
     for x in arr {
+        //~^ manual_find
         if x >= 5 {
             return Some(x);
         }
@@ -187,6 +198,7 @@ fn as_closure() {
     #[rustfmt::skip]
     let f = |arr: Vec<i32>| -> Option<i32> {
         for x in arr {
+        //~^ manual_find
             if x < 1 {
                 return Some(x);
             }
diff --git a/src/tools/clippy/tests/ui/manual_find_fixable.stderr b/src/tools/clippy/tests/ui/manual_find_fixable.stderr
index 5ed8be1b3eed..afa453c5a876 100644
--- a/src/tools/clippy/tests/ui/manual_find_fixable.stderr
+++ b/src/tools/clippy/tests/ui/manual_find_fixable.stderr
@@ -2,6 +2,7 @@ error: manual implementation of `Iterator::find`
   --> tests/ui/manual_find_fixable.rs:10:5
    |
 LL | /     for &v in ARRAY {
+LL | |
 LL | |         if v == n {
 LL | |             return Some(v);
 ...  |
@@ -12,9 +13,10 @@ LL | |     None
    = help: to override `-D warnings` add `#[allow(clippy::manual_find)]`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:19:5
+  --> tests/ui/manual_find_fixable.rs:20:5
    |
 LL | /     for (a, _) in arr {
+LL | |
 LL | |         if a % 2 == 0 {
 LL | |             return Some(a);
 ...  |
@@ -22,9 +24,10 @@ LL | |     None
    | |________^ help: replace with an iterator: `arr.into_iter().map(|(a, _)| a).find(|&a| a % 2 == 0)`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:32:5
+  --> tests/ui/manual_find_fixable.rs:34:5
    |
 LL | /     for el in arr {
+LL | |
 LL | |         if el.name.len() == 10 {
 LL | |             return Some(el);
 ...  |
@@ -34,9 +37,10 @@ LL | |     None
    = note: you may need to dereference some variables
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:42:5
+  --> tests/ui/manual_find_fixable.rs:45:5
    |
 LL | /     for Tuple(a, _) in arr {
+LL | |
 LL | |         if a >= 3 {
 LL | |             return Some(a);
 ...  |
@@ -44,9 +48,10 @@ LL | |     None
    | |________^ help: replace with an iterator: `arr.into_iter().map(|Tuple(a, _)| a).find(|&a| a >= 3)`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:57:5
+  --> tests/ui/manual_find_fixable.rs:61:5
    |
 LL | /     for el in arr {
+LL | |
 LL | |         if el.should_keep() {
 LL | |             return Some(el);
 ...  |
@@ -56,9 +61,10 @@ LL | |     None
    = note: you may need to dereference some variables
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:67:5
+  --> tests/ui/manual_find_fixable.rs:72:5
    |
 LL | /     for el in arr {
+LL | |
 LL | |         if f(el) == 20 {
 LL | |             return Some(el);
 ...  |
@@ -66,9 +72,10 @@ LL | |     None
    | |________^ help: replace with an iterator: `arr.into_iter().find(|&el| f(el) == 20)`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:77:5
+  --> tests/ui/manual_find_fixable.rs:83:5
    |
 LL | /     for &el in arr.values() {
+LL | |
 LL | |         if f(el) {
 LL | |             return Some(el);
 ...  |
@@ -76,9 +83,10 @@ LL | |     None
    | |________^ help: replace with an iterator: `arr.values().find(|&&el| f(el)).copied()`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:86:5
+  --> tests/ui/manual_find_fixable.rs:93:5
    |
 LL | /     for el in arr {
+LL | |
 LL | |         if el.is_true {
 LL | |             return Some(el);
 ...  |
@@ -88,9 +96,10 @@ LL | |     None
    = note: you may need to dereference some variables
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:116:5
+  --> tests/ui/manual_find_fixable.rs:124:5
    |
 LL | /     for (_, &x) in v {
+LL | |
 LL | |         if x > 10 {
 LL | |             return Some(x);
 ...  |
@@ -98,9 +107,10 @@ LL | |     None
    | |________^ help: replace with an iterator: `v.into_iter().map(|(_, &x)| x).find(|&x| x > 10)`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:125:5
+  --> tests/ui/manual_find_fixable.rs:134:5
    |
 LL | /     for &(_, &x) in v {
+LL | |
 LL | |         if x > 10 {
 LL | |             return Some(x);
 ...  |
@@ -108,9 +118,10 @@ LL | |     None
    | |________^ help: replace with an iterator: `v.iter().map(|&(_, &x)| x).find(|&x| x > 10)`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:134:5
+  --> tests/ui/manual_find_fixable.rs:144:5
    |
 LL | /     for x in arr {
+LL | |
 LL | |         if x >= 5 {
 LL | |             return Some(x);
 ...  |
@@ -118,9 +129,10 @@ LL | |     return None;
    | |________________^ help: replace with an iterator: `arr.into_iter().find(|&x| x >= 5)`
 
 error: manual implementation of `Iterator::find`
-  --> tests/ui/manual_find_fixable.rs:189:9
+  --> tests/ui/manual_find_fixable.rs:200:9
    |
 LL | /         for x in arr {
+LL | |
 LL | |             if x < 1 {
 LL | |                 return Some(x);
 ...  |
diff --git a/src/tools/clippy/tests/ui/manual_find_map.fixed b/src/tools/clippy/tests/ui/manual_find_map.fixed
index 2d9a356b9bcd..1a452d50261f 100644
--- a/src/tools/clippy/tests/ui/manual_find_map.fixed
+++ b/src/tools/clippy/tests/ui/manual_find_map.fixed
@@ -7,12 +7,15 @@
 fn main() {
     // is_some(), unwrap()
     let _ = (0..).find_map(|a| to_opt(a));
+    //~^ manual_find_map
 
     // ref pattern, expect()
     let _ = (0..).find_map(|a| to_opt(a));
+    //~^ manual_find_map
 
     // is_ok(), unwrap_or()
     let _ = (0..).find_map(|a| to_res(a).ok());
+    //~^ manual_find_map
 
     let _ = (1..5)
         .find_map(|y| *to_ref(to_opt(y)));
@@ -28,20 +31,34 @@ fn main() {
 #[rustfmt::skip]
 fn simple_equal() {
     iter::<Option<u8>>().find_map(|x| x);
+    //~^ manual_find_map
     iter::<&Option<u8>>().find_map(|x| *x);
+    //~^ manual_find_map
     iter::<&&Option<u8>>().find_map(|x| **x);
+    //~^ manual_find_map
     iter::<Option<&u8>>().find_map(|x| x.cloned());
+    //~^ manual_find_map
     iter::<&Option<&u8>>().find_map(|x| x.cloned());
+    //~^ manual_find_map
     iter::<&Option<String>>().find_map(|x| x.as_deref());
+    //~^ manual_find_map
     iter::<Option<&String>>().find_map(|y| to_ref(y).cloned());
+    //~^ manual_find_map
 
     iter::<Result<u8, ()>>().find_map(|x| x.ok());
+    //~^ manual_find_map
     iter::<&Result<u8, ()>>().find_map(|x| x.ok());
+    //~^ manual_find_map
     iter::<&&Result<u8, ()>>().find_map(|x| x.ok());
+    //~^ manual_find_map
     iter::<Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    //~^ manual_find_map
     iter::<&Result<&u8, ()>>().find_map(|x| x.cloned().ok());
+    //~^ manual_find_map
     iter::<&Result<String, ()>>().find_map(|x| x.as_deref().ok());
+    //~^ manual_find_map
     iter::<Result<&String, ()>>().find_map(|y| to_ref(y).cloned().ok());
+    //~^ manual_find_map
 }
 
 fn no_lint() {
diff --git a/src/tools/clippy/tests/ui/manual_find_map.rs b/src/tools/clippy/tests/ui/manual_find_map.rs
index 7c5cc136695a..9415a2d2b572 100644
--- a/src/tools/clippy/tests/ui/manual_find_map.rs
+++ b/src/tools/clippy/tests/ui/manual_find_map.rs
@@ -7,45 +7,66 @@
 fn main() {
     // is_some(), unwrap()
     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap());
+    //~^ manual_find_map
 
     // ref pattern, expect()
     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
+    //~^ manual_find_map
 
     // is_ok(), unwrap_or()
     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
+    //~^ manual_find_map
 
     let _ = (1..5)
         .find(|&x| to_ref(to_opt(x)).is_some())
+        //~^ manual_find_map
         .map(|y| to_ref(to_opt(y)).unwrap());
     let _ = (1..5)
         .find(|x| to_ref(to_opt(*x)).is_some())
+        //~^ manual_find_map
         .map(|y| to_ref(to_opt(y)).unwrap());
 
     let _ = (1..5)
         .find(|&x| to_ref(to_res(x)).is_ok())
+        //~^ manual_find_map
         .map(|y| to_ref(to_res(y)).unwrap());
     let _ = (1..5)
         .find(|x| to_ref(to_res(*x)).is_ok())
+        //~^ manual_find_map
         .map(|y| to_ref(to_res(y)).unwrap());
 }
 
 #[rustfmt::skip]
 fn simple_equal() {
     iter::<Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<&&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
+    //~^ manual_find_map
     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
+    //~^ manual_find_map
 
     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
+    //~^ manual_find_map
     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
+    //~^ manual_find_map
     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
+    //~^ manual_find_map
     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
+    //~^ manual_find_map
 }
 
 fn no_lint() {
@@ -94,45 +115,54 @@ fn issue_8920() {
     let _ = vec
         .iter()
         .find(|f| f.option_field.is_some())
+        //~^ manual_find_map
         .map(|f| f.option_field.clone().unwrap());
 
     let _ = vec
         .iter()
         .find(|f| f.ref_field.is_some())
+        //~^ manual_find_map
         .map(|f| f.ref_field.cloned().unwrap());
 
     let _ = vec
         .iter()
         .find(|f| f.ref_field.is_some())
+        //~^ manual_find_map
         .map(|f| f.ref_field.copied().unwrap());
 
     let _ = vec
         .iter()
         .find(|f| f.result_field.is_ok())
+        //~^ manual_find_map
         .map(|f| f.result_field.clone().unwrap());
 
     let _ = vec
         .iter()
         .find(|f| f.result_field.is_ok())
+        //~^ manual_find_map
         .map(|f| f.result_field.as_ref().unwrap());
 
     let _ = vec
         .iter()
         .find(|f| f.result_field.is_ok())
+        //~^ manual_find_map
         .map(|f| f.result_field.as_deref().unwrap());
 
     let _ = vec
         .iter_mut()
         .find(|f| f.result_field.is_ok())
+        //~^ manual_find_map
         .map(|f| f.result_field.as_mut().unwrap());
 
     let _ = vec
         .iter_mut()
         .find(|f| f.result_field.is_ok())
+        //~^ manual_find_map
         .map(|f| f.result_field.as_deref_mut().unwrap());
 
     let _ = vec
         .iter()
         .find(|f| f.result_field.is_ok())
+        //~^ manual_find_map
         .map(|f| f.result_field.to_owned().unwrap());
 }
diff --git a/src/tools/clippy/tests/ui/manual_find_map.stderr b/src/tools/clippy/tests/ui/manual_find_map.stderr
index 2722d59f52a9..8fa6c090e6d2 100644
--- a/src/tools/clippy/tests/ui/manual_find_map.stderr
+++ b/src/tools/clippy/tests/ui/manual_find_map.stderr
@@ -13,250 +13,263 @@ LL |     let _ = (0..).find(|n| to_opt(*n).is_some()).map(|a| to_opt(a).unwrap()
    = help: to override `-D warnings` add `#[allow(clippy::manual_find_map)]`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:12:19
+  --> tests/ui/manual_find_map.rs:13:19
    |
 LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_opt(a))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:12:29
+  --> tests/ui/manual_find_map.rs:13:29
    |
 LL |     let _ = (0..).find(|&n| to_opt(n).is_some()).map(|a| to_opt(a).expect("hi"));
    |                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:15:19
+  --> tests/ui/manual_find_map.rs:17:19
    |
 LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|a| to_res(a).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:15:29
+  --> tests/ui/manual_find_map.rs:17:29
    |
 LL |     let _ = (0..).find(|&n| to_res(n).is_ok()).map(|a| to_res(a).unwrap_or(1));
    |                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:18:10
+  --> tests/ui/manual_find_map.rs:21:10
    |
 LL |           .find(|&x| to_ref(to_opt(x)).is_some())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:18:20
+  --> tests/ui/manual_find_map.rs:21:20
    |
 LL |         .find(|&x| to_ref(to_opt(x)).is_some())
    |                    ^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:21:10
+  --> tests/ui/manual_find_map.rs:25:10
    |
 LL |           .find(|x| to_ref(to_opt(*x)).is_some())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_opt(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| *to_ref(to_opt(y)))`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:21:19
+  --> tests/ui/manual_find_map.rs:25:19
    |
 LL |         .find(|x| to_ref(to_opt(*x)).is_some())
    |                   ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:25:10
+  --> tests/ui/manual_find_map.rs:30:10
    |
 LL |           .find(|&x| to_ref(to_res(x)).is_ok())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:25:20
+  --> tests/ui/manual_find_map.rs:30:20
    |
 LL |         .find(|&x| to_ref(to_res(x)).is_ok())
    |                    ^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:28:10
+  --> tests/ui/manual_find_map.rs:34:10
    |
 LL |           .find(|x| to_ref(to_res(*x)).is_ok())
    |  __________^
+LL | |
 LL | |         .map(|y| to_ref(to_res(y)).unwrap());
    | |____________________________________________^ help: try: `find_map(|y| to_ref(to_res(y)).ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:28:19
+  --> tests/ui/manual_find_map.rs:34:19
    |
 LL |         .find(|x| to_ref(to_res(*x)).is_ok())
    |                   ^^^^^^^^^^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:34:26
+  --> tests/ui/manual_find_map.rs:41:26
    |
 LL |     iter::<Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x)`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:35:27
+  --> tests/ui/manual_find_map.rs:43:27
    |
 LL |     iter::<&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| *x)`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:36:28
+  --> tests/ui/manual_find_map.rs:45:28
    |
 LL |     iter::<&&Option<u8>>().find(|x| x.is_some()).map(|x| x.unwrap());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| **x)`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:37:27
+  --> tests/ui/manual_find_map.rs:47:27
    |
 LL |     iter::<Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:38:28
+  --> tests/ui/manual_find_map.rs:49:28
    |
 LL |     iter::<&Option<&u8>>().find(|x| x.is_some()).map(|x| x.cloned().unwrap());
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:39:31
+  --> tests/ui/manual_find_map.rs:51:31
    |
 LL |     iter::<&Option<String>>().find(|x| x.is_some()).map(|x| x.as_deref().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:40:31
+  --> tests/ui/manual_find_map.rs:53:31
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:40:41
+  --> tests/ui/manual_find_map.rs:53:41
    |
 LL |     iter::<Option<&String>>().find(|&x| to_ref(x).is_some()).map(|y| to_ref(y).cloned().unwrap());
    |                                         ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:42:30
+  --> tests/ui/manual_find_map.rs:56:30
    |
 LL |     iter::<Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:43:31
+  --> tests/ui/manual_find_map.rs:58:31
    |
 LL |     iter::<&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:44:32
+  --> tests/ui/manual_find_map.rs:60:32
    |
 LL |     iter::<&&Result<u8, ()>>().find(|x| x.is_ok()).map(|x| x.unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:45:31
+  --> tests/ui/manual_find_map.rs:62:31
    |
 LL |     iter::<Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:46:32
+  --> tests/ui/manual_find_map.rs:64:32
    |
 LL |     iter::<&Result<&u8, ()>>().find(|x| x.is_ok()).map(|x| x.cloned().unwrap());
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.cloned().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:47:35
+  --> tests/ui/manual_find_map.rs:66:35
    |
 LL |     iter::<&Result<String, ()>>().find(|x| x.is_ok()).map(|x| x.as_deref().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|x| x.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:48:35
+  --> tests/ui/manual_find_map.rs:68:35
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `find_map(|y| to_ref(y).cloned().ok())`
    |
 note: the suggestion might change the behavior of the program when merging `filter` and `map`, because this expression potentially contains side effects and will only execute once
-  --> tests/ui/manual_find_map.rs:48:45
+  --> tests/ui/manual_find_map.rs:68:45
    |
 LL |     iter::<Result<&String, ()>>().find(|&x| to_ref(x).is_ok()).map(|y| to_ref(y).cloned().unwrap());
    |                                             ^^^^^^^^^
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:96:10
+  --> tests/ui/manual_find_map.rs:117:10
    |
 LL |           .find(|f| f.option_field.is_some())
    |  __________^
+LL | |
 LL | |         .map(|f| f.option_field.clone().unwrap());
    | |_________________________________________________^ help: try: `find_map(|f| f.option_field.clone())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:101:10
+  --> tests/ui/manual_find_map.rs:123:10
    |
 LL |           .find(|f| f.ref_field.is_some())
    |  __________^
+LL | |
 LL | |         .map(|f| f.ref_field.cloned().unwrap());
    | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.cloned())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:106:10
+  --> tests/ui/manual_find_map.rs:129:10
    |
 LL |           .find(|f| f.ref_field.is_some())
    |  __________^
+LL | |
 LL | |         .map(|f| f.ref_field.copied().unwrap());
    | |_______________________________________________^ help: try: `find_map(|f| f.ref_field.copied())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:111:10
+  --> tests/ui/manual_find_map.rs:135:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.clone().unwrap());
    | |_________________________________________________^ help: try: `find_map(|f| f.result_field.clone().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:116:10
+  --> tests/ui/manual_find_map.rs:141:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_ref().unwrap());
    | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_ref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:121:10
+  --> tests/ui/manual_find_map.rs:147:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_deref().unwrap());
    | |____________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:126:10
+  --> tests/ui/manual_find_map.rs:153:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_mut().unwrap());
    | |__________________________________________________^ help: try: `find_map(|f| f.result_field.as_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:131:10
+  --> tests/ui/manual_find_map.rs:159:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.as_deref_mut().unwrap());
    | |________________________________________________________^ help: try: `find_map(|f| f.result_field.as_deref_mut().ok())`
 
 error: `find(..).map(..)` can be simplified as `find_map(..)`
-  --> tests/ui/manual_find_map.rs:136:10
+  --> tests/ui/manual_find_map.rs:165:10
    |
 LL |           .find(|f| f.result_field.is_ok())
    |  __________^
+LL | |
 LL | |         .map(|f| f.result_field.to_owned().unwrap());
    | |____________________________________________________^ help: try: `find_map(|f| f.result_field.to_owned().ok())`
 
diff --git a/src/tools/clippy/tests/ui/manual_flatten.rs b/src/tools/clippy/tests/ui/manual_flatten.rs
index d57333ace040..97f35c36e24c 100644
--- a/src/tools/clippy/tests/ui/manual_flatten.rs
+++ b/src/tools/clippy/tests/ui/manual_flatten.rs
@@ -5,7 +5,8 @@ fn main() {
     // Test for loop over implicitly adjusted `Iterator` with `if let` expression
     let x = vec![Some(1), Some(2), Some(3)];
     for n in x {
-        //~^ ERROR: unnecessary `if let` since only the `Some` variant of the iterator element
+        //~^ manual_flatten
+
         if let Some(y) = n {
             println!("{}", y);
         }
@@ -14,7 +15,8 @@ fn main() {
     // Test for loop over implicitly adjusted `Iterator` with `if let` statement
     let y: Vec<Result<i32, i32>> = vec![];
     for n in y.clone() {
-        //~^ ERROR: unnecessary `if let` since only the `Ok` variant of the iterator element i
+        //~^ manual_flatten
+
         if let Ok(n) = n {
             println!("{}", n);
         };
@@ -22,7 +24,8 @@ fn main() {
 
     // Test for loop over by reference
     for n in &y {
-        //~^ ERROR: unnecessary `if let` since only the `Ok` variant of the iterator element i
+        //~^ manual_flatten
+
         if let Ok(n) = n {
             println!("{}", n);
         }
@@ -31,7 +34,8 @@ fn main() {
     // Test for loop over an implicit reference
     let z = &y;
     for n in z {
-        //~^ ERROR: unnecessary `if let` since only the `Ok` variant of the iterator element i
+        //~^ manual_flatten
+
         if let Ok(n) = n {
             println!("{}", n);
         }
@@ -41,7 +45,8 @@ fn main() {
     let z = vec![Some(1), Some(2), Some(3)];
     let z = z.iter();
     for n in z {
-        //~^ ERROR: unnecessary `if let` since only the `Some` variant of the iterator element
+        //~^ manual_flatten
+
         if let Some(m) = n {
             println!("{}", m);
         }
@@ -75,7 +80,8 @@ fn main() {
 
     let vec_of_ref = vec![&Some(1)];
     for n in &vec_of_ref {
-        //~^ ERROR: unnecessary `if let` since only the `Some` variant of the iterator element
+        //~^ manual_flatten
+
         if let Some(n) = n {
             println!("{:?}", n);
         }
@@ -83,7 +89,8 @@ fn main() {
 
     let vec_of_ref = &vec_of_ref;
     for n in vec_of_ref {
-        //~^ ERROR: unnecessary `if let` since only the `Some` variant of the iterator element
+        //~^ manual_flatten
+
         if let Some(n) = n {
             println!("{:?}", n);
         }
@@ -91,7 +98,8 @@ fn main() {
 
     let slice_of_ref = &[&Some(1)];
     for n in slice_of_ref {
-        //~^ ERROR: unnecessary `if let` since only the `Some` variant of the iterator element
+        //~^ manual_flatten
+
         if let Some(n) = n {
             println!("{:?}", n);
         }
@@ -122,7 +130,8 @@ fn main() {
 fn run_unformatted_tests() {
     // Skip rustfmt here on purpose so the suggestion does not fit in one line
     for n in vec![
-    //~^ ERROR: unnecessary `if let` since only the `Some` variant of the iterator element
+    //~^ manual_flatten
+
         Some(1),
         Some(2),
         Some(3)
diff --git a/src/tools/clippy/tests/ui/manual_flatten.stderr b/src/tools/clippy/tests/ui/manual_flatten.stderr
index 93f7f11b5e64..5ab25658017e 100644
--- a/src/tools/clippy/tests/ui/manual_flatten.stderr
+++ b/src/tools/clippy/tests/ui/manual_flatten.stderr
@@ -6,14 +6,14 @@ LL |       for n in x {
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Some(y) = n {
-LL | |             println!("{}", y);
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:9:9
+  --> tests/ui/manual_flatten.rs:10:9
    |
 LL | /         if let Some(y) = n {
 LL | |             println!("{}", y);
@@ -23,13 +23,14 @@ LL | |         }
    = help: to override `-D warnings` add `#[allow(clippy::manual_flatten)]`
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:16:5
+  --> tests/ui/manual_flatten.rs:17:5
    |
 LL |       for n in y.clone() {
    |       ^        --------- help: try: `y.clone().into_iter().flatten()`
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Ok(n) = n {
 LL | |             println!("{}", n);
 LL | |         };
@@ -37,7 +38,7 @@ LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:18:9
+  --> tests/ui/manual_flatten.rs:20:9
    |
 LL | /         if let Ok(n) = n {
 LL | |             println!("{}", n);
@@ -45,21 +46,21 @@ LL | |         };
    | |_________^
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:24:5
+  --> tests/ui/manual_flatten.rs:26:5
    |
 LL |       for n in &y {
    |       ^        -- help: try: `y.iter().flatten()`
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Ok(n) = n {
-LL | |             println!("{}", n);
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:26:9
+  --> tests/ui/manual_flatten.rs:29:9
    |
 LL | /         if let Ok(n) = n {
 LL | |             println!("{}", n);
@@ -67,21 +68,21 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Ok` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:33:5
+  --> tests/ui/manual_flatten.rs:36:5
    |
 LL |       for n in z {
    |       ^        - help: try: `z.iter().flatten()`
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Ok(n) = n {
-LL | |             println!("{}", n);
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:35:9
+  --> tests/ui/manual_flatten.rs:39:9
    |
 LL | /         if let Ok(n) = n {
 LL | |             println!("{}", n);
@@ -89,21 +90,21 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:43:5
+  --> tests/ui/manual_flatten.rs:47:5
    |
 LL |       for n in z {
    |       ^        - help: try: `z.flatten()`
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Some(m) = n {
-LL | |             println!("{}", m);
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:45:9
+  --> tests/ui/manual_flatten.rs:50:9
    |
 LL | /         if let Some(m) = n {
 LL | |             println!("{}", m);
@@ -111,21 +112,21 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:77:5
+  --> tests/ui/manual_flatten.rs:82:5
    |
 LL |       for n in &vec_of_ref {
    |       ^        ----------- help: try: `vec_of_ref.iter().copied().flatten()`
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Some(n) = n {
-LL | |             println!("{:?}", n);
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:79:9
+  --> tests/ui/manual_flatten.rs:85:9
    |
 LL | /         if let Some(n) = n {
 LL | |             println!("{:?}", n);
@@ -133,21 +134,21 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:85:5
+  --> tests/ui/manual_flatten.rs:91:5
    |
 LL |       for n in vec_of_ref {
    |       ^        ---------- help: try: `vec_of_ref.iter().copied().flatten()`
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Some(n) = n {
-LL | |             println!("{:?}", n);
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:87:9
+  --> tests/ui/manual_flatten.rs:94:9
    |
 LL | /         if let Some(n) = n {
 LL | |             println!("{:?}", n);
@@ -155,21 +156,21 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:93:5
+  --> tests/ui/manual_flatten.rs:100:5
    |
 LL |       for n in slice_of_ref {
    |       ^        ------------ help: try: `slice_of_ref.iter().copied().flatten()`
    |  _____|
    | |
 LL | |
+LL | |
 LL | |         if let Some(n) = n {
-LL | |             println!("{:?}", n);
-LL | |         }
+...  |
 LL | |     }
    | |_____^
    |
 help: ...and remove the `if let` statement in the for loop
-  --> tests/ui/manual_flatten.rs:95:9
+  --> tests/ui/manual_flatten.rs:103:9
    |
 LL | /         if let Some(n) = n {
 LL | |             println!("{:?}", n);
@@ -177,18 +178,18 @@ LL | |         }
    | |_________^
 
 error: unnecessary `if let` since only the `Some` variant of the iterator element is used
-  --> tests/ui/manual_flatten.rs:124:5
+  --> tests/ui/manual_flatten.rs:132:5
    |
 LL | /     for n in vec![
 LL | |
+LL | |
 LL | |         Some(1),
-LL | |         Some(2),
 ...  |
 LL | |     }
    | |_____^
    |
 help: remove the `if let` statement in the for loop and then...
-  --> tests/ui/manual_flatten.rs:130:9
+  --> tests/ui/manual_flatten.rs:139:9
    |
 LL | /         if let Some(n) = n {
 LL | |             println!("{:?}", n);
diff --git a/src/tools/clippy/tests/ui/manual_float_methods.rs b/src/tools/clippy/tests/ui/manual_float_methods.rs
index 66545d180ef9..62cdc1c141d0 100644
--- a/src/tools/clippy/tests/ui/manual_float_methods.rs
+++ b/src/tools/clippy/tests/ui/manual_float_methods.rs
@@ -22,12 +22,18 @@ fn fn_test_not_inf() -> f64 {
 fn main() {
     let x = 1.0f32;
     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
+    //~^ manual_is_infinite
     if x != f32::INFINITY && x != f32::NEG_INFINITY {}
+    //~^ manual_is_finite
     if x == INFINITE || x == NEG_INFINITE {}
+    //~^ manual_is_infinite
     if x != INFINITE && x != NEG_INFINITE {}
+    //~^ manual_is_finite
     let x = 1.0f64;
     if x == f64::INFINITY || x == f64::NEG_INFINITY {}
+    //~^ manual_is_infinite
     if x != f64::INFINITY && x != f64::NEG_INFINITY {}
+    //~^ manual_is_finite
     // Don't lint
     if x.is_infinite() {}
     if x.is_finite() {}
@@ -42,6 +48,7 @@ fn main() {
     const {
         let x = 1.0f64;
         if x == f64::INFINITY || x == f64::NEG_INFINITY {}
+        //~^ manual_is_infinite
     }
     const X: f64 = 1.0f64;
     if const { X == f64::INFINITY || X == f64::NEG_INFINITY } {}
diff --git a/src/tools/clippy/tests/ui/manual_float_methods.stderr b/src/tools/clippy/tests/ui/manual_float_methods.stderr
index 1352c5e73cab..352c879c87d7 100644
--- a/src/tools/clippy/tests/ui/manual_float_methods.stderr
+++ b/src/tools/clippy/tests/ui/manual_float_methods.stderr
@@ -8,7 +8,7 @@ LL |     if x == f32::INFINITY || x == f32::NEG_INFINITY {}
    = help: to override `-D warnings` add `#[allow(clippy::manual_is_infinite)]`
 
 error: manually checking if a float is finite
-  --> tests/ui/manual_float_methods.rs:25:8
+  --> tests/ui/manual_float_methods.rs:26:8
    |
 LL |     if x != f32::INFINITY && x != f32::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -32,13 +32,13 @@ LL +     if !x.is_infinite() {}
    |
 
 error: manually checking if a float is infinite
-  --> tests/ui/manual_float_methods.rs:26:8
+  --> tests/ui/manual_float_methods.rs:28:8
    |
 LL |     if x == INFINITE || x == NEG_INFINITE {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
 error: manually checking if a float is finite
-  --> tests/ui/manual_float_methods.rs:27:8
+  --> tests/ui/manual_float_methods.rs:30:8
    |
 LL |     if x != INFINITE && x != NEG_INFINITE {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,13 +60,13 @@ LL +     if !x.is_infinite() {}
    |
 
 error: manually checking if a float is infinite
-  --> tests/ui/manual_float_methods.rs:29:8
+  --> tests/ui/manual_float_methods.rs:33:8
    |
 LL |     if x == f64::INFINITY || x == f64::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
 
 error: manually checking if a float is finite
-  --> tests/ui/manual_float_methods.rs:30:8
+  --> tests/ui/manual_float_methods.rs:35:8
    |
 LL |     if x != f64::INFINITY && x != f64::NEG_INFINITY {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL +     if !x.is_infinite() {}
    |
 
 error: manually checking if a float is infinite
-  --> tests/ui/manual_float_methods.rs:44:12
+  --> tests/ui/manual_float_methods.rs:50:12
    |
 LL |         if x == f64::INFINITY || x == f64::NEG_INFINITY {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the dedicated method instead: `x.is_infinite()`
diff --git a/src/tools/clippy/tests/ui/manual_hash_one.fixed b/src/tools/clippy/tests/ui/manual_hash_one.fixed
index edfd9c4a47bb..e45e4bbc3ce7 100644
--- a/src/tools/clippy/tests/ui/manual_hash_one.fixed
+++ b/src/tools/clippy/tests/ui/manual_hash_one.fixed
@@ -7,18 +7,21 @@ fn returned(b: impl BuildHasher) -> u64 {
     
     
     b.hash_one(&true)
+    //~^ manual_hash_one
 }
 
 fn unsized_receiver(b: impl BuildHasher, s: &str) {
     
     
     let _ = b.hash_one(&s[4..10]);
+    //~^ manual_hash_one
 }
 
 fn owned_value(b: impl BuildHasher, v: Vec<u32>) -> Vec<u32> {
     
     
     let _ = b.hash_one(&v);
+    //~^ manual_hash_one
     v
 }
 
@@ -86,4 +89,5 @@ fn msrv_1_71(b: impl BuildHasher, v: impl Hash) {
     
     
     let _ = b.hash_one(&v);
+    //~^ manual_hash_one
 }
diff --git a/src/tools/clippy/tests/ui/manual_hash_one.rs b/src/tools/clippy/tests/ui/manual_hash_one.rs
index ee61522853f0..c93e26c8f6bf 100644
--- a/src/tools/clippy/tests/ui/manual_hash_one.rs
+++ b/src/tools/clippy/tests/ui/manual_hash_one.rs
@@ -7,18 +7,21 @@ fn returned(b: impl BuildHasher) -> u64 {
     let mut hasher = b.build_hasher();
     true.hash(&mut hasher);
     hasher.finish()
+    //~^ manual_hash_one
 }
 
 fn unsized_receiver(b: impl BuildHasher, s: &str) {
     let mut hasher = b.build_hasher();
     s[4..10].hash(&mut hasher);
     let _ = hasher.finish();
+    //~^ manual_hash_one
 }
 
 fn owned_value(b: impl BuildHasher, v: Vec<u32>) -> Vec<u32> {
     let mut hasher = b.build_hasher();
     v.hash(&mut hasher);
     let _ = hasher.finish();
+    //~^ manual_hash_one
     v
 }
 
@@ -86,4 +89,5 @@ fn msrv_1_71(b: impl BuildHasher, v: impl Hash) {
     let mut hasher = b.build_hasher();
     v.hash(&mut hasher);
     let _ = hasher.finish();
+    //~^ manual_hash_one
 }
diff --git a/src/tools/clippy/tests/ui/manual_hash_one.stderr b/src/tools/clippy/tests/ui/manual_hash_one.stderr
index bcff36d9bafc..b0691e2d396c 100644
--- a/src/tools/clippy/tests/ui/manual_hash_one.stderr
+++ b/src/tools/clippy/tests/ui/manual_hash_one.stderr
@@ -14,7 +14,7 @@ LL ~     b.hash_one(&true)
    |
 
 error: manual implementation of `BuildHasher::hash_one`
-  --> tests/ui/manual_hash_one.rs:15:13
+  --> tests/ui/manual_hash_one.rs:16:13
    |
 LL |     let _ = hasher.finish();
    |             ^^^^^^^^^^^^^^^
@@ -27,7 +27,7 @@ LL ~     let _ = b.hash_one(&s[4..10]);
    |
 
 error: manual implementation of `BuildHasher::hash_one`
-  --> tests/ui/manual_hash_one.rs:21:13
+  --> tests/ui/manual_hash_one.rs:23:13
    |
 LL |     let _ = hasher.finish();
    |             ^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL ~     let _ = b.hash_one(&v);
    |
 
 error: manual implementation of `BuildHasher::hash_one`
-  --> tests/ui/manual_hash_one.rs:88:13
+  --> tests/ui/manual_hash_one.rs:91:13
    |
 LL |     let _ = hasher.finish();
    |             ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed
index 53a124f59c8d..c1c929585cfd 100644
--- a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed
+++ b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.fixed
@@ -7,24 +7,34 @@ fn main() {}
 
 fn variants(a: &str, b: &str) {
     if a.eq_ignore_ascii_case(b) {
+        //~^ manual_ignore_case_cmp
         return;
     }
     if a.eq_ignore_ascii_case(b) {
+        //~^ manual_ignore_case_cmp
         return;
     }
     let r = a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     let r = r || a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     r && a.eq_ignore_ascii_case(&b.to_uppercase());
+    //~^ manual_ignore_case_cmp
     // !=
     if !a.eq_ignore_ascii_case(b) {
+        //~^ manual_ignore_case_cmp
         return;
     }
     if !a.eq_ignore_ascii_case(b) {
+        //~^ manual_ignore_case_cmp
         return;
     }
     let r = !a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     let r = r || !a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     r && !a.eq_ignore_ascii_case(&b.to_uppercase());
+    //~^ manual_ignore_case_cmp
 }
 
 fn unsupported(a: char, b: char) {
@@ -36,72 +46,111 @@ fn unsupported(a: char, b: char) {
 
 fn char(a: char, b: char) {
     a.eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == *&b.to_ascii_lowercase();
     *&a.to_ascii_lowercase() == b.to_ascii_lowercase();
     a.eq_ignore_ascii_case(&'a');
+    //~^ manual_ignore_case_cmp
     'a'.eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
 }
 fn u8(a: u8, b: u8) {
     a.eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
     a.eq_ignore_ascii_case(&b'a');
+    //~^ manual_ignore_case_cmp
     b'a'.eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
 }
 fn ref_str(a: &str, b: &str) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     a.to_uppercase().eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     a.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
 }
 fn ref_ref_str(a: &&str, b: &&str) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     a.to_uppercase().eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     a.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
 }
 fn string(a: String, b: String) {
     a.eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
     a.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
     &a.to_ascii_lowercase() == &b.to_ascii_lowercase();
     &&a.to_ascii_lowercase() == &&b.to_ascii_lowercase();
     a.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
 }
 fn ref_string(a: String, b: &String) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     a.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
 
     b.eq_ignore_ascii_case(&a);
+    //~^ manual_ignore_case_cmp
     b.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(&a);
+    //~^ manual_ignore_case_cmp
 }
 fn string_ref_str(a: String, b: &str) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     a.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
 
     b.eq_ignore_ascii_case(&a);
+    //~^ manual_ignore_case_cmp
     b.eq_ignore_ascii_case("a");
+    //~^ manual_ignore_case_cmp
     "a".eq_ignore_ascii_case(&a);
+    //~^ manual_ignore_case_cmp
 }
 fn ref_u8slice(a: &[u8], b: &[u8]) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
 }
 fn u8vec(a: Vec<u8>, b: Vec<u8>) {
     a.eq_ignore_ascii_case(&b);
+    //~^ manual_ignore_case_cmp
 }
 fn ref_u8vec(a: Vec<u8>, b: &Vec<u8>) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     b.eq_ignore_ascii_case(&a);
+    //~^ manual_ignore_case_cmp
 }
 fn ref_osstr(a: &OsStr, b: &OsStr) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
 }
 fn osstring(a: OsString, b: OsString) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
 }
 fn ref_osstring(a: OsString, b: &OsString) {
     a.eq_ignore_ascii_case(b);
+    //~^ manual_ignore_case_cmp
     b.eq_ignore_ascii_case(a);
+    //~^ manual_ignore_case_cmp
 }
diff --git a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs
index 2a4d84b30ace..ca401e595fe9 100644
--- a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs
+++ b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.rs
@@ -7,24 +7,34 @@ fn main() {}
 
 fn variants(a: &str, b: &str) {
     if a.to_ascii_lowercase() == b.to_ascii_lowercase() {
+        //~^ manual_ignore_case_cmp
         return;
     }
     if a.to_ascii_uppercase() == b.to_ascii_uppercase() {
+        //~^ manual_ignore_case_cmp
         return;
     }
     let r = a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     let r = r || a.to_ascii_uppercase() == b.to_ascii_uppercase();
+    //~^ manual_ignore_case_cmp
     r && a.to_ascii_lowercase() == b.to_uppercase().to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     // !=
     if a.to_ascii_lowercase() != b.to_ascii_lowercase() {
+        //~^ manual_ignore_case_cmp
         return;
     }
     if a.to_ascii_uppercase() != b.to_ascii_uppercase() {
+        //~^ manual_ignore_case_cmp
         return;
     }
     let r = a.to_ascii_lowercase() != b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     let r = r || a.to_ascii_uppercase() != b.to_ascii_uppercase();
+    //~^ manual_ignore_case_cmp
     r && a.to_ascii_lowercase() != b.to_uppercase().to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 
 fn unsupported(a: char, b: char) {
@@ -36,72 +46,111 @@ fn unsupported(a: char, b: char) {
 
 fn char(a: char, b: char) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == *&b.to_ascii_lowercase();
     *&a.to_ascii_lowercase() == b.to_ascii_lowercase();
     a.to_ascii_lowercase() == 'a';
+    //~^ manual_ignore_case_cmp
     'a' == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn u8(a: u8, b: u8) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == b'a';
+    //~^ manual_ignore_case_cmp
     b'a' == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn ref_str(a: &str, b: &str) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn ref_ref_str(a: &&str, b: &&str) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn string(a: String, b: String) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     &a.to_ascii_lowercase() == &b.to_ascii_lowercase();
     &&a.to_ascii_lowercase() == &&b.to_ascii_lowercase();
     a.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn ref_string(a: String, b: &String) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 
     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     b.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == a.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn string_ref_str(a: String, b: &str) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     a.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 
     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     b.to_ascii_lowercase() == "a";
+    //~^ manual_ignore_case_cmp
     "a" == a.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn ref_u8slice(a: &[u8], b: &[u8]) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn u8vec(a: Vec<u8>, b: Vec<u8>) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn ref_u8vec(a: Vec<u8>, b: &Vec<u8>) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn ref_osstr(a: &OsStr, b: &OsStr) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn osstring(a: OsString, b: OsString) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
 fn ref_osstring(a: OsString, b: &OsString) {
     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+    //~^ manual_ignore_case_cmp
 }
diff --git a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr
index bc6393b66d5c..47378a65799f 100644
--- a/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr
+++ b/src/tools/clippy/tests/ui/manual_ignore_case_cmp.stderr
@@ -16,7 +16,7 @@ LL +     if a.eq_ignore_ascii_case(b) {
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:12:8
+  --> tests/ui/manual_ignore_case_cmp.rs:13:8
    |
 LL |     if a.to_ascii_uppercase() == b.to_ascii_uppercase() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL +     if a.eq_ignore_ascii_case(b) {
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:15:13
+  --> tests/ui/manual_ignore_case_cmp.rs:17:13
    |
 LL |     let r = a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL +     let r = a.eq_ignore_ascii_case(b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:16:18
+  --> tests/ui/manual_ignore_case_cmp.rs:19:18
    |
 LL |     let r = r || a.to_ascii_uppercase() == b.to_ascii_uppercase();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL +     let r = r || a.eq_ignore_ascii_case(b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:17:10
+  --> tests/ui/manual_ignore_case_cmp.rs:21:10
    |
 LL |     r && a.to_ascii_lowercase() == b.to_uppercase().to_ascii_lowercase();
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL +     r && a.eq_ignore_ascii_case(&b.to_uppercase());
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:19:8
+  --> tests/ui/manual_ignore_case_cmp.rs:24:8
    |
 LL |     if a.to_ascii_lowercase() != b.to_ascii_lowercase() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -76,7 +76,7 @@ LL +     if !a.eq_ignore_ascii_case(b) {
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:22:8
+  --> tests/ui/manual_ignore_case_cmp.rs:28:8
    |
 LL |     if a.to_ascii_uppercase() != b.to_ascii_uppercase() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ LL +     if !a.eq_ignore_ascii_case(b) {
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:25:13
+  --> tests/ui/manual_ignore_case_cmp.rs:32:13
    |
 LL |     let r = a.to_ascii_lowercase() != b.to_ascii_lowercase();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL +     let r = !a.eq_ignore_ascii_case(b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:26:18
+  --> tests/ui/manual_ignore_case_cmp.rs:34:18
    |
 LL |     let r = r || a.to_ascii_uppercase() != b.to_ascii_uppercase();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -112,7 +112,7 @@ LL +     let r = r || !a.eq_ignore_ascii_case(b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:27:10
+  --> tests/ui/manual_ignore_case_cmp.rs:36:10
    |
 LL |     r && a.to_ascii_lowercase() != b.to_uppercase().to_ascii_lowercase();
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -124,7 +124,7 @@ LL +     r && !a.eq_ignore_ascii_case(&b.to_uppercase());
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:38:5
+  --> tests/ui/manual_ignore_case_cmp.rs:48:5
    |
 LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL +     a.eq_ignore_ascii_case(&b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:41:5
+  --> tests/ui/manual_ignore_case_cmp.rs:52:5
    |
 LL |     a.to_ascii_lowercase() == 'a';
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -148,7 +148,7 @@ LL +     a.eq_ignore_ascii_case(&'a');
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:42:5
+  --> tests/ui/manual_ignore_case_cmp.rs:54:5
    |
 LL |     'a' == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -160,7 +160,7 @@ LL +     'a'.eq_ignore_ascii_case(&b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:45:5
+  --> tests/ui/manual_ignore_case_cmp.rs:58:5
    |
 LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -172,7 +172,7 @@ LL +     a.eq_ignore_ascii_case(&b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:46:5
+  --> tests/ui/manual_ignore_case_cmp.rs:60:5
    |
 LL |     a.to_ascii_lowercase() == b'a';
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -184,7 +184,7 @@ LL +     a.eq_ignore_ascii_case(&b'a');
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:47:5
+  --> tests/ui/manual_ignore_case_cmp.rs:62:5
    |
 LL |     b'a' == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -196,7 +196,7 @@ LL +     b'a'.eq_ignore_ascii_case(&b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:50:5
+  --> tests/ui/manual_ignore_case_cmp.rs:66:5
    |
 LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -207,164 +207,20 @@ LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
 LL +     a.eq_ignore_ascii_case(b);
    |
 
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:51:5
-   |
-LL |     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.to_uppercase().eq_ignore_ascii_case(b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:52:5
-   |
-LL |     a.to_ascii_lowercase() == "a";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == "a";
-LL +     a.eq_ignore_ascii_case("a");
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:53:5
-   |
-LL |     "a" == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     "a" == b.to_ascii_lowercase();
-LL +     "a".eq_ignore_ascii_case(b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:56:5
-   |
-LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.eq_ignore_ascii_case(b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:57:5
-   |
-LL |     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.to_uppercase().eq_ignore_ascii_case(b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:58:5
-   |
-LL |     a.to_ascii_lowercase() == "a";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == "a";
-LL +     a.eq_ignore_ascii_case("a");
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:59:5
-   |
-LL |     "a" == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     "a" == b.to_ascii_lowercase();
-LL +     "a".eq_ignore_ascii_case(b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:62:5
-   |
-LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.eq_ignore_ascii_case(&b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:63:5
-   |
-LL |     a.to_ascii_lowercase() == "a";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == "a";
-LL +     a.eq_ignore_ascii_case("a");
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:64:5
-   |
-LL |     "a" == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     "a" == b.to_ascii_lowercase();
-LL +     "a".eq_ignore_ascii_case(&b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:67:5
-   |
-LL |     a.to_ascii_lowercase() == "a";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == "a";
-LL +     a.eq_ignore_ascii_case("a");
-   |
-
 error: manual case-insensitive ASCII comparison
   --> tests/ui/manual_ignore_case_cmp.rs:68:5
    |
-LL |     "a" == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider using `.eq_ignore_ascii_case()` instead
    |
-LL -     "a" == b.to_ascii_lowercase();
-LL +     "a".eq_ignore_ascii_case(&b);
+LL -     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.to_uppercase().eq_ignore_ascii_case(b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:71:5
-   |
-LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.eq_ignore_ascii_case(b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:72:5
+  --> tests/ui/manual_ignore_case_cmp.rs:70:5
    |
 LL |     a.to_ascii_lowercase() == "a";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -376,7 +232,7 @@ LL +     a.eq_ignore_ascii_case("a");
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:73:5
+  --> tests/ui/manual_ignore_case_cmp.rs:72:5
    |
 LL |     "a" == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -387,45 +243,9 @@ LL -     "a" == b.to_ascii_lowercase();
 LL +     "a".eq_ignore_ascii_case(b);
    |
 
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:75:5
-   |
-LL |     b.to_ascii_lowercase() == a.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     b.to_ascii_lowercase() == a.to_ascii_lowercase();
-LL +     b.eq_ignore_ascii_case(&a);
-   |
-
 error: manual case-insensitive ASCII comparison
   --> tests/ui/manual_ignore_case_cmp.rs:76:5
    |
-LL |     b.to_ascii_lowercase() == "a";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     b.to_ascii_lowercase() == "a";
-LL +     b.eq_ignore_ascii_case("a");
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:77:5
-   |
-LL |     "a" == a.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     "a" == a.to_ascii_lowercase();
-LL +     "a".eq_ignore_ascii_case(&a);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:80:5
-   |
 LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
@@ -436,7 +256,19 @@ LL +     a.eq_ignore_ascii_case(b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:81:5
+  --> tests/ui/manual_ignore_case_cmp.rs:78:5
+   |
+LL |     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_uppercase().to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.to_uppercase().eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:80:5
    |
 LL |     a.to_ascii_lowercase() == "a";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -459,57 +291,9 @@ LL -     "a" == b.to_ascii_lowercase();
 LL +     "a".eq_ignore_ascii_case(b);
    |
 
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:84:5
-   |
-LL |     b.to_ascii_lowercase() == a.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     b.to_ascii_lowercase() == a.to_ascii_lowercase();
-LL +     b.eq_ignore_ascii_case(&a);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:85:5
-   |
-LL |     b.to_ascii_lowercase() == "a";
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     b.to_ascii_lowercase() == "a";
-LL +     b.eq_ignore_ascii_case("a");
-   |
-
 error: manual case-insensitive ASCII comparison
   --> tests/ui/manual_ignore_case_cmp.rs:86:5
    |
-LL |     "a" == a.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     "a" == a.to_ascii_lowercase();
-LL +     "a".eq_ignore_ascii_case(&a);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:89:5
-   |
-LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: consider using `.eq_ignore_ascii_case()` instead
-   |
-LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.eq_ignore_ascii_case(b);
-   |
-
-error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:92:5
-   |
 LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
@@ -520,31 +304,55 @@ LL +     a.eq_ignore_ascii_case(&b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:95:5
+  --> tests/ui/manual_ignore_case_cmp.rs:88:5
    |
-LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     a.to_ascii_lowercase() == "a";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider using `.eq_ignore_ascii_case()` instead
    |
-LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.eq_ignore_ascii_case(b);
+LL -     a.to_ascii_lowercase() == "a";
+LL +     a.eq_ignore_ascii_case("a");
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:90:5
+   |
+LL |     "a" == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     "a" == b.to_ascii_lowercase();
+LL +     "a".eq_ignore_ascii_case(&b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:94:5
+   |
+LL |     a.to_ascii_lowercase() == "a";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == "a";
+LL +     a.eq_ignore_ascii_case("a");
    |
 
 error: manual case-insensitive ASCII comparison
   --> tests/ui/manual_ignore_case_cmp.rs:96:5
    |
-LL |     b.to_ascii_lowercase() == a.to_ascii_lowercase();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |     "a" == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider using `.eq_ignore_ascii_case()` instead
    |
-LL -     b.to_ascii_lowercase() == a.to_ascii_lowercase();
-LL +     b.eq_ignore_ascii_case(&a);
+LL -     "a" == b.to_ascii_lowercase();
+LL +     "a".eq_ignore_ascii_case(&b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:99:5
+  --> tests/ui/manual_ignore_case_cmp.rs:100:5
    |
 LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -558,17 +366,65 @@ LL +     a.eq_ignore_ascii_case(b);
 error: manual case-insensitive ASCII comparison
   --> tests/ui/manual_ignore_case_cmp.rs:102:5
    |
-LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+LL |     a.to_ascii_lowercase() == "a";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == "a";
+LL +     a.eq_ignore_ascii_case("a");
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:104:5
+   |
+LL |     "a" == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     "a" == b.to_ascii_lowercase();
+LL +     "a".eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:107:5
+   |
+LL |     b.to_ascii_lowercase() == a.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider using `.eq_ignore_ascii_case()` instead
    |
-LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
-LL +     a.eq_ignore_ascii_case(b);
+LL -     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+LL +     b.eq_ignore_ascii_case(&a);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:105:5
+  --> tests/ui/manual_ignore_case_cmp.rs:109:5
+   |
+LL |     b.to_ascii_lowercase() == "a";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     b.to_ascii_lowercase() == "a";
+LL +     b.eq_ignore_ascii_case("a");
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:111:5
+   |
+LL |     "a" == a.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     "a" == a.to_ascii_lowercase();
+LL +     "a".eq_ignore_ascii_case(&a);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:115:5
    |
 LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -580,7 +436,151 @@ LL +     a.eq_ignore_ascii_case(b);
    |
 
 error: manual case-insensitive ASCII comparison
-  --> tests/ui/manual_ignore_case_cmp.rs:106:5
+  --> tests/ui/manual_ignore_case_cmp.rs:117:5
+   |
+LL |     a.to_ascii_lowercase() == "a";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == "a";
+LL +     a.eq_ignore_ascii_case("a");
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:119:5
+   |
+LL |     "a" == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     "a" == b.to_ascii_lowercase();
+LL +     "a".eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:122:5
+   |
+LL |     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+LL +     b.eq_ignore_ascii_case(&a);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:124:5
+   |
+LL |     b.to_ascii_lowercase() == "a";
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     b.to_ascii_lowercase() == "a";
+LL +     b.eq_ignore_ascii_case("a");
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:126:5
+   |
+LL |     "a" == a.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     "a" == a.to_ascii_lowercase();
+LL +     "a".eq_ignore_ascii_case(&a);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:130:5
+   |
+LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:134:5
+   |
+LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.eq_ignore_ascii_case(&b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:138:5
+   |
+LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:140:5
+   |
+LL |     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     b.to_ascii_lowercase() == a.to_ascii_lowercase();
+LL +     b.eq_ignore_ascii_case(&a);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:144:5
+   |
+LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:148:5
+   |
+LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:152:5
+   |
+LL |     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: consider using `.eq_ignore_ascii_case()` instead
+   |
+LL -     a.to_ascii_lowercase() == b.to_ascii_lowercase();
+LL +     a.eq_ignore_ascii_case(b);
+   |
+
+error: manual case-insensitive ASCII comparison
+  --> tests/ui/manual_ignore_case_cmp.rs:154:5
    |
 LL |     b.to_ascii_lowercase() == a.to_ascii_lowercase();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/manual_inspect.fixed b/src/tools/clippy/tests/ui/manual_inspect.fixed
index 0e1b8fe3edb5..44f15d61f856 100644
--- a/src/tools/clippy/tests/ui/manual_inspect.fixed
+++ b/src/tools/clippy/tests/ui/manual_inspect.fixed
@@ -3,24 +3,29 @@
 
 fn main() {
     let _ = Some(0).inspect(|&x| {
+        //~^ manual_inspect
         println!("{}", x);
     });
 
     let _ = Some(0).inspect(|&x| {
+        //~^ manual_inspect
         println!("{x}");
     });
 
     let _ = Some(0).inspect(|&x| {
+        //~^ manual_inspect
         println!("{}", x * 5 + 1);
     });
 
     let _ = Some(0).inspect(|&x| {
+        //~^ manual_inspect
         if x == 0 {
             panic!();
         }
     });
 
     let _ = Some(0).inspect(|&x| {
+        //~^ manual_inspect
         if &x == &0 {
             let _y = x;
             panic!();
@@ -71,6 +76,7 @@ fn main() {
     }
 
     let _ = Some((String::new(), 0u32)).inspect(|x| {
+        //~^ manual_inspect
         if x.1 == 0 {
             let _x = x.1;
             panic!();
@@ -96,6 +102,7 @@ fn main() {
     });
 
     let _ = Some(String::new()).inspect(|x| {
+        //~^ manual_inspect
         if x.is_empty() {
             let _ = || {
                 let _x = x;
@@ -106,6 +113,7 @@ fn main() {
     });
 
     let _ = Some(0).inspect(|&x| {
+        //~^ manual_inspect
         if x == 0 {
             let _ = || {
                 let _x = x;
@@ -120,6 +128,7 @@ fn main() {
         struct Cell2(core::cell::Cell<u32>);
 
         let _ = Some(Cell2(Cell::new(0u32))).inspect(|x| {
+            //~^ manual_inspect
             x.0.set(1);
         });
 
@@ -135,16 +144,20 @@ fn main() {
     }
 
     let _: Result<_, ()> = Ok(0).inspect(|&x| {
+        //~^ manual_inspect
         println!("{}", x);
     });
 
     let _: Result<(), _> = Err(0).inspect_err(|&x| {
+        //~^ manual_inspect
         println!("{}", x);
     });
 
     let _ = [0]
+        //~^ suspicious_map
         .into_iter()
         .inspect(|&x| {
+            //~^ manual_inspect
             println!("{}", x);
         })
         .count();
diff --git a/src/tools/clippy/tests/ui/manual_inspect.rs b/src/tools/clippy/tests/ui/manual_inspect.rs
index 94cdfe391400..d34f2abce6ae 100644
--- a/src/tools/clippy/tests/ui/manual_inspect.rs
+++ b/src/tools/clippy/tests/ui/manual_inspect.rs
@@ -3,21 +3,25 @@
 
 fn main() {
     let _ = Some(0).map(|x| {
+        //~^ manual_inspect
         println!("{}", x);
         x
     });
 
     let _ = Some(0).map(|x| {
+        //~^ manual_inspect
         println!("{x}");
         x
     });
 
     let _ = Some(0).map(|x| {
+        //~^ manual_inspect
         println!("{}", x * 5 + 1);
         x
     });
 
     let _ = Some(0).map(|x| {
+        //~^ manual_inspect
         if x == 0 {
             panic!();
         }
@@ -25,6 +29,7 @@ fn main() {
     });
 
     let _ = Some(0).map(|x| {
+        //~^ manual_inspect
         if &x == &0 {
             let _y = x;
             panic!();
@@ -76,6 +81,7 @@ fn main() {
     }
 
     let _ = Some((String::new(), 0u32)).map(|x| {
+        //~^ manual_inspect
         if x.1 == 0 {
             let _x = x.1;
             panic!();
@@ -102,6 +108,7 @@ fn main() {
     });
 
     let _ = Some(String::new()).map(|x| {
+        //~^ manual_inspect
         if x.is_empty() {
             let _ = || {
                 let _x = &x;
@@ -113,6 +120,7 @@ fn main() {
     });
 
     let _ = Some(0).map(|x| {
+        //~^ manual_inspect
         if x == 0 {
             let _ = || {
                 let _x = x;
@@ -128,6 +136,7 @@ fn main() {
         struct Cell2(core::cell::Cell<u32>);
 
         let _ = Some(Cell2(Cell::new(0u32))).map(|x| {
+            //~^ manual_inspect
             x.0.set(1);
             x
         });
@@ -144,18 +153,22 @@ fn main() {
     }
 
     let _: Result<_, ()> = Ok(0).map(|x| {
+        //~^ manual_inspect
         println!("{}", x);
         x
     });
 
     let _: Result<(), _> = Err(0).map_err(|x| {
+        //~^ manual_inspect
         println!("{}", x);
         x
     });
 
     let _ = [0]
+        //~^ suspicious_map
         .into_iter()
         .map(|x| {
+            //~^ manual_inspect
             println!("{}", x);
             x
         })
diff --git a/src/tools/clippy/tests/ui/manual_inspect.stderr b/src/tools/clippy/tests/ui/manual_inspect.stderr
index 0559b3bd6611..510325d2baaa 100644
--- a/src/tools/clippy/tests/ui/manual_inspect.stderr
+++ b/src/tools/clippy/tests/ui/manual_inspect.stderr
@@ -9,11 +9,12 @@ LL |     let _ = Some(0).map(|x| {
 help: try
    |
 LL ~     let _ = Some(0).inspect(|&x| {
+LL |
 LL ~         println!("{}", x);
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:10:21
+  --> tests/ui/manual_inspect.rs:11:21
    |
 LL |     let _ = Some(0).map(|x| {
    |                     ^^^
@@ -21,11 +22,12 @@ LL |     let _ = Some(0).map(|x| {
 help: try
    |
 LL ~     let _ = Some(0).inspect(|&x| {
+LL |
 LL ~         println!("{x}");
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:15:21
+  --> tests/ui/manual_inspect.rs:17:21
    |
 LL |     let _ = Some(0).map(|x| {
    |                     ^^^
@@ -33,11 +35,12 @@ LL |     let _ = Some(0).map(|x| {
 help: try
    |
 LL ~     let _ = Some(0).inspect(|&x| {
+LL |
 LL ~         println!("{}", x * 5 + 1);
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:20:21
+  --> tests/ui/manual_inspect.rs:23:21
    |
 LL |     let _ = Some(0).map(|x| {
    |                     ^^^
@@ -45,13 +48,14 @@ LL |     let _ = Some(0).map(|x| {
 help: try
    |
 LL ~     let _ = Some(0).inspect(|&x| {
+LL |
 LL |         if x == 0 {
 LL |             panic!();
 LL ~         }
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:27:21
+  --> tests/ui/manual_inspect.rs:31:21
    |
 LL |     let _ = Some(0).map(|x| {
    |                     ^^^
@@ -59,14 +63,14 @@ LL |     let _ = Some(0).map(|x| {
 help: try
    |
 LL ~     let _ = Some(0).inspect(|&x| {
-LL |         if &x == &0 {
-LL |             let _y = x;
+LL |
+...
 LL |             panic!();
 LL ~         }
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:78:41
+  --> tests/ui/manual_inspect.rs:83:41
    |
 LL |     let _ = Some((String::new(), 0u32)).map(|x| {
    |                                         ^^^
@@ -74,14 +78,14 @@ LL |     let _ = Some((String::new(), 0u32)).map(|x| {
 help: try
    |
 LL ~     let _ = Some((String::new(), 0u32)).inspect(|x| {
-LL |         if x.1 == 0 {
-LL |             let _x = x.1;
+LL |
+...
 LL |             panic!();
 LL ~         }
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:104:33
+  --> tests/ui/manual_inspect.rs:110:33
    |
 LL |     let _ = Some(String::new()).map(|x| {
    |                                 ^^^
@@ -89,6 +93,7 @@ LL |     let _ = Some(String::new()).map(|x| {
 help: try
    |
 LL ~     let _ = Some(String::new()).inspect(|x| {
+LL |
 LL |         if x.is_empty() {
 LL |             let _ = || {
 LL ~                 let _x = x;
@@ -99,7 +104,7 @@ LL ~         println!("test");
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:115:21
+  --> tests/ui/manual_inspect.rs:122:21
    |
 LL |     let _ = Some(0).map(|x| {
    |                     ^^^
@@ -107,14 +112,14 @@ LL |     let _ = Some(0).map(|x| {
 help: try
    |
 LL ~     let _ = Some(0).inspect(|&x| {
-LL |         if x == 0 {
+LL |
 ...
 LL |             panic!();
 LL ~         }
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:130:46
+  --> tests/ui/manual_inspect.rs:138:46
    |
 LL |         let _ = Some(Cell2(Cell::new(0u32))).map(|x| {
    |                                              ^^^
@@ -122,11 +127,12 @@ LL |         let _ = Some(Cell2(Cell::new(0u32))).map(|x| {
 help: try
    |
 LL ~         let _ = Some(Cell2(Cell::new(0u32))).inspect(|x| {
+LL |
 LL ~             x.0.set(1);
    |
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:146:34
+  --> tests/ui/manual_inspect.rs:155:34
    |
 LL |     let _: Result<_, ()> = Ok(0).map(|x| {
    |                                  ^^^
@@ -134,11 +140,12 @@ LL |     let _: Result<_, ()> = Ok(0).map(|x| {
 help: try
    |
 LL ~     let _: Result<_, ()> = Ok(0).inspect(|&x| {
+LL |
 LL ~         println!("{}", x);
    |
 
 error: using `map_err` over `inspect_err`
-  --> tests/ui/manual_inspect.rs:151:35
+  --> tests/ui/manual_inspect.rs:161:35
    |
 LL |     let _: Result<(), _> = Err(0).map_err(|x| {
    |                                   ^^^^^^^
@@ -146,18 +153,19 @@ LL |     let _: Result<(), _> = Err(0).map_err(|x| {
 help: try
    |
 LL ~     let _: Result<(), _> = Err(0).inspect_err(|&x| {
+LL |
 LL ~         println!("{}", x);
    |
 
 error: this call to `map()` won't have an effect on the call to `count()`
-  --> tests/ui/manual_inspect.rs:156:13
+  --> tests/ui/manual_inspect.rs:167:13
    |
 LL |       let _ = [0]
    |  _____________^
+LL | |
 LL | |         .into_iter()
 LL | |         .map(|x| {
-LL | |             println!("{}", x);
-LL | |             x
+...  |
 LL | |         })
 LL | |         .count();
    | |________________^
@@ -167,7 +175,7 @@ LL | |         .count();
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_map)]`
 
 error: using `map` over `inspect`
-  --> tests/ui/manual_inspect.rs:158:10
+  --> tests/ui/manual_inspect.rs:170:10
    |
 LL |         .map(|x| {
    |          ^^^
@@ -175,6 +183,7 @@ LL |         .map(|x| {
 help: try
    |
 LL ~         .inspect(|&x| {
+LL |
 LL ~             println!("{}", x);
    |
 
diff --git a/src/tools/clippy/tests/ui/manual_instant_elapsed.fixed b/src/tools/clippy/tests/ui/manual_instant_elapsed.fixed
index 1811337652dd..187802bb76c9 100644
--- a/src/tools/clippy/tests/ui/manual_instant_elapsed.fixed
+++ b/src/tools/clippy/tests/ui/manual_instant_elapsed.fixed
@@ -15,6 +15,7 @@ fn main() {
     }
 
     let duration = prev_instant.elapsed();
+    //~^ manual_instant_elapsed
 
     // don't catch
     let duration = prev_instant.elapsed();
@@ -24,4 +25,6 @@ fn main() {
     let ref_to_instant = &Instant::now();
 
     (*ref_to_instant).elapsed(); // to ensure parens are added correctly
+    //
+    //~^^ manual_instant_elapsed
 }
diff --git a/src/tools/clippy/tests/ui/manual_instant_elapsed.rs b/src/tools/clippy/tests/ui/manual_instant_elapsed.rs
index fedca38b158a..61e14e5a3d9d 100644
--- a/src/tools/clippy/tests/ui/manual_instant_elapsed.rs
+++ b/src/tools/clippy/tests/ui/manual_instant_elapsed.rs
@@ -15,6 +15,7 @@ fn main() {
     }
 
     let duration = Instant::now() - prev_instant;
+    //~^ manual_instant_elapsed
 
     // don't catch
     let duration = prev_instant.elapsed();
@@ -24,4 +25,6 @@ fn main() {
     let ref_to_instant = &Instant::now();
 
     Instant::now() - *ref_to_instant; // to ensure parens are added correctly
+    //
+    //~^^ manual_instant_elapsed
 }
diff --git a/src/tools/clippy/tests/ui/manual_instant_elapsed.stderr b/src/tools/clippy/tests/ui/manual_instant_elapsed.stderr
index e8ffeb5f8ca3..e84f3126f707 100644
--- a/src/tools/clippy/tests/ui/manual_instant_elapsed.stderr
+++ b/src/tools/clippy/tests/ui/manual_instant_elapsed.stderr
@@ -8,7 +8,7 @@ LL |     let duration = Instant::now() - prev_instant;
    = help: to override `-D warnings` add `#[allow(clippy::manual_instant_elapsed)]`
 
 error: manual implementation of `Instant::elapsed`
-  --> tests/ui/manual_instant_elapsed.rs:26:5
+  --> tests/ui/manual_instant_elapsed.rs:27:5
    |
 LL |     Instant::now() - *ref_to_instant; // to ensure parens are added correctly
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*ref_to_instant).elapsed()`
diff --git a/src/tools/clippy/tests/ui/manual_is_ascii_check.fixed b/src/tools/clippy/tests/ui/manual_is_ascii_check.fixed
index 179149f697db..7b0d19068346 100644
--- a/src/tools/clippy/tests/ui/manual_is_ascii_check.fixed
+++ b/src/tools/clippy/tests/ui/manual_is_ascii_check.fixed
@@ -3,29 +3,45 @@
 
 fn main() {
     assert!('x'.is_ascii_lowercase());
+    //~^ manual_is_ascii_check
     assert!('X'.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
     assert!(b'x'.is_ascii_lowercase());
+    //~^ manual_is_ascii_check
     assert!(b'X'.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
 
     let num = '2';
     assert!(num.is_ascii_digit());
+    //~^ manual_is_ascii_check
     assert!(b'1'.is_ascii_digit());
+    //~^ manual_is_ascii_check
     assert!('x'.is_ascii_alphabetic());
+    //~^ manual_is_ascii_check
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
 
     b'0'.is_ascii_digit();
+    //~^ manual_is_ascii_check
     b'a'.is_ascii_lowercase();
+    //~^ manual_is_ascii_check
     b'A'.is_ascii_uppercase();
+    //~^ manual_is_ascii_check
 
     '0'.is_ascii_digit();
+    //~^ manual_is_ascii_check
     'a'.is_ascii_lowercase();
+    //~^ manual_is_ascii_check
     'A'.is_ascii_uppercase();
+    //~^ manual_is_ascii_check
 
     let cool_letter = &'g';
     cool_letter.is_ascii_digit();
+    //~^ manual_is_ascii_check
     cool_letter.is_ascii_lowercase();
+    //~^ manual_is_ascii_check
     cool_letter.is_ascii_uppercase();
+    //~^ manual_is_ascii_check
 }
 
 #[clippy::msrv = "1.23"]
@@ -39,9 +55,13 @@ fn msrv_1_23() {
 #[clippy::msrv = "1.24"]
 fn msrv_1_24() {
     assert!(b'1'.is_ascii_digit());
+    //~^ manual_is_ascii_check
     assert!('X'.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
     assert!('x'.is_ascii_alphabetic());
+    //~^ manual_is_ascii_check
     assert!('x'.is_ascii_hexdigit());
+    //~^ manual_is_ascii_check
 }
 
 #[clippy::msrv = "1.46"]
@@ -53,14 +73,18 @@ fn msrv_1_46() {
 #[clippy::msrv = "1.47"]
 fn msrv_1_47() {
     const FOO: bool = 'x'.is_ascii_digit();
+    //~^ manual_is_ascii_check
     const BAR: bool = 'x'.is_ascii_hexdigit();
+    //~^ manual_is_ascii_check
 }
 
 #[allow(clippy::deref_addrof, clippy::needless_borrow)]
 fn with_refs() {
     let cool_letter = &&'g';
     cool_letter.is_ascii_digit();
+    //~^ manual_is_ascii_check
     cool_letter.is_ascii_lowercase();
+    //~^ manual_is_ascii_check
 }
 
 fn generics() {
@@ -79,11 +103,16 @@ fn generics() {
     {
     }
     take_while(|c: char| c.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
     take_while(|c: u8| c.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
     take_while(|c: char| c.is_ascii_uppercase());
+    //~^ manual_is_ascii_check
 }
 
 fn adds_type_reference() {
     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c: &&char| c.is_ascii_digit()).collect();
+    //~^ manual_is_ascii_check
     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c: &&mut char| c.is_ascii_digit()).collect();
+    //~^ manual_is_ascii_check
 }
diff --git a/src/tools/clippy/tests/ui/manual_is_ascii_check.rs b/src/tools/clippy/tests/ui/manual_is_ascii_check.rs
index 74f35ce94e84..e4f7fe9f5838 100644
--- a/src/tools/clippy/tests/ui/manual_is_ascii_check.rs
+++ b/src/tools/clippy/tests/ui/manual_is_ascii_check.rs
@@ -3,29 +3,45 @@
 
 fn main() {
     assert!(matches!('x', 'a'..='z'));
+    //~^ manual_is_ascii_check
     assert!(matches!('X', 'A'..='Z'));
+    //~^ manual_is_ascii_check
     assert!(matches!(b'x', b'a'..=b'z'));
+    //~^ manual_is_ascii_check
     assert!(matches!(b'X', b'A'..=b'Z'));
+    //~^ manual_is_ascii_check
 
     let num = '2';
     assert!(matches!(num, '0'..='9'));
+    //~^ manual_is_ascii_check
     assert!(matches!(b'1', b'0'..=b'9'));
+    //~^ manual_is_ascii_check
     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    //~^ manual_is_ascii_check
 
     assert!(matches!('x', 'A'..='Z' | 'a'..='z' | '_'));
 
     (b'0'..=b'9').contains(&b'0');
+    //~^ manual_is_ascii_check
     (b'a'..=b'z').contains(&b'a');
+    //~^ manual_is_ascii_check
     (b'A'..=b'Z').contains(&b'A');
+    //~^ manual_is_ascii_check
 
     ('0'..='9').contains(&'0');
+    //~^ manual_is_ascii_check
     ('a'..='z').contains(&'a');
+    //~^ manual_is_ascii_check
     ('A'..='Z').contains(&'A');
+    //~^ manual_is_ascii_check
 
     let cool_letter = &'g';
     ('0'..='9').contains(cool_letter);
+    //~^ manual_is_ascii_check
     ('a'..='z').contains(cool_letter);
+    //~^ manual_is_ascii_check
     ('A'..='Z').contains(cool_letter);
+    //~^ manual_is_ascii_check
 }
 
 #[clippy::msrv = "1.23"]
@@ -39,9 +55,13 @@ fn msrv_1_23() {
 #[clippy::msrv = "1.24"]
 fn msrv_1_24() {
     assert!(matches!(b'1', b'0'..=b'9'));
+    //~^ manual_is_ascii_check
     assert!(matches!('X', 'A'..='Z'));
+    //~^ manual_is_ascii_check
     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
+    //~^ manual_is_ascii_check
     assert!(matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F'));
+    //~^ manual_is_ascii_check
 }
 
 #[clippy::msrv = "1.46"]
@@ -53,14 +73,18 @@ fn msrv_1_46() {
 #[clippy::msrv = "1.47"]
 fn msrv_1_47() {
     const FOO: bool = matches!('x', '0'..='9');
+    //~^ manual_is_ascii_check
     const BAR: bool = matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F');
+    //~^ manual_is_ascii_check
 }
 
 #[allow(clippy::deref_addrof, clippy::needless_borrow)]
 fn with_refs() {
     let cool_letter = &&'g';
     ('0'..='9').contains(&&cool_letter);
+    //~^ manual_is_ascii_check
     ('a'..='z').contains(*cool_letter);
+    //~^ manual_is_ascii_check
 }
 
 fn generics() {
@@ -79,11 +103,16 @@ fn generics() {
     {
     }
     take_while(|c| ('A'..='Z').contains(&c));
+    //~^ manual_is_ascii_check
     take_while(|c| (b'A'..=b'Z').contains(&c));
+    //~^ manual_is_ascii_check
     take_while(|c: char| ('A'..='Z').contains(&c));
+    //~^ manual_is_ascii_check
 }
 
 fn adds_type_reference() {
     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c| ('0'..='9').contains(c)).collect();
+    //~^ manual_is_ascii_check
     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'..='9').contains(c)).collect();
+    //~^ manual_is_ascii_check
 }
diff --git a/src/tools/clippy/tests/ui/manual_is_ascii_check.stderr b/src/tools/clippy/tests/ui/manual_is_ascii_check.stderr
index 7b3f0c938b0d..9fd7f457b420 100644
--- a/src/tools/clippy/tests/ui/manual_is_ascii_check.stderr
+++ b/src/tools/clippy/tests/ui/manual_is_ascii_check.stderr
@@ -8,145 +8,145 @@ LL |     assert!(matches!('x', 'a'..='z'));
    = help: to override `-D warnings` add `#[allow(clippy::manual_is_ascii_check)]`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:6:13
+  --> tests/ui/manual_is_ascii_check.rs:7:13
    |
 LL |     assert!(matches!('X', 'A'..='Z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:7:13
+  --> tests/ui/manual_is_ascii_check.rs:9:13
    |
 LL |     assert!(matches!(b'x', b'a'..=b'z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'x'.is_ascii_lowercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:8:13
+  --> tests/ui/manual_is_ascii_check.rs:11:13
    |
 LL |     assert!(matches!(b'X', b'A'..=b'Z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'X'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:11:13
+  --> tests/ui/manual_is_ascii_check.rs:15:13
    |
 LL |     assert!(matches!(num, '0'..='9'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:12:13
+  --> tests/ui/manual_is_ascii_check.rs:17:13
    |
 LL |     assert!(matches!(b'1', b'0'..=b'9'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:13:13
+  --> tests/ui/manual_is_ascii_check.rs:19:13
    |
 LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:17:5
+  --> tests/ui/manual_is_ascii_check.rs:24:5
    |
 LL |     (b'0'..=b'9').contains(&b'0');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'0'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:18:5
+  --> tests/ui/manual_is_ascii_check.rs:26:5
    |
 LL |     (b'a'..=b'z').contains(&b'a');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'a'.is_ascii_lowercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:19:5
+  --> tests/ui/manual_is_ascii_check.rs:28:5
    |
 LL |     (b'A'..=b'Z').contains(&b'A');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'A'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:21:5
+  --> tests/ui/manual_is_ascii_check.rs:31:5
    |
 LL |     ('0'..='9').contains(&'0');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'0'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:22:5
+  --> tests/ui/manual_is_ascii_check.rs:33:5
    |
 LL |     ('a'..='z').contains(&'a');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'a'.is_ascii_lowercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:23:5
+  --> tests/ui/manual_is_ascii_check.rs:35:5
    |
 LL |     ('A'..='Z').contains(&'A');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'A'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:26:5
+  --> tests/ui/manual_is_ascii_check.rs:39:5
    |
 LL |     ('0'..='9').contains(cool_letter);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:27:5
+  --> tests/ui/manual_is_ascii_check.rs:41:5
    |
 LL |     ('a'..='z').contains(cool_letter);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_lowercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:28:5
+  --> tests/ui/manual_is_ascii_check.rs:43:5
    |
 LL |     ('A'..='Z').contains(cool_letter);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:41:13
+  --> tests/ui/manual_is_ascii_check.rs:57:13
    |
 LL |     assert!(matches!(b'1', b'0'..=b'9'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `b'1'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:42:13
+  --> tests/ui/manual_is_ascii_check.rs:59:13
    |
 LL |     assert!(matches!('X', 'A'..='Z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'X'.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:43:13
+  --> tests/ui/manual_is_ascii_check.rs:61:13
    |
 LL |     assert!(matches!('x', 'A'..='Z' | 'a'..='z'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_alphabetic()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:44:13
+  --> tests/ui/manual_is_ascii_check.rs:63:13
    |
 LL |     assert!(matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F'));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_hexdigit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:55:23
+  --> tests/ui/manual_is_ascii_check.rs:75:23
    |
 LL |     const FOO: bool = matches!('x', '0'..='9');
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:56:23
+  --> tests/ui/manual_is_ascii_check.rs:77:23
    |
 LL |     const BAR: bool = matches!('x', '0'..='9' | 'a'..='f' | 'A'..='F');
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'x'.is_ascii_hexdigit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:62:5
+  --> tests/ui/manual_is_ascii_check.rs:84:5
    |
 LL |     ('0'..='9').contains(&&cool_letter);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_digit()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:63:5
+  --> tests/ui/manual_is_ascii_check.rs:86:5
    |
 LL |     ('a'..='z').contains(*cool_letter);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cool_letter.is_ascii_lowercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:81:20
+  --> tests/ui/manual_is_ascii_check.rs:105:20
    |
 LL |     take_while(|c| ('A'..='Z').contains(&c));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -158,7 +158,7 @@ LL +     take_while(|c: char| c.is_ascii_uppercase());
    |
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:82:20
+  --> tests/ui/manual_is_ascii_check.rs:107:20
    |
 LL |     take_while(|c| (b'A'..=b'Z').contains(&c));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -170,13 +170,13 @@ LL +     take_while(|c: u8| c.is_ascii_uppercase());
    |
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:83:26
+  --> tests/ui/manual_is_ascii_check.rs:109:26
    |
 LL |     take_while(|c: char| ('A'..='Z').contains(&c));
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `c.is_ascii_uppercase()`
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:87:63
+  --> tests/ui/manual_is_ascii_check.rs:114:63
    |
 LL |     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c| ('0'..='9').contains(c)).collect();
    |                                                               ^^^^^^^^^^^^^^^^^^^^^^^
@@ -188,7 +188,7 @@ LL +     let digits: Vec<&char> = ['1', 'A'].iter().take_while(|c: &&char| c.is_
    |
 
 error: manual check for common ascii range
-  --> tests/ui/manual_is_ascii_check.rs:88:71
+  --> tests/ui/manual_is_ascii_check.rs:116:71
    |
 LL |     let digits: Vec<&mut char> = ['1', 'A'].iter_mut().take_while(|c| ('0'..='9').contains(c)).collect();
    |                                                                       ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/manual_is_power_of_two.fixed b/src/tools/clippy/tests/ui/manual_is_power_of_two.fixed
index dda5fe0ec3e7..6f29d76bd210 100644
--- a/src/tools/clippy/tests/ui/manual_is_power_of_two.fixed
+++ b/src/tools/clippy/tests/ui/manual_is_power_of_two.fixed
@@ -4,13 +4,19 @@ fn main() {
     let a = 16_u64;
 
     let _ = a.is_power_of_two();
+    //~^ manual_is_power_of_two
     let _ = a.is_power_of_two();
+    //~^ manual_is_power_of_two
 
     // Test different orders of expression
     let _ = a.is_power_of_two();
+    //~^ manual_is_power_of_two
     let _ = a.is_power_of_two();
+    //~^ manual_is_power_of_two
     let _ = a.is_power_of_two();
+    //~^ manual_is_power_of_two
     let _ = a.is_power_of_two();
+    //~^ manual_is_power_of_two
 
     let b = 4_i64;
 
diff --git a/src/tools/clippy/tests/ui/manual_is_power_of_two.rs b/src/tools/clippy/tests/ui/manual_is_power_of_two.rs
index a1d3a95c4102..0c44d7a660b4 100644
--- a/src/tools/clippy/tests/ui/manual_is_power_of_two.rs
+++ b/src/tools/clippy/tests/ui/manual_is_power_of_two.rs
@@ -4,13 +4,19 @@ fn main() {
     let a = 16_u64;
 
     let _ = a.count_ones() == 1;
+    //~^ manual_is_power_of_two
     let _ = a & (a - 1) == 0;
+    //~^ manual_is_power_of_two
 
     // Test different orders of expression
     let _ = 1 == a.count_ones();
+    //~^ manual_is_power_of_two
     let _ = (a - 1) & a == 0;
+    //~^ manual_is_power_of_two
     let _ = 0 == a & (a - 1);
+    //~^ manual_is_power_of_two
     let _ = 0 == (a - 1) & a;
+    //~^ manual_is_power_of_two
 
     let b = 4_i64;
 
diff --git a/src/tools/clippy/tests/ui/manual_is_power_of_two.stderr b/src/tools/clippy/tests/ui/manual_is_power_of_two.stderr
index 3cfc6297abf2..ad12ee10565f 100644
--- a/src/tools/clippy/tests/ui/manual_is_power_of_two.stderr
+++ b/src/tools/clippy/tests/ui/manual_is_power_of_two.stderr
@@ -8,31 +8,31 @@ LL |     let _ = a.count_ones() == 1;
    = help: to override `-D warnings` add `#[allow(clippy::manual_is_power_of_two)]`
 
 error: manually reimplementing `is_power_of_two`
-  --> tests/ui/manual_is_power_of_two.rs:7:13
+  --> tests/ui/manual_is_power_of_two.rs:8:13
    |
 LL |     let _ = a & (a - 1) == 0;
    |             ^^^^^^^^^^^^^^^^ help: consider using `.is_power_of_two()`: `a.is_power_of_two()`
 
 error: manually reimplementing `is_power_of_two`
-  --> tests/ui/manual_is_power_of_two.rs:10:13
+  --> tests/ui/manual_is_power_of_two.rs:12:13
    |
 LL |     let _ = 1 == a.count_ones();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using `.is_power_of_two()`: `a.is_power_of_two()`
 
 error: manually reimplementing `is_power_of_two`
-  --> tests/ui/manual_is_power_of_two.rs:11:13
+  --> tests/ui/manual_is_power_of_two.rs:14:13
    |
 LL |     let _ = (a - 1) & a == 0;
    |             ^^^^^^^^^^^^^^^^ help: consider using `.is_power_of_two()`: `a.is_power_of_two()`
 
 error: manually reimplementing `is_power_of_two`
-  --> tests/ui/manual_is_power_of_two.rs:12:13
+  --> tests/ui/manual_is_power_of_two.rs:16:13
    |
 LL |     let _ = 0 == a & (a - 1);
    |             ^^^^^^^^^^^^^^^^ help: consider using `.is_power_of_two()`: `a.is_power_of_two()`
 
 error: manually reimplementing `is_power_of_two`
-  --> tests/ui/manual_is_power_of_two.rs:13:13
+  --> tests/ui/manual_is_power_of_two.rs:18:13
    |
 LL |     let _ = 0 == (a - 1) & a;
    |             ^^^^^^^^^^^^^^^^ help: consider using `.is_power_of_two()`: `a.is_power_of_two()`
diff --git a/src/tools/clippy/tests/ui/manual_is_variant_and.fixed b/src/tools/clippy/tests/ui/manual_is_variant_and.fixed
index 8c34b51103c1..c9c184561dd6 100644
--- a/src/tools/clippy/tests/ui/manual_is_variant_and.fixed
+++ b/src/tools/clippy/tests/ui/manual_is_variant_and.fixed
@@ -13,9 +13,11 @@ fn option_methods() {
     let _ = opt.is_some_and(|x| x > 1);
     // Multi-line cases.
     let _ = opt.is_some_and(|x| {
+    //~^ manual_is_variant_and
         x > 1
     });
     let _ = opt.is_some_and(|x| x > 1);
+    //~^ manual_is_variant_and
     let _ = opt
         .is_some_and(|x| x > 1);
 
@@ -24,6 +26,7 @@ fn option_methods() {
 
     let opt2 = Some('a');
     let _ = opt2.is_some_and(char::is_alphanumeric); // should lint
+    //~^ manual_is_variant_and
     let _ = opt_map!(opt2, |x| x == 'a').unwrap_or_default(); // should not lint
 }
 
@@ -33,6 +36,7 @@ fn result_methods() {
 
     // multi line cases
     let _ = res.is_ok_and(|x| {
+    //~^ manual_is_variant_and
         x > 1
     });
     let _ = res.is_ok_and(|x| x > 1);
@@ -42,6 +46,7 @@ fn result_methods() {
 
     let res2: Result<char, ()> = Ok('a');
     let _ = res2.is_ok_and(char::is_alphanumeric); // should lint
+    //~^ manual_is_variant_and
     let _ = opt_map!(res2, |x| x == 'a').unwrap_or_default(); // should not lint
 }
 
diff --git a/src/tools/clippy/tests/ui/manual_is_variant_and.rs b/src/tools/clippy/tests/ui/manual_is_variant_and.rs
index 25b2489d9421..52c7b56804ce 100644
--- a/src/tools/clippy/tests/ui/manual_is_variant_and.rs
+++ b/src/tools/clippy/tests/ui/manual_is_variant_and.rs
@@ -11,16 +11,20 @@ fn option_methods() {
     // Check for `option.map(_).unwrap_or_default()` use.
     // Single line case.
     let _ = opt.map(|x| x > 1)
+    //~^ manual_is_variant_and
         // Should lint even though this call is on a separate line.
         .unwrap_or_default();
     // Multi-line cases.
     let _ = opt.map(|x| {
+    //~^ manual_is_variant_and
         x > 1
     }
     ).unwrap_or_default();
     let _ = opt.map(|x| x > 1).unwrap_or_default();
+    //~^ manual_is_variant_and
     let _ = opt
         .map(|x| x > 1)
+        //~^ manual_is_variant_and
         .unwrap_or_default();
 
     // won't fix because the return type of the closure is not `bool`
@@ -28,6 +32,7 @@ fn option_methods() {
 
     let opt2 = Some('a');
     let _ = opt2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
+    //~^ manual_is_variant_and
     let _ = opt_map!(opt2, |x| x == 'a').unwrap_or_default(); // should not lint
 }
 
@@ -37,10 +42,12 @@ fn result_methods() {
 
     // multi line cases
     let _ = res.map(|x| {
+    //~^ manual_is_variant_and
         x > 1
     }
     ).unwrap_or_default();
     let _ = res.map(|x| x > 1)
+    //~^ manual_is_variant_and
         .unwrap_or_default();
 
     // won't fix because the return type of the closure is not `bool`
@@ -48,6 +55,7 @@ fn result_methods() {
 
     let res2: Result<char, ()> = Ok('a');
     let _ = res2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
+    //~^ manual_is_variant_and
     let _ = opt_map!(res2, |x| x == 'a').unwrap_or_default(); // should not lint
 }
 
diff --git a/src/tools/clippy/tests/ui/manual_is_variant_and.stderr b/src/tools/clippy/tests/ui/manual_is_variant_and.stderr
index d3ff7cf8b316..a4fa500580d0 100644
--- a/src/tools/clippy/tests/ui/manual_is_variant_and.stderr
+++ b/src/tools/clippy/tests/ui/manual_is_variant_and.stderr
@@ -3,7 +3,7 @@ error: called `map(<f>).unwrap_or_default()` on an `Option` value
    |
 LL |       let _ = opt.map(|x| x > 1)
    |  _________________^
-LL | |         // Should lint even though this call is on a separate line.
+...  |
 LL | |         .unwrap_or_default();
    | |____________________________^ help: use: `is_some_and(|x| x > 1)`
    |
@@ -11,10 +11,11 @@ LL | |         .unwrap_or_default();
    = help: to override `-D warnings` add `#[allow(clippy::manual_is_variant_and)]`
 
 error: called `map(<f>).unwrap_or_default()` on an `Option` value
-  --> tests/ui/manual_is_variant_and.rs:17:17
+  --> tests/ui/manual_is_variant_and.rs:18:17
    |
 LL |       let _ = opt.map(|x| {
    |  _________________^
+LL | |
 LL | |         x > 1
 LL | |     }
 LL | |     ).unwrap_or_default();
@@ -23,35 +24,38 @@ LL | |     ).unwrap_or_default();
 help: use
    |
 LL ~     let _ = opt.is_some_and(|x| {
+LL +
 LL +         x > 1
 LL ~     });
    |
 
 error: called `map(<f>).unwrap_or_default()` on an `Option` value
-  --> tests/ui/manual_is_variant_and.rs:21:17
+  --> tests/ui/manual_is_variant_and.rs:23:17
    |
 LL |     let _ = opt.map(|x| x > 1).unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `is_some_and(|x| x > 1)`
 
 error: called `map(<f>).unwrap_or_default()` on an `Option` value
-  --> tests/ui/manual_is_variant_and.rs:23:10
+  --> tests/ui/manual_is_variant_and.rs:26:10
    |
 LL |           .map(|x| x > 1)
    |  __________^
+LL | |
 LL | |         .unwrap_or_default();
    | |____________________________^ help: use: `is_some_and(|x| x > 1)`
 
 error: called `map(<f>).unwrap_or_default()` on an `Option` value
-  --> tests/ui/manual_is_variant_and.rs:30:18
+  --> tests/ui/manual_is_variant_and.rs:34:18
    |
 LL |     let _ = opt2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `is_some_and(char::is_alphanumeric)`
 
 error: called `map(<f>).unwrap_or_default()` on a `Result` value
-  --> tests/ui/manual_is_variant_and.rs:39:17
+  --> tests/ui/manual_is_variant_and.rs:44:17
    |
 LL |       let _ = res.map(|x| {
    |  _________________^
+LL | |
 LL | |         x > 1
 LL | |     }
 LL | |     ).unwrap_or_default();
@@ -60,20 +64,22 @@ LL | |     ).unwrap_or_default();
 help: use
    |
 LL ~     let _ = res.is_ok_and(|x| {
+LL +
 LL +         x > 1
 LL ~     });
    |
 
 error: called `map(<f>).unwrap_or_default()` on a `Result` value
-  --> tests/ui/manual_is_variant_and.rs:43:17
+  --> tests/ui/manual_is_variant_and.rs:49:17
    |
 LL |       let _ = res.map(|x| x > 1)
    |  _________________^
+LL | |
 LL | |         .unwrap_or_default();
    | |____________________________^ help: use: `is_ok_and(|x| x > 1)`
 
 error: called `map(<f>).unwrap_or_default()` on a `Result` value
-  --> tests/ui/manual_is_variant_and.rs:50:18
+  --> tests/ui/manual_is_variant_and.rs:57:18
    |
 LL |     let _ = res2.map(char::is_alphanumeric).unwrap_or_default(); // should lint
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `is_ok_and(char::is_alphanumeric)`
diff --git a/src/tools/clippy/tests/ui/manual_let_else.rs b/src/tools/clippy/tests/ui/manual_let_else.rs
index 2b36c3f3c2fb..d2350d97ed00 100644
--- a/src/tools/clippy/tests/ui/manual_let_else.rs
+++ b/src/tools/clippy/tests/ui/manual_let_else.rs
@@ -27,17 +27,19 @@ fn main() {}
 
 fn fire() {
     let v = if let Some(v_some) = g() { v_some } else { return };
-    //~^ ERROR: this could be rewritten as `let...else`
+    //~^ manual_let_else
 
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         return;
     };
 
     let v = if let Some(v) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         // Blocks around the identity should have no impact
         { { v } }
     } else {
@@ -49,18 +51,20 @@ fn fire() {
     // continue and break diverge
     loop {
         let v = if let Some(v_some) = g() { v_some } else { continue };
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         let v = if let Some(v_some) = g() { v_some } else { break };
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
     }
 
     // panic also diverges
     let v = if let Some(v_some) = g() { v_some } else { panic!() };
-    //~^ ERROR: this could be rewritten as `let...else`
+    //~^ manual_let_else
 
     // abort also diverges
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         std::process::abort()
@@ -68,7 +72,8 @@ fn fire() {
 
     // If whose two branches diverge also diverges
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         if true { return } else { panic!() }
@@ -76,7 +81,8 @@ fn fire() {
 
     // Diverging after an if still makes the block diverge:
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         if true {}
@@ -85,7 +91,8 @@ fn fire() {
 
     // The final expression will need to be turned into a statement.
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         panic!();
@@ -94,7 +101,8 @@ fn fire() {
 
     // Even if the result is buried multiple expressions deep.
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         panic!();
@@ -110,7 +118,8 @@ fn fire() {
 
     // Or if a break gives the value.
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         loop {
@@ -121,7 +130,8 @@ fn fire() {
 
     // Even if the break is in a weird position.
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         'a: loop {
@@ -137,7 +147,8 @@ fn fire() {
 
     // A match diverges if all branches diverge:
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         match 0 {
@@ -148,7 +159,8 @@ fn fire() {
 
     // An if's expression can cause divergence:
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         if panic!() {};
@@ -156,7 +168,8 @@ fn fire() {
 
     // An expression of a match can cause divergence:
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         match panic!() {
@@ -166,7 +179,8 @@ fn fire() {
 
     // Top level else if
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else if true {
         return;
@@ -176,7 +190,8 @@ fn fire() {
 
     // All match arms diverge
     let v = if let Some(v_some) = g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         match (g(), g()) {
@@ -194,7 +209,8 @@ fn fire() {
 
     // Tuples supported for the declared variables
     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         v_some
     } else {
         return;
@@ -202,7 +218,8 @@ fn fire() {
 
     // Tuples supported with multiple bindings
     let (w, S { v }) = if let (Some(v_some), w_some) = (g().map(|_| S { v: 0 }), 0) {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         (w_some, v_some)
     } else {
         return;
@@ -212,6 +229,7 @@ fn fire() {
     macro_rules! create_binding_if_some {
         ($n:ident, $e:expr) => {
             let $n = if let Some(v) = $e { v } else { return };
+            //~^ manual_let_else
         };
     }
     create_binding_if_some!(w, g());
@@ -221,31 +239,33 @@ fn fire() {
     }
 
     let v = if let Variant::A(a, 0) = e() { a } else { return };
-    //~^ ERROR: this could be rewritten as `let...else`
+    //~^ manual_let_else
 
     // `mut v` is inserted into the pattern
     let mut v = if let Variant::B(b) = e() { b } else { return };
-    //~^ ERROR: this could be rewritten as `let...else`
+    //~^ manual_let_else
 
     // Nesting works
     let nested = Ok(Some(e()));
     let v = if let Ok(Some(Variant::B(b))) | Err(Some(Variant::A(b, _))) = nested {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         b
     } else {
         return;
     };
     // dot dot works
     let v = if let Variant::A(.., a) = e() { a } else { return };
-    //~^ ERROR: this could be rewritten as `let...else`
+    //~^ manual_let_else
 
     // () is preserved: a bit of an edge case but make sure it stays around
     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
-    //~^ ERROR: this could be rewritten as `let...else`
+    //~^ manual_let_else
 
     // Tuple structs work
     let w = if let Some(S { v: x }) = Some(S { v: 0 }) {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         x
     } else {
         return;
@@ -253,7 +273,8 @@ fn fire() {
 
     // Field init shorthand is suggested
     let v = if let Some(S { v: x }) = Some(S { v: 0 }) {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         x
     } else {
         return;
@@ -261,7 +282,8 @@ fn fire() {
 
     // Multi-field structs also work
     let (x, S { v }, w) = if let Some(U { v, w, x }) = None::<U<S<()>>> {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
+
         (x, v, w)
     } else {
         return;
@@ -378,7 +400,7 @@ fn not_fire() {
 
     let ff = Some(1);
     let _ = match ff {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         Some(value) => value,
         _ => macro_call!(),
     };
@@ -455,5 +477,6 @@ fn issue12337() {
     // we still emit a lint for manual_let_else
     let _: Option<()> = try {
         let v = if let Some(v_some) = g() { v_some } else { return };
+        //~^ manual_let_else
     };
 }
diff --git a/src/tools/clippy/tests/ui/manual_let_else.stderr b/src/tools/clippy/tests/ui/manual_let_else.stderr
index dcd5d4561113..8f5cba64d545 100644
--- a/src/tools/clippy/tests/ui/manual_let_else.stderr
+++ b/src/tools/clippy/tests/ui/manual_let_else.stderr
@@ -12,6 +12,7 @@ error: this could be rewritten as `let...else`
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
 LL | |     } else {
 LL | |         return;
@@ -26,12 +27,9 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:39:5
+  --> tests/ui/manual_let_else.rs:40:5
    |
 LL | /     let v = if let Some(v) = g() {
-LL | |
-LL | |         // Blocks around the identity should have no impact
-LL | |         { { v } }
 ...  |
 LL | |         return;
 LL | |     };
@@ -47,28 +45,29 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:51:9
+  --> tests/ui/manual_let_else.rs:53:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { continue };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:53:9
+  --> tests/ui/manual_let_else.rs:56:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { break };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { break };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:58:5
+  --> tests/ui/manual_let_else.rs:61:5
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { panic!() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { panic!() };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:62:5
+  --> tests/ui/manual_let_else.rs:65:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
 LL | |     } else {
 LL | |         std::process::abort()
@@ -83,10 +82,11 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:70:5
+  --> tests/ui/manual_let_else.rs:74:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
 LL | |     } else {
 LL | |         if true { return } else { panic!() }
@@ -101,13 +101,13 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:78:5
+  --> tests/ui/manual_let_else.rs:83:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
-LL | |         if true {}
+...  |
 LL | |         panic!();
 LL | |     };
    | |______^
@@ -121,13 +121,13 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:87:5
+  --> tests/ui/manual_let_else.rs:93:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
-LL | |         panic!();
+...  |
 LL | |         ()
 LL | |     };
    | |______^
@@ -141,12 +141,12 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:96:5
+  --> tests/ui/manual_let_else.rs:103:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
 ...  |
 LL | |     };
    | |______^
@@ -167,12 +167,12 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:112:5
+  --> tests/ui/manual_let_else.rs:120:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
 ...  |
 LL | |     };
    | |______^
@@ -188,12 +188,12 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:123:5
+  --> tests/ui/manual_let_else.rs:132:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
 ...  |
 LL | |     };
    | |______^
@@ -214,12 +214,12 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:139:5
+  --> tests/ui/manual_let_else.rs:149:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
 ...  |
 LL | |         };
 LL | |     };
@@ -236,10 +236,11 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:150:5
+  --> tests/ui/manual_let_else.rs:161:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
 LL | |     } else {
 LL | |         if panic!() {};
@@ -254,12 +255,12 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:158:5
+  --> tests/ui/manual_let_else.rs:170:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
 ...  |
 LL | |         };
 LL | |     };
@@ -275,12 +276,12 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:168:5
+  --> tests/ui/manual_let_else.rs:181:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else if true {
 ...  |
 LL | |         panic!("diverge");
 LL | |     };
@@ -296,12 +297,12 @@ LL +     } };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:178:5
+  --> tests/ui/manual_let_else.rs:192:5
    |
 LL | /     let v = if let Some(v_some) = g() {
 LL | |
+LL | |
 LL | |         v_some
-LL | |     } else {
 ...  |
 LL | |     };
    | |______^
@@ -324,10 +325,11 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:196:5
+  --> tests/ui/manual_let_else.rs:211:5
    |
 LL | /     let (v, w) = if let Some(v_some) = g().map(|v| (v, 42)) {
 LL | |
+LL | |
 LL | |         v_some
 LL | |     } else {
 LL | |         return;
@@ -342,10 +344,11 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:204:5
+  --> tests/ui/manual_let_else.rs:220:5
    |
 LL | /     let (w, S { v }) = if let (Some(v_some), w_some) = (g().map(|_| S { v: 0 }), 0) {
 LL | |
+LL | |
 LL | |         (w_some, v_some)
 LL | |     } else {
 LL | |         return;
@@ -360,7 +363,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:214:13
+  --> tests/ui/manual_let_else.rs:231:13
    |
 LL |             let $n = if let Some(v) = $e { v } else { return };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some($n) = g() else { return };`
@@ -371,22 +374,23 @@ LL |     create_binding_if_some!(w, g());
    = note: this error originates in the macro `create_binding_if_some` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:223:5
+  --> tests/ui/manual_let_else.rs:241:5
    |
 LL |     let v = if let Variant::A(a, 0) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(v, 0) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:227:5
+  --> tests/ui/manual_let_else.rs:245:5
    |
 LL |     let mut v = if let Variant::B(b) = e() { b } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::B(mut v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:232:5
+  --> tests/ui/manual_let_else.rs:250:5
    |
 LL | /     let v = if let Ok(Some(Variant::B(b))) | Err(Some(Variant::A(b, _))) = nested {
 LL | |
+LL | |
 LL | |         b
 LL | |     } else {
 LL | |         return;
@@ -401,22 +405,23 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:239:5
+  --> tests/ui/manual_let_else.rs:258:5
    |
 LL |     let v = if let Variant::A(.., a) = e() { a } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Variant::A(.., v) = e() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:243:5
+  --> tests/ui/manual_let_else.rs:262:5
    |
 LL |     let w = if let (Some(v), ()) = (g(), ()) { v } else { return };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let (Some(w), ()) = (g(), ()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:247:5
+  --> tests/ui/manual_let_else.rs:266:5
    |
 LL | /     let w = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |
+LL | |
 LL | |         x
 LL | |     } else {
 LL | |         return;
@@ -431,10 +436,11 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:255:5
+  --> tests/ui/manual_let_else.rs:275:5
    |
 LL | /     let v = if let Some(S { v: x }) = Some(S { v: 0 }) {
 LL | |
+LL | |
 LL | |         x
 LL | |     } else {
 LL | |         return;
@@ -449,10 +455,11 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:263:5
+  --> tests/ui/manual_let_else.rs:284:5
    |
 LL | /     let (x, S { v }, w) = if let Some(U { v, w, x }) = None::<U<S<()>>> {
 LL | |
+LL | |
 LL | |         (x, v, w)
 LL | |     } else {
 LL | |         return;
@@ -467,7 +474,7 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:380:5
+  --> tests/ui/manual_let_else.rs:402:5
    |
 LL | /     let _ = match ff {
 LL | |
@@ -477,7 +484,7 @@ LL | |     };
    | |______^ help: consider writing: `let Some(_) = ff else { macro_call!() };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else.rs:457:9
+  --> tests/ui/manual_let_else.rs:479:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { return };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return };`
diff --git a/src/tools/clippy/tests/ui/manual_let_else_match.rs b/src/tools/clippy/tests/ui/manual_let_else_match.rs
index c37b5613ff7d..6416753bac10 100644
--- a/src/tools/clippy/tests/ui/manual_let_else_match.rs
+++ b/src/tools/clippy/tests/ui/manual_let_else_match.rs
@@ -34,14 +34,13 @@ fn main() {}
 
 fn fire() {
     let v = match g() {
-        //~^ ERROR: this could be rewritten as `let...else`
-        //~| NOTE: `-D clippy::manual-let-else` implied by `-D warnings`
+        //~^ manual_let_else
         Some(v_some) => v_some,
         None => return,
     };
 
     let v = match g() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         Some(v_some) => v_some,
         _ => return,
     };
@@ -49,13 +48,13 @@ fn fire() {
     loop {
         // More complex pattern for the identity arm and diverging arm
         let v = match h() {
-            //~^ ERROR: this could be rewritten as `let...else`
+            //~^ manual_let_else
             (Some(v), None) | (None, Some(v)) => v,
             (Some(_), Some(_)) | (None, None) => continue,
         };
         // Custom enums are supported as long as the "else" arm is a simple _
         let v = match build_enum() {
-            //~^ ERROR: this could be rewritten as `let...else`
+            //~^ manual_let_else
             Variant::Bar(v) | Variant::Baz(v) => v,
             _ => continue,
         };
@@ -64,14 +63,14 @@ fn fire() {
     // There is a _ in the diverging arm
     // TODO also support unused bindings aka _v
     let v = match f() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         Ok(v) => v,
         Err(_) => return,
     };
 
     // Err(()) is an allowed pattern
     let v = match f().map_err(|_| ()) {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         Ok(v) => v,
         Err(()) => return,
     };
@@ -79,20 +78,20 @@ fn fire() {
     let f = Variant::Bar(1);
 
     let _value = match f {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         Variant::Bar(v) | Variant::Baz(v) => v,
         _ => return,
     };
 
     let _value = match Some(build_enum()) {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         Some(Variant::Bar(v) | Variant::Baz(v)) => v,
         _ => return,
     };
 
     let data = [1_u8, 2, 3, 4, 0, 0, 0, 0];
     let data = match data.as_slice() {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         [data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0] => data,
         _ => return,
     };
@@ -173,7 +172,7 @@ fn not_fire() {
 
 fn issue11579() {
     let msg = match Some("hi") {
-        //~^ ERROR: this could be rewritten as `let...else`
+        //~^ manual_let_else
         Some(m) => m,
         _ => unreachable!("can't happen"),
     };
diff --git a/src/tools/clippy/tests/ui/manual_let_else_match.stderr b/src/tools/clippy/tests/ui/manual_let_else_match.stderr
index 3c0065f64033..393562c629ba 100644
--- a/src/tools/clippy/tests/ui/manual_let_else_match.stderr
+++ b/src/tools/clippy/tests/ui/manual_let_else_match.stderr
@@ -3,7 +3,6 @@ error: this could be rewritten as `let...else`
    |
 LL | /     let v = match g() {
 LL | |
-LL | |
 LL | |         Some(v_some) => v_some,
 LL | |         None => return,
 LL | |     };
@@ -13,7 +12,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::manual_let_else)]`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:43:5
+  --> tests/ui/manual_let_else_match.rs:42:5
    |
 LL | /     let v = match g() {
 LL | |
@@ -23,7 +22,7 @@ LL | |     };
    | |______^ help: consider writing: `let Some(v) = g() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:51:9
+  --> tests/ui/manual_let_else_match.rs:50:9
    |
 LL | /         let v = match h() {
 LL | |
@@ -33,7 +32,7 @@ LL | |         };
    | |__________^ help: consider writing: `let ((Some(v), None) | (None, Some(v))) = h() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:57:9
+  --> tests/ui/manual_let_else_match.rs:56:9
    |
 LL | /         let v = match build_enum() {
 LL | |
@@ -43,7 +42,7 @@ LL | |         };
    | |__________^ help: consider writing: `let (Variant::Bar(v) | Variant::Baz(v)) = build_enum() else { continue };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:66:5
+  --> tests/ui/manual_let_else_match.rs:65:5
    |
 LL | /     let v = match f() {
 LL | |
@@ -53,7 +52,7 @@ LL | |     };
    | |______^ help: consider writing: `let Ok(v) = f() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:73:5
+  --> tests/ui/manual_let_else_match.rs:72:5
    |
 LL | /     let v = match f().map_err(|_| ()) {
 LL | |
@@ -63,7 +62,7 @@ LL | |     };
    | |______^ help: consider writing: `let Ok(v) = f().map_err(|_| ()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:81:5
+  --> tests/ui/manual_let_else_match.rs:80:5
    |
 LL | /     let _value = match f {
 LL | |
@@ -73,7 +72,7 @@ LL | |     };
    | |______^ help: consider writing: `let (Variant::Bar(_value) | Variant::Baz(_value)) = f else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:87:5
+  --> tests/ui/manual_let_else_match.rs:86:5
    |
 LL | /     let _value = match Some(build_enum()) {
 LL | |
@@ -83,7 +82,7 @@ LL | |     };
    | |______^ help: consider writing: `let Some(Variant::Bar(_value) | Variant::Baz(_value)) = Some(build_enum()) else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:94:5
+  --> tests/ui/manual_let_else_match.rs:93:5
    |
 LL | /     let data = match data.as_slice() {
 LL | |
@@ -93,7 +92,7 @@ LL | |     };
    | |______^ help: consider writing: `let ([data @ .., 0, 0, 0, 0] | [data @ .., 0, 0] | [data @ .., 0]) = data.as_slice() else { return };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_match.rs:175:5
+  --> tests/ui/manual_let_else_match.rs:174:5
    |
 LL | /     let msg = match Some("hi") {
 LL | |
diff --git a/src/tools/clippy/tests/ui/manual_let_else_question_mark.fixed b/src/tools/clippy/tests/ui/manual_let_else_question_mark.fixed
index 6b29ce759857..aca32a49c13b 100644
--- a/src/tools/clippy/tests/ui/manual_let_else_question_mark.fixed
+++ b/src/tools/clippy/tests/ui/manual_let_else_question_mark.fixed
@@ -27,15 +27,18 @@ fn main() {}
 fn foo() -> Option<()> {
     // Fire here, normal case
     let v = g()?;
+    //~^ question_mark
 
     // Don't fire here, the pattern is refutable
     let Variant::A(v, w) = e() else { return None };
 
     // Fire here, the pattern is irrefutable
     let (v, w) = g()?;
+    //~^ question_mark
 
     // Don't fire manual_let_else in this instance: question mark can be used instead.
     let v = g()?;
+    //~^ question_mark
 
     // Do fire manual_let_else in this instance: question mark cannot be used here due to the return
     // body.
@@ -56,6 +59,7 @@ fn foo() -> Option<()> {
     #[allow(clippy::question_mark)]
     {
         let Some(v) = g() else { return None };
+        //~^ manual_let_else
     }
 
     Some(())
@@ -64,6 +68,7 @@ fn foo() -> Option<()> {
 // lint not just `return None`, but also `return None;` (note the semicolon)
 fn issue11993(y: Option<i32>) -> Option<i32> {
     let x = y?;
+    //~^^^ question_mark
 
     // don't lint: more than one statement in the else body
     let Some(x) = y else {
diff --git a/src/tools/clippy/tests/ui/manual_let_else_question_mark.rs b/src/tools/clippy/tests/ui/manual_let_else_question_mark.rs
index e92c4c1375e5..8b43d59816f9 100644
--- a/src/tools/clippy/tests/ui/manual_let_else_question_mark.rs
+++ b/src/tools/clippy/tests/ui/manual_let_else_question_mark.rs
@@ -27,19 +27,23 @@ fn main() {}
 fn foo() -> Option<()> {
     // Fire here, normal case
     let Some(v) = g() else { return None };
+    //~^ question_mark
 
     // Don't fire here, the pattern is refutable
     let Variant::A(v, w) = e() else { return None };
 
     // Fire here, the pattern is irrefutable
     let Some((v, w)) = g() else { return None };
+    //~^ question_mark
 
     // Don't fire manual_let_else in this instance: question mark can be used instead.
     let v = if let Some(v_some) = g() { v_some } else { return None };
+    //~^ question_mark
 
     // Do fire manual_let_else in this instance: question mark cannot be used here due to the return
     // body.
     let v = if let Some(v_some) = g() {
+        //~^ manual_let_else
         v_some
     } else {
         return Some(());
@@ -51,6 +55,7 @@ fn foo() -> Option<()> {
     #[allow(clippy::question_mark)]
     {
         let v = match g() {
+            //~^ manual_let_else
             Some(v_some) => v_some,
             _ => return None,
         };
@@ -61,6 +66,7 @@ fn foo() -> Option<()> {
     #[allow(clippy::question_mark)]
     {
         let v = if let Some(v_some) = g() { v_some } else { return None };
+        //~^ manual_let_else
     }
 
     Some(())
@@ -71,6 +77,7 @@ fn issue11993(y: Option<i32>) -> Option<i32> {
     let Some(x) = y else {
         return None;
     };
+    //~^^^ question_mark
 
     // don't lint: more than one statement in the else body
     let Some(x) = y else {
diff --git a/src/tools/clippy/tests/ui/manual_let_else_question_mark.stderr b/src/tools/clippy/tests/ui/manual_let_else_question_mark.stderr
index 434872ca2677..4fdd64d98491 100644
--- a/src/tools/clippy/tests/ui/manual_let_else_question_mark.stderr
+++ b/src/tools/clippy/tests/ui/manual_let_else_question_mark.stderr
@@ -8,21 +8,22 @@ LL |     let Some(v) = g() else { return None };
    = help: to override `-D warnings` add `#[allow(clippy::question_mark)]`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/manual_let_else_question_mark.rs:35:5
+  --> tests/ui/manual_let_else_question_mark.rs:36:5
    |
 LL |     let Some((v, w)) = g() else { return None };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `let (v, w) = g()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/manual_let_else_question_mark.rs:38:13
+  --> tests/ui/manual_let_else_question_mark.rs:40:13
    |
 LL |     let v = if let Some(v_some) = g() { v_some } else { return None };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `g()?`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_question_mark.rs:42:5
+  --> tests/ui/manual_let_else_question_mark.rs:45:5
    |
 LL | /     let v = if let Some(v_some) = g() {
+LL | |
 LL | |         v_some
 LL | |     } else {
 LL | |         return Some(());
@@ -39,22 +40,23 @@ LL +     };
    |
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_question_mark.rs:53:9
+  --> tests/ui/manual_let_else_question_mark.rs:57:9
    |
 LL | /         let v = match g() {
+LL | |
 LL | |             Some(v_some) => v_some,
 LL | |             _ => return None,
 LL | |         };
    | |__________^ help: consider writing: `let Some(v) = g() else { return None };`
 
 error: this could be rewritten as `let...else`
-  --> tests/ui/manual_let_else_question_mark.rs:63:9
+  --> tests/ui/manual_let_else_question_mark.rs:68:9
    |
 LL |         let v = if let Some(v_some) = g() { v_some } else { return None };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider writing: `let Some(v) = g() else { return None };`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/manual_let_else_question_mark.rs:71:5
+  --> tests/ui/manual_let_else_question_mark.rs:77:5
    |
 LL | /     let Some(x) = y else {
 LL | |         return None;
diff --git a/src/tools/clippy/tests/ui/manual_main_separator_str.fixed b/src/tools/clippy/tests/ui/manual_main_separator_str.fixed
index 6441d6edef8c..6e5478ad009e 100644
--- a/src/tools/clippy/tests/ui/manual_main_separator_str.fixed
+++ b/src/tools/clippy/tests/ui/manual_main_separator_str.fixed
@@ -19,12 +19,16 @@ struct V<T> {
 fn main() {
     // Should lint
     let _: &str = std::path::MAIN_SEPARATOR_STR;
+    //~^ manual_main_separator_str
     let _ = len(std::path::MAIN_SEPARATOR_STR);
+    //~^ manual_main_separator_str
     let _: Vec<u16> = std::path::MAIN_SEPARATOR_STR.encode_utf16().collect();
+    //~^ manual_main_separator_str
 
     // Should lint for field `f` only
     let _ = U {
         f: std::path::MAIN_SEPARATOR_STR,
+        //~^ manual_main_separator_str
         g: &MAIN_SEPARATOR.to_string(),
     };
 
diff --git a/src/tools/clippy/tests/ui/manual_main_separator_str.rs b/src/tools/clippy/tests/ui/manual_main_separator_str.rs
index 339dfd8bb473..170af2da143f 100644
--- a/src/tools/clippy/tests/ui/manual_main_separator_str.rs
+++ b/src/tools/clippy/tests/ui/manual_main_separator_str.rs
@@ -19,12 +19,16 @@ struct V<T> {
 fn main() {
     // Should lint
     let _: &str = &MAIN_SEPARATOR.to_string();
+    //~^ manual_main_separator_str
     let _ = len(&MAIN_SEPARATOR.to_string());
+    //~^ manual_main_separator_str
     let _: Vec<u16> = MAIN_SEPARATOR.to_string().encode_utf16().collect();
+    //~^ manual_main_separator_str
 
     // Should lint for field `f` only
     let _ = U {
         f: &MAIN_SEPARATOR.to_string(),
+        //~^ manual_main_separator_str
         g: &MAIN_SEPARATOR.to_string(),
     };
 
diff --git a/src/tools/clippy/tests/ui/manual_main_separator_str.stderr b/src/tools/clippy/tests/ui/manual_main_separator_str.stderr
index 78395eb7d664..1c58b8261d4f 100644
--- a/src/tools/clippy/tests/ui/manual_main_separator_str.stderr
+++ b/src/tools/clippy/tests/ui/manual_main_separator_str.stderr
@@ -8,19 +8,19 @@ LL |     let _: &str = &MAIN_SEPARATOR.to_string();
    = help: to override `-D warnings` add `#[allow(clippy::manual_main_separator_str)]`
 
 error: taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`
-  --> tests/ui/manual_main_separator_str.rs:22:17
+  --> tests/ui/manual_main_separator_str.rs:23:17
    |
 LL |     let _ = len(&MAIN_SEPARATOR.to_string());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::path::MAIN_SEPARATOR_STR`
 
 error: taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`
-  --> tests/ui/manual_main_separator_str.rs:23:23
+  --> tests/ui/manual_main_separator_str.rs:25:23
    |
 LL |     let _: Vec<u16> = MAIN_SEPARATOR.to_string().encode_utf16().collect();
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::path::MAIN_SEPARATOR_STR`
 
 error: taking a reference on `std::path::MAIN_SEPARATOR` conversion to `String`
-  --> tests/ui/manual_main_separator_str.rs:27:12
+  --> tests/ui/manual_main_separator_str.rs:30:12
    |
 LL |         f: &MAIN_SEPARATOR.to_string(),
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `std::path::MAIN_SEPARATOR_STR`
diff --git a/src/tools/clippy/tests/ui/manual_map_option.fixed b/src/tools/clippy/tests/ui/manual_map_option.fixed
index 16cee3fd3823..3586979ab358 100644
--- a/src/tools/clippy/tests/ui/manual_map_option.fixed
+++ b/src/tools/clippy/tests/ui/manual_map_option.fixed
@@ -113,7 +113,16 @@ fn main() {
     }
 
     // #6811
-    Some(0).map(|x| vec![x]);
+    match Some(0) {
+        Some(x) => Some(vec![x]),
+        None => None,
+    };
+
+    // Don't lint, coercion
+    let x: Option<Vec<&[u8]>> = match Some(()) {
+        Some(_) => Some(vec![b"1234"]),
+        None => None,
+    };
 
     option_env!("").map(String::from);
 
diff --git a/src/tools/clippy/tests/ui/manual_map_option.rs b/src/tools/clippy/tests/ui/manual_map_option.rs
index 4655acf1406c..9477d0d795d2 100644
--- a/src/tools/clippy/tests/ui/manual_map_option.rs
+++ b/src/tools/clippy/tests/ui/manual_map_option.rs
@@ -12,21 +12,25 @@
 
 fn main() {
     match Some(0) {
+        //~^ manual_map
         Some(_) => Some(2),
         None::<u32> => None,
     };
 
     match Some(0) {
+        //~^ manual_map
         Some(x) => Some(x + 1),
         _ => None,
     };
 
     match Some("") {
+        //~^ manual_map
         Some(x) => Some(x.is_empty()),
         None => None,
     };
 
     if let Some(x) = Some(0) {
+        //~^ manual_map
         Some(!x)
     } else {
         None
@@ -34,11 +38,13 @@ fn main() {
 
     #[rustfmt::skip]
     match Some(0) {
+    //~^ manual_map
         Some(x) => { Some(std::convert::identity(x)) }
         None => { None }
     };
 
     match Some(&String::new()) {
+        //~^ manual_map
         Some(x) => Some(str::len(x)),
         None => None,
     };
@@ -49,26 +55,31 @@ fn main() {
     };
 
     match &Some([0, 1]) {
+        //~^ manual_map
         Some(x) => Some(x[0]),
         &None => None,
     };
 
     match &Some(0) {
+        //~^ manual_map
         &Some(x) => Some(x * 2),
         None => None,
     };
 
     match Some(String::new()) {
+        //~^ manual_map
         Some(ref x) => Some(x.is_empty()),
         _ => None,
     };
 
     match &&Some(String::new()) {
+        //~^ manual_map
         Some(x) => Some(x.len()),
         _ => None,
     };
 
     match &&Some(0) {
+        //~^ manual_map
         &&Some(x) => Some(x + x),
         &&_ => None,
     };
@@ -82,32 +93,38 @@ fn main() {
     #[allow(clippy::option_map_unit_fn)]
     {
         match &mut Some(String::new()) {
+            //~^ manual_map
             Some(x) => Some(x.push_str("")),
             None => None,
         };
     }
 
     match &mut Some(String::new()) {
+        //~^ manual_map
         Some(ref x) => Some(x.len()),
         None => None,
     };
 
     match &mut &Some(String::new()) {
+        //~^ manual_map
         Some(x) => Some(x.is_empty()),
         &mut _ => None,
     };
 
     match Some((0, 1, 2)) {
+        //~^ manual_map
         Some((x, y, z)) => Some(x + y + z),
         None => None,
     };
 
     match Some([1, 2, 3]) {
+        //~^ manual_map
         Some([first, ..]) => Some(first),
         None => None,
     };
 
     match &Some((String::new(), "test")) {
+        //~^ manual_map
         Some((x, y)) => Some((y, x)),
         None => None,
     };
@@ -170,7 +187,14 @@ fn main() {
         None => None,
     };
 
+    // Don't lint, coercion
+    let x: Option<Vec<&[u8]>> = match Some(()) {
+        Some(_) => Some(vec![b"1234"]),
+        None => None,
+    };
+
     match option_env!("") {
+        //~^ manual_map
         Some(x) => Some(String::from(x)),
         None => None,
     };
@@ -191,6 +215,7 @@ fn main() {
     if let Some(_) = Some(0) {
         Some(0)
     } else if let Some(x) = Some(0) {
+        //~^ manual_map
         Some(x + 1)
     } else {
         None
@@ -199,6 +224,7 @@ fn main() {
     if true {
         Some(0)
     } else if let Some(x) = Some(0) {
+        //~^ manual_map
         Some(x + 1)
     } else {
         None
diff --git a/src/tools/clippy/tests/ui/manual_map_option.stderr b/src/tools/clippy/tests/ui/manual_map_option.stderr
index 47cc18303ba5..8f9bce4c265c 100644
--- a/src/tools/clippy/tests/ui/manual_map_option.stderr
+++ b/src/tools/clippy/tests/ui/manual_map_option.stderr
@@ -2,6 +2,7 @@ error: manual implementation of `Option::map`
   --> tests/ui/manual_map_option.rs:14:5
    |
 LL | /     match Some(0) {
+LL | |
 LL | |         Some(_) => Some(2),
 LL | |         None::<u32> => None,
 LL | |     };
@@ -11,27 +12,30 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::manual_map)]`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:19:5
+  --> tests/ui/manual_map_option.rs:20:5
    |
 LL | /     match Some(0) {
+LL | |
 LL | |         Some(x) => Some(x + 1),
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(0).map(|x| x + 1)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:24:5
+  --> tests/ui/manual_map_option.rs:26:5
    |
 LL | /     match Some("") {
+LL | |
 LL | |         Some(x) => Some(x.is_empty()),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some("").map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:29:5
+  --> tests/ui/manual_map_option.rs:32:5
    |
 LL | /     if let Some(x) = Some(0) {
+LL | |
 LL | |         Some(!x)
 LL | |     } else {
 LL | |         None
@@ -39,145 +43,151 @@ LL | |     };
    | |_____^ help: try: `Some(0).map(|x| !x)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:36:5
+  --> tests/ui/manual_map_option.rs:40:5
    |
 LL | /     match Some(0) {
+LL | |
 LL | |         Some(x) => { Some(std::convert::identity(x)) }
 LL | |         None => { None }
 LL | |     };
    | |_____^ help: try: `Some(0).map(std::convert::identity)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:41:5
+  --> tests/ui/manual_map_option.rs:46:5
    |
 LL | /     match Some(&String::new()) {
+LL | |
 LL | |         Some(x) => Some(str::len(x)),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(&String::new()).map(|x| str::len(x))`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:51:5
+  --> tests/ui/manual_map_option.rs:57:5
    |
 LL | /     match &Some([0, 1]) {
+LL | |
 LL | |         Some(x) => Some(x[0]),
 LL | |         &None => None,
 LL | |     };
    | |_____^ help: try: `Some([0, 1]).as_ref().map(|x| x[0])`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:56:5
+  --> tests/ui/manual_map_option.rs:63:5
    |
 LL | /     match &Some(0) {
+LL | |
 LL | |         &Some(x) => Some(x * 2),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(0).map(|x| x * 2)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:61:5
+  --> tests/ui/manual_map_option.rs:69:5
    |
 LL | /     match Some(String::new()) {
+LL | |
 LL | |         Some(ref x) => Some(x.is_empty()),
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:66:5
+  --> tests/ui/manual_map_option.rs:75:5
    |
 LL | /     match &&Some(String::new()) {
+LL | |
 LL | |         Some(x) => Some(x.len()),
 LL | |         _ => None,
 LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:71:5
+  --> tests/ui/manual_map_option.rs:81:5
    |
 LL | /     match &&Some(0) {
+LL | |
 LL | |         &&Some(x) => Some(x + x),
 LL | |         &&_ => None,
 LL | |     };
    | |_____^ help: try: `Some(0).map(|x| x + x)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:84:9
+  --> tests/ui/manual_map_option.rs:95:9
    |
 LL | /         match &mut Some(String::new()) {
+LL | |
 LL | |             Some(x) => Some(x.push_str("")),
 LL | |             None => None,
 LL | |         };
    | |_________^ help: try: `Some(String::new()).as_mut().map(|x| x.push_str(""))`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:90:5
+  --> tests/ui/manual_map_option.rs:102:5
    |
 LL | /     match &mut Some(String::new()) {
+LL | |
 LL | |         Some(ref x) => Some(x.len()),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.len())`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:95:5
+  --> tests/ui/manual_map_option.rs:108:5
    |
 LL | /     match &mut &Some(String::new()) {
+LL | |
 LL | |         Some(x) => Some(x.is_empty()),
 LL | |         &mut _ => None,
 LL | |     };
    | |_____^ help: try: `Some(String::new()).as_ref().map(|x| x.is_empty())`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:100:5
+  --> tests/ui/manual_map_option.rs:114:5
    |
 LL | /     match Some((0, 1, 2)) {
+LL | |
 LL | |         Some((x, y, z)) => Some(x + y + z),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some((0, 1, 2)).map(|(x, y, z)| x + y + z)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:105:5
+  --> tests/ui/manual_map_option.rs:120:5
    |
 LL | /     match Some([1, 2, 3]) {
+LL | |
 LL | |         Some([first, ..]) => Some(first),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some([1, 2, 3]).map(|[first, ..]| first)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:110:5
+  --> tests/ui/manual_map_option.rs:126:5
    |
 LL | /     match &Some((String::new(), "test")) {
+LL | |
 LL | |         Some((x, y)) => Some((y, x)),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some((String::new(), "test")).as_ref().map(|(x, y)| (y, x))`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:168:5
-   |
-LL | /     match Some(0) {
-LL | |         Some(x) => Some(vec![x]),
-LL | |         None => None,
-LL | |     };
-   | |_____^ help: try: `Some(0).map(|x| vec![x])`
-
-error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:173:5
+  --> tests/ui/manual_map_option.rs:196:5
    |
 LL | /     match option_env!("") {
+LL | |
 LL | |         Some(x) => Some(String::from(x)),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `option_env!("").map(String::from)`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:193:12
+  --> tests/ui/manual_map_option.rs:217:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
+LL | |
 LL | |         Some(x + 1)
 LL | |     } else {
 LL | |         None
@@ -185,15 +195,16 @@ LL | |     };
    | |_____^ help: try: `{ Some(0).map(|x| x + 1) }`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option.rs:201:12
+  --> tests/ui/manual_map_option.rs:226:12
    |
 LL |       } else if let Some(x) = Some(0) {
    |  ____________^
+LL | |
 LL | |         Some(x + 1)
 LL | |     } else {
 LL | |         None
 LL | |     };
    | |_____^ help: try: `{ Some(0).map(|x| x + 1) }`
 
-error: aborting due to 21 previous errors
+error: aborting due to 20 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_map_option_2.fixed b/src/tools/clippy/tests/ui/manual_map_option_2.fixed
index f5bb4e0af1ba..d698cc74ea65 100644
--- a/src/tools/clippy/tests/ui/manual_map_option_2.fixed
+++ b/src/tools/clippy/tests/ui/manual_map_option_2.fixed
@@ -40,9 +40,14 @@ fn main() {
         None => None,
     };
 
-    // Lint. `s` is captured by reference, so no lifetime issues.
     let s = Some(String::new());
+    // Lint. `s` is captured by reference, so no lifetime issues.
     let _ = s.as_ref().map(|x| { if let Some(ref s) = s { (x.clone(), s) } else { panic!() } });
+    // Don't lint this, type of `s` is coercioned from `&String` to `&str`
+    let x: Option<(String, &str)> = match &s {
+        Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+        None => None,
+    };
 
     // Issue #7820
     unsafe fn f(x: u32) -> u32 {
@@ -54,3 +59,87 @@ fn main() {
     let _ = Some(0).map(|x| unsafe { f(x) });
     let _ = Some(0).map(|x| unsafe { f(x) });
 }
+
+// issue #12659
+mod with_type_coercion {
+    trait DummyTrait {}
+
+    fn foo<T: DummyTrait, F: Fn() -> Result<T, ()>>(f: F) {
+        // Don't lint
+        let _: Option<Result<Box<dyn DummyTrait>, ()>> = match Some(0) {
+            Some(_) => Some(match f() {
+                Ok(res) => Ok(Box::new(res)),
+                _ => Err(()),
+            }),
+            None => None,
+        };
+
+        let _: Option<Box<&[u8]>> = match Some(()) {
+            Some(_) => Some(Box::new(b"1234")),
+            None => None,
+        };
+
+        let x = String::new();
+        let _: Option<Box<&str>> = match Some(()) {
+            Some(_) => Some(Box::new(&x)),
+            None => None,
+        };
+
+        let _: Option<&str> = match Some(()) {
+            Some(_) => Some(&x),
+            None => None,
+        };
+
+        let _ = Some(0).map(|_| match f() {
+                Ok(res) => Ok(Box::new(res)),
+                _ => Err(()),
+            });
+    }
+
+    #[allow(clippy::redundant_allocation)]
+    fn bar() {
+        fn f(_: Option<Box<&[u8]>>) {}
+        fn g(b: &[u8]) -> Box<&[u8]> {
+            Box::new(b)
+        }
+
+        let x: &[u8; 4] = b"1234";
+        f(match Some(()) {
+            Some(_) => Some(Box::new(x)),
+            None => None,
+        });
+
+        let _: Option<Box<&[u8]>> = Some(0).map(|_| g(x));
+    }
+
+    fn with_fn_ret(s: &Option<String>) -> Option<(String, &str)> {
+        // Don't lint, `map` doesn't work as the return type is adjusted.
+        match s {
+            Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+            None => None,
+        }
+    }
+
+    fn with_fn_ret_2(s: &Option<String>) -> Option<(String, &str)> {
+        if true {
+            // Don't lint, `map` doesn't work as the return type is adjusted.
+            return match s {
+                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                None => None,
+            };
+        }
+        None
+    }
+
+    #[allow(clippy::needless_late_init)]
+    fn with_fn_ret_3<'a>(s: &'a Option<String>) -> Option<(String, &'a str)> {
+        let x: Option<(String, &'a str)>;
+        x = {
+            match s {
+                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                None => None,
+            }
+        };
+        x
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_map_option_2.rs b/src/tools/clippy/tests/ui/manual_map_option_2.rs
index cbc2356e0a2d..069c2381f6db 100644
--- a/src/tools/clippy/tests/ui/manual_map_option_2.rs
+++ b/src/tools/clippy/tests/ui/manual_map_option_2.rs
@@ -4,6 +4,7 @@
 fn main() {
     // Lint. `y` is declared within the arm, so it isn't captured by the map closure
     let _ = match Some(0) {
+        //~^ manual_map
         Some(x) => Some({
             let y = (String::new(), String::new());
             (x, y.0)
@@ -43,9 +44,15 @@ fn main() {
         None => None,
     };
 
-    // Lint. `s` is captured by reference, so no lifetime issues.
     let s = Some(String::new());
+    // Lint. `s` is captured by reference, so no lifetime issues.
     let _ = match &s {
+        //~^ manual_map
+        Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+        None => None,
+    };
+    // Don't lint this, type of `s` is coercioned from `&String` to `&str`
+    let x: Option<(String, &str)> = match &s {
         Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
         None => None,
     };
@@ -56,16 +63,111 @@ fn main() {
     }
     unsafe {
         let _ = match Some(0) {
+            //~^ manual_map
             Some(x) => Some(f(x)),
             None => None,
         };
     }
     let _ = match Some(0) {
+        //~^ manual_map
         Some(x) => unsafe { Some(f(x)) },
         None => None,
     };
     let _ = match Some(0) {
+        //~^ manual_map
         Some(x) => Some(unsafe { f(x) }),
         None => None,
     };
 }
+
+// issue #12659
+mod with_type_coercion {
+    trait DummyTrait {}
+
+    fn foo<T: DummyTrait, F: Fn() -> Result<T, ()>>(f: F) {
+        // Don't lint
+        let _: Option<Result<Box<dyn DummyTrait>, ()>> = match Some(0) {
+            Some(_) => Some(match f() {
+                Ok(res) => Ok(Box::new(res)),
+                _ => Err(()),
+            }),
+            None => None,
+        };
+
+        let _: Option<Box<&[u8]>> = match Some(()) {
+            Some(_) => Some(Box::new(b"1234")),
+            None => None,
+        };
+
+        let x = String::new();
+        let _: Option<Box<&str>> = match Some(()) {
+            Some(_) => Some(Box::new(&x)),
+            None => None,
+        };
+
+        let _: Option<&str> = match Some(()) {
+            Some(_) => Some(&x),
+            None => None,
+        };
+
+        let _ = match Some(0) {
+            //~^ manual_map
+            Some(_) => Some(match f() {
+                Ok(res) => Ok(Box::new(res)),
+                _ => Err(()),
+            }),
+            None => None,
+        };
+    }
+
+    #[allow(clippy::redundant_allocation)]
+    fn bar() {
+        fn f(_: Option<Box<&[u8]>>) {}
+        fn g(b: &[u8]) -> Box<&[u8]> {
+            Box::new(b)
+        }
+
+        let x: &[u8; 4] = b"1234";
+        f(match Some(()) {
+            Some(_) => Some(Box::new(x)),
+            None => None,
+        });
+
+        let _: Option<Box<&[u8]>> = match Some(0) {
+            //~^ manual_map
+            Some(_) => Some(g(x)),
+            None => None,
+        };
+    }
+
+    fn with_fn_ret(s: &Option<String>) -> Option<(String, &str)> {
+        // Don't lint, `map` doesn't work as the return type is adjusted.
+        match s {
+            Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+            None => None,
+        }
+    }
+
+    fn with_fn_ret_2(s: &Option<String>) -> Option<(String, &str)> {
+        if true {
+            // Don't lint, `map` doesn't work as the return type is adjusted.
+            return match s {
+                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                None => None,
+            };
+        }
+        None
+    }
+
+    #[allow(clippy::needless_late_init)]
+    fn with_fn_ret_3<'a>(s: &'a Option<String>) -> Option<(String, &'a str)> {
+        let x: Option<(String, &'a str)>;
+        x = {
+            match s {
+                Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
+                None => None,
+            }
+        };
+        x
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_map_option_2.stderr b/src/tools/clippy/tests/ui/manual_map_option_2.stderr
index 78e4677544bc..c9e040ce1d0e 100644
--- a/src/tools/clippy/tests/ui/manual_map_option_2.stderr
+++ b/src/tools/clippy/tests/ui/manual_map_option_2.stderr
@@ -3,10 +3,10 @@ error: manual implementation of `Option::map`
    |
 LL |       let _ = match Some(0) {
    |  _____________^
+LL | |
 LL | |         Some(x) => Some({
 LL | |             let y = (String::new(), String::new());
-LL | |             (x, y.0)
-LL | |         }),
+...  |
 LL | |         None => None,
 LL | |     };
    | |_____^
@@ -22,44 +22,80 @@ LL ~         });
    |
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option_2.rs:48:13
+  --> tests/ui/manual_map_option_2.rs:49:13
    |
 LL |       let _ = match &s {
    |  _____________^
+LL | |
 LL | |         Some(x) => Some({ if let Some(ref s) = s { (x.clone(), s) } else { panic!() } }),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `s.as_ref().map(|x| { if let Some(ref s) = s { (x.clone(), s) } else { panic!() } })`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option_2.rs:58:17
+  --> tests/ui/manual_map_option_2.rs:65:17
    |
 LL |           let _ = match Some(0) {
    |  _________________^
+LL | |
 LL | |             Some(x) => Some(f(x)),
 LL | |             None => None,
 LL | |         };
    | |_________^ help: try: `Some(0).map(|x| f(x))`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option_2.rs:63:13
+  --> tests/ui/manual_map_option_2.rs:71:13
    |
 LL |       let _ = match Some(0) {
    |  _____________^
+LL | |
 LL | |         Some(x) => unsafe { Some(f(x)) },
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(0).map(|x| unsafe { f(x) })`
 
 error: manual implementation of `Option::map`
-  --> tests/ui/manual_map_option_2.rs:67:13
+  --> tests/ui/manual_map_option_2.rs:76:13
    |
 LL |       let _ = match Some(0) {
    |  _____________^
+LL | |
 LL | |         Some(x) => Some(unsafe { f(x) }),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: try: `Some(0).map(|x| unsafe { f(x) })`
 
-error: aborting due to 5 previous errors
+error: manual implementation of `Option::map`
+  --> tests/ui/manual_map_option_2.rs:113:17
+   |
+LL |           let _ = match Some(0) {
+   |  _________________^
+LL | |
+LL | |             Some(_) => Some(match f() {
+LL | |                 Ok(res) => Ok(Box::new(res)),
+...  |
+LL | |             None => None,
+LL | |         };
+   | |_________^
+   |
+help: try
+   |
+LL ~         let _ = Some(0).map(|_| match f() {
+LL +                 Ok(res) => Ok(Box::new(res)),
+LL +                 _ => Err(()),
+LL ~             });
+   |
+
+error: manual implementation of `Option::map`
+  --> tests/ui/manual_map_option_2.rs:136:37
+   |
+LL |           let _: Option<Box<&[u8]>> = match Some(0) {
+   |  _____________________________________^
+LL | |
+LL | |             Some(_) => Some(g(x)),
+LL | |             None => None,
+LL | |         };
+   | |_________^ help: try: `Some(0).map(|_| g(x))`
+
+error: aborting due to 7 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.rs b/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.rs
index 786d7e6e2445..c83a26cab21a 100644
--- a/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.rs
+++ b/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.rs
@@ -3,57 +3,64 @@
 pub fn manual_copy_with_counters(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     let mut count = 0;
     for i in 3..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
-        //~| NOTE: `-D clippy::manual-memcpy` implied by `-D warnings`
+        //~^ manual_memcpy
+
         dst[i] = src[count];
         count += 1;
     }
 
     let mut count = 0;
     for i in 3..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[count] = src[i];
         count += 1;
     }
 
     let mut count = 3;
     for i in 0..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[count] = src[i];
         count += 1;
     }
 
     let mut count = 3;
     for i in 0..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[count];
         count += 1;
     }
 
     let mut count = 0;
     for i in 3..(3 + src.len()) {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[count];
         count += 1;
     }
 
     let mut count = 3;
     for i in 5..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[count - 2];
         count += 1;
     }
 
     let mut count = 2;
     for i in 0..dst.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[count];
         count += 1;
     }
 
     let mut count = 5;
     for i in 3..10 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[count];
         count += 1;
     }
@@ -61,7 +68,8 @@ pub fn manual_copy_with_counters(src: &[i32], dst: &mut [i32], dst2: &mut [i32])
     let mut count = 3;
     let mut count2 = 30;
     for i in 0..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[count] = src[i];
         dst2[count2] = src[i];
         count += 1;
@@ -72,7 +80,8 @@ pub fn manual_copy_with_counters(src: &[i32], dst: &mut [i32], dst2: &mut [i32])
     // arithmetic ones
     let mut count = 0 << 1;
     for i in 0..1 << 1 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[count] = src[i + 2];
         count += 1;
     }
@@ -80,7 +89,8 @@ pub fn manual_copy_with_counters(src: &[i32], dst: &mut [i32], dst2: &mut [i32])
     // make sure incrementing expressions without semicolons at the end of loops are handled correctly.
     let mut count = 0;
     for i in 3..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[count];
         count += 1
     }
diff --git a/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.stderr b/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.stderr
index 41a991e9688f..70da8309f398 100644
--- a/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.stderr
+++ b/src/tools/clippy/tests/ui/manual_memcpy/with_loop_counters.stderr
@@ -17,79 +17,86 @@ error: it looks like you're manually copying between slices
    |
 LL | /     for i in 3..src.len() {
 LL | |
+LL | |
 LL | |         dst[count] = src[i];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..(src.len() - 3)].copy_from_slice(&src[3..]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:20:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:21:5
    |
 LL | /     for i in 0..src.len() {
 LL | |
+LL | |
 LL | |         dst[count] = src[i];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[3..(src.len() + 3)].copy_from_slice(&src[..]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:27:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:29:5
    |
 LL | /     for i in 0..src.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..src.len()].copy_from_slice(&src[3..(src.len() + 3)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:34:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:37:5
    |
 LL | /     for i in 3..(3 + src.len()) {
 LL | |
+LL | |
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[3..(3 + src.len())].copy_from_slice(&src[..(3 + src.len() - 3)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:41:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:45:5
    |
 LL | /     for i in 5..src.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[count - 2];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[5..src.len()].copy_from_slice(&src[(3 - 2)..((src.len() - 2) + 3 - 5)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:48:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:53:5
    |
 LL | /     for i in 0..dst.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[2..(dst.len() + 2)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:55:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:61:5
    |
 LL | /     for i in 3..10 {
 LL | |
+LL | |
 LL | |         dst[i] = src[count];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[3..10].copy_from_slice(&src[5..(10 + 5 - 3)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:63:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:70:5
    |
 LL | /     for i in 0..src.len() {
 LL | |
+LL | |
 LL | |         dst[count] = src[i];
-LL | |         dst2[count2] = src[i];
-LL | |         count += 1;
+...  |
 LL | |         count2 += 1;
 LL | |     }
    | |_____^
@@ -101,20 +108,22 @@ LL +     dst2[30..(src.len() + 30)].copy_from_slice(&src[..]);
    |
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:74:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:82:5
    |
 LL | /     for i in 0..1 << 1 {
 LL | |
+LL | |
 LL | |         dst[count] = src[i + 2];
 LL | |         count += 1;
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[(0 << 1)..((1 << 1) + (0 << 1))].copy_from_slice(&src[2..((1 << 1) + 2)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/with_loop_counters.rs:82:5
+  --> tests/ui/manual_memcpy/with_loop_counters.rs:91:5
    |
 LL | /     for i in 3..src.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[count];
 LL | |         count += 1
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.rs b/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.rs
index 2f8640cd3f50..a3b8763812d7 100644
--- a/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.rs
+++ b/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.rs
@@ -12,32 +12,36 @@ const LOOP_OFFSET: usize = 5000;
 pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     // plain manual memcpy
     for i in 0..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
-        //~| NOTE: `-D clippy::manual-memcpy` implied by `-D warnings`
+        //~^ manual_memcpy
+
         dst[i] = src[i];
     }
 
     // dst offset memcpy
     for i in 0..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i + 10] = src[i];
     }
 
     // src offset memcpy
     for i in 0..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i + 10];
     }
 
     // src offset memcpy
     for i in 11..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i - 10];
     }
 
     // overwrite entire dst
     for i in 0..dst.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i];
     }
 
@@ -51,7 +55,8 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
 
     // multiple copies - suggest two memcpy statements
     for i in 10..256 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i - 5];
         dst2[i + 500] = src[i]
     }
@@ -64,7 +69,8 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     let some_var = 5;
     // Offset in variable
     for i in 10..LOOP_OFFSET {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i + LOOP_OFFSET] = src[i - some_var];
     }
 
@@ -78,7 +84,8 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
 
     // make sure vectors are supported
     for i in 0..src_vec.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst_vec[i] = src_vec[i];
     }
 
@@ -108,24 +115,28 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     let from = 1;
 
     for i in from..from + src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i - from];
     }
 
     for i in from..from + 3 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i - from];
     }
 
     #[allow(clippy::identity_op)]
     for i in 0..5 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i - 0] = src[i];
     }
 
     #[allow(clippy::reversed_empty_ranges)]
     for i in 0..0 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i];
     }
 
@@ -149,19 +160,22 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     let src = [0, 1, 2, 3, 4];
     let mut dst = [0; 4];
     for i in 0..4 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i];
     }
 
     let mut dst = [0; 6];
     for i in 0..5 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i];
     }
 
     let mut dst = [0; 5];
     for i in 0..5 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i];
     }
 
@@ -208,13 +222,15 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
     let src = [[0; 5]; 5];
     let mut dst = [0; 5];
     for i in 0..5 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[0][i];
     }
 
     let src = [[[0; 5]; 5]; 5];
     for i in 0..5 {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[0][1][i];
     }
 }
@@ -222,7 +238,8 @@ pub fn manual_copy(src: &[i32], dst: &mut [i32], dst2: &mut [i32]) {
 #[warn(clippy::needless_range_loop, clippy::manual_memcpy)]
 pub fn manual_clone(src: &[String], dst: &mut [String]) {
     for i in 0..src.len() {
-        //~^ ERROR: it looks like you're manually copying between slices
+        //~^ manual_memcpy
+
         dst[i] = src[i].clone();
     }
 }
diff --git a/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.stderr b/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.stderr
index c881e3fac769..0e656dcbc63a 100644
--- a/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.stderr
+++ b/src/tools/clippy/tests/ui/manual_memcpy/without_loop_counters.stderr
@@ -16,42 +16,47 @@ error: it looks like you're manually copying between slices
    |
 LL | /     for i in 0..src.len() {
 LL | |
+LL | |
 LL | |         dst[i + 10] = src[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[10..(src.len() + 10)].copy_from_slice(&src[..]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:27:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:28:5
    |
 LL | /     for i in 0..src.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[i + 10];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..src.len()].copy_from_slice(&src[10..(src.len() + 10)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:33:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:35:5
    |
 LL | /     for i in 11..src.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[i - 10];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[11..src.len()].copy_from_slice(&src[(11 - 10)..(src.len() - 10)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:39:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:42:5
    |
 LL | /     for i in 0..dst.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[..dst.len()]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:53:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:57:5
    |
 LL | /     for i in 10..256 {
 LL | |
+LL | |
 LL | |         dst[i] = src[i - 5];
 LL | |         dst2[i + 500] = src[i]
 LL | |     }
@@ -64,109 +69,121 @@ LL +     dst2[(10 + 500)..(256 + 500)].copy_from_slice(&src[10..256]);
    |
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:66:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:71:5
    |
 LL | /     for i in 10..LOOP_OFFSET {
 LL | |
+LL | |
 LL | |         dst[i + LOOP_OFFSET] = src[i - some_var];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[(10 + LOOP_OFFSET)..(LOOP_OFFSET + LOOP_OFFSET)].copy_from_slice(&src[(10 - some_var)..(LOOP_OFFSET - some_var)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:80:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:86:5
    |
 LL | /     for i in 0..src_vec.len() {
 LL | |
+LL | |
 LL | |         dst_vec[i] = src_vec[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst_vec[..src_vec.len()].copy_from_slice(&src_vec[..]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:110:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:117:5
    |
 LL | /     for i in from..from + src.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[i - from];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[from..(from + src.len())].copy_from_slice(&src[..(from + src.len() - from)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:115:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:123:5
    |
 LL | /     for i in from..from + 3 {
 LL | |
+LL | |
 LL | |         dst[i] = src[i - from];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[from..(from + 3)].copy_from_slice(&src[..(from + 3 - from)]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:121:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:130:5
    |
 LL | /     for i in 0..5 {
 LL | |
+LL | |
 LL | |         dst[i - 0] = src[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..5].copy_from_slice(&src);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:127:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:137:5
    |
 LL | /     for i in 0..0 {
 LL | |
+LL | |
 LL | |         dst[i] = src[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..0].copy_from_slice(&src[..0]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:151:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:162:5
    |
 LL | /     for i in 0..4 {
 LL | |
+LL | |
 LL | |         dst[i] = src[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[..4]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:157:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:169:5
    |
 LL | /     for i in 0..5 {
 LL | |
+LL | |
 LL | |         dst[i] = src[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..5].copy_from_slice(&src);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:163:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:176:5
    |
 LL | /     for i in 0..5 {
 LL | |
+LL | |
 LL | |         dst[i] = src[i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:210:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:224:5
    |
 LL | /     for i in 0..5 {
 LL | |
+LL | |
 LL | |         dst[i] = src[0][i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[0]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:216:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:231:5
    |
 LL | /     for i in 0..5 {
 LL | |
+LL | |
 LL | |         dst[i] = src[0][1][i];
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst.copy_from_slice(&src[0][1]);`
 
 error: it looks like you're manually copying between slices
-  --> tests/ui/manual_memcpy/without_loop_counters.rs:224:5
+  --> tests/ui/manual_memcpy/without_loop_counters.rs:240:5
    |
 LL | /     for i in 0..src.len() {
 LL | |
+LL | |
 LL | |         dst[i] = src[i].clone();
 LL | |     }
    | |_____^ help: try replacing the loop by: `dst[..src.len()].clone_from_slice(&src[..]);`
diff --git a/src/tools/clippy/tests/ui/manual_midpoint.fixed b/src/tools/clippy/tests/ui/manual_midpoint.fixed
new file mode 100644
index 000000000000..63116ced8438
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_midpoint.fixed
@@ -0,0 +1,74 @@
+#![warn(clippy::manual_midpoint)]
+
+macro_rules! mac {
+    ($a: expr, $b: expr) => {
+        ($a + $b) / 2
+    };
+}
+
+macro_rules! add {
+    ($a: expr, $b: expr) => {
+        ($a + $b)
+    };
+}
+
+macro_rules! two {
+    () => {
+        2
+    };
+}
+
+#[clippy::msrv = "1.84"]
+fn older_msrv() {
+    let a: u32 = 10;
+    let _ = (a + 5) / 2;
+}
+
+#[clippy::msrv = "1.85"]
+fn main() {
+    let a: u32 = 10;
+    let _ = u32::midpoint(a, 5); //~ ERROR: manual implementation of `midpoint`
+
+    let f: f32 = 10.0;
+    let _ = f32::midpoint(f, 5.0); //~ ERROR: manual implementation of `midpoint`
+
+    let _: u32 = 5 + u32::midpoint(8, 8) + 2; //~ ERROR: manual implementation of `midpoint`
+    let _: u32 = const { u32::midpoint(8, 8) }; //~ ERROR: manual implementation of `midpoint`
+    let _: f64 = const { f64::midpoint(8.0f64, 8.) }; //~ ERROR: manual implementation of `midpoint`
+    let _: u32 = u32::midpoint(u32::default(), u32::default()); //~ ERROR: manual implementation of `midpoint`
+    let _: u32 = u32::midpoint(two!(), two!()); //~ ERROR: manual implementation of `midpoint`
+
+    // Do not lint in presence of an addition with more than 2 operands
+    let _: u32 = (10 + 20 + 30) / 2;
+
+    // Do not lint if whole or part is coming from a macro
+    let _ = mac!(10, 20);
+    let _: u32 = add!(10u32, 20u32) / 2;
+    let _: u32 = (10 + 20) / two!();
+
+    // Do not lint if a literal is not present
+    let _ = (f + 5.0) / (1.0 + 1.0);
+
+    // Do not lint on signed integer types
+    let i: i32 = 10;
+    let _ = (i + 5) / 2;
+
+    // Do not lint on (x+1)/2 or (1+x)/2 as this looks more like a `div_ceil()` operation
+    let _ = (i + 1) / 2;
+    let _ = (1 + i) / 2;
+
+    // But if we see (x+1.0)/2.0 or (x+1.0)/2.0, it is probably a midpoint operation
+    let _ = f32::midpoint(f, 1.0); //~ ERROR: manual implementation of `midpoint`
+    let _ = f32::midpoint(1.0, f); //~ ERROR: manual implementation of `midpoint`
+}
+
+#[clippy::msrv = "1.86"]
+fn older_signed_midpoint(i: i32) {
+    // Do not lint
+    let _ = (i + 10) / 2;
+}
+
+#[clippy::msrv = "1.87"]
+fn signed_midpoint(i: i32) {
+    let _ = i32::midpoint(i, 10); //~ ERROR: manual implementation of `midpoint`
+}
diff --git a/src/tools/clippy/tests/ui/manual_midpoint.rs b/src/tools/clippy/tests/ui/manual_midpoint.rs
new file mode 100644
index 000000000000..47f1b88c78cd
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_midpoint.rs
@@ -0,0 +1,74 @@
+#![warn(clippy::manual_midpoint)]
+
+macro_rules! mac {
+    ($a: expr, $b: expr) => {
+        ($a + $b) / 2
+    };
+}
+
+macro_rules! add {
+    ($a: expr, $b: expr) => {
+        ($a + $b)
+    };
+}
+
+macro_rules! two {
+    () => {
+        2
+    };
+}
+
+#[clippy::msrv = "1.84"]
+fn older_msrv() {
+    let a: u32 = 10;
+    let _ = (a + 5) / 2;
+}
+
+#[clippy::msrv = "1.85"]
+fn main() {
+    let a: u32 = 10;
+    let _ = (a + 5) / 2; //~ ERROR: manual implementation of `midpoint`
+
+    let f: f32 = 10.0;
+    let _ = (f + 5.0) / 2.0; //~ ERROR: manual implementation of `midpoint`
+
+    let _: u32 = 5 + (8 + 8) / 2 + 2; //~ ERROR: manual implementation of `midpoint`
+    let _: u32 = const { (8 + 8) / 2 }; //~ ERROR: manual implementation of `midpoint`
+    let _: f64 = const { (8.0f64 + 8.) / 2. }; //~ ERROR: manual implementation of `midpoint`
+    let _: u32 = (u32::default() + u32::default()) / 2; //~ ERROR: manual implementation of `midpoint`
+    let _: u32 = (two!() + two!()) / 2; //~ ERROR: manual implementation of `midpoint`
+
+    // Do not lint in presence of an addition with more than 2 operands
+    let _: u32 = (10 + 20 + 30) / 2;
+
+    // Do not lint if whole or part is coming from a macro
+    let _ = mac!(10, 20);
+    let _: u32 = add!(10u32, 20u32) / 2;
+    let _: u32 = (10 + 20) / two!();
+
+    // Do not lint if a literal is not present
+    let _ = (f + 5.0) / (1.0 + 1.0);
+
+    // Do not lint on signed integer types
+    let i: i32 = 10;
+    let _ = (i + 5) / 2;
+
+    // Do not lint on (x+1)/2 or (1+x)/2 as this looks more like a `div_ceil()` operation
+    let _ = (i + 1) / 2;
+    let _ = (1 + i) / 2;
+
+    // But if we see (x+1.0)/2.0 or (x+1.0)/2.0, it is probably a midpoint operation
+    let _ = (f + 1.0) / 2.0; //~ ERROR: manual implementation of `midpoint`
+    let _ = (1.0 + f) / 2.0; //~ ERROR: manual implementation of `midpoint`
+}
+
+#[clippy::msrv = "1.86"]
+fn older_signed_midpoint(i: i32) {
+    // Do not lint
+    let _ = (i + 10) / 2;
+}
+
+#[clippy::msrv = "1.87"]
+fn signed_midpoint(i: i32) {
+    let _ = (i + 10) / 2; //~ ERROR: manual implementation of `midpoint`
+}
diff --git a/src/tools/clippy/tests/ui/manual_midpoint.stderr b/src/tools/clippy/tests/ui/manual_midpoint.stderr
new file mode 100644
index 000000000000..3d588e2114df
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_midpoint.stderr
@@ -0,0 +1,65 @@
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:30:13
+   |
+LL |     let _ = (a + 5) / 2;
+   |             ^^^^^^^^^^^ help: use `u32::midpoint` instead: `u32::midpoint(a, 5)`
+   |
+   = note: `-D clippy::manual-midpoint` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_midpoint)]`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:33:13
+   |
+LL |     let _ = (f + 5.0) / 2.0;
+   |             ^^^^^^^^^^^^^^^ help: use `f32::midpoint` instead: `f32::midpoint(f, 5.0)`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:35:22
+   |
+LL |     let _: u32 = 5 + (8 + 8) / 2 + 2;
+   |                      ^^^^^^^^^^^ help: use `u32::midpoint` instead: `u32::midpoint(8, 8)`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:36:26
+   |
+LL |     let _: u32 = const { (8 + 8) / 2 };
+   |                          ^^^^^^^^^^^ help: use `u32::midpoint` instead: `u32::midpoint(8, 8)`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:37:26
+   |
+LL |     let _: f64 = const { (8.0f64 + 8.) / 2. };
+   |                          ^^^^^^^^^^^^^^^^^^ help: use `f64::midpoint` instead: `f64::midpoint(8.0f64, 8.)`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:38:18
+   |
+LL |     let _: u32 = (u32::default() + u32::default()) / 2;
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `u32::midpoint` instead: `u32::midpoint(u32::default(), u32::default())`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:39:18
+   |
+LL |     let _: u32 = (two!() + two!()) / 2;
+   |                  ^^^^^^^^^^^^^^^^^^^^^ help: use `u32::midpoint` instead: `u32::midpoint(two!(), two!())`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:61:13
+   |
+LL |     let _ = (f + 1.0) / 2.0;
+   |             ^^^^^^^^^^^^^^^ help: use `f32::midpoint` instead: `f32::midpoint(f, 1.0)`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:62:13
+   |
+LL |     let _ = (1.0 + f) / 2.0;
+   |             ^^^^^^^^^^^^^^^ help: use `f32::midpoint` instead: `f32::midpoint(1.0, f)`
+
+error: manual implementation of `midpoint` which can overflow
+  --> tests/ui/manual_midpoint.rs:73:13
+   |
+LL |     let _ = (i + 10) / 2;
+   |             ^^^^^^^^^^^^ help: use `i32::midpoint` instead: `i32::midpoint(i, 10)`
+
+error: aborting due to 10 previous errors
+
diff --git a/src/tools/clippy/tests/ui/manual_next_back.fixed b/src/tools/clippy/tests/ui/manual_next_back.fixed
index 75828f355d90..153fbc6fd071 100644
--- a/src/tools/clippy/tests/ui/manual_next_back.fixed
+++ b/src/tools/clippy/tests/ui/manual_next_back.fixed
@@ -30,5 +30,7 @@ fn main() {
 
     // should lint
     let _ = (0..10).next_back().unwrap();
+    //~^ manual_next_back
     let _ = "something".bytes().next_back();
+    //~^ manual_next_back
 }
diff --git a/src/tools/clippy/tests/ui/manual_next_back.rs b/src/tools/clippy/tests/ui/manual_next_back.rs
index b980e90e1144..ca71d6a24773 100644
--- a/src/tools/clippy/tests/ui/manual_next_back.rs
+++ b/src/tools/clippy/tests/ui/manual_next_back.rs
@@ -30,5 +30,7 @@ fn main() {
 
     // should lint
     let _ = (0..10).rev().next().unwrap();
+    //~^ manual_next_back
     let _ = "something".bytes().rev().next();
+    //~^ manual_next_back
 }
diff --git a/src/tools/clippy/tests/ui/manual_next_back.stderr b/src/tools/clippy/tests/ui/manual_next_back.stderr
index c7e1ceca437c..4ac7b0d21244 100644
--- a/src/tools/clippy/tests/ui/manual_next_back.stderr
+++ b/src/tools/clippy/tests/ui/manual_next_back.stderr
@@ -8,7 +8,7 @@ LL |     let _ = (0..10).rev().next().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::manual_next_back)]`
 
 error: manual backwards iteration
-  --> tests/ui/manual_next_back.rs:33:32
+  --> tests/ui/manual_next_back.rs:34:32
    |
 LL |     let _ = "something".bytes().rev().next();
    |                                ^^^^^^^^^^^^^ help: use: `.next_back()`
diff --git a/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.rs b/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.rs
index ffe2bb924673..bb22165d478f 100644
--- a/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.rs
+++ b/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.rs
@@ -27,6 +27,7 @@ pub enum NoDocHidden {
 
 // name of variant with doc hidden does not start with underscore
 pub enum NoUnderscore {
+    //~^ manual_non_exhaustive
     A,
     B,
     #[doc(hidden)]
diff --git a/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr b/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr
index 0a9ac157f850..0f91f24b4a34 100644
--- a/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr
+++ b/src/tools/clippy/tests/ui/manual_non_exhaustive_enum.stderr
@@ -27,6 +27,7 @@ error: this seems like a manual implementation of the non-exhaustive pattern
   --> tests/ui/manual_non_exhaustive_enum.rs:29:1
    |
 LL | / pub enum NoUnderscore {
+LL | |
 LL | |     A,
 LL | |     B,
 LL | |     #[doc(hidden)]
@@ -35,7 +36,7 @@ LL | | }
    | |_^
    |
 help: remove this variant
-  --> tests/ui/manual_non_exhaustive_enum.rs:33:5
+  --> tests/ui/manual_non_exhaustive_enum.rs:34:5
    |
 LL |     C,
    |     ^
diff --git a/src/tools/clippy/tests/ui/manual_ok_err.fixed b/src/tools/clippy/tests/ui/manual_ok_err.fixed
index e7e0464c4787..bc169b64be9f 100644
--- a/src/tools/clippy/tests/ui/manual_ok_err.fixed
+++ b/src/tools/clippy/tests/ui/manual_ok_err.fixed
@@ -89,3 +89,12 @@ const fn cf(x: Result<u32, &'static str>) -> Option<u32> {
         Err(_) => None,
     }
 }
+
+fn issue14239() {
+    let _ = if false {
+        None
+    } else {
+        "1".parse::<u8>().ok()
+    };
+    //~^^^^^ manual_ok_err
+}
diff --git a/src/tools/clippy/tests/ui/manual_ok_err.rs b/src/tools/clippy/tests/ui/manual_ok_err.rs
index 03ad773f47cf..03c730d4b4e4 100644
--- a/src/tools/clippy/tests/ui/manual_ok_err.rs
+++ b/src/tools/clippy/tests/ui/manual_ok_err.rs
@@ -31,6 +31,7 @@ fn main() {
 
     let _ = if let Ok(v) = funcall() {
         //~^ manual_ok_err
+
         Some(v)
     } else {
         None
@@ -38,6 +39,7 @@ fn main() {
 
     let _ = if let Err(v) = funcall() {
         //~^ manual_ok_err
+
         Some(v)
     } else {
         None
@@ -123,3 +125,14 @@ const fn cf(x: Result<u32, &'static str>) -> Option<u32> {
         Err(_) => None,
     }
 }
+
+fn issue14239() {
+    let _ = if false {
+        None
+    } else if let Ok(n) = "1".parse::<u8>() {
+        Some(n)
+    } else {
+        None
+    };
+    //~^^^^^ manual_ok_err
+}
diff --git a/src/tools/clippy/tests/ui/manual_ok_err.stderr b/src/tools/clippy/tests/ui/manual_ok_err.stderr
index d0d5e2c81e96..13fceacda107 100644
--- a/src/tools/clippy/tests/ui/manual_ok_err.stderr
+++ b/src/tools/clippy/tests/ui/manual_ok_err.stderr
@@ -51,6 +51,7 @@ error: manual implementation of `ok`
 LL |       let _ = if let Ok(v) = funcall() {
    |  _____________^
 LL | |
+LL | |
 LL | |         Some(v)
 LL | |     } else {
 LL | |         None
@@ -58,11 +59,12 @@ LL | |     };
    | |_____^ help: replace with: `funcall().ok()`
 
 error: manual implementation of `err`
-  --> tests/ui/manual_ok_err.rs:39:13
+  --> tests/ui/manual_ok_err.rs:40:13
    |
 LL |       let _ = if let Err(v) = funcall() {
    |  _____________^
 LL | |
+LL | |
 LL | |         Some(v)
 LL | |     } else {
 LL | |         None
@@ -70,7 +72,7 @@ LL | |     };
    | |_____^ help: replace with: `funcall().err()`
 
 error: manual implementation of `ok`
-  --> tests/ui/manual_ok_err.rs:47:13
+  --> tests/ui/manual_ok_err.rs:49:13
    |
 LL |       let _ = match funcall() {
    |  _____________^
@@ -81,7 +83,7 @@ LL | |     };
    | |_____^ help: replace with: `funcall().ok()`
 
 error: manual implementation of `ok`
-  --> tests/ui/manual_ok_err.rs:64:13
+  --> tests/ui/manual_ok_err.rs:66:13
    |
 LL |       let _ = match -S {
    |  _____________^
@@ -91,5 +93,23 @@ LL | |         _ => None,
 LL | |     };
    | |_____^ help: replace with: `(-S).ok()`
 
-error: aborting due to 8 previous errors
+error: manual implementation of `ok`
+  --> tests/ui/manual_ok_err.rs:132:12
+   |
+LL |       } else if let Ok(n) = "1".parse::<u8>() {
+   |  ____________^
+LL | |         Some(n)
+LL | |     } else {
+LL | |         None
+LL | |     };
+   | |_____^
+   |
+help: replace with
+   |
+LL ~     } else {
+LL +         "1".parse::<u8>().ok()
+LL ~     };
+   |
+
+error: aborting due to 9 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_ok_or.fixed b/src/tools/clippy/tests/ui/manual_ok_or.fixed
index cc53cb416a22..f326822149cd 100644
--- a/src/tools/clippy/tests/ui/manual_ok_or.fixed
+++ b/src/tools/clippy/tests/ui/manual_ok_or.fixed
@@ -9,12 +9,15 @@ fn main() {
     // basic case
     let foo: Option<i32> = None;
     foo.ok_or("error");
+    //~^ manual_ok_or
 
     // eta expansion case
     foo.ok_or("error");
+    //~^ manual_ok_or
 
     // turbo fish syntax
     None::<i32>.ok_or("error");
+    //~^ manual_ok_or
 
     // multiline case
     #[rustfmt::skip]
diff --git a/src/tools/clippy/tests/ui/manual_ok_or.rs b/src/tools/clippy/tests/ui/manual_ok_or.rs
index 39c61a1e490f..7d065eda0ea1 100644
--- a/src/tools/clippy/tests/ui/manual_ok_or.rs
+++ b/src/tools/clippy/tests/ui/manual_ok_or.rs
@@ -9,16 +9,20 @@ fn main() {
     // basic case
     let foo: Option<i32> = None;
     foo.map_or(Err("error"), |v| Ok(v));
+    //~^ manual_ok_or
 
     // eta expansion case
     foo.map_or(Err("error"), Ok);
+    //~^ manual_ok_or
 
     // turbo fish syntax
     None::<i32>.map_or(Err("error"), |v| Ok(v));
+    //~^ manual_ok_or
 
     // multiline case
     #[rustfmt::skip]
     foo.map_or(Err::<i32, &str>(
+    //~^ manual_ok_or
         &format!(
             "{}{}{}{}{}{}{}",
             "Alice", "Bob", "Sarah", "Marc", "Sandra", "Eric", "Jenifer")
diff --git a/src/tools/clippy/tests/ui/manual_ok_or.stderr b/src/tools/clippy/tests/ui/manual_ok_or.stderr
index 2441a75b5c46..e8176f4c31fa 100644
--- a/src/tools/clippy/tests/ui/manual_ok_or.stderr
+++ b/src/tools/clippy/tests/ui/manual_ok_or.stderr
@@ -8,34 +8,25 @@ LL |     foo.map_or(Err("error"), |v| Ok(v));
    = help: to override `-D warnings` add `#[allow(clippy::manual_ok_or)]`
 
 error: this pattern reimplements `Option::ok_or`
-  --> tests/ui/manual_ok_or.rs:14:5
+  --> tests/ui/manual_ok_or.rs:15:5
    |
 LL |     foo.map_or(Err("error"), Ok);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `foo.ok_or("error")`
 
-error: called `map_or(Err(_), Ok)` on an `Option` value
-  --> tests/ui/manual_ok_or.rs:14:5
-   |
-LL |     foo.map_or(Err("error"), Ok);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `ok_or`: `foo.ok_or("error")`
-   |
-   = note: `-D clippy::option-map-or-err-ok` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::option_map_or_err_ok)]`
-
 error: this pattern reimplements `Option::ok_or`
-  --> tests/ui/manual_ok_or.rs:17:5
+  --> tests/ui/manual_ok_or.rs:19:5
    |
 LL |     None::<i32>.map_or(Err("error"), |v| Ok(v));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `None::<i32>.ok_or("error")`
 
 error: this pattern reimplements `Option::ok_or`
-  --> tests/ui/manual_ok_or.rs:21:5
+  --> tests/ui/manual_ok_or.rs:24:5
    |
 LL | /     foo.map_or(Err::<i32, &str>(
+LL | |
 LL | |         &format!(
 LL | |             "{}{}{}{}{}{}{}",
-LL | |             "Alice", "Bob", "Sarah", "Marc", "Sandra", "Eric", "Jenifer")
-LL | |         ),
+...  |
 LL | |         |v| Ok(v),
 LL | |     );
    | |_____^
@@ -47,5 +38,5 @@ LL +         "{}{}{}{}{}{}{}",
 LL ~         "Alice", "Bob", "Sarah", "Marc", "Sandra", "Eric", "Jenifer"));
    |
 
-error: aborting due to 5 previous errors
+error: aborting due to 4 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_option_as_slice.rs b/src/tools/clippy/tests/ui/manual_option_as_slice.rs
index 561a8b534014..e1a97a6b2711 100644
--- a/src/tools/clippy/tests/ui/manual_option_as_slice.rs
+++ b/src/tools/clippy/tests/ui/manual_option_as_slice.rs
@@ -10,6 +10,7 @@ fn check(x: Option<u32>) {
 
     _ = if let Some(f) = x.as_ref() {
         //~^ manual_option_as_slice
+
         std::slice::from_ref(f)
     } else {
         &[]
diff --git a/src/tools/clippy/tests/ui/manual_option_as_slice.stderr b/src/tools/clippy/tests/ui/manual_option_as_slice.stderr
index 569269d3e2b7..e240ae8eb7d9 100644
--- a/src/tools/clippy/tests/ui/manual_option_as_slice.stderr
+++ b/src/tools/clippy/tests/ui/manual_option_as_slice.stderr
@@ -18,6 +18,7 @@ error: use `Option::as_slice`
 LL |       _ = if let Some(f) = x.as_ref() {
    |  _________^
 LL | |
+LL | |
 LL | |         std::slice::from_ref(f)
 LL | |     } else {
 LL | |         &[]
@@ -25,31 +26,31 @@ LL | |     };
    | |_____^ help: use: `x.as_slice()`
 
 error: use `Option::as_slice`
-  --> tests/ui/manual_option_as_slice.rs:18:9
+  --> tests/ui/manual_option_as_slice.rs:19:9
    |
 LL |     _ = x.as_ref().map_or(&[][..], std::slice::from_ref);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.as_slice()`
 
 error: use `Option::as_slice`
-  --> tests/ui/manual_option_as_slice.rs:21:9
+  --> tests/ui/manual_option_as_slice.rs:22:9
    |
 LL |     _ = x.as_ref().map_or_else(Default::default, std::slice::from_ref);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.as_slice()`
 
 error: use `Option::as_slice`
-  --> tests/ui/manual_option_as_slice.rs:24:9
+  --> tests/ui/manual_option_as_slice.rs:25:9
    |
 LL |     _ = x.as_ref().map(std::slice::from_ref).unwrap_or_default();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.as_slice()`
 
 error: use `Option::as_slice`
-  --> tests/ui/manual_option_as_slice.rs:27:9
+  --> tests/ui/manual_option_as_slice.rs:28:9
    |
 LL |     _ = x.as_ref().map_or_else(|| &[42][..0], std::slice::from_ref);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.as_slice()`
 
 error: use `Option::as_slice`
-  --> tests/ui/manual_option_as_slice.rs:32:13
+  --> tests/ui/manual_option_as_slice.rs:33:13
    |
 LL |         _ = x.as_ref().map_or_else(<&[_]>::default, from_ref);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `x.as_slice()`
diff --git a/src/tools/clippy/tests/ui/manual_pattern_char_comparison.fixed b/src/tools/clippy/tests/ui/manual_pattern_char_comparison.fixed
index 03e621d95ba1..b03e83e6b99d 100644
--- a/src/tools/clippy/tests/ui/manual_pattern_char_comparison.fixed
+++ b/src/tools/clippy/tests/ui/manual_pattern_char_comparison.fixed
@@ -9,16 +9,25 @@ impl NotStr {
 fn main() {
     let sentence = "Hello, world!";
     sentence.trim_end_matches(['.', ',', '!', '?']);
+    //~^ manual_pattern_char_comparison
     sentence.split(['\n', 'X']);
+    //~^ manual_pattern_char_comparison
     sentence.split(['\n', 'X']);
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, 'X');
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, |c: char| c.is_whitespace() || c == 'X');
     let char_compare = 'X';
     sentence.splitn(3, char_compare);
+    //~^ manual_pattern_char_comparison
     sentence.split(['\n', 'X', 'Y']);
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, 'X');
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, ['X', 'W']);
+    //~^ manual_pattern_char_comparison
     sentence.find('🎈');
+    //~^ manual_pattern_char_comparison
 
     let not_str = NotStr;
     not_str.find(|c: char| c == 'X');
@@ -58,4 +67,5 @@ fn msrv_1_57() {
 fn msrv_1_58() {
     let sentence = "Hello, world!";
     sentence.trim_end_matches(['.', ',', '!', '?']);
+    //~^ manual_pattern_char_comparison
 }
diff --git a/src/tools/clippy/tests/ui/manual_pattern_char_comparison.rs b/src/tools/clippy/tests/ui/manual_pattern_char_comparison.rs
index 43e883cd325a..451480df4225 100644
--- a/src/tools/clippy/tests/ui/manual_pattern_char_comparison.rs
+++ b/src/tools/clippy/tests/ui/manual_pattern_char_comparison.rs
@@ -9,16 +9,25 @@ impl NotStr {
 fn main() {
     let sentence = "Hello, world!";
     sentence.trim_end_matches(|c: char| c == '.' || c == ',' || c == '!' || c == '?');
+    //~^ manual_pattern_char_comparison
     sentence.split(|c: char| c == '\n' || c == 'X');
+    //~^ manual_pattern_char_comparison
     sentence.split(|c| c == '\n' || c == 'X');
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, |c: char| c == 'X');
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, |c: char| c.is_whitespace() || c == 'X');
     let char_compare = 'X';
     sentence.splitn(3, |c: char| c == char_compare);
+    //~^ manual_pattern_char_comparison
     sentence.split(|c: char| matches!(c, '\n' | 'X' | 'Y'));
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, |c: char| matches!(c, 'X'));
+    //~^ manual_pattern_char_comparison
     sentence.splitn(3, |c: char| matches!(c, 'X' | 'W'));
+    //~^ manual_pattern_char_comparison
     sentence.find(|c| c == '🎈');
+    //~^ manual_pattern_char_comparison
 
     let not_str = NotStr;
     not_str.find(|c: char| c == 'X');
@@ -58,4 +67,5 @@ fn msrv_1_57() {
 fn msrv_1_58() {
     let sentence = "Hello, world!";
     sentence.trim_end_matches(|c: char| c == '.' || c == ',' || c == '!' || c == '?');
+    //~^ manual_pattern_char_comparison
 }
diff --git a/src/tools/clippy/tests/ui/manual_pattern_char_comparison.stderr b/src/tools/clippy/tests/ui/manual_pattern_char_comparison.stderr
index f185d7c8f676..d4fc3faa066f 100644
--- a/src/tools/clippy/tests/ui/manual_pattern_char_comparison.stderr
+++ b/src/tools/clippy/tests/ui/manual_pattern_char_comparison.stderr
@@ -8,55 +8,55 @@ LL |     sentence.trim_end_matches(|c: char| c == '.' || c == ',' || c == '!' ||
    = help: to override `-D warnings` add `#[allow(clippy::manual_pattern_char_comparison)]`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:12:20
+  --> tests/ui/manual_pattern_char_comparison.rs:13:20
    |
 LL |     sentence.split(|c: char| c == '\n' || c == 'X');
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using an array of `char`: `['\n', 'X']`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:13:20
+  --> tests/ui/manual_pattern_char_comparison.rs:15:20
    |
 LL |     sentence.split(|c| c == '\n' || c == 'X');
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using an array of `char`: `['\n', 'X']`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:14:24
+  --> tests/ui/manual_pattern_char_comparison.rs:17:24
    |
 LL |     sentence.splitn(3, |c: char| c == 'X');
    |                        ^^^^^^^^^^^^^^^^^^ help: consider using a `char`: `'X'`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:17:24
+  --> tests/ui/manual_pattern_char_comparison.rs:21:24
    |
 LL |     sentence.splitn(3, |c: char| c == char_compare);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a `char`: `char_compare`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:18:20
+  --> tests/ui/manual_pattern_char_comparison.rs:23:20
    |
 LL |     sentence.split(|c: char| matches!(c, '\n' | 'X' | 'Y'));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using an array of `char`: `['\n', 'X', 'Y']`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:19:24
+  --> tests/ui/manual_pattern_char_comparison.rs:25:24
    |
 LL |     sentence.splitn(3, |c: char| matches!(c, 'X'));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a `char`: `'X'`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:20:24
+  --> tests/ui/manual_pattern_char_comparison.rs:27:24
    |
 LL |     sentence.splitn(3, |c: char| matches!(c, 'X' | 'W'));
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using an array of `char`: `['X', 'W']`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:21:19
+  --> tests/ui/manual_pattern_char_comparison.rs:29:19
    |
 LL |     sentence.find(|c| c == '🎈');
    |                   ^^^^^^^^^^^^^ help: consider using a `char`: `'🎈'`
 
 error: this manual char comparison can be written more succinctly
-  --> tests/ui/manual_pattern_char_comparison.rs:60:31
+  --> tests/ui/manual_pattern_char_comparison.rs:69:31
    |
 LL |     sentence.trim_end_matches(|c: char| c == '.' || c == ',' || c == '!' || c == '?');
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using an array of `char`: `['.', ',', '!', '?']`
diff --git a/src/tools/clippy/tests/ui/manual_range_patterns.fixed b/src/tools/clippy/tests/ui/manual_range_patterns.fixed
index 60467bf9e884..c05e1fb27b03 100644
--- a/src/tools/clippy/tests/ui/manual_range_patterns.fixed
+++ b/src/tools/clippy/tests/ui/manual_range_patterns.fixed
@@ -6,7 +6,9 @@ fn main() {
     let f = 6;
 
     let _ = matches!(f, 1..=10);
+    //~^ manual_range_patterns
     let _ = matches!(f, 1..=10);
+    //~^ manual_range_patterns
     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
     let _ = matches!(f, | 4);
     let _ = matches!(f, 4 | 5);
@@ -14,34 +16,51 @@ fn main() {
     let _ = matches!(f, 0 | 2147483647);
     let _ = matches!(f, -2147483647 | 2147483647);
     let _ = matches!(f, 1..=4);
+    //~^ manual_range_patterns
     let _ = matches!(f, 1..4);
+    //~^ manual_range_patterns
     let _ = matches!(f, 1..=48324729);
+    //~^ manual_range_patterns
     let _ = matches!(f, 0..=48324730);
+    //~^ manual_range_patterns
     let _ = matches!(f, 0..=3);
+    //~^ manual_range_patterns
     #[allow(clippy::match_like_matches_macro)]
     let _ = match f {
         1..=10 => true,
+        //~^ manual_range_patterns
         _ => false,
     };
     let _ = matches!(f, -5..=3);
+    //~^ manual_range_patterns
     let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1); // 2 is missing
     let _ = matches!(f, -1_000_001..=1_000_001);
+    //~^ manual_range_patterns
     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_002);
 
     matches!(f, 0x00..=0x03);
+    //~^ manual_range_patterns
     matches!(f, 0x00..=0x07);
+    //~^ manual_range_patterns
     matches!(f, -0x09..=0x00);
+    //~^ manual_range_patterns
 
     matches!(f, 0..=5);
+    //~^ manual_range_patterns
     matches!(f, 0..5);
+    //~^ manual_range_patterns
 
     matches!(f, 0..10);
+    //~^ manual_range_patterns
     matches!(f, 0..=10);
+    //~^ manual_range_patterns
     matches!(f, 0..=10);
+    //~^ manual_range_patterns
 
     macro_rules! mac {
         ($e:expr) => {
             matches!($e, 1..=10)
+            //~^ manual_range_patterns
         };
     }
     mac!(f);
diff --git a/src/tools/clippy/tests/ui/manual_range_patterns.rs b/src/tools/clippy/tests/ui/manual_range_patterns.rs
index 9cd803334499..e5c403dc5f2e 100644
--- a/src/tools/clippy/tests/ui/manual_range_patterns.rs
+++ b/src/tools/clippy/tests/ui/manual_range_patterns.rs
@@ -6,7 +6,9 @@ fn main() {
     let f = 6;
 
     let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
+    //~^ manual_range_patterns
     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
+    //~^ manual_range_patterns
     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 8 | 10); // 7 is missing
     let _ = matches!(f, | 4);
     let _ = matches!(f, 4 | 5);
@@ -14,34 +16,51 @@ fn main() {
     let _ = matches!(f, 0 | 2147483647);
     let _ = matches!(f, -2147483647 | 2147483647);
     let _ = matches!(f, 1 | (2..=4));
+    //~^ manual_range_patterns
     let _ = matches!(f, 1 | (2..4));
+    //~^ manual_range_patterns
     let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
+    //~^ manual_range_patterns
     let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
+    //~^ manual_range_patterns
     let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
+    //~^ manual_range_patterns
     #[allow(clippy::match_like_matches_macro)]
     let _ = match f {
         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
+        //~^ manual_range_patterns
         _ => false,
     };
     let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1 | 2);
+    //~^ manual_range_patterns
     let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1); // 2 is missing
     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_001);
+    //~^ manual_range_patterns
     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_002);
 
     matches!(f, 0x00 | 0x01 | 0x02 | 0x03);
+    //~^ manual_range_patterns
     matches!(f, 0x00..=0x05 | 0x06 | 0x07);
+    //~^ manual_range_patterns
     matches!(f, -0x09 | -0x08 | -0x07..=0x00);
+    //~^ manual_range_patterns
 
     matches!(f, 0..5 | 5);
+    //~^ manual_range_patterns
     matches!(f, 0 | 1..5);
+    //~^ manual_range_patterns
 
     matches!(f, 0..=5 | 6..10);
+    //~^ manual_range_patterns
     matches!(f, 0..5 | 5..=10);
+    //~^ manual_range_patterns
     matches!(f, 5..=10 | 0..5);
+    //~^ manual_range_patterns
 
     macro_rules! mac {
         ($e:expr) => {
             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
+            //~^ manual_range_patterns
         };
     }
     mac!(f);
diff --git a/src/tools/clippy/tests/ui/manual_range_patterns.stderr b/src/tools/clippy/tests/ui/manual_range_patterns.stderr
index 7c19fdd475f1..e494e7234d68 100644
--- a/src/tools/clippy/tests/ui/manual_range_patterns.stderr
+++ b/src/tools/clippy/tests/ui/manual_range_patterns.stderr
@@ -8,109 +8,109 @@ LL |     let _ = matches!(f, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10);
    = help: to override `-D warnings` add `#[allow(clippy::manual_range_patterns)]`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:9:25
+  --> tests/ui/manual_range_patterns.rs:10:25
    |
 LL |     let _ = matches!(f, 4 | 2 | 3 | 1 | 5 | 6 | 9 | 7 | 8 | 10);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:16:25
+  --> tests/ui/manual_range_patterns.rs:18:25
    |
 LL |     let _ = matches!(f, 1 | (2..=4));
    |                         ^^^^^^^^^^^ help: try: `1..=4`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:17:25
+  --> tests/ui/manual_range_patterns.rs:20:25
    |
 LL |     let _ = matches!(f, 1 | (2..4));
    |                         ^^^^^^^^^^ help: try: `1..4`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:18:25
+  --> tests/ui/manual_range_patterns.rs:22:25
    |
 LL |     let _ = matches!(f, (1..=10) | (2..=13) | (14..=48324728) | 48324729);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=48324729`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:19:25
+  --> tests/ui/manual_range_patterns.rs:24:25
    |
 LL |     let _ = matches!(f, 0 | (1..=10) | 48324730 | (2..=13) | (14..=48324728) | 48324729);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=48324730`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:20:25
+  --> tests/ui/manual_range_patterns.rs:26:25
    |
 LL |     let _ = matches!(f, 0..=1 | 0..=2 | 0..=3);
    |                         ^^^^^^^^^^^^^^^^^^^^^ help: try: `0..=3`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:23:9
+  --> tests/ui/manual_range_patterns.rs:30:9
    |
 LL |         1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10 => true,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:26:25
+  --> tests/ui/manual_range_patterns.rs:34:25
    |
 LL |     let _ = matches!(f, -1 | -5 | 3 | -2 | -4 | -3 | 0 | 1 | 2);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-5..=3`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:28:25
+  --> tests/ui/manual_range_patterns.rs:37:25
    |
 LL |     let _ = matches!(f, -1_000_000..=1_000_000 | -1_000_001 | 1_000_001);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-1_000_001..=1_000_001`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:31:17
+  --> tests/ui/manual_range_patterns.rs:41:17
    |
 LL |     matches!(f, 0x00 | 0x01 | 0x02 | 0x03);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0x00..=0x03`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:32:17
+  --> tests/ui/manual_range_patterns.rs:43:17
    |
 LL |     matches!(f, 0x00..=0x05 | 0x06 | 0x07);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `0x00..=0x07`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:33:17
+  --> tests/ui/manual_range_patterns.rs:45:17
    |
 LL |     matches!(f, -0x09 | -0x08 | -0x07..=0x00);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `-0x09..=0x00`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:35:17
+  --> tests/ui/manual_range_patterns.rs:48:17
    |
 LL |     matches!(f, 0..5 | 5);
    |                 ^^^^^^^^ help: try: `0..=5`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:36:17
+  --> tests/ui/manual_range_patterns.rs:50:17
    |
 LL |     matches!(f, 0 | 1..5);
    |                 ^^^^^^^^ help: try: `0..5`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:38:17
+  --> tests/ui/manual_range_patterns.rs:53:17
    |
 LL |     matches!(f, 0..=5 | 6..10);
    |                 ^^^^^^^^^^^^^ help: try: `0..10`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:39:17
+  --> tests/ui/manual_range_patterns.rs:55:17
    |
 LL |     matches!(f, 0..5 | 5..=10);
    |                 ^^^^^^^^^^^^^ help: try: `0..=10`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:40:17
+  --> tests/ui/manual_range_patterns.rs:57:17
    |
 LL |     matches!(f, 5..=10 | 0..5);
    |                 ^^^^^^^^^^^^^ help: try: `0..=10`
 
 error: this OR pattern can be rewritten using a range
-  --> tests/ui/manual_range_patterns.rs:44:26
+  --> tests/ui/manual_range_patterns.rs:62:26
    |
 LL |             matches!($e, 1 | 2 | 3 | 4 | 5 | 6 | 7 | 8 | 9 | 10)
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `1..=10`
diff --git a/src/tools/clippy/tests/ui/manual_rem_euclid.fixed b/src/tools/clippy/tests/ui/manual_rem_euclid.fixed
index 2d50865586d1..e64654bb6866 100644
--- a/src/tools/clippy/tests/ui/manual_rem_euclid.fixed
+++ b/src/tools/clippy/tests/ui/manual_rem_euclid.fixed
@@ -11,10 +11,15 @@ fn main() {
     let value: i32 = 5;
 
     let _: i32 = value.rem_euclid(4);
+    //~^ manual_rem_euclid
     let _: i32 = value.rem_euclid(4);
+    //~^ manual_rem_euclid
     let _: i32 = value.rem_euclid(4);
+    //~^ manual_rem_euclid
     let _: i32 = value.rem_euclid(4);
+    //~^ manual_rem_euclid
     let _: i32 = 1 + value.rem_euclid(4);
+    //~^ manual_rem_euclid
 
     let _: i32 = (3 + value % 4) % 4;
     let _: i32 = (-4 + value % -4) % -4;
@@ -35,6 +40,7 @@ fn main() {
     inline!(
         let value: i32 = 5;
         let _: i32 = value.rem_euclid(4);
+        //~^ manual_rem_euclid
     );
 
     // Do not lint in external macros
@@ -47,11 +53,13 @@ fn main() {
 // Should lint for params too
 pub fn rem_euclid_4(num: i32) -> i32 {
     num.rem_euclid(4)
+    //~^ manual_rem_euclid
 }
 
 // Constant version came later, should still lint
 pub const fn const_rem_euclid_4(num: i32) -> i32 {
     num.rem_euclid(4)
+    //~^ manual_rem_euclid
 }
 
 #[clippy::msrv = "1.37"]
@@ -64,6 +72,7 @@ pub fn msrv_1_37() {
 pub fn msrv_1_38() {
     let x: i32 = 10;
     let _: i32 = x.rem_euclid(4);
+    //~^ manual_rem_euclid
 }
 
 // For const fns:
@@ -77,4 +86,5 @@ pub const fn msrv_1_51() {
 pub const fn msrv_1_52() {
     let x: i32 = 10;
     let _: i32 = x.rem_euclid(4);
+    //~^ manual_rem_euclid
 }
diff --git a/src/tools/clippy/tests/ui/manual_rem_euclid.rs b/src/tools/clippy/tests/ui/manual_rem_euclid.rs
index e405a2db4765..4561a7ee9ea4 100644
--- a/src/tools/clippy/tests/ui/manual_rem_euclid.rs
+++ b/src/tools/clippy/tests/ui/manual_rem_euclid.rs
@@ -11,10 +11,15 @@ fn main() {
     let value: i32 = 5;
 
     let _: i32 = ((value % 4) + 4) % 4;
+    //~^ manual_rem_euclid
     let _: i32 = (4 + (value % 4)) % 4;
+    //~^ manual_rem_euclid
     let _: i32 = (value % 4 + 4) % 4;
+    //~^ manual_rem_euclid
     let _: i32 = (4 + value % 4) % 4;
+    //~^ manual_rem_euclid
     let _: i32 = 1 + (4 + value % 4) % 4;
+    //~^ manual_rem_euclid
 
     let _: i32 = (3 + value % 4) % 4;
     let _: i32 = (-4 + value % -4) % -4;
@@ -35,6 +40,7 @@ fn main() {
     inline!(
         let value: i32 = 5;
         let _: i32 = ((value % 4) + 4) % 4;
+        //~^ manual_rem_euclid
     );
 
     // Do not lint in external macros
@@ -47,11 +53,13 @@ fn main() {
 // Should lint for params too
 pub fn rem_euclid_4(num: i32) -> i32 {
     ((num % 4) + 4) % 4
+    //~^ manual_rem_euclid
 }
 
 // Constant version came later, should still lint
 pub const fn const_rem_euclid_4(num: i32) -> i32 {
     ((num % 4) + 4) % 4
+    //~^ manual_rem_euclid
 }
 
 #[clippy::msrv = "1.37"]
@@ -64,6 +72,7 @@ pub fn msrv_1_37() {
 pub fn msrv_1_38() {
     let x: i32 = 10;
     let _: i32 = ((x % 4) + 4) % 4;
+    //~^ manual_rem_euclid
 }
 
 // For const fns:
@@ -77,4 +86,5 @@ pub const fn msrv_1_51() {
 pub const fn msrv_1_52() {
     let x: i32 = 10;
     let _: i32 = ((x % 4) + 4) % 4;
+    //~^ manual_rem_euclid
 }
diff --git a/src/tools/clippy/tests/ui/manual_rem_euclid.stderr b/src/tools/clippy/tests/ui/manual_rem_euclid.stderr
index a19fdadb1c9b..386815b23b68 100644
--- a/src/tools/clippy/tests/ui/manual_rem_euclid.stderr
+++ b/src/tools/clippy/tests/ui/manual_rem_euclid.stderr
@@ -8,31 +8,31 @@ LL |     let _: i32 = ((value % 4) + 4) % 4;
    = help: to override `-D warnings` add `#[allow(clippy::manual_rem_euclid)]`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:14:18
+  --> tests/ui/manual_rem_euclid.rs:15:18
    |
 LL |     let _: i32 = (4 + (value % 4)) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:15:18
+  --> tests/ui/manual_rem_euclid.rs:17:18
    |
 LL |     let _: i32 = (value % 4 + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:16:18
+  --> tests/ui/manual_rem_euclid.rs:19:18
    |
 LL |     let _: i32 = (4 + value % 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:17:22
+  --> tests/ui/manual_rem_euclid.rs:21:22
    |
 LL |     let _: i32 = 1 + (4 + value % 4) % 4;
    |                      ^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:37:22
+  --> tests/ui/manual_rem_euclid.rs:42:22
    |
 LL |         let _: i32 = ((value % 4) + 4) % 4;
    |                      ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `value.rem_euclid(4)`
@@ -40,25 +40,25 @@ LL |         let _: i32 = ((value % 4) + 4) % 4;
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:49:5
+  --> tests/ui/manual_rem_euclid.rs:55:5
    |
 LL |     ((num % 4) + 4) % 4
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:54:5
+  --> tests/ui/manual_rem_euclid.rs:61:5
    |
 LL |     ((num % 4) + 4) % 4
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `num.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:66:18
+  --> tests/ui/manual_rem_euclid.rs:74:18
    |
 LL |     let _: i32 = ((x % 4) + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^ help: consider using: `x.rem_euclid(4)`
 
 error: manual `rem_euclid` implementation
-  --> tests/ui/manual_rem_euclid.rs:79:18
+  --> tests/ui/manual_rem_euclid.rs:88:18
    |
 LL |     let _: i32 = ((x % 4) + 4) % 4;
    |                  ^^^^^^^^^^^^^^^^^ help: consider using: `x.rem_euclid(4)`
diff --git a/src/tools/clippy/tests/ui/manual_repeat_n.fixed b/src/tools/clippy/tests/ui/manual_repeat_n.fixed
index 4235b02a89e3..44ad3c02d3b8 100644
--- a/src/tools/clippy/tests/ui/manual_repeat_n.fixed
+++ b/src/tools/clippy/tests/ui/manual_repeat_n.fixed
@@ -4,14 +4,19 @@ use std::iter::repeat;
 
 fn main() {
     let _ = std::iter::repeat_n(10, 3);
+    //~^ manual_repeat_n
 
     let _ = std::iter::repeat_n(String::from("foo"), 4);
+    //~^ manual_repeat_n
 
     for value in std::iter::repeat_n(5, 3) {}
+    //~^ manual_repeat_n
 
     let _: Vec<_> = std::iter::repeat_n(String::from("bar"), 10).collect();
+    //~^ manual_repeat_n
 
     let _ = std::iter::repeat_n(vec![1, 2], 2);
+    //~^ manual_repeat_n
 }
 
 mod foo_lib {
diff --git a/src/tools/clippy/tests/ui/manual_repeat_n.rs b/src/tools/clippy/tests/ui/manual_repeat_n.rs
index dbf9ac6a14af..ef6d6827d573 100644
--- a/src/tools/clippy/tests/ui/manual_repeat_n.rs
+++ b/src/tools/clippy/tests/ui/manual_repeat_n.rs
@@ -4,14 +4,19 @@ use std::iter::repeat;
 
 fn main() {
     let _ = repeat(10).take(3);
+    //~^ manual_repeat_n
 
     let _ = repeat(String::from("foo")).take(4);
+    //~^ manual_repeat_n
 
     for value in std::iter::repeat(5).take(3) {}
+    //~^ manual_repeat_n
 
     let _: Vec<_> = std::iter::repeat(String::from("bar")).take(10).collect();
+    //~^ manual_repeat_n
 
     let _ = repeat(vec![1, 2]).take(2);
+    //~^ manual_repeat_n
 }
 
 mod foo_lib {
diff --git a/src/tools/clippy/tests/ui/manual_repeat_n.stderr b/src/tools/clippy/tests/ui/manual_repeat_n.stderr
index 87395b3f8bf1..de968b3ff791 100644
--- a/src/tools/clippy/tests/ui/manual_repeat_n.stderr
+++ b/src/tools/clippy/tests/ui/manual_repeat_n.stderr
@@ -8,25 +8,25 @@ LL |     let _ = repeat(10).take(3);
    = help: to override `-D warnings` add `#[allow(clippy::manual_repeat_n)]`
 
 error: this `repeat().take()` can be written more concisely
-  --> tests/ui/manual_repeat_n.rs:8:13
+  --> tests/ui/manual_repeat_n.rs:9:13
    |
 LL |     let _ = repeat(String::from("foo")).take(4);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `repeat_n()` instead: `std::iter::repeat_n(String::from("foo"), 4)`
 
 error: this `repeat().take()` can be written more concisely
-  --> tests/ui/manual_repeat_n.rs:10:18
+  --> tests/ui/manual_repeat_n.rs:12:18
    |
 LL |     for value in std::iter::repeat(5).take(3) {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `repeat_n()` instead: `std::iter::repeat_n(5, 3)`
 
 error: this `repeat().take()` can be written more concisely
-  --> tests/ui/manual_repeat_n.rs:12:21
+  --> tests/ui/manual_repeat_n.rs:15:21
    |
 LL |     let _: Vec<_> = std::iter::repeat(String::from("bar")).take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `repeat_n()` instead: `std::iter::repeat_n(String::from("bar"), 10)`
 
 error: this `repeat().take()` can be written more concisely
-  --> tests/ui/manual_repeat_n.rs:14:13
+  --> tests/ui/manual_repeat_n.rs:18:13
    |
 LL |     let _ = repeat(vec![1, 2]).take(2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `repeat_n()` instead: `std::iter::repeat_n(vec![1, 2], 2)`
diff --git a/src/tools/clippy/tests/ui/manual_retain.fixed b/src/tools/clippy/tests/ui/manual_retain.fixed
index 5540029bf6b1..ca8491131c06 100644
--- a/src/tools/clippy/tests/ui/manual_retain.fixed
+++ b/src/tools/clippy/tests/ui/manual_retain.fixed
@@ -23,13 +23,18 @@ fn binary_heap_retain() {
     let mut binary_heap = BinaryHeap::from([1, 2, 3]);
     // Do lint.
     binary_heap.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     binary_heap.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     binary_heap.retain(|x| x % 2 == 0);
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = BinaryHeap::from([(0, 1), (1, 2), (2, 3)]);
     tuples.retain(|(ref x, ref y)| *x == 0);
+    //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     binary_heap = binary_heap
@@ -60,7 +65,9 @@ fn btree_map_retain() {
     let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
     // Do lint.
     btree_map.retain(|k, _| k % 2 == 0);
+    //~^ manual_retain
     btree_map.retain(|_, &mut v| v % 2 == 0);
+    //~^ manual_retain
     btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
 
     // Do not lint, because the parameters are not matched in tuple pattern
@@ -84,13 +91,18 @@ fn btree_set_retain() {
 
     // Do lint.
     btree_set.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     btree_set.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     btree_set.retain(|x| x % 2 == 0);
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = BTreeSet::from([(0, 1), (1, 2), (2, 3)]);
     tuples.retain(|(ref x, ref y)| *x == 0);
+    //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     btree_set = btree_set
@@ -121,7 +133,9 @@ fn hash_map_retain() {
     let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
     // Do lint.
     hash_map.retain(|k, _| k % 2 == 0);
+    //~^ manual_retain
     hash_map.retain(|_, &mut v| v % 2 == 0);
+    //~^ manual_retain
     hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0));
 
     // Do not lint, because the parameters are not matched in tuple pattern
@@ -144,13 +158,18 @@ fn hash_set_retain() {
     let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
     // Do lint.
     hash_set.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     hash_set.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     hash_set.retain(|x| x % 2 == 0);
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = HashSet::from([(0, 1), (1, 2), (2, 3)]);
     tuples.retain(|(ref x, ref y)| *x == 0);
+    //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
@@ -180,6 +199,7 @@ fn string_retain() {
     let mut s = String::from("foobar");
     // Do lint.
     s.retain(|c| c != 'o');
+    //~^ manual_retain
 
     // Do not lint, because this expression is not assign.
     let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
@@ -192,13 +212,18 @@ fn vec_retain() {
     let mut vec = vec![0, 1, 2];
     // Do lint.
     vec.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     vec.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     vec.retain(|x| x % 2 == 0);
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = vec![(0, 1), (1, 2), (2, 3)];
     tuples.retain(|(ref x, ref y)| *x == 0);
+    //~^ manual_retain
     tuples.retain(|(x, y)| *x == 0);
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
@@ -221,8 +246,11 @@ fn vec_deque_retain() {
 
     // Do lint.
     vec_deque.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     vec_deque.retain(|x| x % 2 == 0);
+    //~^ manual_retain
     vec_deque.retain(|x| x % 2 == 0);
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     vec_deque = vec_deque
@@ -280,10 +308,12 @@ fn issue_10393() {
     // Do lint
     let mut vec = vec![(0, 1), (1, 2), (2, 3)];
     vec.retain(|(x, y)| *x == 0);
+    //~^ manual_retain
 
     // Do lint
     let mut tuples = vec![(true, -2), (false, 3)];
     tuples.retain(|(_, n)| *n > 0);
+    //~^ manual_retain
 }
 
 fn issue_11457() {
@@ -301,11 +331,17 @@ fn issue_12081() {
 
     // Do lint
     vec.retain(|&x| x == 0);
+    //~^ manual_retain
     vec.retain(|&x| x == 0);
+    //~^ manual_retain
     vec.retain(|&x| x == 0);
+    //~^ manual_retain
 
     // Do lint
     vec.retain(|x| *x == 0);
+    //~^ manual_retain
     vec.retain(|x| *x == 0);
+    //~^ manual_retain
     vec.retain(|x| *x == 0);
+    //~^ manual_retain
 }
diff --git a/src/tools/clippy/tests/ui/manual_retain.rs b/src/tools/clippy/tests/ui/manual_retain.rs
index cee641d9d65f..cd05a41f3f25 100644
--- a/src/tools/clippy/tests/ui/manual_retain.rs
+++ b/src/tools/clippy/tests/ui/manual_retain.rs
@@ -23,13 +23,18 @@ fn binary_heap_retain() {
     let mut binary_heap = BinaryHeap::from([1, 2, 3]);
     // Do lint.
     binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
+    //~^ manual_retain
     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
+    //~^ manual_retain
     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = BinaryHeap::from([(0, 1), (1, 2), (2, 3)]);
     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     binary_heap = binary_heap
@@ -60,8 +65,11 @@ fn btree_map_retain() {
     let mut btree_map: BTreeMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
     // Do lint.
     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+    //~^ manual_retain
     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+    //~^ manual_retain
     btree_map = btree_map
+        //~^ manual_retain
         .into_iter()
         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
         .collect();
@@ -87,13 +95,18 @@ fn btree_set_retain() {
 
     // Do lint.
     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    //~^ manual_retain
     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    //~^ manual_retain
     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = BTreeSet::from([(0, 1), (1, 2), (2, 3)]);
     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     btree_set = btree_set
@@ -124,8 +137,11 @@ fn hash_map_retain() {
     let mut hash_map: HashMap<i8, i8> = (0..8).map(|x| (x, x * 10)).collect();
     // Do lint.
     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
+    //~^ manual_retain
     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
+    //~^ manual_retain
     hash_map = hash_map
+        //~^ manual_retain
         .into_iter()
         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
         .collect();
@@ -150,13 +166,18 @@ fn hash_set_retain() {
     let mut hash_set = HashSet::from([1, 2, 3, 4, 5, 6]);
     // Do lint.
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
+    //~^ manual_retain
     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
+    //~^ manual_retain
     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = HashSet::from([(0, 1), (1, 2), (2, 3)]);
     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect::<HashSet<i8>>();
@@ -186,6 +207,7 @@ fn string_retain() {
     let mut s = String::from("foobar");
     // Do lint.
     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
+    //~^ manual_retain
 
     // Do not lint, because this expression is not assign.
     let mut bar: String = s.chars().filter(|&c| c != 'o').to_owned().collect();
@@ -198,13 +220,18 @@ fn vec_retain() {
     let mut vec = vec![0, 1, 2];
     // Do lint.
     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
+    //~^ manual_retain
     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    //~^ manual_retain
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
+    //~^ manual_retain
 
     // Do lint, because we use pattern matching
     let mut tuples = vec![(0, 1), (1, 2), (2, 3)];
     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
+    //~^ manual_retain
     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     vec = vec.into_iter().filter(|x| x % 2 == 0).collect::<Vec<i8>>();
@@ -227,8 +254,11 @@ fn vec_deque_retain() {
 
     // Do lint.
     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
+    //~^ manual_retain
     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
+    //~^ manual_retain
     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
+    //~^ manual_retain
 
     // Do not lint, because type conversion is performed
     vec_deque = vec_deque
@@ -286,10 +316,12 @@ fn issue_10393() {
     // Do lint
     let mut vec = vec![(0, 1), (1, 2), (2, 3)];
     vec = vec.into_iter().filter(|(x, y)| *x == 0).collect();
+    //~^ manual_retain
 
     // Do lint
     let mut tuples = vec![(true, -2), (false, 3)];
     tuples = tuples.into_iter().filter(|(_, n)| *n > 0).collect();
+    //~^ manual_retain
 }
 
 fn issue_11457() {
@@ -307,11 +339,17 @@ fn issue_12081() {
 
     // Do lint
     vec = vec.iter().filter(|&&x| x == 0).copied().collect();
+    //~^ manual_retain
     vec = vec.iter().filter(|&&x| x == 0).cloned().collect();
+    //~^ manual_retain
     vec = vec.into_iter().filter(|&x| x == 0).collect();
+    //~^ manual_retain
 
     // Do lint
     vec = vec.iter().filter(|&x| *x == 0).copied().collect();
+    //~^ manual_retain
     vec = vec.iter().filter(|&x| *x == 0).cloned().collect();
+    //~^ manual_retain
     vec = vec.into_iter().filter(|x| *x == 0).collect();
+    //~^ manual_retain
 }
diff --git a/src/tools/clippy/tests/ui/manual_retain.stderr b/src/tools/clippy/tests/ui/manual_retain.stderr
index c25c804df758..2f81647dd8b7 100644
--- a/src/tools/clippy/tests/ui/manual_retain.stderr
+++ b/src/tools/clippy/tests/ui/manual_retain.stderr
@@ -8,229 +8,231 @@ LL |     binary_heap = binary_heap.into_iter().filter(|x| x % 2 == 0).collect();
    = help: to override `-D warnings` add `#[allow(clippy::manual_retain)]`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:26:5
+  --> tests/ui/manual_retain.rs:27:5
    |
 LL |     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:27:5
+  --> tests/ui/manual_retain.rs:29:5
    |
 LL |     binary_heap = binary_heap.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `binary_heap.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:31:5
+  --> tests/ui/manual_retain.rs:34:5
    |
 LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:32:5
+  --> tests/ui/manual_retain.rs:36:5
    |
 LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:62:5
+  --> tests/ui/manual_retain.rs:67:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:63:5
+  --> tests/ui/manual_retain.rs:69:5
    |
 LL |     btree_map = btree_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:64:5
+  --> tests/ui/manual_retain.rs:71:5
    |
 LL | /     btree_map = btree_map
+LL | |
 LL | |         .into_iter()
 LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
 LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `btree_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:89:5
+  --> tests/ui/manual_retain.rs:97:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:90:5
+  --> tests/ui/manual_retain.rs:99:5
    |
 LL |     btree_set = btree_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:91:5
+  --> tests/ui/manual_retain.rs:101:5
    |
 LL |     btree_set = btree_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `btree_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:95:5
+  --> tests/ui/manual_retain.rs:106:5
    |
 LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:96:5
+  --> tests/ui/manual_retain.rs:108:5
    |
 LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:126:5
+  --> tests/ui/manual_retain.rs:139:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(k, _)| k % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|k, _| k % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:127:5
+  --> tests/ui/manual_retain.rs:141:5
    |
 LL |     hash_map = hash_map.into_iter().filter(|(_, v)| v % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_map.retain(|_, &mut v| v % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:128:5
+  --> tests/ui/manual_retain.rs:143:5
    |
 LL | /     hash_map = hash_map
+LL | |
 LL | |         .into_iter()
 LL | |         .filter(|(k, v)| (k % 2 == 0) && (v % 2 == 0))
 LL | |         .collect();
    | |__________________^ help: consider calling `.retain()` instead: `hash_map.retain(|k, &mut v| (k % 2 == 0) && (v % 2 == 0))`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:152:5
+  --> tests/ui/manual_retain.rs:168:5
    |
 LL |     hash_set = hash_set.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:153:5
+  --> tests/ui/manual_retain.rs:170:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:154:5
+  --> tests/ui/manual_retain.rs:172:5
    |
 LL |     hash_set = hash_set.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `hash_set.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:158:5
+  --> tests/ui/manual_retain.rs:177:5
    |
 LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:159:5
+  --> tests/ui/manual_retain.rs:179:5
    |
 LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:188:5
+  --> tests/ui/manual_retain.rs:209:5
    |
 LL |     s = s.chars().filter(|&c| c != 'o').to_owned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `s.retain(|c| c != 'o')`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:200:5
+  --> tests/ui/manual_retain.rs:222:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:201:5
+  --> tests/ui/manual_retain.rs:224:5
    |
 LL |     vec = vec.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:202:5
+  --> tests/ui/manual_retain.rs:226:5
    |
 LL |     vec = vec.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:206:5
+  --> tests/ui/manual_retain.rs:231:5
    |
 LL |     tuples = tuples.iter().filter(|(ref x, ref y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(ref x, ref y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:207:5
+  --> tests/ui/manual_retain.rs:233:5
    |
 LL |     tuples = tuples.iter().filter(|(x, y)| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(x, y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:229:5
+  --> tests/ui/manual_retain.rs:256:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:230:5
+  --> tests/ui/manual_retain.rs:258:5
    |
 LL |     vec_deque = vec_deque.iter().filter(|&x| x % 2 == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:231:5
+  --> tests/ui/manual_retain.rs:260:5
    |
 LL |     vec_deque = vec_deque.into_iter().filter(|x| x % 2 == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec_deque.retain(|x| x % 2 == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:288:5
+  --> tests/ui/manual_retain.rs:318:5
    |
 LL |     vec = vec.into_iter().filter(|(x, y)| *x == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|(x, y)| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:292:5
+  --> tests/ui/manual_retain.rs:323:5
    |
 LL |     tuples = tuples.into_iter().filter(|(_, n)| *n > 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `tuples.retain(|(_, n)| *n > 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:309:5
+  --> tests/ui/manual_retain.rs:341:5
    |
 LL |     vec = vec.iter().filter(|&&x| x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|&x| x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:310:5
+  --> tests/ui/manual_retain.rs:343:5
    |
 LL |     vec = vec.iter().filter(|&&x| x == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|&x| x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:311:5
+  --> tests/ui/manual_retain.rs:345:5
    |
 LL |     vec = vec.into_iter().filter(|&x| x == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|&x| x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:314:5
+  --> tests/ui/manual_retain.rs:349:5
    |
 LL |     vec = vec.iter().filter(|&x| *x == 0).copied().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:315:5
+  --> tests/ui/manual_retain.rs:351:5
    |
 LL |     vec = vec.iter().filter(|&x| *x == 0).cloned().collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| *x == 0)`
 
 error: this expression can be written more simply using `.retain()`
-  --> tests/ui/manual_retain.rs:316:5
+  --> tests/ui/manual_retain.rs:353:5
    |
 LL |     vec = vec.into_iter().filter(|x| *x == 0).collect();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling `.retain()` instead: `vec.retain(|x| *x == 0)`
diff --git a/src/tools/clippy/tests/ui/manual_rotate.fixed b/src/tools/clippy/tests/ui/manual_rotate.fixed
index 5d33838a3187..49db8661369e 100644
--- a/src/tools/clippy/tests/ui/manual_rotate.fixed
+++ b/src/tools/clippy/tests/ui/manual_rotate.fixed
@@ -6,18 +6,29 @@ fn main() {
     let a_u32 = 1u32;
     // True positives
     let y_u8 = x_u8.rotate_right(3);
+    //~^ manual_rotate
     let y_u16 = x_u16.rotate_right(7);
+    //~^ manual_rotate
     let y_u32 = x_u32.rotate_right(8);
+    //~^ manual_rotate
     let y_u64 = x_u64.rotate_right(9);
+    //~^ manual_rotate
     let y_i8 = x_i8.rotate_right(3);
+    //~^ manual_rotate
     let y_i16 = x_i16.rotate_right(7);
+    //~^ manual_rotate
     let y_i32 = x_i32.rotate_right(8);
+    //~^ manual_rotate
     let y_i64 = x_i64.rotate_right(9);
+    //~^ manual_rotate
     // Plus also works instead of |
     let y_u32_plus = x_u32.rotate_right(8);
+    //~^ manual_rotate
     // Complex expression
     let y_u32_complex = (x_u32 | 3256).rotate_right(8);
+    //~^ manual_rotate
     let y_u64_as = (x_u32 as u64).rotate_right(8);
+    //~^ manual_rotate
 
     // False positives - can't be replaced with a rotation
     let y_u8_false = (x_u8 >> 6) | (x_u8 << 3);
diff --git a/src/tools/clippy/tests/ui/manual_rotate.rs b/src/tools/clippy/tests/ui/manual_rotate.rs
index 5377491fb1a3..6445e60aa25d 100644
--- a/src/tools/clippy/tests/ui/manual_rotate.rs
+++ b/src/tools/clippy/tests/ui/manual_rotate.rs
@@ -6,18 +6,29 @@ fn main() {
     let a_u32 = 1u32;
     // True positives
     let y_u8 = (x_u8 >> 3) | (x_u8 << 5);
+    //~^ manual_rotate
     let y_u16 = (x_u16 >> 7) | (x_u16 << 9);
+    //~^ manual_rotate
     let y_u32 = (x_u32 >> 8) | (x_u32 << 24);
+    //~^ manual_rotate
     let y_u64 = (x_u64 >> 9) | (x_u64 << 55);
+    //~^ manual_rotate
     let y_i8 = (x_i8 >> 3) | (x_i8 << 5);
+    //~^ manual_rotate
     let y_i16 = (x_i16 >> 7) | (x_i16 << 9);
+    //~^ manual_rotate
     let y_i32 = (x_i32 >> 8) | (x_i32 << 24);
+    //~^ manual_rotate
     let y_i64 = (x_i64 >> 9) | (x_i64 << 55);
+    //~^ manual_rotate
     // Plus also works instead of |
     let y_u32_plus = (x_u32 >> 8) + (x_u32 << 24);
+    //~^ manual_rotate
     // Complex expression
     let y_u32_complex = ((x_u32 | 3256) >> 8) | ((x_u32 | 3256) << 24);
+    //~^ manual_rotate
     let y_u64_as = (x_u32 as u64 >> 8) | ((x_u32 as u64) << 56);
+    //~^ manual_rotate
 
     // False positives - can't be replaced with a rotation
     let y_u8_false = (x_u8 >> 6) | (x_u8 << 3);
diff --git a/src/tools/clippy/tests/ui/manual_rotate.stderr b/src/tools/clippy/tests/ui/manual_rotate.stderr
index 52da0861f700..a28721fbb94c 100644
--- a/src/tools/clippy/tests/ui/manual_rotate.stderr
+++ b/src/tools/clippy/tests/ui/manual_rotate.stderr
@@ -8,61 +8,61 @@ LL |     let y_u8 = (x_u8 >> 3) | (x_u8 << 5);
    = help: to override `-D warnings` add `#[allow(clippy::manual_rotate)]`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:9:17
+  --> tests/ui/manual_rotate.rs:10:17
    |
 LL |     let y_u16 = (x_u16 >> 7) | (x_u16 << 9);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_u16.rotate_right(7)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:10:17
+  --> tests/ui/manual_rotate.rs:12:17
    |
 LL |     let y_u32 = (x_u32 >> 8) | (x_u32 << 24);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_u32.rotate_right(8)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:11:17
+  --> tests/ui/manual_rotate.rs:14:17
    |
 LL |     let y_u64 = (x_u64 >> 9) | (x_u64 << 55);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_u64.rotate_right(9)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:12:16
+  --> tests/ui/manual_rotate.rs:16:16
    |
 LL |     let y_i8 = (x_i8 >> 3) | (x_i8 << 5);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_i8.rotate_right(3)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:13:17
+  --> tests/ui/manual_rotate.rs:18:17
    |
 LL |     let y_i16 = (x_i16 >> 7) | (x_i16 << 9);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_i16.rotate_right(7)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:14:17
+  --> tests/ui/manual_rotate.rs:20:17
    |
 LL |     let y_i32 = (x_i32 >> 8) | (x_i32 << 24);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_i32.rotate_right(8)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:15:17
+  --> tests/ui/manual_rotate.rs:22:17
    |
 LL |     let y_i64 = (x_i64 >> 9) | (x_i64 << 55);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_i64.rotate_right(9)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:17:22
+  --> tests/ui/manual_rotate.rs:25:22
    |
 LL |     let y_u32_plus = (x_u32 >> 8) + (x_u32 << 24);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `x_u32.rotate_right(8)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:19:25
+  --> tests/ui/manual_rotate.rs:28:25
    |
 LL |     let y_u32_complex = ((x_u32 | 3256) >> 8) | ((x_u32 | 3256) << 24);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `(x_u32 | 3256).rotate_right(8)`
 
 error: there is no need to manually implement bit rotation
-  --> tests/ui/manual_rotate.rs:20:20
+  --> tests/ui/manual_rotate.rs:30:20
    |
 LL |     let y_u64_as = (x_u32 as u64 >> 8) | ((x_u32 as u64) << 56);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: this expression can be rewritten as: `(x_u32 as u64).rotate_right(8)`
diff --git a/src/tools/clippy/tests/ui/manual_saturating_arithmetic.fixed b/src/tools/clippy/tests/ui/manual_saturating_arithmetic.fixed
index 528a65790c4c..3f73d6e5a1a6 100644
--- a/src/tools/clippy/tests/ui/manual_saturating_arithmetic.fixed
+++ b/src/tools/clippy/tests/ui/manual_saturating_arithmetic.fixed
@@ -4,38 +4,57 @@ use std::{i32, i128, u32, u128};
 
 fn main() {
     let _ = 1u32.saturating_add(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1u32.saturating_add(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1u8.saturating_add(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1u128.saturating_add(1);
     let _ = 1u32.checked_add(1).unwrap_or(1234); // ok
     let _ = 1u8.checked_add(1).unwrap_or(0); // ok
     let _ = 1u32.saturating_mul(1);
+    //~^ manual_saturating_arithmetic
 
     let _ = 1u32.saturating_sub(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1u32.saturating_sub(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1u8.saturating_sub(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1u32.checked_sub(1).unwrap_or(1234); // ok
     let _ = 1u8.checked_sub(1).unwrap_or(255); // ok
 
     let _ = 1i32.saturating_add(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.saturating_add(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.saturating_add(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128.saturating_add(1);
     let _ = 1i32.saturating_add(-1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.saturating_add(-1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.saturating_add(-1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128.saturating_add(-1);
     let _ = 1i32.checked_add(1).unwrap_or(1234); // ok
     let _ = 1i8.checked_add(1).unwrap_or(-128); // ok
     let _ = 1i8.checked_add(-1).unwrap_or(127); // ok
 
     let _ = 1i32.saturating_sub(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.saturating_sub(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.saturating_sub(1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128.saturating_sub(1);
     let _ = 1i32.saturating_sub(-1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.saturating_sub(-1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.saturating_sub(-1);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128.saturating_sub(-1);
     let _ = 1i32.checked_sub(1).unwrap_or(1234); // ok
     let _ = 1i8.checked_sub(1).unwrap_or(127); // ok
diff --git a/src/tools/clippy/tests/ui/manual_saturating_arithmetic.rs b/src/tools/clippy/tests/ui/manual_saturating_arithmetic.rs
index 55f3720dfcc0..98246a5cd96c 100644
--- a/src/tools/clippy/tests/ui/manual_saturating_arithmetic.rs
+++ b/src/tools/clippy/tests/ui/manual_saturating_arithmetic.rs
@@ -4,31 +4,47 @@ use std::{i32, i128, u32, u128};
 
 fn main() {
     let _ = 1u32.checked_add(1).unwrap_or(u32::max_value());
+    //~^ manual_saturating_arithmetic
     let _ = 1u32.checked_add(1).unwrap_or(u32::MAX);
+    //~^ manual_saturating_arithmetic
     let _ = 1u8.checked_add(1).unwrap_or(255);
+    //~^ manual_saturating_arithmetic
     let _ = 1u128
+        //~^ manual_saturating_arithmetic
         .checked_add(1)
         .unwrap_or(340_282_366_920_938_463_463_374_607_431_768_211_455);
     let _ = 1u32.checked_add(1).unwrap_or(1234); // ok
     let _ = 1u8.checked_add(1).unwrap_or(0); // ok
     let _ = 1u32.checked_mul(1).unwrap_or(u32::MAX);
+    //~^ manual_saturating_arithmetic
 
     let _ = 1u32.checked_sub(1).unwrap_or(u32::min_value());
+    //~^ manual_saturating_arithmetic
     let _ = 1u32.checked_sub(1).unwrap_or(u32::MIN);
+    //~^ manual_saturating_arithmetic
     let _ = 1u8.checked_sub(1).unwrap_or(0);
+    //~^ manual_saturating_arithmetic
     let _ = 1u32.checked_sub(1).unwrap_or(1234); // ok
     let _ = 1u8.checked_sub(1).unwrap_or(255); // ok
 
     let _ = 1i32.checked_add(1).unwrap_or(i32::max_value());
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.checked_add(1).unwrap_or(i32::MAX);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.checked_add(1).unwrap_or(127);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128
+        //~^ manual_saturating_arithmetic
         .checked_add(1)
         .unwrap_or(170_141_183_460_469_231_731_687_303_715_884_105_727);
     let _ = 1i32.checked_add(-1).unwrap_or(i32::min_value());
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.checked_add(-1).unwrap_or(i32::MIN);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.checked_add(-1).unwrap_or(-128);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128
+        //~^ manual_saturating_arithmetic
         .checked_add(-1)
         .unwrap_or(-170_141_183_460_469_231_731_687_303_715_884_105_728);
     let _ = 1i32.checked_add(1).unwrap_or(1234); // ok
@@ -36,15 +52,23 @@ fn main() {
     let _ = 1i8.checked_add(-1).unwrap_or(127); // ok
 
     let _ = 1i32.checked_sub(1).unwrap_or(i32::min_value());
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.checked_sub(1).unwrap_or(i32::MIN);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.checked_sub(1).unwrap_or(-128);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128
+        //~^ manual_saturating_arithmetic
         .checked_sub(1)
         .unwrap_or(-170_141_183_460_469_231_731_687_303_715_884_105_728);
     let _ = 1i32.checked_sub(-1).unwrap_or(i32::max_value());
+    //~^ manual_saturating_arithmetic
     let _ = 1i32.checked_sub(-1).unwrap_or(i32::MAX);
+    //~^ manual_saturating_arithmetic
     let _ = 1i8.checked_sub(-1).unwrap_or(127);
+    //~^ manual_saturating_arithmetic
     let _ = 1i128
+        //~^ manual_saturating_arithmetic
         .checked_sub(-1)
         .unwrap_or(170_141_183_460_469_231_731_687_303_715_884_105_727);
     let _ = 1i32.checked_sub(1).unwrap_or(1234); // ok
diff --git a/src/tools/clippy/tests/ui/manual_saturating_arithmetic.stderr b/src/tools/clippy/tests/ui/manual_saturating_arithmetic.stderr
index b6a8df0f84e1..9d133d8a073b 100644
--- a/src/tools/clippy/tests/ui/manual_saturating_arithmetic.stderr
+++ b/src/tools/clippy/tests/ui/manual_saturating_arithmetic.stderr
@@ -8,154 +8,159 @@ LL |     let _ = 1u32.checked_add(1).unwrap_or(u32::max_value());
    = help: to override `-D warnings` add `#[allow(clippy::manual_saturating_arithmetic)]`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:7:13
+  --> tests/ui/manual_saturating_arithmetic.rs:8:13
    |
 LL |     let _ = 1u32.checked_add(1).unwrap_or(u32::MAX);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1u32.saturating_add(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:8:13
+  --> tests/ui/manual_saturating_arithmetic.rs:10:13
    |
 LL |     let _ = 1u8.checked_add(1).unwrap_or(255);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1u8.saturating_add(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:9:13
+  --> tests/ui/manual_saturating_arithmetic.rs:12:13
    |
 LL |       let _ = 1u128
    |  _____________^
+LL | |
 LL | |         .checked_add(1)
 LL | |         .unwrap_or(340_282_366_920_938_463_463_374_607_431_768_211_455);
    | |_______________________________________________________________________^ help: consider using `saturating_add`: `1u128.saturating_add(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:14:13
+  --> tests/ui/manual_saturating_arithmetic.rs:18:13
    |
 LL |     let _ = 1u32.checked_mul(1).unwrap_or(u32::MAX);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_mul`: `1u32.saturating_mul(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:16:13
+  --> tests/ui/manual_saturating_arithmetic.rs:21:13
    |
 LL |     let _ = 1u32.checked_sub(1).unwrap_or(u32::min_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1u32.saturating_sub(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:17:13
+  --> tests/ui/manual_saturating_arithmetic.rs:23:13
    |
 LL |     let _ = 1u32.checked_sub(1).unwrap_or(u32::MIN);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1u32.saturating_sub(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:18:13
+  --> tests/ui/manual_saturating_arithmetic.rs:25:13
    |
 LL |     let _ = 1u8.checked_sub(1).unwrap_or(0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1u8.saturating_sub(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:22:13
+  --> tests/ui/manual_saturating_arithmetic.rs:30:13
    |
 LL |     let _ = 1i32.checked_add(1).unwrap_or(i32::max_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1i32.saturating_add(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:23:13
+  --> tests/ui/manual_saturating_arithmetic.rs:32:13
    |
 LL |     let _ = 1i32.checked_add(1).unwrap_or(i32::MAX);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1i32.saturating_add(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:24:13
+  --> tests/ui/manual_saturating_arithmetic.rs:34:13
    |
 LL |     let _ = 1i8.checked_add(1).unwrap_or(127);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1i8.saturating_add(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:25:13
+  --> tests/ui/manual_saturating_arithmetic.rs:36:13
    |
 LL |       let _ = 1i128
    |  _____________^
+LL | |
 LL | |         .checked_add(1)
 LL | |         .unwrap_or(170_141_183_460_469_231_731_687_303_715_884_105_727);
    | |_______________________________________________________________________^ help: consider using `saturating_add`: `1i128.saturating_add(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:28:13
+  --> tests/ui/manual_saturating_arithmetic.rs:40:13
    |
 LL |     let _ = 1i32.checked_add(-1).unwrap_or(i32::min_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1i32.saturating_add(-1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:29:13
+  --> tests/ui/manual_saturating_arithmetic.rs:42:13
    |
 LL |     let _ = 1i32.checked_add(-1).unwrap_or(i32::MIN);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1i32.saturating_add(-1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:30:13
+  --> tests/ui/manual_saturating_arithmetic.rs:44:13
    |
 LL |     let _ = 1i8.checked_add(-1).unwrap_or(-128);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_add`: `1i8.saturating_add(-1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:31:13
+  --> tests/ui/manual_saturating_arithmetic.rs:46:13
    |
 LL |       let _ = 1i128
    |  _____________^
+LL | |
 LL | |         .checked_add(-1)
 LL | |         .unwrap_or(-170_141_183_460_469_231_731_687_303_715_884_105_728);
    | |________________________________________________________________________^ help: consider using `saturating_add`: `1i128.saturating_add(-1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:38:13
+  --> tests/ui/manual_saturating_arithmetic.rs:54:13
    |
 LL |     let _ = 1i32.checked_sub(1).unwrap_or(i32::min_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1i32.saturating_sub(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:39:13
+  --> tests/ui/manual_saturating_arithmetic.rs:56:13
    |
 LL |     let _ = 1i32.checked_sub(1).unwrap_or(i32::MIN);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1i32.saturating_sub(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:40:13
+  --> tests/ui/manual_saturating_arithmetic.rs:58:13
    |
 LL |     let _ = 1i8.checked_sub(1).unwrap_or(-128);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1i8.saturating_sub(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:41:13
+  --> tests/ui/manual_saturating_arithmetic.rs:60:13
    |
 LL |       let _ = 1i128
    |  _____________^
+LL | |
 LL | |         .checked_sub(1)
 LL | |         .unwrap_or(-170_141_183_460_469_231_731_687_303_715_884_105_728);
    | |________________________________________________________________________^ help: consider using `saturating_sub`: `1i128.saturating_sub(1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:44:13
+  --> tests/ui/manual_saturating_arithmetic.rs:64:13
    |
 LL |     let _ = 1i32.checked_sub(-1).unwrap_or(i32::max_value());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1i32.saturating_sub(-1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:45:13
+  --> tests/ui/manual_saturating_arithmetic.rs:66:13
    |
 LL |     let _ = 1i32.checked_sub(-1).unwrap_or(i32::MAX);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1i32.saturating_sub(-1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:46:13
+  --> tests/ui/manual_saturating_arithmetic.rs:68:13
    |
 LL |     let _ = 1i8.checked_sub(-1).unwrap_or(127);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `saturating_sub`: `1i8.saturating_sub(-1)`
 
 error: manual saturating arithmetic
-  --> tests/ui/manual_saturating_arithmetic.rs:47:13
+  --> tests/ui/manual_saturating_arithmetic.rs:70:13
    |
 LL |       let _ = 1i128
    |  _____________^
+LL | |
 LL | |         .checked_sub(-1)
 LL | |         .unwrap_or(170_141_183_460_469_231_731_687_303_715_884_105_727);
    | |_______________________________________________________________________^ help: consider using `saturating_sub`: `1i128.saturating_sub(-1)`
diff --git a/src/tools/clippy/tests/ui/manual_slice_fill.fixed b/src/tools/clippy/tests/ui/manual_slice_fill.fixed
index 397a156a2dc7..bba863247f5d 100644
--- a/src/tools/clippy/tests/ui/manual_slice_fill.fixed
+++ b/src/tools/clippy/tests/ui/manual_slice_fill.fixed
@@ -1,5 +1,5 @@
 #![warn(clippy::manual_slice_fill)]
-#![allow(clippy::needless_range_loop)]
+#![allow(clippy::needless_range_loop, clippy::useless_vec)]
 
 macro_rules! assign_element {
     ($slice:ident, $index:expr) => {
@@ -99,3 +99,27 @@ fn should_not_lint() {
         *i = None;
     }
 }
+
+fn issue_14192() {
+    let mut tmp = vec![0; 3];
+
+    for i in 0..tmp.len() {
+        tmp[i] = i;
+    }
+
+    for i in 0..tmp.len() {
+        tmp[i] = 2 + i;
+    }
+
+    for i in 0..tmp.len() {
+        tmp[0] = i;
+    }
+}
+
+fn issue14189() {
+    // Should not lint because `!*b` is not constant
+    let mut tmp = vec![1, 2, 3];
+    for b in &mut tmp {
+        *b = !*b;
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_slice_fill.rs b/src/tools/clippy/tests/ui/manual_slice_fill.rs
index c25127ca613a..44c60dc40f07 100644
--- a/src/tools/clippy/tests/ui/manual_slice_fill.rs
+++ b/src/tools/clippy/tests/ui/manual_slice_fill.rs
@@ -1,5 +1,5 @@
 #![warn(clippy::manual_slice_fill)]
-#![allow(clippy::needless_range_loop)]
+#![allow(clippy::needless_range_loop, clippy::useless_vec)]
 
 macro_rules! assign_element {
     ($slice:ident, $index:expr) => {
@@ -23,21 +23,25 @@ fn should_lint() {
     let mut some_slice = [1, 2, 3, 4, 5];
 
     for i in 0..some_slice.len() {
+        //~^ manual_slice_fill
         some_slice[i] = 0;
     }
 
     let x = 5;
     for i in 0..some_slice.len() {
+        //~^ manual_slice_fill
         some_slice[i] = x;
     }
 
     for i in &mut some_slice {
+        //~^ manual_slice_fill
         *i = 0;
     }
 
     // This should trigger `manual_slice_fill`, but the applicability is `MaybeIncorrect` since comments
     // within the loop might be purely informational.
     for i in 0..some_slice.len() {
+        //~^ manual_slice_fill
         some_slice[i] = 0;
         // foo
     }
@@ -108,3 +112,27 @@ fn should_not_lint() {
         *i = None;
     }
 }
+
+fn issue_14192() {
+    let mut tmp = vec![0; 3];
+
+    for i in 0..tmp.len() {
+        tmp[i] = i;
+    }
+
+    for i in 0..tmp.len() {
+        tmp[i] = 2 + i;
+    }
+
+    for i in 0..tmp.len() {
+        tmp[0] = i;
+    }
+}
+
+fn issue14189() {
+    // Should not lint because `!*b` is not constant
+    let mut tmp = vec![1, 2, 3];
+    for b in &mut tmp {
+        *b = !*b;
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_slice_fill.stderr b/src/tools/clippy/tests/ui/manual_slice_fill.stderr
index 3aa980f69191..38e43d5b4e06 100644
--- a/src/tools/clippy/tests/ui/manual_slice_fill.stderr
+++ b/src/tools/clippy/tests/ui/manual_slice_fill.stderr
@@ -2,6 +2,7 @@ error: manually filling a slice
   --> tests/ui/manual_slice_fill.rs:25:5
    |
 LL | /     for i in 0..some_slice.len() {
+LL | |
 LL | |         some_slice[i] = 0;
 LL | |     }
    | |_____^ help: try: `some_slice.fill(0);`
@@ -10,25 +11,28 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::manual_slice_fill)]`
 
 error: manually filling a slice
-  --> tests/ui/manual_slice_fill.rs:30:5
+  --> tests/ui/manual_slice_fill.rs:31:5
    |
 LL | /     for i in 0..some_slice.len() {
+LL | |
 LL | |         some_slice[i] = x;
 LL | |     }
    | |_____^ help: try: `some_slice.fill(x);`
 
 error: manually filling a slice
-  --> tests/ui/manual_slice_fill.rs:34:5
+  --> tests/ui/manual_slice_fill.rs:36:5
    |
 LL | /     for i in &mut some_slice {
+LL | |
 LL | |         *i = 0;
 LL | |     }
    | |_____^ help: try: `some_slice.fill(0);`
 
 error: manually filling a slice
-  --> tests/ui/manual_slice_fill.rs:40:5
+  --> tests/ui/manual_slice_fill.rs:43:5
    |
 LL | /     for i in 0..some_slice.len() {
+LL | |
 LL | |         some_slice[i] = 0;
 LL | |         // foo
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/manual_slice_size_calculation.fixed b/src/tools/clippy/tests/ui/manual_slice_size_calculation.fixed
index 0603b30e3465..294d1e1506de 100644
--- a/src/tools/clippy/tests/ui/manual_slice_size_calculation.fixed
+++ b/src/tools/clippy/tests/ui/manual_slice_size_calculation.fixed
@@ -15,18 +15,35 @@ fn main() {
 
     // True positives:
     let _ = std::mem::size_of_val(s_i32); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = std::mem::size_of_val(s_i32); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = std::mem::size_of_val(s_i32) * 5; // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = std::mem::size_of_val(*s_i32_ref); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = std::mem::size_of_val(**s_i32_ref_ref); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
 
     let len = s_i32.len();
     let size = size_of::<i32>();
     let _ = std::mem::size_of_val(s_i32); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = std::mem::size_of_val(s_i32); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = std::mem::size_of_val(s_i32); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
 
     let _ = std::mem::size_of_val(external!(&[1u64][..]));
+    //~^ manual_slice_size_calculation
 
     // True negatives:
     let _ = size_of::<i32>() + s_i32.len(); // Ok, not a multiplication
diff --git a/src/tools/clippy/tests/ui/manual_slice_size_calculation.rs b/src/tools/clippy/tests/ui/manual_slice_size_calculation.rs
index 14093e653c09..ae5225663139 100644
--- a/src/tools/clippy/tests/ui/manual_slice_size_calculation.rs
+++ b/src/tools/clippy/tests/ui/manual_slice_size_calculation.rs
@@ -15,18 +15,35 @@ fn main() {
 
     // True positives:
     let _ = s_i32.len() * size_of::<i32>(); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = size_of::<i32>() * s_i32.len(); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = size_of::<i32>() * s_i32_ref.len(); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = size_of::<i32>() * s_i32_ref_ref.len(); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
 
     let len = s_i32.len();
     let size = size_of::<i32>();
     let _ = len * size_of::<i32>(); // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = s_i32.len() * size; // WARNING
+    //
+    //~^^ manual_slice_size_calculation
     let _ = len * size; // WARNING
+    //
+    //~^^ manual_slice_size_calculation
 
     let _ = external!(&[1u64][..]).len() * size_of::<u64>();
+    //~^ manual_slice_size_calculation
 
     // True negatives:
     let _ = size_of::<i32>() + s_i32.len(); // Ok, not a multiplication
diff --git a/src/tools/clippy/tests/ui/manual_slice_size_calculation.stderr b/src/tools/clippy/tests/ui/manual_slice_size_calculation.stderr
index 0397f3a4969a..f07e97a1c863 100644
--- a/src/tools/clippy/tests/ui/manual_slice_size_calculation.stderr
+++ b/src/tools/clippy/tests/ui/manual_slice_size_calculation.stderr
@@ -8,49 +8,49 @@ LL |     let _ = s_i32.len() * size_of::<i32>(); // WARNING
    = help: to override `-D warnings` add `#[allow(clippy::manual_slice_size_calculation)]`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:18:13
+  --> tests/ui/manual_slice_size_calculation.rs:20:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:19:13
+  --> tests/ui/manual_slice_size_calculation.rs:23:13
    |
 LL |     let _ = size_of::<i32>() * s_i32.len() * 5; // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:20:13
+  --> tests/ui/manual_slice_size_calculation.rs:26:13
    |
 LL |     let _ = size_of::<i32>() * s_i32_ref.len(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(*s_i32_ref)`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:21:13
+  --> tests/ui/manual_slice_size_calculation.rs:29:13
    |
 LL |     let _ = size_of::<i32>() * s_i32_ref_ref.len(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(**s_i32_ref_ref)`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:25:13
+  --> tests/ui/manual_slice_size_calculation.rs:35:13
    |
 LL |     let _ = len * size_of::<i32>(); // WARNING
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:26:13
+  --> tests/ui/manual_slice_size_calculation.rs:38:13
    |
 LL |     let _ = s_i32.len() * size; // WARNING
    |             ^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:27:13
+  --> tests/ui/manual_slice_size_calculation.rs:41:13
    |
 LL |     let _ = len * size; // WARNING
    |             ^^^^^^^^^^ help: try: `std::mem::size_of_val(s_i32)`
 
 error: manual slice size calculation
-  --> tests/ui/manual_slice_size_calculation.rs:29:13
+  --> tests/ui/manual_slice_size_calculation.rs:45:13
    |
 LL |     let _ = external!(&[1u64][..]).len() * size_of::<u64>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::mem::size_of_val(external!(&[1u64][..]))`
diff --git a/src/tools/clippy/tests/ui/manual_split_once.fixed b/src/tools/clippy/tests/ui/manual_split_once.fixed
index aaac6a048e1d..76dfb99b787d 100644
--- a/src/tools/clippy/tests/ui/manual_split_once.fixed
+++ b/src/tools/clippy/tests/ui/manual_split_once.fixed
@@ -9,23 +9,33 @@ use itertools::Itertools;
 fn main() {
     let _ = "key=value".splitn(2, '=').nth(2);
     let _ = "key=value".split_once('=').unwrap().1;
+    //~^ manual_split_once
     let _ = "key=value".split_once('=').unwrap().1;
+    //~^ manual_split_once
     let (_, _) = "key=value".split_once('=').unwrap();
+    //~^ manual_split_once
 
     let s = String::from("key=value");
     let _ = s.split_once('=').unwrap().1;
+    //~^ manual_split_once
 
     let s = Box::<str>::from("key=value");
     let _ = s.split_once('=').unwrap().1;
+    //~^ manual_split_once
 
     let s = &"key=value";
     let _ = s.split_once('=').unwrap().1;
+    //~^ manual_split_once
 
     fn _f(s: &str) -> Option<&str> {
         let _ = s.split_once('=')?.1;
+        //~^ manual_split_once
         let _ = s.split_once('=')?.1;
+        //~^ manual_split_once
         let _ = s.rsplit_once('=')?.0;
+        //~^ manual_split_once
         let _ = s.rsplit_once('=')?.0;
+        //~^ manual_split_once
         None
     }
 
@@ -34,24 +44,31 @@ fn main() {
 
     // `rsplitn` gives the results in the reverse order of `rsplit_once`
     let _ = "key=value".rsplit_once('=').unwrap().0;
+    //~^ manual_split_once
     let (_, _) = "key=value".rsplit_once('=').map(|(x, y)| (y, x)).unwrap();
+    //~^ manual_split_once
     let _ = s.rsplit_once('=').map(|x| x.0);
+    //~^ manual_split_once
 }
 
 fn indirect() -> Option<()> {
     let (l, r) = "a.b.c".split_once('.').unwrap();
+    //~^ manual_split_once
     
     
 
     let (l, r) = "a.b.c".split_once('.')?;
+    //~^ manual_split_once
     
     
 
     let (l, r) = "a.b.c".rsplit_once('.').unwrap();
+    //~^ manual_split_once
     
     
 
     let (l, r) = "a.b.c".rsplit_once('.')?;
+    //~^ manual_split_once
     
     
 
@@ -137,8 +154,10 @@ fn _msrv_1_51() {
 #[clippy::msrv = "1.52"]
 fn _msrv_1_52() {
     let _ = "key=value".split_once('=').unwrap().1;
+    //~^ manual_split_once
 
     let (a, b) = "a.b.c".split_once('.').unwrap();
+    //~^ manual_split_once
     
     
 }
diff --git a/src/tools/clippy/tests/ui/manual_split_once.rs b/src/tools/clippy/tests/ui/manual_split_once.rs
index 113e1737c97d..73602fae3d82 100644
--- a/src/tools/clippy/tests/ui/manual_split_once.rs
+++ b/src/tools/clippy/tests/ui/manual_split_once.rs
@@ -9,23 +9,33 @@ use itertools::Itertools;
 fn main() {
     let _ = "key=value".splitn(2, '=').nth(2);
     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+    //~^ manual_split_once
     let _ = "key=value".splitn(2, '=').skip(1).next().unwrap();
+    //~^ manual_split_once
     let (_, _) = "key=value".splitn(2, '=').next_tuple().unwrap();
+    //~^ manual_split_once
 
     let s = String::from("key=value");
     let _ = s.splitn(2, '=').nth(1).unwrap();
+    //~^ manual_split_once
 
     let s = Box::<str>::from("key=value");
     let _ = s.splitn(2, '=').nth(1).unwrap();
+    //~^ manual_split_once
 
     let s = &"key=value";
     let _ = s.splitn(2, '=').skip(1).next().unwrap();
+    //~^ manual_split_once
 
     fn _f(s: &str) -> Option<&str> {
         let _ = s.splitn(2, '=').nth(1)?;
+        //~^ manual_split_once
         let _ = s.splitn(2, '=').skip(1).next()?;
+        //~^ manual_split_once
         let _ = s.rsplitn(2, '=').nth(1)?;
+        //~^ manual_split_once
         let _ = s.rsplitn(2, '=').skip(1).next()?;
+        //~^ manual_split_once
         None
     }
 
@@ -34,24 +44,31 @@ fn main() {
 
     // `rsplitn` gives the results in the reverse order of `rsplit_once`
     let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
+    //~^ manual_split_once
     let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
+    //~^ manual_split_once
     let _ = s.rsplitn(2, '=').nth(1);
+    //~^ manual_split_once
 }
 
 fn indirect() -> Option<()> {
     let mut iter = "a.b.c".splitn(2, '.');
+    //~^ manual_split_once
     let l = iter.next().unwrap();
     let r = iter.next().unwrap();
 
     let mut iter = "a.b.c".splitn(2, '.');
+    //~^ manual_split_once
     let l = iter.next()?;
     let r = iter.next()?;
 
     let mut iter = "a.b.c".rsplitn(2, '.');
+    //~^ manual_split_once
     let r = iter.next().unwrap();
     let l = iter.next().unwrap();
 
     let mut iter = "a.b.c".rsplitn(2, '.');
+    //~^ manual_split_once
     let r = iter.next()?;
     let l = iter.next()?;
 
@@ -137,8 +154,10 @@ fn _msrv_1_51() {
 #[clippy::msrv = "1.52"]
 fn _msrv_1_52() {
     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
+    //~^ manual_split_once
 
     let mut iter = "a.b.c".splitn(2, '.');
+    //~^ manual_split_once
     let a = iter.next().unwrap();
     let b = iter.next().unwrap();
 }
diff --git a/src/tools/clippy/tests/ui/manual_split_once.stderr b/src/tools/clippy/tests/ui/manual_split_once.stderr
index 366d860f25ef..2a44f6e7438c 100644
--- a/src/tools/clippy/tests/ui/manual_split_once.stderr
+++ b/src/tools/clippy/tests/ui/manual_split_once.stderr
@@ -8,23 +8,17 @@ LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::manual_split_once)]`
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:12:13
+  --> tests/ui/manual_split_once.rs:13:13
    |
 LL |     let _ = "key=value".splitn(2, '=').skip(1).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:13:18
+  --> tests/ui/manual_split_once.rs:15:18
    |
 LL |     let (_, _) = "key=value".splitn(2, '=').next_tuple().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split_once('=')`
 
-error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:16:13
-   |
-LL |     let _ = s.splitn(2, '=').nth(1).unwrap();
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=').unwrap().1`
-
 error: manual implementation of `split_once`
   --> tests/ui/manual_split_once.rs:19:13
    |
@@ -32,58 +26,65 @@ LL |     let _ = s.splitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:22:13
+  --> tests/ui/manual_split_once.rs:23:13
+   |
+LL |     let _ = s.splitn(2, '=').nth(1).unwrap();
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=').unwrap().1`
+
+error: manual implementation of `split_once`
+  --> tests/ui/manual_split_once.rs:27:13
    |
 LL |     let _ = s.splitn(2, '=').skip(1).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:25:17
+  --> tests/ui/manual_split_once.rs:31:17
    |
 LL |         let _ = s.splitn(2, '=').nth(1)?;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=')?.1`
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:26:17
+  --> tests/ui/manual_split_once.rs:33:17
    |
 LL |         let _ = s.splitn(2, '=').skip(1).next()?;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.split_once('=')?.1`
 
 error: manual implementation of `rsplit_once`
-  --> tests/ui/manual_split_once.rs:27:17
+  --> tests/ui/manual_split_once.rs:35:17
    |
 LL |         let _ = s.rsplitn(2, '=').nth(1)?;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.rsplit_once('=')?.0`
 
 error: manual implementation of `rsplit_once`
-  --> tests/ui/manual_split_once.rs:28:17
+  --> tests/ui/manual_split_once.rs:37:17
    |
 LL |         let _ = s.rsplitn(2, '=').skip(1).next()?;
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.rsplit_once('=')?.0`
 
 error: manual implementation of `rsplit_once`
-  --> tests/ui/manual_split_once.rs:36:13
+  --> tests/ui/manual_split_once.rs:46:13
    |
 LL |     let _ = "key=value".rsplitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".rsplit_once('=').unwrap().0`
 
 error: manual implementation of `rsplit_once`
-  --> tests/ui/manual_split_once.rs:37:18
+  --> tests/ui/manual_split_once.rs:48:18
    |
 LL |     let (_, _) = "key=value".rsplitn(2, '=').next_tuple().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".rsplit_once('=').map(|(x, y)| (y, x))`
 
 error: manual implementation of `rsplit_once`
-  --> tests/ui/manual_split_once.rs:38:13
+  --> tests/ui/manual_split_once.rs:50:13
    |
 LL |     let _ = s.rsplitn(2, '=').nth(1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.rsplit_once('=').map(|x| x.0)`
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:42:5
+  --> tests/ui/manual_split_once.rs:55:5
    |
 LL |     let mut iter = "a.b.c".splitn(2, '.');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |     let l = iter.next().unwrap();
    |     ----------------------------- first usage here
 LL |     let r = iter.next().unwrap();
@@ -92,15 +93,17 @@ LL |     let r = iter.next().unwrap();
 help: replace with `split_once`
    |
 LL ~     let (l, r) = "a.b.c".split_once('.').unwrap();
+LL |
 LL ~     
 LL ~     
    |
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:46:5
+  --> tests/ui/manual_split_once.rs:60:5
    |
 LL |     let mut iter = "a.b.c".splitn(2, '.');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |     let l = iter.next()?;
    |     --------------------- first usage here
 LL |     let r = iter.next()?;
@@ -109,15 +112,17 @@ LL |     let r = iter.next()?;
 help: replace with `split_once`
    |
 LL ~     let (l, r) = "a.b.c".split_once('.')?;
+LL |
 LL ~     
 LL ~     
    |
 
 error: manual implementation of `rsplit_once`
-  --> tests/ui/manual_split_once.rs:50:5
+  --> tests/ui/manual_split_once.rs:65:5
    |
 LL |     let mut iter = "a.b.c".rsplitn(2, '.');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |     let r = iter.next().unwrap();
    |     ----------------------------- first usage here
 LL |     let l = iter.next().unwrap();
@@ -126,15 +131,17 @@ LL |     let l = iter.next().unwrap();
 help: replace with `rsplit_once`
    |
 LL ~     let (l, r) = "a.b.c".rsplit_once('.').unwrap();
+LL |
 LL ~     
 LL ~     
    |
 
 error: manual implementation of `rsplit_once`
-  --> tests/ui/manual_split_once.rs:54:5
+  --> tests/ui/manual_split_once.rs:70:5
    |
 LL |     let mut iter = "a.b.c".rsplitn(2, '.');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |     let r = iter.next()?;
    |     --------------------- first usage here
 LL |     let l = iter.next()?;
@@ -143,21 +150,23 @@ LL |     let l = iter.next()?;
 help: replace with `rsplit_once`
    |
 LL ~     let (l, r) = "a.b.c".rsplit_once('.')?;
+LL |
 LL ~     
 LL ~     
    |
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:139:13
+  --> tests/ui/manual_split_once.rs:156:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(1).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split_once('=').unwrap().1`
 
 error: manual implementation of `split_once`
-  --> tests/ui/manual_split_once.rs:141:5
+  --> tests/ui/manual_split_once.rs:159:5
    |
 LL |     let mut iter = "a.b.c".splitn(2, '.');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |     let a = iter.next().unwrap();
    |     ----------------------------- first usage here
 LL |     let b = iter.next().unwrap();
@@ -166,6 +175,7 @@ LL |     let b = iter.next().unwrap();
 help: replace with `split_once`
    |
 LL ~     let (a, b) = "a.b.c".split_once('.').unwrap();
+LL |
 LL ~     
 LL ~     
    |
diff --git a/src/tools/clippy/tests/ui/manual_str_repeat.fixed b/src/tools/clippy/tests/ui/manual_str_repeat.fixed
index da6f36f53b0d..bbe4260f6bc8 100644
--- a/src/tools/clippy/tests/ui/manual_str_repeat.fixed
+++ b/src/tools/clippy/tests/ui/manual_str_repeat.fixed
@@ -6,13 +6,18 @@ use std::iter::repeat;
 
 fn main() {
     let _: String = "test".repeat(10);
+    //~^ manual_str_repeat
     let _: String = "x".repeat(10);
+    //~^ manual_str_repeat
     let _: String = "'".repeat(10);
+    //~^ manual_str_repeat
     let _: String = "\"".repeat(10);
+    //~^ manual_str_repeat
 
     let x = "test";
     let count = 10;
     let _ = x.repeat(count + 2);
+    //~^ manual_str_repeat
 
     macro_rules! m {
         ($e:expr) => {{ $e }};
@@ -22,6 +27,7 @@ fn main() {
 
     let x = &x;
     let _: String = (*x).repeat(count);
+    //~^ manual_str_repeat
 
     macro_rules! repeat_m {
         ($e:expr) => {{ repeat($e) }};
@@ -31,6 +37,7 @@ fn main() {
 
     let x: Box<str> = Box::from("test");
     let _: String = x.repeat(count);
+    //~^ manual_str_repeat
 
     #[derive(Clone)]
     struct S;
@@ -43,9 +50,11 @@ fn main() {
     let _: String = repeat(Box::new(S)).take(count).collect();
 
     let _: String = Cow::Borrowed("test").repeat(count);
+    //~^ manual_str_repeat
 
     let x = "x".to_owned();
     let _: String = x.repeat(count);
+    //~^ manual_str_repeat
 
     let x = 'x';
     // Don't lint, not char literal
@@ -61,4 +70,5 @@ fn _msrv_1_15() {
 #[clippy::msrv = "1.16"]
 fn _msrv_1_16() {
     let _: String = "test".repeat(10);
+    //~^ manual_str_repeat
 }
diff --git a/src/tools/clippy/tests/ui/manual_str_repeat.rs b/src/tools/clippy/tests/ui/manual_str_repeat.rs
index 686ed4fee7d1..38d2eb4fcad8 100644
--- a/src/tools/clippy/tests/ui/manual_str_repeat.rs
+++ b/src/tools/clippy/tests/ui/manual_str_repeat.rs
@@ -6,13 +6,18 @@ use std::iter::repeat;
 
 fn main() {
     let _: String = std::iter::repeat("test").take(10).collect();
+    //~^ manual_str_repeat
     let _: String = std::iter::repeat('x').take(10).collect();
+    //~^ manual_str_repeat
     let _: String = std::iter::repeat('\'').take(10).collect();
+    //~^ manual_str_repeat
     let _: String = std::iter::repeat('"').take(10).collect();
+    //~^ manual_str_repeat
 
     let x = "test";
     let count = 10;
     let _ = repeat(x).take(count + 2).collect::<String>();
+    //~^ manual_str_repeat
 
     macro_rules! m {
         ($e:expr) => {{ $e }};
@@ -22,6 +27,7 @@ fn main() {
 
     let x = &x;
     let _: String = repeat(*x).take(count).collect();
+    //~^ manual_str_repeat
 
     macro_rules! repeat_m {
         ($e:expr) => {{ repeat($e) }};
@@ -31,6 +37,7 @@ fn main() {
 
     let x: Box<str> = Box::from("test");
     let _: String = repeat(x).take(count).collect();
+    //~^ manual_str_repeat
 
     #[derive(Clone)]
     struct S;
@@ -43,9 +50,11 @@ fn main() {
     let _: String = repeat(Box::new(S)).take(count).collect();
 
     let _: String = repeat(Cow::Borrowed("test")).take(count).collect();
+    //~^ manual_str_repeat
 
     let x = "x".to_owned();
     let _: String = repeat(x).take(count).collect();
+    //~^ manual_str_repeat
 
     let x = 'x';
     // Don't lint, not char literal
@@ -61,4 +70,5 @@ fn _msrv_1_15() {
 #[clippy::msrv = "1.16"]
 fn _msrv_1_16() {
     let _: String = std::iter::repeat("test").take(10).collect();
+    //~^ manual_str_repeat
 }
diff --git a/src/tools/clippy/tests/ui/manual_str_repeat.stderr b/src/tools/clippy/tests/ui/manual_str_repeat.stderr
index d4f8786fb5f1..7998c3f6d97c 100644
--- a/src/tools/clippy/tests/ui/manual_str_repeat.stderr
+++ b/src/tools/clippy/tests/ui/manual_str_repeat.stderr
@@ -8,55 +8,55 @@ LL |     let _: String = std::iter::repeat("test").take(10).collect();
    = help: to override `-D warnings` add `#[allow(clippy::manual_str_repeat)]`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:9:21
+  --> tests/ui/manual_str_repeat.rs:10:21
    |
 LL |     let _: String = std::iter::repeat('x').take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"x".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:10:21
+  --> tests/ui/manual_str_repeat.rs:12:21
    |
 LL |     let _: String = std::iter::repeat('\'').take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"'".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:11:21
+  --> tests/ui/manual_str_repeat.rs:14:21
    |
 LL |     let _: String = std::iter::repeat('"').take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"\"".repeat(10)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:15:13
+  --> tests/ui/manual_str_repeat.rs:19:13
    |
 LL |     let _ = repeat(x).take(count + 2).collect::<String>();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.repeat(count + 2)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:24:21
+  --> tests/ui/manual_str_repeat.rs:29:21
    |
 LL |     let _: String = repeat(*x).take(count).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*x).repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:33:21
+  --> tests/ui/manual_str_repeat.rs:39:21
    |
 LL |     let _: String = repeat(x).take(count).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:45:21
+  --> tests/ui/manual_str_repeat.rs:52:21
    |
 LL |     let _: String = repeat(Cow::Borrowed("test")).take(count).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Cow::Borrowed("test").repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:48:21
+  --> tests/ui/manual_str_repeat.rs:56:21
    |
 LL |     let _: String = repeat(x).take(count).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.repeat(count)`
 
 error: manual implementation of `str::repeat` using iterators
-  --> tests/ui/manual_str_repeat.rs:63:21
+  --> tests/ui/manual_str_repeat.rs:72:21
    |
 LL |     let _: String = std::iter::repeat("test").take(10).collect();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"test".repeat(10)`
diff --git a/src/tools/clippy/tests/ui/manual_string_new.fixed b/src/tools/clippy/tests/ui/manual_string_new.fixed
index 2d4c5a029153..02eeb603891a 100644
--- a/src/tools/clippy/tests/ui/manual_string_new.fixed
+++ b/src/tools/clippy/tests/ui/manual_string_new.fixed
@@ -12,12 +12,15 @@ macro_rules! create_strings_from_macro {
 fn main() {
     // Method calls
     let _ = String::new();
+    //~^ manual_string_new
     let _ = "no warning".to_string();
 
     let _ = String::new();
+    //~^ manual_string_new
     let _ = "no warning".to_owned();
 
     let _: String = String::new();
+    //~^ manual_string_new
     let _: String = "no warning".into();
 
     let _: SomeOtherStruct = "no warning".into();
@@ -25,26 +28,32 @@ fn main() {
 
     // Calls
     let _ = String::new();
+    //~^ manual_string_new
     let _ = String::new();
+    //~^ manual_string_new
     let _ = String::from("no warning");
     let _ = SomeOtherStruct::from("no warning");
     let _ = SomeOtherStruct::from(""); // Again: no warning.
 
     let _ = String::new();
+    //~^ manual_string_new
     let _ = String::try_from("no warning").unwrap();
     let _ = String::try_from("no warning").expect("this should not warn");
     let _ = SomeOtherStruct::try_from("no warning").unwrap();
     let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
 
     let _: String = String::new();
+    //~^ manual_string_new
     let _: String = From::from("no warning");
     let _: SomeOtherStruct = From::from("no warning");
     let _: SomeOtherStruct = From::from(""); // Again: no warning.
 
     let _: String = String::new();
+    //~^ manual_string_new
     let _: String = TryFrom::try_from("no warning").unwrap();
     let _: String = TryFrom::try_from("no warning").expect("this should not warn");
     let _: String = String::new();
+    //~^ manual_string_new
     let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
     let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
 
diff --git a/src/tools/clippy/tests/ui/manual_string_new.rs b/src/tools/clippy/tests/ui/manual_string_new.rs
index 20f0be6aaf97..fb4f58abad26 100644
--- a/src/tools/clippy/tests/ui/manual_string_new.rs
+++ b/src/tools/clippy/tests/ui/manual_string_new.rs
@@ -12,12 +12,15 @@ macro_rules! create_strings_from_macro {
 fn main() {
     // Method calls
     let _ = "".to_string();
+    //~^ manual_string_new
     let _ = "no warning".to_string();
 
     let _ = "".to_owned();
+    //~^ manual_string_new
     let _ = "no warning".to_owned();
 
     let _: String = "".into();
+    //~^ manual_string_new
     let _: String = "no warning".into();
 
     let _: SomeOtherStruct = "no warning".into();
@@ -25,26 +28,32 @@ fn main() {
 
     // Calls
     let _ = String::from("");
+    //~^ manual_string_new
     let _ = <String>::from("");
+    //~^ manual_string_new
     let _ = String::from("no warning");
     let _ = SomeOtherStruct::from("no warning");
     let _ = SomeOtherStruct::from(""); // Again: no warning.
 
     let _ = String::try_from("").unwrap();
+    //~^ manual_string_new
     let _ = String::try_from("no warning").unwrap();
     let _ = String::try_from("no warning").expect("this should not warn");
     let _ = SomeOtherStruct::try_from("no warning").unwrap();
     let _ = SomeOtherStruct::try_from("").unwrap(); // Again: no warning.
 
     let _: String = From::from("");
+    //~^ manual_string_new
     let _: String = From::from("no warning");
     let _: SomeOtherStruct = From::from("no warning");
     let _: SomeOtherStruct = From::from(""); // Again: no warning.
 
     let _: String = TryFrom::try_from("").unwrap();
+    //~^ manual_string_new
     let _: String = TryFrom::try_from("no warning").unwrap();
     let _: String = TryFrom::try_from("no warning").expect("this should not warn");
     let _: String = TryFrom::try_from("").expect("this should warn");
+    //~^ manual_string_new
     let _: SomeOtherStruct = TryFrom::try_from("no_warning").unwrap();
     let _: SomeOtherStruct = TryFrom::try_from("").unwrap(); // Again: no warning.
 
diff --git a/src/tools/clippy/tests/ui/manual_string_new.stderr b/src/tools/clippy/tests/ui/manual_string_new.stderr
index 6b434f405d31..2d98501f62d4 100644
--- a/src/tools/clippy/tests/ui/manual_string_new.stderr
+++ b/src/tools/clippy/tests/ui/manual_string_new.stderr
@@ -8,49 +8,49 @@ LL |     let _ = "".to_string();
    = help: to override `-D warnings` add `#[allow(clippy::manual_string_new)]`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:17:13
+  --> tests/ui/manual_string_new.rs:18:13
    |
 LL |     let _ = "".to_owned();
    |             ^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:20:21
+  --> tests/ui/manual_string_new.rs:22:21
    |
 LL |     let _: String = "".into();
    |                     ^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:27:13
+  --> tests/ui/manual_string_new.rs:30:13
    |
 LL |     let _ = String::from("");
    |             ^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:28:13
+  --> tests/ui/manual_string_new.rs:32:13
    |
 LL |     let _ = <String>::from("");
    |             ^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:33:13
+  --> tests/ui/manual_string_new.rs:38:13
    |
 LL |     let _ = String::try_from("").unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:39:21
+  --> tests/ui/manual_string_new.rs:45:21
    |
 LL |     let _: String = From::from("");
    |                     ^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:44:21
+  --> tests/ui/manual_string_new.rs:51:21
    |
 LL |     let _: String = TryFrom::try_from("").unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
 
 error: empty String is being created manually
-  --> tests/ui/manual_string_new.rs:47:21
+  --> tests/ui/manual_string_new.rs:55:21
    |
 LL |     let _: String = TryFrom::try_from("").expect("this should warn");
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::new()`
diff --git a/src/tools/clippy/tests/ui/manual_strip.rs b/src/tools/clippy/tests/ui/manual_strip.rs
index 8bd0300e6bcc..086b75a39875 100644
--- a/src/tools/clippy/tests/ui/manual_strip.rs
+++ b/src/tools/clippy/tests/ui/manual_strip.rs
@@ -5,7 +5,8 @@ fn main() {
 
     if s.starts_with("ab") {
         str::to_string(&s["ab".len()..]);
-        //~^ ERROR: stripping a prefix manually
+        //~^ manual_strip
+
         s["ab".len()..].to_string();
 
         str::to_string(&s[2..]);
@@ -14,7 +15,8 @@ fn main() {
 
     if s.ends_with("bc") {
         str::to_string(&s[..s.len() - "bc".len()]);
-        //~^ ERROR: stripping a suffix manually
+        //~^ manual_strip
+
         s[..s.len() - "bc".len()].to_string();
 
         str::to_string(&s[..s.len() - 2]);
@@ -24,7 +26,8 @@ fn main() {
     // Character patterns
     if s.starts_with('a') {
         str::to_string(&s[1..]);
-        //~^ ERROR: stripping a prefix manually
+        //~^ manual_strip
+
         s[1..].to_string();
     }
 
@@ -32,14 +35,15 @@ fn main() {
     let prefix = "ab";
     if s.starts_with(prefix) {
         str::to_string(&s[prefix.len()..]);
-        //~^ ERROR: stripping a prefix manually
+        //~^ manual_strip
     }
 
     // Constant prefix
     const PREFIX: &str = "ab";
     if s.starts_with(PREFIX) {
         str::to_string(&s[PREFIX.len()..]);
-        //~^ ERROR: stripping a prefix manually
+        //~^ manual_strip
+
         str::to_string(&s[2..]);
     }
 
@@ -47,14 +51,14 @@ fn main() {
     const TARGET: &str = "abc";
     if TARGET.starts_with(prefix) {
         str::to_string(&TARGET[prefix.len()..]);
-        //~^ ERROR: stripping a prefix manually
+        //~^ manual_strip
     }
 
     // String target - not mutated.
     let s1: String = "abc".into();
     if s1.starts_with("ab") {
         s1[2..].to_uppercase();
-        //~^ ERROR: stripping a prefix manually
+        //~^ manual_strip
     }
 
     // String target - mutated. (Don't lint.)
@@ -70,6 +74,23 @@ fn main() {
     if s3.starts_with("ab") {
         s4[2..].to_string();
     }
+
+    // Don't propose to reuse the `stripped` identifier as it is overriden
+    if s.starts_with("ab") {
+        let stripped = &s["ab".len()..];
+        //~^ ERROR: stripping a prefix manually
+        let stripped = format!("{stripped}-");
+        println!("{stripped}{}", &s["ab".len()..]);
+    }
+
+    // Don't propose to reuse the `stripped` identifier as it is mutable
+    if s.starts_with("ab") {
+        let mut stripped = &s["ab".len()..];
+        //~^ ERROR: stripping a prefix manually
+        stripped = "";
+        let stripped = format!("{stripped}-");
+        println!("{stripped}{}", &s["ab".len()..]);
+    }
 }
 
 #[clippy::msrv = "1.44"]
@@ -85,6 +106,6 @@ fn msrv_1_45() {
     let s = "abc";
     if s.starts_with('a') {
         s[1..].to_string();
-        //~^ ERROR: stripping a prefix manually
+        //~^ manual_strip
     }
 }
diff --git a/src/tools/clippy/tests/ui/manual_strip.stderr b/src/tools/clippy/tests/ui/manual_strip.stderr
index a70c988a0549..a323ef700e76 100644
--- a/src/tools/clippy/tests/ui/manual_strip.stderr
+++ b/src/tools/clippy/tests/ui/manual_strip.stderr
@@ -16,6 +16,7 @@ help: try using the `strip_prefix` method
 LL ~     if let Some(<stripped>) = s.strip_prefix("ab") {
 LL ~         str::to_string(<stripped>);
 LL |
+LL |
 LL ~         <stripped>.to_string();
 LL |
 LL ~         str::to_string(<stripped>);
@@ -23,13 +24,13 @@ LL ~         <stripped>.to_string();
    |
 
 error: stripping a suffix manually
-  --> tests/ui/manual_strip.rs:16:24
+  --> tests/ui/manual_strip.rs:17:24
    |
 LL |         str::to_string(&s[..s.len() - "bc".len()]);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the suffix was tested here
-  --> tests/ui/manual_strip.rs:15:5
+  --> tests/ui/manual_strip.rs:16:5
    |
 LL |     if s.ends_with("bc") {
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -38,6 +39,7 @@ help: try using the `strip_suffix` method
 LL ~     if let Some(<stripped>) = s.strip_suffix("bc") {
 LL ~         str::to_string(<stripped>);
 LL |
+LL |
 LL ~         <stripped>.to_string();
 LL |
 LL ~         str::to_string(<stripped>);
@@ -45,13 +47,13 @@ LL ~         <stripped>.to_string();
    |
 
 error: stripping a prefix manually
-  --> tests/ui/manual_strip.rs:26:24
+  --> tests/ui/manual_strip.rs:28:24
    |
 LL |         str::to_string(&s[1..]);
    |                        ^^^^^^^
    |
 note: the prefix was tested here
-  --> tests/ui/manual_strip.rs:25:5
+  --> tests/ui/manual_strip.rs:27:5
    |
 LL |     if s.starts_with('a') {
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -60,17 +62,18 @@ help: try using the `strip_prefix` method
 LL ~     if let Some(<stripped>) = s.strip_prefix('a') {
 LL ~         str::to_string(<stripped>);
 LL |
+LL |
 LL ~         <stripped>.to_string();
    |
 
 error: stripping a prefix manually
-  --> tests/ui/manual_strip.rs:34:24
+  --> tests/ui/manual_strip.rs:37:24
    |
 LL |         str::to_string(&s[prefix.len()..]);
    |                        ^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> tests/ui/manual_strip.rs:33:5
+  --> tests/ui/manual_strip.rs:36:5
    |
 LL |     if s.starts_with(prefix) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -81,13 +84,13 @@ LL ~         str::to_string(<stripped>);
    |
 
 error: stripping a prefix manually
-  --> tests/ui/manual_strip.rs:41:24
+  --> tests/ui/manual_strip.rs:44:24
    |
 LL |         str::to_string(&s[PREFIX.len()..]);
    |                        ^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> tests/ui/manual_strip.rs:40:5
+  --> tests/ui/manual_strip.rs:43:5
    |
 LL |     if s.starts_with(PREFIX) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,17 +99,18 @@ help: try using the `strip_prefix` method
 LL ~     if let Some(<stripped>) = s.strip_prefix(PREFIX) {
 LL ~         str::to_string(<stripped>);
 LL |
+LL |
 LL ~         str::to_string(<stripped>);
    |
 
 error: stripping a prefix manually
-  --> tests/ui/manual_strip.rs:49:24
+  --> tests/ui/manual_strip.rs:53:24
    |
 LL |         str::to_string(&TARGET[prefix.len()..]);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: the prefix was tested here
-  --> tests/ui/manual_strip.rs:48:5
+  --> tests/ui/manual_strip.rs:52:5
    |
 LL |     if TARGET.starts_with(prefix) {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -117,13 +121,13 @@ LL ~         str::to_string(<stripped>);
    |
 
 error: stripping a prefix manually
-  --> tests/ui/manual_strip.rs:56:9
+  --> tests/ui/manual_strip.rs:60:9
    |
 LL |         s1[2..].to_uppercase();
    |         ^^^^^^^
    |
 note: the prefix was tested here
-  --> tests/ui/manual_strip.rs:55:5
+  --> tests/ui/manual_strip.rs:59:5
    |
 LL |     if s1.starts_with("ab") {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -134,13 +138,54 @@ LL ~         <stripped>.to_uppercase();
    |
 
 error: stripping a prefix manually
-  --> tests/ui/manual_strip.rs:87:9
+  --> tests/ui/manual_strip.rs:80:24
+   |
+LL |         let stripped = &s["ab".len()..];
+   |                        ^^^^^^^^^^^^^^^^
+   |
+note: the prefix was tested here
+  --> tests/ui/manual_strip.rs:79:5
+   |
+LL |     if s.starts_with("ab") {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL ~     if let Some(<stripped>) = s.strip_prefix("ab") {
+LL ~         let stripped = <stripped>;
+LL |
+LL |         let stripped = format!("{stripped}-");
+LL ~         println!("{stripped}{}", <stripped>);
+   |
+
+error: stripping a prefix manually
+  --> tests/ui/manual_strip.rs:88:28
+   |
+LL |         let mut stripped = &s["ab".len()..];
+   |                            ^^^^^^^^^^^^^^^^
+   |
+note: the prefix was tested here
+  --> tests/ui/manual_strip.rs:87:5
+   |
+LL |     if s.starts_with("ab") {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_prefix` method
+   |
+LL ~     if let Some(<stripped>) = s.strip_prefix("ab") {
+LL ~         let mut stripped = <stripped>;
+LL |
+LL |         stripped = "";
+LL |         let stripped = format!("{stripped}-");
+LL ~         println!("{stripped}{}", <stripped>);
+   |
+
+error: stripping a prefix manually
+  --> tests/ui/manual_strip.rs:108:9
    |
 LL |         s[1..].to_string();
    |         ^^^^^^
    |
 note: the prefix was tested here
-  --> tests/ui/manual_strip.rs:86:5
+  --> tests/ui/manual_strip.rs:107:5
    |
 LL |     if s.starts_with('a') {
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -150,5 +195,5 @@ LL ~     if let Some(<stripped>) = s.strip_prefix('a') {
 LL ~         <stripped>.to_string();
    |
 
-error: aborting due to 8 previous errors
+error: aborting due to 10 previous errors
 
diff --git a/src/tools/clippy/tests/ui/manual_strip_fixable.fixed b/src/tools/clippy/tests/ui/manual_strip_fixable.fixed
new file mode 100644
index 000000000000..75a3f1645de3
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_strip_fixable.fixed
@@ -0,0 +1,15 @@
+#![warn(clippy::manual_strip)]
+
+fn main() {
+    let s = "abc";
+
+    if let Some(stripped) = s.strip_prefix("ab") {
+        //~^ ERROR: stripping a prefix manually
+        println!("{stripped}{}", stripped);
+    }
+
+    if let Some(stripped) = s.strip_suffix("bc") {
+        //~^ ERROR: stripping a suffix manually
+        println!("{stripped}{}", stripped);
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_strip_fixable.rs b/src/tools/clippy/tests/ui/manual_strip_fixable.rs
new file mode 100644
index 000000000000..5080068449e2
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_strip_fixable.rs
@@ -0,0 +1,17 @@
+#![warn(clippy::manual_strip)]
+
+fn main() {
+    let s = "abc";
+
+    if s.starts_with("ab") {
+        let stripped = &s["ab".len()..];
+        //~^ ERROR: stripping a prefix manually
+        println!("{stripped}{}", &s["ab".len()..]);
+    }
+
+    if s.ends_with("bc") {
+        let stripped = &s[..s.len() - "bc".len()];
+        //~^ ERROR: stripping a suffix manually
+        println!("{stripped}{}", &s[..s.len() - "bc".len()]);
+    }
+}
diff --git a/src/tools/clippy/tests/ui/manual_strip_fixable.stderr b/src/tools/clippy/tests/ui/manual_strip_fixable.stderr
new file mode 100644
index 000000000000..1c276e5d8fdf
--- /dev/null
+++ b/src/tools/clippy/tests/ui/manual_strip_fixable.stderr
@@ -0,0 +1,40 @@
+error: stripping a prefix manually
+  --> tests/ui/manual_strip_fixable.rs:7:24
+   |
+LL |         let stripped = &s["ab".len()..];
+   |                        ^^^^^^^^^^^^^^^^
+   |
+note: the prefix was tested here
+  --> tests/ui/manual_strip_fixable.rs:6:5
+   |
+LL |     if s.starts_with("ab") {
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
+   = note: `-D clippy::manual-strip` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::manual_strip)]`
+help: try using the `strip_prefix` method
+   |
+LL ~     if let Some(stripped) = s.strip_prefix("ab") {
+LL ~
+LL ~         println!("{stripped}{}", stripped);
+   |
+
+error: stripping a suffix manually
+  --> tests/ui/manual_strip_fixable.rs:13:24
+   |
+LL |         let stripped = &s[..s.len() - "bc".len()];
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: the suffix was tested here
+  --> tests/ui/manual_strip_fixable.rs:12:5
+   |
+LL |     if s.ends_with("bc") {
+   |     ^^^^^^^^^^^^^^^^^^^^^
+help: try using the `strip_suffix` method
+   |
+LL ~     if let Some(stripped) = s.strip_suffix("bc") {
+LL ~
+LL ~         println!("{stripped}{}", stripped);
+   |
+
+error: aborting due to 2 previous errors
+
diff --git a/src/tools/clippy/tests/ui/manual_swap_auto_fix.rs b/src/tools/clippy/tests/ui/manual_swap_auto_fix.rs
index 702a9e67d3d5..c9880e651cd7 100644
--- a/src/tools/clippy/tests/ui/manual_swap_auto_fix.rs
+++ b/src/tools/clippy/tests/ui/manual_swap_auto_fix.rs
@@ -4,7 +4,8 @@
 fn swap1() {
     let mut v = [3, 2, 1, 0];
     let index = v[0];
-    //~^ ERROR: this looks like you are swapping elements of `v` manually
+    //~^ manual_swap
+
     v[0] = v[index];
     v[index] = index;
 }
@@ -12,6 +13,7 @@ fn swap1() {
 fn swap2() {
     let mut v = [3, 2, 1, 0];
     let tmp = v[0];
+    //~^ manual_swap
     v[0] = v[1];
     v[1] = tmp;
     // check not found in this scope.
@@ -23,6 +25,7 @@ fn swap3() {
     let i1 = 0;
     let i2 = 1;
     let temp = v[i1];
+    //~^ manual_swap
     v[i1] = v[i2];
     v[i2] = temp;
 }
@@ -32,6 +35,7 @@ fn swap4() {
     let i1 = 0;
     let i2 = 1;
     let temp = v[i1];
+    //~^ manual_swap
     v[i1] = v[i2 + 1];
     v[i2 + 1] = temp;
 }
@@ -41,6 +45,7 @@ fn swap5() {
     let i1 = 0;
     let i2 = 1;
     let temp = v[i1];
+    //~^ manual_swap
     v[i1] = v[i2 + 1];
     v[i2 + 1] = temp;
 }
@@ -48,7 +53,8 @@ fn swap5() {
 fn swap6() {
     let mut v = [0, 1, 2, 3];
     let index = v[0];
-    //~^ ERROR: this looks like you are swapping elements of `v` manually
+    //~^ manual_swap
+
     v[0] = v[index + 1];
     v[index + 1] = index;
 }
@@ -58,6 +64,7 @@ fn swap7() {
     let i1 = 0;
     let i2 = 6;
     let tmp = v[i1 * 3];
+    //~^ manual_swap
     v[i1 * 3] = v[i2 / 2];
     v[i2 / 2] = tmp;
 }
@@ -67,6 +74,7 @@ fn swap8() {
     let i1 = 1;
     let i2 = 1;
     let tmp = v[i1 + i2];
+    //~^ manual_swap
     v[i1 + i2] = v[i2];
     v[i2] = tmp;
 }
diff --git a/src/tools/clippy/tests/ui/manual_swap_auto_fix.stderr b/src/tools/clippy/tests/ui/manual_swap_auto_fix.stderr
index eecfcd3977be..7ab898fcc726 100644
--- a/src/tools/clippy/tests/ui/manual_swap_auto_fix.stderr
+++ b/src/tools/clippy/tests/ui/manual_swap_auto_fix.stderr
@@ -3,6 +3,7 @@ error: this looks like you are swapping elements of `v` manually
    |
 LL | /     let index = v[0];
 LL | |
+LL | |
 LL | |     v[0] = v[index];
 LL | |     v[index] = index;
    | |_____________________^
@@ -16,9 +17,10 @@ LL +     v.swap(0, index);
    |
 
 error: this looks like you are swapping elements of `v` manually
-  --> tests/ui/manual_swap_auto_fix.rs:14:5
+  --> tests/ui/manual_swap_auto_fix.rs:15:5
    |
 LL | /     let tmp = v[0];
+LL | |
 LL | |     v[0] = v[1];
 LL | |     v[1] = tmp;
    | |_______________^
@@ -30,34 +32,38 @@ LL +     v.swap(0, 1);
    |
 
 error: this looks like you are swapping elements of `v` manually
-  --> tests/ui/manual_swap_auto_fix.rs:25:5
+  --> tests/ui/manual_swap_auto_fix.rs:27:5
    |
 LL | /     let temp = v[i1];
+LL | |
 LL | |     v[i1] = v[i2];
 LL | |     v[i2] = temp;
    | |_________________^ help: try: `v.swap(i1, i2);`
 
 error: this looks like you are swapping elements of `v` manually
-  --> tests/ui/manual_swap_auto_fix.rs:34:5
+  --> tests/ui/manual_swap_auto_fix.rs:37:5
    |
 LL | /     let temp = v[i1];
+LL | |
 LL | |     v[i1] = v[i2 + 1];
 LL | |     v[i2 + 1] = temp;
    | |_____________________^ help: try: `v.swap(i1, i2 + 1);`
 
 error: this looks like you are swapping elements of `v` manually
-  --> tests/ui/manual_swap_auto_fix.rs:43:5
+  --> tests/ui/manual_swap_auto_fix.rs:47:5
    |
 LL | /     let temp = v[i1];
+LL | |
 LL | |     v[i1] = v[i2 + 1];
 LL | |     v[i2 + 1] = temp;
    | |_____________________^ help: try: `v.swap(i1, i2 + 1);`
 
 error: this looks like you are swapping elements of `v` manually
-  --> tests/ui/manual_swap_auto_fix.rs:50:5
+  --> tests/ui/manual_swap_auto_fix.rs:55:5
    |
 LL | /     let index = v[0];
 LL | |
+LL | |
 LL | |     v[0] = v[index + 1];
 LL | |     v[index + 1] = index;
    | |_________________________^
@@ -69,17 +75,19 @@ LL +     v.swap(0, index + 1);
    |
 
 error: this looks like you are swapping elements of `v` manually
-  --> tests/ui/manual_swap_auto_fix.rs:60:5
+  --> tests/ui/manual_swap_auto_fix.rs:66:5
    |
 LL | /     let tmp = v[i1 * 3];
+LL | |
 LL | |     v[i1 * 3] = v[i2 / 2];
 LL | |     v[i2 / 2] = tmp;
    | |____________________^ help: try: `v.swap(i1 * 3, i2 / 2);`
 
 error: this looks like you are swapping elements of `v` manually
-  --> tests/ui/manual_swap_auto_fix.rs:69:5
+  --> tests/ui/manual_swap_auto_fix.rs:76:5
    |
 LL | /     let tmp = v[i1 + i2];
+LL | |
 LL | |     v[i1 + i2] = v[i2];
 LL | |     v[i2] = tmp;
    | |________________^ help: try: `v.swap(i1 + i2, i2);`
diff --git a/src/tools/clippy/tests/ui/manual_try_fold.rs b/src/tools/clippy/tests/ui/manual_try_fold.rs
index 7299d7cf9862..c91ea41bb84c 100644
--- a/src/tools/clippy/tests/ui/manual_try_fold.rs
+++ b/src/tools/clippy/tests/ui/manual_try_fold.rs
@@ -57,13 +57,16 @@ fn main() {
     [1, 2, 3]
         .iter()
         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
+        //~^ manual_try_fold
         .unwrap();
     [1, 2, 3]
         .iter()
         .fold(NotOption(0i32, 0i32), |sum, i| NotOption(0i32, 0i32));
+    //~^ manual_try_fold
     [1, 2, 3]
         .iter()
         .fold(NotOptionButWorse(0i32), |sum, i| NotOptionButWorse(0i32));
+    //~^ manual_try_fold
     // Do not lint
     [1, 2, 3].iter().try_fold(0i32, |sum, i| sum.checked_add(*i)).unwrap();
     [1, 2, 3].iter().fold(0i32, |sum, i| sum + i);
@@ -94,6 +97,7 @@ fn msrv_juust_right() {
     [1, 2, 3]
         .iter()
         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
+        //~^ manual_try_fold
         .unwrap();
 }
 
diff --git a/src/tools/clippy/tests/ui/manual_try_fold.stderr b/src/tools/clippy/tests/ui/manual_try_fold.stderr
index bc075e87d71f..f2740187878f 100644
--- a/src/tools/clippy/tests/ui/manual_try_fold.stderr
+++ b/src/tools/clippy/tests/ui/manual_try_fold.stderr
@@ -8,19 +8,19 @@ LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
    = help: to override `-D warnings` add `#[allow(clippy::manual_try_fold)]`
 
 error: usage of `Iterator::fold` on a type that implements `Try`
-  --> tests/ui/manual_try_fold.rs:63:10
+  --> tests/ui/manual_try_fold.rs:64:10
    |
 LL |         .fold(NotOption(0i32, 0i32), |sum, i| NotOption(0i32, 0i32));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(..., |sum, i| ...)`
 
 error: usage of `Iterator::fold` on a type that implements `Try`
-  --> tests/ui/manual_try_fold.rs:66:10
+  --> tests/ui/manual_try_fold.rs:68:10
    |
 LL |         .fold(NotOptionButWorse(0i32), |sum, i| NotOptionButWorse(0i32));
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
 
 error: usage of `Iterator::fold` on a type that implements `Try`
-  --> tests/ui/manual_try_fold.rs:96:10
+  --> tests/ui/manual_try_fold.rs:99:10
    |
 LL |         .fold(Some(0i32), |sum, i| sum?.checked_add(*i))
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `try_fold` instead: `try_fold(0i32, |sum, i| ...)`
diff --git a/src/tools/clippy/tests/ui/manual_unwrap_or.rs b/src/tools/clippy/tests/ui/manual_unwrap_or.rs
index cdbe51a41212..c88b6f95da68 100644
--- a/src/tools/clippy/tests/ui/manual_unwrap_or.rs
+++ b/src/tools/clippy/tests/ui/manual_unwrap_or.rs
@@ -9,18 +9,21 @@
 fn option_unwrap_or() {
     // int case
     match Some(1) {
+        //~^ manual_unwrap_or
         Some(i) => i,
         None => 42,
     };
 
     // int case reversed
     match Some(1) {
+        //~^ manual_unwrap_or
         None => 42,
         Some(i) => i,
     };
 
     // richer none expr
     match Some(1) {
+        //~^ manual_unwrap_or
         Some(i) => i,
         None => 1 + 42,
     };
@@ -28,6 +31,7 @@ fn option_unwrap_or() {
     // multiline case
     #[rustfmt::skip]
     match Some(1) {
+    //~^ manual_unwrap_or
         Some(i) => i,
         None => {
             42 + 42
@@ -38,6 +42,7 @@ fn option_unwrap_or() {
 
     // string case
     match Some("Bob") {
+        //~^ manual_unwrap_or
         Some(i) => i,
         None => "Alice",
     };
@@ -85,6 +90,7 @@ fn option_unwrap_or() {
     };
 
     if let Some(x) = Some(1) {
+        //~^ manual_unwrap_or
         x
     } else {
         42
@@ -118,6 +124,7 @@ fn option_unwrap_or() {
 fn result_unwrap_or() {
     // int case
     match Ok::<i32, &str>(1) {
+        //~^ manual_unwrap_or
         Ok(i) => i,
         Err(_) => 42,
     };
@@ -125,12 +132,14 @@ fn result_unwrap_or() {
     // int case, scrutinee is a binding
     let a = Ok::<i32, &str>(1);
     match a {
+        //~^ manual_unwrap_or
         Ok(i) => i,
         Err(_) => 42,
     };
 
     // int case, suggestion must surround Result expr with parentheses
     match Ok(1) as Result<i32, &str> {
+        //~^ manual_unwrap_or
         Ok(i) => i,
         Err(_) => 42,
     };
@@ -144,18 +153,21 @@ fn result_unwrap_or() {
     }
     let s = S {};
     match s.method() {
+        //~^ manual_unwrap_or
         Some(i) => i,
         None => 42,
     };
 
     // int case reversed
     match Ok::<i32, &str>(1) {
+        //~^ manual_unwrap_or
         Err(_) => 42,
         Ok(i) => i,
     };
 
     // richer none expr
     match Ok::<i32, &str>(1) {
+        //~^ manual_unwrap_or
         Ok(i) => i,
         Err(_) => 1 + 42,
     };
@@ -163,6 +175,7 @@ fn result_unwrap_or() {
     // multiline case
     #[rustfmt::skip]
     match Ok::<i32, &str>(1) {
+    //~^ manual_unwrap_or
         Ok(i) => i,
         Err(_) => {
             42 + 42
@@ -173,6 +186,7 @@ fn result_unwrap_or() {
 
     // string case
     match Ok::<&str, &str>("Bob") {
+        //~^ manual_unwrap_or
         Ok(i) => i,
         Err(_) => "Alice",
     };
@@ -209,6 +223,7 @@ fn result_unwrap_or() {
     };
 
     if let Ok(x) = Ok::<i32, i32>(1) {
+        //~^ manual_unwrap_or
         x
     } else {
         42
@@ -263,6 +278,7 @@ mod issue6965 {
 
     fn test() {
         let _ = match some_macro!() {
+            //~^ manual_unwrap_or
             Some(val) => val,
             None => 0,
         };
diff --git a/src/tools/clippy/tests/ui/manual_unwrap_or.stderr b/src/tools/clippy/tests/ui/manual_unwrap_or.stderr
index a5a64ecb9a3e..a5deb55786e9 100644
--- a/src/tools/clippy/tests/ui/manual_unwrap_or.stderr
+++ b/src/tools/clippy/tests/ui/manual_unwrap_or.stderr
@@ -2,6 +2,7 @@ error: this pattern reimplements `Option::unwrap_or`
   --> tests/ui/manual_unwrap_or.rs:11:5
    |
 LL | /     match Some(1) {
+LL | |
 LL | |         Some(i) => i,
 LL | |         None => 42,
 LL | |     };
@@ -11,30 +12,32 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::manual_unwrap_or)]`
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:17:5
+  --> tests/ui/manual_unwrap_or.rs:18:5
    |
 LL | /     match Some(1) {
+LL | |
 LL | |         None => 42,
 LL | |         Some(i) => i,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(42)`
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:23:5
+  --> tests/ui/manual_unwrap_or.rs:25:5
    |
 LL | /     match Some(1) {
+LL | |
 LL | |         Some(i) => i,
 LL | |         None => 1 + 42,
 LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(1 + 42)`
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:30:5
+  --> tests/ui/manual_unwrap_or.rs:33:5
    |
 LL | /     match Some(1) {
+LL | |
 LL | |         Some(i) => i,
 LL | |         None => {
-LL | |             42 + 42
 ...  |
 LL | |     };
    | |_____^
@@ -49,18 +52,20 @@ LL ~     });
    |
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:40:5
+  --> tests/ui/manual_unwrap_or.rs:44:5
    |
 LL | /     match Some("Bob") {
+LL | |
 LL | |         Some(i) => i,
 LL | |         None => "Alice",
 LL | |     };
    | |_____^ help: replace with: `Some("Bob").unwrap_or("Alice")`
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:87:5
+  --> tests/ui/manual_unwrap_or.rs:92:5
    |
 LL | /     if let Some(x) = Some(1) {
+LL | |
 LL | |         x
 LL | |     } else {
 LL | |         42
@@ -68,66 +73,72 @@ LL | |     };
    | |_____^ help: replace with: `Some(1).unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:120:5
+  --> tests/ui/manual_unwrap_or.rs:126:5
    |
 LL | /     match Ok::<i32, &str>(1) {
+LL | |
 LL | |         Ok(i) => i,
 LL | |         Err(_) => 42,
 LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:127:5
+  --> tests/ui/manual_unwrap_or.rs:134:5
    |
 LL | /     match a {
+LL | |
 LL | |         Ok(i) => i,
 LL | |         Err(_) => 42,
 LL | |     };
    | |_____^ help: replace with: `a.unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:133:5
+  --> tests/ui/manual_unwrap_or.rs:141:5
    |
 LL | /     match Ok(1) as Result<i32, &str> {
+LL | |
 LL | |         Ok(i) => i,
 LL | |         Err(_) => 42,
 LL | |     };
    | |_____^ help: replace with: `(Ok(1) as Result<i32, &str>).unwrap_or(42)`
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:146:5
+  --> tests/ui/manual_unwrap_or.rs:155:5
    |
 LL | /     match s.method() {
+LL | |
 LL | |         Some(i) => i,
 LL | |         None => 42,
 LL | |     };
    | |_____^ help: replace with: `s.method().unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:152:5
+  --> tests/ui/manual_unwrap_or.rs:162:5
    |
 LL | /     match Ok::<i32, &str>(1) {
+LL | |
 LL | |         Err(_) => 42,
 LL | |         Ok(i) => i,
 LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:158:5
+  --> tests/ui/manual_unwrap_or.rs:169:5
    |
 LL | /     match Ok::<i32, &str>(1) {
+LL | |
 LL | |         Ok(i) => i,
 LL | |         Err(_) => 1 + 42,
 LL | |     };
    | |_____^ help: replace with: `Ok::<i32, &str>(1).unwrap_or(1 + 42)`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:165:5
+  --> tests/ui/manual_unwrap_or.rs:177:5
    |
 LL | /     match Ok::<i32, &str>(1) {
+LL | |
 LL | |         Ok(i) => i,
 LL | |         Err(_) => {
-LL | |             42 + 42
 ...  |
 LL | |     };
    | |_____^
@@ -142,18 +153,20 @@ LL ~     });
    |
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:175:5
+  --> tests/ui/manual_unwrap_or.rs:188:5
    |
 LL | /     match Ok::<&str, &str>("Bob") {
+LL | |
 LL | |         Ok(i) => i,
 LL | |         Err(_) => "Alice",
 LL | |     };
    | |_____^ help: replace with: `Ok::<&str, &str>("Bob").unwrap_or("Alice")`
 
 error: this pattern reimplements `Result::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:211:5
+  --> tests/ui/manual_unwrap_or.rs:225:5
    |
 LL | /     if let Ok(x) = Ok::<i32, i32>(1) {
+LL | |
 LL | |         x
 LL | |     } else {
 LL | |         42
@@ -161,10 +174,11 @@ LL | |     };
    | |_____^ help: replace with: `Ok::<i32, i32>(1).unwrap_or(42)`
 
 error: this pattern reimplements `Option::unwrap_or`
-  --> tests/ui/manual_unwrap_or.rs:265:17
+  --> tests/ui/manual_unwrap_or.rs:280:17
    |
 LL |           let _ = match some_macro!() {
    |  _________________^
+LL | |
 LL | |             Some(val) => val,
 LL | |             None => 0,
 LL | |         };
diff --git a/src/tools/clippy/tests/ui/manual_unwrap_or_default.rs b/src/tools/clippy/tests/ui/manual_unwrap_or_default.rs
index 649f65c89fb0..bedb3f0af0f3 100644
--- a/src/tools/clippy/tests/ui/manual_unwrap_or_default.rs
+++ b/src/tools/clippy/tests/ui/manual_unwrap_or_default.rs
@@ -4,35 +4,36 @@
 fn main() {
     let x: Option<Vec<String>> = None;
     match x {
-        //~^ ERROR: match can be simplified with `.unwrap_or_default()`
+        //~^ manual_unwrap_or_default
         Some(v) => v,
         None => Vec::default(),
     };
 
     let x: Option<Vec<String>> = None;
     match x {
-        //~^ ERROR: match can be simplified with `.unwrap_or_default()`
+        //~^ manual_unwrap_or_default
         Some(v) => v,
         _ => Vec::default(),
     };
 
     let x: Option<String> = None;
     match x {
-        //~^ ERROR: match can be simplified with `.unwrap_or_default()`
+        //~^ manual_unwrap_or_default
         Some(v) => v,
         None => String::new(),
     };
 
     let x: Option<Vec<String>> = None;
     match x {
-        //~^ ERROR: match can be simplified with `.unwrap_or_default()`
+        //~^ manual_unwrap_or_default
         None => Vec::default(),
         Some(v) => v,
     };
 
     let x: Option<Vec<String>> = None;
     if let Some(v) = x {
-        //~^ ERROR: if let can be simplified with `.unwrap_or_default()`
+        //~^ manual_unwrap_or_default
+
         v
     } else {
         Vec::default()
@@ -50,14 +51,15 @@ fn main() {
 
     let x: Result<String, i64> = Ok(String::new());
     match x {
-        //~^ ERROR: match can be simplified with `.unwrap_or_default()`
+        //~^ manual_unwrap_or_default
         Ok(v) => v,
         Err(_) => String::new(),
     };
 
     let x: Result<String, i64> = Ok(String::new());
     if let Ok(v) = x {
-        //~^ ERROR: if let can be simplified with `.unwrap_or_default()`
+        //~^ manual_unwrap_or_default
+
         v
     } else {
         String::new()
@@ -69,6 +71,7 @@ unsafe fn no_deref_ptr(a: Option<i32>, b: *const Option<i32>) -> i32 {
     match a {
         // `*b` being correct depends on `a == Some(_)`
         Some(_) => match *b {
+            //~^ manual_unwrap_or_default
             Some(v) => v,
             _ => 0,
         },
diff --git a/src/tools/clippy/tests/ui/manual_unwrap_or_default.stderr b/src/tools/clippy/tests/ui/manual_unwrap_or_default.stderr
index 9e3b1be5cb9b..ca9aa159152e 100644
--- a/src/tools/clippy/tests/ui/manual_unwrap_or_default.stderr
+++ b/src/tools/clippy/tests/ui/manual_unwrap_or_default.stderr
@@ -46,6 +46,7 @@ error: if let can be simplified with `.unwrap_or_default()`
    |
 LL | /     if let Some(v) = x {
 LL | |
+LL | |
 LL | |         v
 LL | |     } else {
 LL | |         Vec::default()
@@ -53,7 +54,7 @@ LL | |     };
    | |_____^ help: replace it with: `x.unwrap_or_default()`
 
 error: match can be simplified with `.unwrap_or_default()`
-  --> tests/ui/manual_unwrap_or_default.rs:52:5
+  --> tests/ui/manual_unwrap_or_default.rs:53:5
    |
 LL | /     match x {
 LL | |
@@ -63,10 +64,11 @@ LL | |     };
    | |_____^ help: replace it with: `x.unwrap_or_default()`
 
 error: if let can be simplified with `.unwrap_or_default()`
-  --> tests/ui/manual_unwrap_or_default.rs:59:5
+  --> tests/ui/manual_unwrap_or_default.rs:60:5
    |
 LL | /     if let Ok(v) = x {
 LL | |
+LL | |
 LL | |         v
 LL | |     } else {
 LL | |         String::new()
@@ -74,10 +76,11 @@ LL | |     };
    | |_____^ help: replace it with: `x.unwrap_or_default()`
 
 error: match can be simplified with `.unwrap_or_default()`
-  --> tests/ui/manual_unwrap_or_default.rs:71:20
+  --> tests/ui/manual_unwrap_or_default.rs:73:20
    |
 LL |           Some(_) => match *b {
    |  ____________________^
+LL | |
 LL | |             Some(v) => v,
 LL | |             _ => 0,
 LL | |         },
diff --git a/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.rs b/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.rs
index acc54b52816c..c48a4d5ee515 100644
--- a/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.rs
+++ b/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.rs
@@ -3,13 +3,17 @@ fn issue_12670() {
     // no auto: type not found
     #[allow(clippy::match_result_ok)]
     let _ = if let Some(x) = "1".parse().ok() {
+        //~^ manual_unwrap_or_default
         x
     } else {
         i32::default()
     };
     let _ = if let Some(x) = None { x } else { i32::default() };
+    //~^ manual_unwrap_or_default
     // auto fix with unwrap_or_default
     let a: Option<i32> = None;
     let _ = if let Some(x) = a { x } else { i32::default() };
+    //~^ manual_unwrap_or_default
     let _ = if let Some(x) = Some(99) { x } else { i32::default() };
+    //~^ manual_unwrap_or_default
 }
diff --git a/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.stderr b/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.stderr
index 3849d33cf254..94a7c2f5d2c3 100644
--- a/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/manual_unwrap_or_default_unfixable.stderr
@@ -3,6 +3,7 @@ error: if let can be simplified with `.unwrap_or_default()`
    |
 LL |       let _ = if let Some(x) = "1".parse().ok() {
    |  _____________^
+LL | |
 LL | |         x
 LL | |     } else {
 LL | |         i32::default()
@@ -13,19 +14,19 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::manual_unwrap_or_default)]`
 
 error: if let can be simplified with `.unwrap_or_default()`
-  --> tests/ui/manual_unwrap_or_default_unfixable.rs:10:13
+  --> tests/ui/manual_unwrap_or_default_unfixable.rs:11:13
    |
 LL |     let _ = if let Some(x) = None { x } else { i32::default() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `None::<i32>.unwrap_or_default()`
 
 error: if let can be simplified with `.unwrap_or_default()`
-  --> tests/ui/manual_unwrap_or_default_unfixable.rs:13:13
+  --> tests/ui/manual_unwrap_or_default_unfixable.rs:15:13
    |
 LL |     let _ = if let Some(x) = a { x } else { i32::default() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `a.unwrap_or_default()`
 
 error: if let can be simplified with `.unwrap_or_default()`
-  --> tests/ui/manual_unwrap_or_default_unfixable.rs:14:13
+  --> tests/ui/manual_unwrap_or_default_unfixable.rs:17:13
    |
 LL |     let _ = if let Some(x) = Some(99) { x } else { i32::default() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(99).unwrap_or_default()`
diff --git a/src/tools/clippy/tests/ui/manual_while_let_some.fixed b/src/tools/clippy/tests/ui/manual_while_let_some.fixed
index c70d258dfe6e..c0f6522d5fb8 100644
--- a/src/tools/clippy/tests/ui/manual_while_let_some.fixed
+++ b/src/tools/clippy/tests/ui/manual_while_let_some.fixed
@@ -19,6 +19,7 @@ fn main() {
     let mut numbers = vec![1, 2, 3, 4, 5];
     while let Some(number) = numbers.pop() {
         
+        //~^ manual_while_let_some
     }
 
     let mut val = VecInStruct {
@@ -27,14 +28,17 @@ fn main() {
     };
     while let Some(number) = val.numbers.pop() {
         
+        //~^ manual_while_let_some
     }
 
     while let Some(element) = numbers.pop() {
         accept_i32(element);
+        //~^ manual_while_let_some
     }
 
     while let Some(element) = numbers.pop() {
         accept_i32(element);
+        //~^ manual_while_let_some
     }
 
     // This should not warn. It "conditionally" pops elements.
@@ -78,14 +82,17 @@ fn main() {
     let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
     while let Some((a, b)) = numbers.pop() {
         
+        //~^ manual_while_let_some
     }
 
     while let Some(element) = numbers.pop() {
         accept_i32_tuple(element);
+        //~^ manual_while_let_some
     }
 
     let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
     while let Some(Foo { a, b }) = results.pop() {
         
+        //~^ manual_while_let_some
     }
 }
diff --git a/src/tools/clippy/tests/ui/manual_while_let_some.rs b/src/tools/clippy/tests/ui/manual_while_let_some.rs
index 415bb5798667..f69eb66af1d7 100644
--- a/src/tools/clippy/tests/ui/manual_while_let_some.rs
+++ b/src/tools/clippy/tests/ui/manual_while_let_some.rs
@@ -19,6 +19,7 @@ fn main() {
     let mut numbers = vec![1, 2, 3, 4, 5];
     while !numbers.is_empty() {
         let number = numbers.pop().unwrap();
+        //~^ manual_while_let_some
     }
 
     let mut val = VecInStruct {
@@ -27,14 +28,17 @@ fn main() {
     };
     while !val.numbers.is_empty() {
         let number = val.numbers.pop().unwrap();
+        //~^ manual_while_let_some
     }
 
     while !numbers.is_empty() {
         accept_i32(numbers.pop().unwrap());
+        //~^ manual_while_let_some
     }
 
     while !numbers.is_empty() {
         accept_i32(numbers.pop().expect(""));
+        //~^ manual_while_let_some
     }
 
     // This should not warn. It "conditionally" pops elements.
@@ -78,14 +82,17 @@ fn main() {
     let mut numbers = vec![(0, 0), (1, 1), (2, 2)];
     while !numbers.is_empty() {
         let (a, b) = numbers.pop().unwrap();
+        //~^ manual_while_let_some
     }
 
     while !numbers.is_empty() {
         accept_i32_tuple(numbers.pop().unwrap());
+        //~^ manual_while_let_some
     }
 
     let mut results = vec![Foo { a: 1, b: 2 }, Foo { a: 3, b: 4 }];
     while !results.is_empty() {
         let Foo { a, b } = results.pop().unwrap();
+        //~^ manual_while_let_some
     }
 }
diff --git a/src/tools/clippy/tests/ui/manual_while_let_some.stderr b/src/tools/clippy/tests/ui/manual_while_let_some.stderr
index 8d444b80aaff..5f2fecb7a0b9 100644
--- a/src/tools/clippy/tests/ui/manual_while_let_some.stderr
+++ b/src/tools/clippy/tests/ui/manual_while_let_some.stderr
@@ -13,7 +13,7 @@ LL ~
    |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> tests/ui/manual_while_let_some.rs:29:9
+  --> tests/ui/manual_while_let_some.rs:30:9
    |
 LL |         let number = val.numbers.pop().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL ~
    |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> tests/ui/manual_while_let_some.rs:33:20
+  --> tests/ui/manual_while_let_some.rs:35:20
    |
 LL |         accept_i32(numbers.pop().unwrap());
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL ~         accept_i32(element);
    |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> tests/ui/manual_while_let_some.rs:37:20
+  --> tests/ui/manual_while_let_some.rs:40:20
    |
 LL |         accept_i32(numbers.pop().expect(""));
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL ~         accept_i32(element);
    |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> tests/ui/manual_while_let_some.rs:80:9
+  --> tests/ui/manual_while_let_some.rs:84:9
    |
 LL |         let (a, b) = numbers.pop().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL ~
    |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> tests/ui/manual_while_let_some.rs:84:26
+  --> tests/ui/manual_while_let_some.rs:89:26
    |
 LL |         accept_i32_tuple(numbers.pop().unwrap());
    |                          ^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL ~         accept_i32_tuple(element);
    |
 
 error: you seem to be trying to pop elements from a `Vec` in a loop
-  --> tests/ui/manual_while_let_some.rs:89:9
+  --> tests/ui/manual_while_let_some.rs:95:9
    |
 LL |         let Foo { a, b } = results.pop().unwrap();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/many_single_char_names.rs b/src/tools/clippy/tests/ui/many_single_char_names.rs
index 68578340d90e..b60109224855 100644
--- a/src/tools/clippy/tests/ui/many_single_char_names.rs
+++ b/src/tools/clippy/tests/ui/many_single_char_names.rs
@@ -3,10 +3,10 @@
 
 fn bla() {
     let a: i32;
-    //~^ ERROR: 5 bindings with single-character names in scope
-    //~| NOTE: `-D clippy::many-single-char-names` implied by `-D warnings`
-    //~| ERROR: 6 bindings with single-character names in scope
-    //~| ERROR: 5 bindings with single-character names in scope
+    //~^ many_single_char_names
+    //~| many_single_char_names
+    //~| many_single_char_names
+
     let (b, c, d): (i32, i64, i16);
     {
         {
@@ -32,11 +32,11 @@ fn bla() {
 }
 
 fn bindings(a: i32, b: i32, c: i32, d: i32, e: i32, f: i32, g: i32, h: i32) {}
-//~^ ERROR: 8 bindings with single-character names in scope
+//~^ many_single_char_names
 
 fn bindings2() {
     let (a, b, c, d, e, f, g, h): (bool, bool, bool, bool, bool, bool, bool, bool) = unimplemented!();
-    //~^ ERROR: 8 bindings with single-character names in scope
+    //~^ many_single_char_names
 }
 
 fn shadowing() {
diff --git a/src/tools/clippy/tests/ui/map_all_any_identity.fixed b/src/tools/clippy/tests/ui/map_all_any_identity.fixed
index c92462ab9c27..35543d239752 100644
--- a/src/tools/clippy/tests/ui/map_all_any_identity.fixed
+++ b/src/tools/clippy/tests/ui/map_all_any_identity.fixed
@@ -3,6 +3,7 @@
 fn main() {
     let _ = ["foo"].into_iter().any(|s| s == "foo");
     //~^ map_all_any_identity
+
     let _ = ["foo"].into_iter().all(|s| s == "foo");
     //~^ map_all_any_identity
 
diff --git a/src/tools/clippy/tests/ui/map_all_any_identity.rs b/src/tools/clippy/tests/ui/map_all_any_identity.rs
index 0e4a564ca046..704eb821aaaa 100644
--- a/src/tools/clippy/tests/ui/map_all_any_identity.rs
+++ b/src/tools/clippy/tests/ui/map_all_any_identity.rs
@@ -3,6 +3,7 @@
 fn main() {
     let _ = ["foo"].into_iter().map(|s| s == "foo").any(|a| a);
     //~^ map_all_any_identity
+
     let _ = ["foo"].into_iter().map(|s| s == "foo").all(std::convert::identity);
     //~^ map_all_any_identity
 
diff --git a/src/tools/clippy/tests/ui/map_all_any_identity.stderr b/src/tools/clippy/tests/ui/map_all_any_identity.stderr
index 39df2a3d9616..24df97d883ac 100644
--- a/src/tools/clippy/tests/ui/map_all_any_identity.stderr
+++ b/src/tools/clippy/tests/ui/map_all_any_identity.stderr
@@ -13,7 +13,7 @@ LL +     let _ = ["foo"].into_iter().any(|s| s == "foo");
    |
 
 error: usage of `.map(...).all(identity)`
-  --> tests/ui/map_all_any_identity.rs:6:33
+  --> tests/ui/map_all_any_identity.rs:7:33
    |
 LL |     let _ = ["foo"].into_iter().map(|s| s == "foo").all(std::convert::identity);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/map_clone.fixed b/src/tools/clippy/tests/ui/map_clone.fixed
index f9f8dc1a5123..8db4b21be684 100644
--- a/src/tools/clippy/tests/ui/map_clone.fixed
+++ b/src/tools/clippy/tests/ui/map_clone.fixed
@@ -12,11 +12,16 @@
 
 fn main() {
     let _: Vec<i8> = vec![5_i8; 6].iter().copied().collect();
+    //~^ map_clone
     let _: Vec<String> = vec![String::new()].iter().cloned().collect();
+    //~^ map_clone
     let _: Vec<u32> = vec![42, 43].iter().copied().collect();
+    //~^ map_clone
     let _: Option<u64> = Some(Box::new(16)).map(|b| *b);
     let _: Option<u64> = Some(&16).copied();
+    //~^ map_clone
     let _: Option<u8> = Some(&1).copied();
+    //~^ map_clone
 
     // Don't lint these
     let v = vec![5_i8; 6];
@@ -28,6 +33,7 @@ fn main() {
 
     // Issue #498
     let _ = std::env::args();
+    //~^ map_clone
 
     // Issue #4824 item types that aren't references
     {
@@ -67,22 +73,21 @@ fn main() {
     let x = Some(String::new());
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.cloned();
-    //~^ ERROR: you are explicitly cloning with `.map()`
+    //~^ map_clone
+
     let y = x.cloned();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
+
     let y = x.cloned();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
 
     let x: Option<u32> = Some(0);
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.copied();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
+
     let y = x.copied();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
 
     // Should not suggest `copied` or `cloned` here since `T` is not a reference.
     let x: Option<u32> = Some(0);
@@ -93,20 +98,18 @@ fn main() {
     let x: Result<String, ()> = Ok(String::new());
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.cloned();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
+
     let y = x.cloned();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
 
     let x: Result<u32, ()> = Ok(0);
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.copied();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
+
     let y = x.copied();
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
 
     // Should not suggest `copied` or `cloned` here since `T` is not a reference.
     let x: Result<u32, ()> = Ok(0);
diff --git a/src/tools/clippy/tests/ui/map_clone.rs b/src/tools/clippy/tests/ui/map_clone.rs
index a5c19ce06319..a726e3561634 100644
--- a/src/tools/clippy/tests/ui/map_clone.rs
+++ b/src/tools/clippy/tests/ui/map_clone.rs
@@ -12,11 +12,16 @@
 
 fn main() {
     let _: Vec<i8> = vec![5_i8; 6].iter().map(|x| *x).collect();
+    //~^ map_clone
     let _: Vec<String> = vec![String::new()].iter().map(|x| x.clone()).collect();
+    //~^ map_clone
     let _: Vec<u32> = vec![42, 43].iter().map(|&x| x).collect();
+    //~^ map_clone
     let _: Option<u64> = Some(Box::new(16)).map(|b| *b);
     let _: Option<u64> = Some(&16).map(|b| *b);
+    //~^ map_clone
     let _: Option<u8> = Some(&1).map(|x| x.clone());
+    //~^ map_clone
 
     // Don't lint these
     let v = vec![5_i8; 6];
@@ -28,6 +33,7 @@ fn main() {
 
     // Issue #498
     let _ = std::env::args().map(|v| v.clone());
+    //~^ map_clone
 
     // Issue #4824 item types that aren't references
     {
@@ -67,22 +73,21 @@ fn main() {
     let x = Some(String::new());
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.map(|x| String::clone(x));
-    //~^ ERROR: you are explicitly cloning with `.map()`
+    //~^ map_clone
+
     let y = x.map(Clone::clone);
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
+
     let y = x.map(String::clone);
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
 
     let x: Option<u32> = Some(0);
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.map(|x| u32::clone(x));
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
+
     let y = x.map(|x| Clone::clone(x));
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
 
     // Should not suggest `copied` or `cloned` here since `T` is not a reference.
     let x: Option<u32> = Some(0);
@@ -93,20 +98,18 @@ fn main() {
     let x: Result<String, ()> = Ok(String::new());
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.map(|x| String::clone(x));
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
+
     let y = x.map(|x| Clone::clone(x));
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `cloned` method
+    //~^ map_clone
 
     let x: Result<u32, ()> = Ok(0);
     let x = x.as_ref(); // We do this to prevent triggering the `useless_asref` lint.
     let y = x.map(|x| u32::clone(x));
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
+
     let y = x.map(|x| Clone::clone(x));
-    //~^ ERROR: you are explicitly cloning with `.map()`
-    //~| HELP: consider calling the dedicated `copied` method
+    //~^ map_clone
 
     // Should not suggest `copied` or `cloned` here since `T` is not a reference.
     let x: Result<u32, ()> = Ok(0);
diff --git a/src/tools/clippy/tests/ui/map_clone.stderr b/src/tools/clippy/tests/ui/map_clone.stderr
index d9e025de4abe..8bf54e4e8aee 100644
--- a/src/tools/clippy/tests/ui/map_clone.stderr
+++ b/src/tools/clippy/tests/ui/map_clone.stderr
@@ -8,85 +8,85 @@ LL |     let _: Vec<i8> = vec![5_i8; 6].iter().map(|x| *x).collect();
    = help: to override `-D warnings` add `#[allow(clippy::map_clone)]`
 
 error: you are using an explicit closure for cloning elements
-  --> tests/ui/map_clone.rs:15:26
+  --> tests/ui/map_clone.rs:16:26
    |
 LL |     let _: Vec<String> = vec![String::new()].iter().map(|x| x.clone()).collect();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `vec![String::new()].iter().cloned()`
 
 error: you are using an explicit closure for copying elements
-  --> tests/ui/map_clone.rs:16:23
+  --> tests/ui/map_clone.rs:18:23
    |
 LL |     let _: Vec<u32> = vec![42, 43].iter().map(|&x| x).collect();
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `vec![42, 43].iter().copied()`
 
 error: you are using an explicit closure for copying elements
-  --> tests/ui/map_clone.rs:18:26
+  --> tests/ui/map_clone.rs:21:26
    |
 LL |     let _: Option<u64> = Some(&16).map(|b| *b);
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `Some(&16).copied()`
 
 error: you are using an explicit closure for copying elements
-  --> tests/ui/map_clone.rs:19:25
+  --> tests/ui/map_clone.rs:23:25
    |
 LL |     let _: Option<u8> = Some(&1).map(|x| x.clone());
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `Some(&1).copied()`
 
 error: you are needlessly cloning iterator elements
-  --> tests/ui/map_clone.rs:30:29
+  --> tests/ui/map_clone.rs:35:29
    |
 LL |     let _ = std::env::args().map(|v| v.clone());
    |                             ^^^^^^^^^^^^^^^^^^^ help: remove the `map` call
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:69:13
+  --> tests/ui/map_clone.rs:75:13
    |
 LL |     let y = x.map(|x| String::clone(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `x.cloned()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:71:13
+  --> tests/ui/map_clone.rs:78:13
    |
 LL |     let y = x.map(Clone::clone);
    |             ^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `x.cloned()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:74:13
+  --> tests/ui/map_clone.rs:81:13
    |
 LL |     let y = x.map(String::clone);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `x.cloned()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:80:13
+  --> tests/ui/map_clone.rs:86:13
    |
 LL |     let y = x.map(|x| u32::clone(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `x.copied()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:83:13
+  --> tests/ui/map_clone.rs:89:13
    |
 LL |     let y = x.map(|x| Clone::clone(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `x.copied()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:95:13
+  --> tests/ui/map_clone.rs:100:13
    |
 LL |     let y = x.map(|x| String::clone(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `x.cloned()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:98:13
+  --> tests/ui/map_clone.rs:103:13
    |
 LL |     let y = x.map(|x| Clone::clone(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `cloned` method: `x.cloned()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:104:13
+  --> tests/ui/map_clone.rs:108:13
    |
 LL |     let y = x.map(|x| u32::clone(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `x.copied()`
 
 error: you are explicitly cloning with `.map()`
-  --> tests/ui/map_clone.rs:107:13
+  --> tests/ui/map_clone.rs:111:13
    |
 LL |     let y = x.map(|x| Clone::clone(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider calling the dedicated `copied` method: `x.copied()`
diff --git a/src/tools/clippy/tests/ui/map_collect_result_unit.fixed b/src/tools/clippy/tests/ui/map_collect_result_unit.fixed
index 374af105f889..26957e59f14a 100644
--- a/src/tools/clippy/tests/ui/map_collect_result_unit.fixed
+++ b/src/tools/clippy/tests/ui/map_collect_result_unit.fixed
@@ -3,7 +3,9 @@
 fn main() {
     {
         let _ = (0..3).try_for_each(|t| Err(t + 1));
+        //~^ map_collect_result_unit
         let _: Result<(), _> = (0..3).try_for_each(|t| Err(t + 1));
+        //~^ map_collect_result_unit
 
         let _ = (0..3).try_for_each(|t| Err(t + 1));
     }
diff --git a/src/tools/clippy/tests/ui/map_collect_result_unit.rs b/src/tools/clippy/tests/ui/map_collect_result_unit.rs
index 5c6fb23e2372..cdd73bfe6544 100644
--- a/src/tools/clippy/tests/ui/map_collect_result_unit.rs
+++ b/src/tools/clippy/tests/ui/map_collect_result_unit.rs
@@ -3,7 +3,9 @@
 fn main() {
     {
         let _ = (0..3).map(|t| Err(t + 1)).collect::<Result<(), _>>();
+        //~^ map_collect_result_unit
         let _: Result<(), _> = (0..3).map(|t| Err(t + 1)).collect();
+        //~^ map_collect_result_unit
 
         let _ = (0..3).try_for_each(|t| Err(t + 1));
     }
diff --git a/src/tools/clippy/tests/ui/map_collect_result_unit.stderr b/src/tools/clippy/tests/ui/map_collect_result_unit.stderr
index 8d147340e16a..93293be855bb 100644
--- a/src/tools/clippy/tests/ui/map_collect_result_unit.stderr
+++ b/src/tools/clippy/tests/ui/map_collect_result_unit.stderr
@@ -8,7 +8,7 @@ LL |         let _ = (0..3).map(|t| Err(t + 1)).collect::<Result<(), _>>();
    = help: to override `-D warnings` add `#[allow(clippy::map_collect_result_unit)]`
 
 error: `.map().collect()` can be replaced with `.try_for_each()`
-  --> tests/ui/map_collect_result_unit.rs:6:32
+  --> tests/ui/map_collect_result_unit.rs:7:32
    |
 LL |         let _: Result<(), _> = (0..3).map(|t| Err(t + 1)).collect();
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(0..3).try_for_each(|t| Err(t + 1))`
diff --git a/src/tools/clippy/tests/ui/map_err.rs b/src/tools/clippy/tests/ui/map_err.rs
index 07c51784407a..0f0c8f6c71cf 100644
--- a/src/tools/clippy/tests/ui/map_err.rs
+++ b/src/tools/clippy/tests/ui/map_err.rs
@@ -20,7 +20,7 @@ fn main() -> Result<(), Errors> {
     let x = u32::try_from(-123_i32);
 
     println!("{:?}", x.map_err(|_| Errors::Ignored));
-    //~^ ERROR: `map_err(|_|...` wildcard pattern discards the original error
+    //~^ map_err_ignore
 
     // Should not warn you because you explicitly ignore the parameter
     // using a named wildcard value
diff --git a/src/tools/clippy/tests/ui/map_flatten.rs b/src/tools/clippy/tests/ui/map_flatten.rs
index eafc8b6e81ca..d7e9c9d9900d 100644
--- a/src/tools/clippy/tests/ui/map_flatten.rs
+++ b/src/tools/clippy/tests/ui/map_flatten.rs
@@ -6,8 +6,9 @@
 fn long_span() {
     let _: Option<i32> = Some(1)
         .map(|x| {
-        //~^ ERROR: called `map(..).flatten()` on `Option`
-        //~| NOTE: `-D clippy::map-flatten` implied by `-D warnings`
+        //~^ map_flatten
+
+
             if x <= 5 {
                 Some(x)
             } else {
@@ -18,7 +19,8 @@ fn long_span() {
 
     let _: Result<i32, i32> = Ok(1)
         .map(|x| {
-        //~^ ERROR: called `map(..).flatten()` on `Result`
+        //~^ map_flatten
+
             if x == 1 {
                 Ok(x)
             } else {
@@ -31,7 +33,8 @@ fn long_span() {
     fn do_something() { }
     let _: Result<i32, i32> = result
         .map(|res| {
-        //~^ ERROR: called `map(..).flatten()` on `Result`
+        //~^ map_flatten
+
             if res > 0 {
                 do_something();
                 Ok(res)
@@ -44,7 +47,8 @@ fn long_span() {
     let _: Vec<_> = vec![5_i8; 6]
         .into_iter()
         .map(|some_value| {
-        //~^ ERROR: called `map(..).flatten()` on `Iterator`
+        //~^ map_flatten
+
             if some_value > 3 {
                 Some(some_value)
             } else {
@@ -62,7 +66,7 @@ fn no_suggestion_if_comments_present() {
         .iter()
         // a lovely comment explaining the code in very detail
         .map(|x| x.iter())
-        //~^ ERROR: called `map(..).flatten()` on `Iterator`
+        //~^ map_flatten
         // the answer to life, the universe and everything could be here
         .flatten();
 }
diff --git a/src/tools/clippy/tests/ui/map_flatten.stderr b/src/tools/clippy/tests/ui/map_flatten.stderr
index 34bd174d7dde..704267fea3cf 100644
--- a/src/tools/clippy/tests/ui/map_flatten.stderr
+++ b/src/tools/clippy/tests/ui/map_flatten.stderr
@@ -3,9 +3,6 @@ error: called `map(..).flatten()` on `Option`
    |
 LL |           .map(|x| {
    |  __________^
-LL | |
-LL | |
-LL | |             if x <= 5 {
 ...  |
 LL | |         })
 LL | |         .flatten();
@@ -17,7 +14,8 @@ help: try replacing `map` with `and_then` and remove the `.flatten()`
    |
 LL ~         .and_then(|x| {
 LL +
-LL +
+LL + 
+LL + 
 LL +             if x <= 5 {
 LL +                 Some(x)
 LL +             } else {
@@ -27,13 +25,13 @@ LL ~         });
    |
 
 error: called `map(..).flatten()` on `Result`
-  --> tests/ui/map_flatten.rs:20:10
+  --> tests/ui/map_flatten.rs:21:10
    |
 LL |           .map(|x| {
    |  __________^
 LL | |
+LL | |
 LL | |             if x == 1 {
-LL | |                 Ok(x)
 ...  |
 LL | |         })
 LL | |         .flatten();
@@ -43,6 +41,7 @@ help: try replacing `map` with `and_then` and remove the `.flatten()`
    |
 LL ~         .and_then(|x| {
 LL +
+LL + 
 LL +             if x == 1 {
 LL +                 Ok(x)
 LL +             } else {
@@ -52,13 +51,13 @@ LL ~         });
    |
 
 error: called `map(..).flatten()` on `Result`
-  --> tests/ui/map_flatten.rs:33:10
+  --> tests/ui/map_flatten.rs:35:10
    |
 LL |           .map(|res| {
    |  __________^
 LL | |
+LL | |
 LL | |             if res > 0 {
-LL | |                 do_something();
 ...  |
 LL | |         })
 LL | |         .flatten();
@@ -68,6 +67,7 @@ help: try replacing `map` with `and_then` and remove the `.flatten()`
    |
 LL ~         .and_then(|res| {
 LL +
+LL + 
 LL +             if res > 0 {
 LL +                 do_something();
 LL +                 Ok(res)
@@ -78,13 +78,13 @@ LL ~         });
    |
 
 error: called `map(..).flatten()` on `Iterator`
-  --> tests/ui/map_flatten.rs:46:10
+  --> tests/ui/map_flatten.rs:49:10
    |
 LL |           .map(|some_value| {
    |  __________^
 LL | |
+LL | |
 LL | |             if some_value > 3 {
-LL | |                 Some(some_value)
 ...  |
 LL | |         })
 LL | |         .flatten()
@@ -94,6 +94,7 @@ help: try replacing `map` with `filter_map` and remove the `.flatten()`
    |
 LL ~         .filter_map(|some_value| {
 LL +
+LL + 
 LL +             if some_value > 3 {
 LL +                 Some(some_value)
 LL +             } else {
@@ -103,7 +104,7 @@ LL +         })
    |
 
 error: called `map(..).flatten()` on `Iterator`
-  --> tests/ui/map_flatten.rs:64:10
+  --> tests/ui/map_flatten.rs:68:10
    |
 LL |           .map(|x| x.iter())
    |  __________^
diff --git a/src/tools/clippy/tests/ui/map_flatten_fixable.fixed b/src/tools/clippy/tests/ui/map_flatten_fixable.fixed
index 1932f412d2ca..948fec970d86 100644
--- a/src/tools/clippy/tests/ui/map_flatten_fixable.fixed
+++ b/src/tools/clippy/tests/ui/map_flatten_fixable.fixed
@@ -14,18 +14,25 @@ fn main() {
     let option_id_ref: fn(i8) -> Option<i8> = option_id;
     let option_id_closure = |x| Some(x);
     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id).collect();
+    //~^ map_flatten
     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_ref).collect();
+    //~^ map_flatten
     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(option_id_closure).collect();
+    //~^ map_flatten
     let _: Vec<_> = vec![5_i8; 6].into_iter().filter_map(|x| x.checked_add(1)).collect();
+    //~^ map_flatten
 
     // mapping to Iterator on Iterator
     let _: Vec<_> = vec![5_i8; 6].into_iter().flat_map(|x| 0..x).collect();
+    //~^ map_flatten
 
     // mapping to Option on Option
     let _: Option<_> = (Some(Some(1))).and_then(|x| x);
+    //~^ map_flatten
 
     // mapping to Result on Result
     let _: Result<_, &str> = (Ok(Ok(1))).and_then(|x| x);
+    //~^ map_flatten
 
     issue8734();
     issue8878();
@@ -35,6 +42,7 @@ fn issue8734() {
     let _ = [0u8, 1, 2, 3]
         .into_iter()
         .flat_map(|n| match n {
+            //~^ map_flatten
             1 => [n
                 .saturating_add(1)
                 .saturating_add(1)
@@ -54,6 +62,7 @@ fn issue8878() {
     std::collections::HashMap::<u32, u32>::new()
         .get(&0)
         .and_then(|_| {
+        //~^ map_flatten
 // we need some newlines
 // so that the span is big enough
 // for a split output of the diagnostic
diff --git a/src/tools/clippy/tests/ui/map_flatten_fixable.rs b/src/tools/clippy/tests/ui/map_flatten_fixable.rs
index 093fd9b6cae2..67a91ab94147 100644
--- a/src/tools/clippy/tests/ui/map_flatten_fixable.rs
+++ b/src/tools/clippy/tests/ui/map_flatten_fixable.rs
@@ -14,18 +14,25 @@ fn main() {
     let option_id_ref: fn(i8) -> Option<i8> = option_id;
     let option_id_closure = |x| Some(x);
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().collect();
+    //~^ map_flatten
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
+    //~^ map_flatten
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
+    //~^ map_flatten
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
+    //~^ map_flatten
 
     // mapping to Iterator on Iterator
     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
+    //~^ map_flatten
 
     // mapping to Option on Option
     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
+    //~^ map_flatten
 
     // mapping to Result on Result
     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
+    //~^ map_flatten
 
     issue8734();
     issue8878();
@@ -35,6 +42,7 @@ fn issue8734() {
     let _ = [0u8, 1, 2, 3]
         .into_iter()
         .map(|n| match n {
+            //~^ map_flatten
             1 => [n
                 .saturating_add(1)
                 .saturating_add(1)
@@ -55,6 +63,7 @@ fn issue8878() {
     std::collections::HashMap::<u32, u32>::new()
         .get(&0)
         .map(|_| {
+        //~^ map_flatten
 // we need some newlines
 // so that the span is big enough
 // for a split output of the diagnostic
diff --git a/src/tools/clippy/tests/ui/map_flatten_fixable.stderr b/src/tools/clippy/tests/ui/map_flatten_fixable.stderr
index 095bee52d6d7..05d4d9a6ad85 100644
--- a/src/tools/clippy/tests/ui/map_flatten_fixable.stderr
+++ b/src/tools/clippy/tests/ui/map_flatten_fixable.stderr
@@ -8,49 +8,49 @@ LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id).flatten().coll
    = help: to override `-D warnings` add `#[allow(clippy::map_flatten)]`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> tests/ui/map_flatten_fixable.rs:17:47
+  --> tests/ui/map_flatten_fixable.rs:18:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_ref).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id_ref)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> tests/ui/map_flatten_fixable.rs:18:47
+  --> tests/ui/map_flatten_fixable.rs:20:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(option_id_closure).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(option_id_closure)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> tests/ui/map_flatten_fixable.rs:19:47
+  --> tests/ui/map_flatten_fixable.rs:22:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| x.checked_add(1)).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `filter_map` and remove the `.flatten()`: `filter_map(|x| x.checked_add(1))`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> tests/ui/map_flatten_fixable.rs:22:47
+  --> tests/ui/map_flatten_fixable.rs:26:47
    |
 LL |     let _: Vec<_> = vec![5_i8; 6].into_iter().map(|x| 0..x).flatten().collect();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `flat_map` and remove the `.flatten()`: `flat_map(|x| 0..x)`
 
 error: called `map(..).flatten()` on `Option`
-  --> tests/ui/map_flatten_fixable.rs:25:40
+  --> tests/ui/map_flatten_fixable.rs:30:40
    |
 LL |     let _: Option<_> = (Some(Some(1))).map(|x| x).flatten();
    |                                        ^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `and_then` and remove the `.flatten()`: `and_then(|x| x)`
 
 error: called `map(..).flatten()` on `Result`
-  --> tests/ui/map_flatten_fixable.rs:28:42
+  --> tests/ui/map_flatten_fixable.rs:34:42
    |
 LL |     let _: Result<_, &str> = (Ok(Ok(1))).map(|x| x).flatten();
    |                                          ^^^^^^^^^^^^^^^^^^^^ help: try replacing `map` with `and_then` and remove the `.flatten()`: `and_then(|x| x)`
 
 error: called `map(..).flatten()` on `Iterator`
-  --> tests/ui/map_flatten_fixable.rs:37:10
+  --> tests/ui/map_flatten_fixable.rs:44:10
    |
 LL |           .map(|n| match n {
    |  __________^
+LL | |
 LL | |             1 => [n
 LL | |                 .saturating_add(1)
-LL | |                 .saturating_add(1)
 ...  |
 LL | |         })
 LL | |         .flatten();
@@ -59,6 +59,7 @@ LL | |         .flatten();
 help: try replacing `map` with `flat_map` and remove the `.flatten()`
    |
 LL ~         .flat_map(|n| match n {
+LL +
 LL +             1 => [n
 LL +                 .saturating_add(1)
 LL +                 .saturating_add(1)
@@ -73,7 +74,7 @@ LL ~         });
    |
 
 error: called `map(..).flatten()` on `Option`
-  --> tests/ui/map_flatten_fixable.rs:57:10
+  --> tests/ui/map_flatten_fixable.rs:65:10
    |
 LL |           .map(|_| {
    |  __________^
@@ -85,6 +86,7 @@ LL | |         .flatten();
 help: try replacing `map` with `and_then` and remove the `.flatten()`
    |
 LL ~         .and_then(|_| {
+LL +
 LL + // we need some newlines
 LL + // so that the span is big enough
 LL + // for a split output of the diagnostic
diff --git a/src/tools/clippy/tests/ui/map_identity.fixed b/src/tools/clippy/tests/ui/map_identity.fixed
index 3257ddc6f72b..83b2dac5fc51 100644
--- a/src/tools/clippy/tests/ui/map_identity.fixed
+++ b/src/tools/clippy/tests/ui/map_identity.fixed
@@ -5,8 +5,12 @@ fn main() {
     let x: [u16; 3] = [1, 2, 3];
     // should lint
     let _: Vec<_> = x.iter().map(not_identity).collect();
+    //~^ map_identity
     let _: Vec<_> = x.iter().collect();
+    //~^ map_identity
+    //~| map_identity
     let _: Option<u8> = Some(3);
+    //~^ map_identity
     let _: Result<i8, f32> = Ok(-3);
     // should not lint
     let _: Vec<_> = x.iter().map(|x| 2 * x).collect();
@@ -16,6 +20,7 @@ fn main() {
         return x + 3;
     });
     let _: Result<u32, u32> = Ok(1);
+    //~^ map_identity
     let _: Result<u32, u32> = Ok(1).map_err(|a: u32| a * 42);
     // : u32 guides type inference
     let _ = Ok(1).map_err(|a: u32| a);
@@ -26,11 +31,14 @@ fn issue7189() {
     // should lint
     let x = [(1, 2), (3, 4)].iter().copied();
     let _ = x.clone();
+    //~^ map_identity
     let _ = x.clone();
     let _ = x.clone();
+    //~^ map_identity
 
     let y = [(1, 2, (3, (4,))), (5, 6, (7, (8,)))].iter().copied();
     let _ = y.clone();
+    //~^ map_identity
 
     // should not lint
     let _ = x.clone().map(|(x, y)| (x, y, y));
@@ -60,6 +68,7 @@ fn issue11764() {
 
     // no match ergonomics for `(i32, i32)`
     let _ = x.iter().copied();
+    //~^ map_identity
 }
 
 fn issue13904() {
@@ -71,8 +80,10 @@ fn issue13904() {
     #[allow(unused_mut)]
     let mut it = [1, 2, 3].into_iter();
     let _ = it.next();
+    //~^ map_identity
 
     // lint
     let it = [1, 2, 3].into_iter();
     let _ = { it }.next();
+    //~^ map_identity
 }
diff --git a/src/tools/clippy/tests/ui/map_identity.rs b/src/tools/clippy/tests/ui/map_identity.rs
index be3bb9a4f106..e839c551364b 100644
--- a/src/tools/clippy/tests/ui/map_identity.rs
+++ b/src/tools/clippy/tests/ui/map_identity.rs
@@ -5,9 +5,14 @@ fn main() {
     let x: [u16; 3] = [1, 2, 3];
     // should lint
     let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
+    //~^ map_identity
     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
+    //~^ map_identity
+    //~| map_identity
     let _: Option<u8> = Some(3).map(|x| x);
+    //~^ map_identity
     let _: Result<i8, f32> = Ok(-3).map(|x| {
+        //~^ map_identity
         return x;
     });
     // should not lint
@@ -18,6 +23,7 @@ fn main() {
         return x + 3;
     });
     let _: Result<u32, u32> = Ok(1).map_err(|a| a);
+    //~^ map_identity
     let _: Result<u32, u32> = Ok(1).map_err(|a: u32| a * 42);
     // : u32 guides type inference
     let _ = Ok(1).map_err(|a: u32| a);
@@ -28,13 +34,17 @@ fn issue7189() {
     // should lint
     let x = [(1, 2), (3, 4)].iter().copied();
     let _ = x.clone().map(|(x, y)| (x, y));
+    //~^ map_identity
     let _ = x.clone().map(|(x, y)| {
+        //~^ map_identity
         return (x, y);
     });
     let _ = x.clone().map(|(x, y)| return (x, y));
+    //~^ map_identity
 
     let y = [(1, 2, (3, (4,))), (5, 6, (7, (8,)))].iter().copied();
     let _ = y.clone().map(|(x, y, (z, (w,)))| (x, y, (z, (w,))));
+    //~^ map_identity
 
     // should not lint
     let _ = x.clone().map(|(x, y)| (x, y, y));
@@ -64,6 +74,7 @@ fn issue11764() {
 
     // no match ergonomics for `(i32, i32)`
     let _ = x.iter().copied().map(|(x, y)| (x, y));
+    //~^ map_identity
 }
 
 fn issue13904() {
@@ -75,8 +86,10 @@ fn issue13904() {
     #[allow(unused_mut)]
     let mut it = [1, 2, 3].into_iter();
     let _ = it.map(|x| x).next();
+    //~^ map_identity
 
     // lint
     let it = [1, 2, 3].into_iter();
     let _ = { it }.map(|x| x).next();
+    //~^ map_identity
 }
diff --git a/src/tools/clippy/tests/ui/map_identity.stderr b/src/tools/clippy/tests/ui/map_identity.stderr
index aa3fc4ae0b5c..9836f3b4cc5f 100644
--- a/src/tools/clippy/tests/ui/map_identity.stderr
+++ b/src/tools/clippy/tests/ui/map_identity.stderr
@@ -8,79 +8,81 @@ LL |     let _: Vec<_> = x.iter().map(not_identity).map(|x| return x).collect();
    = help: to override `-D warnings` add `#[allow(clippy::map_identity)]`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:8:57
+  --> tests/ui/map_identity.rs:9:57
    |
 LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
    |                                                         ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:8:29
+  --> tests/ui/map_identity.rs:9:29
    |
 LL |     let _: Vec<_> = x.iter().map(std::convert::identity).map(|y| y).collect();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:9:32
+  --> tests/ui/map_identity.rs:12:32
    |
 LL |     let _: Option<u8> = Some(3).map(|x| x);
    |                                ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:10:36
+  --> tests/ui/map_identity.rs:14:36
    |
 LL |       let _: Result<i8, f32> = Ok(-3).map(|x| {
    |  ____________________________________^
+LL | |
 LL | |         return x;
 LL | |     });
    | |______^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:20:36
+  --> tests/ui/map_identity.rs:25:36
    |
 LL |     let _: Result<u32, u32> = Ok(1).map_err(|a| a);
    |                                    ^^^^^^^^^^^^^^^ help: remove the call to `map_err`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:30:22
+  --> tests/ui/map_identity.rs:36:22
    |
 LL |     let _ = x.clone().map(|(x, y)| (x, y));
    |                      ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:31:22
+  --> tests/ui/map_identity.rs:38:22
    |
 LL |       let _ = x.clone().map(|(x, y)| {
    |  ______________________^
+LL | |
 LL | |         return (x, y);
 LL | |     });
    | |______^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:34:22
+  --> tests/ui/map_identity.rs:42:22
    |
 LL |     let _ = x.clone().map(|(x, y)| return (x, y));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:37:22
+  --> tests/ui/map_identity.rs:46:22
    |
 LL |     let _ = y.clone().map(|(x, y, (z, (w,)))| (x, y, (z, (w,))));
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:66:30
+  --> tests/ui/map_identity.rs:76:30
    |
 LL |     let _ = x.iter().copied().map(|(x, y)| (x, y));
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:77:15
+  --> tests/ui/map_identity.rs:88:15
    |
 LL |     let _ = it.map(|x| x).next();
    |               ^^^^^^^^^^^ help: remove the call to `map`
 
 error: unnecessary map of the identity function
-  --> tests/ui/map_identity.rs:81:19
+  --> tests/ui/map_identity.rs:93:19
    |
 LL |     let _ = { it }.map(|x| x).next();
    |                   ^^^^^^^^^^^ help: remove the call to `map`
diff --git a/src/tools/clippy/tests/ui/map_unit_fn.rs b/src/tools/clippy/tests/ui/map_unit_fn.rs
index e7f07b50f3ab..3a810196a44d 100644
--- a/src/tools/clippy/tests/ui/map_unit_fn.rs
+++ b/src/tools/clippy/tests/ui/map_unit_fn.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![allow(unused)]
 struct Mappable;
 
diff --git a/src/tools/clippy/tests/ui/map_unwrap_or.rs b/src/tools/clippy/tests/ui/map_unwrap_or.rs
index dfaa8f24f987..fba81cb493cd 100644
--- a/src/tools/clippy/tests/ui/map_unwrap_or.rs
+++ b/src/tools/clippy/tests/ui/map_unwrap_or.rs
@@ -15,25 +15,31 @@ fn option_methods() {
     // Check for `option.map(_).unwrap_or(_)` use.
     // Single line case.
     let _ = opt.map(|x| x + 1)
+    //~^ map_unwrap_or
         // Should lint even though this call is on a separate line.
         .unwrap_or(0);
     // Multi-line cases.
     let _ = opt.map(|x| {
+    //~^ map_unwrap_or
         x + 1
     }
     ).unwrap_or(0);
     let _ = opt.map(|x| x + 1)
+    //~^ map_unwrap_or
         .unwrap_or({
             0
         });
     // Single line `map(f).unwrap_or(None)` case.
     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
+    //~^ map_unwrap_or
     // Multi-line `map(f).unwrap_or(None)` cases.
     let _ = opt.map(|x| {
+    //~^ map_unwrap_or
         Some(x + 1)
     }
     ).unwrap_or(None);
     let _ = opt
+    //~^ map_unwrap_or
         .map(|x| Some(x + 1))
         .unwrap_or(None);
     // macro case
@@ -45,20 +51,24 @@ fn option_methods() {
     // ...but DO lint if the `unwrap_or` argument is not used in the `map`
     let id: String = "identifier".to_string();
     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
+    //~^ map_unwrap_or
 
     // Check for `option.map(_).unwrap_or_else(_)` use.
     // Multi-line cases.
     let _ = opt.map(|x| {
+    //~^ map_unwrap_or
         x + 1
     }
     ).unwrap_or_else(|| 0);
     let _ = opt.map(|x| x + 1)
+    //~^ map_unwrap_or
         .unwrap_or_else(||
             0
         );
 
     // Check for `map(f).unwrap_or(false)` use.
     let _ = opt.map(|x| x > 5).unwrap_or(false);
+    //~^ map_unwrap_or
 
 }
 
@@ -69,10 +79,12 @@ fn result_methods() {
     // Check for `result.map(_).unwrap_or_else(_)` use.
     // multi line cases
     let _ = res.map(|x| {
+    //~^ map_unwrap_or
         x + 1
     }
     ).unwrap_or_else(|_e| 0);
     let _ = res.map(|x| x + 1)
+    //~^ map_unwrap_or
         .unwrap_or_else(|_e| {
             0
         });
@@ -97,6 +109,7 @@ fn msrv_1_41() {
     let res: Result<i32, ()> = Ok(1);
 
     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
+    //~^ map_unwrap_or
 }
 
 #[clippy::msrv = "1.69"]
@@ -104,6 +117,7 @@ fn msrv_1_69() {
     let opt: Option<i32> = Some(1);
 
     let _ = opt.map(|x| x > 5).unwrap_or(false);
+    //~^ map_unwrap_or
 }
 
 #[clippy::msrv = "1.70"]
@@ -111,6 +125,7 @@ fn msrv_1_70() {
     let opt: Option<i32> = Some(1);
 
     let _ = opt.map(|x| x > 5).unwrap_or(false);
+    //~^ map_unwrap_or
 }
 
 mod issue_10579 {
diff --git a/src/tools/clippy/tests/ui/map_unwrap_or.stderr b/src/tools/clippy/tests/ui/map_unwrap_or.stderr
index d6ddd09c188c..0b6c9b7fcf19 100644
--- a/src/tools/clippy/tests/ui/map_unwrap_or.stderr
+++ b/src/tools/clippy/tests/ui/map_unwrap_or.stderr
@@ -3,7 +3,7 @@ error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
    |
 LL |       let _ = opt.map(|x| x + 1)
    |  _____________^
-LL | |         // Should lint even though this call is on a separate line.
+...  |
 LL | |         .unwrap_or(0);
    | |_____________________^
    |
@@ -16,10 +16,11 @@ LL +     let _ = opt.map_or(0, |x| x + 1);
    |
 
 error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:21:13
+  --> tests/ui/map_unwrap_or.rs:22:13
    |
 LL |       let _ = opt.map(|x| {
    |  _____________^
+LL | |
 LL | |         x + 1
 LL | |     }
 LL | |     ).unwrap_or(0);
@@ -28,16 +29,18 @@ LL | |     ).unwrap_or(0);
 help: use `map_or(<a>, <f>)` instead
    |
 LL ~     let _ = opt.map_or(0, |x| {
+LL |
 LL |         x + 1
 LL |     }
 LL ~     );
    |
 
 error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:25:13
+  --> tests/ui/map_unwrap_or.rs:27:13
    |
 LL |       let _ = opt.map(|x| x + 1)
    |  _____________^
+LL | |
 LL | |         .unwrap_or({
 LL | |             0
 LL | |         });
@@ -51,7 +54,7 @@ LL ~         }, |x| x + 1);
    |
 
 error: called `map(<f>).unwrap_or(None)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:30:13
+  --> tests/ui/map_unwrap_or.rs:33:13
    |
 LL |     let _ = opt.map(|x| Some(x + 1)).unwrap_or(None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -63,10 +66,11 @@ LL +     let _ = opt.and_then(|x| Some(x + 1));
    |
 
 error: called `map(<f>).unwrap_or(None)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:32:13
+  --> tests/ui/map_unwrap_or.rs:36:13
    |
 LL |       let _ = opt.map(|x| {
    |  _____________^
+LL | |
 LL | |         Some(x + 1)
 LL | |     }
 LL | |     ).unwrap_or(None);
@@ -75,16 +79,18 @@ LL | |     ).unwrap_or(None);
 help: use `and_then(<f>)` instead
    |
 LL ~     let _ = opt.and_then(|x| {
+LL |
 LL |         Some(x + 1)
 LL |     }
 LL ~     );
    |
 
 error: called `map(<f>).unwrap_or(None)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:36:13
+  --> tests/ui/map_unwrap_or.rs:41:13
    |
 LL |       let _ = opt
    |  _____________^
+LL | |
 LL | |         .map(|x| Some(x + 1))
 LL | |         .unwrap_or(None);
    | |________________________^
@@ -96,7 +102,7 @@ LL +         .and_then(|x| Some(x + 1));
    |
 
 error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:47:13
+  --> tests/ui/map_unwrap_or.rs:53:13
    |
 LL |     let _ = Some("prefix").map(|p| format!("{}.", p)).unwrap_or(id);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,27 +114,29 @@ LL +     let _ = Some("prefix").map_or(id, |p| format!("{}.", p));
    |
 
 error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:51:13
+  --> tests/ui/map_unwrap_or.rs:58:13
    |
 LL |       let _ = opt.map(|x| {
    |  _____________^
+LL | |
 LL | |         x + 1
 LL | |     }
 LL | |     ).unwrap_or_else(|| 0);
    | |__________________________^
 
 error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:55:13
+  --> tests/ui/map_unwrap_or.rs:63:13
    |
 LL |       let _ = opt.map(|x| x + 1)
    |  _____________^
+LL | |
 LL | |         .unwrap_or_else(||
 LL | |             0
 LL | |         );
    | |_________^
 
 error: called `map(<f>).unwrap_or(false)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:61:13
+  --> tests/ui/map_unwrap_or.rs:70:13
    |
 LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -140,33 +148,35 @@ LL +     let _ = opt.is_some_and(|x| x > 5);
    |
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
-  --> tests/ui/map_unwrap_or.rs:71:13
+  --> tests/ui/map_unwrap_or.rs:81:13
    |
 LL |       let _ = res.map(|x| {
    |  _____________^
+LL | |
 LL | |         x + 1
 LL | |     }
 LL | |     ).unwrap_or_else(|_e| 0);
    | |____________________________^
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
-  --> tests/ui/map_unwrap_or.rs:75:13
+  --> tests/ui/map_unwrap_or.rs:86:13
    |
 LL |       let _ = res.map(|x| x + 1)
    |  _____________^
+LL | |
 LL | |         .unwrap_or_else(|_e| {
 LL | |             0
 LL | |         });
    | |__________^
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
-  --> tests/ui/map_unwrap_or.rs:99:13
+  --> tests/ui/map_unwrap_or.rs:111:13
    |
 LL |     let _ = res.map(|x| x + 1).unwrap_or_else(|_e| 0);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or_else(|_e| 0, |x| x + 1)`
 
 error: called `map(<f>).unwrap_or(<a>)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:106:13
+  --> tests/ui/map_unwrap_or.rs:119:13
    |
 LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -178,7 +188,7 @@ LL +     let _ = opt.map_or(false, |x| x > 5);
    |
 
 error: called `map(<f>).unwrap_or(false)` on an `Option` value
-  --> tests/ui/map_unwrap_or.rs:113:13
+  --> tests/ui/map_unwrap_or.rs:127:13
    |
 LL |     let _ = opt.map(|x| x > 5).unwrap_or(false);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/map_unwrap_or_fixable.rs b/src/tools/clippy/tests/ui/map_unwrap_or_fixable.rs
index d3d0ae0154c1..1078c7a3cf34 100644
--- a/src/tools/clippy/tests/ui/map_unwrap_or_fixable.rs
+++ b/src/tools/clippy/tests/ui/map_unwrap_or_fixable.rs
@@ -14,6 +14,7 @@ fn option_methods() {
     // Check for `option.map(_).unwrap_or_else(_)` use.
     // single line case
     let _ = opt.map(|x| x + 1)
+    //~^ map_unwrap_or
         // Should lint even though this call is on a separate line.
         .unwrap_or_else(|| 0);
 
@@ -44,6 +45,7 @@ fn result_methods() {
     // Check for `result.map(_).unwrap_or_else(_)` use.
     // single line case
     let _ = res.map(|x| x + 1)
+    //~^ map_unwrap_or
         // should lint even though this call is on a separate line
         .unwrap_or_else(|_e| 0);
 
diff --git a/src/tools/clippy/tests/ui/map_unwrap_or_fixable.stderr b/src/tools/clippy/tests/ui/map_unwrap_or_fixable.stderr
index 89a7c979f6e9..99e660f8dbd1 100644
--- a/src/tools/clippy/tests/ui/map_unwrap_or_fixable.stderr
+++ b/src/tools/clippy/tests/ui/map_unwrap_or_fixable.stderr
@@ -3,7 +3,7 @@ error: called `map(<f>).unwrap_or_else(<g>)` on an `Option` value
    |
 LL |       let _ = opt.map(|x| x + 1)
    |  _____________^
-LL | |         // Should lint even though this call is on a separate line.
+...  |
 LL | |         .unwrap_or_else(|| 0);
    | |_____________________________^ help: try: `opt.map_or_else(|| 0, |x| x + 1)`
    |
@@ -11,11 +11,11 @@ LL | |         .unwrap_or_else(|| 0);
    = help: to override `-D warnings` add `#[allow(clippy::map_unwrap_or)]`
 
 error: called `map(<f>).unwrap_or_else(<g>)` on a `Result` value
-  --> tests/ui/map_unwrap_or_fixable.rs:46:13
+  --> tests/ui/map_unwrap_or_fixable.rs:47:13
    |
 LL |       let _ = res.map(|x| x + 1)
    |  _____________^
-LL | |         // should lint even though this call is on a separate line
+...  |
 LL | |         .unwrap_or_else(|_e| 0);
    | |_______________________________^ help: try: `res.map_or_else(|_e| 0, |x| x + 1)`
 
diff --git a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.fixed b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.fixed
index 18716e93d1e9..254c46ecae38 100644
--- a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.fixed
+++ b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.fixed
@@ -23,27 +23,43 @@ macro_rules! r#gen {
 fn main() {
     // These should be raised
     std::iter::repeat_with(|| do_something()).take(10);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(10);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(11);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(7);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(8);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_n(3, 10);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| {
+        //~^ map_with_unused_argument_over_ranges
         let x = 3;
         x + 2
     }).take(10);
     std::iter::repeat_with(|| do_something()).take(10).collect::<Vec<_>>();
+    //~^ map_with_unused_argument_over_ranges
     let upper = 4;
     std::iter::repeat_with(|| do_something()).take(upper);
+    //~^ map_with_unused_argument_over_ranges
     let upper_fn = || 4;
     std::iter::repeat_with(|| do_something()).take(upper_fn());
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(upper_fn() + 1);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(upper_fn() - 2);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(upper_fn() - 1);
+    //~^ map_with_unused_argument_over_ranges
     (-3..9).map(|_| do_something());
     std::iter::repeat_with(|| do_something()).take(0);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take(1);
+    //~^ map_with_unused_argument_over_ranges
     std::iter::repeat_with(|| do_something()).take((1 << 4) - 0);
+    //~^ map_with_unused_argument_over_ranges
     // These should not be raised
     r#gen!();
     let lower = 2;
@@ -65,9 +81,11 @@ fn msrv_1_27() {
 #[clippy::msrv = "1.28"]
 fn msrv_1_28() {
     std::iter::repeat_with(|| do_something()).take(10);
+    //~^ map_with_unused_argument_over_ranges
 }
 
 #[clippy::msrv = "1.81"]
 fn msrv_1_82() {
     std::iter::repeat(3).take(10);
+    //~^ map_with_unused_argument_over_ranges
 }
diff --git a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.rs b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.rs
index 596afd51e61f..05c8d64f8012 100644
--- a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.rs
+++ b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.rs
@@ -23,27 +23,43 @@ macro_rules! r#gen {
 fn main() {
     // These should be raised
     (0..10).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (0..10).map(|_foo| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (0..=10).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (3..10).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (3..=10).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (0..10).map(|_| 3);
+    //~^ map_with_unused_argument_over_ranges
     (0..10).map(|_| {
+        //~^ map_with_unused_argument_over_ranges
         let x = 3;
         x + 2
     });
     (0..10).map(|_| do_something()).collect::<Vec<_>>();
+    //~^ map_with_unused_argument_over_ranges
     let upper = 4;
     (0..upper).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     let upper_fn = || 4;
     (0..upper_fn()).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (0..=upper_fn()).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (2..upper_fn()).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (2..=upper_fn()).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (-3..9).map(|_| do_something());
     (9..3).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (9..=9).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     (1..=1 << 4).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
     // These should not be raised
     r#gen!();
     let lower = 2;
@@ -65,9 +81,11 @@ fn msrv_1_27() {
 #[clippy::msrv = "1.28"]
 fn msrv_1_28() {
     (0..10).map(|_| do_something());
+    //~^ map_with_unused_argument_over_ranges
 }
 
 #[clippy::msrv = "1.81"]
 fn msrv_1_82() {
     (0..10).map(|_| 3);
+    //~^ map_with_unused_argument_over_ranges
 }
diff --git a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.stderr b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.stderr
index 840515f95df4..e5c93ceac02a 100644
--- a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.stderr
+++ b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges.stderr
@@ -13,7 +13,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(10);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:26:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:27:5
    |
 LL |     (0..10).map(|_foo| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(10);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:27:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:29:5
    |
 LL |     (0..=10).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(11);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:28:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:31:5
    |
 LL |     (3..10).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(7);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:29:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:33:5
    |
 LL |     (3..=10).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(8);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:30:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:35:5
    |
 LL |     (0..10).map(|_| 3);
    |     ^^^^^^^^^^^^^^^^^^
@@ -73,9 +73,10 @@ LL +     std::iter::repeat_n(3, 10);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:31:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:37:5
    |
 LL | /     (0..10).map(|_| {
+LL | |
 LL | |         let x = 3;
 LL | |         x + 2
 LL | |     });
@@ -84,13 +85,14 @@ LL | |     });
 help: remove the explicit range and use `repeat_with` and `take`
    |
 LL ~     std::iter::repeat_with(|| {
+LL |
 LL |         let x = 3;
 LL |         x + 2
 LL ~     }).take(10);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:35:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:42:5
    |
 LL |     (0..10).map(|_| do_something()).collect::<Vec<_>>();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -102,7 +104,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(10).collect::<Vec<_>>();
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:37:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:45:5
    |
 LL |     (0..upper).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,7 +116,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(upper);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:39:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:48:5
    |
 LL |     (0..upper_fn()).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -126,7 +128,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(upper_fn());
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:40:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:50:5
    |
 LL |     (0..=upper_fn()).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -138,7 +140,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(upper_fn() + 1);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:41:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:52:5
    |
 LL |     (2..upper_fn()).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -150,7 +152,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(upper_fn() - 2);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:42:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:54:5
    |
 LL |     (2..=upper_fn()).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -162,7 +164,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(upper_fn() - 1);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:44:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:57:5
    |
 LL |     (9..3).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -174,7 +176,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(0);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:45:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:59:5
    |
 LL |     (9..=9).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -186,7 +188,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(1);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:46:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:61:5
    |
 LL |     (1..=1 << 4).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -198,7 +200,7 @@ LL +     std::iter::repeat_with(|| do_something()).take((1 << 4) - 0);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:67:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:83:5
    |
 LL |     (0..10).map(|_| do_something());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -210,7 +212,7 @@ LL +     std::iter::repeat_with(|| do_something()).take(10);
    |
 
 error: map of a closure that does not depend on its parameter over a range
-  --> tests/ui/map_with_unused_argument_over_ranges.rs:72:5
+  --> tests/ui/map_with_unused_argument_over_ranges.rs:89:5
    |
 LL |     (0..10).map(|_| 3);
    |     ^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.fixed b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.fixed
index 65e59774905c..15a2780da440 100644
--- a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.fixed
+++ b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.fixed
@@ -5,4 +5,5 @@ use alloc::vec::Vec;
 
 fn nostd(v: &mut [i32]) {
     let _: Vec<_> = core::iter::repeat_n(3 + 1, 10).collect();
+    //~^ map_with_unused_argument_over_ranges
 }
diff --git a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.rs b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.rs
index dda7a69b33f9..58de71facebb 100644
--- a/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.rs
+++ b/src/tools/clippy/tests/ui/map_with_unused_argument_over_ranges_nostd.rs
@@ -5,4 +5,5 @@ use alloc::vec::Vec;
 
 fn nostd(v: &mut [i32]) {
     let _: Vec<_> = (0..10).map(|_| 3 + 1).collect();
+    //~^ map_with_unused_argument_over_ranges
 }
diff --git a/src/tools/clippy/tests/ui/match_as_ref.rs b/src/tools/clippy/tests/ui/match_as_ref.rs
index 655e16623697..3a5b1227331e 100644
--- a/src/tools/clippy/tests/ui/match_as_ref.rs
+++ b/src/tools/clippy/tests/ui/match_as_ref.rs
@@ -4,12 +4,14 @@
 fn match_as_ref() {
     let owned: Option<()> = None;
     let borrowed: Option<&()> = match owned {
+        //~^ match_as_ref
         None => None,
         Some(ref v) => Some(v),
     };
 
     let mut mut_owned: Option<()> = None;
     let borrow_mut: Option<&mut ()> = match mut_owned {
+        //~^ match_as_ref
         None => None,
         Some(ref mut v) => Some(v),
     };
@@ -28,6 +30,7 @@ mod issue4437 {
     impl Error for E {
         fn source(&self) -> Option<&(dyn Error + 'static)> {
             match self.source {
+                //~^ match_as_ref
                 Some(ref s) => Some(s),
                 None => None,
             }
diff --git a/src/tools/clippy/tests/ui/match_as_ref.stderr b/src/tools/clippy/tests/ui/match_as_ref.stderr
index 97b121424d93..7b40cb80dc6e 100644
--- a/src/tools/clippy/tests/ui/match_as_ref.stderr
+++ b/src/tools/clippy/tests/ui/match_as_ref.stderr
@@ -3,6 +3,7 @@ error: use `as_ref()` instead
    |
 LL |       let borrowed: Option<&()> = match owned {
    |  _________________________________^
+LL | |
 LL | |         None => None,
 LL | |         Some(ref v) => Some(v),
 LL | |     };
@@ -12,19 +13,21 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::match_as_ref)]`
 
 error: use `as_mut()` instead
-  --> tests/ui/match_as_ref.rs:12:39
+  --> tests/ui/match_as_ref.rs:13:39
    |
 LL |       let borrow_mut: Option<&mut ()> = match mut_owned {
    |  _______________________________________^
+LL | |
 LL | |         None => None,
 LL | |         Some(ref mut v) => Some(v),
 LL | |     };
    | |_____^ help: try: `mut_owned.as_mut()`
 
 error: use `as_ref()` instead
-  --> tests/ui/match_as_ref.rs:30:13
+  --> tests/ui/match_as_ref.rs:32:13
    |
 LL | /             match self.source {
+LL | |
 LL | |                 Some(ref s) => Some(s),
 LL | |                 None => None,
 LL | |             }
diff --git a/src/tools/clippy/tests/ui/match_bool.fixed b/src/tools/clippy/tests/ui/match_bool.fixed
index 61a8e54fa10c..1dfb82db1206 100644
--- a/src/tools/clippy/tests/ui/match_bool.fixed
+++ b/src/tools/clippy/tests/ui/match_bool.fixed
@@ -55,4 +55,10 @@ fn match_bool() {
     if !(!test && option == 5) { println!("Hello") };
 }
 
+fn issue14099() {
+    if true { 'a: {
+        break 'a;
+    } }
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/match_bool.rs b/src/tools/clippy/tests/ui/match_bool.rs
index 9c81d2917869..719b4e51eb6d 100644
--- a/src/tools/clippy/tests/ui/match_bool.rs
+++ b/src/tools/clippy/tests/ui/match_bool.rs
@@ -5,20 +5,20 @@ fn match_bool() {
     let test: bool = true;
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         true => 0,
         false => 42,
     };
 
     let option = 1;
     match option == 1 {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         true => 1,
         false => 0,
     };
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         true => (),
         false => {
             println!("Noooo!");
@@ -26,7 +26,7 @@ fn match_bool() {
     };
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         false => {
             println!("Noooo!");
         },
@@ -34,7 +34,7 @@ fn match_bool() {
     };
 
     match test && test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         false => {
             println!("Noooo!");
         },
@@ -42,7 +42,7 @@ fn match_bool() {
     };
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         false => {
             println!("Noooo!");
         },
@@ -67,40 +67,50 @@ fn match_bool() {
     };
 
     let _ = match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         true if option == 5 => 10,
         _ => 1,
     };
 
     let _ = match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         false if option == 5 => 10,
         _ => 1,
     };
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         true if option == 5 => println!("Hello"),
         _ => (),
     };
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         true if option == 5 => (),
         _ => println!("Hello"),
     };
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         false if option == 5 => println!("Hello"),
         _ => (),
     };
 
     match test {
-        //~^ ERROR: `match` on a boolean expression
+        //~^ match_bool
         false if option == 5 => (),
         _ => println!("Hello"),
     };
 }
 
+fn issue14099() {
+    match true {
+        //~^ match_bool
+        true => 'a: {
+            break 'a;
+        },
+        _ => (),
+    }
+}
+
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/match_bool.stderr b/src/tools/clippy/tests/ui/match_bool.stderr
index a4e504a0a82e..c05742e56339 100644
--- a/src/tools/clippy/tests/ui/match_bool.stderr
+++ b/src/tools/clippy/tests/ui/match_bool.stderr
@@ -164,5 +164,24 @@ LL | |         _ => println!("Hello"),
 LL | |     };
    | |_____^ help: consider using an `if`/`else` expression: `if !(!test && option == 5) { println!("Hello") }`
 
-error: aborting due to 12 previous errors
+error: `match` on a boolean expression
+  --> tests/ui/match_bool.rs:107:5
+   |
+LL | /     match true {
+LL | |
+LL | |         true => 'a: {
+LL | |             break 'a;
+LL | |         },
+LL | |         _ => (),
+LL | |     }
+   | |_____^
+   |
+help: consider using an `if`/`else` expression
+   |
+LL ~     if true { 'a: {
+LL +         break 'a;
+LL +     } }
+   |
+
+error: aborting due to 13 previous errors
 
diff --git a/src/tools/clippy/tests/ui/match_expr_like_matches_macro.fixed b/src/tools/clippy/tests/ui/match_expr_like_matches_macro.fixed
index 05edc024ba9f..8530ab16bfd7 100644
--- a/src/tools/clippy/tests/ui/match_expr_like_matches_macro.fixed
+++ b/src/tools/clippy/tests/ui/match_expr_like_matches_macro.fixed
@@ -12,18 +12,23 @@ fn main() {
 
     // Lint
     let _y = matches!(x, Some(0));
+    //~^^^^ match_like_matches_macro
 
     // Lint
     let _w = x.is_some();
+    //~^^^^ redundant_pattern_matching
 
     // Turn into is_none
     let _z = x.is_none();
+    //~^^^^ redundant_pattern_matching
 
     // Lint
     let _zz = !matches!(x, Some(r) if r == 0);
+    //~^^^^ match_like_matches_macro
 
     // Lint
     let _zzz = matches!(x, Some(5));
+    //~^ match_like_matches_macro
 
     // No lint
     let _a = match x {
@@ -48,16 +53,19 @@ fn main() {
     {
         // lint
         let _ans = matches!(x, E::A(_) | E::B(_));
+        //~^^^^^ match_like_matches_macro
     }
     {
         // lint
         // skip rustfmt to prevent removing block for first pattern
         #[rustfmt::skip]
         let _ans = matches!(x, E::A(_) | E::B(_));
+        //~^^^^^^^ match_like_matches_macro
     }
     {
         // lint
         let _ans = !matches!(x, E::B(_) | E::C);
+        //~^^^^^ match_like_matches_macro
     }
     {
         // no lint
@@ -114,12 +122,14 @@ fn main() {
         // should print "z" in suggestion (#6503)
         let z = &Some(3);
         let _z = matches!(z, Some(3));
+        //~^^^^ match_like_matches_macro
     }
 
     {
         // this could also print "z" in suggestion..?
         let z = Some(3);
         let _z = matches!(&z, Some(3));
+        //~^^^^ match_like_matches_macro
     }
 
     {
@@ -134,6 +144,7 @@ fn main() {
             let z = AnEnum::X;
             // we can't remove the reference here!
             let _ = matches!(&z, AnEnum::X);
+            //~^^^^ match_like_matches_macro
             foo(z);
         }
     }
@@ -145,6 +156,7 @@ fn main() {
         let val = Some(S(42));
         // we need the reference here because later val is consumed by fun()
         let _res = matches!(&val, &Some(ref _a));
+        //~^^^^ match_like_matches_macro
         fun(val);
     }
 
@@ -154,6 +166,7 @@ fn main() {
         fn fun(_val: Option<S>) {}
         let val = Some(S(42));
         let _res = matches!(&val, &Some(ref _a));
+        //~^^^^ match_like_matches_macro
         fun(val);
     }
 
@@ -209,4 +222,5 @@ fn msrv_1_41() {
 #[clippy::msrv = "1.42"]
 fn msrv_1_42() {
     let _y = matches!(Some(5), Some(0));
+    //~^^^^ match_like_matches_macro
 }
diff --git a/src/tools/clippy/tests/ui/match_expr_like_matches_macro.rs b/src/tools/clippy/tests/ui/match_expr_like_matches_macro.rs
index d6a0313cde43..81017936889e 100644
--- a/src/tools/clippy/tests/ui/match_expr_like_matches_macro.rs
+++ b/src/tools/clippy/tests/ui/match_expr_like_matches_macro.rs
@@ -15,27 +15,32 @@ fn main() {
         Some(0) => true,
         _ => false,
     };
+    //~^^^^ match_like_matches_macro
 
     // Lint
     let _w = match x {
         Some(_) => true,
         _ => false,
     };
+    //~^^^^ redundant_pattern_matching
 
     // Turn into is_none
     let _z = match x {
         Some(_) => false,
         None => true,
     };
+    //~^^^^ redundant_pattern_matching
 
     // Lint
     let _zz = match x {
         Some(r) if r == 0 => false,
         _ => true,
     };
+    //~^^^^ match_like_matches_macro
 
     // Lint
     let _zzz = if let Some(5) = x { true } else { false };
+    //~^ match_like_matches_macro
 
     // No lint
     let _a = match x {
@@ -64,6 +69,7 @@ fn main() {
             E::B(_) => true,
             _ => false,
         };
+        //~^^^^^ match_like_matches_macro
     }
     {
         // lint
@@ -76,6 +82,7 @@ fn main() {
             E::B(_) => true,
             _ => false,
         };
+        //~^^^^^^^ match_like_matches_macro
     }
     {
         // lint
@@ -84,6 +91,7 @@ fn main() {
             E::C => false,
             _ => true,
         };
+        //~^^^^^ match_like_matches_macro
     }
     {
         // no lint
@@ -143,6 +151,7 @@ fn main() {
             Some(3) => true,
             _ => false,
         };
+        //~^^^^ match_like_matches_macro
     }
 
     {
@@ -152,6 +161,7 @@ fn main() {
             Some(3) => true,
             _ => false,
         };
+        //~^^^^ match_like_matches_macro
     }
 
     {
@@ -169,6 +179,7 @@ fn main() {
                 AnEnum::X => true,
                 _ => false,
             };
+            //~^^^^ match_like_matches_macro
             foo(z);
         }
     }
@@ -183,6 +194,7 @@ fn main() {
             &Some(ref _a) => true,
             _ => false,
         };
+        //~^^^^ match_like_matches_macro
         fun(val);
     }
 
@@ -195,6 +207,7 @@ fn main() {
             &Some(ref _a) => true,
             _ => false,
         };
+        //~^^^^ match_like_matches_macro
         fun(val);
     }
 
@@ -253,4 +266,5 @@ fn msrv_1_42() {
         Some(0) => true,
         _ => false,
     };
+    //~^^^^ match_like_matches_macro
 }
diff --git a/src/tools/clippy/tests/ui/match_expr_like_matches_macro.stderr b/src/tools/clippy/tests/ui/match_expr_like_matches_macro.stderr
index ffe5772ece90..8fceb05bc6e8 100644
--- a/src/tools/clippy/tests/ui/match_expr_like_matches_macro.stderr
+++ b/src/tools/clippy/tests/ui/match_expr_like_matches_macro.stderr
@@ -12,7 +12,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::match_like_matches_macro)]`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/match_expr_like_matches_macro.rs:20:14
+  --> tests/ui/match_expr_like_matches_macro.rs:21:14
    |
 LL |       let _w = match x {
    |  ______________^
@@ -25,7 +25,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/match_expr_like_matches_macro.rs:26:14
+  --> tests/ui/match_expr_like_matches_macro.rs:28:14
    |
 LL |       let _z = match x {
    |  ______________^
@@ -35,7 +35,7 @@ LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:32:15
+  --> tests/ui/match_expr_like_matches_macro.rs:35:15
    |
 LL |       let _zz = match x {
    |  _______________^
@@ -45,13 +45,13 @@ LL | |     };
    | |_____^ help: try: `!matches!(x, Some(r) if r == 0)`
 
 error: if let .. else expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:38:16
+  --> tests/ui/match_expr_like_matches_macro.rs:42:16
    |
 LL |     let _zzz = if let Some(5) = x { true } else { false };
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(x, Some(5))`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:62:20
+  --> tests/ui/match_expr_like_matches_macro.rs:67:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -62,7 +62,7 @@ LL | |         };
    | |_________^ help: try: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:72:20
+  --> tests/ui/match_expr_like_matches_macro.rs:78:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -74,7 +74,7 @@ LL | |         };
    | |_________^ help: try: `matches!(x, E::A(_) | E::B(_))`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:82:20
+  --> tests/ui/match_expr_like_matches_macro.rs:89:20
    |
 LL |           let _ans = match x {
    |  ____________________^
@@ -85,7 +85,7 @@ LL | |         };
    | |_________^ help: try: `!matches!(x, E::B(_) | E::C)`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:142:18
+  --> tests/ui/match_expr_like_matches_macro.rs:150:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -95,7 +95,7 @@ LL | |         };
    | |_________^ help: try: `matches!(z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:151:18
+  --> tests/ui/match_expr_like_matches_macro.rs:160:18
    |
 LL |           let _z = match &z {
    |  __________________^
@@ -105,7 +105,7 @@ LL | |         };
    | |_________^ help: try: `matches!(&z, Some(3))`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:168:21
+  --> tests/ui/match_expr_like_matches_macro.rs:178:21
    |
 LL |               let _ = match &z {
    |  _____________________^
@@ -115,7 +115,7 @@ LL | |             };
    | |_____________^ help: try: `matches!(&z, AnEnum::X)`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:182:20
+  --> tests/ui/match_expr_like_matches_macro.rs:193:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -125,7 +125,7 @@ LL | |         };
    | |_________^ help: try: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:194:20
+  --> tests/ui/match_expr_like_matches_macro.rs:206:20
    |
 LL |           let _res = match &val {
    |  ____________________^
@@ -135,7 +135,7 @@ LL | |         };
    | |_________^ help: try: `matches!(&val, &Some(ref _a))`
 
 error: match expression looks like `matches!` macro
-  --> tests/ui/match_expr_like_matches_macro.rs:252:14
+  --> tests/ui/match_expr_like_matches_macro.rs:265:14
    |
 LL |       let _y = match Some(5) {
    |  ______________^
diff --git a/src/tools/clippy/tests/ui/match_on_vec_items.rs b/src/tools/clippy/tests/ui/match_on_vec_items.rs
index f7b8500faa4a..f3174ec9734d 100644
--- a/src/tools/clippy/tests/ui/match_on_vec_items.rs
+++ b/src/tools/clippy/tests/ui/match_on_vec_items.rs
@@ -8,8 +8,7 @@ fn match_with_wildcard() {
 
     // Lint, may panic
     match arr[idx] {
-        //~^ ERROR: indexing into a vector may panic
-        //~| NOTE: `-D clippy::match-on-vec-items` implied by `-D warnings`
+        //~^ match_on_vec_items
         0 => println!("0"),
         1 => println!("1"),
         _ => {},
@@ -17,7 +16,7 @@ fn match_with_wildcard() {
 
     // Lint, may panic
     match arr[range] {
-        //~^ ERROR: indexing into a vector may panic
+        //~^ match_on_vec_items
         [0, 1] => println!("0 1"),
         [1, 2] => println!("1 2"),
         _ => {},
@@ -31,7 +30,7 @@ fn match_without_wildcard() {
 
     // Lint, may panic
     match arr[idx] {
-        //~^ ERROR: indexing into a vector may panic
+        //~^ match_on_vec_items
         0 => println!("0"),
         1 => println!("1"),
         num => {},
@@ -39,7 +38,7 @@ fn match_without_wildcard() {
 
     // Lint, may panic
     match arr[range] {
-        //~^ ERROR: indexing into a vector may panic
+        //~^ match_on_vec_items
         [0, 1] => println!("0 1"),
         [1, 2] => println!("1 2"),
         [ref sub @ ..] => {},
@@ -53,7 +52,7 @@ fn match_wildcard_and_action() {
 
     // Lint, may panic
     match arr[idx] {
-        //~^ ERROR: indexing into a vector may panic
+        //~^ match_on_vec_items
         0 => println!("0"),
         1 => println!("1"),
         _ => println!("Hello, World!"),
@@ -61,7 +60,7 @@ fn match_wildcard_and_action() {
 
     // Lint, may panic
     match arr[range] {
-        //~^ ERROR: indexing into a vector may panic
+        //~^ match_on_vec_items
         [0, 1] => println!("0 1"),
         [1, 2] => println!("1 2"),
         _ => println!("Hello, World!"),
@@ -75,7 +74,7 @@ fn match_vec_ref() {
 
     // Lint, may panic
     match arr[idx] {
-        //~^ ERROR: indexing into a vector may panic
+        //~^ match_on_vec_items
         0 => println!("0"),
         1 => println!("1"),
         _ => {},
@@ -83,7 +82,7 @@ fn match_vec_ref() {
 
     // Lint, may panic
     match arr[range] {
-        //~^ ERROR: indexing into a vector may panic
+        //~^ match_on_vec_items
         [0, 1] => println!("0 1"),
         [1, 2] => println!("1 2"),
         _ => {},
diff --git a/src/tools/clippy/tests/ui/match_on_vec_items.stderr b/src/tools/clippy/tests/ui/match_on_vec_items.stderr
index e31db3784137..ae79e1305f7f 100644
--- a/src/tools/clippy/tests/ui/match_on_vec_items.stderr
+++ b/src/tools/clippy/tests/ui/match_on_vec_items.stderr
@@ -8,43 +8,43 @@ LL |     match arr[idx] {
    = help: to override `-D warnings` add `#[allow(clippy::match_on_vec_items)]`
 
 error: indexing into a vector may panic
-  --> tests/ui/match_on_vec_items.rs:19:11
+  --> tests/ui/match_on_vec_items.rs:18:11
    |
 LL |     match arr[range] {
    |           ^^^^^^^^^^ help: try: `arr.get(range)`
 
 error: indexing into a vector may panic
-  --> tests/ui/match_on_vec_items.rs:33:11
+  --> tests/ui/match_on_vec_items.rs:32:11
    |
 LL |     match arr[idx] {
    |           ^^^^^^^^ help: try: `arr.get(idx)`
 
 error: indexing into a vector may panic
-  --> tests/ui/match_on_vec_items.rs:41:11
+  --> tests/ui/match_on_vec_items.rs:40:11
    |
 LL |     match arr[range] {
    |           ^^^^^^^^^^ help: try: `arr.get(range)`
 
 error: indexing into a vector may panic
-  --> tests/ui/match_on_vec_items.rs:55:11
+  --> tests/ui/match_on_vec_items.rs:54:11
    |
 LL |     match arr[idx] {
    |           ^^^^^^^^ help: try: `arr.get(idx)`
 
 error: indexing into a vector may panic
-  --> tests/ui/match_on_vec_items.rs:63:11
+  --> tests/ui/match_on_vec_items.rs:62:11
    |
 LL |     match arr[range] {
    |           ^^^^^^^^^^ help: try: `arr.get(range)`
 
 error: indexing into a vector may panic
-  --> tests/ui/match_on_vec_items.rs:77:11
+  --> tests/ui/match_on_vec_items.rs:76:11
    |
 LL |     match arr[idx] {
    |           ^^^^^^^^ help: try: `arr.get(idx)`
 
 error: indexing into a vector may panic
-  --> tests/ui/match_on_vec_items.rs:85:11
+  --> tests/ui/match_on_vec_items.rs:84:11
    |
 LL |     match arr[range] {
    |           ^^^^^^^^^^ help: try: `arr.get(range)`
diff --git a/src/tools/clippy/tests/ui/match_overlapping_arm.rs b/src/tools/clippy/tests/ui/match_overlapping_arm.rs
index a056fdeaa5d0..176287e3d2e0 100644
--- a/src/tools/clippy/tests/ui/match_overlapping_arm.rs
+++ b/src/tools/clippy/tests/ui/match_overlapping_arm.rs
@@ -7,14 +7,14 @@ fn overlapping() {
 
     match 42 {
         0..=10 => println!("0..=10"),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         0..=11 => println!("0..=11"),
         _ => (),
     }
 
     match 42 {
         0..=5 => println!("0..=5"),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         6..=7 => println!("6..=7"),
         FOO..=11 => println!("FOO..=11"),
         _ => (),
@@ -52,7 +52,7 @@ fn overlapping() {
 
     match 42 {
         0..11 => println!("0..11"),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         0..=11 => println!("0..=11"),
         _ => (),
     }
@@ -78,13 +78,13 @@ fn overlapping() {
     match 42 {
         5..14 => println!("5..14"),
         0..=10 => println!("0..=10"),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         _ => (),
     }
 
     match 42 {
         0..7 => println!("0..7"),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         0..=10 => println!("0..=10"),
         _ => (),
     }
@@ -97,7 +97,7 @@ fn overlapping() {
 
     match 42 {
         ..=23 => println!("..=23"),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         ..26 => println!("..26"),
         _ => (),
     }
@@ -107,7 +107,7 @@ fn overlapping() {
         5..=10 => (),
         0..=20 => (),
         21..=30 => (),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         21..=40 => (),
         _ => (),
     }
@@ -122,7 +122,7 @@ fn overlapping() {
     // Only warn about the first if there are multiple overlaps
     match 42u128 {
         0..=0x0000_0000_0000_00ff => (),
-        //~^ ERROR: some ranges overlap
+        //~^ match_overlapping_arm
         0..=0x0000_0000_0000_ffff => (),
         0..=0x0000_0000_ffff_ffff => (),
         0..=0xffff_ffff_ffff_ffff => (),
diff --git a/src/tools/clippy/tests/ui/match_ref_pats.fixed b/src/tools/clippy/tests/ui/match_ref_pats.fixed
index f8d47b0fdc7d..8add3da0c99f 100644
--- a/src/tools/clippy/tests/ui/match_ref_pats.fixed
+++ b/src/tools/clippy/tests/ui/match_ref_pats.fixed
@@ -6,6 +6,7 @@ fn ref_pats() {
     {
         let v = &Some(0);
         match *v {
+            //~^ match_ref_pats
             Some(v) => println!("{:?}", v),
             None => println!("none"),
         }
@@ -23,6 +24,7 @@ fn ref_pats() {
     // Special case: using `&` both in expr and pats.
     let w = Some(0);
     match w {
+        //~^ match_ref_pats
         Some(v) => println!("{:?}", v),
         None => println!("none"),
     }
@@ -35,11 +37,13 @@ fn ref_pats() {
 
     let a = &Some(0);
     if a.is_none() {
+        //~^ redundant_pattern_matching
         println!("none");
     }
 
     let b = Some(0);
     if b.is_none() {
+        //~^ redundant_pattern_matching
         println!("none");
     }
 }
@@ -100,6 +104,7 @@ mod issue_7740 {
     fn issue_7740() {
         // Issue #7740
         match *foobar_variant!(0) {
+            //~^ match_ref_pats
             FooBar::Foo => println!("Foo"),
             FooBar::Bar => println!("Bar"),
             FooBar::FooBar => println!("FooBar"),
diff --git a/src/tools/clippy/tests/ui/match_ref_pats.rs b/src/tools/clippy/tests/ui/match_ref_pats.rs
index bcd7bf7ab51b..07889b0dfc24 100644
--- a/src/tools/clippy/tests/ui/match_ref_pats.rs
+++ b/src/tools/clippy/tests/ui/match_ref_pats.rs
@@ -6,6 +6,7 @@ fn ref_pats() {
     {
         let v = &Some(0);
         match v {
+            //~^ match_ref_pats
             &Some(v) => println!("{:?}", v),
             &None => println!("none"),
         }
@@ -23,6 +24,7 @@ fn ref_pats() {
     // Special case: using `&` both in expr and pats.
     let w = Some(0);
     match &w {
+        //~^ match_ref_pats
         &Some(v) => println!("{:?}", v),
         &None => println!("none"),
     }
@@ -35,11 +37,13 @@ fn ref_pats() {
 
     let a = &Some(0);
     if let &None = a {
+        //~^ redundant_pattern_matching
         println!("none");
     }
 
     let b = Some(0);
     if let &None = &b {
+        //~^ redundant_pattern_matching
         println!("none");
     }
 }
@@ -100,6 +104,7 @@ mod issue_7740 {
     fn issue_7740() {
         // Issue #7740
         match foobar_variant!(0) {
+            //~^ match_ref_pats
             &FooBar::Foo => println!("Foo"),
             &FooBar::Bar => println!("Bar"),
             &FooBar::FooBar => println!("FooBar"),
diff --git a/src/tools/clippy/tests/ui/match_ref_pats.stderr b/src/tools/clippy/tests/ui/match_ref_pats.stderr
index fc01ab0a919a..f81b290b32cb 100644
--- a/src/tools/clippy/tests/ui/match_ref_pats.stderr
+++ b/src/tools/clippy/tests/ui/match_ref_pats.stderr
@@ -2,6 +2,7 @@ error: you don't need to add `&` to all patterns
   --> tests/ui/match_ref_pats.rs:8:9
    |
 LL | /         match v {
+LL | |
 LL | |             &Some(v) => println!("{:?}", v),
 LL | |             &None => println!("none"),
 LL | |         }
@@ -12,14 +13,16 @@ LL | |         }
 help: instead of prefixing all patterns with `&`, you can dereference the expression
    |
 LL ~         match *v {
+LL |
 LL ~             Some(v) => println!("{:?}", v),
 LL ~             None => println!("none"),
    |
 
 error: you don't need to add `&` to both the expression and the patterns
-  --> tests/ui/match_ref_pats.rs:25:5
+  --> tests/ui/match_ref_pats.rs:26:5
    |
 LL | /     match &w {
+LL | |
 LL | |         &Some(v) => println!("{:?}", v),
 LL | |         &None => println!("none"),
 LL | |     }
@@ -28,12 +31,13 @@ LL | |     }
 help: try
    |
 LL ~     match w {
+LL |
 LL ~         Some(v) => println!("{:?}", v),
 LL ~         None => println!("none"),
    |
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/match_ref_pats.rs:37:12
+  --> tests/ui/match_ref_pats.rs:39:12
    |
 LL |     if let &None = a {
    |     -------^^^^^---- help: try: `if a.is_none()`
@@ -42,15 +46,16 @@ LL |     if let &None = a {
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/match_ref_pats.rs:42:12
+  --> tests/ui/match_ref_pats.rs:45:12
    |
 LL |     if let &None = &b {
    |     -------^^^^^----- help: try: `if b.is_none()`
 
 error: you don't need to add `&` to all patterns
-  --> tests/ui/match_ref_pats.rs:102:9
+  --> tests/ui/match_ref_pats.rs:106:9
    |
 LL | /         match foobar_variant!(0) {
+LL | |
 LL | |             &FooBar::Foo => println!("Foo"),
 LL | |             &FooBar::Bar => println!("Bar"),
 LL | |             &FooBar::FooBar => println!("FooBar"),
@@ -61,6 +66,7 @@ LL | |         }
 help: instead of prefixing all patterns with `&`, you can dereference the expression
    |
 LL ~         match *foobar_variant!(0) {
+LL |
 LL ~             FooBar::Foo => println!("Foo"),
 LL ~             FooBar::Bar => println!("Bar"),
 LL ~             FooBar::FooBar => println!("FooBar"),
diff --git a/src/tools/clippy/tests/ui/match_result_ok.fixed b/src/tools/clippy/tests/ui/match_result_ok.fixed
index 117e0bc68ccc..0e630e6a2904 100644
--- a/src/tools/clippy/tests/ui/match_result_ok.fixed
+++ b/src/tools/clippy/tests/ui/match_result_ok.fixed
@@ -11,6 +11,7 @@
 
 fn str_to_int(x: &str) -> i32 {
     if let Ok(y) = x.parse() { y } else { 0 }
+    //~^ match_result_ok
 }
 
 fn str_to_int_ok(x: &str) -> i32 {
@@ -21,6 +22,7 @@ fn str_to_int_ok(x: &str) -> i32 {
 fn strange_some_no_else(x: &str) -> i32 {
     {
         if let Ok(y) = x   .   parse()    {
+        //~^ match_result_ok
             return y;
         };
         0
@@ -47,6 +49,7 @@ impl Wat {
 fn base_1(x: i32) {
     let mut wat = Wat { counter: x };
     while let Ok(a) = wat.next() {
+        //~^ match_result_ok
         println!("{}", a);
     }
 }
diff --git a/src/tools/clippy/tests/ui/match_result_ok.rs b/src/tools/clippy/tests/ui/match_result_ok.rs
index f8a5269024da..63bf6e8ab508 100644
--- a/src/tools/clippy/tests/ui/match_result_ok.rs
+++ b/src/tools/clippy/tests/ui/match_result_ok.rs
@@ -11,6 +11,7 @@
 
 fn str_to_int(x: &str) -> i32 {
     if let Some(y) = x.parse().ok() { y } else { 0 }
+    //~^ match_result_ok
 }
 
 fn str_to_int_ok(x: &str) -> i32 {
@@ -21,6 +22,7 @@ fn str_to_int_ok(x: &str) -> i32 {
 fn strange_some_no_else(x: &str) -> i32 {
     {
         if let Some(y) = x   .   parse()   .   ok   ()    {
+        //~^ match_result_ok
             return y;
         };
         0
@@ -47,6 +49,7 @@ impl Wat {
 fn base_1(x: i32) {
     let mut wat = Wat { counter: x };
     while let Some(a) = wat.next().ok() {
+        //~^ match_result_ok
         println!("{}", a);
     }
 }
diff --git a/src/tools/clippy/tests/ui/match_result_ok.stderr b/src/tools/clippy/tests/ui/match_result_ok.stderr
index 18b23bd78454..822cc4de77f3 100644
--- a/src/tools/clippy/tests/ui/match_result_ok.stderr
+++ b/src/tools/clippy/tests/ui/match_result_ok.stderr
@@ -13,7 +13,7 @@ LL +     if let Ok(y) = x.parse() { y } else { 0 }
    |
 
 error: matching on `Some` with `ok()` is redundant
-  --> tests/ui/match_result_ok.rs:23:9
+  --> tests/ui/match_result_ok.rs:24:9
    |
 LL |         if let Some(y) = x   .   parse()   .   ok   ()    {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +         if let Ok(y) = x   .   parse()    {
    |
 
 error: matching on `Some` with `ok()` is redundant
-  --> tests/ui/match_result_ok.rs:49:5
+  --> tests/ui/match_result_ok.rs:51:5
    |
 LL |     while let Some(a) = wat.next().ok() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/match_same_arms.rs b/src/tools/clippy/tests/ui/match_same_arms.rs
index 2f4652dcf32b..55441948e91b 100644
--- a/src/tools/clippy/tests/ui/match_same_arms.rs
+++ b/src/tools/clippy/tests/ui/match_same_arms.rs
@@ -9,30 +9,36 @@ pub enum Abc {
 
 fn match_same_arms() {
     let _ = match Abc::A {
-        Abc::A => 0, //~ ERROR: this match arm has an identical body to the `_` wildcard arm
+        Abc::A => 0,
+        //~^ match_same_arms
         Abc::B => 1,
         _ => 0,
     };
 
     match (1, 2, 3) {
-        (1, .., 3) => 42, //~ ERROR: this match arm has an identical body to another arm
+        (1, .., 3) => 42,
+        //~^ match_same_arms
         (.., 3) => 42,
         _ => 0,
     };
 
     let _ = match 42 {
         42 => 1,
-        51 => 1, //~ ERROR: this match arm has an identical body to another arm
-        41 => 2, //~ ERROR: this match arm has an identical body to another arm
+        51 => 1,
+        //~^ match_same_arms
+        41 => 2,
+        //~^ match_same_arms
         52 => 2,
         _ => 0,
     };
 
     let _ = match 42 {
         1 => 2,
-        2 => 2, //~ ERROR: this match arm has an identical body to another arm
-        //~^ ERROR: this match arm has an identical body to another arm
-        3 => 2, //~ ERROR: this match arm has an identical body to another arm
+        2 => 2,
+        //~^ match_same_arms
+        //~| match_same_arms
+        3 => 2,
+        //~^ match_same_arms
         4 => 3,
         _ => 0,
     };
@@ -50,7 +56,7 @@ mod issue4244 {
             match self {
                 CommandInfo::BuiltIn { name, .. } => name.to_string(),
                 CommandInfo::External { name, .. } => name.to_string(),
-                //~^ ERROR: this match arm has an identical body to another arm
+                //~^ match_same_arms
             }
         }
     }
diff --git a/src/tools/clippy/tests/ui/match_same_arms.stderr b/src/tools/clippy/tests/ui/match_same_arms.stderr
index 4a4772da143a..3744b83d89cc 100644
--- a/src/tools/clippy/tests/ui/match_same_arms.stderr
+++ b/src/tools/clippy/tests/ui/match_same_arms.stderr
@@ -1,12 +1,13 @@
 error: this match arm has an identical body to the `_` wildcard arm
   --> tests/ui/match_same_arms.rs:12:9
    |
-LL |         Abc::A => 0,
-   |         ^^^^^^^^^^^^^ help: try removing the arm
+LL | /         Abc::A => 0,
+LL | |
+   | |________^ help: try removing the arm
    |
    = help: or try changing either arm body
 note: `_` wildcard arm here
-  --> tests/ui/match_same_arms.rs:14:9
+  --> tests/ui/match_same_arms.rs:15:9
    |
 LL |         _ => 0,
    |         ^^^^^^
@@ -14,7 +15,7 @@ LL |         _ => 0,
    = help: to override `-D warnings` add `#[allow(clippy::match_same_arms)]`
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms.rs:18:9
+  --> tests/ui/match_same_arms.rs:19:9
    |
 LL |         (1, .., 3) => 42,
    |         ^^^^^^^^^^^^^^^^
@@ -23,11 +24,12 @@ LL |         (1, .., 3) => 42,
 help: or try merging the arm patterns and removing the obsolete arm
    |
 LL ~         (1, .., 3) | (.., 3) => 42,
+LL |
 LL ~         _ => 0,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms.rs:25:9
+  --> tests/ui/match_same_arms.rs:27:9
    |
 LL |         51 => 1,
    |         ^^^^^^^
@@ -41,7 +43,7 @@ LL +         51 | 42 => 1,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms.rs:26:9
+  --> tests/ui/match_same_arms.rs:29:9
    |
 LL |         41 => 2,
    |         ^^^^^^^
@@ -50,11 +52,12 @@ LL |         41 => 2,
 help: or try merging the arm patterns and removing the obsolete arm
    |
 LL ~         41 | 52 => 2,
+LL |
 LL ~         _ => 0,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms.rs:33:9
+  --> tests/ui/match_same_arms.rs:37:9
    |
 LL |         2 => 2,
    |         ^^^^^^
@@ -68,7 +71,7 @@ LL +         2 | 1 => 2,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms.rs:35:9
+  --> tests/ui/match_same_arms.rs:40:9
    |
 LL |         3 => 2,
    |         ^^^^^^
@@ -78,11 +81,12 @@ help: or try merging the arm patterns and removing the obsolete arm
    |
 LL ~         2 => 2,
 LL |
+LL |
 LL ~         3 | 1 => 2,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms.rs:33:9
+  --> tests/ui/match_same_arms.rs:37:9
    |
 LL |         2 => 2,
    |         ^^^^^^
@@ -92,11 +96,12 @@ help: or try merging the arm patterns and removing the obsolete arm
    |
 LL ~         2 | 3 => 2,
 LL |
+LL |
 LL ~
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms.rs:52:17
+  --> tests/ui/match_same_arms.rs:58:17
    |
 LL |                 CommandInfo::External { name, .. } => name.to_string(),
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/match_same_arms2.fixed b/src/tools/clippy/tests/ui/match_same_arms2.fixed
index b7d377f1ebff..0d93e2c728d7 100644
--- a/src/tools/clippy/tests/ui/match_same_arms2.fixed
+++ b/src/tools/clippy/tests/ui/match_same_arms2.fixed
@@ -14,6 +14,7 @@ fn foo() -> bool {
 
 fn match_same_arms() {
     let _ = match 42 {
+        //~^^^^^^^^^ match_same_arms
         _ => {
             foo();
             let mut a = 42 + [23].len() as i32;
@@ -24,15 +25,16 @@ fn match_same_arms() {
             a
         },
     };
-    //~^^^^^^^^^^^^^^^^^^^ ERROR: this match arm has an identical body to the `_` wildcard arm
 
     let _ = match 42 {
-        51 | 42 => foo(), //~ ERROR: this match arm has an identical body to another arm
+        51 | 42 => foo(),
+        //~^ match_same_arms
         _ => true,
     };
 
     let _ = match Some(42) {
-        None | Some(_) => 24, //~ ERROR: this match arm has an identical body to another arm
+        None | Some(_) => 24,
+        //~^ match_same_arms
     };
 
     let _ = match Some(42) {
@@ -53,7 +55,8 @@ fn match_same_arms() {
     };
 
     match (Some(42), Some(42)) {
-        (None, Some(a)) | (Some(a), None) => bar(a), //~ ERROR: this match arm has an identical body to another arm
+        (None, Some(a)) | (Some(a), None) => bar(a),
+        //~^ match_same_arms
         _ => (),
     }
 
@@ -66,12 +69,14 @@ fn match_same_arms() {
     };
 
     let _ = match (Some(42), Some(42)) {
-        (None, Some(a)) | (Some(a), None) if a == 42 => a, //~ ERROR: this match arm has an identical body to another arm
+        (None, Some(a)) | (Some(a), None) if a == 42 => a,
+        //~^ match_same_arms
         _ => 0,
     };
 
     match (Some(42), Some(42)) {
-        (Some(a), ..) | (.., Some(a)) => bar(a), //~ ERROR: this match arm has an identical body to another arm
+        (Some(a), ..) | (.., Some(a)) => bar(a),
+        //~^ match_same_arms
         _ => (),
     }
 
@@ -104,7 +109,8 @@ fn match_same_arms() {
     }
 
     match (x, Some(1i32)) {
-        (Ok(x), Some(_)) | (Ok(_), Some(x)) => println!("ok {}", x), //~ ERROR: this match arm has an identical body to another arm
+        (Ok(x), Some(_)) | (Ok(_), Some(x)) => println!("ok {}", x),
+        //~^ match_same_arms
         _ => println!("err"),
     }
 
@@ -118,7 +124,8 @@ fn match_same_arms() {
     // False negative #2251.
     match x {
         Ok(_tmp) => println!("ok"),
-        Ok(_) | Ok(3) => println!("ok"), //~ ERROR: this match arm has an identical body to another arm
+        Ok(_) | Ok(3) => println!("ok"),
+        //~^ match_same_arms
         Err(_) => {
             unreachable!();
         },
@@ -145,11 +152,11 @@ fn match_same_arms() {
         1 | 0 => {
             empty!(0);
         },
+        //~^^^ match_same_arms
         x => {
             empty!(x);
         },
     }
-    //~^^^^^^^ ERROR: this match arm has an identical body to another arm
 
     match_expr_like_matches_macro_priority();
 }
@@ -193,7 +200,8 @@ fn main() {
 
     // Suggest moving `Foo::Z(_)` up.
     let _ = match Foo::X(0) {
-        Foo::X(0) | Foo::Z(_) => 1, //~ ERROR: this match arm has an identical body to another arm
+        Foo::X(0) | Foo::Z(_) => 1,
+        //~^ match_same_arms
         Foo::X(_) | Foo::Y(_) => 2,
         _ => 0,
     };
@@ -201,7 +209,8 @@ fn main() {
     // Suggest moving `Foo::X(0)` down.
     let _ = match Foo::X(0) {
         Foo::Y(_) | Foo::Z(0) => 2,
-        Foo::Z(_) | Foo::X(0) => 1, //~ ERROR: this match arm has an identical body to another arm
+        Foo::Z(_) | Foo::X(0) => 1,
+        //~^ match_same_arms
         _ => 0,
     };
 
@@ -223,7 +232,8 @@ fn main() {
     let _ = match None {
         Some(Bar { y: 10, z: 0, .. }) => 2,
         None => 50,
-        Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. }) => 1, //~ ERROR: this match arm has an identical body to another arm
+        Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. }) => 1,
+        //~^ match_same_arms
         _ => 200,
     };
 
@@ -237,6 +247,7 @@ fn main() {
 
     let _ = match 0 {
         1 | 0 => cfg!(not_enable),
+        //~^ match_same_arms
         _ => false,
     };
 }
@@ -252,7 +263,7 @@ mod with_lifetime {
         fn get(&self) -> &'a str {
             match *self {
                 MaybeStaticStr::Borrowed(s) | MaybeStaticStr::Static(s) => s,
-                //~^ ERROR: this match arm has an identical body to another arm
+                //~^ match_same_arms
             }
         }
     }
diff --git a/src/tools/clippy/tests/ui/match_same_arms2.rs b/src/tools/clippy/tests/ui/match_same_arms2.rs
index dfd15d10c3d3..b0ebc4784f33 100644
--- a/src/tools/clippy/tests/ui/match_same_arms2.rs
+++ b/src/tools/clippy/tests/ui/match_same_arms2.rs
@@ -23,6 +23,7 @@ fn match_same_arms() {
             a = -31 - a;
             a
         },
+        //~^^^^^^^^^ match_same_arms
         _ => {
             foo();
             let mut a = 42 + [23].len() as i32;
@@ -33,17 +34,18 @@ fn match_same_arms() {
             a
         },
     };
-    //~^^^^^^^^^^^^^^^^^^^ ERROR: this match arm has an identical body to the `_` wildcard arm
 
     let _ = match 42 {
         42 => foo(),
-        51 => foo(), //~ ERROR: this match arm has an identical body to another arm
+        51 => foo(),
+        //~^ match_same_arms
         _ => true,
     };
 
     let _ = match Some(42) {
         Some(_) => 24,
-        None => 24, //~ ERROR: this match arm has an identical body to another arm
+        None => 24,
+        //~^ match_same_arms
     };
 
     let _ = match Some(42) {
@@ -65,7 +67,8 @@ fn match_same_arms() {
 
     match (Some(42), Some(42)) {
         (Some(a), None) => bar(a),
-        (None, Some(a)) => bar(a), //~ ERROR: this match arm has an identical body to another arm
+        (None, Some(a)) => bar(a),
+        //~^ match_same_arms
         _ => (),
     }
 
@@ -79,12 +82,14 @@ fn match_same_arms() {
 
     let _ = match (Some(42), Some(42)) {
         (Some(a), None) if a == 42 => a,
-        (None, Some(a)) if a == 42 => a, //~ ERROR: this match arm has an identical body to another arm
+        (None, Some(a)) if a == 42 => a,
+        //~^ match_same_arms
         _ => 0,
     };
 
     match (Some(42), Some(42)) {
-        (Some(a), ..) => bar(a), //~ ERROR: this match arm has an identical body to another arm
+        (Some(a), ..) => bar(a),
+        //~^ match_same_arms
         (.., Some(a)) => bar(a),
         _ => (),
     }
@@ -118,7 +123,8 @@ fn match_same_arms() {
     }
 
     match (x, Some(1i32)) {
-        (Ok(x), Some(_)) => println!("ok {}", x), //~ ERROR: this match arm has an identical body to another arm
+        (Ok(x), Some(_)) => println!("ok {}", x),
+        //~^ match_same_arms
         (Ok(_), Some(x)) => println!("ok {}", x),
         _ => println!("err"),
     }
@@ -134,7 +140,8 @@ fn match_same_arms() {
     match x {
         Ok(_tmp) => println!("ok"),
         Ok(3) => println!("ok"),
-        Ok(_) => println!("ok"), //~ ERROR: this match arm has an identical body to another arm
+        Ok(_) => println!("ok"),
+        //~^ match_same_arms
         Err(_) => {
             unreachable!();
         },
@@ -164,11 +171,11 @@ fn match_same_arms() {
         1 => {
             empty!(0);
         },
+        //~^^^ match_same_arms
         x => {
             empty!(x);
         },
     }
-    //~^^^^^^^ ERROR: this match arm has an identical body to another arm
 
     match_expr_like_matches_macro_priority();
 }
@@ -212,7 +219,8 @@ fn main() {
 
     // Suggest moving `Foo::Z(_)` up.
     let _ = match Foo::X(0) {
-        Foo::X(0) => 1, //~ ERROR: this match arm has an identical body to another arm
+        Foo::X(0) => 1,
+        //~^ match_same_arms
         Foo::X(_) | Foo::Y(_) => 2,
         Foo::Z(_) => 1,
         _ => 0,
@@ -222,7 +230,8 @@ fn main() {
     let _ = match Foo::X(0) {
         Foo::X(0) => 1,
         Foo::Y(_) | Foo::Z(0) => 2,
-        Foo::Z(_) => 1, //~ ERROR: this match arm has an identical body to another arm
+        Foo::Z(_) => 1,
+        //~^ match_same_arms
         _ => 0,
     };
 
@@ -245,7 +254,8 @@ fn main() {
         Some(Bar { x: 0, y: 5, .. }) => 1,
         Some(Bar { y: 10, z: 0, .. }) => 2,
         None => 50,
-        Some(Bar { y: 0, x: 5, .. }) => 1, //~ ERROR: this match arm has an identical body to another arm
+        Some(Bar { y: 0, x: 5, .. }) => 1,
+        //~^ match_same_arms
         _ => 200,
     };
 
@@ -260,6 +270,7 @@ fn main() {
     let _ = match 0 {
         0 => cfg!(not_enable),
         1 => cfg!(not_enable),
+        //~^ match_same_arms
         _ => false,
     };
 }
@@ -276,7 +287,7 @@ mod with_lifetime {
             match *self {
                 MaybeStaticStr::Static(s) => s,
                 MaybeStaticStr::Borrowed(s) => s,
-                //~^ ERROR: this match arm has an identical body to another arm
+                //~^ match_same_arms
             }
         }
     }
diff --git a/src/tools/clippy/tests/ui/match_same_arms2.stderr b/src/tools/clippy/tests/ui/match_same_arms2.stderr
index 525a25e9287b..21a8743cc324 100644
--- a/src/tools/clippy/tests/ui/match_same_arms2.stderr
+++ b/src/tools/clippy/tests/ui/match_same_arms2.stderr
@@ -7,12 +7,12 @@ LL | |             let mut a = 42 + [23].len() as i32;
 LL | |             if true {
 ...  |
 LL | |         },
-LL | |         _ => {
+LL | |
    | |________^ help: try removing the arm
    |
    = help: or try changing either arm body
 note: `_` wildcard arm here
-  --> tests/ui/match_same_arms2.rs:26:9
+  --> tests/ui/match_same_arms2.rs:27:9
    |
 LL | /         _ => {
 LL | |             foo();
@@ -40,7 +40,7 @@ LL +         51 | 42 => foo(),
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:46:9
+  --> tests/ui/match_same_arms2.rs:47:9
    |
 LL |         None => 24,
    |         ^^^^^^^^^^
@@ -54,7 +54,7 @@ LL +         None | Some(_) => 24,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:68:9
+  --> tests/ui/match_same_arms2.rs:70:9
    |
 LL |         (None, Some(a)) => bar(a),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ LL +         (None, Some(a)) | (Some(a), None) => bar(a),
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:82:9
+  --> tests/ui/match_same_arms2.rs:85:9
    |
 LL |         (None, Some(a)) if a == 42 => a,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -82,7 +82,7 @@ LL +         (None, Some(a)) | (Some(a), None) if a == 42 => a,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:87:9
+  --> tests/ui/match_same_arms2.rs:91:9
    |
 LL |         (Some(a), ..) => bar(a),
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -91,11 +91,12 @@ LL |         (Some(a), ..) => bar(a),
 help: or try merging the arm patterns and removing the obsolete arm
    |
 LL ~         (Some(a), ..) | (.., Some(a)) => bar(a),
+LL |
 LL ~         _ => (),
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:121:9
+  --> tests/ui/match_same_arms2.rs:126:9
    |
 LL |         (Ok(x), Some(_)) => println!("ok {}", x),
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -104,11 +105,12 @@ LL |         (Ok(x), Some(_)) => println!("ok {}", x),
 help: or try merging the arm patterns and removing the obsolete arm
    |
 LL ~         (Ok(x), Some(_)) | (Ok(_), Some(x)) => println!("ok {}", x),
+LL |
 LL ~         _ => println!("err"),
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:137:9
+  --> tests/ui/match_same_arms2.rs:143:9
    |
 LL |         Ok(_) => println!("ok"),
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -122,7 +124,7 @@ LL +         Ok(_) | Ok(3) => println!("ok"),
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:164:9
+  --> tests/ui/match_same_arms2.rs:171:9
    |
 LL | /         1 => {
 LL | |             empty!(0);
@@ -140,7 +142,7 @@ LL +         1 | 0 => {
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:215:9
+  --> tests/ui/match_same_arms2.rs:222:9
    |
 LL |         Foo::X(0) => 1,
    |         ^^^^^^^^^^^^^^
@@ -149,12 +151,13 @@ LL |         Foo::X(0) => 1,
 help: or try merging the arm patterns and removing the obsolete arm
    |
 LL ~         Foo::X(0) | Foo::Z(_) => 1,
+LL |
 LL |         Foo::X(_) | Foo::Y(_) => 2,
 LL ~         _ => 0,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:225:9
+  --> tests/ui/match_same_arms2.rs:233:9
    |
 LL |         Foo::Z(_) => 1,
    |         ^^^^^^^^^^^^^^
@@ -167,7 +170,7 @@ LL ~         Foo::Z(_) | Foo::X(0) => 1,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:248:9
+  --> tests/ui/match_same_arms2.rs:257:9
    |
 LL |         Some(Bar { y: 0, x: 5, .. }) => 1,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +184,7 @@ LL ~         Some(Bar { y: 0, x: 5, .. }) | Some(Bar { x: 0, y: 5, .. }) => 1,
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:262:9
+  --> tests/ui/match_same_arms2.rs:272:9
    |
 LL |         1 => cfg!(not_enable),
    |         ^^^^^^^^^^^^^^^^^^^^^
@@ -195,7 +198,7 @@ LL +         1 | 0 => cfg!(not_enable),
    |
 
 error: this match arm has an identical body to another arm
-  --> tests/ui/match_same_arms2.rs:278:17
+  --> tests/ui/match_same_arms2.rs:289:17
    |
 LL |                 MaybeStaticStr::Borrowed(s) => s,
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.fixed b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.fixed
index 804c0a869a9f..0c9398933b80 100644
--- a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.fixed
+++ b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.fixed
@@ -41,7 +41,7 @@ pub fn g(x: Ordering) {
         Ordering::Relaxed => println!("relaxed"),
         Ordering::Release => println!("release"),
         Ordering::Acquire => println!("acquire"),
-        //~^ ERROR: this match arm has an identical body to the `_` wildcard arm
+        //~^ match_same_arms
         _ => repeat(),
     }
 }
@@ -54,7 +54,7 @@ mod g {
             Ordering::Relaxed => println!("relaxed"),
             Ordering::Release => println!("release"),
             Ordering::Acquire => println!("acquire"),
-            //~^ ERROR: this match arm has an identical body to the `_` wildcard arm
+            //~^ match_same_arms
             _ => repeat(),
         }
     }
diff --git a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs
index e50663932a1a..304a9e5c28e7 100644
--- a/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs
+++ b/src/tools/clippy/tests/ui/match_same_arms_non_exhaustive.rs
@@ -42,7 +42,7 @@ pub fn g(x: Ordering) {
         Ordering::Release => println!("release"),
         Ordering::Acquire => println!("acquire"),
         Ordering::AcqRel | Ordering::SeqCst => repeat(),
-        //~^ ERROR: this match arm has an identical body to the `_` wildcard arm
+        //~^ match_same_arms
         _ => repeat(),
     }
 }
@@ -56,7 +56,7 @@ mod g {
             Ordering::Release => println!("release"),
             Ordering::Acquire => println!("acquire"),
             Ordering::AcqRel | Ordering::SeqCst => repeat(),
-            //~^ ERROR: this match arm has an identical body to the `_` wildcard arm
+            //~^ match_same_arms
             _ => repeat(),
         }
     }
diff --git a/src/tools/clippy/tests/ui/match_single_binding.rs b/src/tools/clippy/tests/ui/match_single_binding.rs
index ff2f842ac39e..ada51254c6cd 100644
--- a/src/tools/clippy/tests/ui/match_single_binding.rs
+++ b/src/tools/clippy/tests/ui/match_single_binding.rs
@@ -31,12 +31,14 @@ fn main() {
     let c = 3;
     // Lint
     match (a, b, c) {
+        //~^ match_single_binding
         (x, y, z) => {
             println!("{} {} {}", x, y, z);
         },
     }
     // Lint
     match (a, b, c) {
+        //~^ match_single_binding
         (x, y, z) => println!("{} {} {}", x, y, z),
     }
     // Ok
@@ -54,10 +56,12 @@ fn main() {
     }
     // Lint
     match a {
+        //~^ match_single_binding
         _ => println!("whatever"),
     }
     // Lint
     match a {
+        //~^ match_single_binding
         _ => {
             let x = 29;
             println!("x has a value of {}", x);
@@ -65,6 +69,7 @@ fn main() {
     }
     // Lint
     match a {
+        //~^ match_single_binding
         _ => {
             let e = 5 * a;
             if e >= 5 {
@@ -75,24 +80,29 @@ fn main() {
     // Lint
     let p = Point { x: 0, y: 7 };
     match p {
+        //~^ match_single_binding
         Point { x, y } => println!("Coords: ({}, {})", x, y),
     }
     // Lint
     match p {
+        //~^ match_single_binding
         Point { x: x1, y: y1 } => println!("Coords: ({}, {})", x1, y1),
     }
     // Lint
     let x = 5;
     match x {
+        //~^ match_single_binding
         ref r => println!("Got a reference to {}", r),
     }
     // Lint
     let mut x = 5;
     match x {
+        //~^ match_single_binding
         ref mut mr => println!("Got a mutable reference to {}", mr),
     }
     // Lint
     let product = match coords() {
+        //~^ match_single_binding
         Point { x, y } => x * y,
     };
     // Lint
@@ -101,6 +111,7 @@ fn main() {
     let _ = v
         .iter()
         .map(|i| match i.unwrap() {
+            //~^ match_single_binding
             unwrapped => unwrapped,
         })
         .collect::<Vec<u8>>();
@@ -127,6 +138,7 @@ fn main() {
     // Lint
     let x = 1;
     match x {
+        //~^ match_single_binding
         // =>
         _ => println!("Not an array index start"),
     }
@@ -136,6 +148,7 @@ fn issue_8723() {
     let (mut val, idx) = ("a b", 1);
 
     val = match val.split_at(idx) {
+        //~^ match_single_binding
         (pre, suf) => {
             println!("{}", pre);
             suf
@@ -149,12 +162,14 @@ fn side_effects() {}
 
 fn issue_9575() {
     let _ = || match side_effects() {
+        //~^ match_single_binding
         _ => println!("Needs curlies"),
     };
 }
 
 fn issue_9725(r: Option<u32>) {
     match r {
+        //~^ match_single_binding
         x => match x {
             Some(_) => {
                 println!("Some");
@@ -168,37 +183,46 @@ fn issue_9725(r: Option<u32>) {
 
 fn issue_10447() -> usize {
     match 1 {
+        //~^ match_single_binding
         _ => (),
     }
 
     let a = match 1 {
+        //~^ match_single_binding
         _ => (),
     };
 
     match 1 {
+        //~^ match_single_binding
         _ => side_effects(),
     }
 
     let b = match 1 {
+        //~^ match_single_binding
         _ => side_effects(),
     };
 
     match 1 {
+        //~^ match_single_binding
         _ => println!("1"),
     }
 
     let c = match 1 {
+        //~^ match_single_binding
         _ => println!("1"),
     };
 
     let in_expr = [
         match 1 {
+            //~^ match_single_binding
             _ => (),
         },
         match 1 {
+            //~^ match_single_binding
             _ => side_effects(),
         },
         match 1 {
+            //~^ match_single_binding
             _ => println!("1"),
         },
     ];
diff --git a/src/tools/clippy/tests/ui/match_single_binding.stderr b/src/tools/clippy/tests/ui/match_single_binding.stderr
index 19ab85180ad2..7e1ec32dac2f 100644
--- a/src/tools/clippy/tests/ui/match_single_binding.stderr
+++ b/src/tools/clippy/tests/ui/match_single_binding.stderr
@@ -2,6 +2,7 @@ error: this match could be written as a `let` statement
   --> tests/ui/match_single_binding.rs:33:5
    |
 LL | /     match (a, b, c) {
+LL | |
 LL | |         (x, y, z) => {
 LL | |             println!("{} {} {}", x, y, z);
 LL | |         },
@@ -19,9 +20,10 @@ LL +     }
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:39:5
+  --> tests/ui/match_single_binding.rs:40:5
    |
 LL | /     match (a, b, c) {
+LL | |
 LL | |         (x, y, z) => println!("{} {} {}", x, y, z),
 LL | |     }
    | |_____^
@@ -33,17 +35,19 @@ LL +     println!("{} {} {}", x, y, z);
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:56:5
+  --> tests/ui/match_single_binding.rs:58:5
    |
 LL | /     match a {
+LL | |
 LL | |         _ => println!("whatever"),
 LL | |     }
    | |_____^ help: consider using the match body instead: `println!("whatever");`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:60:5
+  --> tests/ui/match_single_binding.rs:63:5
    |
 LL | /     match a {
+LL | |
 LL | |         _ => {
 LL | |             let x = 29;
 LL | |             println!("x has a value of {}", x);
@@ -60,12 +64,12 @@ LL +     }
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:67:5
+  --> tests/ui/match_single_binding.rs:71:5
    |
 LL | /     match a {
+LL | |
 LL | |         _ => {
 LL | |             let e = 5 * a;
-LL | |             if e >= 5 {
 ...  |
 LL | |         },
 LL | |     }
@@ -82,9 +86,10 @@ LL +     }
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:77:5
+  --> tests/ui/match_single_binding.rs:82:5
    |
 LL | /     match p {
+LL | |
 LL | |         Point { x, y } => println!("Coords: ({}, {})", x, y),
 LL | |     }
    | |_____^
@@ -96,9 +101,10 @@ LL +     println!("Coords: ({}, {})", x, y);
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:81:5
+  --> tests/ui/match_single_binding.rs:87:5
    |
 LL | /     match p {
+LL | |
 LL | |         Point { x: x1, y: y1 } => println!("Coords: ({}, {})", x1, y1),
 LL | |     }
    | |_____^
@@ -110,9 +116,10 @@ LL +     println!("Coords: ({}, {})", x1, y1);
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:86:5
+  --> tests/ui/match_single_binding.rs:93:5
    |
 LL | /     match x {
+LL | |
 LL | |         ref r => println!("Got a reference to {}", r),
 LL | |     }
    | |_____^
@@ -124,9 +131,10 @@ LL +     println!("Got a reference to {}", r);
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:91:5
+  --> tests/ui/match_single_binding.rs:99:5
    |
 LL | /     match x {
+LL | |
 LL | |         ref mut mr => println!("Got a mutable reference to {}", mr),
 LL | |     }
    | |_____^
@@ -138,9 +146,10 @@ LL +     println!("Got a mutable reference to {}", mr);
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:95:5
+  --> tests/ui/match_single_binding.rs:104:5
    |
 LL | /     let product = match coords() {
+LL | |
 LL | |         Point { x, y } => x * y,
 LL | |     };
    | |______^
@@ -152,10 +161,11 @@ LL +     let product = x * y;
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:103:18
+  --> tests/ui/match_single_binding.rs:113:18
    |
 LL |           .map(|i| match i.unwrap() {
    |  __________________^
+LL | |
 LL | |             unwrapped => unwrapped,
 LL | |         })
    | |_________^
@@ -169,18 +179,20 @@ LL ~         })
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:129:5
+  --> tests/ui/match_single_binding.rs:140:5
    |
 LL | /     match x {
+LL | |
 LL | |         // =>
 LL | |         _ => println!("Not an array index start"),
 LL | |     }
    | |_____^ help: consider using the match body instead: `println!("Not an array index start")`
 
 error: this assignment could be simplified
-  --> tests/ui/match_single_binding.rs:138:5
+  --> tests/ui/match_single_binding.rs:150:5
    |
 LL | /     val = match val.split_at(idx) {
+LL | |
 LL | |         (pre, suf) => {
 LL | |             println!("{}", pre);
 LL | |             suf
@@ -198,10 +210,11 @@ LL ~     };
    |
 
 error: this match could be replaced by its scrutinee and body
-  --> tests/ui/match_single_binding.rs:151:16
+  --> tests/ui/match_single_binding.rs:164:16
    |
 LL |       let _ = || match side_effects() {
    |  ________________^
+LL | |
 LL | |         _ => println!("Needs curlies"),
 LL | |     };
    | |_____^
@@ -215,12 +228,12 @@ LL ~     };
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding.rs:157:5
+  --> tests/ui/match_single_binding.rs:171:5
    |
 LL | /     match r {
+LL | |
 LL | |         x => match x {
 LL | |             Some(_) => {
-LL | |                 println!("Some");
 ...  |
 LL | |         },
 LL | |     };
@@ -240,76 +253,85 @@ LL ~     };
    |
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:170:5
+  --> tests/ui/match_single_binding.rs:185:5
    |
 LL | /     match 1 {
+LL | |
 LL | |         _ => (),
 LL | |     }
    | |_____^ help: consider using the match body instead: `();`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:174:13
+  --> tests/ui/match_single_binding.rs:190:13
    |
 LL |       let a = match 1 {
    |  _____________^
+LL | |
 LL | |         _ => (),
 LL | |     };
    | |_____^ help: consider using the match body instead: `()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:178:5
+  --> tests/ui/match_single_binding.rs:195:5
    |
 LL | /     match 1 {
+LL | |
 LL | |         _ => side_effects(),
 LL | |     }
    | |_____^ help: consider using the match body instead: `side_effects();`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:182:13
+  --> tests/ui/match_single_binding.rs:200:13
    |
 LL |       let b = match 1 {
    |  _____________^
+LL | |
 LL | |         _ => side_effects(),
 LL | |     };
    | |_____^ help: consider using the match body instead: `side_effects()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:186:5
+  --> tests/ui/match_single_binding.rs:205:5
    |
 LL | /     match 1 {
+LL | |
 LL | |         _ => println!("1"),
 LL | |     }
    | |_____^ help: consider using the match body instead: `println!("1");`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:190:13
+  --> tests/ui/match_single_binding.rs:210:13
    |
 LL |       let c = match 1 {
    |  _____________^
+LL | |
 LL | |         _ => println!("1"),
 LL | |     };
    | |_____^ help: consider using the match body instead: `println!("1")`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:195:9
+  --> tests/ui/match_single_binding.rs:216:9
    |
 LL | /         match 1 {
+LL | |
 LL | |             _ => (),
 LL | |         },
    | |_________^ help: consider using the match body instead: `()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:198:9
+  --> tests/ui/match_single_binding.rs:220:9
    |
 LL | /         match 1 {
+LL | |
 LL | |             _ => side_effects(),
 LL | |         },
    | |_________^ help: consider using the match body instead: `side_effects()`
 
 error: this match could be replaced by its body itself
-  --> tests/ui/match_single_binding.rs:201:9
+  --> tests/ui/match_single_binding.rs:224:9
    |
 LL | /         match 1 {
+LL | |
 LL | |             _ => println!("1"),
 LL | |         },
    | |_________^ help: consider using the match body instead: `println!("1")`
diff --git a/src/tools/clippy/tests/ui/match_single_binding2.fixed b/src/tools/clippy/tests/ui/match_single_binding2.fixed
index 5673aa78c76a..988121f50d0f 100644
--- a/src/tools/clippy/tests/ui/match_single_binding2.fixed
+++ b/src/tools/clippy/tests/ui/match_single_binding2.fixed
@@ -45,6 +45,7 @@ fn main() {
     // issue #7094
     let x = 1;
     match x {
+        //~^ match_single_binding
         0 => 1,
         _ => 2,
     };
diff --git a/src/tools/clippy/tests/ui/match_single_binding2.rs b/src/tools/clippy/tests/ui/match_single_binding2.rs
index 575e7f5816b8..a4fb2bd6f381 100644
--- a/src/tools/clippy/tests/ui/match_single_binding2.rs
+++ b/src/tools/clippy/tests/ui/match_single_binding2.rs
@@ -15,6 +15,7 @@ fn main() {
     fn size_hint<I: Iterator>(iter: &AppendIter<I>) -> (usize, Option<usize>) {
         match &iter.inner {
             Some((iter, _item)) => match iter.size_hint() {
+                //~^ match_single_binding
                 (min, max) => (min.saturating_add(1), max.and_then(|max| max.checked_add(1))),
             },
             None => (0, Some(0)),
@@ -28,6 +29,7 @@ fn main() {
         #[rustfmt::skip]
         Some((first, _second)) => {
             match get_tup() {
+            //~^ match_single_binding
                 (a, b) => println!("a {:?} and b {:?}", a, b),
             }
         },
@@ -39,6 +41,7 @@ fn main() {
     // Lint (scrutinee has side effects)
     // issue #7094
     match side_effects() {
+        //~^ match_single_binding
         _ => println!("Side effects"),
     }
 
@@ -46,6 +49,7 @@ fn main() {
     // issue #7094
     let x = 1;
     match match x {
+        //~^ match_single_binding
         0 => 1,
         _ => 2,
     } {
diff --git a/src/tools/clippy/tests/ui/match_single_binding2.stderr b/src/tools/clippy/tests/ui/match_single_binding2.stderr
index 38659596af1f..a24cbe3eed76 100644
--- a/src/tools/clippy/tests/ui/match_single_binding2.stderr
+++ b/src/tools/clippy/tests/ui/match_single_binding2.stderr
@@ -3,6 +3,7 @@ error: this match could be written as a `let` statement
    |
 LL |               Some((iter, _item)) => match iter.size_hint() {
    |  ____________________________________^
+LL | |
 LL | |                 (min, max) => (min.saturating_add(1), max.and_then(|max| max.checked_add(1))),
 LL | |             },
    | |_____________^
@@ -18,9 +19,10 @@ LL ~             },
    |
 
 error: this match could be written as a `let` statement
-  --> tests/ui/match_single_binding2.rs:30:13
+  --> tests/ui/match_single_binding2.rs:31:13
    |
 LL | /             match get_tup() {
+LL | |
 LL | |                 (a, b) => println!("a {:?} and b {:?}", a, b),
 LL | |             }
    | |_____________^
@@ -32,9 +34,10 @@ LL +             println!("a {:?} and b {:?}", a, b)
    |
 
 error: this match could be replaced by its scrutinee and body
-  --> tests/ui/match_single_binding2.rs:41:5
+  --> tests/ui/match_single_binding2.rs:43:5
    |
 LL | /     match side_effects() {
+LL | |
 LL | |         _ => println!("Side effects"),
 LL | |     }
    | |_____^
@@ -46,9 +49,10 @@ LL +     println!("Side effects");
    |
 
 error: this match could be replaced by its scrutinee and body
-  --> tests/ui/match_single_binding2.rs:48:5
+  --> tests/ui/match_single_binding2.rs:51:5
    |
 LL | /     match match x {
+LL | |
 LL | |         0 => 1,
 LL | |         _ => 2,
 LL | |     } {
@@ -59,6 +63,7 @@ LL | |     }
 help: consider using the scrutinee and body instead
    |
 LL ~     match x {
+LL +
 LL +         0 => 1,
 LL +         _ => 2,
 LL +     };
diff --git a/src/tools/clippy/tests/ui/match_str_case_mismatch.fixed b/src/tools/clippy/tests/ui/match_str_case_mismatch.fixed
index a608ab0c0cb0..5f41f29f8a46 100644
--- a/src/tools/clippy/tests/ui/match_str_case_mismatch.fixed
+++ b/src/tools/clippy/tests/ui/match_str_case_mismatch.fixed
@@ -110,6 +110,7 @@ fn as_str_match_mismatch() {
     match var.to_ascii_lowercase().as_str() {
         "foo" => {},
         "bar" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -120,6 +121,7 @@ fn non_alphabetic_mismatch() {
     match var.to_ascii_lowercase().as_str() {
         "1234567890" => {},
         "~!@#$%^&*()-_=+foo" => {},
+        //~^ match_str_case_mismatch
         "\n\r\t\x7F" => {},
         _ => {},
     }
@@ -132,6 +134,7 @@ fn unicode_cased_mismatch() {
         "水" => {},
         "νερό" => {},
         "воды" => {},
+        //~^ match_str_case_mismatch
         "물" => {},
         _ => {},
     }
@@ -143,6 +146,7 @@ fn titlecase_mismatch() {
     match var.to_lowercase().as_str() {
         "foolj" => {},
         "bardz" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -153,6 +157,7 @@ fn no_case_equivalent_mismatch() {
     match var.to_uppercase().as_str() {
         "FOOɕ" => {},
         "BARʁ" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -163,6 +168,7 @@ fn addrof_unary_match_mismatch() {
     match &*var.to_ascii_lowercase() {
         "foo" => {},
         "bar" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -178,6 +184,7 @@ fn alternating_chain_mismatch() {
     {
         "FOO" => {},
         "BAR" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
diff --git a/src/tools/clippy/tests/ui/match_str_case_mismatch.rs b/src/tools/clippy/tests/ui/match_str_case_mismatch.rs
index 1e4269d1db5d..fa5d5a8ebc31 100644
--- a/src/tools/clippy/tests/ui/match_str_case_mismatch.rs
+++ b/src/tools/clippy/tests/ui/match_str_case_mismatch.rs
@@ -110,6 +110,7 @@ fn as_str_match_mismatch() {
     match var.to_ascii_lowercase().as_str() {
         "foo" => {},
         "Bar" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -120,6 +121,7 @@ fn non_alphabetic_mismatch() {
     match var.to_ascii_lowercase().as_str() {
         "1234567890" => {},
         "~!@#$%^&*()-_=+Foo" => {},
+        //~^ match_str_case_mismatch
         "\n\r\t\x7F" => {},
         _ => {},
     }
@@ -132,6 +134,7 @@ fn unicode_cased_mismatch() {
         "水" => {},
         "νερό" => {},
         "Воды" => {},
+        //~^ match_str_case_mismatch
         "물" => {},
         _ => {},
     }
@@ -143,6 +146,7 @@ fn titlecase_mismatch() {
     match var.to_lowercase().as_str() {
         "foolj" => {},
         "barDz" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -153,6 +157,7 @@ fn no_case_equivalent_mismatch() {
     match var.to_uppercase().as_str() {
         "FOOɕ" => {},
         "bARʁ" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -163,6 +168,7 @@ fn addrof_unary_match_mismatch() {
     match &*var.to_ascii_lowercase() {
         "foo" => {},
         "Bar" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
@@ -178,6 +184,7 @@ fn alternating_chain_mismatch() {
     {
         "FOO" => {},
         "bAR" => {},
+        //~^ match_str_case_mismatch
         _ => {},
     }
 }
diff --git a/src/tools/clippy/tests/ui/match_str_case_mismatch.stderr b/src/tools/clippy/tests/ui/match_str_case_mismatch.stderr
index 5b14fd13a53b..8068edfff947 100644
--- a/src/tools/clippy/tests/ui/match_str_case_mismatch.stderr
+++ b/src/tools/clippy/tests/ui/match_str_case_mismatch.stderr
@@ -13,7 +13,7 @@ LL +         "bar" => {},
    |
 
 error: this `match` arm has a differing case than its expression
-  --> tests/ui/match_str_case_mismatch.rs:122:9
+  --> tests/ui/match_str_case_mismatch.rs:123:9
    |
 LL |         "~!@#$%^&*()-_=+Foo" => {},
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +         "~!@#$%^&*()-_=+foo" => {},
    |
 
 error: this `match` arm has a differing case than its expression
-  --> tests/ui/match_str_case_mismatch.rs:134:9
+  --> tests/ui/match_str_case_mismatch.rs:136:9
    |
 LL |         "Воды" => {},
    |         ^^^^^^
@@ -37,7 +37,7 @@ LL +         "воды" => {},
    |
 
 error: this `match` arm has a differing case than its expression
-  --> tests/ui/match_str_case_mismatch.rs:145:9
+  --> tests/ui/match_str_case_mismatch.rs:148:9
    |
 LL |         "barDz" => {},
    |         ^^^^^^
@@ -49,7 +49,7 @@ LL +         "bardz" => {},
    |
 
 error: this `match` arm has a differing case than its expression
-  --> tests/ui/match_str_case_mismatch.rs:155:9
+  --> tests/ui/match_str_case_mismatch.rs:159:9
    |
 LL |         "bARʁ" => {},
    |         ^^^^^^
@@ -61,7 +61,7 @@ LL +         "BARʁ" => {},
    |
 
 error: this `match` arm has a differing case than its expression
-  --> tests/ui/match_str_case_mismatch.rs:165:9
+  --> tests/ui/match_str_case_mismatch.rs:170:9
    |
 LL |         "Bar" => {},
    |         ^^^^^
@@ -73,7 +73,7 @@ LL +         "bar" => {},
    |
 
 error: this `match` arm has a differing case than its expression
-  --> tests/ui/match_str_case_mismatch.rs:180:9
+  --> tests/ui/match_str_case_mismatch.rs:186:9
    |
 LL |         "bAR" => {},
    |         ^^^^^
diff --git a/src/tools/clippy/tests/ui/match_wild_err_arm.rs b/src/tools/clippy/tests/ui/match_wild_err_arm.rs
index 8e670ce5bda2..d18d4047e2a6 100644
--- a/src/tools/clippy/tests/ui/match_wild_err_arm.rs
+++ b/src/tools/clippy/tests/ui/match_wild_err_arm.rs
@@ -21,24 +21,22 @@ fn match_wild_err_arm() {
         Ok(3) => println!("ok"),
         Ok(_) => println!("ok"),
         Err(_) => panic!("err"),
-        //~^ ERROR: `Err(_)` matches all errors
-        //~| NOTE: match each error separately or use the error output, or use `.expect(ms
+        //~^ match_wild_err_arm
     }
 
     match x {
         Ok(3) => println!("ok"),
         Ok(_) => println!("ok"),
         Err(_) => panic!(),
-        //~^ ERROR: `Err(_)` matches all errors
-        //~| NOTE: match each error separately or use the error output, or use `.expect(ms
+        //~^ match_wild_err_arm
     }
 
     match x {
         Ok(3) => println!("ok"),
         Ok(_) => println!("ok"),
         Err(_) => {
-            //~^ ERROR: `Err(_)` matches all errors
-            //~| NOTE: match each error separately or use the error output, or use `.expect(ms
+            //~^ match_wild_err_arm
+
             panic!();
         },
     }
@@ -47,8 +45,7 @@ fn match_wild_err_arm() {
         Ok(3) => println!("ok"),
         Ok(_) => println!("ok"),
         Err(_e) => panic!(),
-        //~^ ERROR: `Err(_e)` matches all errors
-        //~| NOTE: match each error separately or use the error output, or use `.expect(ms
+        //~^ match_wild_err_arm
     }
 
     // Allowed when used in `panic!`.
diff --git a/src/tools/clippy/tests/ui/match_wild_err_arm.stderr b/src/tools/clippy/tests/ui/match_wild_err_arm.stderr
index f98065d9a591..fc65924f0873 100644
--- a/src/tools/clippy/tests/ui/match_wild_err_arm.stderr
+++ b/src/tools/clippy/tests/ui/match_wild_err_arm.stderr
@@ -9,7 +9,7 @@ LL |         Err(_) => panic!("err"),
    = help: to override `-D warnings` add `#[allow(clippy::match_wild_err_arm)]`
 
 error: `Err(_)` matches all errors
-  --> tests/ui/match_wild_err_arm.rs:31:9
+  --> tests/ui/match_wild_err_arm.rs:30:9
    |
 LL |         Err(_) => panic!(),
    |         ^^^^^^
@@ -17,7 +17,7 @@ LL |         Err(_) => panic!(),
    = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_)` matches all errors
-  --> tests/ui/match_wild_err_arm.rs:39:9
+  --> tests/ui/match_wild_err_arm.rs:37:9
    |
 LL |         Err(_) => {
    |         ^^^^^^
@@ -25,7 +25,7 @@ LL |         Err(_) => {
    = note: match each error separately or use the error output, or use `.expect(msg)` if the error case is unreachable
 
 error: `Err(_e)` matches all errors
-  --> tests/ui/match_wild_err_arm.rs:49:9
+  --> tests/ui/match_wild_err_arm.rs:47:9
    |
 LL |         Err(_e) => panic!(),
    |         ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.fixed b/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.fixed
index e5ea2fdde82f..c34f49df6549 100644
--- a/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.fixed
+++ b/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.fixed
@@ -20,6 +20,7 @@ impl Color {
             Self::Green => (),
             Self::Blue => (),
             Self::Rgb(..) => (),
+            //~^ match_wildcard_for_single_variants
         };
     }
 }
@@ -30,6 +31,7 @@ fn main() {
         Foo::A => {},
         Foo::B => {},
         Foo::C => {},
+        //~^ match_wildcard_for_single_variants
     }
 
     let color = Color::Red;
@@ -40,6 +42,7 @@ fn main() {
         Color::Green => {},
         Color::Rgb(_r, _g, _b) => {},
         Color::Blue => {},
+        //~^ match_wildcard_for_single_variants
     }
 
     // check exhaustive wild
@@ -48,12 +51,14 @@ fn main() {
         Color::Green => {},
         Color::Rgb(..) => {},
         Color::Blue => {},
+        //~^ match_wildcard_for_single_variants
     }
     match color {
         Color::Red => {},
         Color::Green => {},
         Color::Rgb(_, _, _) => {},
         Color::Blue => {},
+        //~^ match_wildcard_for_single_variants
     }
 
     // shouldn't lint as there is one missing variant
@@ -71,6 +76,7 @@ fn main() {
         Color::Green => (),
         &Color::Rgb(..) => (),
         Color::Blue => (),
+        //~^ match_wildcard_for_single_variants
     }
 
     use self::Color as C;
@@ -80,6 +86,7 @@ fn main() {
         C::Green => (),
         C::Rgb(..) => (),
         C::Blue => (),
+        //~^ match_wildcard_for_single_variants
     }
 
     match color {
@@ -87,6 +94,7 @@ fn main() {
         Color::Green => (),
         Color::Rgb(..) => (),
         Color::Blue => (),
+        //~^ match_wildcard_for_single_variants
     }
 
     match Some(0) {
@@ -122,6 +130,7 @@ fn main() {
             Enum::B => (),
             Enum::C => (),
             Enum::__Private => (),
+            //~^ match_wildcard_for_single_variants
         }
         match Enum::A {
             Enum::A => (),
@@ -149,6 +158,7 @@ mod issue9993 {
             _ if false => 0,
             Foo::A(_) => 1,
             Foo::B => 2,
+            //~^ match_wildcard_for_single_variants
         };
     }
 }
diff --git a/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.rs b/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.rs
index dbd7fbe160f0..ecdb7d2fa3af 100644
--- a/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.rs
+++ b/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.rs
@@ -20,6 +20,7 @@ impl Color {
             Self::Green => (),
             Self::Blue => (),
             _ => (),
+            //~^ match_wildcard_for_single_variants
         };
     }
 }
@@ -30,6 +31,7 @@ fn main() {
         Foo::A => {},
         Foo::B => {},
         _ => {},
+        //~^ match_wildcard_for_single_variants
     }
 
     let color = Color::Red;
@@ -40,6 +42,7 @@ fn main() {
         Color::Green => {},
         Color::Rgb(_r, _g, _b) => {},
         _ => {},
+        //~^ match_wildcard_for_single_variants
     }
 
     // check exhaustive wild
@@ -48,12 +51,14 @@ fn main() {
         Color::Green => {},
         Color::Rgb(..) => {},
         _ => {},
+        //~^ match_wildcard_for_single_variants
     }
     match color {
         Color::Red => {},
         Color::Green => {},
         Color::Rgb(_, _, _) => {},
         _ => {},
+        //~^ match_wildcard_for_single_variants
     }
 
     // shouldn't lint as there is one missing variant
@@ -71,6 +76,7 @@ fn main() {
         Color::Green => (),
         &Color::Rgb(..) => (),
         &_ => (),
+        //~^ match_wildcard_for_single_variants
     }
 
     use self::Color as C;
@@ -80,6 +86,7 @@ fn main() {
         C::Green => (),
         C::Rgb(..) => (),
         _ => (),
+        //~^ match_wildcard_for_single_variants
     }
 
     match color {
@@ -87,6 +94,7 @@ fn main() {
         Color::Green => (),
         Color::Rgb(..) => (),
         _ => (),
+        //~^ match_wildcard_for_single_variants
     }
 
     match Some(0) {
@@ -122,6 +130,7 @@ fn main() {
             Enum::B => (),
             Enum::C => (),
             _ => (),
+            //~^ match_wildcard_for_single_variants
         }
         match Enum::A {
             Enum::A => (),
@@ -149,6 +158,7 @@ mod issue9993 {
             _ if false => 0,
             Foo::A(_) => 1,
             _ => 2,
+            //~^ match_wildcard_for_single_variants
         };
     }
 }
diff --git a/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.stderr b/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.stderr
index 5cc50c823b2c..3c0cc53b1bf2 100644
--- a/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.stderr
+++ b/src/tools/clippy/tests/ui/match_wildcard_for_single_variants.stderr
@@ -8,55 +8,55 @@ LL |             _ => (),
    = help: to override `-D warnings` add `#[allow(clippy::match_wildcard_for_single_variants)]`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:32:9
+  --> tests/ui/match_wildcard_for_single_variants.rs:33:9
    |
 LL |         _ => {},
    |         ^ help: try: `Foo::C`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:42:9
+  --> tests/ui/match_wildcard_for_single_variants.rs:44:9
    |
 LL |         _ => {},
    |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:50:9
+  --> tests/ui/match_wildcard_for_single_variants.rs:53:9
    |
 LL |         _ => {},
    |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:56:9
+  --> tests/ui/match_wildcard_for_single_variants.rs:60:9
    |
 LL |         _ => {},
    |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:73:9
+  --> tests/ui/match_wildcard_for_single_variants.rs:78:9
    |
 LL |         &_ => (),
    |         ^^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:82:9
+  --> tests/ui/match_wildcard_for_single_variants.rs:88:9
    |
 LL |         _ => (),
    |         ^ help: try: `C::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:89:9
+  --> tests/ui/match_wildcard_for_single_variants.rs:96:9
    |
 LL |         _ => (),
    |         ^ help: try: `Color::Blue`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:124:13
+  --> tests/ui/match_wildcard_for_single_variants.rs:132:13
    |
 LL |             _ => (),
    |             ^ help: try: `Enum::__Private`
 
 error: wildcard matches only a single variant and will also match any future added variants
-  --> tests/ui/match_wildcard_for_single_variants.rs:151:13
+  --> tests/ui/match_wildcard_for_single_variants.rs:160:13
    |
 LL |             _ => 2,
    |             ^ help: try: `Foo::B`
diff --git a/src/tools/clippy/tests/ui/mem_forget.rs b/src/tools/clippy/tests/ui/mem_forget.rs
index 1f508b3bca28..b510af8ac6f1 100644
--- a/src/tools/clippy/tests/ui/mem_forget.rs
+++ b/src/tools/clippy/tests/ui/mem_forget.rs
@@ -12,23 +12,19 @@ fn main() {
 
     let six: Arc<i32> = Arc::new(6);
     memstuff::forget(six);
-    //~^ ERROR: usage of `mem::forget` on `Drop` type
-    //~| NOTE: argument has type `std::sync::Arc<i32>`
+    //~^ mem_forget
 
     let seven: Rc<i32> = Rc::new(7);
     std::mem::forget(seven);
-    //~^ ERROR: usage of `mem::forget` on `Drop` type
-    //~| NOTE: argument has type `std::rc::Rc<i32>`
+    //~^ mem_forget
 
     let eight: Vec<i32> = vec![8];
     forgetSomething(eight);
-    //~^ ERROR: usage of `mem::forget` on `Drop` type
-    //~| NOTE: argument has type `std::vec::Vec<i32>`
+    //~^ mem_forget
 
     let string = String::new();
     std::mem::forget(string);
-    //~^ ERROR: usage of `mem::forget` on type with `Drop` fields
-    //~| NOTE: argument has type `std::string::String`
+    //~^ mem_forget
 
     std::mem::forget(7);
 }
diff --git a/src/tools/clippy/tests/ui/mem_forget.stderr b/src/tools/clippy/tests/ui/mem_forget.stderr
index 3b0e839e0871..049db54a04b0 100644
--- a/src/tools/clippy/tests/ui/mem_forget.stderr
+++ b/src/tools/clippy/tests/ui/mem_forget.stderr
@@ -9,7 +9,7 @@ LL |     memstuff::forget(six);
    = help: to override `-D warnings` add `#[allow(clippy::mem_forget)]`
 
 error: usage of `mem::forget` on `Drop` type
-  --> tests/ui/mem_forget.rs:19:5
+  --> tests/ui/mem_forget.rs:18:5
    |
 LL |     std::mem::forget(seven);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     std::mem::forget(seven);
    = note: argument has type `std::rc::Rc<i32>`
 
 error: usage of `mem::forget` on `Drop` type
-  --> tests/ui/mem_forget.rs:24:5
+  --> tests/ui/mem_forget.rs:22:5
    |
 LL |     forgetSomething(eight);
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     forgetSomething(eight);
    = note: argument has type `std::vec::Vec<i32>`
 
 error: usage of `mem::forget` on type with `Drop` fields
-  --> tests/ui/mem_forget.rs:29:5
+  --> tests/ui/mem_forget.rs:26:5
    |
 LL |     std::mem::forget(string);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/mem_replace.fixed b/src/tools/clippy/tests/ui/mem_replace.fixed
index 4210dbbe82d3..870ef23113a2 100644
--- a/src/tools/clippy/tests/ui/mem_replace.fixed
+++ b/src/tools/clippy/tests/ui/mem_replace.fixed
@@ -11,53 +11,76 @@ use std::mem;
 fn replace_option_with_none() {
     let mut an_option = Some(1);
     let _ = an_option.take();
+    //~^ mem_replace_option_with_none
     let an_option = &mut Some(1);
     let _ = an_option.take();
+    //~^ mem_replace_option_with_none
 }
 
 fn replace_with_default() {
     let mut s = String::from("foo");
     let _ = std::mem::take(&mut s);
+    //~^ mem_replace_with_default
+    let _ = std::mem::take(&mut s);
+    //~^ mem_replace_with_default
 
     let s = &mut String::from("foo");
     let _ = std::mem::take(s);
+    //~^ mem_replace_with_default
     let _ = std::mem::take(s);
+    //~^ mem_replace_with_default
+    let _ = std::mem::take(s);
+    //~^ mem_replace_with_default
 
     let mut v = vec![123];
     let _ = std::mem::take(&mut v);
+    //~^ mem_replace_with_default
     let _ = std::mem::take(&mut v);
+    //~^ mem_replace_with_default
     let _ = std::mem::take(&mut v);
+    //~^ mem_replace_with_default
     let _ = std::mem::take(&mut v);
+    //~^ mem_replace_with_default
 
     let mut hash_map: HashMap<i32, i32> = HashMap::new();
     let _ = std::mem::take(&mut hash_map);
+    //~^ mem_replace_with_default
 
     let mut btree_map: BTreeMap<i32, i32> = BTreeMap::new();
     let _ = std::mem::take(&mut btree_map);
+    //~^ mem_replace_with_default
 
     let mut vd: VecDeque<i32> = VecDeque::new();
     let _ = std::mem::take(&mut vd);
+    //~^ mem_replace_with_default
 
     let mut hash_set: HashSet<&str> = HashSet::new();
     let _ = std::mem::take(&mut hash_set);
+    //~^ mem_replace_with_default
 
     let mut btree_set: BTreeSet<&str> = BTreeSet::new();
     let _ = std::mem::take(&mut btree_set);
+    //~^ mem_replace_with_default
 
     let mut list: LinkedList<i32> = LinkedList::new();
     let _ = std::mem::take(&mut list);
+    //~^ mem_replace_with_default
 
     let mut binary_heap: BinaryHeap<i32> = BinaryHeap::new();
     let _ = std::mem::take(&mut binary_heap);
+    //~^ mem_replace_with_default
 
     let mut tuple = (vec![1, 2], BinaryHeap::<i32>::new());
     let _ = std::mem::take(&mut tuple);
+    //~^ mem_replace_with_default
 
     let mut refstr = "hello";
     let _ = std::mem::take(&mut refstr);
+    //~^ mem_replace_with_default
 
     let mut slice: &[i32] = &[1, 2, 3];
     let _ = std::mem::take(&mut slice);
+    //~^ mem_replace_with_default
 }
 
 // lint is disabled for primitives because in this case `take`
@@ -94,6 +117,7 @@ fn msrv_1_39() {
 fn msrv_1_40() {
     let mut s = String::from("foo");
     let _ = std::mem::take(&mut s);
+    //~^ mem_replace_with_default
 }
 
 fn issue9824() {
@@ -124,8 +148,34 @@ fn issue9824() {
 
     // replace option with none
     let _ = f.0.take();
+    //~^ mem_replace_option_with_none
     let _ = (*f).take();
+    //~^ mem_replace_option_with_none
     let _ = b.opt.take();
+    //~^ mem_replace_option_with_none
     // replace with default
     let _ = std::mem::take(&mut b.val);
+    //~^ mem_replace_with_default
+}
+
+#[clippy::msrv = "1.31"]
+fn mem_replace_option_with_some() {
+    let mut an_option = Some(0);
+    let replaced = an_option.replace(1);
+    //~^ ERROR: replacing an `Option` with `Some(..)`
+
+    let mut an_option = &mut Some(0);
+    let replaced = an_option.replace(1);
+    //~^ ERROR: replacing an `Option` with `Some(..)`
+
+    let (mut opt1, mut opt2) = (Some(0), Some(0));
+    let b = true;
+    let replaced = (if b { &mut opt1 } else { &mut opt2 }).replace(1);
+    //~^ ERROR: replacing an `Option` with `Some(..)`
+}
+
+#[clippy::msrv = "1.30"]
+fn mem_replace_option_with_some_bad_msrv() {
+    let mut an_option = Some(0);
+    let replaced = mem::replace(&mut an_option, Some(1));
 }
diff --git a/src/tools/clippy/tests/ui/mem_replace.rs b/src/tools/clippy/tests/ui/mem_replace.rs
index bd7ad78b2af2..b4ed5eafea95 100644
--- a/src/tools/clippy/tests/ui/mem_replace.rs
+++ b/src/tools/clippy/tests/ui/mem_replace.rs
@@ -11,53 +11,76 @@ use std::mem;
 fn replace_option_with_none() {
     let mut an_option = Some(1);
     let _ = mem::replace(&mut an_option, None);
+    //~^ mem_replace_option_with_none
     let an_option = &mut Some(1);
     let _ = mem::replace(an_option, None);
+    //~^ mem_replace_option_with_none
 }
 
 fn replace_with_default() {
     let mut s = String::from("foo");
     let _ = std::mem::replace(&mut s, String::default());
+    //~^ mem_replace_with_default
+    let _ = std::mem::replace(&mut s, String::new());
+    //~^ mem_replace_with_default
 
     let s = &mut String::from("foo");
     let _ = std::mem::replace(s, String::default());
+    //~^ mem_replace_with_default
+    let _ = std::mem::replace(s, String::new());
+    //~^ mem_replace_with_default
     let _ = std::mem::replace(s, Default::default());
+    //~^ mem_replace_with_default
 
     let mut v = vec![123];
     let _ = std::mem::replace(&mut v, Vec::default());
+    //~^ mem_replace_with_default
     let _ = std::mem::replace(&mut v, Default::default());
+    //~^ mem_replace_with_default
     let _ = std::mem::replace(&mut v, Vec::new());
+    //~^ mem_replace_with_default
     let _ = std::mem::replace(&mut v, vec![]);
+    //~^ mem_replace_with_default
 
     let mut hash_map: HashMap<i32, i32> = HashMap::new();
     let _ = std::mem::replace(&mut hash_map, HashMap::new());
+    //~^ mem_replace_with_default
 
     let mut btree_map: BTreeMap<i32, i32> = BTreeMap::new();
     let _ = std::mem::replace(&mut btree_map, BTreeMap::new());
+    //~^ mem_replace_with_default
 
     let mut vd: VecDeque<i32> = VecDeque::new();
     let _ = std::mem::replace(&mut vd, VecDeque::new());
+    //~^ mem_replace_with_default
 
     let mut hash_set: HashSet<&str> = HashSet::new();
     let _ = std::mem::replace(&mut hash_set, HashSet::new());
+    //~^ mem_replace_with_default
 
     let mut btree_set: BTreeSet<&str> = BTreeSet::new();
     let _ = std::mem::replace(&mut btree_set, BTreeSet::new());
+    //~^ mem_replace_with_default
 
     let mut list: LinkedList<i32> = LinkedList::new();
     let _ = std::mem::replace(&mut list, LinkedList::new());
+    //~^ mem_replace_with_default
 
     let mut binary_heap: BinaryHeap<i32> = BinaryHeap::new();
     let _ = std::mem::replace(&mut binary_heap, BinaryHeap::new());
+    //~^ mem_replace_with_default
 
     let mut tuple = (vec![1, 2], BinaryHeap::<i32>::new());
     let _ = std::mem::replace(&mut tuple, (vec![], BinaryHeap::new()));
+    //~^ mem_replace_with_default
 
     let mut refstr = "hello";
     let _ = std::mem::replace(&mut refstr, "");
+    //~^ mem_replace_with_default
 
     let mut slice: &[i32] = &[1, 2, 3];
     let _ = std::mem::replace(&mut slice, &[]);
+    //~^ mem_replace_with_default
 }
 
 // lint is disabled for primitives because in this case `take`
@@ -94,6 +117,7 @@ fn msrv_1_39() {
 fn msrv_1_40() {
     let mut s = String::from("foo");
     let _ = std::mem::replace(&mut s, String::default());
+    //~^ mem_replace_with_default
 }
 
 fn issue9824() {
@@ -124,8 +148,34 @@ fn issue9824() {
 
     // replace option with none
     let _ = std::mem::replace(&mut f.0, None);
+    //~^ mem_replace_option_with_none
     let _ = std::mem::replace(&mut *f, None);
+    //~^ mem_replace_option_with_none
     let _ = std::mem::replace(&mut b.opt, None);
+    //~^ mem_replace_option_with_none
     // replace with default
     let _ = std::mem::replace(&mut b.val, String::default());
+    //~^ mem_replace_with_default
+}
+
+#[clippy::msrv = "1.31"]
+fn mem_replace_option_with_some() {
+    let mut an_option = Some(0);
+    let replaced = mem::replace(&mut an_option, Some(1));
+    //~^ ERROR: replacing an `Option` with `Some(..)`
+
+    let mut an_option = &mut Some(0);
+    let replaced = mem::replace(an_option, Some(1));
+    //~^ ERROR: replacing an `Option` with `Some(..)`
+
+    let (mut opt1, mut opt2) = (Some(0), Some(0));
+    let b = true;
+    let replaced = mem::replace(if b { &mut opt1 } else { &mut opt2 }, Some(1));
+    //~^ ERROR: replacing an `Option` with `Some(..)`
+}
+
+#[clippy::msrv = "1.30"]
+fn mem_replace_option_with_some_bad_msrv() {
+    let mut an_option = Some(0);
+    let replaced = mem::replace(&mut an_option, Some(1));
 }
diff --git a/src/tools/clippy/tests/ui/mem_replace.stderr b/src/tools/clippy/tests/ui/mem_replace.stderr
index c33f80b01b85..fb4a367266d3 100644
--- a/src/tools/clippy/tests/ui/mem_replace.stderr
+++ b/src/tools/clippy/tests/ui/mem_replace.stderr
@@ -8,13 +8,13 @@ LL |     let _ = mem::replace(&mut an_option, None);
    = help: to override `-D warnings` add `#[allow(clippy::mem_replace_option_with_none)]`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace.rs:15:13
+  --> tests/ui/mem_replace.rs:16:13
    |
 LL |     let _ = mem::replace(an_option, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `an_option.take()`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:20:13
+  --> tests/ui/mem_replace.rs:22:13
    |
 LL |     let _ = std::mem::replace(&mut s, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut s)`
@@ -23,130 +23,163 @@ LL |     let _ = std::mem::replace(&mut s, String::default());
    = help: to override `-D warnings` add `#[allow(clippy::mem_replace_with_default)]`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:23:13
+  --> tests/ui/mem_replace.rs:24:13
+   |
+LL |     let _ = std::mem::replace(&mut s, String::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut s)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> tests/ui/mem_replace.rs:28:13
    |
 LL |     let _ = std::mem::replace(s, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(s)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:24:13
+  --> tests/ui/mem_replace.rs:30:13
+   |
+LL |     let _ = std::mem::replace(s, String::new());
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(s)`
+
+error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
+  --> tests/ui/mem_replace.rs:32:13
    |
 LL |     let _ = std::mem::replace(s, Default::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(s)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:27:13
+  --> tests/ui/mem_replace.rs:36:13
    |
 LL |     let _ = std::mem::replace(&mut v, Vec::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:28:13
+  --> tests/ui/mem_replace.rs:38:13
    |
 LL |     let _ = std::mem::replace(&mut v, Default::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:29:13
+  --> tests/ui/mem_replace.rs:40:13
    |
 LL |     let _ = std::mem::replace(&mut v, Vec::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:30:13
+  --> tests/ui/mem_replace.rs:42:13
    |
 LL |     let _ = std::mem::replace(&mut v, vec![]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut v)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:33:13
+  --> tests/ui/mem_replace.rs:46:13
    |
 LL |     let _ = std::mem::replace(&mut hash_map, HashMap::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut hash_map)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:36:13
+  --> tests/ui/mem_replace.rs:50:13
    |
 LL |     let _ = std::mem::replace(&mut btree_map, BTreeMap::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut btree_map)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:39:13
+  --> tests/ui/mem_replace.rs:54:13
    |
 LL |     let _ = std::mem::replace(&mut vd, VecDeque::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut vd)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:42:13
+  --> tests/ui/mem_replace.rs:58:13
    |
 LL |     let _ = std::mem::replace(&mut hash_set, HashSet::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut hash_set)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:45:13
+  --> tests/ui/mem_replace.rs:62:13
    |
 LL |     let _ = std::mem::replace(&mut btree_set, BTreeSet::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut btree_set)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:48:13
+  --> tests/ui/mem_replace.rs:66:13
    |
 LL |     let _ = std::mem::replace(&mut list, LinkedList::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut list)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:51:13
+  --> tests/ui/mem_replace.rs:70:13
    |
 LL |     let _ = std::mem::replace(&mut binary_heap, BinaryHeap::new());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut binary_heap)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:54:13
+  --> tests/ui/mem_replace.rs:74:13
    |
 LL |     let _ = std::mem::replace(&mut tuple, (vec![], BinaryHeap::new()));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut tuple)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:57:13
+  --> tests/ui/mem_replace.rs:78:13
    |
 LL |     let _ = std::mem::replace(&mut refstr, "");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut refstr)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:60:13
+  --> tests/ui/mem_replace.rs:82:13
    |
 LL |     let _ = std::mem::replace(&mut slice, &[]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut slice)`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:96:13
+  --> tests/ui/mem_replace.rs:119:13
    |
 LL |     let _ = std::mem::replace(&mut s, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut s)`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace.rs:126:13
+  --> tests/ui/mem_replace.rs:150:13
    |
 LL |     let _ = std::mem::replace(&mut f.0, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `f.0.take()`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace.rs:127:13
+  --> tests/ui/mem_replace.rs:152:13
    |
 LL |     let _ = std::mem::replace(&mut *f, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `(*f).take()`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace.rs:128:13
+  --> tests/ui/mem_replace.rs:154:13
    |
 LL |     let _ = std::mem::replace(&mut b.opt, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `b.opt.take()`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `std::mem::take`
-  --> tests/ui/mem_replace.rs:130:13
+  --> tests/ui/mem_replace.rs:157:13
    |
 LL |     let _ = std::mem::replace(&mut b.val, String::default());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::mem::take(&mut b.val)`
 
-error: aborting due to 24 previous errors
+error: replacing an `Option` with `Some(..)`
+  --> tests/ui/mem_replace.rs:164:20
+   |
+LL |     let replaced = mem::replace(&mut an_option, Some(1));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::replace()` instead: `an_option.replace(1)`
+   |
+   = note: `-D clippy::mem-replace-option-with-some` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::mem_replace_option_with_some)]`
+
+error: replacing an `Option` with `Some(..)`
+  --> tests/ui/mem_replace.rs:168:20
+   |
+LL |     let replaced = mem::replace(an_option, Some(1));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::replace()` instead: `an_option.replace(1)`
+
+error: replacing an `Option` with `Some(..)`
+  --> tests/ui/mem_replace.rs:173:20
+   |
+LL |     let replaced = mem::replace(if b { &mut opt1 } else { &mut opt2 }, Some(1));
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::replace()` instead: `(if b { &mut opt1 } else { &mut opt2 }).replace(1)`
+
+error: aborting due to 29 previous errors
 
diff --git a/src/tools/clippy/tests/ui/mem_replace_macro.rs b/src/tools/clippy/tests/ui/mem_replace_macro.rs
index c14ea2942f3e..9458dade3a9c 100644
--- a/src/tools/clippy/tests/ui/mem_replace_macro.rs
+++ b/src/tools/clippy/tests/ui/mem_replace_macro.rs
@@ -8,5 +8,6 @@ use proc_macros::{external, inline_macros};
 fn main() {
     let s = &mut String::from("foo");
     let _ = inline!(std::mem::replace($s, Default::default()));
+    //~^ mem_replace_with_default
     let _ = external!(std::mem::replace($s, Default::default()));
 }
diff --git a/src/tools/clippy/tests/ui/mem_replace_no_std.fixed b/src/tools/clippy/tests/ui/mem_replace_no_std.fixed
index 60f523c8ef1e..669450e59d8b 100644
--- a/src/tools/clippy/tests/ui/mem_replace_no_std.fixed
+++ b/src/tools/clippy/tests/ui/mem_replace_no_std.fixed
@@ -21,16 +21,20 @@ fn panic(info: &PanicInfo) -> ! {
 fn replace_option_with_none() {
     let mut an_option = Some(1);
     let _ = an_option.take();
+    //~^ mem_replace_option_with_none
     let an_option = &mut Some(1);
     let _ = an_option.take();
+    //~^ mem_replace_option_with_none
 }
 
 fn replace_with_default() {
     let mut refstr = "hello";
     let _ = core::mem::take(&mut refstr);
+    //~^ mem_replace_with_default
 
     let mut slice: &[i32] = &[1, 2, 3];
     let _ = core::mem::take(&mut slice);
+    //~^ mem_replace_with_default
 }
 
 // lint is disabled for primitives because in this case `take`
@@ -74,8 +78,11 @@ fn issue9824() {
 
     // replace option with none
     let _ = f.0.take();
+    //~^ mem_replace_option_with_none
     let _ = (*f).take();
+    //~^ mem_replace_option_with_none
     let _ = b.opt.take();
+    //~^ mem_replace_option_with_none
     // replace with default
     let _ = mem::replace(&mut b.val, u8::default());
 }
diff --git a/src/tools/clippy/tests/ui/mem_replace_no_std.rs b/src/tools/clippy/tests/ui/mem_replace_no_std.rs
index d1cb9a5817ba..2cdf1df5196a 100644
--- a/src/tools/clippy/tests/ui/mem_replace_no_std.rs
+++ b/src/tools/clippy/tests/ui/mem_replace_no_std.rs
@@ -21,16 +21,20 @@ fn panic(info: &PanicInfo) -> ! {
 fn replace_option_with_none() {
     let mut an_option = Some(1);
     let _ = mem::replace(&mut an_option, None);
+    //~^ mem_replace_option_with_none
     let an_option = &mut Some(1);
     let _ = mem::replace(an_option, None);
+    //~^ mem_replace_option_with_none
 }
 
 fn replace_with_default() {
     let mut refstr = "hello";
     let _ = mem::replace(&mut refstr, "");
+    //~^ mem_replace_with_default
 
     let mut slice: &[i32] = &[1, 2, 3];
     let _ = mem::replace(&mut slice, &[]);
+    //~^ mem_replace_with_default
 }
 
 // lint is disabled for primitives because in this case `take`
@@ -74,8 +78,11 @@ fn issue9824() {
 
     // replace option with none
     let _ = mem::replace(&mut f.0, None);
+    //~^ mem_replace_option_with_none
     let _ = mem::replace(&mut *f, None);
+    //~^ mem_replace_option_with_none
     let _ = mem::replace(&mut b.opt, None);
+    //~^ mem_replace_option_with_none
     // replace with default
     let _ = mem::replace(&mut b.val, u8::default());
 }
diff --git a/src/tools/clippy/tests/ui/mem_replace_no_std.stderr b/src/tools/clippy/tests/ui/mem_replace_no_std.stderr
index 6ba6d2162a74..926a8288fd31 100644
--- a/src/tools/clippy/tests/ui/mem_replace_no_std.stderr
+++ b/src/tools/clippy/tests/ui/mem_replace_no_std.stderr
@@ -8,13 +8,13 @@ LL |     let _ = mem::replace(&mut an_option, None);
    = help: to override `-D warnings` add `#[allow(clippy::mem_replace_option_with_none)]`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace_no_std.rs:25:13
+  --> tests/ui/mem_replace_no_std.rs:26:13
    |
 LL |     let _ = mem::replace(an_option, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `an_option.take()`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `core::mem::take`
-  --> tests/ui/mem_replace_no_std.rs:30:13
+  --> tests/ui/mem_replace_no_std.rs:32:13
    |
 LL |     let _ = mem::replace(&mut refstr, "");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `core::mem::take(&mut refstr)`
@@ -23,25 +23,25 @@ LL |     let _ = mem::replace(&mut refstr, "");
    = help: to override `-D warnings` add `#[allow(clippy::mem_replace_with_default)]`
 
 error: replacing a value of type `T` with `T::default()` is better expressed using `core::mem::take`
-  --> tests/ui/mem_replace_no_std.rs:33:13
+  --> tests/ui/mem_replace_no_std.rs:36:13
    |
 LL |     let _ = mem::replace(&mut slice, &[]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `core::mem::take(&mut slice)`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace_no_std.rs:76:13
+  --> tests/ui/mem_replace_no_std.rs:80:13
    |
 LL |     let _ = mem::replace(&mut f.0, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `f.0.take()`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace_no_std.rs:77:13
+  --> tests/ui/mem_replace_no_std.rs:82:13
    |
 LL |     let _ = mem::replace(&mut *f, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `(*f).take()`
 
 error: replacing an `Option` with `None`
-  --> tests/ui/mem_replace_no_std.rs:78:13
+  --> tests/ui/mem_replace_no_std.rs:84:13
    |
 LL |     let _ = mem::replace(&mut b.opt, None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider `Option::take()` instead: `b.opt.take()`
diff --git a/src/tools/clippy/tests/ui/methods.rs b/src/tools/clippy/tests/ui/methods.rs
index cb1f695c651c..76b0d131dd41 100644
--- a/src/tools/clippy/tests/ui/methods.rs
+++ b/src/tools/clippy/tests/ui/methods.rs
@@ -11,6 +11,7 @@
     clippy::new_without_default,
     clippy::needless_pass_by_value,
     clippy::needless_lifetimes,
+    clippy::elidable_lifetime_names,
     clippy::print_stdout,
     clippy::must_use_candidate,
     clippy::use_self,
@@ -101,6 +102,7 @@ struct BadNew;
 
 impl BadNew {
     fn new() -> i32 {
+        //~^ new_ret_no_self
         0
     }
 }
@@ -122,6 +124,7 @@ fn filter_next() {
 
     // Multi-line case.
     let _ = v.iter().filter(|&x| {
+    //~^ filter_next
                                 *x < 0
                             }
                    ).next();
diff --git a/src/tools/clippy/tests/ui/methods.stderr b/src/tools/clippy/tests/ui/methods.stderr
index 2e2bd3d874f5..353b999d7da0 100644
--- a/src/tools/clippy/tests/ui/methods.stderr
+++ b/src/tools/clippy/tests/ui/methods.stderr
@@ -1,7 +1,8 @@
 error: methods called `new` usually return `Self`
-  --> tests/ui/methods.rs:103:5
+  --> tests/ui/methods.rs:104:5
    |
 LL | /     fn new() -> i32 {
+LL | |
 LL | |         0
 LL | |     }
    | |_____^
@@ -10,10 +11,11 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::new_ret_no_self)]`
 
 error: called `filter(..).next()` on an `Iterator`. This is more succinctly expressed by calling `.find(..)` instead
-  --> tests/ui/methods.rs:124:13
+  --> tests/ui/methods.rs:126:13
    |
 LL |       let _ = v.iter().filter(|&x| {
    |  _____________^
+LL | |
 LL | |                                 *x < 0
 LL | |                             }
 LL | |                    ).next();
diff --git a/src/tools/clippy/tests/ui/methods_fixable.fixed b/src/tools/clippy/tests/ui/methods_fixable.fixed
index bb06b5a480ff..49730d811558 100644
--- a/src/tools/clippy/tests/ui/methods_fixable.fixed
+++ b/src/tools/clippy/tests/ui/methods_fixable.fixed
@@ -7,4 +7,5 @@ fn main() {
 
     // Single-line case.
     let _ = v.iter().find(|&x| *x < 0);
+    //~^ filter_next
 }
diff --git a/src/tools/clippy/tests/ui/methods_fixable.rs b/src/tools/clippy/tests/ui/methods_fixable.rs
index 11de924593ed..a499b63b6f5b 100644
--- a/src/tools/clippy/tests/ui/methods_fixable.rs
+++ b/src/tools/clippy/tests/ui/methods_fixable.rs
@@ -7,4 +7,5 @@ fn main() {
 
     // Single-line case.
     let _ = v.iter().filter(|&x| *x < 0).next();
+    //~^ filter_next
 }
diff --git a/src/tools/clippy/tests/ui/methods_unfixable.rs b/src/tools/clippy/tests/ui/methods_unfixable.rs
index ee59983a7573..c19a769f7974 100644
--- a/src/tools/clippy/tests/ui/methods_unfixable.rs
+++ b/src/tools/clippy/tests/ui/methods_unfixable.rs
@@ -7,5 +7,5 @@ fn main() {
 pub fn issue10029() {
     let iter = (0..10);
     let _ = iter.filter(|_| true).next();
-    //~^ ERROR: called `filter(..).next()` on an `Iterator`. This is more succinctly expre
+    //~^ filter_next
 }
diff --git a/src/tools/clippy/tests/ui/min_ident_chars.rs b/src/tools/clippy/tests/ui/min_ident_chars.rs
index 1d89f26b6ee4..f473ac848a8e 100644
--- a/src/tools/clippy/tests/ui/min_ident_chars.rs
+++ b/src/tools/clippy/tests/ui/min_ident_chars.rs
@@ -7,24 +7,35 @@ extern crate proc_macros;
 use proc_macros::{external, with_span};
 
 struct A {
+    //~^ min_ident_chars
     a: u32,
+    //~^ min_ident_chars
     i: u32,
     A: u32,
+    //~^ min_ident_chars
     I: u32,
+    //~^ min_ident_chars
 }
 
 struct B(u32);
+//~^ min_ident_chars
 
 struct O {
+    //~^ min_ident_chars
     o: u32,
+    //~^ min_ident_chars
 }
 
 struct i;
 
 enum C {
+    //~^ min_ident_chars
     D,
+    //~^ min_ident_chars
     E,
+    //~^ min_ident_chars
     F,
+    //~^ min_ident_chars
     j,
 }
 
@@ -39,8 +50,11 @@ struct AA<T, E>(T, E);
 
 trait Trait {
     const A: u32 = 0;
+    //~^ min_ident_chars
     type A;
+    //~^ min_ident_chars
     fn a() {}
+    //~^ min_ident_chars
 }
 
 fn main() {
@@ -55,22 +69,37 @@ fn main() {
     let z = 1;
     // Implicitly disallowed idents
     let h = 1;
+    //~^ min_ident_chars
     let e = 2;
+    //~^ min_ident_chars
     let l = 3;
+    //~^ min_ident_chars
     let l = 4;
+    //~^ min_ident_chars
     let o = 6;
+    //~^ min_ident_chars
     // 2 len does not lint
     let hi = 0;
     // Lint
     let (h, o, w) = (1, 2, 3);
+    //~^ min_ident_chars
+    //~| min_ident_chars
     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
+    //~^ min_ident_chars
+    //~| min_ident_chars
+    //~| min_ident_chars
     let you = Vec4 { x: 1, y: 2, z: 3, w: 4 };
     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
+    //~^ min_ident_chars
+    //~| min_ident_chars
+    //~| min_ident_chars
     let today = true;
     // Ideally this wouldn't lint, but this would (likely) require global analysis, outta scope
     // of this lint regardless
     let o = 1;
+    //~^ min_ident_chars
     let o = O { o };
+    //~^ min_ident_chars
 
     for j in 0..1000 {}
     for _ in 0..10 {}
@@ -85,7 +114,10 @@ fn main() {
 }
 
 fn b() {}
+//~^ min_ident_chars
 fn wrong_pythagoras(a: f32, b: f32) -> f32 {
+    //~^ min_ident_chars
+    //~| min_ident_chars
     a * a + a * b
 }
 
diff --git a/src/tools/clippy/tests/ui/min_ident_chars.stderr b/src/tools/clippy/tests/ui/min_ident_chars.stderr
index 3dd5c9561fd0..bd6c45cf648e 100644
--- a/src/tools/clippy/tests/ui/min_ident_chars.stderr
+++ b/src/tools/clippy/tests/ui/min_ident_chars.stderr
@@ -8,187 +8,187 @@ LL | struct A {
    = help: to override `-D warnings` add `#[allow(clippy::min_ident_chars)]`
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:10:5
+  --> tests/ui/min_ident_chars.rs:11:5
    |
 LL |     a: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:12:5
+  --> tests/ui/min_ident_chars.rs:14:5
    |
 LL |     A: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:13:5
+  --> tests/ui/min_ident_chars.rs:16:5
    |
 LL |     I: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:16:8
+  --> tests/ui/min_ident_chars.rs:20:8
    |
 LL | struct B(u32);
    |        ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:18:8
+  --> tests/ui/min_ident_chars.rs:23:8
    |
 LL | struct O {
    |        ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:19:5
+  --> tests/ui/min_ident_chars.rs:25:5
    |
 LL |     o: u32,
    |     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:24:6
+  --> tests/ui/min_ident_chars.rs:31:6
    |
 LL | enum C {
    |      ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:25:5
+  --> tests/ui/min_ident_chars.rs:33:5
    |
 LL |     D,
    |     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:26:5
+  --> tests/ui/min_ident_chars.rs:35:5
    |
 LL |     E,
    |     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:27:5
+  --> tests/ui/min_ident_chars.rs:37:5
    |
 LL |     F,
    |     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:41:11
+  --> tests/ui/min_ident_chars.rs:52:11
    |
 LL |     const A: u32 = 0;
    |           ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:42:10
+  --> tests/ui/min_ident_chars.rs:54:10
    |
 LL |     type A;
    |          ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:43:8
+  --> tests/ui/min_ident_chars.rs:56:8
    |
 LL |     fn a() {}
    |        ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:57:9
+  --> tests/ui/min_ident_chars.rs:71:9
    |
 LL |     let h = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:58:9
+  --> tests/ui/min_ident_chars.rs:73:9
    |
 LL |     let e = 2;
    |         ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:59:9
+  --> tests/ui/min_ident_chars.rs:75:9
    |
 LL |     let l = 3;
    |         ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:60:9
+  --> tests/ui/min_ident_chars.rs:77:9
    |
 LL |     let l = 4;
    |         ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:61:9
+  --> tests/ui/min_ident_chars.rs:79:9
    |
 LL |     let o = 6;
    |         ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:65:10
+  --> tests/ui/min_ident_chars.rs:84:10
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |          ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:65:13
+  --> tests/ui/min_ident_chars.rs:84:13
    |
 LL |     let (h, o, w) = (1, 2, 3);
    |             ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:66:10
+  --> tests/ui/min_ident_chars.rs:87:10
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |          ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:66:14
+  --> tests/ui/min_ident_chars.rs:87:14
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |              ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:66:17
+  --> tests/ui/min_ident_chars.rs:87:17
    |
 LL |     for (a, (r, e)) in (0..1000).enumerate().enumerate() {}
    |                 ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:68:16
+  --> tests/ui/min_ident_chars.rs:92:16
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:68:19
+  --> tests/ui/min_ident_chars.rs:92:19
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                   ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:68:29
+  --> tests/ui/min_ident_chars.rs:92:29
    |
 LL |     while let (d, o, _i, n, g) = (true, true, false, false, true) {}
    |                             ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:72:9
+  --> tests/ui/min_ident_chars.rs:99:9
    |
 LL |     let o = 1;
    |         ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:73:9
+  --> tests/ui/min_ident_chars.rs:101:9
    |
 LL |     let o = O { o };
    |         ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:87:4
+  --> tests/ui/min_ident_chars.rs:116:4
    |
 LL | fn b() {}
    |    ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:88:21
+  --> tests/ui/min_ident_chars.rs:118:21
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                     ^
 
 error: this ident consists of a single char
-  --> tests/ui/min_ident_chars.rs:88:29
+  --> tests/ui/min_ident_chars.rs:118:29
    |
 LL | fn wrong_pythagoras(a: f32, b: f32) -> f32 {
    |                             ^
diff --git a/src/tools/clippy/tests/ui/min_max.rs b/src/tools/clippy/tests/ui/min_max.rs
index cf64f85f9bb5..f3eeb85f20ed 100644
--- a/src/tools/clippy/tests/ui/min_max.rs
+++ b/src/tools/clippy/tests/ui/min_max.rs
@@ -20,17 +20,19 @@ impl NotOrd {
 fn main() {
     let x = 2usize;
     min(1, max(3, x));
-    //~^ ERROR: this `min`/`max` combination leads to constant result
-    //~| NOTE: `-D clippy::min-max` implied by `-D warnings`
+    //~^ min_max
+
     min(max(3, x), 1);
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
+
     max(min(x, 1), 3);
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
+
     max(3, min(x, 1));
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
 
     my_max(3, my_min(x, 1));
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
 
     min(3, max(1, x)); // ok, could be 1, 2 or 3 depending on x
 
@@ -41,32 +43,37 @@ fn main() {
 
     let s = "Hello";
     min("Apple", max("Zoo", s));
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
+
     max(min(s, "Apple"), "Zoo");
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
 
     max("Apple", min(s, "Zoo")); // ok
 
     let f = 3f32;
     x.min(1).max(3);
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
+
     x.max(3).min(1);
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
+
     f.max(3f32).min(1f32);
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
 
     x.max(1).min(3); // ok
     x.min(3).max(1); // ok
     f.min(3f32).max(1f32); // ok
 
     max(x.min(1), 3);
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
+
     min(x.max(1), 3); // ok
 
     s.max("Zoo").min("Apple");
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
+
     s.min("Apple").max("Zoo");
-    //~^ ERROR: this `min`/`max` combination leads to constant result
+    //~^ min_max
 
     s.min("Zoo").max("Apple"); // ok
 
diff --git a/src/tools/clippy/tests/ui/min_max.stderr b/src/tools/clippy/tests/ui/min_max.stderr
index bb1a82e320d9..84b4d3754552 100644
--- a/src/tools/clippy/tests/ui/min_max.stderr
+++ b/src/tools/clippy/tests/ui/min_max.stderr
@@ -14,67 +14,67 @@ LL |     min(max(3, x), 1);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:27:5
+  --> tests/ui/min_max.rs:28:5
    |
 LL |     max(min(x, 1), 3);
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:29:5
+  --> tests/ui/min_max.rs:31:5
    |
 LL |     max(3, min(x, 1));
    |     ^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:32:5
+  --> tests/ui/min_max.rs:34:5
    |
 LL |     my_max(3, my_min(x, 1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:43:5
+  --> tests/ui/min_max.rs:45:5
    |
 LL |     min("Apple", max("Zoo", s));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:45:5
+  --> tests/ui/min_max.rs:48:5
    |
 LL |     max(min(s, "Apple"), "Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:51:5
+  --> tests/ui/min_max.rs:54:5
    |
 LL |     x.min(1).max(3);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:53:5
+  --> tests/ui/min_max.rs:57:5
    |
 LL |     x.max(3).min(1);
    |     ^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:55:5
+  --> tests/ui/min_max.rs:60:5
    |
 LL |     f.max(3f32).min(1f32);
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:62:5
+  --> tests/ui/min_max.rs:67:5
    |
 LL |     max(x.min(1), 3);
    |     ^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:66:5
+  --> tests/ui/min_max.rs:72:5
    |
 LL |     s.max("Zoo").min("Apple");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this `min`/`max` combination leads to constant result
-  --> tests/ui/min_max.rs:68:5
+  --> tests/ui/min_max.rs:75:5
    |
 LL |     s.min("Apple").max("Zoo");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/min_rust_version_attr.rs b/src/tools/clippy/tests/ui/min_rust_version_attr.rs
index 5fe3306d6fc8..4627bef28a29 100644
--- a/src/tools/clippy/tests/ui/min_rust_version_attr.rs
+++ b/src/tools/clippy/tests/ui/min_rust_version_attr.rs
@@ -11,13 +11,13 @@ fn just_under_msrv() {
 #[clippy::msrv = "1.43.0"]
 fn meets_msrv() {
     let log2_10 = 3.321928094887362;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_10` found
+    //~^ approx_constant
 }
 
 #[clippy::msrv = "1.44.0"]
 fn just_above_msrv() {
     let log2_10 = 3.321928094887362;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_10` found
+    //~^ approx_constant
 }
 
 #[clippy::msrv = "1.42"]
@@ -28,7 +28,7 @@ fn no_patch_under() {
 #[clippy::msrv = "1.43"]
 fn no_patch_meets() {
     let log2_10 = 3.321928094887362;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_10` found
+    //~^ approx_constant
 }
 
 fn inner_attr_under() {
@@ -39,7 +39,7 @@ fn inner_attr_under() {
 fn inner_attr_meets() {
     #![clippy::msrv = "1.43"]
     let log2_10 = 3.321928094887362;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_10` found
+    //~^ approx_constant
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/6920
@@ -50,7 +50,7 @@ fn scoping() {
 
     // Should warn
     let log2_10 = 3.321928094887362;
-    //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_10` found
+    //~^ approx_constant
 
     mod a {
         #![clippy::msrv = "1.42.0"]
@@ -58,7 +58,7 @@ fn scoping() {
         fn should_warn() {
             #![clippy::msrv = "1.43.0"]
             let log2_10 = 3.321928094887362;
-            //~^ ERROR: approximate value of `f{32, 64}::consts::LOG2_10` found
+            //~^ approx_constant
         }
 
         fn should_not_warn() {
diff --git a/src/tools/clippy/tests/ui/mismatching_type_param_order.rs b/src/tools/clippy/tests/ui/mismatching_type_param_order.rs
index a4560f9e9a99..11ff865b583b 100644
--- a/src/tools/clippy/tests/ui/mismatching_type_param_order.rs
+++ b/src/tools/clippy/tests/ui/mismatching_type_param_order.rs
@@ -9,12 +9,12 @@ fn main() {
 
     // lint on both params
     impl<B, A> Foo<B, A> {}
-    //~^ ERROR: `Foo` has a similarly named generic type parameter `B` in its declaration,
-    //~| ERROR: `Foo` has a similarly named generic type parameter `A` in its declaration,
+    //~^ mismatching_type_param_order
+    //~| mismatching_type_param_order
 
     // lint on the 2nd param
     impl<C, A> Foo<C, A> {}
-    //~^ ERROR: `Foo` has a similarly named generic type parameter `A` in its declaration,
+    //~^ mismatching_type_param_order
 
     // should not lint
     impl<A, B> Foo<A, B> {}
@@ -26,8 +26,8 @@ fn main() {
 
     // should not lint on lifetimes
     impl<'m, 'l, B, A> FooLifetime<'m, 'l, B, A> {}
-    //~^ ERROR: `FooLifetime` has a similarly named generic type parameter `B` in its decl
-    //~| ERROR: `FooLifetime` has a similarly named generic type parameter `A` in its decl
+    //~^ mismatching_type_param_order
+    //~| mismatching_type_param_order
 
     struct Bar {
         x: i32,
@@ -44,9 +44,9 @@ fn main() {
     }
 
     impl<C, A, B> FooEnum<C, A, B> {}
-    //~^ ERROR: `FooEnum` has a similarly named generic type parameter `C` in its declarat
-    //~| ERROR: `FooEnum` has a similarly named generic type parameter `A` in its declarat
-    //~| ERROR: `FooEnum` has a similarly named generic type parameter `B` in its declarat
+    //~^ mismatching_type_param_order
+    //~| mismatching_type_param_order
+    //~| mismatching_type_param_order
 
     // also works for unions
     union FooUnion<A: Copy, B>
@@ -58,8 +58,8 @@ fn main() {
     }
 
     impl<B: Copy, A> FooUnion<B, A> where A: Copy {}
-    //~^ ERROR: `FooUnion` has a similarly named generic type parameter `B` in its declara
-    //~| ERROR: `FooUnion` has a similarly named generic type parameter `A` in its declara
+    //~^ mismatching_type_param_order
+    //~| mismatching_type_param_order
 
     impl<A, B> FooUnion<A, B>
     where
diff --git a/src/tools/clippy/tests/ui/misnamed_getters.fixed b/src/tools/clippy/tests/ui/misnamed_getters.fixed
index 70af604b2144..cada5307b1c8 100644
--- a/src/tools/clippy/tests/ui/misnamed_getters.fixed
+++ b/src/tools/clippy/tests/ui/misnamed_getters.fixed
@@ -10,32 +10,37 @@ struct A {
 
 impl A {
     fn a(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
-        //~| NOTE: `-D clippy::misnamed-getters` implied by `-D warnings`
+        //~^ misnamed_getters
+
         &self.a
     }
     fn a_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 
     fn b(self) -> u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         self.b
     }
 
     fn b_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 
     fn c(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.c
     }
 
     fn c_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.c
     }
 }
@@ -47,21 +52,25 @@ union B {
 
 impl B {
     unsafe fn a(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.a
     }
     unsafe fn a_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 
     unsafe fn b(self) -> u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         self.b
     }
 
     unsafe fn b_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 
@@ -74,21 +83,25 @@ impl B {
     }
 
     unsafe fn a_unchecked(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.a
     }
     unsafe fn a_unchecked_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 
     unsafe fn b_unchecked(self) -> u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         self.b
     }
 
     unsafe fn b_unchecked_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 
@@ -121,20 +134,24 @@ impl core::ops::DerefMut for D {
 
 impl D {
     fn a(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.a
     }
     fn a_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 
     fn d(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.d
     }
     fn d_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.d
     }
 }
diff --git a/src/tools/clippy/tests/ui/misnamed_getters.rs b/src/tools/clippy/tests/ui/misnamed_getters.rs
index 23c3e7bc5cf7..f529c56b4717 100644
--- a/src/tools/clippy/tests/ui/misnamed_getters.rs
+++ b/src/tools/clippy/tests/ui/misnamed_getters.rs
@@ -10,32 +10,37 @@ struct A {
 
 impl A {
     fn a(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
-        //~| NOTE: `-D clippy::misnamed-getters` implied by `-D warnings`
+        //~^ misnamed_getters
+
         &self.b
     }
     fn a_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 
     fn b(self) -> u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         self.a
     }
 
     fn b_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 
     fn c(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.b
     }
 
     fn c_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 }
@@ -47,21 +52,25 @@ union B {
 
 impl B {
     unsafe fn a(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.b
     }
     unsafe fn a_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 
     unsafe fn b(self) -> u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         self.a
     }
 
     unsafe fn b_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 
@@ -74,21 +83,25 @@ impl B {
     }
 
     unsafe fn a_unchecked(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.b
     }
     unsafe fn a_unchecked_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 
     unsafe fn b_unchecked(self) -> u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         self.a
     }
 
     unsafe fn b_unchecked_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.a
     }
 
@@ -121,20 +134,24 @@ impl core::ops::DerefMut for D {
 
 impl D {
     fn a(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.b
     }
     fn a_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 
     fn d(&self) -> &u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &self.b
     }
     fn d_mut(&mut self) -> &mut u8 {
-        //~^ ERROR: getter function appears to return the wrong field
+        //~^ misnamed_getters
+
         &mut self.b
     }
 }
diff --git a/src/tools/clippy/tests/ui/misnamed_getters.stderr b/src/tools/clippy/tests/ui/misnamed_getters.stderr
index 056fa2be9215..5dd1d75bcf6f 100644
--- a/src/tools/clippy/tests/ui/misnamed_getters.stderr
+++ b/src/tools/clippy/tests/ui/misnamed_getters.stderr
@@ -17,135 +17,105 @@ error: getter function appears to return the wrong field
    |
 LL | /     fn a_mut(&mut self) -> &mut u8 {
 LL | |
+LL | |
 LL | |         &mut self.b
    | |         ----------- help: consider using: `&mut self.a`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:22:5
+  --> tests/ui/misnamed_getters.rs:23:5
    |
 LL | /     fn b(self) -> u8 {
 LL | |
+LL | |
 LL | |         self.a
    | |         ------ help: consider using: `self.b`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:27:5
+  --> tests/ui/misnamed_getters.rs:29:5
    |
 LL | /     fn b_mut(&mut self) -> &mut u8 {
 LL | |
+LL | |
 LL | |         &mut self.a
    | |         ----------- help: consider using: `&mut self.b`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:32:5
+  --> tests/ui/misnamed_getters.rs:35:5
    |
 LL | /     fn c(&self) -> &u8 {
 LL | |
+LL | |
 LL | |         &self.b
    | |         ------- help: consider using: `&self.c`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:37:5
+  --> tests/ui/misnamed_getters.rs:41:5
    |
 LL | /     fn c_mut(&mut self) -> &mut u8 {
 LL | |
+LL | |
 LL | |         &mut self.a
    | |         ----------- help: consider using: `&mut self.c`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:49:5
+  --> tests/ui/misnamed_getters.rs:54:5
    |
 LL | /     unsafe fn a(&self) -> &u8 {
 LL | |
+LL | |
 LL | |         &self.b
    | |         ------- help: consider using: `&self.a`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:53:5
+  --> tests/ui/misnamed_getters.rs:59:5
    |
 LL | /     unsafe fn a_mut(&mut self) -> &mut u8 {
 LL | |
+LL | |
 LL | |         &mut self.b
    | |         ----------- help: consider using: `&mut self.a`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:58:5
+  --> tests/ui/misnamed_getters.rs:65:5
    |
 LL | /     unsafe fn b(self) -> u8 {
 LL | |
+LL | |
 LL | |         self.a
    | |         ------ help: consider using: `self.b`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:63:5
+  --> tests/ui/misnamed_getters.rs:71:5
    |
 LL | /     unsafe fn b_mut(&mut self) -> &mut u8 {
 LL | |
+LL | |
 LL | |         &mut self.a
    | |         ----------- help: consider using: `&mut self.b`
 LL | |     }
    | |_____^
 
-error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:76:5
-   |
-LL | /     unsafe fn a_unchecked(&self) -> &u8 {
-LL | |
-LL | |         &self.b
-   | |         ------- help: consider using: `&self.a`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:80:5
-   |
-LL | /     unsafe fn a_unchecked_mut(&mut self) -> &mut u8 {
-LL | |
-LL | |         &mut self.b
-   | |         ----------- help: consider using: `&mut self.a`
-LL | |     }
-   | |_____^
-
 error: getter function appears to return the wrong field
   --> tests/ui/misnamed_getters.rs:85:5
    |
-LL | /     unsafe fn b_unchecked(self) -> u8 {
+LL | /     unsafe fn a_unchecked(&self) -> &u8 {
 LL | |
-LL | |         self.a
-   | |         ------ help: consider using: `self.b`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:90:5
-   |
-LL | /     unsafe fn b_unchecked_mut(&mut self) -> &mut u8 {
-LL | |
-LL | |         &mut self.a
-   | |         ----------- help: consider using: `&mut self.b`
-LL | |     }
-   | |_____^
-
-error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:123:5
-   |
-LL | /     fn a(&self) -> &u8 {
 LL | |
 LL | |         &self.b
    | |         ------- help: consider using: `&self.a`
@@ -153,9 +123,10 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:127:5
+  --> tests/ui/misnamed_getters.rs:90:5
    |
-LL | /     fn a_mut(&mut self) -> &mut u8 {
+LL | /     unsafe fn a_unchecked_mut(&mut self) -> &mut u8 {
+LL | |
 LL | |
 LL | |         &mut self.b
    | |         ----------- help: consider using: `&mut self.a`
@@ -163,20 +134,66 @@ LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:132:5
+  --> tests/ui/misnamed_getters.rs:96:5
+   |
+LL | /     unsafe fn b_unchecked(self) -> u8 {
+LL | |
+LL | |
+LL | |         self.a
+   | |         ------ help: consider using: `self.b`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> tests/ui/misnamed_getters.rs:102:5
+   |
+LL | /     unsafe fn b_unchecked_mut(&mut self) -> &mut u8 {
+LL | |
+LL | |
+LL | |         &mut self.a
+   | |         ----------- help: consider using: `&mut self.b`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> tests/ui/misnamed_getters.rs:136:5
+   |
+LL | /     fn a(&self) -> &u8 {
+LL | |
+LL | |
+LL | |         &self.b
+   | |         ------- help: consider using: `&self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> tests/ui/misnamed_getters.rs:141:5
+   |
+LL | /     fn a_mut(&mut self) -> &mut u8 {
+LL | |
+LL | |
+LL | |         &mut self.b
+   | |         ----------- help: consider using: `&mut self.a`
+LL | |     }
+   | |_____^
+
+error: getter function appears to return the wrong field
+  --> tests/ui/misnamed_getters.rs:147:5
    |
 LL | /     fn d(&self) -> &u8 {
 LL | |
+LL | |
 LL | |         &self.b
    | |         ------- help: consider using: `&self.d`
 LL | |     }
    | |_____^
 
 error: getter function appears to return the wrong field
-  --> tests/ui/misnamed_getters.rs:136:5
+  --> tests/ui/misnamed_getters.rs:152:5
    |
 LL | /     fn d_mut(&mut self) -> &mut u8 {
 LL | |
+LL | |
 LL | |         &mut self.b
    | |         ----------- help: consider using: `&mut self.d`
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/missing_asserts_for_indexing.fixed b/src/tools/clippy/tests/ui/missing_asserts_for_indexing.fixed
index ac44a6f3fdb2..3bbafe0bba3f 100644
--- a/src/tools/clippy/tests/ui/missing_asserts_for_indexing.fixed
+++ b/src/tools/clippy/tests/ui/missing_asserts_for_indexing.fixed
@@ -28,25 +28,25 @@ fn sum_with_assert_ge_other_way(v: &[u8]) -> u8 {
 fn sum_with_assert_lt(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 fn sum_with_assert_le(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 fn sum_with_incorrect_assert_len(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 fn sum_with_incorrect_assert_len2(v: &[u8]) -> u8 {
     assert!(v.len() > 4);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 // ok, don't lint for single array access
@@ -64,7 +64,8 @@ fn subslice_ok(v: &[u8]) {
 fn subslice_bad(v: &[u8]) {
     assert!(v.len() > 3);
     let _ = v[0];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v[1..4];
 }
 
@@ -78,7 +79,8 @@ fn subslice_inclusive_ok(v: &[u8]) {
 fn subslice_inclusive_bad(v: &[u8]) {
     assert!(v.len() > 4);
     let _ = v[0];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v[1..=4];
 }
 
@@ -93,15 +95,17 @@ fn index_different_slices_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() > 12);
     assert!(v2.len() > 15);
     let _ = v1[0] + v1[12];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v2[5] + v2[15];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 fn index_different_slices_one_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() > 12);
     assert!(v2.len() > 15);
     let _ = v1[0] + v1[12];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v2[5] + v2[15];
 }
 
@@ -125,11 +129,13 @@ fn issue11835(v1: &[u8], v2: &[u8], v3: &[u8], v4: &[u8]) {
     assert!(4 == v4.len());
 
     let _ = v1[0] + v1[1] + v1[2];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v2[0] + v2[1] + v2[2];
 
     let _ = v3[0] + v3[1] + v3[2];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v4[0] + v4[1] + v4[2];
 }
 
diff --git a/src/tools/clippy/tests/ui/missing_asserts_for_indexing.rs b/src/tools/clippy/tests/ui/missing_asserts_for_indexing.rs
index f05d5fea57dc..f8ea0173c13f 100644
--- a/src/tools/clippy/tests/ui/missing_asserts_for_indexing.rs
+++ b/src/tools/clippy/tests/ui/missing_asserts_for_indexing.rs
@@ -28,25 +28,25 @@ fn sum_with_assert_ge_other_way(v: &[u8]) -> u8 {
 fn sum_with_assert_lt(v: &[u8]) -> u8 {
     assert!(v.len() < 5);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 fn sum_with_assert_le(v: &[u8]) -> u8 {
     assert!(v.len() <= 5);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 fn sum_with_incorrect_assert_len(v: &[u8]) -> u8 {
     assert!(v.len() > 3);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 fn sum_with_incorrect_assert_len2(v: &[u8]) -> u8 {
     assert!(v.len() >= 4);
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 
 // ok, don't lint for single array access
@@ -64,7 +64,8 @@ fn subslice_ok(v: &[u8]) {
 fn subslice_bad(v: &[u8]) {
     assert!(v.len() >= 3);
     let _ = v[0];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v[1..4];
 }
 
@@ -78,7 +79,8 @@ fn subslice_inclusive_ok(v: &[u8]) {
 fn subslice_inclusive_bad(v: &[u8]) {
     assert!(v.len() >= 4);
     let _ = v[0];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v[1..=4];
 }
 
@@ -93,15 +95,17 @@ fn index_different_slices_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() >= 12);
     assert!(v2.len() >= 15);
     let _ = v1[0] + v1[12];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v2[5] + v2[15];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
 }
 fn index_different_slices_one_wrong_len(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() >= 12);
     assert!(v2.len() > 15);
     let _ = v1[0] + v1[12];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v2[5] + v2[15];
 }
 
@@ -125,11 +129,13 @@ fn issue11835(v1: &[u8], v2: &[u8], v3: &[u8], v4: &[u8]) {
     assert!(4 == v4.len());
 
     let _ = v1[0] + v1[1] + v1[2];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v2[0] + v2[1] + v2[2];
 
     let _ = v3[0] + v3[1] + v3[2];
-    //~^ ERROR: indexing into a slice multiple times with an `assert` that does not cover the
+    //~^ missing_asserts_for_indexing
+
     let _ = v4[0] + v4[1] + v4[2];
 }
 
diff --git a/src/tools/clippy/tests/ui/missing_asserts_for_indexing.stderr b/src/tools/clippy/tests/ui/missing_asserts_for_indexing.stderr
index 2e63cd4a0e50..5d30920ccf52 100644
--- a/src/tools/clippy/tests/ui/missing_asserts_for_indexing.stderr
+++ b/src/tools/clippy/tests/ui/missing_asserts_for_indexing.stderr
@@ -147,7 +147,7 @@ LL |       assert!(v.len() >= 3);
    |       --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 3)`
 LL |       let _ = v[0];
    |  _____________^
-LL | |
+...  |
 LL | |     let _ = v[1..4];
    | |___________________^
    |
@@ -157,37 +157,37 @@ note: slice indexed here
 LL |     let _ = v[0];
    |             ^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:68:13
+  --> tests/ui/missing_asserts_for_indexing.rs:69:13
    |
 LL |     let _ = v[1..4];
    |             ^^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> tests/ui/missing_asserts_for_indexing.rs:80:13
+  --> tests/ui/missing_asserts_for_indexing.rs:81:13
    |
 LL |       assert!(v.len() >= 4);
    |       --------------------- help: provide the highest index that is indexed with: `assert!(v.len() > 4)`
 LL |       let _ = v[0];
    |  _____________^
-LL | |
+...  |
 LL | |     let _ = v[1..=4];
    | |____________________^
    |
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:80:13
+  --> tests/ui/missing_asserts_for_indexing.rs:81:13
    |
 LL |     let _ = v[0];
    |             ^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:82:13
+  --> tests/ui/missing_asserts_for_indexing.rs:84:13
    |
 LL |     let _ = v[1..=4];
    |             ^^^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> tests/ui/missing_asserts_for_indexing.rs:95:13
+  --> tests/ui/missing_asserts_for_indexing.rs:97:13
    |
 LL |     assert!(v1.len() >= 12);
    |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
@@ -196,19 +196,19 @@ LL |     let _ = v1[0] + v1[12];
    |             ^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:95:13
+  --> tests/ui/missing_asserts_for_indexing.rs:97:13
    |
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:95:21
+  --> tests/ui/missing_asserts_for_indexing.rs:97:21
    |
 LL |     let _ = v1[0] + v1[12];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> tests/ui/missing_asserts_for_indexing.rs:97:13
+  --> tests/ui/missing_asserts_for_indexing.rs:100:13
    |
 LL |     assert!(v2.len() >= 15);
    |     ----------------------- help: provide the highest index that is indexed with: `assert!(v2.len() > 15)`
@@ -217,19 +217,19 @@ LL |     let _ = v2[5] + v2[15];
    |             ^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:97:13
+  --> tests/ui/missing_asserts_for_indexing.rs:100:13
    |
 LL |     let _ = v2[5] + v2[15];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:97:21
+  --> tests/ui/missing_asserts_for_indexing.rs:100:21
    |
 LL |     let _ = v2[5] + v2[15];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> tests/ui/missing_asserts_for_indexing.rs:103:13
+  --> tests/ui/missing_asserts_for_indexing.rs:106:13
    |
 LL |     assert!(v1.len() >= 12);
    |     ----------------------- help: provide the highest index that is indexed with: `assert!(v1.len() > 12)`
@@ -238,19 +238,19 @@ LL |     let _ = v1[0] + v1[12];
    |             ^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:103:13
+  --> tests/ui/missing_asserts_for_indexing.rs:106:13
    |
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:103:21
+  --> tests/ui/missing_asserts_for_indexing.rs:106:21
    |
 LL |     let _ = v1[0] + v1[12];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> tests/ui/missing_asserts_for_indexing.rs:127:13
+  --> tests/ui/missing_asserts_for_indexing.rs:131:13
    |
 LL |     assert!(v1.len() == 2);
    |     ---------------------- help: provide the highest index that is indexed with: `assert!(v1.len() == 3)`
@@ -259,24 +259,24 @@ LL |     let _ = v1[0] + v1[1] + v1[2];
    |             ^^^^^^^^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:127:13
+  --> tests/ui/missing_asserts_for_indexing.rs:131:13
    |
 LL |     let _ = v1[0] + v1[1] + v1[2];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:127:21
+  --> tests/ui/missing_asserts_for_indexing.rs:131:21
    |
 LL |     let _ = v1[0] + v1[1] + v1[2];
    |                     ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:127:29
+  --> tests/ui/missing_asserts_for_indexing.rs:131:29
    |
 LL |     let _ = v1[0] + v1[1] + v1[2];
    |                             ^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times with an `assert` that does not cover the highest index
-  --> tests/ui/missing_asserts_for_indexing.rs:131:13
+  --> tests/ui/missing_asserts_for_indexing.rs:136:13
    |
 LL |     assert!(2 == v3.len());
    |     ---------------------- help: provide the highest index that is indexed with: `assert!(v3.len() == 3)`
@@ -285,17 +285,17 @@ LL |     let _ = v3[0] + v3[1] + v3[2];
    |             ^^^^^^^^^^^^^^^^^^^^^
    |
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:131:13
+  --> tests/ui/missing_asserts_for_indexing.rs:136:13
    |
 LL |     let _ = v3[0] + v3[1] + v3[2];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:131:21
+  --> tests/ui/missing_asserts_for_indexing.rs:136:21
    |
 LL |     let _ = v3[0] + v3[1] + v3[2];
    |                     ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing.rs:131:29
+  --> tests/ui/missing_asserts_for_indexing.rs:136:29
    |
 LL |     let _ = v3[0] + v3[1] + v3[2];
    |                             ^^^^^
diff --git a/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.rs b/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.rs
index de53079a4760..a520151a2dd9 100644
--- a/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.rs
+++ b/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.rs
@@ -3,18 +3,20 @@
 
 fn sum(v: &[u8]) -> u8 {
     v[0] + v[1] + v[2] + v[3] + v[4]
-    //~^ ERROR: indexing into a slice multiple times without an `assert`
+    //~^ missing_asserts_for_indexing
 }
 
 fn subslice(v: &[u8]) {
     let _ = v[0];
-    //~^ ERROR: indexing into a slice multiple times without an `assert`
+    //~^ missing_asserts_for_indexing
+
     let _ = v[1..4];
 }
 
 fn variables(v: &[u8]) -> u8 {
     let a = v[0];
-    //~^ ERROR: indexing into a slice multiple times without an `assert`
+    //~^ missing_asserts_for_indexing
+
     let b = v[1];
     let c = v[2];
     a + b + c
@@ -22,13 +24,16 @@ fn variables(v: &[u8]) -> u8 {
 
 fn index_different_slices(v1: &[u8], v2: &[u8]) {
     let _ = v1[0] + v1[12];
+    //~^ missing_asserts_for_indexing
     let _ = v2[5] + v2[15];
+    //~^ missing_asserts_for_indexing
 }
 
 fn index_different_slices2(v1: &[u8], v2: &[u8]) {
     assert!(v1.len() > 12);
     let _ = v1[0] + v1[12];
     let _ = v2[5] + v2[15];
+    //~^ missing_asserts_for_indexing
 }
 
 struct Foo<'a> {
@@ -38,7 +43,7 @@ struct Foo<'a> {
 
 fn index_struct_field(f: &Foo<'_>) {
     let _ = f.v[0] + f.v[1];
-    //~^ ERROR: indexing into a slice multiple times without an `assert`
+    //~^ missing_asserts_for_indexing
 }
 
 fn index_struct_different_fields(f: &Foo<'_>) {
@@ -52,7 +57,7 @@ fn shadowing() {
 
     let x: &[i32] = &[1];
     let _ = x[0] + x[1];
-    //~^ ERROR: indexing into a slice multiple times without an `assert`
+    //~^ missing_asserts_for_indexing
 }
 
 pub fn issue11856(values: &[i32]) -> usize {
diff --git a/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.stderr b/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.stderr
index b575e09966ce..24109b052a8a 100644
--- a/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/missing_asserts_for_indexing_unfixable.stderr
@@ -39,7 +39,7 @@ error: indexing into a slice multiple times without an `assert`
    |
 LL |       let _ = v[0];
    |  _____________^
-LL | |
+...  |
 LL | |     let _ = v[1..4];
    | |___________________^
    |
@@ -50,130 +50,131 @@ note: slice indexed here
 LL |     let _ = v[0];
    |             ^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:12:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:13:13
    |
 LL |     let _ = v[1..4];
    |             ^^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times without an `assert`
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:16:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:17:13
    |
 LL |       let a = v[0];
    |  _____________^
 LL | |
+LL | |
 LL | |     let b = v[1];
 LL | |     let c = v[2];
    | |________________^
    |
    = help: consider asserting the length before indexing: `assert!(v.len() > 2);`
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:16:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:17:13
    |
 LL |     let a = v[0];
    |             ^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:18:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:20:13
    |
 LL |     let b = v[1];
    |             ^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:19:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:21:13
    |
 LL |     let c = v[2];
    |             ^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times without an `assert`
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:24:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:26:13
    |
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^^^^^^^^^^
    |
    = help: consider asserting the length before indexing: `assert!(v1.len() > 12);`
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:24:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:26:13
    |
 LL |     let _ = v1[0] + v1[12];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:24:21
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:26:21
    |
 LL |     let _ = v1[0] + v1[12];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times without an `assert`
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:25:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:28:13
    |
 LL |     let _ = v2[5] + v2[15];
    |             ^^^^^^^^^^^^^^
    |
    = help: consider asserting the length before indexing: `assert!(v2.len() > 15);`
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:25:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:28:13
    |
 LL |     let _ = v2[5] + v2[15];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:25:21
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:28:21
    |
 LL |     let _ = v2[5] + v2[15];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times without an `assert`
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:31:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:35:13
    |
 LL |     let _ = v2[5] + v2[15];
    |             ^^^^^^^^^^^^^^
    |
    = help: consider asserting the length before indexing: `assert!(v2.len() > 15);`
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:31:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:35:13
    |
 LL |     let _ = v2[5] + v2[15];
    |             ^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:31:21
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:35:21
    |
 LL |     let _ = v2[5] + v2[15];
    |                     ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times without an `assert`
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:40:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:45:13
    |
 LL |     let _ = f.v[0] + f.v[1];
    |             ^^^^^^^^^^^^^^^
    |
    = help: consider asserting the length before indexing: `assert!(f.v.len() > 1);`
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:40:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:45:13
    |
 LL |     let _ = f.v[0] + f.v[1];
    |             ^^^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:40:22
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:45:22
    |
 LL |     let _ = f.v[0] + f.v[1];
    |                      ^^^^^^
    = note: asserting the length before indexing will elide bounds checks
 
 error: indexing into a slice multiple times without an `assert`
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:54:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:59:13
    |
 LL |     let _ = x[0] + x[1];
    |             ^^^^^^^^^^^
    |
    = help: consider asserting the length before indexing: `assert!(x.len() > 1);`
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:54:13
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:59:13
    |
 LL |     let _ = x[0] + x[1];
    |             ^^^^
 note: slice indexed here
-  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:54:20
+  --> tests/ui/missing_asserts_for_indexing_unfixable.rs:59:20
    |
 LL |     let _ = x[0] + x[1];
    |                    ^^^^
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs b/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs
index cdfdcd5007a8..aef5eb5b890a 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/cant_be_const.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //! False-positive tests to ensure we don't suggest `const` for things where it would cause a
 //! compilation error.
 //! The .stderr output of this test should be empty. Otherwise it's a bug somewhere.
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.fixed b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.fixed
index 689060468c57..10df44e73b85 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.fixed
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.fixed
@@ -11,45 +11,44 @@ struct Game {
 impl Game {
     // Could be const
     pub const fn new() -> Self {
-        //~^ ERROR: this could be a `const fn`
-        //~| NOTE: `-D clippy::missing-const-for-fn` implied by `-D warnings`
+        //~^ missing_const_for_fn
         Self { guess: 42 }
     }
 
     const fn const_generic_params<'a, T, const N: usize>(&self, b: &'a [T; N]) -> &'a [T; N] {
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
         b
     }
 }
 
 // Could be const
 const fn one() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     1
 }
 
 // Could also be const
 const fn two() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     let abc = 2;
     abc
 }
 
 // Could be const (since Rust 1.39)
 const fn string() -> String {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     String::new()
 }
 
 // Could be const
 const unsafe fn four() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     4
 }
 
 // Could also be const
 const fn generic<T>(t: T) -> T {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     t
 }
 
@@ -58,7 +57,7 @@ fn sub(x: u32) -> usize {
 }
 
 const fn generic_arr<T: Copy>(t: [T; 1]) -> T {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     t[0]
 }
 
@@ -72,7 +71,7 @@ mod with_drop {
     impl B {
         // This can be const, because `a` is passed by reference
         pub const fn b(self, a: &A) -> B {
-            //~^ ERROR: this could be a `const fn`
+            //~^ missing_const_for_fn
             B
         }
     }
@@ -82,7 +81,7 @@ mod with_drop {
 mod const_fn_stabilized_before_msrv {
     // This could be const because `u8::is_ascii_digit` is a stable const function in 1.47.
     const fn const_fn_stabilized_before_msrv(byte: u8) {
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
         byte.is_ascii_digit();
     }
 }
@@ -94,7 +93,7 @@ fn msrv_1_45() -> i32 {
 
 #[clippy::msrv = "1.46"]
 const fn msrv_1_46() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     46
 }
 
@@ -114,7 +113,7 @@ impl const Drop for D {
 // Lint this, since it can be dropped in const contexts
 // FIXME(const_trait_impl)
 const fn d(this: D) {}
-//~^ ERROR: this could be a `const fn`
+//~^ missing_const_for_fn
 
 mod msrv {
     struct Foo(*const u8, &'static u8);
@@ -122,12 +121,12 @@ mod msrv {
     impl Foo {
         #[clippy::msrv = "1.58"]
         const fn deref_ptr_can_be_const(self) -> usize {
-            //~^ ERROR: this could be a `const fn`
+            //~^ missing_const_for_fn
             unsafe { *self.0 as usize }
         }
 
         const fn deref_copied_val(self) -> usize {
-            //~^ ERROR: this could be a `const fn`
+            //~^ missing_const_for_fn
             *self.1 as usize
         }
     }
@@ -138,7 +137,7 @@ mod msrv {
 
     #[clippy::msrv = "1.56"]
     const fn union_access_can_be_const() {
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
         let bar = Bar { val: 1 };
         let _ = unsafe { bar.val };
     }
@@ -146,12 +145,12 @@ mod msrv {
     #[clippy::msrv = "1.62"]
     mod with_extern {
         const extern "C" fn c() {}
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
 
         #[rustfmt::skip]
         #[allow(missing_abi)]
         const extern fn implicit_c() {}
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
 
         // any item functions in extern block won't trigger this lint
         extern "C" {
@@ -168,11 +167,13 @@ mod issue12677 {
     impl Wrapper {
         #[must_use]
         pub const fn new(strings: Vec<String>) -> Self {
+            //~^ missing_const_for_fn
             Self { strings }
         }
 
         #[must_use]
         pub const fn empty() -> Self {
+            //~^ missing_const_for_fn
             Self { strings: Vec::new() }
         }
     }
@@ -184,6 +185,7 @@ mod issue12677 {
 
     impl Other {
         pub const fn new(text: String) -> Self {
+            //~^ missing_const_for_fn
             let vec = Vec::new();
             Self { text, vec }
         }
@@ -203,18 +205,19 @@ mod with_ty_alias {
     // is. Because the associate ty could have no default, therefore would cause ICE, as demonstrated
     // in this test.
     const fn alias_ty_is_projection(bar: <() as FooTrait>::Foo) {}
+    //~^ missing_const_for_fn
 }
 
 mod extern_fn {
     const extern "C-unwind" fn c_unwind() {}
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     const extern "system" fn system() {}
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     const extern "system-unwind" fn system_unwind() {}
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
 }
 
 const fn mut_add(x: &mut i32) {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     *x += 1;
 }
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs
index 492c47d7e49b..bc44b34daef7 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.rs
@@ -11,45 +11,44 @@ struct Game {
 impl Game {
     // Could be const
     pub fn new() -> Self {
-        //~^ ERROR: this could be a `const fn`
-        //~| NOTE: `-D clippy::missing-const-for-fn` implied by `-D warnings`
+        //~^ missing_const_for_fn
         Self { guess: 42 }
     }
 
     fn const_generic_params<'a, T, const N: usize>(&self, b: &'a [T; N]) -> &'a [T; N] {
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
         b
     }
 }
 
 // Could be const
 fn one() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     1
 }
 
 // Could also be const
 fn two() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     let abc = 2;
     abc
 }
 
 // Could be const (since Rust 1.39)
 fn string() -> String {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     String::new()
 }
 
 // Could be const
 unsafe fn four() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     4
 }
 
 // Could also be const
 fn generic<T>(t: T) -> T {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     t
 }
 
@@ -58,7 +57,7 @@ fn sub(x: u32) -> usize {
 }
 
 fn generic_arr<T: Copy>(t: [T; 1]) -> T {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     t[0]
 }
 
@@ -72,7 +71,7 @@ mod with_drop {
     impl B {
         // This can be const, because `a` is passed by reference
         pub fn b(self, a: &A) -> B {
-            //~^ ERROR: this could be a `const fn`
+            //~^ missing_const_for_fn
             B
         }
     }
@@ -82,7 +81,7 @@ mod with_drop {
 mod const_fn_stabilized_before_msrv {
     // This could be const because `u8::is_ascii_digit` is a stable const function in 1.47.
     fn const_fn_stabilized_before_msrv(byte: u8) {
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
         byte.is_ascii_digit();
     }
 }
@@ -94,7 +93,7 @@ fn msrv_1_45() -> i32 {
 
 #[clippy::msrv = "1.46"]
 fn msrv_1_46() -> i32 {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     46
 }
 
@@ -114,7 +113,7 @@ impl const Drop for D {
 // Lint this, since it can be dropped in const contexts
 // FIXME(const_trait_impl)
 fn d(this: D) {}
-//~^ ERROR: this could be a `const fn`
+//~^ missing_const_for_fn
 
 mod msrv {
     struct Foo(*const u8, &'static u8);
@@ -122,12 +121,12 @@ mod msrv {
     impl Foo {
         #[clippy::msrv = "1.58"]
         fn deref_ptr_can_be_const(self) -> usize {
-            //~^ ERROR: this could be a `const fn`
+            //~^ missing_const_for_fn
             unsafe { *self.0 as usize }
         }
 
         fn deref_copied_val(self) -> usize {
-            //~^ ERROR: this could be a `const fn`
+            //~^ missing_const_for_fn
             *self.1 as usize
         }
     }
@@ -138,7 +137,7 @@ mod msrv {
 
     #[clippy::msrv = "1.56"]
     fn union_access_can_be_const() {
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
         let bar = Bar { val: 1 };
         let _ = unsafe { bar.val };
     }
@@ -146,12 +145,12 @@ mod msrv {
     #[clippy::msrv = "1.62"]
     mod with_extern {
         extern "C" fn c() {}
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
 
         #[rustfmt::skip]
         #[allow(missing_abi)]
         extern fn implicit_c() {}
-        //~^ ERROR: this could be a `const fn`
+        //~^ missing_const_for_fn
 
         // any item functions in extern block won't trigger this lint
         extern "C" {
@@ -168,11 +167,13 @@ mod issue12677 {
     impl Wrapper {
         #[must_use]
         pub fn new(strings: Vec<String>) -> Self {
+            //~^ missing_const_for_fn
             Self { strings }
         }
 
         #[must_use]
         pub fn empty() -> Self {
+            //~^ missing_const_for_fn
             Self { strings: Vec::new() }
         }
     }
@@ -184,6 +185,7 @@ mod issue12677 {
 
     impl Other {
         pub fn new(text: String) -> Self {
+            //~^ missing_const_for_fn
             let vec = Vec::new();
             Self { text, vec }
         }
@@ -203,18 +205,19 @@ mod with_ty_alias {
     // is. Because the associate ty could have no default, therefore would cause ICE, as demonstrated
     // in this test.
     fn alias_ty_is_projection(bar: <() as FooTrait>::Foo) {}
+    //~^ missing_const_for_fn
 }
 
 mod extern_fn {
     extern "C-unwind" fn c_unwind() {}
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     extern "system" fn system() {}
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     extern "system-unwind" fn system_unwind() {}
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
 }
 
 fn mut_add(x: &mut i32) {
-    //~^ ERROR: this could be a `const fn`
+    //~^ missing_const_for_fn
     *x += 1;
 }
diff --git a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
index a06703e2ebf2..5df5a54ff521 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
+++ b/src/tools/clippy/tests/ui/missing_const_for_fn/could_be_const.stderr
@@ -3,7 +3,6 @@ error: this could be a `const fn`
    |
 LL | /     pub fn new() -> Self {
 LL | |
-LL | |
 LL | |         Self { guess: 42 }
 LL | |     }
    | |_____^
@@ -16,7 +15,7 @@ LL |     pub const fn new() -> Self {
    |         +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:19:5
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:18:5
    |
 LL | /     fn const_generic_params<'a, T, const N: usize>(&self, b: &'a [T; N]) -> &'a [T; N] {
 LL | |
@@ -30,7 +29,7 @@ LL |     const fn const_generic_params<'a, T, const N: usize>(&self, b: &'a [T;
    |     +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:26:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:25:1
    |
 LL | / fn one() -> i32 {
 LL | |
@@ -44,7 +43,7 @@ LL | const fn one() -> i32 {
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:32:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:31:1
    |
 LL | / fn two() -> i32 {
 LL | |
@@ -59,7 +58,7 @@ LL | const fn two() -> i32 {
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:39:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:38:1
    |
 LL | / fn string() -> String {
 LL | |
@@ -73,7 +72,7 @@ LL | const fn string() -> String {
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:45:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:44:1
    |
 LL | / unsafe fn four() -> i32 {
 LL | |
@@ -87,7 +86,7 @@ LL | const unsafe fn four() -> i32 {
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:51:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:50:1
    |
 LL | / fn generic<T>(t: T) -> T {
 LL | |
@@ -101,7 +100,7 @@ LL | const fn generic<T>(t: T) -> T {
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:60:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:59:1
    |
 LL | / fn generic_arr<T: Copy>(t: [T; 1]) -> T {
 LL | |
@@ -115,7 +114,7 @@ LL | const fn generic_arr<T: Copy>(t: [T; 1]) -> T {
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:74:9
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:73:9
    |
 LL | /         pub fn b(self, a: &A) -> B {
 LL | |
@@ -129,7 +128,7 @@ LL |         pub const fn b(self, a: &A) -> B {
    |             +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:84:5
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:83:5
    |
 LL | /     fn const_fn_stabilized_before_msrv(byte: u8) {
 LL | |
@@ -143,7 +142,7 @@ LL |     const fn const_fn_stabilized_before_msrv(byte: u8) {
    |     +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:96:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:95:1
    |
 LL | / fn msrv_1_46() -> i32 {
 LL | |
@@ -157,7 +156,7 @@ LL | const fn msrv_1_46() -> i32 {
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:116:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:115:1
    |
 LL | fn d(this: D) {}
    | ^^^^^^^^^^^^^^^^
@@ -168,7 +167,7 @@ LL | const fn d(this: D) {}
    | +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:124:9
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:123:9
    |
 LL | /         fn deref_ptr_can_be_const(self) -> usize {
 LL | |
@@ -182,7 +181,7 @@ LL |         const fn deref_ptr_can_be_const(self) -> usize {
    |         +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:129:9
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:128:9
    |
 LL | /         fn deref_copied_val(self) -> usize {
 LL | |
@@ -196,7 +195,7 @@ LL |         const fn deref_copied_val(self) -> usize {
    |         +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:140:5
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:139:5
    |
 LL | /     fn union_access_can_be_const() {
 LL | |
@@ -211,7 +210,7 @@ LL |     const fn union_access_can_be_const() {
    |     +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:148:9
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:147:9
    |
 LL |         extern "C" fn c() {}
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -222,7 +221,7 @@ LL |         const extern "C" fn c() {}
    |         +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:153:9
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:152:9
    |
 LL |         extern fn implicit_c() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -233,9 +232,10 @@ LL |         const extern fn implicit_c() {}
    |         +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:170:9
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:169:9
    |
 LL | /         pub fn new(strings: Vec<String>) -> Self {
+LL | |
 LL | |             Self { strings }
 LL | |         }
    | |_________^
@@ -249,6 +249,7 @@ error: this could be a `const fn`
   --> tests/ui/missing_const_for_fn/could_be_const.rs:175:9
    |
 LL | /         pub fn empty() -> Self {
+LL | |
 LL | |             Self { strings: Vec::new() }
 LL | |         }
    | |_________^
@@ -259,9 +260,10 @@ LL |         pub const fn empty() -> Self {
    |             +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:186:9
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:187:9
    |
 LL | /         pub fn new(text: String) -> Self {
+LL | |
 LL | |             let vec = Vec::new();
 LL | |             Self { text, vec }
 LL | |         }
@@ -273,7 +275,7 @@ LL |         pub const fn new(text: String) -> Self {
    |             +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:205:5
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:207:5
    |
 LL |     fn alias_ty_is_projection(bar: <() as FooTrait>::Foo) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -284,7 +286,7 @@ LL |     const fn alias_ty_is_projection(bar: <() as FooTrait>::Foo) {}
    |     +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:209:5
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:212:5
    |
 LL |     extern "C-unwind" fn c_unwind() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -295,7 +297,7 @@ LL |     const extern "C-unwind" fn c_unwind() {}
    |     +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:211:5
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:214:5
    |
 LL |     extern "system" fn system() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -306,7 +308,7 @@ LL |     const extern "system" fn system() {}
    |     +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:213:5
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:216:5
    |
 LL |     extern "system-unwind" fn system_unwind() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -317,7 +319,7 @@ LL |     const extern "system-unwind" fn system_unwind() {}
    |     +++++
 
 error: this could be a `const fn`
-  --> tests/ui/missing_const_for_fn/could_be_const.rs:217:1
+  --> tests/ui/missing_const_for_fn/could_be_const.rs:220:1
    |
 LL | / fn mut_add(x: &mut i32) {
 LL | |
diff --git a/src/tools/clippy/tests/ui/missing_const_for_thread_local.fixed b/src/tools/clippy/tests/ui/missing_const_for_thread_local.fixed
index 90b31b9b5d21..2efe10c153da 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_thread_local.fixed
+++ b/src/tools/clippy/tests/ui/missing_const_for_thread_local.fixed
@@ -6,8 +6,8 @@ fn main() {
     // lint and suggest const
     thread_local! {
         static BUF_1: RefCell<String> = const { RefCell::new(String::new()) };
+        //~^ missing_const_for_thread_local
     }
-    //~^^ ERROR: initializer for `thread_local` value can be made `const`
 
     // don't lint
     thread_local! {
@@ -16,23 +16,25 @@ fn main() {
 
     thread_local! {
         static SIMPLE:i32 = const { 1 };
+        //~^ missing_const_for_thread_local
     }
-    //~^^ ERROR: initializer for `thread_local` value can be made `const`
 
     // lint and suggest const for all non const items
     thread_local! {
         static BUF_3_CAN_BE_MADE_CONST: RefCell<String> = const { RefCell::new(String::new()) };
+        //~^ missing_const_for_thread_local
         static CONST_MIXED_WITH:i32 = const { 1 };
         static BUF_4_CAN_BE_MADE_CONST: RefCell<String> = const { RefCell::new(String::new()) };
+        //~^ missing_const_for_thread_local
     }
-    //~^^^^ ERROR: initializer for `thread_local` value can be made `const`
-    //~^^^ ERROR: initializer for `thread_local` value can be made `const`
 
     thread_local! {
         static PEEL_ME: i32 = const { 1 };
-        //~^ ERROR: initializer for `thread_local` value can be made `const`
+        //~^ missing_const_for_thread_local
+
         static PEEL_ME_MANY: i32 = const { { let x = 1; x * x } };
-        //~^ ERROR: initializer for `thread_local` value can be made `const`
+        //~^ missing_const_for_thread_local
+
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/missing_const_for_thread_local.rs b/src/tools/clippy/tests/ui/missing_const_for_thread_local.rs
index f97e4848fd7a..119cc5a99fa0 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_thread_local.rs
+++ b/src/tools/clippy/tests/ui/missing_const_for_thread_local.rs
@@ -6,8 +6,8 @@ fn main() {
     // lint and suggest const
     thread_local! {
         static BUF_1: RefCell<String> = RefCell::new(String::new());
+        //~^ missing_const_for_thread_local
     }
-    //~^^ ERROR: initializer for `thread_local` value can be made `const`
 
     // don't lint
     thread_local! {
@@ -16,23 +16,25 @@ fn main() {
 
     thread_local! {
         static SIMPLE:i32 = 1;
+        //~^ missing_const_for_thread_local
     }
-    //~^^ ERROR: initializer for `thread_local` value can be made `const`
 
     // lint and suggest const for all non const items
     thread_local! {
         static BUF_3_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(String::new());
+        //~^ missing_const_for_thread_local
         static CONST_MIXED_WITH:i32 = const { 1 };
         static BUF_4_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(String::new());
+        //~^ missing_const_for_thread_local
     }
-    //~^^^^ ERROR: initializer for `thread_local` value can be made `const`
-    //~^^^ ERROR: initializer for `thread_local` value can be made `const`
 
     thread_local! {
         static PEEL_ME: i32 = { 1 };
-        //~^ ERROR: initializer for `thread_local` value can be made `const`
+        //~^ missing_const_for_thread_local
+
         static PEEL_ME_MANY: i32 = { let x = 1; x * x };
-        //~^ ERROR: initializer for `thread_local` value can be made `const`
+        //~^ missing_const_for_thread_local
+
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/missing_const_for_thread_local.stderr b/src/tools/clippy/tests/ui/missing_const_for_thread_local.stderr
index c143a37454f5..4e90c10c92f8 100644
--- a/src/tools/clippy/tests/ui/missing_const_for_thread_local.stderr
+++ b/src/tools/clippy/tests/ui/missing_const_for_thread_local.stderr
@@ -20,7 +20,7 @@ LL |         static BUF_3_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(Stri
    |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `const { RefCell::new(String::new()) }`
 
 error: initializer for `thread_local` value can be made `const`
-  --> tests/ui/missing_const_for_thread_local.rs:26:59
+  --> tests/ui/missing_const_for_thread_local.rs:27:59
    |
 LL |         static BUF_4_CAN_BE_MADE_CONST: RefCell<String> = RefCell::new(String::new());
    |                                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `const { RefCell::new(String::new()) }`
@@ -32,7 +32,7 @@ LL |         static PEEL_ME: i32 = { 1 };
    |                               ^^^^^ help: replace with: `const { 1 }`
 
 error: initializer for `thread_local` value can be made `const`
-  --> tests/ui/missing_const_for_thread_local.rs:34:36
+  --> tests/ui/missing_const_for_thread_local.rs:35:36
    |
 LL |         static PEEL_ME_MANY: i32 = { let x = 1; x * x };
    |                                    ^^^^^^^^^^^^^^^^^^^^ help: replace with: `const { { let x = 1; x * x } }`
diff --git a/src/tools/clippy/tests/ui/missing_doc.rs b/src/tools/clippy/tests/ui/missing_doc.rs
index 31bc4309582e..705de959cb7d 100644
--- a/src/tools/clippy/tests/ui/missing_doc.rs
+++ b/src/tools/clippy/tests/ui/missing_doc.rs
@@ -17,15 +17,18 @@ use proc_macros::with_span;
 use std::arch::global_asm;
 
 type Typedef = String;
+//~^ missing_docs_in_private_items
 pub type PubTypedef = String;
 
 mod module_no_dox {}
+//~^ missing_docs_in_private_items
 pub mod pub_module_no_dox {}
 
 /// dox
 pub fn foo() {}
 pub fn foo2() {}
 fn foo3() {}
+//~^ missing_docs_in_private_items
 #[allow(clippy::missing_docs_in_private_items)]
 pub fn foo4() {}
 
@@ -40,8 +43,13 @@ mod a {
 }
 
 enum Baz {
+    //~^ missing_docs_in_private_items
     BazA { a: isize, b: isize },
+    //~^ missing_docs_in_private_items
+    //~| missing_docs_in_private_items
+    //~| missing_docs_in_private_items
     BarB,
+    //~^ missing_docs_in_private_items
 }
 
 pub enum PubBaz {
@@ -66,6 +74,7 @@ pub enum PubBaz3 {
 pub fn baz() {}
 
 const FOO: u32 = 0;
+//~^ missing_docs_in_private_items
 /// dox
 pub const FOO1: u32 = 0;
 #[allow(clippy::missing_docs_in_private_items)]
@@ -75,6 +84,7 @@ pub const FOO3: u32 = 0;
 pub const FOO4: u32 = 0;
 
 static BAR: u32 = 0;
+//~^ missing_docs_in_private_items
 /// dox
 pub static BAR1: u32 = 0;
 #[allow(clippy::missing_docs_in_private_items)]
@@ -84,17 +94,20 @@ pub static BAR3: u32 = 0;
 pub static BAR4: u32 = 0;
 
 mod internal_impl {
+    //~^ missing_docs_in_private_items
     /// dox
     pub fn documented() {}
     pub fn undocumented1() {}
     pub fn undocumented2() {}
     fn undocumented3() {}
+    //~^ missing_docs_in_private_items
     /// dox
     pub mod globbed {
         /// dox
         pub fn also_documented() {}
         pub fn also_undocumented1() {}
         fn also_undocumented2() {}
+        //~^ missing_docs_in_private_items
     }
 }
 /// dox
@@ -120,6 +133,7 @@ with_span!(span pub const FOO2_PM: u32 = 0;);
 const _: () = ();
 
 fn issue13298() {
+    //~^ missing_docs_in_private_items
     // Rustdoc doesn't generate documentation for items within other items like fns or consts
     const MSG: &str = "Hello, world!";
 }
diff --git a/src/tools/clippy/tests/ui/missing_doc.stderr b/src/tools/clippy/tests/ui/missing_doc.stderr
index 6554eed16106..63e440b82d14 100644
--- a/src/tools/clippy/tests/ui/missing_doc.stderr
+++ b/src/tools/clippy/tests/ui/missing_doc.stderr
@@ -8,89 +8,91 @@ LL | type Typedef = String;
    = help: to override `-D warnings` add `#[allow(clippy::missing_docs_in_private_items)]`
 
 error: missing documentation for a module
-  --> tests/ui/missing_doc.rs:22:1
+  --> tests/ui/missing_doc.rs:23:1
    |
 LL | mod module_no_dox {}
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a function
-  --> tests/ui/missing_doc.rs:28:1
+  --> tests/ui/missing_doc.rs:30:1
    |
 LL | fn foo3() {}
    | ^^^^^^^^^^^^
 
 error: missing documentation for an enum
-  --> tests/ui/missing_doc.rs:42:1
+  --> tests/ui/missing_doc.rs:45:1
    |
 LL | / enum Baz {
+LL | |
 LL | |     BazA { a: isize, b: isize },
-LL | |     BarB,
+...  |
 LL | | }
    | |_^
 
 error: missing documentation for a variant
-  --> tests/ui/missing_doc.rs:43:5
+  --> tests/ui/missing_doc.rs:47:5
    |
 LL |     BazA { a: isize, b: isize },
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a struct field
-  --> tests/ui/missing_doc.rs:43:12
+  --> tests/ui/missing_doc.rs:47:12
    |
 LL |     BazA { a: isize, b: isize },
    |            ^^^^^^^^
 
 error: missing documentation for a struct field
-  --> tests/ui/missing_doc.rs:43:22
+  --> tests/ui/missing_doc.rs:47:22
    |
 LL |     BazA { a: isize, b: isize },
    |                      ^^^^^^^^
 
 error: missing documentation for a variant
-  --> tests/ui/missing_doc.rs:44:5
+  --> tests/ui/missing_doc.rs:51:5
    |
 LL |     BarB,
    |     ^^^^
 
 error: missing documentation for a constant
-  --> tests/ui/missing_doc.rs:68:1
+  --> tests/ui/missing_doc.rs:76:1
    |
 LL | const FOO: u32 = 0;
    | ^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a static
-  --> tests/ui/missing_doc.rs:77:1
+  --> tests/ui/missing_doc.rs:86:1
    |
 LL | static BAR: u32 = 0;
    | ^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a module
-  --> tests/ui/missing_doc.rs:86:1
+  --> tests/ui/missing_doc.rs:96:1
    |
 LL | / mod internal_impl {
+LL | |
 LL | |     /// dox
 LL | |     pub fn documented() {}
-LL | |     pub fn undocumented1() {}
 ...  |
 LL | | }
    | |_^
 
 error: missing documentation for a function
-  --> tests/ui/missing_doc.rs:91:5
+  --> tests/ui/missing_doc.rs:102:5
    |
 LL |     fn undocumented3() {}
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a function
-  --> tests/ui/missing_doc.rs:97:9
+  --> tests/ui/missing_doc.rs:109:9
    |
 LL |         fn also_undocumented2() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing documentation for a function
-  --> tests/ui/missing_doc.rs:122:1
+  --> tests/ui/missing_doc.rs:135:1
    |
 LL | / fn issue13298() {
+LL | |
 LL | |     // Rustdoc doesn't generate documentation for items within other items like fns or consts
 LL | |     const MSG: &str = "Hello, world!";
 LL | | }
diff --git a/src/tools/clippy/tests/ui/missing_doc_crate.rs b/src/tools/clippy/tests/ui/missing_doc_crate.rs
index fdb23af279df..e6e783a2bb40 100644
--- a/src/tools/clippy/tests/ui/missing_doc_crate.rs
+++ b/src/tools/clippy/tests/ui/missing_doc_crate.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::missing_docs_in_private_items)]
 #![allow(clippy::doc_include_without_cfg)]
 #![doc = include_str!("../../README.md")]
diff --git a/src/tools/clippy/tests/ui/missing_doc_crate_missing.rs b/src/tools/clippy/tests/ui/missing_doc_crate_missing.rs
index 73584ac8c67d..f55d8b67cb84 100644
--- a/src/tools/clippy/tests/ui/missing_doc_crate_missing.rs
+++ b/src/tools/clippy/tests/ui/missing_doc_crate_missing.rs
@@ -1,5 +1,4 @@
 #![warn(clippy::missing_docs_in_private_items)]
-//~^ ERROR: missing documentation for the crate
-//~| NOTE: `-D clippy::missing-docs-in-private-items` implied by `-D warnings`
+//~^ missing_docs_in_private_items
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/missing_doc_impl.rs b/src/tools/clippy/tests/ui/missing_doc_impl.rs
index 520ddbe16b82..034ce31dfe76 100644
--- a/src/tools/clippy/tests/ui/missing_doc_impl.rs
+++ b/src/tools/clippy/tests/ui/missing_doc_impl.rs
@@ -11,13 +11,17 @@ extern crate proc_macros;
 use proc_macros::with_span;
 
 struct Foo {
+    //~^ missing_docs_in_private_items
     a: isize,
+    //~^ missing_docs_in_private_items
     b: isize,
+    //~^ missing_docs_in_private_items
 }
 
 pub struct PubFoo {
     pub a: isize,
     b: isize,
+    //~^ missing_docs_in_private_items
 }
 
 #[allow(clippy::missing_docs_in_private_items)]
@@ -65,9 +69,11 @@ pub trait E: Sized {
 
 impl Foo {
     pub fn new() -> Self {
+        //~^ missing_docs_in_private_items
         Foo { a: 0, b: 0 }
     }
     fn bar() {}
+    //~^ missing_docs_in_private_items
 }
 
 impl PubFoo {
@@ -76,6 +82,7 @@ impl PubFoo {
     pub fn foo1() {}
     #[must_use = "yep"]
     fn foo2() -> u32 {
+        //~^ missing_docs_in_private_items
         1
     }
     #[allow(clippy::missing_docs_in_private_items)]
diff --git a/src/tools/clippy/tests/ui/missing_doc_impl.stderr b/src/tools/clippy/tests/ui/missing_doc_impl.stderr
index e2052c346df8..999ff06f593e 100644
--- a/src/tools/clippy/tests/ui/missing_doc_impl.stderr
+++ b/src/tools/clippy/tests/ui/missing_doc_impl.stderr
@@ -2,8 +2,9 @@ error: missing documentation for a struct
   --> tests/ui/missing_doc_impl.rs:13:1
    |
 LL | / struct Foo {
+LL | |
 LL | |     a: isize,
-LL | |     b: isize,
+...  |
 LL | | }
    | |_^
    |
@@ -11,41 +12,43 @@ LL | | }
    = help: to override `-D warnings` add `#[allow(clippy::missing_docs_in_private_items)]`
 
 error: missing documentation for a struct field
-  --> tests/ui/missing_doc_impl.rs:14:5
+  --> tests/ui/missing_doc_impl.rs:15:5
    |
 LL |     a: isize,
    |     ^^^^^^^^
 
 error: missing documentation for a struct field
-  --> tests/ui/missing_doc_impl.rs:15:5
+  --> tests/ui/missing_doc_impl.rs:17:5
    |
 LL |     b: isize,
    |     ^^^^^^^^
 
 error: missing documentation for a struct field
-  --> tests/ui/missing_doc_impl.rs:20:5
+  --> tests/ui/missing_doc_impl.rs:23:5
    |
 LL |     b: isize,
    |     ^^^^^^^^
 
 error: missing documentation for an associated function
-  --> tests/ui/missing_doc_impl.rs:67:5
+  --> tests/ui/missing_doc_impl.rs:71:5
    |
 LL | /     pub fn new() -> Self {
+LL | |
 LL | |         Foo { a: 0, b: 0 }
 LL | |     }
    | |_____^
 
 error: missing documentation for an associated function
-  --> tests/ui/missing_doc_impl.rs:70:5
+  --> tests/ui/missing_doc_impl.rs:75:5
    |
 LL |     fn bar() {}
    |     ^^^^^^^^^^^
 
 error: missing documentation for an associated function
-  --> tests/ui/missing_doc_impl.rs:78:5
+  --> tests/ui/missing_doc_impl.rs:84:5
    |
 LL | /     fn foo2() -> u32 {
+LL | |
 LL | |         1
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/missing_fields_in_debug.rs b/src/tools/clippy/tests/ui/missing_fields_in_debug.rs
index 68867ec819d1..14803b5485a1 100644
--- a/src/tools/clippy/tests/ui/missing_fields_in_debug.rs
+++ b/src/tools/clippy/tests/ui/missing_fields_in_debug.rs
@@ -12,7 +12,8 @@ struct NamedStruct1Ignored {
 }
 
 impl fmt::Debug for NamedStruct1Ignored {
-    //~^ ERROR: manual `Debug` impl does not include all fields
+    //~^ missing_fields_in_debug
+
     // unused field: hidden
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         formatter
@@ -31,7 +32,8 @@ struct NamedStructMultipleIgnored {
 }
 
 impl fmt::Debug for NamedStructMultipleIgnored {
-    //~^ ERROR: manual `Debug` impl does not include all fields
+    //~^ missing_fields_in_debug
+
     // unused fields: hidden, hidden2, hidden4
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         formatter
@@ -93,7 +95,8 @@ struct MultiExprDebugImpl {
 
 // ok
 impl fmt::Debug for MultiExprDebugImpl {
-    //~^ ERROR: manual `Debug` impl does not include all fields
+    //~^ missing_fields_in_debug
+
     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
         let mut f = formatter.debug_struct("MultiExprDebugImpl");
         f.field("a", &self.a);
diff --git a/src/tools/clippy/tests/ui/missing_fields_in_debug.stderr b/src/tools/clippy/tests/ui/missing_fields_in_debug.stderr
index 5e51194c4b37..75b551e1f5c7 100644
--- a/src/tools/clippy/tests/ui/missing_fields_in_debug.stderr
+++ b/src/tools/clippy/tests/ui/missing_fields_in_debug.stderr
@@ -2,9 +2,6 @@ error: manual `Debug` impl does not include all fields
   --> tests/ui/missing_fields_in_debug.rs:14:1
    |
 LL | / impl fmt::Debug for NamedStruct1Ignored {
-LL | |
-LL | |     // unused field: hidden
-LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 ...  |
 LL | | }
    | |_^
@@ -20,28 +17,25 @@ LL |     hidden: u32,
    = help: to override `-D warnings` add `#[allow(clippy::missing_fields_in_debug)]`
 
 error: manual `Debug` impl does not include all fields
-  --> tests/ui/missing_fields_in_debug.rs:33:1
+  --> tests/ui/missing_fields_in_debug.rs:34:1
    |
 LL | / impl fmt::Debug for NamedStructMultipleIgnored {
-LL | |
-LL | |     // unused fields: hidden, hidden2, hidden4
-LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
 ...  |
 LL | | }
    | |_^
    |
 note: this field is unused
-  --> tests/ui/missing_fields_in_debug.rs:27:5
+  --> tests/ui/missing_fields_in_debug.rs:28:5
    |
 LL |     hidden: u32,
    |     ^^^^^^^^^^^
 note: this field is unused
-  --> tests/ui/missing_fields_in_debug.rs:28:5
+  --> tests/ui/missing_fields_in_debug.rs:29:5
    |
 LL |     hidden2: String,
    |     ^^^^^^^^^^^^^^^
 note: this field is unused
-  --> tests/ui/missing_fields_in_debug.rs:30:5
+  --> tests/ui/missing_fields_in_debug.rs:31:5
    |
 LL |     hidden4: ((((u8), u16), u32), u64),
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,18 +43,18 @@ LL |     hidden4: ((((u8), u16), u32), u64),
    = help: consider calling `.finish_non_exhaustive()` if you intend to ignore fields
 
 error: manual `Debug` impl does not include all fields
-  --> tests/ui/missing_fields_in_debug.rs:95:1
+  --> tests/ui/missing_fields_in_debug.rs:97:1
    |
 LL | / impl fmt::Debug for MultiExprDebugImpl {
 LL | |
+LL | |
 LL | |     fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-LL | |         let mut f = formatter.debug_struct("MultiExprDebugImpl");
 ...  |
 LL | | }
    | |_^
    |
 note: this field is unused
-  --> tests/ui/missing_fields_in_debug.rs:91:5
+  --> tests/ui/missing_fields_in_debug.rs:93:5
    |
 LL |     b: String,
    |     ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/missing_inline.rs b/src/tools/clippy/tests/ui/missing_inline.rs
index dca85b94d5ee..c1801005b777 100644
--- a/src/tools/clippy/tests/ui/missing_inline.rs
+++ b/src/tools/clippy/tests/ui/missing_inline.rs
@@ -18,8 +18,8 @@ pub mod pub_module {} // ok
 fn foo() {}
 // missing #[inline]
 pub fn pub_foo() {}
-//~^ ERROR: missing `#[inline]` for a function
-//~| NOTE: `-D clippy::missing-inline-in-public-items` implied by `-D warnings`
+//~^ missing_inline_in_public_items
+
 #[inline]
 pub fn pub_foo_inline() {} // ok
 #[inline(always)]
@@ -37,7 +37,8 @@ pub trait PubBar {
     fn PubBar_a(); // ok
     // missing #[inline]
     fn PubBar_b() {}
-    //~^ ERROR: missing `#[inline]` for a default trait method
+    //~^ missing_inline_in_public_items
+
     #[inline]
     fn PubBar_c() {} // ok
 }
@@ -53,13 +54,15 @@ impl PubBar for Foo {
 impl PubBar for PubFoo {
     // missing #[inline]
     fn PubBar_a() {}
-    //~^ ERROR: missing `#[inline]` for a method
+    //~^ missing_inline_in_public_items
+
     // missing #[inline]
     fn PubBar_b() {}
-    //~^ ERROR: missing `#[inline]` for a method
+    //~^ missing_inline_in_public_items
+
     // missing #[inline]
     fn PubBar_c() {}
-    //~^ ERROR: missing `#[inline]` for a method
+    //~^ missing_inline_in_public_items
 }
 
 // do not need inline because Foo is not exported
@@ -71,7 +74,7 @@ impl Foo {
 impl PubFoo {
     // missing #[inline]
     pub fn PubFooImpl() {}
-    //~^ ERROR: missing `#[inline]` for a method
+    //~^ missing_inline_in_public_items
 }
 
 // do not lint this since users cannot control the external code
diff --git a/src/tools/clippy/tests/ui/missing_inline.stderr b/src/tools/clippy/tests/ui/missing_inline.stderr
index c2bb37141a02..99ee828e805c 100644
--- a/src/tools/clippy/tests/ui/missing_inline.stderr
+++ b/src/tools/clippy/tests/ui/missing_inline.stderr
@@ -14,25 +14,25 @@ LL |     fn PubBar_b() {}
    |     ^^^^^^^^^^^^^^^^
 
 error: missing `#[inline]` for a method
-  --> tests/ui/missing_inline.rs:55:5
+  --> tests/ui/missing_inline.rs:56:5
    |
 LL |     fn PubBar_a() {}
    |     ^^^^^^^^^^^^^^^^
 
 error: missing `#[inline]` for a method
-  --> tests/ui/missing_inline.rs:58:5
+  --> tests/ui/missing_inline.rs:60:5
    |
 LL |     fn PubBar_b() {}
    |     ^^^^^^^^^^^^^^^^
 
 error: missing `#[inline]` for a method
-  --> tests/ui/missing_inline.rs:61:5
+  --> tests/ui/missing_inline.rs:64:5
    |
 LL |     fn PubBar_c() {}
    |     ^^^^^^^^^^^^^^^^
 
 error: missing `#[inline]` for a method
-  --> tests/ui/missing_inline.rs:73:5
+  --> tests/ui/missing_inline.rs:76:5
    |
 LL |     pub fn PubFooImpl() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/missing_inline_executable.rs b/src/tools/clippy/tests/ui/missing_inline_executable.rs
index 6e0400ac935b..444a7f1c964f 100644
--- a/src/tools/clippy/tests/ui/missing_inline_executable.rs
+++ b/src/tools/clippy/tests/ui/missing_inline_executable.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::missing_inline_in_public_items)]
 
 pub fn foo() {}
diff --git a/src/tools/clippy/tests/ui/missing_inline_proc_macro.rs b/src/tools/clippy/tests/ui/missing_inline_proc_macro.rs
index e47a198c6aea..ce368304f725 100644
--- a/src/tools/clippy/tests/ui/missing_inline_proc_macro.rs
+++ b/src/tools/clippy/tests/ui/missing_inline_proc_macro.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::missing_inline_in_public_items)]
 
 extern crate proc_macro;
diff --git a/src/tools/clippy/tests/ui/missing_panics_doc.rs b/src/tools/clippy/tests/ui/missing_panics_doc.rs
index b0fa8e988598..95e361c5d555 100644
--- a/src/tools/clippy/tests/ui/missing_panics_doc.rs
+++ b/src/tools/clippy/tests/ui/missing_panics_doc.rs
@@ -11,17 +11,20 @@ fn main() {}
 
 /// This needs to be documented
 pub fn unwrap() {
+    //~^ missing_panics_doc
     let result = Err("Hi");
     result.unwrap()
 }
 
 /// This needs to be documented
 pub fn panic() {
+    //~^ missing_panics_doc
     panic!("This function panics")
 }
 
 /// This needs to be documented
 pub fn inner_body(opt: Option<u32>) {
+    //~^ missing_panics_doc
     opt.map(|x| {
         if x == 10 {
             panic!()
@@ -31,17 +34,20 @@ pub fn inner_body(opt: Option<u32>) {
 
 /// This needs to be documented
 pub fn unreachable_and_panic() {
+    //~^ missing_panics_doc
     if true { unreachable!() } else { panic!() }
 }
 
 /// This needs to be documented
 pub fn assert_eq() {
+    //~^ missing_panics_doc
     let x = 0;
     assert_eq!(x, 0);
 }
 
 /// This needs to be documented
 pub fn assert_ne() {
+    //~^ missing_panics_doc
     let x = 0;
     assert_ne!(x, 0);
 }
@@ -149,30 +155,36 @@ pub fn debug_assertions() {
 // `pub` is required, because the lint does not consider unreachable items
 pub mod issue10240 {
     pub fn option_unwrap<T>(v: &[T]) -> &T {
+        //~^ missing_panics_doc
         let o: Option<&T> = v.last();
         o.unwrap()
     }
 
     pub fn option_expect<T>(v: &[T]) -> &T {
+        //~^ missing_panics_doc
         let o: Option<&T> = v.last();
         o.expect("passed an empty thing")
     }
 
     pub fn result_unwrap<T>(v: &[T]) -> &T {
+        //~^ missing_panics_doc
         let res: Result<&T, &str> = v.last().ok_or("oh noes");
         res.unwrap()
     }
 
     pub fn result_expect<T>(v: &[T]) -> &T {
+        //~^ missing_panics_doc
         let res: Result<&T, &str> = v.last().ok_or("oh noes");
         res.expect("passed an empty thing")
     }
 
     pub fn last_unwrap(v: &[u32]) -> u32 {
+        //~^ missing_panics_doc
         *v.last().unwrap()
     }
 
     pub fn last_expect(v: &[u32]) -> u32 {
+        //~^ missing_panics_doc
         *v.last().expect("passed an empty thing")
     }
 }
diff --git a/src/tools/clippy/tests/ui/missing_panics_doc.stderr b/src/tools/clippy/tests/ui/missing_panics_doc.stderr
index c6a939d86f7c..a83e2fa367dd 100644
--- a/src/tools/clippy/tests/ui/missing_panics_doc.stderr
+++ b/src/tools/clippy/tests/ui/missing_panics_doc.stderr
@@ -5,7 +5,7 @@ LL | pub fn unwrap() {
    | ^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:15:5
+  --> tests/ui/missing_panics_doc.rs:16:5
    |
 LL |     result.unwrap()
    |     ^^^^^^^^^^^^^^^
@@ -13,133 +13,133 @@ LL |     result.unwrap()
    = help: to override `-D warnings` add `#[allow(clippy::missing_panics_doc)]`
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:19:1
+  --> tests/ui/missing_panics_doc.rs:20:1
    |
 LL | pub fn panic() {
    | ^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:20:5
+  --> tests/ui/missing_panics_doc.rs:22:5
    |
 LL |     panic!("This function panics")
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:24:1
+  --> tests/ui/missing_panics_doc.rs:26:1
    |
 LL | pub fn inner_body(opt: Option<u32>) {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:27:13
+  --> tests/ui/missing_panics_doc.rs:30:13
    |
 LL |             panic!()
    |             ^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:33:1
+  --> tests/ui/missing_panics_doc.rs:36:1
    |
 LL | pub fn unreachable_and_panic() {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:34:39
+  --> tests/ui/missing_panics_doc.rs:38:39
    |
 LL |     if true { unreachable!() } else { panic!() }
    |                                       ^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:38:1
+  --> tests/ui/missing_panics_doc.rs:42:1
    |
 LL | pub fn assert_eq() {
    | ^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:40:5
+  --> tests/ui/missing_panics_doc.rs:45:5
    |
 LL |     assert_eq!(x, 0);
    |     ^^^^^^^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:44:1
+  --> tests/ui/missing_panics_doc.rs:49:1
    |
 LL | pub fn assert_ne() {
    | ^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:46:5
+  --> tests/ui/missing_panics_doc.rs:52:5
    |
 LL |     assert_ne!(x, 0);
    |     ^^^^^^^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:151:5
+  --> tests/ui/missing_panics_doc.rs:157:5
    |
 LL |     pub fn option_unwrap<T>(v: &[T]) -> &T {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:153:9
+  --> tests/ui/missing_panics_doc.rs:160:9
    |
 LL |         o.unwrap()
    |         ^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:156:5
+  --> tests/ui/missing_panics_doc.rs:163:5
    |
 LL |     pub fn option_expect<T>(v: &[T]) -> &T {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:158:9
+  --> tests/ui/missing_panics_doc.rs:166:9
    |
 LL |         o.expect("passed an empty thing")
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:161:5
+  --> tests/ui/missing_panics_doc.rs:169:5
    |
 LL |     pub fn result_unwrap<T>(v: &[T]) -> &T {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:163:9
+  --> tests/ui/missing_panics_doc.rs:172:9
    |
 LL |         res.unwrap()
    |         ^^^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:166:5
+  --> tests/ui/missing_panics_doc.rs:175:5
    |
 LL |     pub fn result_expect<T>(v: &[T]) -> &T {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:168:9
+  --> tests/ui/missing_panics_doc.rs:178:9
    |
 LL |         res.expect("passed an empty thing")
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:171:5
+  --> tests/ui/missing_panics_doc.rs:181:5
    |
 LL |     pub fn last_unwrap(v: &[u32]) -> u32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:172:10
+  --> tests/ui/missing_panics_doc.rs:183:10
    |
 LL |         *v.last().unwrap()
    |          ^^^^^^^^^^^^^^^^^
 
 error: docs for function which may panic missing `# Panics` section
-  --> tests/ui/missing_panics_doc.rs:175:5
+  --> tests/ui/missing_panics_doc.rs:186:5
    |
 LL |     pub fn last_expect(v: &[u32]) -> u32 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: first possible panic found here
-  --> tests/ui/missing_panics_doc.rs:176:10
+  --> tests/ui/missing_panics_doc.rs:188:10
    |
 LL |         *v.last().expect("passed an empty thing")
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/missing_spin_loop.fixed b/src/tools/clippy/tests/ui/missing_spin_loop.fixed
index b6520d478be8..03fbf8ccc8a3 100644
--- a/src/tools/clippy/tests/ui/missing_spin_loop.fixed
+++ b/src/tools/clippy/tests/ui/missing_spin_loop.fixed
@@ -8,16 +8,22 @@ fn main() {
     let b = AtomicBool::new(true);
     // Those should lint
     while b.load(Ordering::Acquire) { std::hint::spin_loop() }
+    //~^ missing_spin_loop
 
     while !b.load(Ordering::SeqCst) { std::hint::spin_loop() }
+    //~^ missing_spin_loop
 
     while b.load(Ordering::Acquire) == false { std::hint::spin_loop() }
+    //~^ missing_spin_loop
 
     while { true == b.load(Ordering::Acquire) } { std::hint::spin_loop() }
+    //~^ missing_spin_loop
 
     while b.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed) != Ok(true) { std::hint::spin_loop() }
+    //~^ missing_spin_loop
 
     while Ok(false) != b.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) { std::hint::spin_loop() }
+    //~^ missing_spin_loop
 
     // This is OK, as the body is not empty
     while b.load(Ordering::Acquire) {
diff --git a/src/tools/clippy/tests/ui/missing_spin_loop.rs b/src/tools/clippy/tests/ui/missing_spin_loop.rs
index 7b115c66ade6..bf18590b9408 100644
--- a/src/tools/clippy/tests/ui/missing_spin_loop.rs
+++ b/src/tools/clippy/tests/ui/missing_spin_loop.rs
@@ -8,16 +8,22 @@ fn main() {
     let b = AtomicBool::new(true);
     // Those should lint
     while b.load(Ordering::Acquire) {}
+    //~^ missing_spin_loop
 
     while !b.load(Ordering::SeqCst) {}
+    //~^ missing_spin_loop
 
     while b.load(Ordering::Acquire) == false {}
+    //~^ missing_spin_loop
 
     while { true == b.load(Ordering::Acquire) } {}
+    //~^ missing_spin_loop
 
     while b.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed) != Ok(true) {}
+    //~^ missing_spin_loop
 
     while Ok(false) != b.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) {}
+    //~^ missing_spin_loop
 
     // This is OK, as the body is not empty
     while b.load(Ordering::Acquire) {
diff --git a/src/tools/clippy/tests/ui/missing_spin_loop.stderr b/src/tools/clippy/tests/ui/missing_spin_loop.stderr
index 12f4b53a3d18..98c32d042346 100644
--- a/src/tools/clippy/tests/ui/missing_spin_loop.stderr
+++ b/src/tools/clippy/tests/ui/missing_spin_loop.stderr
@@ -8,31 +8,31 @@ LL |     while b.load(Ordering::Acquire) {}
    = help: to override `-D warnings` add `#[allow(clippy::missing_spin_loop)]`
 
 error: busy-waiting loop should at least have a spin loop hint
-  --> tests/ui/missing_spin_loop.rs:12:37
+  --> tests/ui/missing_spin_loop.rs:13:37
    |
 LL |     while !b.load(Ordering::SeqCst) {}
    |                                     ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
-  --> tests/ui/missing_spin_loop.rs:14:46
+  --> tests/ui/missing_spin_loop.rs:16:46
    |
 LL |     while b.load(Ordering::Acquire) == false {}
    |                                              ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
-  --> tests/ui/missing_spin_loop.rs:16:49
+  --> tests/ui/missing_spin_loop.rs:19:49
    |
 LL |     while { true == b.load(Ordering::Acquire) } {}
    |                                                 ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
-  --> tests/ui/missing_spin_loop.rs:18:93
+  --> tests/ui/missing_spin_loop.rs:22:93
    |
 LL |     while b.compare_exchange(true, false, Ordering::Acquire, Ordering::Relaxed) != Ok(true) {}
    |                                                                                             ^^ help: try: `{ std::hint::spin_loop() }`
 
 error: busy-waiting loop should at least have a spin loop hint
-  --> tests/ui/missing_spin_loop.rs:20:94
+  --> tests/ui/missing_spin_loop.rs:25:94
    |
 LL |     while Ok(false) != b.compare_exchange(false, true, Ordering::Acquire, Ordering::Relaxed) {}
    |                                                                                              ^^ help: try: `{ std::hint::spin_loop() }`
diff --git a/src/tools/clippy/tests/ui/missing_spin_loop_no_std.fixed b/src/tools/clippy/tests/ui/missing_spin_loop_no_std.fixed
index 771ab1ab21a8..a525d414670e 100644
--- a/src/tools/clippy/tests/ui/missing_spin_loop_no_std.fixed
+++ b/src/tools/clippy/tests/ui/missing_spin_loop_no_std.fixed
@@ -9,5 +9,6 @@ pub fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let b = AtomicBool::new(true);
     // This should lint with `core::hint::spin_loop()`
     while b.load(Ordering::Acquire) { core::hint::spin_loop() }
+    //~^ missing_spin_loop
     0
 }
diff --git a/src/tools/clippy/tests/ui/missing_spin_loop_no_std.rs b/src/tools/clippy/tests/ui/missing_spin_loop_no_std.rs
index bf890fc4066b..3b421f32c34f 100644
--- a/src/tools/clippy/tests/ui/missing_spin_loop_no_std.rs
+++ b/src/tools/clippy/tests/ui/missing_spin_loop_no_std.rs
@@ -9,5 +9,6 @@ pub fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let b = AtomicBool::new(true);
     // This should lint with `core::hint::spin_loop()`
     while b.load(Ordering::Acquire) {}
+    //~^ missing_spin_loop
     0
 }
diff --git a/src/tools/clippy/tests/ui/missing_trait_methods.rs b/src/tools/clippy/tests/ui/missing_trait_methods.rs
index 55b904bde59a..7af186ba3322 100644
--- a/src/tools/clippy/tests/ui/missing_trait_methods.rs
+++ b/src/tools/clippy/tests/ui/missing_trait_methods.rs
@@ -20,10 +20,11 @@ trait B {
 struct Partial;
 
 impl A for Partial {}
-//~^ ERROR: missing trait method provided by default: `provided`
+//~^ missing_trait_methods
 
 impl B for Partial {
-    //~^ ERROR: missing trait method provided by default: `b`
+    //~^ missing_trait_methods
+
     fn required() {}
 
     fn a(_: usize) -> usize {
@@ -56,5 +57,8 @@ trait MissingMultiple {
 }
 
 impl MissingMultiple for Partial {}
+//~^ missing_trait_methods
+//~| missing_trait_methods
+//~| missing_trait_methods
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/missing_trait_methods.stderr b/src/tools/clippy/tests/ui/missing_trait_methods.stderr
index 9c4968b022d7..d9fb8951ab3d 100644
--- a/src/tools/clippy/tests/ui/missing_trait_methods.stderr
+++ b/src/tools/clippy/tests/ui/missing_trait_methods.stderr
@@ -25,19 +25,7 @@ LL |     fn b<'a, T: AsRef<[u8]>>(a: &'a T) -> &'a [u8] {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: missing trait method provided by default: `one`
-  --> tests/ui/missing_trait_methods.rs:58:1
-   |
-LL | impl MissingMultiple for Partial {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   |
-help: implement the method
-  --> tests/ui/missing_trait_methods.rs:53:5
-   |
-LL |     fn one() {}
-   |     ^^^^^^^^
-
-error: missing trait method provided by default: `two`
-  --> tests/ui/missing_trait_methods.rs:58:1
+  --> tests/ui/missing_trait_methods.rs:59:1
    |
 LL | impl MissingMultiple for Partial {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -45,11 +33,11 @@ LL | impl MissingMultiple for Partial {}
 help: implement the method
   --> tests/ui/missing_trait_methods.rs:54:5
    |
-LL |     fn two() {}
+LL |     fn one() {}
    |     ^^^^^^^^
 
-error: missing trait method provided by default: `three`
-  --> tests/ui/missing_trait_methods.rs:58:1
+error: missing trait method provided by default: `two`
+  --> tests/ui/missing_trait_methods.rs:59:1
    |
 LL | impl MissingMultiple for Partial {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -57,6 +45,18 @@ LL | impl MissingMultiple for Partial {}
 help: implement the method
   --> tests/ui/missing_trait_methods.rs:55:5
    |
+LL |     fn two() {}
+   |     ^^^^^^^^
+
+error: missing trait method provided by default: `three`
+  --> tests/ui/missing_trait_methods.rs:59:1
+   |
+LL | impl MissingMultiple for Partial {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: implement the method
+  --> tests/ui/missing_trait_methods.rs:56:5
+   |
 LL |     fn three() {}
    |     ^^^^^^^^^^
 
diff --git a/src/tools/clippy/tests/ui/mistyped_literal_suffix.fixed b/src/tools/clippy/tests/ui/mistyped_literal_suffix.fixed
index b84b3dc349ec..a0190acc5d4b 100644
--- a/src/tools/clippy/tests/ui/mistyped_literal_suffix.fixed
+++ b/src/tools/clippy/tests/ui/mistyped_literal_suffix.fixed
@@ -14,35 +14,58 @@ use proc_macros::with_span;
 
 fn main() {
     let fail14 = 2_i32;
+    //~^ mistyped_literal_suffixes
     let fail15 = 4_i64;
+    //~^ mistyped_literal_suffixes
     let fail16 = 7_i8; //
+    //
+    //~^^ mistyped_literal_suffixes
     let fail17 = 23_i16; //
+    //
+    //~^^ mistyped_literal_suffixes
     let ok18 = 23_128;
 
     let fail20 = 2_i8; //
+    //
+    //~^^ mistyped_literal_suffixes
     let fail21 = 4_i16; //
+    //
+    //~^^ mistyped_literal_suffixes
 
     let ok24 = 12.34_64;
     let fail25 = 1E2_f32;
+    //~^ mistyped_literal_suffixes
     let fail26 = 43E7_f64;
+    //~^ mistyped_literal_suffixes
     let fail27 = 243E17_f32;
+    //~^ mistyped_literal_suffixes
     let fail28 = 241_251_235E723_f64;
+    //~^ mistyped_literal_suffixes
     let ok29 = 42279.911_32;
 
     // testing that the suggestion actually fits in its type
     let fail30 = 127_i8; // should be i8
+    //
+    //~^^ mistyped_literal_suffixes
     let fail31 = 240_u8; // should be u8
+    //
+    //~^^ mistyped_literal_suffixes
     let ok32 = 360_8; // doesn't fit in either, should be ignored
     let fail33 = 0x1234_i16;
+    //~^ mistyped_literal_suffixes
     let fail34 = 0xABCD_u16;
+    //~^ mistyped_literal_suffixes
     let ok35 = 0x12345_16;
     let fail36 = 0xFFFF_FFFF_FFFF_FFFF_u64; // u64
+    //
+    //~^^ mistyped_literal_suffixes
 
     // issue #6129
     let ok37 = 123_32.123;
     let ok38 = 124_64.0;
 
     let _ = 1.123_45E1_f32;
+    //~^ mistyped_literal_suffixes
 
     let _ = with_span!(1 2_u32);
 }
diff --git a/src/tools/clippy/tests/ui/mistyped_literal_suffix.rs b/src/tools/clippy/tests/ui/mistyped_literal_suffix.rs
index a47a736067a8..12a26204e755 100644
--- a/src/tools/clippy/tests/ui/mistyped_literal_suffix.rs
+++ b/src/tools/clippy/tests/ui/mistyped_literal_suffix.rs
@@ -14,35 +14,58 @@ use proc_macros::with_span;
 
 fn main() {
     let fail14 = 2_32;
+    //~^ mistyped_literal_suffixes
     let fail15 = 4_64;
+    //~^ mistyped_literal_suffixes
     let fail16 = 7_8; //
+    //
+    //~^^ mistyped_literal_suffixes
     let fail17 = 23_16; //
+    //
+    //~^^ mistyped_literal_suffixes
     let ok18 = 23_128;
 
     let fail20 = 2__8; //
+    //
+    //~^^ mistyped_literal_suffixes
     let fail21 = 4___16; //
+    //
+    //~^^ mistyped_literal_suffixes
 
     let ok24 = 12.34_64;
     let fail25 = 1E2_32;
+    //~^ mistyped_literal_suffixes
     let fail26 = 43E7_64;
+    //~^ mistyped_literal_suffixes
     let fail27 = 243E17_32;
+    //~^ mistyped_literal_suffixes
     let fail28 = 241251235E723_64;
+    //~^ mistyped_literal_suffixes
     let ok29 = 42279.911_32;
 
     // testing that the suggestion actually fits in its type
     let fail30 = 127_8; // should be i8
+    //
+    //~^^ mistyped_literal_suffixes
     let fail31 = 240_8; // should be u8
+    //
+    //~^^ mistyped_literal_suffixes
     let ok32 = 360_8; // doesn't fit in either, should be ignored
     let fail33 = 0x1234_16;
+    //~^ mistyped_literal_suffixes
     let fail34 = 0xABCD_16;
+    //~^ mistyped_literal_suffixes
     let ok35 = 0x12345_16;
     let fail36 = 0xFFFF_FFFF_FFFF_FFFF_64; // u64
+    //
+    //~^^ mistyped_literal_suffixes
 
     // issue #6129
     let ok37 = 123_32.123;
     let ok38 = 124_64.0;
 
     let _ = 1.12345E1_32;
+    //~^ mistyped_literal_suffixes
 
     let _ = with_span!(1 2_u32);
 }
diff --git a/src/tools/clippy/tests/ui/mistyped_literal_suffix.stderr b/src/tools/clippy/tests/ui/mistyped_literal_suffix.stderr
index 56bfb06d8e66..9c6b2fab21c3 100644
--- a/src/tools/clippy/tests/ui/mistyped_literal_suffix.stderr
+++ b/src/tools/clippy/tests/ui/mistyped_literal_suffix.stderr
@@ -7,91 +7,91 @@ LL |     let fail14 = 2_32;
    = note: `#[deny(clippy::mistyped_literal_suffixes)]` on by default
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:17:18
+  --> tests/ui/mistyped_literal_suffix.rs:18:18
    |
 LL |     let fail15 = 4_64;
    |                  ^^^^ help: did you mean to write: `4_i64`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:18:18
+  --> tests/ui/mistyped_literal_suffix.rs:20:18
    |
 LL |     let fail16 = 7_8; //
    |                  ^^^ help: did you mean to write: `7_i8`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:19:18
+  --> tests/ui/mistyped_literal_suffix.rs:23:18
    |
 LL |     let fail17 = 23_16; //
    |                  ^^^^^ help: did you mean to write: `23_i16`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:22:18
+  --> tests/ui/mistyped_literal_suffix.rs:28:18
    |
 LL |     let fail20 = 2__8; //
    |                  ^^^^ help: did you mean to write: `2_i8`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:23:18
+  --> tests/ui/mistyped_literal_suffix.rs:31:18
    |
 LL |     let fail21 = 4___16; //
    |                  ^^^^^^ help: did you mean to write: `4_i16`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:26:18
+  --> tests/ui/mistyped_literal_suffix.rs:36:18
    |
 LL |     let fail25 = 1E2_32;
    |                  ^^^^^^ help: did you mean to write: `1E2_f32`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:27:18
+  --> tests/ui/mistyped_literal_suffix.rs:38:18
    |
 LL |     let fail26 = 43E7_64;
    |                  ^^^^^^^ help: did you mean to write: `43E7_f64`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:28:18
+  --> tests/ui/mistyped_literal_suffix.rs:40:18
    |
 LL |     let fail27 = 243E17_32;
    |                  ^^^^^^^^^ help: did you mean to write: `243E17_f32`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:29:18
+  --> tests/ui/mistyped_literal_suffix.rs:42:18
    |
 LL |     let fail28 = 241251235E723_64;
    |                  ^^^^^^^^^^^^^^^^ help: did you mean to write: `241_251_235E723_f64`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:33:18
+  --> tests/ui/mistyped_literal_suffix.rs:47:18
    |
 LL |     let fail30 = 127_8; // should be i8
    |                  ^^^^^ help: did you mean to write: `127_i8`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:34:18
+  --> tests/ui/mistyped_literal_suffix.rs:50:18
    |
 LL |     let fail31 = 240_8; // should be u8
    |                  ^^^^^ help: did you mean to write: `240_u8`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:36:18
+  --> tests/ui/mistyped_literal_suffix.rs:54:18
    |
 LL |     let fail33 = 0x1234_16;
    |                  ^^^^^^^^^ help: did you mean to write: `0x1234_i16`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:37:18
+  --> tests/ui/mistyped_literal_suffix.rs:56:18
    |
 LL |     let fail34 = 0xABCD_16;
    |                  ^^^^^^^^^ help: did you mean to write: `0xABCD_u16`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:39:18
+  --> tests/ui/mistyped_literal_suffix.rs:59:18
    |
 LL |     let fail36 = 0xFFFF_FFFF_FFFF_FFFF_64; // u64
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean to write: `0xFFFF_FFFF_FFFF_FFFF_u64`
 
 error: mistyped literal suffix
-  --> tests/ui/mistyped_literal_suffix.rs:45:13
+  --> tests/ui/mistyped_literal_suffix.rs:67:13
    |
 LL |     let _ = 1.12345E1_32;
    |             ^^^^^^^^^^^^ help: did you mean to write: `1.123_45E1_f32`
diff --git a/src/tools/clippy/tests/ui/mixed_attributes_style/auxiliary/submodule.rs b/src/tools/clippy/tests/ui/mixed_attributes_style/auxiliary/submodule.rs
index df44b07a6941..43d22940415f 100644
--- a/src/tools/clippy/tests/ui/mixed_attributes_style/auxiliary/submodule.rs
+++ b/src/tools/clippy/tests/ui/mixed_attributes_style/auxiliary/submodule.rs
@@ -3,7 +3,6 @@
 #![allow(dead_code)]
 
 #[allow(unused)]
-//~^ ERROR: item has both inner and outer attributes
 mod foo {
     #![allow(dead_code)]
 }
diff --git a/src/tools/clippy/tests/ui/mixed_attributes_style/global_allow.rs b/src/tools/clippy/tests/ui/mixed_attributes_style/global_allow.rs
index 153262e65570..19a45e720a60 100644
--- a/src/tools/clippy/tests/ui/mixed_attributes_style/global_allow.rs
+++ b/src/tools/clippy/tests/ui/mixed_attributes_style/global_allow.rs
@@ -1,4 +1,5 @@
-// issue 12436
+// https://github.com/rust-lang/rust-clippy/issues/12436
+//@check-pass
 #![allow(clippy::mixed_attributes_style)]
 
 #[path = "auxiliary/submodule.rs"]
diff --git a/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.rs b/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.rs
index b0f1f0bda9e6..8cef6a80048a 100644
--- a/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.rs
+++ b/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.rs
@@ -1,3 +1,5 @@
+//@error-in-other-file: item has both inner and outer attributes
+//@no-rustfix
 #[path = "auxiliary/submodule.rs"] // don't lint.
 /// This doc comment should not lint, it could be used to add context to the original module doc
 mod submodule;
diff --git a/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.stderr b/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.stderr
index 968c537c7e44..1239742a05b7 100644
--- a/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.stderr
+++ b/src/tools/clippy/tests/ui/mixed_attributes_style/mod_declaration.stderr
@@ -2,7 +2,6 @@ error: item has both inner and outer attributes
   --> tests/ui/mixed_attributes_style/auxiliary/submodule.rs:5:1
    |
 LL | / #[allow(unused)]
-LL | |
 LL | | mod foo {
 LL | |     #![allow(dead_code)]
    | |________________________^
diff --git a/src/tools/clippy/tests/ui/mixed_read_write_in_expression.rs b/src/tools/clippy/tests/ui/mixed_read_write_in_expression.rs
index 241536abdfbd..2ead166bf801 100644
--- a/src/tools/clippy/tests/ui/mixed_read_write_in_expression.rs
+++ b/src/tools/clippy/tests/ui/mixed_read_write_in_expression.rs
@@ -12,11 +12,12 @@ fn main() {
         x = 1;
         1
     } + x;
-    //~^ ERROR: unsequenced read of `x`
+    //~^ mixed_read_write_in_expression
 
     // Example from iss#277
     x += {
-        //~^ ERROR: unsequenced read of `x`
+        //~^ mixed_read_write_in_expression
+
         x = 20;
         2
     };
@@ -30,7 +31,7 @@ fn main() {
     let base = Foo { a: 4, b: 5 };
     let foo = Foo {
         a: x,
-        //~^ ERROR: unsequenced read of `x`
+        //~^ mixed_read_write_in_expression
         ..{
             x = 6;
             base
@@ -40,7 +41,8 @@ fn main() {
     let closure = || {
         let mut x = 0;
         x += {
-            //~^ ERROR: unsequenced read of `x`
+            //~^ mixed_read_write_in_expression
+
             x = 20;
             2
         };
diff --git a/src/tools/clippy/tests/ui/mixed_read_write_in_expression.stderr b/src/tools/clippy/tests/ui/mixed_read_write_in_expression.stderr
index 796d4ccd26b7..e34dce2bb132 100644
--- a/src/tools/clippy/tests/ui/mixed_read_write_in_expression.stderr
+++ b/src/tools/clippy/tests/ui/mixed_read_write_in_expression.stderr
@@ -19,31 +19,31 @@ LL |     x += {
    |     ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> tests/ui/mixed_read_write_in_expression.rs:20:9
+  --> tests/ui/mixed_read_write_in_expression.rs:21:9
    |
 LL |         x = 20;
    |         ^^^^^^
 
 error: unsequenced read of `x`
-  --> tests/ui/mixed_read_write_in_expression.rs:32:12
+  --> tests/ui/mixed_read_write_in_expression.rs:33:12
    |
 LL |         a: x,
    |            ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> tests/ui/mixed_read_write_in_expression.rs:35:13
+  --> tests/ui/mixed_read_write_in_expression.rs:36:13
    |
 LL |             x = 6;
    |             ^^^^^
 
 error: unsequenced read of `x`
-  --> tests/ui/mixed_read_write_in_expression.rs:42:9
+  --> tests/ui/mixed_read_write_in_expression.rs:43:9
    |
 LL |         x += {
    |         ^
    |
 note: whether read occurs before this write depends on evaluation order
-  --> tests/ui/mixed_read_write_in_expression.rs:44:13
+  --> tests/ui/mixed_read_write_in_expression.rs:46:13
    |
 LL |             x = 20;
    |             ^^^^^^
diff --git a/src/tools/clippy/tests/ui/module_inception.rs b/src/tools/clippy/tests/ui/module_inception.rs
index ad46e0c29aee..15b7fb877770 100644
--- a/src/tools/clippy/tests/ui/module_inception.rs
+++ b/src/tools/clippy/tests/ui/module_inception.rs
@@ -3,14 +3,15 @@
 pub mod foo2 {
     pub mod bar2 {
         pub mod bar2 {
-            //~^ ERROR: module has the same name as its containing module
-            //~| NOTE: `-D clippy::module-inception` implied by `-D warnings`
+            //~^ module_inception
+
             pub mod foo2 {}
         }
         pub mod foo2 {}
     }
     pub mod foo2 {
-        //~^ ERROR: module has the same name as its containing module
+        //~^ module_inception
+
         pub mod bar2 {}
     }
 }
@@ -18,13 +19,15 @@ pub mod foo2 {
 mod foo {
     mod bar {
         mod bar {
-            //~^ ERROR: module has the same name as its containing module
+            //~^ module_inception
+
             mod foo {}
         }
         mod foo {}
     }
     mod foo {
-        //~^ ERROR: module has the same name as its containing module
+        //~^ module_inception
+
         mod bar {}
     }
 }
diff --git a/src/tools/clippy/tests/ui/module_inception.stderr b/src/tools/clippy/tests/ui/module_inception.stderr
index 455f5372747a..8e7d555cebc6 100644
--- a/src/tools/clippy/tests/ui/module_inception.stderr
+++ b/src/tools/clippy/tests/ui/module_inception.stderr
@@ -16,24 +16,27 @@ error: module has the same name as its containing module
    |
 LL | /     pub mod foo2 {
 LL | |
+LL | |
 LL | |         pub mod bar2 {}
 LL | |     }
    | |_____^
 
 error: module has the same name as its containing module
-  --> tests/ui/module_inception.rs:20:9
+  --> tests/ui/module_inception.rs:21:9
    |
 LL | /         mod bar {
 LL | |
+LL | |
 LL | |             mod foo {}
 LL | |         }
    | |_________^
 
 error: module has the same name as its containing module
-  --> tests/ui/module_inception.rs:26:5
+  --> tests/ui/module_inception.rs:28:5
    |
 LL | /     mod foo {
 LL | |
+LL | |
 LL | |         mod bar {}
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/module_name_repetitions.rs b/src/tools/clippy/tests/ui/module_name_repetitions.rs
index 71d8ac7a1f0e..2fde98d7927c 100644
--- a/src/tools/clippy/tests/ui/module_name_repetitions.rs
+++ b/src/tools/clippy/tests/ui/module_name_repetitions.rs
@@ -6,16 +6,19 @@
 pub mod foo {
     pub fn foo() {}
     pub fn foo_bar() {}
-    //~^ ERROR: item name starts with its containing module's name
-    //~| NOTE: `-D clippy::module-name-repetitions` implied by `-D warnings`
+    //~^ module_name_repetitions
+
     pub fn bar_foo() {}
-    //~^ ERROR: item name ends with its containing module's name
+    //~^ module_name_repetitions
+
     pub struct FooCake;
-    //~^ ERROR: item name starts with its containing module's name
+    //~^ module_name_repetitions
+
     pub enum CakeFoo {}
-    //~^ ERROR: item name ends with its containing module's name
+    //~^ module_name_repetitions
+
     pub struct Foo7Bar;
-    //~^ ERROR: item name starts with its containing module's name
+    //~^ module_name_repetitions
 
     // Should not warn
     pub struct Foobar;
@@ -28,7 +31,7 @@ pub mod foo {
     pub use error::Error;
     // ... but should still warn when the item is reexported to create a *public* path with repetition.
     pub use error::FooError;
-    //~^ ERROR: item name starts with its containing module's name
+    //~^ module_name_repetitions
 
     // FIXME: This should also warn because it creates the public path `foo::FooIter`.
     mod iter {
diff --git a/src/tools/clippy/tests/ui/module_name_repetitions.stderr b/src/tools/clippy/tests/ui/module_name_repetitions.stderr
index 8fd8b3948753..9000c44a3902 100644
--- a/src/tools/clippy/tests/ui/module_name_repetitions.stderr
+++ b/src/tools/clippy/tests/ui/module_name_repetitions.stderr
@@ -14,25 +14,25 @@ LL |     pub fn bar_foo() {}
    |            ^^^^^^^
 
 error: item name starts with its containing module's name
-  --> tests/ui/module_name_repetitions.rs:13:16
+  --> tests/ui/module_name_repetitions.rs:14:16
    |
 LL |     pub struct FooCake;
    |                ^^^^^^^
 
 error: item name ends with its containing module's name
-  --> tests/ui/module_name_repetitions.rs:15:14
+  --> tests/ui/module_name_repetitions.rs:17:14
    |
 LL |     pub enum CakeFoo {}
    |              ^^^^^^^
 
 error: item name starts with its containing module's name
-  --> tests/ui/module_name_repetitions.rs:17:16
+  --> tests/ui/module_name_repetitions.rs:20:16
    |
 LL |     pub struct Foo7Bar;
    |                ^^^^^^^
 
 error: item name starts with its containing module's name
-  --> tests/ui/module_name_repetitions.rs:30:20
+  --> tests/ui/module_name_repetitions.rs:33:20
    |
 LL |     pub use error::FooError;
    |                    ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/modulo_arithmetic_float.rs b/src/tools/clippy/tests/ui/modulo_arithmetic_float.rs
index a5b63bed531b..0e08174f686e 100644
--- a/src/tools/clippy/tests/ui/modulo_arithmetic_float.rs
+++ b/src/tools/clippy/tests/ui/modulo_arithmetic_float.rs
@@ -6,67 +6,62 @@
 fn main() {
     // Lint when both sides are const and of the opposite sign
     -1.6 % 2.1;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1.600 %
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1.6 % -2.1;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1.600 %
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     (1.1 - 2.3) % (1.1 + 2.3);
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1.200 %
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     (1.1 + 2.3) % (1.1 - 2.3);
-    //~^ ERROR: you are using modulo operator on constants with different signs: `3.400 %
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     // Lint on floating point numbers
     let a_f16: f16 = -1.6;
     let mut b_f16: f16 = 2.1;
     a_f16 % b_f16;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f16 % a_f16;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f16 %= a_f16;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     // Lint on floating point numbers
     let a_f32: f32 = -1.6;
     let mut b_f32: f32 = 2.1;
     a_f32 % b_f32;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f32 % a_f32;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f32 %= a_f32;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_f64: f64 = -1.6;
     let mut b_f64: f64 = 2.1;
     a_f64 % b_f64;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f64 % a_f64;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f64 %= a_f64;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_f128: f128 = -1.6;
     let mut b_f128: f128 = 2.1;
     a_f128 % b_f128;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f128 % a_f128;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_f128 %= a_f128;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     // No lint when both sides are const and of the same sign
     1.6 % 2.1;
diff --git a/src/tools/clippy/tests/ui/modulo_arithmetic_float.stderr b/src/tools/clippy/tests/ui/modulo_arithmetic_float.stderr
index 2b4937552bda..91b5c80ce9f4 100644
--- a/src/tools/clippy/tests/ui/modulo_arithmetic_float.stderr
+++ b/src/tools/clippy/tests/ui/modulo_arithmetic_float.stderr
@@ -33,7 +33,7 @@ LL |     (1.1 + 2.3) % (1.1 - 2.3);
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:24:5
+  --> tests/ui/modulo_arithmetic_float.rs:23:5
    |
 LL |     a_f16 % b_f16;
    |     ^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     a_f16 % b_f16;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:27:5
+  --> tests/ui/modulo_arithmetic_float.rs:26:5
    |
 LL |     b_f16 % a_f16;
    |     ^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     b_f16 % a_f16;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:30:5
+  --> tests/ui/modulo_arithmetic_float.rs:29:5
    |
 LL |     b_f16 %= a_f16;
    |     ^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     b_f16 %= a_f16;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:37:5
+  --> tests/ui/modulo_arithmetic_float.rs:35:5
    |
 LL |     a_f32 % b_f32;
    |     ^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     a_f32 % b_f32;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:40:5
+  --> tests/ui/modulo_arithmetic_float.rs:38:5
    |
 LL |     b_f32 % a_f32;
    |     ^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     b_f32 % a_f32;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:43:5
+  --> tests/ui/modulo_arithmetic_float.rs:41:5
    |
 LL |     b_f32 %= a_f32;
    |     ^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     b_f32 %= a_f32;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:49:5
+  --> tests/ui/modulo_arithmetic_float.rs:46:5
    |
 LL |     a_f64 % b_f64;
    |     ^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     a_f64 % b_f64;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:52:5
+  --> tests/ui/modulo_arithmetic_float.rs:49:5
    |
 LL |     b_f64 % a_f64;
    |     ^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     b_f64 % a_f64;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:55:5
+  --> tests/ui/modulo_arithmetic_float.rs:52:5
    |
 LL |     b_f64 %= a_f64;
    |     ^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     b_f64 %= a_f64;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:61:5
+  --> tests/ui/modulo_arithmetic_float.rs:57:5
    |
 LL |     a_f128 % b_f128;
    |     ^^^^^^^^^^^^^^^
@@ -113,7 +113,7 @@ LL |     a_f128 % b_f128;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:64:5
+  --> tests/ui/modulo_arithmetic_float.rs:60:5
    |
 LL |     b_f128 % a_f128;
    |     ^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     b_f128 % a_f128;
    = note: double check for expected result especially when interoperating with different languages
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_float.rs:67:5
+  --> tests/ui/modulo_arithmetic_float.rs:63:5
    |
 LL |     b_f128 %= a_f128;
    |     ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/modulo_arithmetic_integral.rs b/src/tools/clippy/tests/ui/modulo_arithmetic_integral.rs
index c427b8580e17..d7cd910e43cb 100644
--- a/src/tools/clippy/tests/ui/modulo_arithmetic_integral.rs
+++ b/src/tools/clippy/tests/ui/modulo_arithmetic_integral.rs
@@ -6,77 +6,69 @@ fn main() {
     let a = -1;
     let mut b = 2;
     a % b;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b % a;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b %= a;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_i8: i8 = 1;
     let mut b_i8: i8 = 2;
     a_i8 % b_i8;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_i8 %= a_i8;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_i16: i16 = 1;
     let mut b_i16: i16 = 2;
     a_i16 % b_i16;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_i16 %= a_i16;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_i32: i32 = 1;
     let mut b_i32: i32 = 2;
     a_i32 % b_i32;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_i32 %= a_i32;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_i64: i64 = 1;
     let mut b_i64: i64 = 2;
     a_i64 % b_i64;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_i64 %= a_i64;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_i128: i128 = 1;
     let mut b_i128: i128 = 2;
     a_i128 % b_i128;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_i128 %= a_i128;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a_isize: isize = 1;
     let mut b_isize: isize = 2;
     a_isize % b_isize;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b_isize %= a_isize;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     let a = 1;
     let mut b = 2;
     a % b;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     b %= a;
-    //~^ ERROR: you are using modulo operator on types that might have different signs
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     // No lint on unsigned integral value
     let a_u8: u8 = 17;
diff --git a/src/tools/clippy/tests/ui/modulo_arithmetic_integral.stderr b/src/tools/clippy/tests/ui/modulo_arithmetic_integral.stderr
index f1cfe791a03b..d1b71cdab5e4 100644
--- a/src/tools/clippy/tests/ui/modulo_arithmetic_integral.stderr
+++ b/src/tools/clippy/tests/ui/modulo_arithmetic_integral.stderr
@@ -28,7 +28,7 @@ LL |     b %= a;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:20:5
+  --> tests/ui/modulo_arithmetic_integral.rs:19:5
    |
 LL |     a_i8 % b_i8;
    |     ^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL |     a_i8 % b_i8;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:23:5
+  --> tests/ui/modulo_arithmetic_integral.rs:22:5
    |
 LL |     b_i8 %= a_i8;
    |     ^^^^^^^^^^^^
@@ -46,7 +46,7 @@ LL |     b_i8 %= a_i8;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:29:5
+  --> tests/ui/modulo_arithmetic_integral.rs:27:5
    |
 LL |     a_i16 % b_i16;
    |     ^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     a_i16 % b_i16;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:32:5
+  --> tests/ui/modulo_arithmetic_integral.rs:30:5
    |
 LL |     b_i16 %= a_i16;
    |     ^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     b_i16 %= a_i16;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:38:5
+  --> tests/ui/modulo_arithmetic_integral.rs:35:5
    |
 LL |     a_i32 % b_i32;
    |     ^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     a_i32 % b_i32;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:41:5
+  --> tests/ui/modulo_arithmetic_integral.rs:38:5
    |
 LL |     b_i32 %= a_i32;
    |     ^^^^^^^^^^^^^^
@@ -82,7 +82,7 @@ LL |     b_i32 %= a_i32;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:47:5
+  --> tests/ui/modulo_arithmetic_integral.rs:43:5
    |
 LL |     a_i64 % b_i64;
    |     ^^^^^^^^^^^^^
@@ -91,7 +91,7 @@ LL |     a_i64 % b_i64;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:50:5
+  --> tests/ui/modulo_arithmetic_integral.rs:46:5
    |
 LL |     b_i64 %= a_i64;
    |     ^^^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     b_i64 %= a_i64;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:56:5
+  --> tests/ui/modulo_arithmetic_integral.rs:51:5
    |
 LL |     a_i128 % b_i128;
    |     ^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     a_i128 % b_i128;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:59:5
+  --> tests/ui/modulo_arithmetic_integral.rs:54:5
    |
 LL |     b_i128 %= a_i128;
    |     ^^^^^^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL |     b_i128 %= a_i128;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:65:5
+  --> tests/ui/modulo_arithmetic_integral.rs:59:5
    |
 LL |     a_isize % b_isize;
    |     ^^^^^^^^^^^^^^^^^
@@ -127,7 +127,7 @@ LL |     a_isize % b_isize;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:68:5
+  --> tests/ui/modulo_arithmetic_integral.rs:62:5
    |
 LL |     b_isize %= a_isize;
    |     ^^^^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL |     b_isize %= a_isize;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:74:5
+  --> tests/ui/modulo_arithmetic_integral.rs:67:5
    |
 LL |     a % b;
    |     ^^^^^
@@ -145,7 +145,7 @@ LL |     a % b;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on types that might have different signs
-  --> tests/ui/modulo_arithmetic_integral.rs:77:5
+  --> tests/ui/modulo_arithmetic_integral.rs:70:5
    |
 LL |     b %= a;
    |     ^^^^^^
diff --git a/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.rs b/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.rs
index dbc679a69825..9f5fb697df0e 100644
--- a/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.rs
+++ b/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.rs
@@ -9,57 +9,55 @@
 fn main() {
     // Lint when both sides are const and of the opposite sign
     -1 % 2;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1 % -2;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1 % -2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     (1 - 2) % (1 + 2);
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 3`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     (1 + 2) % (1 - 2);
-    //~^ ERROR: you are using modulo operator on constants with different signs: `3 % -1`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     35 * (7 - 4 * 2) % (-500 * -600);
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-35 % 30
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     -1i8 % 2i8;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1i8 % -2i8;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1 % -2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     -1i16 % 2i16;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1i16 % -2i16;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1 % -2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     -1i32 % 2i32;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1i32 % -2i32;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1 % -2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     -1i64 % 2i64;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1i64 % -2i64;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1 % -2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     -1i128 % 2i128;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1i128 % -2i128;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1 % -2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     -1isize % 2isize;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `-1 % 2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
+
     1isize % -2isize;
-    //~^ ERROR: you are using modulo operator on constants with different signs: `1 % -2`
-    //~| NOTE: double check for expected result especially when interoperating with differ
+    //~^ modulo_arithmetic
 
     // No lint when both sides are const and of the same sign
     1 % 2;
diff --git a/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.stderr b/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.stderr
index 722d9b83660e..12edee8cf425 100644
--- a/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.stderr
+++ b/src/tools/clippy/tests/ui/modulo_arithmetic_integral_const.stderr
@@ -46,7 +46,7 @@ LL |     35 * (7 - 4 * 2) % (-500 * -600);
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:27:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:26:5
    |
 LL |     -1i8 % 2i8;
    |     ^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     -1i8 % 2i8;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:30:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:29:5
    |
 LL |     1i8 % -2i8;
    |     ^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     1i8 % -2i8;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:33:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:32:5
    |
 LL |     -1i16 % 2i16;
    |     ^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     -1i16 % 2i16;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:36:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:35:5
    |
 LL |     1i16 % -2i16;
    |     ^^^^^^^^^^^^
@@ -82,7 +82,7 @@ LL |     1i16 % -2i16;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:39:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:38:5
    |
 LL |     -1i32 % 2i32;
    |     ^^^^^^^^^^^^
@@ -91,7 +91,7 @@ LL |     -1i32 % 2i32;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:42:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:41:5
    |
 LL |     1i32 % -2i32;
    |     ^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     1i32 % -2i32;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:45:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:44:5
    |
 LL |     -1i64 % 2i64;
    |     ^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     -1i64 % 2i64;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:48:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:47:5
    |
 LL |     1i64 % -2i64;
    |     ^^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL |     1i64 % -2i64;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:51:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:50:5
    |
 LL |     -1i128 % 2i128;
    |     ^^^^^^^^^^^^^^
@@ -127,7 +127,7 @@ LL |     -1i128 % 2i128;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:54:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:53:5
    |
 LL |     1i128 % -2i128;
    |     ^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL |     1i128 % -2i128;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `-1 % 2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:57:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:56:5
    |
 LL |     -1isize % 2isize;
    |     ^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL |     -1isize % 2isize;
    = note: or consider using `rem_euclid` or similar function
 
 error: you are using modulo operator on constants with different signs: `1 % -2`
-  --> tests/ui/modulo_arithmetic_integral_const.rs:60:5
+  --> tests/ui/modulo_arithmetic_integral_const.rs:59:5
    |
 LL |     1isize % -2isize;
    |     ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/modulo_one.rs b/src/tools/clippy/tests/ui/modulo_one.rs
index c332a15f1577..63ae61059cb8 100644
--- a/src/tools/clippy/tests/ui/modulo_one.rs
+++ b/src/tools/clippy/tests/ui/modulo_one.rs
@@ -1,4 +1,5 @@
 #![warn(clippy::modulo_one)]
+#![allow(unconditional_panic)]
 #![allow(clippy::no_effect, clippy::unnecessary_operation, clippy::identity_op)]
 
 static STATIC_ONE: usize = 2 - 1;
@@ -6,33 +7,34 @@ static STATIC_NEG_ONE: i64 = 1 - 2;
 
 fn main() {
     10 % 1;
-    //~^ ERROR: any number modulo 1 will be 0
-    //~| NOTE: `-D clippy::modulo-one` implied by `-D warnings`
+    //~^ modulo_one
+
     10 % -1;
-    //~^ ERROR: any number modulo -1 will panic/overflow or result in 0
+    //~^ modulo_one
+
     10 % 2;
     // also caught by rustc
     i32::MIN % (-1);
-    //~^ ERROR: this operation will panic at runtime
-    //~| NOTE: `#[deny(unconditional_panic)]` on by default
-    //~| ERROR: any number modulo -1 will panic/overflow or result in 0
+    //~^ modulo_one
 
     const ONE: u32 = 1 * 1;
     const NEG_ONE: i64 = 1 - 2;
     const INT_MIN: i64 = i64::MIN;
 
     2 % ONE;
-    //~^ ERROR: any number modulo 1 will be 0
+    //~^ modulo_one
+
     // NOT caught by lint
     5 % STATIC_ONE;
     2 % NEG_ONE;
-    //~^ ERROR: any number modulo -1 will panic/overflow or result in 0
+    //~^ modulo_one
+
     // NOT caught by lint
     5 % STATIC_NEG_ONE;
     // also caught by rustc
     INT_MIN % NEG_ONE;
-    //~^ ERROR: this operation will panic at runtime
-    //~| ERROR: any number modulo -1 will panic/overflow or result in 0
+    //~^ modulo_one
+
     // Not caught by lint, we don't look into static items, even if entirely immutable.
     INT_MIN % STATIC_NEG_ONE;
 }
diff --git a/src/tools/clippy/tests/ui/modulo_one.stderr b/src/tools/clippy/tests/ui/modulo_one.stderr
index aedcf24eae71..1c9c79d1c621 100644
--- a/src/tools/clippy/tests/ui/modulo_one.stderr
+++ b/src/tools/clippy/tests/ui/modulo_one.stderr
@@ -1,19 +1,5 @@
-error: this operation will panic at runtime
-  --> tests/ui/modulo_one.rs:15:5
-   |
-LL |     i32::MIN % (-1);
-   |     ^^^^^^^^^^^^^^^ attempt to compute `i32::MIN % -1_i32`, which would overflow
-   |
-   = note: `#[deny(unconditional_panic)]` on by default
-
-error: this operation will panic at runtime
-  --> tests/ui/modulo_one.rs:33:5
-   |
-LL |     INT_MIN % NEG_ONE;
-   |     ^^^^^^^^^^^^^^^^^ attempt to compute `i64::MIN % -1_i64`, which would overflow
-
 error: any number modulo 1 will be 0
-  --> tests/ui/modulo_one.rs:8:5
+  --> tests/ui/modulo_one.rs:9:5
    |
 LL |     10 % 1;
    |     ^^^^^^
@@ -22,13 +8,13 @@ LL |     10 % 1;
    = help: to override `-D warnings` add `#[allow(clippy::modulo_one)]`
 
 error: any number modulo -1 will panic/overflow or result in 0
-  --> tests/ui/modulo_one.rs:11:5
+  --> tests/ui/modulo_one.rs:12:5
    |
 LL |     10 % -1;
    |     ^^^^^^^
 
 error: any number modulo -1 will panic/overflow or result in 0
-  --> tests/ui/modulo_one.rs:15:5
+  --> tests/ui/modulo_one.rs:17:5
    |
 LL |     i32::MIN % (-1);
    |     ^^^^^^^^^^^^^^^
@@ -40,16 +26,16 @@ LL |     2 % ONE;
    |     ^^^^^^^
 
 error: any number modulo -1 will panic/overflow or result in 0
-  --> tests/ui/modulo_one.rs:28:5
+  --> tests/ui/modulo_one.rs:29:5
    |
 LL |     2 % NEG_ONE;
    |     ^^^^^^^^^^^
 
 error: any number modulo -1 will panic/overflow or result in 0
-  --> tests/ui/modulo_one.rs:33:5
+  --> tests/ui/modulo_one.rs:35:5
    |
 LL |     INT_MIN % NEG_ONE;
    |     ^^^^^^^^^^^^^^^^^
 
-error: aborting due to 8 previous errors
+error: aborting due to 6 previous errors
 
diff --git a/src/tools/clippy/tests/ui/msrv_attributes_without_early_lints.rs b/src/tools/clippy/tests/ui/msrv_attributes_without_early_lints.rs
new file mode 100644
index 000000000000..dcef1a485fce
--- /dev/null
+++ b/src/tools/clippy/tests/ui/msrv_attributes_without_early_lints.rs
@@ -0,0 +1,14 @@
+//@check-pass
+
+#![allow(clippy::all, clippy::pedantic, clippy::restriction, clippy::nursery)]
+#![forbid(clippy::ptr_as_ptr)]
+
+/// MSRV checking in late passes skips checking the parent nodes if no early pass sees a
+/// `#[clippy::msrv]` attribute
+///
+/// Here we ensure that even if all early passes are allowed (above) the attribute is still detected
+/// in late lints such as `clippy::ptr_as_ptr`
+#[clippy::msrv = "1.37"]
+fn f(p: *const i32) {
+    let _ = p as *const i64;
+}
diff --git a/src/tools/clippy/tests/ui/multi_assignments.rs b/src/tools/clippy/tests/ui/multi_assignments.rs
index cdbf13b68889..5a0d9a7aa37c 100644
--- a/src/tools/clippy/tests/ui/multi_assignments.rs
+++ b/src/tools/clippy/tests/ui/multi_assignments.rs
@@ -2,15 +2,18 @@
 fn main() {
     let (mut a, mut b, mut c, mut d) = ((), (), (), ());
     a = b = c;
-    //~^ ERROR: assignments don't nest intuitively
-    //~| NOTE: `-D clippy::multi-assignments` implied by `-D warnings`
+    //~^ multi_assignments
+
     a = b = c = d;
-    //~^ ERROR: assignments don't nest intuitively
-    //~| ERROR: assignments don't nest intuitively
+    //~^ multi_assignments
+    //~| multi_assignments
+
     a = b = { c };
-    //~^ ERROR: assignments don't nest intuitively
+    //~^ multi_assignments
+
     a = { b = c };
-    //~^ ERROR: assignments don't nest intuitively
+    //~^ multi_assignments
+
     a = (b = c);
-    //~^ ERROR: assignments don't nest intuitively
+    //~^ multi_assignments
 }
diff --git a/src/tools/clippy/tests/ui/multi_assignments.stderr b/src/tools/clippy/tests/ui/multi_assignments.stderr
index 53c22fcdb4c0..f56489c0b4b7 100644
--- a/src/tools/clippy/tests/ui/multi_assignments.stderr
+++ b/src/tools/clippy/tests/ui/multi_assignments.stderr
@@ -20,19 +20,19 @@ LL |     a = b = c = d;
    |         ^^^^^^^^^
 
 error: assignments don't nest intuitively
-  --> tests/ui/multi_assignments.rs:10:5
+  --> tests/ui/multi_assignments.rs:11:5
    |
 LL |     a = b = { c };
    |     ^^^^^^^^^^^^^
 
 error: assignments don't nest intuitively
-  --> tests/ui/multi_assignments.rs:12:5
+  --> tests/ui/multi_assignments.rs:14:5
    |
 LL |     a = { b = c };
    |     ^^^^^^^^^^^^^
 
 error: assignments don't nest intuitively
-  --> tests/ui/multi_assignments.rs:14:5
+  --> tests/ui/multi_assignments.rs:17:5
    |
 LL |     a = (b = c);
    |     ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/multiple_bound_locations.rs b/src/tools/clippy/tests/ui/multiple_bound_locations.rs
index de9d994782ec..95b269d8935d 100644
--- a/src/tools/clippy/tests/ui/multiple_bound_locations.rs
+++ b/src/tools/clippy/tests/ui/multiple_bound_locations.rs
@@ -1,21 +1,21 @@
 #![warn(clippy::multiple_bound_locations)]
 
 fn ty<F: std::fmt::Debug>(a: F)
-//~^ ERROR: bound is defined in more than one place
+//~^ multiple_bound_locations
 where
     F: Sized,
 {
 }
 
 fn lifetime<'a, 'b: 'a, 'c>(a: &'b str, b: &'a str, c: &'c str)
-//~^ ERROR: bound is defined in more than one place
+//~^ multiple_bound_locations
 where
     'b: 'c,
 {
 }
 
 fn ty_pred<F: Sized>()
-//~^ ERROR: bound is defined in more than one place
+//~^ multiple_bound_locations
 where
     for<'a> F: Send + 'a,
 {
@@ -25,21 +25,21 @@ struct B;
 
 impl B {
     fn ty<F: std::fmt::Debug>(a: F)
-    //~^ ERROR: bound is defined in more than one place
+    //~^ multiple_bound_locations
     where
         F: Sized,
     {
     }
 
     fn lifetime<'a, 'b: 'a, 'c>(a: &'b str, b: &'a str, c: &'c str)
-    //~^ ERROR: bound is defined in more than one place
+    //~^ multiple_bound_locations
     where
         'b: 'c,
     {
     }
 
     fn ty_pred<F: Sized>()
-    //~^ ERROR: bound is defined in more than one place
+    //~^ multiple_bound_locations
     where
         for<'a> F: Send + 'a,
     {
diff --git a/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.rs b/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.rs
index 87d3517cd5f2..016fd89a7b7a 100644
--- a/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.rs
+++ b/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.rs
@@ -36,6 +36,7 @@ static mut STATIC: i32 = 0;
 
 fn test1() {
     unsafe {
+        //~^ multiple_unsafe_ops_per_block
         STATIC += 1;
         not_very_safe();
     }
@@ -45,6 +46,7 @@ fn test2() {
     let u = U { i: 0 };
 
     unsafe {
+        //~^ multiple_unsafe_ops_per_block
         drop(u.u);
         *raw_ptr();
     }
@@ -52,6 +54,7 @@ fn test2() {
 
 fn test3() {
     unsafe {
+        //~^ multiple_unsafe_ops_per_block
         asm!("nop");
         sample.not_very_safe();
         STATIC = 0;
@@ -61,6 +64,7 @@ fn test3() {
 fn test_all() {
     let u = U { i: 0 };
     unsafe {
+        //~^ multiple_unsafe_ops_per_block
         drop(u.u);
         drop(STATIC);
         sample.not_very_safe();
@@ -105,6 +109,7 @@ fn correct3() {
 
 unsafe fn read_char_bad(ptr: *const u8) -> char {
     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
+    //~^ multiple_unsafe_ops_per_block
 }
 
 // no lint
@@ -123,6 +128,7 @@ fn issue10259() {
 
 fn _fn_ptr(x: unsafe fn()) {
     unsafe {
+        //~^ multiple_unsafe_ops_per_block
         x();
         x();
     }
@@ -134,6 +140,7 @@ fn _assoc_const() {
     }
     fn _f<T: X>() {
         unsafe {
+            //~^ multiple_unsafe_ops_per_block
             T::X();
             T::X();
         }
@@ -144,6 +151,7 @@ fn _field_fn_ptr(x: unsafe fn()) {
     struct X(unsafe fn());
     let x = X(x);
     unsafe {
+        //~^ multiple_unsafe_ops_per_block
         x.0();
         x.0();
     }
diff --git a/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.stderr b/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.stderr
index a9417a9ef91c..3130cecc2525 100644
--- a/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.stderr
+++ b/src/tools/clippy/tests/ui/multiple_unsafe_ops_per_block.stderr
@@ -2,18 +2,19 @@ error: this `unsafe` block contains 2 unsafe operations, expected only one
   --> tests/ui/multiple_unsafe_ops_per_block.rs:38:5
    |
 LL | /     unsafe {
+LL | |
 LL | |         STATIC += 1;
 LL | |         not_very_safe();
 LL | |     }
    | |_____^
    |
 note: modification of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:39:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:40:9
    |
 LL |         STATIC += 1;
    |         ^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:40:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:41:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
@@ -21,29 +22,31 @@ LL |         not_very_safe();
    = help: to override `-D warnings` add `#[allow(clippy::multiple_unsafe_ops_per_block)]`
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:47:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:48:5
    |
 LL | /     unsafe {
+LL | |
 LL | |         drop(u.u);
 LL | |         *raw_ptr();
 LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:48:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:50:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:49:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:51:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 3 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:54:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:56:5
    |
 LL | /     unsafe {
+LL | |
 LL | |         asm!("nop");
 LL | |         sample.not_very_safe();
 LL | |         STATIC = 0;
@@ -51,137 +54,140 @@ LL | |     }
    | |_____^
    |
 note: inline assembly used here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:55:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:58:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 note: unsafe method call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:56:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:59:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: modification of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:57:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:60:9
    |
 LL |         STATIC = 0;
    |         ^^^^^^^^^^
 
 error: this `unsafe` block contains 6 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:63:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:66:5
    |
 LL | /     unsafe {
+LL | |
 LL | |         drop(u.u);
 LL | |         drop(STATIC);
-LL | |         sample.not_very_safe();
 ...  |
 LL | |         asm!("nop");
 LL | |     }
    | |_____^
    |
 note: union field access occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:64:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:68:14
    |
 LL |         drop(u.u);
    |              ^^^
 note: access of a mutable static occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:65:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:69:14
    |
 LL |         drop(STATIC);
    |              ^^^^^^
 note: unsafe method call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:66:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:70:9
    |
 LL |         sample.not_very_safe();
    |         ^^^^^^^^^^^^^^^^^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:67:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:71:9
    |
 LL |         not_very_safe();
    |         ^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:68:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:72:9
    |
 LL |         *raw_ptr();
    |         ^^^^^^^^^^
 note: inline assembly used here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:69:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:73:9
    |
 LL |         asm!("nop");
    |         ^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:107:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:5
    |
 LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:107:14
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:14
    |
 LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 note: raw pointer dereference occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:107:39
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:111:39
    |
 LL |     unsafe { char::from_u32_unchecked(*ptr.cast::<u32>()) }
    |                                       ^^^^^^^^^^^^^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:125:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:130:5
    |
 LL | /     unsafe {
+LL | |
 LL | |         x();
 LL | |         x();
 LL | |     }
    | |_____^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:126:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:132:9
    |
 LL |         x();
    |         ^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:127:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:133:9
    |
 LL |         x();
    |         ^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:136:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:142:9
    |
 LL | /         unsafe {
+LL | |
 LL | |             T::X();
 LL | |             T::X();
 LL | |         }
    | |_________^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:137:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:144:13
    |
 LL |             T::X();
    |             ^^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:138:13
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:145:13
    |
 LL |             T::X();
    |             ^^^^^^
 
 error: this `unsafe` block contains 2 unsafe operations, expected only one
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:146:5
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:153:5
    |
 LL | /     unsafe {
+LL | |
 LL | |         x.0();
 LL | |         x.0();
 LL | |     }
    | |_____^
    |
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:147:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:155:9
    |
 LL |         x.0();
    |         ^^^^^
 note: unsafe function call occurs here
-  --> tests/ui/multiple_unsafe_ops_per_block.rs:148:9
+  --> tests/ui/multiple_unsafe_ops_per_block.rs:156:9
    |
 LL |         x.0();
    |         ^^^^^
diff --git a/src/tools/clippy/tests/ui/must_use_candidates.fixed b/src/tools/clippy/tests/ui/must_use_candidates.fixed
index 2459af606884..b5d356a50217 100644
--- a/src/tools/clippy/tests/ui/must_use_candidates.fixed
+++ b/src/tools/clippy/tests/ui/must_use_candidates.fixed
@@ -14,11 +14,13 @@ pub struct MyAtomic(AtomicBool);
 pub struct MyPure;
 
 #[must_use] pub fn pure(i: u8) -> u8 {
+    //~^ must_use_candidate
     i
 }
 
 impl MyPure {
     #[must_use] pub fn inherent_pure(&self) -> u8 {
+        //~^ must_use_candidate
         0
     }
 }
@@ -50,6 +52,7 @@ pub fn with_callback<F: Fn(u32) -> bool>(f: &F) -> bool {
 }
 
 #[must_use] pub fn with_marker(_d: std::marker::PhantomData<&mut u32>) -> bool {
+    //~^ must_use_candidate
     true
 }
 
@@ -62,6 +65,7 @@ pub fn atomics(b: &AtomicBool) -> bool {
 }
 
 #[must_use] pub fn rcd(_x: Rc<u32>) -> bool {
+    //~^ must_use_candidate
     true
 }
 
@@ -70,6 +74,7 @@ pub fn rcmut(_x: Rc<&mut u32>) -> bool {
 }
 
 #[must_use] pub fn arcd(_x: Arc<u32>) -> bool {
+    //~^ must_use_candidate
     false
 }
 
diff --git a/src/tools/clippy/tests/ui/must_use_candidates.rs b/src/tools/clippy/tests/ui/must_use_candidates.rs
index 5f9b2449552a..14ea16662fdb 100644
--- a/src/tools/clippy/tests/ui/must_use_candidates.rs
+++ b/src/tools/clippy/tests/ui/must_use_candidates.rs
@@ -14,11 +14,13 @@ pub struct MyAtomic(AtomicBool);
 pub struct MyPure;
 
 pub fn pure(i: u8) -> u8 {
+    //~^ must_use_candidate
     i
 }
 
 impl MyPure {
     pub fn inherent_pure(&self) -> u8 {
+        //~^ must_use_candidate
         0
     }
 }
@@ -50,6 +52,7 @@ pub fn with_callback<F: Fn(u32) -> bool>(f: &F) -> bool {
 }
 
 pub fn with_marker(_d: std::marker::PhantomData<&mut u32>) -> bool {
+    //~^ must_use_candidate
     true
 }
 
@@ -62,6 +65,7 @@ pub fn atomics(b: &AtomicBool) -> bool {
 }
 
 pub fn rcd(_x: Rc<u32>) -> bool {
+    //~^ must_use_candidate
     true
 }
 
@@ -70,6 +74,7 @@ pub fn rcmut(_x: Rc<&mut u32>) -> bool {
 }
 
 pub fn arcd(_x: Arc<u32>) -> bool {
+    //~^ must_use_candidate
     false
 }
 
diff --git a/src/tools/clippy/tests/ui/must_use_candidates.stderr b/src/tools/clippy/tests/ui/must_use_candidates.stderr
index 2117e37866e2..590253d95f9e 100644
--- a/src/tools/clippy/tests/ui/must_use_candidates.stderr
+++ b/src/tools/clippy/tests/ui/must_use_candidates.stderr
@@ -8,25 +8,25 @@ LL | pub fn pure(i: u8) -> u8 {
    = help: to override `-D warnings` add `#[allow(clippy::must_use_candidate)]`
 
 error: this method could have a `#[must_use]` attribute
-  --> tests/ui/must_use_candidates.rs:21:5
+  --> tests/ui/must_use_candidates.rs:22:5
    |
 LL |     pub fn inherent_pure(&self) -> u8 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add the attribute: `#[must_use] pub fn inherent_pure(&self) -> u8`
 
 error: this function could have a `#[must_use]` attribute
-  --> tests/ui/must_use_candidates.rs:52:1
+  --> tests/ui/must_use_candidates.rs:54:1
    |
 LL | pub fn with_marker(_d: std::marker::PhantomData<&mut u32>) -> bool {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add the attribute: `#[must_use] pub fn with_marker(_d: std::marker::PhantomData<&mut u32>) -> bool`
 
 error: this function could have a `#[must_use]` attribute
-  --> tests/ui/must_use_candidates.rs:64:1
+  --> tests/ui/must_use_candidates.rs:67:1
    |
 LL | pub fn rcd(_x: Rc<u32>) -> bool {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add the attribute: `#[must_use] pub fn rcd(_x: Rc<u32>) -> bool`
 
 error: this function could have a `#[must_use]` attribute
-  --> tests/ui/must_use_candidates.rs:72:1
+  --> tests/ui/must_use_candidates.rs:76:1
    |
 LL | pub fn arcd(_x: Arc<u32>) -> bool {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add the attribute: `#[must_use] pub fn arcd(_x: Arc<u32>) -> bool`
diff --git a/src/tools/clippy/tests/ui/must_use_unit.fixed b/src/tools/clippy/tests/ui/must_use_unit.fixed
index b92d9379c904..683754a98c82 100644
--- a/src/tools/clippy/tests/ui/must_use_unit.fixed
+++ b/src/tools/clippy/tests/ui/must_use_unit.fixed
@@ -7,10 +7,13 @@ extern crate proc_macros;
 use proc_macros::external;
 
 pub fn must_use_default() {}
+//~^ must_use_unit
 
 pub fn must_use_unit() -> () {}
+//~^ must_use_unit
 
 pub fn must_use_with_note() {}
+//~^ must_use_unit
 
 fn main() {
     must_use_default();
@@ -23,9 +26,3 @@ fn main() {
         fn foo() {}
     );
 }
-
-#[cfg_attr(all(), deprecated)]
-fn issue_12320() {}
-
-#[cfg_attr(all(), deprecated, doc = "foo")]
-fn issue_12320_2() {}
diff --git a/src/tools/clippy/tests/ui/must_use_unit.rs b/src/tools/clippy/tests/ui/must_use_unit.rs
index c77e72827504..519b8fa36821 100644
--- a/src/tools/clippy/tests/ui/must_use_unit.rs
+++ b/src/tools/clippy/tests/ui/must_use_unit.rs
@@ -8,12 +8,15 @@ use proc_macros::external;
 
 #[must_use]
 pub fn must_use_default() {}
+//~^ must_use_unit
 
 #[must_use]
 pub fn must_use_unit() -> () {}
+//~^ must_use_unit
 
 #[must_use = "With note"]
 pub fn must_use_with_note() {}
+//~^ must_use_unit
 
 fn main() {
     must_use_default();
@@ -26,9 +29,3 @@ fn main() {
         fn foo() {}
     );
 }
-
-#[cfg_attr(all(), must_use, deprecated)]
-fn issue_12320() {}
-
-#[cfg_attr(all(), deprecated, doc = "foo", must_use)]
-fn issue_12320_2() {}
diff --git a/src/tools/clippy/tests/ui/must_use_unit.stderr b/src/tools/clippy/tests/ui/must_use_unit.stderr
index b435568deeab..8f2af0cbd291 100644
--- a/src/tools/clippy/tests/ui/must_use_unit.stderr
+++ b/src/tools/clippy/tests/ui/must_use_unit.stderr
@@ -10,7 +10,7 @@ LL | pub fn must_use_default() {}
    = help: to override `-D warnings` add `#[allow(clippy::must_use_unit)]`
 
 error: this unit-returning function has a `#[must_use]` attribute
-  --> tests/ui/must_use_unit.rs:13:1
+  --> tests/ui/must_use_unit.rs:14:1
    |
 LL | #[must_use]
    | ----------- help: remove the attribute
@@ -18,28 +18,12 @@ LL | pub fn must_use_unit() -> () {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this unit-returning function has a `#[must_use]` attribute
-  --> tests/ui/must_use_unit.rs:16:1
+  --> tests/ui/must_use_unit.rs:18:1
    |
 LL | #[must_use = "With note"]
    | ------------------------- help: remove the attribute
 LL | pub fn must_use_with_note() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: this unit-returning function has a `#[must_use]` attribute
-  --> tests/ui/must_use_unit.rs:31:1
-   |
-LL | #[cfg_attr(all(), must_use, deprecated)]
-   |                   -------------------- help: change these attributes to: `deprecated`
-LL | fn issue_12320() {}
-   | ^^^^^^^^^^^^^^^^
-
-error: this unit-returning function has a `#[must_use]` attribute
-  --> tests/ui/must_use_unit.rs:34:1
-   |
-LL | #[cfg_attr(all(), deprecated, doc = "foo", must_use)]
-   |                   --------------------------------- help: change these attributes to: `deprecated, doc = "foo"`
-LL | fn issue_12320_2() {}
-   | ^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 5 previous errors
+error: aborting due to 3 previous errors
 
diff --git a/src/tools/clippy/tests/ui/must_use_unit_unfixable.rs b/src/tools/clippy/tests/ui/must_use_unit_unfixable.rs
new file mode 100644
index 000000000000..0dba7996bac3
--- /dev/null
+++ b/src/tools/clippy/tests/ui/must_use_unit_unfixable.rs
@@ -0,0 +1,11 @@
+//@no-rustfix
+
+#[cfg_attr(all(), must_use, deprecated)]
+fn issue_12320() {}
+//~^ must_use_unit
+
+#[cfg_attr(all(), deprecated, doc = "foo", must_use)]
+fn issue_12320_2() {}
+//~^ must_use_unit
+
+fn main() {}
diff --git a/src/tools/clippy/tests/ui/must_use_unit_unfixable.stderr b/src/tools/clippy/tests/ui/must_use_unit_unfixable.stderr
new file mode 100644
index 000000000000..087682199afb
--- /dev/null
+++ b/src/tools/clippy/tests/ui/must_use_unit_unfixable.stderr
@@ -0,0 +1,28 @@
+error: this unit-returning function has a `#[must_use]` attribute
+  --> tests/ui/must_use_unit_unfixable.rs:4:1
+   |
+LL | fn issue_12320() {}
+   | ^^^^^^^^^^^^^^^^
+   |
+help: remove `must_use`
+  --> tests/ui/must_use_unit_unfixable.rs:3:19
+   |
+LL | #[cfg_attr(all(), must_use, deprecated)]
+   |                   ^^^^^^^^
+   = note: `-D clippy::must-use-unit` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::must_use_unit)]`
+
+error: this unit-returning function has a `#[must_use]` attribute
+  --> tests/ui/must_use_unit_unfixable.rs:8:1
+   |
+LL | fn issue_12320_2() {}
+   | ^^^^^^^^^^^^^^^^^^
+   |
+help: remove `must_use`
+  --> tests/ui/must_use_unit_unfixable.rs:7:44
+   |
+LL | #[cfg_attr(all(), deprecated, doc = "foo", must_use)]
+   |                                            ^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/src/tools/clippy/tests/ui/mut_from_ref.rs b/src/tools/clippy/tests/ui/mut_from_ref.rs
index 0ab6d77de1e1..b8c10f3eeb8f 100644
--- a/src/tools/clippy/tests/ui/mut_from_ref.rs
+++ b/src/tools/clippy/tests/ui/mut_from_ref.rs
@@ -5,14 +5,15 @@ struct Foo;
 
 impl Foo {
     fn this_wont_hurt_a_bit(&self) -> &mut Foo {
-        //~^ ERROR: mutable borrow from immutable input(s)
+        //~^ mut_from_ref
+
         unsafe { unimplemented!() }
     }
 }
 
 trait Ouch {
     fn ouch(x: &Foo) -> &mut Foo;
-    //~^ ERROR: mutable borrow from immutable input(s)
+    //~^ mut_from_ref
 }
 
 impl Ouch for Foo {
@@ -22,17 +23,20 @@ impl Ouch for Foo {
 }
 
 fn fail(x: &u32) -> &mut u16 {
-    //~^ ERROR: mutable borrow from immutable input(s)
+    //~^ mut_from_ref
+
     unsafe { unimplemented!() }
 }
 
 fn fail_lifetime<'a>(x: &'a u32, y: &mut u32) -> &'a mut u32 {
-    //~^ ERROR: mutable borrow from immutable input(s)
+    //~^ mut_from_ref
+
     unsafe { unimplemented!() }
 }
 
 fn fail_double<'a, 'b>(x: &'a u32, y: &'a u32, z: &'b mut u32) -> &'a mut u32 {
-    //~^ ERROR: mutable borrow from immutable input(s)
+    //~^ mut_from_ref
+
     unsafe { unimplemented!() }
 }
 
@@ -47,7 +51,8 @@ fn also_works<'a>(x: &'a u32, y: &'a mut u32) -> &'a mut u32 {
 }
 
 unsafe fn also_broken(x: &u32) -> &mut u32 {
-    //~^ ERROR: mutable borrow from immutable input(s)
+    //~^ mut_from_ref
+
     unimplemented!()
 }
 
diff --git a/src/tools/clippy/tests/ui/mut_from_ref.stderr b/src/tools/clippy/tests/ui/mut_from_ref.stderr
index 34fe91b5b3ac..8c3c8e0c3d85 100644
--- a/src/tools/clippy/tests/ui/mut_from_ref.stderr
+++ b/src/tools/clippy/tests/ui/mut_from_ref.stderr
@@ -13,61 +13,61 @@ LL |     fn this_wont_hurt_a_bit(&self) -> &mut Foo {
    = help: to override `-D warnings` add `#[allow(clippy::mut_from_ref)]`
 
 error: mutable borrow from immutable input(s)
-  --> tests/ui/mut_from_ref.rs:14:25
+  --> tests/ui/mut_from_ref.rs:15:25
    |
 LL |     fn ouch(x: &Foo) -> &mut Foo;
    |                         ^^^^^^^^
    |
 note: immutable borrow here
-  --> tests/ui/mut_from_ref.rs:14:16
+  --> tests/ui/mut_from_ref.rs:15:16
    |
 LL |     fn ouch(x: &Foo) -> &mut Foo;
    |                ^^^^
 
 error: mutable borrow from immutable input(s)
-  --> tests/ui/mut_from_ref.rs:24:21
+  --> tests/ui/mut_from_ref.rs:25:21
    |
 LL | fn fail(x: &u32) -> &mut u16 {
    |                     ^^^^^^^^
    |
 note: immutable borrow here
-  --> tests/ui/mut_from_ref.rs:24:12
+  --> tests/ui/mut_from_ref.rs:25:12
    |
 LL | fn fail(x: &u32) -> &mut u16 {
    |            ^^^^
 
 error: mutable borrow from immutable input(s)
-  --> tests/ui/mut_from_ref.rs:29:50
+  --> tests/ui/mut_from_ref.rs:31:50
    |
 LL | fn fail_lifetime<'a>(x: &'a u32, y: &mut u32) -> &'a mut u32 {
    |                                                  ^^^^^^^^^^^
    |
 note: immutable borrow here
-  --> tests/ui/mut_from_ref.rs:29:25
+  --> tests/ui/mut_from_ref.rs:31:25
    |
 LL | fn fail_lifetime<'a>(x: &'a u32, y: &mut u32) -> &'a mut u32 {
    |                         ^^^^^^^
 
 error: mutable borrow from immutable input(s)
-  --> tests/ui/mut_from_ref.rs:34:67
+  --> tests/ui/mut_from_ref.rs:37:67
    |
 LL | fn fail_double<'a, 'b>(x: &'a u32, y: &'a u32, z: &'b mut u32) -> &'a mut u32 {
    |                                                                   ^^^^^^^^^^^
    |
 note: immutable borrow here
-  --> tests/ui/mut_from_ref.rs:34:27
+  --> tests/ui/mut_from_ref.rs:37:27
    |
 LL | fn fail_double<'a, 'b>(x: &'a u32, y: &'a u32, z: &'b mut u32) -> &'a mut u32 {
    |                           ^^^^^^^     ^^^^^^^
 
 error: mutable borrow from immutable input(s)
-  --> tests/ui/mut_from_ref.rs:49:35
+  --> tests/ui/mut_from_ref.rs:53:35
    |
 LL | unsafe fn also_broken(x: &u32) -> &mut u32 {
    |                                   ^^^^^^^^
    |
 note: immutable borrow here
-  --> tests/ui/mut_from_ref.rs:49:26
+  --> tests/ui/mut_from_ref.rs:53:26
    |
 LL | unsafe fn also_broken(x: &u32) -> &mut u32 {
    |                          ^^^^
diff --git a/src/tools/clippy/tests/ui/mut_key.rs b/src/tools/clippy/tests/ui/mut_key.rs
index 43ff705c4775..29dc2d020132 100644
--- a/src/tools/clippy/tests/ui/mut_key.rs
+++ b/src/tools/clippy/tests/ui/mut_key.rs
@@ -29,11 +29,12 @@ impl Hash for Key {
 }
 
 fn should_not_take_this_arg(m: &mut HashMap<Key, usize>, _n: usize) -> HashSet<Key> {
-    //~^ ERROR: mutable key type
-    //~| NOTE: `-D clippy::mutable-key-type` implied by `-D warnings`
-    //~| ERROR: mutable key type
+    //~^ mutable_key_type
+    //~| mutable_key_type
+
     let _other: HashMap<Key, bool> = HashMap::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     m.keys().cloned().collect()
 }
 
@@ -61,7 +62,7 @@ fn generics_are_ok_too<K>(_m: &mut HashSet<K>) {
 fn tuples<U>(_m: &mut HashMap<((), U), ()>) {}
 
 fn tuples_bad<U>(_m: &mut HashMap<(Key, U), bool>) {}
-//~^ ERROR: mutable key type
+//~^ mutable_key_type
 
 fn main() {
     let _ = should_not_take_this_arg(&mut HashMap::new(), 1);
@@ -74,29 +75,39 @@ fn main() {
     raw_mut_ptr_is_ok(&mut HashMap::new());
 
     let _map = HashMap::<Cell<usize>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<&mut Cell<usize>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     // Collection types from `std` who's impl of `Hash` or `Ord` delegate their type parameters
     let _map = HashMap::<Vec<Cell<usize>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<BTreeMap<Cell<usize>, ()>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<BTreeMap<(), Cell<usize>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<BTreeSet<Cell<usize>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<Option<Cell<usize>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<Option<Vec<Cell<usize>>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     // Smart pointers from `std` who's impl of `Hash` or `Ord` delegate their type parameters
     let _map = HashMap::<Box<Cell<usize>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<Rc<Cell<usize>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
+
     let _map = HashMap::<Arc<Cell<usize>>, usize>::new();
-    //~^ ERROR: mutable key type
+    //~^ mutable_key_type
 
     // Not interior mutability
     let _map = HashMap::<&mut usize, usize>::new();
diff --git a/src/tools/clippy/tests/ui/mut_key.stderr b/src/tools/clippy/tests/ui/mut_key.stderr
index 8698ed4fd678..0d504584fbae 100644
--- a/src/tools/clippy/tests/ui/mut_key.stderr
+++ b/src/tools/clippy/tests/ui/mut_key.stderr
@@ -31,7 +31,7 @@ LL |     let _other: HashMap<Key, bool> = HashMap::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:63:22
+  --> tests/ui/mut_key.rs:64:22
    |
 LL | fn tuples_bad<U>(_m: &mut HashMap<(Key, U), bool>) {}
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -42,7 +42,7 @@ LL | fn tuples_bad<U>(_m: &mut HashMap<(Key, U), bool>) {}
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:76:5
+  --> tests/ui/mut_key.rs:77:5
    |
 LL |     let _map = HashMap::<Cell<usize>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -51,7 +51,7 @@ LL |     let _map = HashMap::<Cell<usize>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:78:5
+  --> tests/ui/mut_key.rs:80:5
    |
 LL |     let _map = HashMap::<&mut Cell<usize>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL |     let _map = HashMap::<&mut Cell<usize>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:81:5
+  --> tests/ui/mut_key.rs:84:5
    |
 LL |     let _map = HashMap::<Vec<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +71,7 @@ LL |     let _map = HashMap::<Vec<Cell<usize>>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:83:5
+  --> tests/ui/mut_key.rs:87:5
    |
 LL |     let _map = HashMap::<BTreeMap<Cell<usize>, ()>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     let _map = HashMap::<BTreeMap<Cell<usize>, ()>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:85:5
+  --> tests/ui/mut_key.rs:90:5
    |
 LL |     let _map = HashMap::<BTreeMap<(), Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -91,7 +91,7 @@ LL |     let _map = HashMap::<BTreeMap<(), Cell<usize>>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:87:5
+  --> tests/ui/mut_key.rs:93:5
    |
 LL |     let _map = HashMap::<BTreeSet<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -101,7 +101,7 @@ LL |     let _map = HashMap::<BTreeSet<Cell<usize>>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:89:5
+  --> tests/ui/mut_key.rs:96:5
    |
 LL |     let _map = HashMap::<Option<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -111,7 +111,7 @@ LL |     let _map = HashMap::<Option<Cell<usize>>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:91:5
+  --> tests/ui/mut_key.rs:99:5
    |
 LL |     let _map = HashMap::<Option<Vec<Cell<usize>>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -122,7 +122,7 @@ LL |     let _map = HashMap::<Option<Vec<Cell<usize>>>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:94:5
+  --> tests/ui/mut_key.rs:103:5
    |
 LL |     let _map = HashMap::<Box<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     let _map = HashMap::<Box<Cell<usize>>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:96:5
+  --> tests/ui/mut_key.rs:106:5
    |
 LL |     let _map = HashMap::<Rc<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -142,7 +142,7 @@ LL |     let _map = HashMap::<Rc<Cell<usize>>, usize>::new();
    = note: ... because it contains `UnsafeCell<usize>`, which has interior mutability
 
 error: mutable key type
-  --> tests/ui/mut_key.rs:98:5
+  --> tests/ui/mut_key.rs:109:5
    |
 LL |     let _map = HashMap::<Arc<Cell<usize>>, usize>::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/mut_mut.rs b/src/tools/clippy/tests/ui/mut_mut.rs
index 4c45bc980265..bbcdbc89b6a4 100644
--- a/src/tools/clippy/tests/ui/mut_mut.rs
+++ b/src/tools/clippy/tests/ui/mut_mut.rs
@@ -13,6 +13,7 @@ extern crate proc_macros;
 use proc_macros::{external, inline_macros};
 
 fn fun(x: &mut &mut u32) -> bool {
+    //~^ mut_mut
     **x > 0
 }
 
@@ -30,21 +31,29 @@ macro_rules! mut_ptr {
 #[inline_macros]
 fn main() {
     let mut x = &mut &mut 1u32;
+    //~^ mut_mut
     {
         let mut y = &mut x;
+        //~^ mut_mut
     }
 
     if fun(x) {
         let y: &mut &mut u32 = &mut &mut 2;
+        //~^ mut_mut
+        //~| mut_mut
         **y + **x;
     }
 
     if fun(x) {
         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
+        //~^ mut_mut
+        //~| mut_mut
+        //~| mut_mut
         ***y + **x;
     }
 
     let mut z = inline!(&mut $(&mut 3u32));
+    //~^ mut_mut
 }
 
 fn issue939() {
diff --git a/src/tools/clippy/tests/ui/mut_mut.stderr b/src/tools/clippy/tests/ui/mut_mut.stderr
index 42853fdc008c..74b0c9ba145a 100644
--- a/src/tools/clippy/tests/ui/mut_mut.stderr
+++ b/src/tools/clippy/tests/ui/mut_mut.stderr
@@ -8,13 +8,13 @@ LL | fn fun(x: &mut &mut u32) -> bool {
    = help: to override `-D warnings` add `#[allow(clippy::mut_mut)]`
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:32:17
+  --> tests/ui/mut_mut.rs:33:17
    |
 LL |     let mut x = &mut &mut 1u32;
    |                 ^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:47:25
+  --> tests/ui/mut_mut.rs:55:25
    |
 LL |     let mut z = inline!(&mut $(&mut 3u32));
    |                         ^
@@ -22,37 +22,37 @@ LL |     let mut z = inline!(&mut $(&mut 3u32));
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this expression mutably borrows a mutable reference. Consider reborrowing
-  --> tests/ui/mut_mut.rs:34:21
+  --> tests/ui/mut_mut.rs:36:21
    |
 LL |         let mut y = &mut x;
    |                     ^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:38:32
+  --> tests/ui/mut_mut.rs:41:32
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                                ^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:38:16
+  --> tests/ui/mut_mut.rs:41:16
    |
 LL |         let y: &mut &mut u32 = &mut &mut 2;
    |                ^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:43:37
+  --> tests/ui/mut_mut.rs:48:37
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                                     ^^^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:43:16
+  --> tests/ui/mut_mut.rs:48:16
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                ^^^^^^^^^^^^^^^^^^
 
 error: generally you want to avoid `&mut &mut _` if possible
-  --> tests/ui/mut_mut.rs:43:21
+  --> tests/ui/mut_mut.rs:48:21
    |
 LL |         let y: &mut &mut &mut u32 = &mut &mut &mut 2;
    |                     ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/mut_mutex_lock.fixed b/src/tools/clippy/tests/ui/mut_mutex_lock.fixed
index 29c5a27cb624..5790ee8c1b02 100644
--- a/src/tools/clippy/tests/ui/mut_mutex_lock.fixed
+++ b/src/tools/clippy/tests/ui/mut_mutex_lock.fixed
@@ -8,11 +8,13 @@ fn mut_mutex_lock() {
     let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
 
     let mut value = value_mutex.get_mut().unwrap();
+    //~^ mut_mutex_lock
     *value += 1;
 
     let mut value_mutex = Mutex::new(42_u8);
     let mut_ref_mut_ref_mutex = &mut &mut value_mutex;
     let mut value = mut_ref_mut_ref_mutex.get_mut().unwrap();
+    //~^ mut_mutex_lock
     *value += 1;
 }
 
diff --git a/src/tools/clippy/tests/ui/mut_mutex_lock.rs b/src/tools/clippy/tests/ui/mut_mutex_lock.rs
index fcdb3ff97dbc..7286afac823b 100644
--- a/src/tools/clippy/tests/ui/mut_mutex_lock.rs
+++ b/src/tools/clippy/tests/ui/mut_mutex_lock.rs
@@ -8,11 +8,13 @@ fn mut_mutex_lock() {
     let value_mutex = Arc::get_mut(&mut value_rc).unwrap();
 
     let mut value = value_mutex.lock().unwrap();
+    //~^ mut_mutex_lock
     *value += 1;
 
     let mut value_mutex = Mutex::new(42_u8);
     let mut_ref_mut_ref_mutex = &mut &mut value_mutex;
     let mut value = mut_ref_mut_ref_mutex.lock().unwrap();
+    //~^ mut_mutex_lock
     *value += 1;
 }
 
diff --git a/src/tools/clippy/tests/ui/mut_mutex_lock.stderr b/src/tools/clippy/tests/ui/mut_mutex_lock.stderr
index 92601c4c6121..67543c73c6ee 100644
--- a/src/tools/clippy/tests/ui/mut_mutex_lock.stderr
+++ b/src/tools/clippy/tests/ui/mut_mutex_lock.stderr
@@ -8,7 +8,7 @@ LL |     let mut value = value_mutex.lock().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::mut_mutex_lock)]`
 
 error: calling `&mut Mutex::lock` unnecessarily locks an exclusive (mutable) reference
-  --> tests/ui/mut_mutex_lock.rs:15:43
+  --> tests/ui/mut_mutex_lock.rs:16:43
    |
 LL |     let mut value = mut_ref_mut_ref_mutex.lock().unwrap();
    |                                           ^^^^ help: change this to: `get_mut`
diff --git a/src/tools/clippy/tests/ui/mut_range_bound.rs b/src/tools/clippy/tests/ui/mut_range_bound.rs
index 7aebbf4981ee..107a6229b86d 100644
--- a/src/tools/clippy/tests/ui/mut_range_bound.rs
+++ b/src/tools/clippy/tests/ui/mut_range_bound.rs
@@ -6,8 +6,7 @@ fn mut_range_bound_upper() {
     let mut m = 4;
     for i in 0..m {
         m = 5;
-        //~^ ERROR: attempt to mutate range bound within loop
-        //~| NOTE: the range of the loop is unchanged
+        //~^ mut_range_bound
     }
 }
 
@@ -15,8 +14,7 @@ fn mut_range_bound_lower() {
     let mut m = 4;
     for i in m..10 {
         m *= 2;
-        //~^ ERROR: attempt to mutate range bound within loop
-        //~| NOTE: the range of the loop is unchanged
+        //~^ mut_range_bound
     }
 }
 
@@ -25,11 +23,10 @@ fn mut_range_bound_both() {
     let mut n = 6;
     for i in m..n {
         m = 5;
-        //~^ ERROR: attempt to mutate range bound within loop
-        //~| NOTE: the range of the loop is unchanged
+        //~^ mut_range_bound
+
         n = 7;
-        //~^ ERROR: attempt to mutate range bound within loop
-        //~| NOTE: the range of the loop is unchanged
+        //~^ mut_range_bound
     }
 }
 
@@ -44,8 +41,8 @@ fn mut_borrow_range_bound() {
     let mut m = 4;
     for i in 0..m {
         let n = &mut m;
-        //~^ ERROR: attempt to mutate range bound within loop
-        //~| NOTE: the range of the loop is unchanged
+        //~^ mut_range_bound
+
         *n += 1;
     }
 }
@@ -79,8 +76,8 @@ fn mut_range_bound_no_immediate_break() {
     for i in 0..m {
         // warning because it is not immediately followed by break
         m = 2;
-        //~^ ERROR: attempt to mutate range bound within loop
-        //~| NOTE: the range of the loop is unchanged
+        //~^ mut_range_bound
+
         if m == 4 {
             break;
         }
@@ -91,8 +88,8 @@ fn mut_range_bound_no_immediate_break() {
         if n == 4 {
             // FIXME: warning because it is not immediately followed by break
             n = 1;
-            //~^ ERROR: attempt to mutate range bound within loop
-            //~| NOTE: the range of the loop is unchanged
+            //~^ mut_range_bound
+
             let _ = 2;
             break;
         }
diff --git a/src/tools/clippy/tests/ui/mut_range_bound.stderr b/src/tools/clippy/tests/ui/mut_range_bound.stderr
index 6f93b0ebe6fc..3aae6e2dca6d 100644
--- a/src/tools/clippy/tests/ui/mut_range_bound.stderr
+++ b/src/tools/clippy/tests/ui/mut_range_bound.stderr
@@ -9,7 +9,7 @@ LL |         m = 5;
    = help: to override `-D warnings` add `#[allow(clippy::mut_range_bound)]`
 
 error: attempt to mutate range bound within loop
-  --> tests/ui/mut_range_bound.rs:17:9
+  --> tests/ui/mut_range_bound.rs:16:9
    |
 LL |         m *= 2;
    |         ^
@@ -17,7 +17,7 @@ LL |         m *= 2;
    = note: the range of the loop is unchanged
 
 error: attempt to mutate range bound within loop
-  --> tests/ui/mut_range_bound.rs:27:9
+  --> tests/ui/mut_range_bound.rs:25:9
    |
 LL |         m = 5;
    |         ^
@@ -25,7 +25,7 @@ LL |         m = 5;
    = note: the range of the loop is unchanged
 
 error: attempt to mutate range bound within loop
-  --> tests/ui/mut_range_bound.rs:30:9
+  --> tests/ui/mut_range_bound.rs:28:9
    |
 LL |         n = 7;
    |         ^
@@ -33,7 +33,7 @@ LL |         n = 7;
    = note: the range of the loop is unchanged
 
 error: attempt to mutate range bound within loop
-  --> tests/ui/mut_range_bound.rs:46:22
+  --> tests/ui/mut_range_bound.rs:43:22
    |
 LL |         let n = &mut m;
    |                      ^
@@ -41,7 +41,7 @@ LL |         let n = &mut m;
    = note: the range of the loop is unchanged
 
 error: attempt to mutate range bound within loop
-  --> tests/ui/mut_range_bound.rs:81:9
+  --> tests/ui/mut_range_bound.rs:78:9
    |
 LL |         m = 2;
    |         ^
@@ -49,7 +49,7 @@ LL |         m = 2;
    = note: the range of the loop is unchanged
 
 error: attempt to mutate range bound within loop
-  --> tests/ui/mut_range_bound.rs:93:13
+  --> tests/ui/mut_range_bound.rs:90:13
    |
 LL |             n = 1;
    |             ^
diff --git a/src/tools/clippy/tests/ui/mut_reference.rs b/src/tools/clippy/tests/ui/mut_reference.rs
index 1d7faaa5e75e..f664c373cdc3 100644
--- a/src/tools/clippy/tests/ui/mut_reference.rs
+++ b/src/tools/clippy/tests/ui/mut_reference.rs
@@ -28,16 +28,16 @@ impl MyStruct {
 fn main() {
     // Functions
     takes_an_immutable_reference(&mut 42);
-    //~^ ERROR: the function `takes_an_immutable_reference` doesn't need a mutable referen
-    //~| NOTE: `-D clippy::unnecessary-mut-passed` implied by `-D warnings`
+    //~^ unnecessary_mut_passed
+
     let as_ptr: fn(&i32) = takes_an_immutable_reference;
     as_ptr(&mut 42);
-    //~^ ERROR: the function `as_ptr` doesn't need a mutable reference
+    //~^ unnecessary_mut_passed
 
     // Methods
     let my_struct = MyStruct;
     my_struct.takes_an_immutable_reference(&mut 42);
-    //~^ ERROR: the method `takes_an_immutable_reference` doesn't need a mutable reference
+    //~^ unnecessary_mut_passed
 
     // No error
 
diff --git a/src/tools/clippy/tests/ui/mutex_atomic.rs b/src/tools/clippy/tests/ui/mutex_atomic.rs
index 3a51538b7424..80a712a9286a 100644
--- a/src/tools/clippy/tests/ui/mutex_atomic.rs
+++ b/src/tools/clippy/tests/ui/mutex_atomic.rs
@@ -6,32 +6,40 @@
 fn main() {
     use std::sync::Mutex;
     Mutex::new(true);
-    //~^ ERROR: consider using an `AtomicBool` instead of a `Mutex` here; if you just want
-    //~| NOTE: `-D clippy::mutex-atomic` implied by `-D warnings`
+    //~^ mutex_atomic
+
     Mutex::new(5usize);
-    //~^ ERROR: consider using an `AtomicUsize` instead of a `Mutex` here; if you just wan
+    //~^ mutex_atomic
+
     Mutex::new(9isize);
-    //~^ ERROR: consider using an `AtomicIsize` instead of a `Mutex` here; if you just wan
+    //~^ mutex_atomic
+
     let mut x = 4u32;
     Mutex::new(&x as *const u32);
-    //~^ ERROR: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want
+    //~^ mutex_atomic
+
     Mutex::new(&mut x as *mut u32);
-    //~^ ERROR: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want
+    //~^ mutex_atomic
+
     Mutex::new(0u32);
-    //~^ ERROR: consider using an `AtomicU32` instead of a `Mutex` here; if you just wan
-    //~| NOTE: `-D clippy::mutex-integer` implied by `-D warnings`
+    //~^ mutex_integer
+
     Mutex::new(0i32);
-    //~^ ERROR: consider using an `AtomicI32` instead of a `Mutex` here; if you just wan
+    //~^ mutex_integer
+
     Mutex::new(0f32); // there are no float atomics, so this should not lint
     Mutex::new(0u8);
-    //~^ ERROR: consider using an `AtomicU8` instead of a `Mutex` here; if you just wan
+    //~^ mutex_integer
+
     Mutex::new(0i16);
-    //~^ ERROR: consider using an `AtomicI16` instead of a `Mutex` here; if you just wan
+    //~^ mutex_integer
+
     let _x: Mutex<i8> = Mutex::new(0);
-    //~^ ERROR: consider using an `AtomicI8` instead of a `Mutex` here; if you just wan
+    //~^ mutex_integer
+
     const X: i64 = 0;
     Mutex::new(X);
-    //~^ ERROR: consider using an `AtomicI64` instead of a `Mutex` here; if you just wan
+    //~^ mutex_integer
 
     // there are no 128 atomics, so these two should not lint
     {
diff --git a/src/tools/clippy/tests/ui/mutex_atomic.stderr b/src/tools/clippy/tests/ui/mutex_atomic.stderr
index 683a7b939db3..838fc1d7c36e 100644
--- a/src/tools/clippy/tests/ui/mutex_atomic.stderr
+++ b/src/tools/clippy/tests/ui/mutex_atomic.stderr
@@ -14,25 +14,25 @@ LL |     Mutex::new(5usize);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicIsize` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:13:5
+  --> tests/ui/mutex_atomic.rs:14:5
    |
 LL |     Mutex::new(9isize);
    |     ^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:16:5
+  --> tests/ui/mutex_atomic.rs:18:5
    |
 LL |     Mutex::new(&x as *const u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicPtr` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:18:5
+  --> tests/ui/mutex_atomic.rs:21:5
    |
 LL |     Mutex::new(&mut x as *mut u32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicU32` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:20:5
+  --> tests/ui/mutex_atomic.rs:24:5
    |
 LL |     Mutex::new(0u32);
    |     ^^^^^^^^^^^^^^^^
@@ -41,31 +41,31 @@ LL |     Mutex::new(0u32);
    = help: to override `-D warnings` add `#[allow(clippy::mutex_integer)]`
 
 error: consider using an `AtomicI32` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:23:5
+  --> tests/ui/mutex_atomic.rs:27:5
    |
 LL |     Mutex::new(0i32);
    |     ^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicU8` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:26:5
+  --> tests/ui/mutex_atomic.rs:31:5
    |
 LL |     Mutex::new(0u8);
    |     ^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicI16` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:28:5
+  --> tests/ui/mutex_atomic.rs:34:5
    |
 LL |     Mutex::new(0i16);
    |     ^^^^^^^^^^^^^^^^
 
 error: consider using an `AtomicI8` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:30:25
+  --> tests/ui/mutex_atomic.rs:37:25
    |
 LL |     let _x: Mutex<i8> = Mutex::new(0);
    |                         ^^^^^^^^^^^^^
 
 error: consider using an `AtomicI64` instead of a `Mutex` here; if you just want the locking behavior and not the internal type, consider using `Mutex<()>`
-  --> tests/ui/mutex_atomic.rs:33:5
+  --> tests/ui/mutex_atomic.rs:41:5
    |
 LL |     Mutex::new(X);
    |     ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/needless_arbitrary_self_type.fixed b/src/tools/clippy/tests/ui/needless_arbitrary_self_type.fixed
index 530eb77d83d2..adb9096c9f24 100644
--- a/src/tools/clippy/tests/ui/needless_arbitrary_self_type.fixed
+++ b/src/tools/clippy/tests/ui/needless_arbitrary_self_type.fixed
@@ -8,6 +8,7 @@ pub enum ValType {
 
 impl ValType {
     pub fn bad(self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -16,6 +17,7 @@ impl ValType {
     }
 
     pub fn mut_bad(mut self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -24,6 +26,7 @@ impl ValType {
     }
 
     pub fn ref_bad(&self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -32,6 +35,7 @@ impl ValType {
     }
 
     pub fn ref_bad_with_lifetime<'a>(&'a self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -40,6 +44,7 @@ impl ValType {
     }
 
     pub fn mut_ref_bad(&mut self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -48,6 +53,7 @@ impl ValType {
     }
 
     pub fn mut_ref_bad_with_lifetime<'a>(&'a mut self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -66,7 +72,9 @@ impl ValType {
 
 trait Foo<'r#struct> {
     fn f1(&'r#struct self) {}
+    //~^ needless_arbitrary_self_type
     fn f2(&'r#struct mut self) {}
+    //~^ needless_arbitrary_self_type
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/needless_arbitrary_self_type.rs b/src/tools/clippy/tests/ui/needless_arbitrary_self_type.rs
index 5a1ff96a11cc..550546ed24fd 100644
--- a/src/tools/clippy/tests/ui/needless_arbitrary_self_type.rs
+++ b/src/tools/clippy/tests/ui/needless_arbitrary_self_type.rs
@@ -8,6 +8,7 @@ pub enum ValType {
 
 impl ValType {
     pub fn bad(self: Self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -16,6 +17,7 @@ impl ValType {
     }
 
     pub fn mut_bad(mut self: Self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -24,6 +26,7 @@ impl ValType {
     }
 
     pub fn ref_bad(self: &Self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -32,6 +35,7 @@ impl ValType {
     }
 
     pub fn ref_bad_with_lifetime<'a>(self: &'a Self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -40,6 +44,7 @@ impl ValType {
     }
 
     pub fn mut_ref_bad(self: &mut Self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -48,6 +53,7 @@ impl ValType {
     }
 
     pub fn mut_ref_bad_with_lifetime<'a>(self: &'a mut Self) {
+        //~^ needless_arbitrary_self_type
         unimplemented!();
     }
 
@@ -66,7 +72,9 @@ impl ValType {
 
 trait Foo<'r#struct> {
     fn f1(self: &'r#struct Self) {}
+    //~^ needless_arbitrary_self_type
     fn f2(self: &'r#struct mut Self) {}
+    //~^ needless_arbitrary_self_type
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/needless_arbitrary_self_type.stderr b/src/tools/clippy/tests/ui/needless_arbitrary_self_type.stderr
index 7ebbbaa122f5..b5c0aae8310f 100644
--- a/src/tools/clippy/tests/ui/needless_arbitrary_self_type.stderr
+++ b/src/tools/clippy/tests/ui/needless_arbitrary_self_type.stderr
@@ -8,43 +8,43 @@ LL |     pub fn bad(self: Self) {
    = help: to override `-D warnings` add `#[allow(clippy::needless_arbitrary_self_type)]`
 
 error: the type of the `self` parameter does not need to be arbitrary
-  --> tests/ui/needless_arbitrary_self_type.rs:18:20
+  --> tests/ui/needless_arbitrary_self_type.rs:19:20
    |
 LL |     pub fn mut_bad(mut self: Self) {
    |                    ^^^^^^^^^^^^^^ help: consider to change this parameter to: `mut self`
 
 error: the type of the `self` parameter does not need to be arbitrary
-  --> tests/ui/needless_arbitrary_self_type.rs:26:20
+  --> tests/ui/needless_arbitrary_self_type.rs:28:20
    |
 LL |     pub fn ref_bad(self: &Self) {
    |                    ^^^^^^^^^^^ help: consider to change this parameter to: `&self`
 
 error: the type of the `self` parameter does not need to be arbitrary
-  --> tests/ui/needless_arbitrary_self_type.rs:34:38
+  --> tests/ui/needless_arbitrary_self_type.rs:37:38
    |
 LL |     pub fn ref_bad_with_lifetime<'a>(self: &'a Self) {
    |                                      ^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'a self`
 
 error: the type of the `self` parameter does not need to be arbitrary
-  --> tests/ui/needless_arbitrary_self_type.rs:42:24
+  --> tests/ui/needless_arbitrary_self_type.rs:46:24
    |
 LL |     pub fn mut_ref_bad(self: &mut Self) {
    |                        ^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&mut self`
 
 error: the type of the `self` parameter does not need to be arbitrary
-  --> tests/ui/needless_arbitrary_self_type.rs:50:42
+  --> tests/ui/needless_arbitrary_self_type.rs:55:42
    |
 LL |     pub fn mut_ref_bad_with_lifetime<'a>(self: &'a mut Self) {
    |                                          ^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'a mut self`
 
 error: the type of the `self` parameter does not need to be arbitrary
-  --> tests/ui/needless_arbitrary_self_type.rs:68:11
+  --> tests/ui/needless_arbitrary_self_type.rs:74:11
    |
 LL |     fn f1(self: &'r#struct Self) {}
    |           ^^^^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'r#struct self`
 
 error: the type of the `self` parameter does not need to be arbitrary
-  --> tests/ui/needless_arbitrary_self_type.rs:69:11
+  --> tests/ui/needless_arbitrary_self_type.rs:76:11
    |
 LL |     fn f2(self: &'r#struct mut Self) {}
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider to change this parameter to: `&'r#struct mut self`
diff --git a/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.fixed b/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.fixed
index 62a6e5932435..f4ee0a8bd072 100644
--- a/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.fixed
+++ b/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.fixed
@@ -40,6 +40,7 @@ mod issue_6089 {
     impl T2 for S2 {
         #[allow(clippy::needless_lifetimes)]
         fn call_with_mut_self(&mut self) {}
+        //~^ needless_arbitrary_self_type
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.rs b/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.rs
index 00871f9f450c..3f29025c1362 100644
--- a/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.rs
+++ b/src/tools/clippy/tests/ui/needless_arbitrary_self_type_unfixable.rs
@@ -40,6 +40,7 @@ mod issue_6089 {
     impl T2 for S2 {
         #[allow(clippy::needless_lifetimes)]
         fn call_with_mut_self(self: &mut Self) {}
+        //~^ needless_arbitrary_self_type
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/needless_as_bytes.fixed b/src/tools/clippy/tests/ui/needless_as_bytes.fixed
index 74b4ba5be798..9cbc7b9c2651 100644
--- a/src/tools/clippy/tests/ui/needless_as_bytes.fixed
+++ b/src/tools/clippy/tests/ui/needless_as_bytes.fixed
@@ -16,11 +16,13 @@ impl S {
 fn main() {
     if "some string".is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", "some string".len());
         //~^ needless_as_bytes
     }
     if "some string".is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", "some string".len());
         //~^ needless_as_bytes
     }
@@ -28,11 +30,13 @@ fn main() {
     let s = String::from("yet another string");
     if s.is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", s.len());
         //~^ needless_as_bytes
     }
     if s.is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", s.len());
         //~^ needless_as_bytes
     }
diff --git a/src/tools/clippy/tests/ui/needless_as_bytes.rs b/src/tools/clippy/tests/ui/needless_as_bytes.rs
index ffcce60bbbef..7de699647e85 100644
--- a/src/tools/clippy/tests/ui/needless_as_bytes.rs
+++ b/src/tools/clippy/tests/ui/needless_as_bytes.rs
@@ -16,11 +16,13 @@ impl S {
 fn main() {
     if "some string".as_bytes().is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", "some string".as_bytes().len());
         //~^ needless_as_bytes
     }
     if "some string".bytes().is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", "some string".bytes().len());
         //~^ needless_as_bytes
     }
@@ -28,11 +30,13 @@ fn main() {
     let s = String::from("yet another string");
     if s.as_bytes().is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", s.as_bytes().len());
         //~^ needless_as_bytes
     }
     if s.bytes().is_empty() {
         //~^ needless_as_bytes
+
         println!("len = {}", s.bytes().len());
         //~^ needless_as_bytes
     }
diff --git a/src/tools/clippy/tests/ui/needless_as_bytes.stderr b/src/tools/clippy/tests/ui/needless_as_bytes.stderr
index 138c6630ae7d..0eead9815f8a 100644
--- a/src/tools/clippy/tests/ui/needless_as_bytes.stderr
+++ b/src/tools/clippy/tests/ui/needless_as_bytes.stderr
@@ -8,43 +8,43 @@ LL |     if "some string".as_bytes().is_empty() {
    = help: to override `-D warnings` add `#[allow(clippy::needless_as_bytes)]`
 
 error: needless call to `as_bytes`
-  --> tests/ui/needless_as_bytes.rs:19:30
+  --> tests/ui/needless_as_bytes.rs:20:30
    |
 LL |         println!("len = {}", "some string".as_bytes().len());
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: `len()` can be called directly on strings: `"some string".len()`
 
 error: needless call to `bytes`
-  --> tests/ui/needless_as_bytes.rs:22:8
+  --> tests/ui/needless_as_bytes.rs:23:8
    |
 LL |     if "some string".bytes().is_empty() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: `is_empty()` can be called directly on strings: `"some string".is_empty()`
 
 error: needless call to `bytes`
-  --> tests/ui/needless_as_bytes.rs:24:30
+  --> tests/ui/needless_as_bytes.rs:26:30
    |
 LL |         println!("len = {}", "some string".bytes().len());
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: `len()` can be called directly on strings: `"some string".len()`
 
 error: needless call to `as_bytes`
-  --> tests/ui/needless_as_bytes.rs:29:8
+  --> tests/ui/needless_as_bytes.rs:31:8
    |
 LL |     if s.as_bytes().is_empty() {
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: `is_empty()` can be called directly on strings: `s.is_empty()`
 
 error: needless call to `as_bytes`
-  --> tests/ui/needless_as_bytes.rs:31:30
+  --> tests/ui/needless_as_bytes.rs:34:30
    |
 LL |         println!("len = {}", s.as_bytes().len());
    |                              ^^^^^^^^^^^^^^^^^^ help: `len()` can be called directly on strings: `s.len()`
 
 error: needless call to `bytes`
-  --> tests/ui/needless_as_bytes.rs:34:8
+  --> tests/ui/needless_as_bytes.rs:37:8
    |
 LL |     if s.bytes().is_empty() {
    |        ^^^^^^^^^^^^^^^^^^^^ help: `is_empty()` can be called directly on strings: `s.is_empty()`
 
 error: needless call to `bytes`
-  --> tests/ui/needless_as_bytes.rs:36:30
+  --> tests/ui/needless_as_bytes.rs:40:30
    |
 LL |         println!("len = {}", s.bytes().len());
    |                              ^^^^^^^^^^^^^^^ help: `len()` can be called directly on strings: `s.len()`
diff --git a/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed b/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed
index a8176618c1f2..89a3c1474f25 100644
--- a/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed
+++ b/src/tools/clippy/tests/ui/needless_bitwise_bool.fixed
@@ -21,6 +21,7 @@ fn main() {
         println!("true")
     }
     if y && !x {
+        //~^ needless_bitwise_bool
         println!("true")
     }
 
diff --git a/src/tools/clippy/tests/ui/needless_bitwise_bool.rs b/src/tools/clippy/tests/ui/needless_bitwise_bool.rs
index f190eb2b76e7..f5aa7a9f3d9e 100644
--- a/src/tools/clippy/tests/ui/needless_bitwise_bool.rs
+++ b/src/tools/clippy/tests/ui/needless_bitwise_bool.rs
@@ -21,6 +21,7 @@ fn main() {
         println!("true")
     }
     if y & !x {
+        //~^ needless_bitwise_bool
         println!("true")
     }
 
diff --git a/src/tools/clippy/tests/ui/needless_bool/fixable.fixed b/src/tools/clippy/tests/ui/needless_bool/fixable.fixed
index ec63c4fd6a26..0664abf0944d 100644
--- a/src/tools/clippy/tests/ui/needless_bool/fixable.fixed
+++ b/src/tools/clippy/tests/ui/needless_bool/fixable.fixed
@@ -39,17 +39,26 @@ fn main() {
     let x = true;
     let y = false;
     x;
+    //~^^^^^ needless_bool
     !x;
+    //~^^^^^ needless_bool
     !(x && y);
+    //~^^^^^ needless_bool
     let a = 0;
     let b = 1;
 
     a != b;
+    //~^^^^^ needless_bool
     a == b;
+    //~^^^^^ needless_bool
     a >= b;
+    //~^^^^^ needless_bool
     a > b;
+    //~^^^^^ needless_bool
     a <= b;
+    //~^^^^^ needless_bool
     a < b;
+    //~^^^^^ needless_bool
     if x {
         x
     } else {
@@ -74,26 +83,32 @@ fn main() {
 
 fn bool_ret3(x: bool) -> bool {
     return x;
+    //~^^^^^ needless_bool
 }
 
 fn bool_ret4(x: bool) -> bool {
     return !x;
+    //~^^^^^ needless_bool
 }
 
 fn bool_ret5(x: bool, y: bool) -> bool {
     return x && y;
+    //~^^^^^ needless_bool
 }
 
 fn bool_ret6(x: bool, y: bool) -> bool {
     return !(x && y);
+    //~^^^^^ needless_bool
 }
 
 fn needless_bool(x: bool) {
     if x {};
+    //~^ bool_comparison
 }
 
 fn needless_bool2(x: bool) {
     if !x {};
+    //~^ bool_comparison
 }
 
 fn needless_bool3(x: bool) {
@@ -104,7 +119,9 @@ fn needless_bool3(x: bool) {
     }
 
     if x {};
+    //~^ bool_comparison
     if !x {};
+    //~^ bool_comparison
 }
 
 fn needless_bool_in_the_suggestion_wraps_the_predicate_of_if_else_statement_in_brackets() {
@@ -114,6 +131,7 @@ fn needless_bool_in_the_suggestion_wraps_the_predicate_of_if_else_statement_in_b
     let x = if b {
         true
     } else { !returns_bool() };
+    //~^^^^^ needless_bool
 }
 
 unsafe fn no(v: u8) -> u8 {
@@ -123,10 +141,13 @@ unsafe fn no(v: u8) -> u8 {
 #[allow(clippy::unnecessary_operation)]
 fn needless_bool_condition() -> bool {
     (unsafe { no(4) } & 1 != 0);
+    //~^^^^^ needless_bool
     let _brackets_unneeded = unsafe { no(4) } & 1 != 0;
+    //~^ needless_bool
     fn foo() -> bool {
         // parentheses are needed here
         (unsafe { no(4) } & 1 != 0)
+        //~^ needless_bool
     }
 
     foo()
@@ -138,8 +159,11 @@ fn issue12846() {
 
     // parentheses are needed here
     let _x = (a && b).then(|| todo!());
+    //~^ needless_bool
     let _x = (a && b) as u8;
+    //~^ needless_bool
 
     // parentheses are not needed here
     let _x = a.then(|| todo!());
+    //~^ needless_bool
 }
diff --git a/src/tools/clippy/tests/ui/needless_bool/fixable.rs b/src/tools/clippy/tests/ui/needless_bool/fixable.rs
index 8694aa715908..7507a6af408b 100644
--- a/src/tools/clippy/tests/ui/needless_bool/fixable.rs
+++ b/src/tools/clippy/tests/ui/needless_bool/fixable.rs
@@ -43,16 +43,19 @@ fn main() {
     } else {
         false
     };
+    //~^^^^^ needless_bool
     if x {
         false
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if x && y {
         false
     } else {
         true
     };
+    //~^^^^^ needless_bool
     let a = 0;
     let b = 1;
 
@@ -61,31 +64,37 @@ fn main() {
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if a != b {
         false
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if a < b {
         false
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if a <= b {
         false
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if a > b {
         false
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if a >= b {
         false
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if x {
         x
     } else {
@@ -114,6 +123,7 @@ fn bool_ret3(x: bool) -> bool {
     } else {
         return false;
     };
+    //~^^^^^ needless_bool
 }
 
 fn bool_ret4(x: bool) -> bool {
@@ -122,6 +132,7 @@ fn bool_ret4(x: bool) -> bool {
     } else {
         return true;
     };
+    //~^^^^^ needless_bool
 }
 
 fn bool_ret5(x: bool, y: bool) -> bool {
@@ -130,6 +141,7 @@ fn bool_ret5(x: bool, y: bool) -> bool {
     } else {
         return false;
     };
+    //~^^^^^ needless_bool
 }
 
 fn bool_ret6(x: bool, y: bool) -> bool {
@@ -138,14 +150,17 @@ fn bool_ret6(x: bool, y: bool) -> bool {
     } else {
         return true;
     };
+    //~^^^^^ needless_bool
 }
 
 fn needless_bool(x: bool) {
     if x == true {};
+    //~^ bool_comparison
 }
 
 fn needless_bool2(x: bool) {
     if x == false {};
+    //~^ bool_comparison
 }
 
 fn needless_bool3(x: bool) {
@@ -156,7 +171,9 @@ fn needless_bool3(x: bool) {
     }
 
     if x == true {};
+    //~^ bool_comparison
     if x == false {};
+    //~^ bool_comparison
 }
 
 fn needless_bool_in_the_suggestion_wraps_the_predicate_of_if_else_statement_in_brackets() {
@@ -170,6 +187,7 @@ fn needless_bool_in_the_suggestion_wraps_the_predicate_of_if_else_statement_in_b
     } else {
         true
     };
+    //~^^^^^ needless_bool
 }
 
 unsafe fn no(v: u8) -> u8 {
@@ -183,10 +201,13 @@ fn needless_bool_condition() -> bool {
     } else {
         false
     };
+    //~^^^^^ needless_bool
     let _brackets_unneeded = if unsafe { no(4) } & 1 != 0 { true } else { false };
+    //~^ needless_bool
     fn foo() -> bool {
         // parentheses are needed here
         if unsafe { no(4) } & 1 != 0 { true } else { false }
+        //~^ needless_bool
     }
 
     foo()
@@ -198,8 +219,11 @@ fn issue12846() {
 
     // parentheses are needed here
     let _x = if a && b { true } else { false }.then(|| todo!());
+    //~^ needless_bool
     let _x = if a && b { true } else { false } as u8;
+    //~^ needless_bool
 
     // parentheses are not needed here
     let _x = if a { true } else { false }.then(|| todo!());
+    //~^ needless_bool
 }
diff --git a/src/tools/clippy/tests/ui/needless_bool/fixable.stderr b/src/tools/clippy/tests/ui/needless_bool/fixable.stderr
index 99b5b9983448..3f117ee5a502 100644
--- a/src/tools/clippy/tests/ui/needless_bool/fixable.stderr
+++ b/src/tools/clippy/tests/ui/needless_bool/fixable.stderr
@@ -12,7 +12,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::needless_bool)]`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:46:5
+  --> tests/ui/needless_bool/fixable.rs:47:5
    |
 LL | /     if x {
 LL | |         false
@@ -22,7 +22,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:51:5
+  --> tests/ui/needless_bool/fixable.rs:53:5
    |
 LL | /     if x && y {
 LL | |         false
@@ -32,7 +32,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `!(x && y)`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:59:5
+  --> tests/ui/needless_bool/fixable.rs:62:5
    |
 LL | /     if a == b {
 LL | |         false
@@ -42,7 +42,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a != b`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:64:5
+  --> tests/ui/needless_bool/fixable.rs:68:5
    |
 LL | /     if a != b {
 LL | |         false
@@ -52,7 +52,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a == b`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:69:5
+  --> tests/ui/needless_bool/fixable.rs:74:5
    |
 LL | /     if a < b {
 LL | |         false
@@ -62,7 +62,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a >= b`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:74:5
+  --> tests/ui/needless_bool/fixable.rs:80:5
    |
 LL | /     if a <= b {
 LL | |         false
@@ -72,7 +72,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a > b`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:79:5
+  --> tests/ui/needless_bool/fixable.rs:86:5
    |
 LL | /     if a > b {
 LL | |         false
@@ -82,7 +82,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a <= b`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:84:5
+  --> tests/ui/needless_bool/fixable.rs:92:5
    |
 LL | /     if a >= b {
 LL | |         false
@@ -92,7 +92,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `a < b`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:112:5
+  --> tests/ui/needless_bool/fixable.rs:121:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -102,7 +102,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:120:5
+  --> tests/ui/needless_bool/fixable.rs:130:5
    |
 LL | /     if x {
 LL | |         return false;
@@ -112,7 +112,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !x`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:128:5
+  --> tests/ui/needless_bool/fixable.rs:139:5
    |
 LL | /     if x && y {
 LL | |         return true;
@@ -122,7 +122,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return x && y`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:136:5
+  --> tests/ui/needless_bool/fixable.rs:148:5
    |
 LL | /     if x && y {
 LL | |         return false;
@@ -132,7 +132,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `return !(x && y)`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/needless_bool/fixable.rs:144:8
+  --> tests/ui/needless_bool/fixable.rs:157:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
@@ -141,25 +141,25 @@ LL |     if x == true {};
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/needless_bool/fixable.rs:148:8
+  --> tests/ui/needless_bool/fixable.rs:162:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/needless_bool/fixable.rs:158:8
+  --> tests/ui/needless_bool/fixable.rs:173:8
    |
 LL |     if x == true {};
    |        ^^^^^^^^^ help: try simplifying it as shown: `x`
 
 error: equality checks against false can be replaced by a negation
-  --> tests/ui/needless_bool/fixable.rs:159:8
+  --> tests/ui/needless_bool/fixable.rs:175:8
    |
 LL |     if x == false {};
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!x`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:168:12
+  --> tests/ui/needless_bool/fixable.rs:185:12
    |
 LL |       } else if returns_bool() {
    |  ____________^
@@ -170,7 +170,7 @@ LL | |     };
    | |_____^ help: you can reduce it to: `{ !returns_bool() }`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:181:5
+  --> tests/ui/needless_bool/fixable.rs:199:5
    |
 LL | /     if unsafe { no(4) } & 1 != 0 {
 LL | |         true
@@ -180,31 +180,31 @@ LL | |     };
    | |_____^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:186:30
+  --> tests/ui/needless_bool/fixable.rs:205:30
    |
 LL |     let _brackets_unneeded = if unsafe { no(4) } & 1 != 0 { true } else { false };
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `unsafe { no(4) } & 1 != 0`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:189:9
+  --> tests/ui/needless_bool/fixable.rs:209:9
    |
 LL |         if unsafe { no(4) } & 1 != 0 { true } else { false }
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `(unsafe { no(4) } & 1 != 0)`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:200:14
+  --> tests/ui/needless_bool/fixable.rs:221:14
    |
 LL |     let _x = if a && b { true } else { false }.then(|| todo!());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `(a && b)`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:201:14
+  --> tests/ui/needless_bool/fixable.rs:223:14
    |
 LL |     let _x = if a && b { true } else { false } as u8;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `(a && b)`
 
 error: this if-then-else expression returns a bool literal
-  --> tests/ui/needless_bool/fixable.rs:204:14
+  --> tests/ui/needless_bool/fixable.rs:227:14
    |
 LL |     let _x = if a { true } else { false }.then(|| todo!());
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `a`
diff --git a/src/tools/clippy/tests/ui/needless_bool/simple.rs b/src/tools/clippy/tests/ui/needless_bool/simple.rs
index 588bb88f4461..40ffeae6c56f 100644
--- a/src/tools/clippy/tests/ui/needless_bool/simple.rs
+++ b/src/tools/clippy/tests/ui/needless_bool/simple.rs
@@ -16,11 +16,13 @@ fn main() {
     } else {
         true
     };
+    //~^^^^^ needless_bool
     if x {
         false
     } else {
         false
     };
+    //~^^^^^ needless_bool
     if x {
         x
     } else {
@@ -36,6 +38,7 @@ fn bool_ret(x: bool) -> bool {
     } else {
         return true;
     };
+    //~^^^^^ needless_bool
 }
 
 fn bool_ret2(x: bool) -> bool {
@@ -44,4 +47,5 @@ fn bool_ret2(x: bool) -> bool {
     } else {
         return false;
     };
+    //~^^^^^ needless_bool
 }
diff --git a/src/tools/clippy/tests/ui/needless_bool/simple.stderr b/src/tools/clippy/tests/ui/needless_bool/simple.stderr
index bf30a56f43e7..077e9b5df47c 100644
--- a/src/tools/clippy/tests/ui/needless_bool/simple.stderr
+++ b/src/tools/clippy/tests/ui/needless_bool/simple.stderr
@@ -12,7 +12,7 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::needless_bool)]`
 
 error: this if-then-else expression will always return false
-  --> tests/ui/needless_bool/simple.rs:19:5
+  --> tests/ui/needless_bool/simple.rs:20:5
    |
 LL | /     if x {
 LL | |         false
@@ -22,7 +22,7 @@ LL | |     };
    | |_____^
 
 error: this if-then-else expression will always return true
-  --> tests/ui/needless_bool/simple.rs:34:5
+  --> tests/ui/needless_bool/simple.rs:36:5
    |
 LL | /     if x {
 LL | |         return true;
@@ -32,7 +32,7 @@ LL | |     };
    | |_____^
 
 error: this if-then-else expression will always return false
-  --> tests/ui/needless_bool/simple.rs:42:5
+  --> tests/ui/needless_bool/simple.rs:45:5
    |
 LL | /     if x {
 LL | |         return false;
diff --git a/src/tools/clippy/tests/ui/needless_bool_assign.fixed b/src/tools/clippy/tests/ui/needless_bool_assign.fixed
index 7b10fe78c681..e0c717ecda21 100644
--- a/src/tools/clippy/tests/ui/needless_bool_assign.fixed
+++ b/src/tools/clippy/tests/ui/needless_bool_assign.fixed
@@ -11,7 +11,9 @@ fn main() {
     };
     let mut a = Data { field: false };
     a.field = random() && random();
+    //~^^^^^ needless_bool_assign
     a.field = !(random() && random());
+    //~^^^^^ needless_bool_assign
     // Do not lint…
     if random() {
         a.field = false;
@@ -22,6 +24,8 @@ fn main() {
     // This one also triggers lint `clippy::if_same_then_else`
     // which does not suggest a rewrite.
     random(); a.field = true;
+    //~^^^^^ if_same_then_else
+    //~| needless_bool_assign
     let mut b = false;
     if random() {
         a.field = false;
diff --git a/src/tools/clippy/tests/ui/needless_bool_assign.rs b/src/tools/clippy/tests/ui/needless_bool_assign.rs
index 85c0a5777fee..3e4fecefa785 100644
--- a/src/tools/clippy/tests/ui/needless_bool_assign.rs
+++ b/src/tools/clippy/tests/ui/needless_bool_assign.rs
@@ -15,11 +15,13 @@ fn main() {
     } else {
         a.field = false
     }
+    //~^^^^^ needless_bool_assign
     if random() && random() {
         a.field = false;
     } else {
         a.field = true
     }
+    //~^^^^^ needless_bool_assign
     // Do not lint…
     if random() {
         a.field = false;
@@ -34,6 +36,8 @@ fn main() {
     } else {
         a.field = true;
     }
+    //~^^^^^ if_same_then_else
+    //~| needless_bool_assign
     let mut b = false;
     if random() {
         a.field = false;
diff --git a/src/tools/clippy/tests/ui/needless_bool_assign.stderr b/src/tools/clippy/tests/ui/needless_bool_assign.stderr
index 2d80dded39c3..f33a4bc0c592 100644
--- a/src/tools/clippy/tests/ui/needless_bool_assign.stderr
+++ b/src/tools/clippy/tests/ui/needless_bool_assign.stderr
@@ -12,7 +12,7 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::needless_bool_assign)]`
 
 error: this if-then-else expression assigns a bool literal
-  --> tests/ui/needless_bool_assign.rs:18:5
+  --> tests/ui/needless_bool_assign.rs:19:5
    |
 LL | /     if random() && random() {
 LL | |         a.field = false;
@@ -22,7 +22,7 @@ LL | |     }
    | |_____^ help: you can reduce it to: `a.field = !(random() && random());`
 
 error: this if-then-else expression assigns a bool literal
-  --> tests/ui/needless_bool_assign.rs:32:5
+  --> tests/ui/needless_bool_assign.rs:34:5
    |
 LL | /     if random() {
 LL | |         a.field = true;
@@ -32,7 +32,7 @@ LL | |     }
    | |_____^ help: you can reduce it to: `random(); a.field = true;`
 
 error: this `if` has identical blocks
-  --> tests/ui/needless_bool_assign.rs:32:17
+  --> tests/ui/needless_bool_assign.rs:34:17
    |
 LL |       if random() {
    |  _________________^
@@ -41,7 +41,7 @@ LL | |     } else {
    | |_____^
    |
 note: same as this
-  --> tests/ui/needless_bool_assign.rs:34:12
+  --> tests/ui/needless_bool_assign.rs:36:12
    |
 LL |       } else {
    |  ____________^
diff --git a/src/tools/clippy/tests/ui/needless_borrow.fixed b/src/tools/clippy/tests/ui/needless_borrow.fixed
index 2763830e09c9..d7d344452c5d 100644
--- a/src/tools/clippy/tests/ui/needless_borrow.fixed
+++ b/src/tools/clippy/tests/ui/needless_borrow.fixed
@@ -14,10 +14,14 @@ fn main() {
     let ref_a = &a;
     let _ = x(&a); // no warning
     let _ = x(&a); // warn
+    //
+    //~^^ needless_borrow
 
     let mut b = 5;
     mut_ref(&mut b); // no warning
     mut_ref(&mut b); // warn
+    //
+    //~^^ needless_borrow
 
     let s = &String::from("hi");
     let s_ident = f(&s); // should not error, because `&String` implements Copy, but `String` does not
@@ -30,14 +34,17 @@ fn main() {
         45 => {
             println!("foo");
             &a
+            //~^ needless_borrow
         },
         46 => &a,
+        //~^ needless_borrow
         47 => {
             println!("foo");
             loop {
                 println!("{}", a);
                 if a == 25 {
                     break ref_a;
+                    //~^ needless_borrow
                 }
             }
         },
@@ -45,12 +52,17 @@ fn main() {
     };
 
     let _ = x(&a);
+    //~^ needless_borrow
     let _ = x(&a);
+    //~^ needless_borrow
     let _ = x(&mut b);
+    //~^ needless_borrow
     let _ = x(ref_a);
+    //~^ needless_borrow
     {
         let b = &mut b;
         x(b);
+        //~^ needless_borrow
     }
 
     // Issue #8191
@@ -58,9 +70,13 @@ fn main() {
     let mut x = &mut x;
 
     mut_ref(x);
+    //~^ needless_borrow
     mut_ref(x);
+    //~^ needless_borrow
     let y: &mut i32 = x;
+    //~^ needless_borrow
     let y: &mut i32 = x;
+    //~^ needless_borrow
 
     let y = match 0 {
         // Don't lint. Removing the borrow would move 'x'
@@ -70,12 +86,14 @@ fn main() {
     let y: &mut i32 = match 0 {
         // Lint here. The type given above triggers auto-borrow.
         0 => x,
+        //~^ needless_borrow
         _ => &mut *x,
     };
     fn ref_mut_i32(_: &mut i32) {}
     ref_mut_i32(match 0 {
         // Lint here. The type given above triggers auto-borrow.
         0 => x,
+        //~^ needless_borrow
         _ => &mut *x,
     });
     // use 'x' after to make sure it's still usable in the fixed code.
@@ -88,8 +106,10 @@ fn main() {
 
     let x = (1, 2);
     let _ = x.0;
+    //~^ needless_borrow
     let x = &x as *const (i32, i32);
     let _ = unsafe { (*x).0 };
+    //~^ needless_borrow
 
     // Issue #8367
     trait Foo {
@@ -100,6 +120,7 @@ fn main() {
     }
     (&()).foo(); // Don't lint. `()` doesn't implement `Foo`
     (&()).foo();
+    //~^ needless_borrow
 
     impl Foo for i32 {
         fn foo(self) {}
@@ -109,6 +130,7 @@ fn main() {
     }
     (&5).foo(); // Don't lint. `5` will call `<i32 as Foo>::foo`
     (&5).foo();
+    //~^ needless_borrow
 
     trait FooRef {
         fn foo_ref(&self);
@@ -135,6 +157,7 @@ fn main() {
 
     // issue #11786
     let x: (&str,) = ("",);
+    //~^ needless_borrow
 }
 
 #[allow(clippy::needless_borrowed_reference)]
@@ -177,6 +200,7 @@ mod issue9160 {
     {
         fn calls_field(&self) -> T {
             (self.f)()
+            //~^ needless_borrow
         }
     }
 
@@ -186,6 +210,7 @@ mod issue9160 {
     {
         fn calls_mut_field(&mut self) -> T {
             (self.f)()
+            //~^ needless_borrow
         }
     }
 }
@@ -223,6 +248,7 @@ fn issue9383() {
         };
         let _ = &mut (&mut x.u).x;
         let _ = &mut { x.u }.x;
+        //~^ needless_borrow
         let _ = &mut ({ &mut x.u }).x;
 
         let mut x = U {
@@ -230,11 +256,14 @@ fn issue9383() {
         };
         let _ = &mut (&mut x.u).x;
         let _ = &mut { x.u }.x;
+        //~^ needless_borrow
         let _ = &mut ({ &mut x.u }).x;
 
         let mut x = U { u: Wrap(Foo { x: 0 }) };
         let _ = &mut x.u.x;
+        //~^ needless_borrow
         let _ = &mut { x.u }.x;
+        //~^ needless_borrow
         let _ = &mut ({ &mut x.u }).x;
     }
 }
@@ -256,6 +285,7 @@ fn issue_12268() {
     let option = Some((&1,));
     let x = (&1,);
     option.unwrap_or((x.0,));
-    //~^ ERROR: this expression creates a reference which is immediately dereferenced by the
+    //~^ needless_borrow
+
     // compiler
 }
diff --git a/src/tools/clippy/tests/ui/needless_borrow.rs b/src/tools/clippy/tests/ui/needless_borrow.rs
index b46f82b18c64..1f05b90b4728 100644
--- a/src/tools/clippy/tests/ui/needless_borrow.rs
+++ b/src/tools/clippy/tests/ui/needless_borrow.rs
@@ -14,10 +14,14 @@ fn main() {
     let ref_a = &a;
     let _ = x(&a); // no warning
     let _ = x(&&a); // warn
+    //
+    //~^^ needless_borrow
 
     let mut b = 5;
     mut_ref(&mut b); // no warning
     mut_ref(&mut &mut b); // warn
+    //
+    //~^^ needless_borrow
 
     let s = &String::from("hi");
     let s_ident = f(&s); // should not error, because `&String` implements Copy, but `String` does not
@@ -30,14 +34,17 @@ fn main() {
         45 => {
             println!("foo");
             &&a
+            //~^ needless_borrow
         },
         46 => &&a,
+        //~^ needless_borrow
         47 => {
             println!("foo");
             loop {
                 println!("{}", a);
                 if a == 25 {
                     break &ref_a;
+                    //~^ needless_borrow
                 }
             }
         },
@@ -45,12 +52,17 @@ fn main() {
     };
 
     let _ = x(&&&a);
+    //~^ needless_borrow
     let _ = x(&mut &&a);
+    //~^ needless_borrow
     let _ = x(&&&mut b);
+    //~^ needless_borrow
     let _ = x(&&ref_a);
+    //~^ needless_borrow
     {
         let b = &mut b;
         x(&b);
+        //~^ needless_borrow
     }
 
     // Issue #8191
@@ -58,9 +70,13 @@ fn main() {
     let mut x = &mut x;
 
     mut_ref(&mut x);
+    //~^ needless_borrow
     mut_ref(&mut &mut x);
+    //~^ needless_borrow
     let y: &mut i32 = &mut x;
+    //~^ needless_borrow
     let y: &mut i32 = &mut &mut x;
+    //~^ needless_borrow
 
     let y = match 0 {
         // Don't lint. Removing the borrow would move 'x'
@@ -70,12 +86,14 @@ fn main() {
     let y: &mut i32 = match 0 {
         // Lint here. The type given above triggers auto-borrow.
         0 => &mut x,
+        //~^ needless_borrow
         _ => &mut *x,
     };
     fn ref_mut_i32(_: &mut i32) {}
     ref_mut_i32(match 0 {
         // Lint here. The type given above triggers auto-borrow.
         0 => &mut x,
+        //~^ needless_borrow
         _ => &mut *x,
     });
     // use 'x' after to make sure it's still usable in the fixed code.
@@ -88,8 +106,10 @@ fn main() {
 
     let x = (1, 2);
     let _ = (&x).0;
+    //~^ needless_borrow
     let x = &x as *const (i32, i32);
     let _ = unsafe { (&*x).0 };
+    //~^ needless_borrow
 
     // Issue #8367
     trait Foo {
@@ -100,6 +120,7 @@ fn main() {
     }
     (&()).foo(); // Don't lint. `()` doesn't implement `Foo`
     (&&()).foo();
+    //~^ needless_borrow
 
     impl Foo for i32 {
         fn foo(self) {}
@@ -109,6 +130,7 @@ fn main() {
     }
     (&5).foo(); // Don't lint. `5` will call `<i32 as Foo>::foo`
     (&&5).foo();
+    //~^ needless_borrow
 
     trait FooRef {
         fn foo_ref(&self);
@@ -135,6 +157,7 @@ fn main() {
 
     // issue #11786
     let x: (&str,) = (&"",);
+    //~^ needless_borrow
 }
 
 #[allow(clippy::needless_borrowed_reference)]
@@ -177,6 +200,7 @@ mod issue9160 {
     {
         fn calls_field(&self) -> T {
             (&self.f)()
+            //~^ needless_borrow
         }
     }
 
@@ -186,6 +210,7 @@ mod issue9160 {
     {
         fn calls_mut_field(&mut self) -> T {
             (&mut self.f)()
+            //~^ needless_borrow
         }
     }
 }
@@ -223,6 +248,7 @@ fn issue9383() {
         };
         let _ = &mut (&mut x.u).x;
         let _ = &mut (&mut { x.u }).x;
+        //~^ needless_borrow
         let _ = &mut ({ &mut x.u }).x;
 
         let mut x = U {
@@ -230,11 +256,14 @@ fn issue9383() {
         };
         let _ = &mut (&mut x.u).x;
         let _ = &mut (&mut { x.u }).x;
+        //~^ needless_borrow
         let _ = &mut ({ &mut x.u }).x;
 
         let mut x = U { u: Wrap(Foo { x: 0 }) };
         let _ = &mut (&mut x.u).x;
+        //~^ needless_borrow
         let _ = &mut (&mut { x.u }).x;
+        //~^ needless_borrow
         let _ = &mut ({ &mut x.u }).x;
     }
 }
@@ -256,6 +285,7 @@ fn issue_12268() {
     let option = Some((&1,));
     let x = (&1,);
     option.unwrap_or((&x.0,));
-    //~^ ERROR: this expression creates a reference which is immediately dereferenced by the
+    //~^ needless_borrow
+
     // compiler
 }
diff --git a/src/tools/clippy/tests/ui/needless_borrow.stderr b/src/tools/clippy/tests/ui/needless_borrow.stderr
index 4b2b17e7e570..b036b1e47d18 100644
--- a/src/tools/clippy/tests/ui/needless_borrow.stderr
+++ b/src/tools/clippy/tests/ui/needless_borrow.stderr
@@ -8,163 +8,163 @@ LL |     let _ = x(&&a); // warn
    = help: to override `-D warnings` add `#[allow(clippy::needless_borrow)]`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:20:13
+  --> tests/ui/needless_borrow.rs:22:13
    |
 LL |     mut_ref(&mut &mut b); // warn
    |             ^^^^^^^^^^^ help: change this to: `&mut b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:32:13
+  --> tests/ui/needless_borrow.rs:36:13
    |
 LL |             &&a
    |             ^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:34:15
+  --> tests/ui/needless_borrow.rs:39:15
    |
 LL |         46 => &&a,
    |               ^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:40:27
+  --> tests/ui/needless_borrow.rs:46:27
    |
 LL |                     break &ref_a;
    |                           ^^^^^^ help: change this to: `ref_a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:47:15
+  --> tests/ui/needless_borrow.rs:54:15
    |
 LL |     let _ = x(&&&a);
    |               ^^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:48:15
+  --> tests/ui/needless_borrow.rs:56:15
    |
 LL |     let _ = x(&mut &&a);
    |               ^^^^^^^^ help: change this to: `&a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:49:15
+  --> tests/ui/needless_borrow.rs:58:15
    |
 LL |     let _ = x(&&&mut b);
    |               ^^^^^^^^ help: change this to: `&mut b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:50:15
+  --> tests/ui/needless_borrow.rs:60:15
    |
 LL |     let _ = x(&&ref_a);
    |               ^^^^^^^ help: change this to: `ref_a`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:53:11
+  --> tests/ui/needless_borrow.rs:64:11
    |
 LL |         x(&b);
    |           ^^ help: change this to: `b`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:60:13
+  --> tests/ui/needless_borrow.rs:72:13
    |
 LL |     mut_ref(&mut x);
    |             ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:61:13
+  --> tests/ui/needless_borrow.rs:74:13
    |
 LL |     mut_ref(&mut &mut x);
    |             ^^^^^^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:62:23
+  --> tests/ui/needless_borrow.rs:76:23
    |
 LL |     let y: &mut i32 = &mut x;
    |                       ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:63:23
+  --> tests/ui/needless_borrow.rs:78:23
    |
 LL |     let y: &mut i32 = &mut &mut x;
    |                       ^^^^^^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:72:14
+  --> tests/ui/needless_borrow.rs:88:14
    |
 LL |         0 => &mut x,
    |              ^^^^^^ help: change this to: `x`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:78:14
+  --> tests/ui/needless_borrow.rs:95:14
    |
 LL |         0 => &mut x,
    |              ^^^^^^ help: change this to: `x`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:90:13
+  --> tests/ui/needless_borrow.rs:108:13
    |
 LL |     let _ = (&x).0;
    |             ^^^^ help: change this to: `x`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:92:22
+  --> tests/ui/needless_borrow.rs:111:22
    |
 LL |     let _ = unsafe { (&*x).0 };
    |                      ^^^^^ help: change this to: `(*x)`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:102:5
+  --> tests/ui/needless_borrow.rs:122:5
    |
 LL |     (&&()).foo();
    |     ^^^^^^ help: change this to: `(&())`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:111:5
+  --> tests/ui/needless_borrow.rs:132:5
    |
 LL |     (&&5).foo();
    |     ^^^^^ help: change this to: `(&5)`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:137:23
+  --> tests/ui/needless_borrow.rs:159:23
    |
 LL |     let x: (&str,) = (&"",);
    |                       ^^^ help: change this to: `""`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:179:13
+  --> tests/ui/needless_borrow.rs:202:13
    |
 LL |             (&self.f)()
    |             ^^^^^^^^^ help: change this to: `(self.f)`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:188:13
+  --> tests/ui/needless_borrow.rs:212:13
    |
 LL |             (&mut self.f)()
    |             ^^^^^^^^^^^^^ help: change this to: `(self.f)`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:225:22
+  --> tests/ui/needless_borrow.rs:250:22
    |
 LL |         let _ = &mut (&mut { x.u }).x;
    |                      ^^^^^^^^^^^^^^ help: change this to: `{ x.u }`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:232:22
+  --> tests/ui/needless_borrow.rs:258:22
    |
 LL |         let _ = &mut (&mut { x.u }).x;
    |                      ^^^^^^^^^^^^^^ help: change this to: `{ x.u }`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:236:22
+  --> tests/ui/needless_borrow.rs:263:22
    |
 LL |         let _ = &mut (&mut x.u).x;
    |                      ^^^^^^^^^^ help: change this to: `x.u`
 
 error: this expression borrows a value the compiler would automatically borrow
-  --> tests/ui/needless_borrow.rs:237:22
+  --> tests/ui/needless_borrow.rs:265:22
    |
 LL |         let _ = &mut (&mut { x.u }).x;
    |                      ^^^^^^^^^^^^^^ help: change this to: `{ x.u }`
 
 error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_borrow.rs:258:23
+  --> tests/ui/needless_borrow.rs:287:23
    |
 LL |     option.unwrap_or((&x.0,));
    |                       ^^^^ help: change this to: `x.0`
diff --git a/src/tools/clippy/tests/ui/needless_borrow_pat.fixed b/src/tools/clippy/tests/ui/needless_borrow_pat.fixed
index 8f8887f08a27..fe966a716df7 100644
--- a/src/tools/clippy/tests/ui/needless_borrow_pat.fixed
+++ b/src/tools/clippy/tests/ui/needless_borrow_pat.fixed
@@ -57,22 +57,22 @@ fn main() {
     // Err, reference to a &String
     let _: &String = match Some(&x) {
         Some(x) => x,
-        //~^ ERROR: this pattern creates a reference to a reference
-        //~| NOTE: `-D clippy::needless-borrow` implied by `-D warnings`
+        //~^ needless_borrow
         None => return,
     };
 
     // Err, reference to a &String.
     let _: &String = match Some(&x) {
         Some(x) => x,
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
         None => return,
     };
 
     // Err, reference to a &String
     let _: &String = match Some(&x) {
         Some(x) => {
-            //~^ ERROR: this pattern creates a reference to a reference
+            //~^ needless_borrow
+
             f1(x);
             f1(x);
             x
@@ -83,19 +83,21 @@ fn main() {
     // Err, reference to a &String
     match Some(&x) {
         Some(x) => m1!(x),
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
         None => return,
     };
 
     // Err, reference to a &String
     let _ = |&x: &&String| {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         let _: &String = x;
     };
 
     // Err, reference to a &String
     let (y,) = (&x,);
-    //~^ ERROR: this pattern creates a reference to a reference
+    //~^ needless_borrow
+
     let _: &String = y;
 
     let y = &&x;
@@ -106,7 +108,7 @@ fn main() {
     // Err, reference to a &u32. Don't suggest adding a reference to the field access.
     let _: u32 = match Some(&x) {
         Some(x) => x.0,
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
         None => return,
     };
 
@@ -117,14 +119,15 @@ fn main() {
     // Err, reference to &u32.
     let _: &u32 = match E::A(&0) {
         E::A(x) | E::B(x) => x,
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
     };
 
     // Err, reference to &String.
     if_chain! {
         if true;
         if let Some(x) = Some(&String::new());
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         then {
             f1(x);
         }
@@ -133,7 +136,8 @@ fn main() {
 
 // Err, reference to a &String
 fn f2<'a>(&x: &&'a String) -> &'a String {
-    //~^ ERROR: this pattern creates a reference to a reference
+    //~^ needless_borrow
+
     let _: &String = x;
     x
 }
@@ -141,7 +145,8 @@ fn f2<'a>(&x: &&'a String) -> &'a String {
 trait T1 {
     // Err, reference to a &String
     fn f(&x: &&String) {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         let _: &String = x;
     }
 }
@@ -150,7 +155,8 @@ struct S;
 impl T1 for S {
     // Err, reference to a &String
     fn f(&x: &&String) {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         let _: &String = x;
     }
 }
diff --git a/src/tools/clippy/tests/ui/needless_borrow_pat.rs b/src/tools/clippy/tests/ui/needless_borrow_pat.rs
index 56dbd923f256..a6b43855cad1 100644
--- a/src/tools/clippy/tests/ui/needless_borrow_pat.rs
+++ b/src/tools/clippy/tests/ui/needless_borrow_pat.rs
@@ -57,22 +57,22 @@ fn main() {
     // Err, reference to a &String
     let _: &String = match Some(&x) {
         Some(ref x) => x,
-        //~^ ERROR: this pattern creates a reference to a reference
-        //~| NOTE: `-D clippy::needless-borrow` implied by `-D warnings`
+        //~^ needless_borrow
         None => return,
     };
 
     // Err, reference to a &String.
     let _: &String = match Some(&x) {
         Some(ref x) => *x,
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
         None => return,
     };
 
     // Err, reference to a &String
     let _: &String = match Some(&x) {
         Some(ref x) => {
-            //~^ ERROR: this pattern creates a reference to a reference
+            //~^ needless_borrow
+
             f1(x);
             f1(*x);
             x
@@ -83,19 +83,21 @@ fn main() {
     // Err, reference to a &String
     match Some(&x) {
         Some(ref x) => m1!(x),
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
         None => return,
     };
 
     // Err, reference to a &String
     let _ = |&ref x: &&String| {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         let _: &String = x;
     };
 
     // Err, reference to a &String
     let (ref y,) = (&x,);
-    //~^ ERROR: this pattern creates a reference to a reference
+    //~^ needless_borrow
+
     let _: &String = *y;
 
     let y = &&x;
@@ -106,7 +108,7 @@ fn main() {
     // Err, reference to a &u32. Don't suggest adding a reference to the field access.
     let _: u32 = match Some(&x) {
         Some(ref x) => x.0,
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
         None => return,
     };
 
@@ -117,14 +119,15 @@ fn main() {
     // Err, reference to &u32.
     let _: &u32 = match E::A(&0) {
         E::A(ref x) | E::B(ref x) => *x,
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
     };
 
     // Err, reference to &String.
     if_chain! {
         if true;
         if let Some(ref x) = Some(&String::new());
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         then {
             f1(x);
         }
@@ -133,7 +136,8 @@ fn main() {
 
 // Err, reference to a &String
 fn f2<'a>(&ref x: &&'a String) -> &'a String {
-    //~^ ERROR: this pattern creates a reference to a reference
+    //~^ needless_borrow
+
     let _: &String = x;
     *x
 }
@@ -141,7 +145,8 @@ fn f2<'a>(&ref x: &&'a String) -> &'a String {
 trait T1 {
     // Err, reference to a &String
     fn f(&ref x: &&String) {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         let _: &String = x;
     }
 }
@@ -150,7 +155,8 @@ struct S;
 impl T1 for S {
     // Err, reference to a &String
     fn f(&ref x: &&String) {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ needless_borrow
+
         let _: &String = *x;
     }
 }
diff --git a/src/tools/clippy/tests/ui/needless_borrow_pat.stderr b/src/tools/clippy/tests/ui/needless_borrow_pat.stderr
index 035376cabaf4..25c570eb7ff7 100644
--- a/src/tools/clippy/tests/ui/needless_borrow_pat.stderr
+++ b/src/tools/clippy/tests/ui/needless_borrow_pat.stderr
@@ -8,7 +8,7 @@ LL |         Some(ref x) => x,
    = help: to override `-D warnings` add `#[allow(clippy::needless_borrow)]`
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:67:14
+  --> tests/ui/needless_borrow_pat.rs:66:14
    |
 LL |         Some(ref x) => *x,
    |              ^^^^^
@@ -20,7 +20,7 @@ LL +         Some(x) => x,
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:74:14
+  --> tests/ui/needless_borrow_pat.rs:73:14
    |
 LL |         Some(ref x) => {
    |              ^^^^^
@@ -29,6 +29,7 @@ help: try
    |
 LL ~         Some(x) => {
 LL |
+LL |
 LL |             f1(x);
 LL ~             f1(x);
    |
@@ -46,7 +47,7 @@ LL |     let _ = |&ref x: &&String| {
    |               ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:97:10
+  --> tests/ui/needless_borrow_pat.rs:98:10
    |
 LL |     let (ref y,) = (&x,);
    |          ^^^^^
@@ -55,17 +56,18 @@ help: try
    |
 LL ~     let (y,) = (&x,);
 LL |
+LL |
 LL ~     let _: &String = y;
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:108:14
+  --> tests/ui/needless_borrow_pat.rs:110:14
    |
 LL |         Some(ref x) => x.0,
    |              ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:119:14
+  --> tests/ui/needless_borrow_pat.rs:121:14
    |
 LL |         E::A(ref x) | E::B(ref x) => *x,
    |              ^^^^^         ^^^^^
@@ -77,13 +79,13 @@ LL +         E::A(x) | E::B(x) => x,
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:126:21
+  --> tests/ui/needless_borrow_pat.rs:128:21
    |
 LL |         if let Some(ref x) = Some(&String::new());
    |                     ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:135:12
+  --> tests/ui/needless_borrow_pat.rs:138:12
    |
 LL | fn f2<'a>(&ref x: &&'a String) -> &'a String {
    |            ^^^^^
@@ -92,18 +94,19 @@ help: try
    |
 LL ~ fn f2<'a>(&x: &&'a String) -> &'a String {
 LL |
+LL |
 LL |     let _: &String = x;
 LL ~     x
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:143:11
+  --> tests/ui/needless_borrow_pat.rs:147:11
    |
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^ help: try: `x`
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/needless_borrow_pat.rs:152:11
+  --> tests/ui/needless_borrow_pat.rs:157:11
    |
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
@@ -112,6 +115,7 @@ help: try
    |
 LL ~     fn f(&x: &&String) {
 LL |
+LL |
 LL ~         let _: &String = x;
    |
 
diff --git a/src/tools/clippy/tests/ui/needless_borrowed_ref.fixed b/src/tools/clippy/tests/ui/needless_borrowed_ref.fixed
index 5d2fd0950ee4..e4504bc2784c 100644
--- a/src/tools/clippy/tests/ui/needless_borrowed_ref.fixed
+++ b/src/tools/clippy/tests/ui/needless_borrowed_ref.fixed
@@ -28,32 +28,48 @@ fn should_lint(
 ) {
     let mut v = Vec::<String>::new();
     let _ = v.iter_mut().filter(|a| a.is_empty());
+    //~^ needless_borrowed_reference
 
     let var = 3;
     let thingy = Some(&var);
     if let Some(v) = thingy {}
+    //~^ needless_borrowed_reference
 
     if let &[a, ref b] = slice_of_refs {}
+    //~^ needless_borrowed_reference
 
     let [a, ..] = &array;
+    //~^ needless_borrowed_reference
     let [a, b, ..] = &array;
+    //~^ needless_borrowed_reference
 
     if let [a, b] = slice {}
+    //~^ needless_borrowed_reference
     if let [a, b] = &vec[..] {}
+    //~^ needless_borrowed_reference
 
     if let [a, b, ..] = slice {}
+    //~^ needless_borrowed_reference
     if let [a, .., b] = slice {}
+    //~^ needless_borrowed_reference
     if let [.., a, b] = slice {}
+    //~^ needless_borrowed_reference
 
     if let [a, _] = slice {}
+    //~^ needless_borrowed_reference
 
     if let (a, b, c) = &tuple {}
+    //~^ needless_borrowed_reference
     if let (a, _, c) = &tuple {}
+    //~^ needless_borrowed_reference
     if let (a, ..) = &tuple {}
+    //~^ needless_borrowed_reference
 
     if let TupleStruct(a, ..) = &tuple_struct {}
+    //~^ needless_borrowed_reference
 
     if let Struct {
+        //~^ needless_borrowed_reference
         a,
         b: b,
         c: renamed,
@@ -61,6 +77,7 @@ fn should_lint(
     {}
 
     if let Struct { a, b: _, .. } = &s {}
+    //~^ needless_borrowed_reference
 }
 
 fn should_not_lint(
diff --git a/src/tools/clippy/tests/ui/needless_borrowed_ref.rs b/src/tools/clippy/tests/ui/needless_borrowed_ref.rs
index 556fd3a35427..7edfda60b979 100644
--- a/src/tools/clippy/tests/ui/needless_borrowed_ref.rs
+++ b/src/tools/clippy/tests/ui/needless_borrowed_ref.rs
@@ -28,32 +28,48 @@ fn should_lint(
 ) {
     let mut v = Vec::<String>::new();
     let _ = v.iter_mut().filter(|&ref a| a.is_empty());
+    //~^ needless_borrowed_reference
 
     let var = 3;
     let thingy = Some(&var);
     if let Some(&ref v) = thingy {}
+    //~^ needless_borrowed_reference
 
     if let &[&ref a, ref b] = slice_of_refs {}
+    //~^ needless_borrowed_reference
 
     let &[ref a, ..] = &array;
+    //~^ needless_borrowed_reference
     let &[ref a, ref b, ..] = &array;
+    //~^ needless_borrowed_reference
 
     if let &[ref a, ref b] = slice {}
+    //~^ needless_borrowed_reference
     if let &[ref a, ref b] = &vec[..] {}
+    //~^ needless_borrowed_reference
 
     if let &[ref a, ref b, ..] = slice {}
+    //~^ needless_borrowed_reference
     if let &[ref a, .., ref b] = slice {}
+    //~^ needless_borrowed_reference
     if let &[.., ref a, ref b] = slice {}
+    //~^ needless_borrowed_reference
 
     if let &[ref a, _] = slice {}
+    //~^ needless_borrowed_reference
 
     if let &(ref a, ref b, ref c) = &tuple {}
+    //~^ needless_borrowed_reference
     if let &(ref a, _, ref c) = &tuple {}
+    //~^ needless_borrowed_reference
     if let &(ref a, ..) = &tuple {}
+    //~^ needless_borrowed_reference
 
     if let &TupleStruct(ref a, ..) = &tuple_struct {}
+    //~^ needless_borrowed_reference
 
     if let &Struct {
+        //~^ needless_borrowed_reference
         ref a,
         b: ref b,
         c: ref renamed,
@@ -61,6 +77,7 @@ fn should_lint(
     {}
 
     if let &Struct { ref a, b: _, .. } = &s {}
+    //~^ needless_borrowed_reference
 }
 
 fn should_not_lint(
diff --git a/src/tools/clippy/tests/ui/needless_borrowed_ref.stderr b/src/tools/clippy/tests/ui/needless_borrowed_ref.stderr
index b8181e2805c9..bfa3cafdedeb 100644
--- a/src/tools/clippy/tests/ui/needless_borrowed_ref.stderr
+++ b/src/tools/clippy/tests/ui/needless_borrowed_ref.stderr
@@ -13,7 +13,7 @@ LL +     let _ = v.iter_mut().filter(|a| a.is_empty());
    |
 
 error: this pattern takes a reference on something that is being dereferenced
-  --> tests/ui/needless_borrowed_ref.rs:34:17
+  --> tests/ui/needless_borrowed_ref.rs:35:17
    |
 LL |     if let Some(&ref v) = thingy {}
    |                 ^^^^^^
@@ -25,7 +25,7 @@ LL +     if let Some(v) = thingy {}
    |
 
 error: this pattern takes a reference on something that is being dereferenced
-  --> tests/ui/needless_borrowed_ref.rs:36:14
+  --> tests/ui/needless_borrowed_ref.rs:38:14
    |
 LL |     if let &[&ref a, ref b] = slice_of_refs {}
    |              ^^^^^^
@@ -37,7 +37,7 @@ LL +     if let &[a, ref b] = slice_of_refs {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:38:9
+  --> tests/ui/needless_borrowed_ref.rs:41:9
    |
 LL |     let &[ref a, ..] = &array;
    |         ^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     let [a, ..] = &array;
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:39:9
+  --> tests/ui/needless_borrowed_ref.rs:43:9
    |
 LL |     let &[ref a, ref b, ..] = &array;
    |         ^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     let [a, b, ..] = &array;
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:41:12
+  --> tests/ui/needless_borrowed_ref.rs:46:12
    |
 LL |     if let &[ref a, ref b] = slice {}
    |            ^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     if let [a, b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:42:12
+  --> tests/ui/needless_borrowed_ref.rs:48:12
    |
 LL |     if let &[ref a, ref b] = &vec[..] {}
    |            ^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     if let [a, b] = &vec[..] {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:44:12
+  --> tests/ui/needless_borrowed_ref.rs:51:12
    |
 LL |     if let &[ref a, ref b, ..] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     if let [a, b, ..] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:45:12
+  --> tests/ui/needless_borrowed_ref.rs:53:12
    |
 LL |     if let &[ref a, .., ref b] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     if let [a, .., b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:46:12
+  --> tests/ui/needless_borrowed_ref.rs:55:12
    |
 LL |     if let &[.., ref a, ref b] = slice {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     if let [.., a, b] = slice {}
    |
 
 error: dereferencing a slice pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:48:12
+  --> tests/ui/needless_borrowed_ref.rs:58:12
    |
 LL |     if let &[ref a, _] = slice {}
    |            ^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     if let [a, _] = slice {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:50:12
+  --> tests/ui/needless_borrowed_ref.rs:61:12
    |
 LL |     if let &(ref a, ref b, ref c) = &tuple {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     if let (a, b, c) = &tuple {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:51:12
+  --> tests/ui/needless_borrowed_ref.rs:63:12
    |
 LL |     if let &(ref a, _, ref c) = &tuple {}
    |            ^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     if let (a, _, c) = &tuple {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:52:12
+  --> tests/ui/needless_borrowed_ref.rs:65:12
    |
 LL |     if let &(ref a, ..) = &tuple {}
    |            ^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     if let (a, ..) = &tuple {}
    |
 
 error: dereferencing a tuple pattern where every element takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:54:12
+  --> tests/ui/needless_borrowed_ref.rs:68:12
    |
 LL |     if let &TupleStruct(ref a, ..) = &tuple_struct {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,10 +181,11 @@ LL +     if let TupleStruct(a, ..) = &tuple_struct {}
    |
 
 error: dereferencing a struct pattern where every field's pattern takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:56:12
+  --> tests/ui/needless_borrowed_ref.rs:71:12
    |
 LL |       if let &Struct {
    |  ____________^
+LL | |
 LL | |         ref a,
 LL | |         b: ref b,
 LL | |         c: ref renamed,
@@ -194,13 +195,14 @@ LL | |     } = &s
 help: try removing the `&` and `ref` parts
    |
 LL ~     if let Struct {
+LL |
 LL ~         a,
 LL ~         b: b,
 LL ~         c: renamed,
    |
 
 error: dereferencing a struct pattern where every field's pattern takes a reference
-  --> tests/ui/needless_borrowed_ref.rs:63:12
+  --> tests/ui/needless_borrowed_ref.rs:79:12
    |
 LL |     if let &Struct { ref a, b: _, .. } = &s {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
index c1dc8b5e8d09..8dea0d259772 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.fixed
@@ -14,11 +14,14 @@ use std::process::Command;
 
 fn main() {
     let _ = Command::new("ls").args(["-a", "-l"]).status().unwrap();
+    //~^ needless_borrows_for_generic_args
     let _ = Path::new(".").join(".");
+    //~^ needless_borrows_for_generic_args
     let _ = Any::type_id(&""); // Don't lint. `Any` is only bound
     let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
     let _ = Some("").unwrap_or(&"");
     let _ = std::fs::write("x", "".to_string());
+    //~^ needless_borrows_for_generic_args
 
     {
         #[derive(Clone, Copy)]
@@ -34,6 +37,7 @@ fn main() {
         fn deref_target_is_x<T: Deref<Target = X>>(_: T) {}
 
         deref_target_is_x(X);
+        //~^ needless_borrows_for_generic_args
     }
     {
         fn multiple_constraints<T, U, V, X, Y>(_: T)
@@ -47,6 +51,7 @@ fn main() {
         }
 
         multiple_constraints([[""]]);
+        //~^ needless_borrows_for_generic_args
     }
     {
         #[derive(Clone, Copy)]
@@ -67,6 +72,7 @@ fn main() {
         }
 
         multiple_constraints_normalizes_to_same(X, X);
+        //~^ needless_borrows_for_generic_args
     }
     {
         fn only_sized<T>(_: T) {}
@@ -125,6 +131,7 @@ fn main() {
         #[allow(unused_mut)]
         fn warn(mut x: &mut Iter) {
             takes_iter(x)
+            //~^ needless_borrows_for_generic_args
         }
     }
     #[clippy::msrv = "1.52.0"]
@@ -134,6 +141,7 @@ fn main() {
     #[clippy::msrv = "1.53.0"]
     {
         let _ = Command::new("ls").args(["-a", "-l"]).status().unwrap();
+        //~^ needless_borrows_for_generic_args
     };
     {
         let env = "env".to_owned();
@@ -245,6 +253,7 @@ fn main() {
         // 8
         foo::<&[u8; 100]>(&a);
         foo(a);
+        //~^ needless_borrows_for_generic_args
     }
     {
         struct S;
@@ -329,9 +338,13 @@ fn main() {
         let x = String::new();
         f(&x); // Don't lint, not a copy, makes it unavailable later
         f(String::new()); // Lint, makes no difference
+        //
+        //~^^ needless_borrows_for_generic_args
         let y = "".to_owned();
         f(&y); // Don't lint
         f("".to_owned()); // Lint
+        //
+        //~^^ needless_borrows_for_generic_args
     }
     {
         fn takes_writer<T: std::io::Write>(_: T) {}
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
index c7f66824d581..bc2db6774e96 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.rs
@@ -14,11 +14,14 @@ use std::process::Command;
 
 fn main() {
     let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+    //~^ needless_borrows_for_generic_args
     let _ = Path::new(".").join(&&".");
+    //~^ needless_borrows_for_generic_args
     let _ = Any::type_id(&""); // Don't lint. `Any` is only bound
     let _ = Box::new(&""); // Don't lint. Type parameter appears in return type
     let _ = Some("").unwrap_or(&"");
     let _ = std::fs::write("x", &"".to_string());
+    //~^ needless_borrows_for_generic_args
 
     {
         #[derive(Clone, Copy)]
@@ -34,6 +37,7 @@ fn main() {
         fn deref_target_is_x<T: Deref<Target = X>>(_: T) {}
 
         deref_target_is_x(&X);
+        //~^ needless_borrows_for_generic_args
     }
     {
         fn multiple_constraints<T, U, V, X, Y>(_: T)
@@ -47,6 +51,7 @@ fn main() {
         }
 
         multiple_constraints(&[[""]]);
+        //~^ needless_borrows_for_generic_args
     }
     {
         #[derive(Clone, Copy)]
@@ -67,6 +72,7 @@ fn main() {
         }
 
         multiple_constraints_normalizes_to_same(&X, X);
+        //~^ needless_borrows_for_generic_args
     }
     {
         fn only_sized<T>(_: T) {}
@@ -125,6 +131,7 @@ fn main() {
         #[allow(unused_mut)]
         fn warn(mut x: &mut Iter) {
             takes_iter(&mut x)
+            //~^ needless_borrows_for_generic_args
         }
     }
     #[clippy::msrv = "1.52.0"]
@@ -134,6 +141,7 @@ fn main() {
     #[clippy::msrv = "1.53.0"]
     {
         let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
+        //~^ needless_borrows_for_generic_args
     };
     {
         let env = "env".to_owned();
@@ -245,6 +253,7 @@ fn main() {
         // 8
         foo::<&[u8; 100]>(&a);
         foo(&a);
+        //~^ needless_borrows_for_generic_args
     }
     {
         struct S;
@@ -329,9 +338,13 @@ fn main() {
         let x = String::new();
         f(&x); // Don't lint, not a copy, makes it unavailable later
         f(&String::new()); // Lint, makes no difference
+        //
+        //~^^ needless_borrows_for_generic_args
         let y = "".to_owned();
         f(&y); // Don't lint
         f(&"".to_owned()); // Lint
+        //
+        //~^^ needless_borrows_for_generic_args
     }
     {
         fn takes_writer<T: std::io::Write>(_: T) {}
diff --git a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr
index fba0755d14b5..8829854e3073 100644
--- a/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr
+++ b/src/tools/clippy/tests/ui/needless_borrows_for_generic_args.stderr
@@ -8,61 +8,61 @@ LL |     let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::needless_borrows_for_generic_args)]`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:17:33
+  --> tests/ui/needless_borrows_for_generic_args.rs:18:33
    |
 LL |     let _ = Path::new(".").join(&&".");
    |                                 ^^^^^ help: change this to: `"."`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:21:33
+  --> tests/ui/needless_borrows_for_generic_args.rs:23:33
    |
 LL |     let _ = std::fs::write("x", &"".to_string());
    |                                 ^^^^^^^^^^^^^^^ help: change this to: `"".to_string()`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:36:27
+  --> tests/ui/needless_borrows_for_generic_args.rs:39:27
    |
 LL |         deref_target_is_x(&X);
    |                           ^^ help: change this to: `X`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:49:30
+  --> tests/ui/needless_borrows_for_generic_args.rs:53:30
    |
 LL |         multiple_constraints(&[[""]]);
    |                              ^^^^^^^ help: change this to: `[[""]]`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:69:49
+  --> tests/ui/needless_borrows_for_generic_args.rs:74:49
    |
 LL |         multiple_constraints_normalizes_to_same(&X, X);
    |                                                 ^^ help: change this to: `X`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:127:24
+  --> tests/ui/needless_borrows_for_generic_args.rs:133:24
    |
 LL |             takes_iter(&mut x)
    |                        ^^^^^^ help: change this to: `x`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:136:41
+  --> tests/ui/needless_borrows_for_generic_args.rs:143:41
    |
 LL |         let _ = Command::new("ls").args(&["-a", "-l"]).status().unwrap();
    |                                         ^^^^^^^^^^^^^ help: change this to: `["-a", "-l"]`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:247:13
+  --> tests/ui/needless_borrows_for_generic_args.rs:255:13
    |
 LL |         foo(&a);
    |             ^^ help: change this to: `a`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:331:11
+  --> tests/ui/needless_borrows_for_generic_args.rs:340:11
    |
 LL |         f(&String::new()); // Lint, makes no difference
    |           ^^^^^^^^^^^^^^ help: change this to: `String::new()`
 
 error: the borrowed expression implements the required traits
-  --> tests/ui/needless_borrows_for_generic_args.rs:334:11
+  --> tests/ui/needless_borrows_for_generic_args.rs:345:11
    |
 LL |         f(&"".to_owned()); // Lint
    |           ^^^^^^^^^^^^^^ help: change this to: `"".to_owned()`
diff --git a/src/tools/clippy/tests/ui/needless_character_iteration.fixed b/src/tools/clippy/tests/ui/needless_character_iteration.fixed
index f0bf84a41d7e..e25db9bb590f 100644
--- a/src/tools/clippy/tests/ui/needless_character_iteration.fixed
+++ b/src/tools/clippy/tests/ui/needless_character_iteration.fixed
@@ -16,25 +16,29 @@ fn magic(_: char) {}
 
 fn main() {
     "foo".is_ascii();
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     !"foo".is_ascii();
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     "foo".is_ascii();
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     !"foo".is_ascii();
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
 
     let s = String::new();
     s.is_ascii();
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     !"foo".to_string().is_ascii();
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
 
     "foo".is_ascii();
     !"foo".is_ascii();
 
     S::default().field().is_ascii();
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
 
     // Should not lint!
     "foo".chars().all(|c| {
diff --git a/src/tools/clippy/tests/ui/needless_character_iteration.rs b/src/tools/clippy/tests/ui/needless_character_iteration.rs
index 2805d2438b4a..9b184dab6bc8 100644
--- a/src/tools/clippy/tests/ui/needless_character_iteration.rs
+++ b/src/tools/clippy/tests/ui/needless_character_iteration.rs
@@ -16,33 +16,39 @@ fn magic(_: char) {}
 
 fn main() {
     "foo".chars().all(|c| c.is_ascii());
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     "foo".chars().any(|c| !c.is_ascii());
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     "foo".chars().all(|c| char::is_ascii(&c));
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     "foo".chars().any(|c| !char::is_ascii(&c));
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
 
     let s = String::new();
     s.chars().all(|c| c.is_ascii());
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
+
     "foo".to_string().chars().any(|c| !c.is_ascii());
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
 
     "foo".chars().all(|c| {
-        //~^ ERROR: checking if a string is ascii using iterators
+        //~^ needless_character_iteration
+
         let x = c;
         x.is_ascii()
     });
     "foo".chars().any(|c| {
-        //~^ ERROR: checking if a string is ascii using iterators
+        //~^ needless_character_iteration
+
         let x = c;
         !x.is_ascii()
     });
 
     S::default().field().chars().all(|x| x.is_ascii());
-    //~^ ERROR: checking if a string is ascii using iterators
+    //~^ needless_character_iteration
 
     // Should not lint!
     "foo".chars().all(|c| {
diff --git a/src/tools/clippy/tests/ui/needless_character_iteration.stderr b/src/tools/clippy/tests/ui/needless_character_iteration.stderr
index 7966033555f5..995404996644 100644
--- a/src/tools/clippy/tests/ui/needless_character_iteration.stderr
+++ b/src/tools/clippy/tests/ui/needless_character_iteration.stderr
@@ -8,57 +8,59 @@ LL |     "foo".chars().all(|c| c.is_ascii());
    = help: to override `-D warnings` add `#[allow(clippy::needless_character_iteration)]`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:20:5
+  --> tests/ui/needless_character_iteration.rs:21:5
    |
 LL |     "foo".chars().any(|c| !c.is_ascii());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `!"foo".is_ascii()`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:22:5
+  --> tests/ui/needless_character_iteration.rs:24:5
    |
 LL |     "foo".chars().all(|c| char::is_ascii(&c));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"foo".is_ascii()`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:24:5
+  --> tests/ui/needless_character_iteration.rs:27:5
    |
 LL |     "foo".chars().any(|c| !char::is_ascii(&c));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `!"foo".is_ascii()`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:28:5
+  --> tests/ui/needless_character_iteration.rs:31:5
    |
 LL |     s.chars().all(|c| c.is_ascii());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.is_ascii()`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:30:5
+  --> tests/ui/needless_character_iteration.rs:34:5
    |
 LL |     "foo".to_string().chars().any(|c| !c.is_ascii());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `!"foo".to_string().is_ascii()`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:33:5
+  --> tests/ui/needless_character_iteration.rs:37:5
    |
 LL | /     "foo".chars().all(|c| {
 LL | |
+LL | |
 LL | |         let x = c;
 LL | |         x.is_ascii()
 LL | |     });
    | |______^ help: try: `"foo".is_ascii()`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:38:5
+  --> tests/ui/needless_character_iteration.rs:43:5
    |
 LL | /     "foo".chars().any(|c| {
 LL | |
+LL | |
 LL | |         let x = c;
 LL | |         !x.is_ascii()
 LL | |     });
    | |______^ help: try: `!"foo".is_ascii()`
 
 error: checking if a string is ascii using iterators
-  --> tests/ui/needless_character_iteration.rs:44:5
+  --> tests/ui/needless_character_iteration.rs:50:5
    |
 LL |     S::default().field().chars().all(|x| x.is_ascii());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `S::default().field().is_ascii()`
diff --git a/src/tools/clippy/tests/ui/needless_collect.fixed b/src/tools/clippy/tests/ui/needless_collect.fixed
index bd83581bdd97..bad8c307586c 100644
--- a/src/tools/clippy/tests/ui/needless_collect.fixed
+++ b/src/tools/clippy/tests/ui/needless_collect.fixed
@@ -1,4 +1,10 @@
-#![allow(unused, clippy::needless_if, clippy::suspicious_map, clippy::iter_count)]
+#![allow(
+    unused,
+    clippy::needless_if,
+    clippy::suspicious_map,
+    clippy::iter_count,
+    clippy::manual_contains
+)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList};
 
@@ -7,16 +13,21 @@ use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedL
 fn main() {
     let sample = [1; 5];
     let len = sample.iter().count();
+    //~^ needless_collect
     if sample.iter().next().is_none() {
+        //~^ needless_collect
         // Empty
     }
     sample.iter().cloned().any(|x| x == 1);
+    //~^ needless_collect
     // #7164 HashMap's and BTreeMap's `len` usage should not be linted
     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().len();
     sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().len();
 
     sample.iter().map(|x| (x, x)).next().is_none();
+    //~^ needless_collect
     sample.iter().map(|x| (x, x)).next().is_none();
+    //~^ needless_collect
 
     // Notice the `HashSet`--this should not be linted
     sample.iter().collect::<HashSet<_>>().len();
@@ -24,19 +35,27 @@ fn main() {
     sample.iter().collect::<BTreeSet<_>>().len();
 
     sample.iter().count();
+    //~^ needless_collect
     sample.iter().next().is_none();
+    //~^ needless_collect
     sample.iter().cloned().any(|x| x == 1);
+    //~^ needless_collect
     sample.iter().any(|x| x == &1);
+    //~^ needless_collect
 
     // `BinaryHeap` doesn't have `contains` method
     sample.iter().count();
+    //~^ needless_collect
     sample.iter().next().is_none();
+    //~^ needless_collect
 
     // Don't lint string from str
     let _ = ["", ""].into_iter().collect::<String>().is_empty();
 
     let _ = sample.iter().next().is_none();
+    //~^ needless_collect
     let _ = sample.iter().any(|x| x == &0);
+    //~^ needless_collect
 
     struct VecWrapper<T>(Vec<T>);
     impl<T> core::ops::Deref for VecWrapper<T> {
@@ -59,14 +78,20 @@ fn main() {
     }
 
     let _ = sample.iter().next().is_none();
+    //~^ needless_collect
     let _ = sample.iter().any(|x| x == &0);
+    //~^ needless_collect
 
     #[allow(clippy::double_parens)]
     {
         Vec::<u8>::new().extend((0..10));
+        //~^ needless_collect
         foo((0..10));
+        //~^ needless_collect
         bar((0..10).collect::<Vec<_>>(), (0..10));
+        //~^ needless_collect
         baz((0..10), (), ('a'..='z'))
+        //~^ needless_collect
     }
 
     let values = [1, 2, 3, 4];
diff --git a/src/tools/clippy/tests/ui/needless_collect.rs b/src/tools/clippy/tests/ui/needless_collect.rs
index 6a81a767bbb6..3dfb5194f404 100644
--- a/src/tools/clippy/tests/ui/needless_collect.rs
+++ b/src/tools/clippy/tests/ui/needless_collect.rs
@@ -1,4 +1,10 @@
-#![allow(unused, clippy::needless_if, clippy::suspicious_map, clippy::iter_count)]
+#![allow(
+    unused,
+    clippy::needless_if,
+    clippy::suspicious_map,
+    clippy::iter_count,
+    clippy::manual_contains
+)]
 
 use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedList};
 
@@ -7,16 +13,21 @@ use std::collections::{BTreeMap, BTreeSet, BinaryHeap, HashMap, HashSet, LinkedL
 fn main() {
     let sample = [1; 5];
     let len = sample.iter().collect::<Vec<_>>().len();
+    //~^ needless_collect
     if sample.iter().collect::<Vec<_>>().is_empty() {
+        //~^ needless_collect
         // Empty
     }
     sample.iter().cloned().collect::<Vec<_>>().contains(&1);
+    //~^ needless_collect
     // #7164 HashMap's and BTreeMap's `len` usage should not be linted
     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().len();
     sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().len();
 
     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().is_empty();
+    //~^ needless_collect
     sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().is_empty();
+    //~^ needless_collect
 
     // Notice the `HashSet`--this should not be linted
     sample.iter().collect::<HashSet<_>>().len();
@@ -24,19 +35,27 @@ fn main() {
     sample.iter().collect::<BTreeSet<_>>().len();
 
     sample.iter().collect::<LinkedList<_>>().len();
+    //~^ needless_collect
     sample.iter().collect::<LinkedList<_>>().is_empty();
+    //~^ needless_collect
     sample.iter().cloned().collect::<LinkedList<_>>().contains(&1);
+    //~^ needless_collect
     sample.iter().collect::<LinkedList<_>>().contains(&&1);
+    //~^ needless_collect
 
     // `BinaryHeap` doesn't have `contains` method
     sample.iter().collect::<BinaryHeap<_>>().len();
+    //~^ needless_collect
     sample.iter().collect::<BinaryHeap<_>>().is_empty();
+    //~^ needless_collect
 
     // Don't lint string from str
     let _ = ["", ""].into_iter().collect::<String>().is_empty();
 
     let _ = sample.iter().collect::<HashSet<_>>().is_empty();
+    //~^ needless_collect
     let _ = sample.iter().collect::<HashSet<_>>().contains(&&0);
+    //~^ needless_collect
 
     struct VecWrapper<T>(Vec<T>);
     impl<T> core::ops::Deref for VecWrapper<T> {
@@ -59,14 +78,20 @@ fn main() {
     }
 
     let _ = sample.iter().collect::<VecWrapper<_>>().is_empty();
+    //~^ needless_collect
     let _ = sample.iter().collect::<VecWrapper<_>>().contains(&&0);
+    //~^ needless_collect
 
     #[allow(clippy::double_parens)]
     {
         Vec::<u8>::new().extend((0..10).collect::<Vec<_>>());
+        //~^ needless_collect
         foo((0..10).collect::<Vec<_>>());
+        //~^ needless_collect
         bar((0..10).collect::<Vec<_>>(), (0..10).collect::<Vec<_>>());
+        //~^ needless_collect
         baz((0..10), (), ('a'..='z').collect::<Vec<_>>())
+        //~^ needless_collect
     }
 
     let values = [1, 2, 3, 4];
diff --git a/src/tools/clippy/tests/ui/needless_collect.stderr b/src/tools/clippy/tests/ui/needless_collect.stderr
index ea317896d368..00745eb2923c 100644
--- a/src/tools/clippy/tests/ui/needless_collect.stderr
+++ b/src/tools/clippy/tests/ui/needless_collect.stderr
@@ -1,5 +1,5 @@
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:9:29
+  --> tests/ui/needless_collect.rs:15:29
    |
 LL |     let len = sample.iter().collect::<Vec<_>>().len();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
@@ -8,109 +8,109 @@ LL |     let len = sample.iter().collect::<Vec<_>>().len();
    = help: to override `-D warnings` add `#[allow(clippy::needless_collect)]`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:10:22
+  --> tests/ui/needless_collect.rs:17:22
    |
 LL |     if sample.iter().collect::<Vec<_>>().is_empty() {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:13:28
+  --> tests/ui/needless_collect.rs:21:28
    |
 LL |     sample.iter().cloned().collect::<Vec<_>>().contains(&1);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == 1)`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:18:35
+  --> tests/ui/needless_collect.rs:27:35
    |
 LL |     sample.iter().map(|x| (x, x)).collect::<HashMap<_, _>>().is_empty();
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:19:35
+  --> tests/ui/needless_collect.rs:29:35
    |
 LL |     sample.iter().map(|x| (x, x)).collect::<BTreeMap<_, _>>().is_empty();
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:26:19
+  --> tests/ui/needless_collect.rs:37:19
    |
 LL |     sample.iter().collect::<LinkedList<_>>().len();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:27:19
+  --> tests/ui/needless_collect.rs:39:19
    |
 LL |     sample.iter().collect::<LinkedList<_>>().is_empty();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:28:28
+  --> tests/ui/needless_collect.rs:41:28
    |
 LL |     sample.iter().cloned().collect::<LinkedList<_>>().contains(&1);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == 1)`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:29:19
+  --> tests/ui/needless_collect.rs:43:19
    |
 LL |     sample.iter().collect::<LinkedList<_>>().contains(&&1);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == &1)`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:32:19
+  --> tests/ui/needless_collect.rs:47:19
    |
 LL |     sample.iter().collect::<BinaryHeap<_>>().len();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `count()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:33:19
+  --> tests/ui/needless_collect.rs:49:19
    |
 LL |     sample.iter().collect::<BinaryHeap<_>>().is_empty();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:38:27
+  --> tests/ui/needless_collect.rs:55:27
    |
 LL |     let _ = sample.iter().collect::<HashSet<_>>().is_empty();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:39:27
+  --> tests/ui/needless_collect.rs:57:27
    |
 LL |     let _ = sample.iter().collect::<HashSet<_>>().contains(&&0);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == &0)`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:61:27
+  --> tests/ui/needless_collect.rs:80:27
    |
 LL |     let _ = sample.iter().collect::<VecWrapper<_>>().is_empty();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `next().is_none()`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:62:27
+  --> tests/ui/needless_collect.rs:82:27
    |
 LL |     let _ = sample.iter().collect::<VecWrapper<_>>().contains(&&0);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `any(|x| x == &0)`
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:66:40
+  --> tests/ui/needless_collect.rs:87:40
    |
 LL |         Vec::<u8>::new().extend((0..10).collect::<Vec<_>>());
    |                                        ^^^^^^^^^^^^^^^^^^^^ help: remove this call
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:67:20
+  --> tests/ui/needless_collect.rs:89:20
    |
 LL |         foo((0..10).collect::<Vec<_>>());
    |                    ^^^^^^^^^^^^^^^^^^^^ help: remove this call
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:68:49
+  --> tests/ui/needless_collect.rs:91:49
    |
 LL |         bar((0..10).collect::<Vec<_>>(), (0..10).collect::<Vec<_>>());
    |                                                 ^^^^^^^^^^^^^^^^^^^^ help: remove this call
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect.rs:69:37
+  --> tests/ui/needless_collect.rs:93:37
    |
 LL |         baz((0..10), (), ('a'..='z').collect::<Vec<_>>())
    |                                     ^^^^^^^^^^^^^^^^^^^^ help: remove this call
diff --git a/src/tools/clippy/tests/ui/needless_collect_indirect.rs b/src/tools/clippy/tests/ui/needless_collect_indirect.rs
index 9d66c5f255fe..57d0f2b99480 100644
--- a/src/tools/clippy/tests/ui/needless_collect_indirect.rs
+++ b/src/tools/clippy/tests/ui/needless_collect_indirect.rs
@@ -7,17 +7,20 @@ use std::collections::{BinaryHeap, HashMap, HashSet, LinkedList, VecDeque};
 fn main() {
     let sample = [1; 5];
     let indirect_iter = sample.iter().collect::<Vec<_>>();
-    //~^ ERROR: avoid using `collect()` when not needed
-    //~| NOTE: `-D clippy::needless-collect` implied by `-D warnings`
+    //~^ needless_collect
+
     indirect_iter.into_iter().map(|x| (x, x + 1)).collect::<HashMap<_, _>>();
     let indirect_len = sample.iter().collect::<VecDeque<_>>();
-    //~^ ERROR: avoid using `collect()` when not needed
+    //~^ needless_collect
+
     indirect_len.len();
     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
-    //~^ ERROR: avoid using `collect()` when not needed
+    //~^ needless_collect
+
     indirect_empty.is_empty();
     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
-    //~^ ERROR: avoid using `collect()` when not needed
+    //~^ needless_collect
+
     indirect_contains.contains(&&5);
     let indirect_negative = sample.iter().collect::<Vec<_>>();
     indirect_negative.len();
@@ -30,7 +33,8 @@ fn main() {
     let a = "a".to_string();
     let sample = vec![a.clone(), "b".to_string(), "c".to_string()];
     let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
-    //~^ ERROR: avoid using `collect()` when not needed
+    //~^ needless_collect
+
     non_copy_contains.contains(&a);
 
     // Fix #5991
@@ -60,25 +64,29 @@ mod issue7110 {
 
     fn lint_vec(string: &str) -> usize {
         let buffer: Vec<&str> = string.split('/').collect();
-        //~^ ERROR: avoid using `collect()` when not needed
+        //~^ needless_collect
+
         buffer.len()
     }
     fn lint_vec_deque() -> usize {
         let sample = [1; 5];
         let indirect_len: VecDeque<_> = sample.iter().collect();
-        //~^ ERROR: avoid using `collect()` when not needed
+        //~^ needless_collect
+
         indirect_len.len()
     }
     fn lint_linked_list() -> usize {
         let sample = [1; 5];
         let indirect_len: LinkedList<_> = sample.iter().collect();
-        //~^ ERROR: avoid using `collect()` when not needed
+        //~^ needless_collect
+
         indirect_len.len()
     }
     fn lint_binary_heap() -> usize {
         let sample = [1; 5];
         let indirect_len: BinaryHeap<_> = sample.iter().collect();
-        //~^ ERROR: avoid using `collect()` when not needed
+        //~^ needless_collect
+
         indirect_len.len()
     }
     fn dont_lint(string: &str) -> usize {
@@ -139,7 +147,8 @@ mod issue_8553 {
 
         for i in 0..2 {
             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
-            //~^ ERROR: avoid using `collect()` when not needed
+            //~^ needless_collect
+
             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
             // Do lint
             y.contains(&i);
@@ -165,7 +174,8 @@ mod issue_8553 {
 
         while n > 2 {
             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
-            //~^ ERROR: avoid using `collect()` when not needed
+            //~^ needless_collect
+
             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
             // Do lint
             y.contains(&n);
@@ -195,7 +205,8 @@ mod issue_8553 {
         loop {
             if n < 2 {
                 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
-                //~^ ERROR: avoid using `collect()` when not needed
+                //~^ needless_collect
+
                 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
                 // Do lint
                 y.contains(&n);
@@ -232,7 +243,8 @@ mod issue_8553 {
 
         while let Some(value) = optional {
             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
-            //~^ ERROR: avoid using `collect()` when not needed
+            //~^ needless_collect
+
             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
             if n < 2 {
                 // Do lint
@@ -258,7 +270,8 @@ mod issue_8553 {
         let vec = vec![1, 2];
         let v: Vec<usize> = vec.iter().map(|i| i * i).collect();
         let w = v.iter().collect::<Vec<_>>();
-        //~^ ERROR: avoid using `collect()` when not needed
+        //~^ needless_collect
+
         // Do lint
         for _ in 0..w.len() {
             todo!();
@@ -281,7 +294,8 @@ mod issue_8553 {
         let mut vec = vec![1, 2];
         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
         let mut w = v.iter().collect::<Vec<_>>();
-        //~^ ERROR: avoid using `collect()` when not needed
+        //~^ needless_collect
+
         // Do lint
         while 1 == w.len() {
             todo!();
@@ -304,7 +318,8 @@ mod issue_8553 {
         let mut vec = vec![1, 2];
         let mut v: Vec<usize> = vec.iter().map(|i| i * i).collect();
         let mut w = v.iter().collect::<Vec<_>>();
-        //~^ ERROR: avoid using `collect()` when not needed
+        //~^ needless_collect
+
         // Do lint
         while let Some(i) = Some(w.len()) {
             todo!();
diff --git a/src/tools/clippy/tests/ui/needless_collect_indirect.stderr b/src/tools/clippy/tests/ui/needless_collect_indirect.stderr
index f25c02937545..c7bf1b14df80 100644
--- a/src/tools/clippy/tests/ui/needless_collect_indirect.stderr
+++ b/src/tools/clippy/tests/ui/needless_collect_indirect.stderr
@@ -22,7 +22,7 @@ error: avoid using `collect()` when not needed
    |
 LL |     let indirect_len = sample.iter().collect::<VecDeque<_>>();
    |                                      ^^^^^^^
-LL |
+...
 LL |     indirect_len.len();
    |     ------------------ the iterator could be used here instead
    |
@@ -30,15 +30,16 @@ help: take the original Iterator's count instead of collecting it and finding th
    |
 LL ~     
 LL |
+LL |
 LL ~     sample.iter().count();
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:16:40
+  --> tests/ui/needless_collect_indirect.rs:17:40
    |
 LL |     let indirect_empty = sample.iter().collect::<VecDeque<_>>();
    |                                        ^^^^^^^
-LL |
+...
 LL |     indirect_empty.is_empty();
    |     ------------------------- the iterator could be used here instead
    |
@@ -46,15 +47,16 @@ help: check if the original Iterator has anything instead of collecting it and s
    |
 LL ~     
 LL |
+LL |
 LL ~     sample.iter().next().is_none();
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:19:43
+  --> tests/ui/needless_collect_indirect.rs:21:43
    |
 LL |     let indirect_contains = sample.iter().collect::<VecDeque<_>>();
    |                                           ^^^^^^^
-LL |
+...
 LL |     indirect_contains.contains(&&5);
    |     ------------------------------- the iterator could be used here instead
    |
@@ -62,15 +64,16 @@ help: check if the original Iterator contains an element instead of collecting t
    |
 LL ~     
 LL |
+LL |
 LL ~     sample.iter().any(|x| x == &5);
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:32:48
+  --> tests/ui/needless_collect_indirect.rs:35:48
    |
 LL |     let non_copy_contains = sample.into_iter().collect::<Vec<_>>();
    |                                                ^^^^^^^
-LL |
+...
 LL |     non_copy_contains.contains(&a);
    |     ------------------------------ the iterator could be used here instead
    |
@@ -78,15 +81,16 @@ help: check if the original Iterator contains an element instead of collecting t
    |
 LL ~     
 LL |
+LL |
 LL ~     sample.into_iter().any(|x| x == a);
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:62:51
+  --> tests/ui/needless_collect_indirect.rs:66:51
    |
 LL |         let buffer: Vec<&str> = string.split('/').collect();
    |                                                   ^^^^^^^
-LL |
+...
 LL |         buffer.len()
    |         ------------ the iterator could be used here instead
    |
@@ -94,15 +98,16 @@ help: take the original Iterator's count instead of collecting it and finding th
    |
 LL ~         
 LL |
+LL |
 LL ~         string.split('/').count()
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:68:55
+  --> tests/ui/needless_collect_indirect.rs:73:55
    |
 LL |         let indirect_len: VecDeque<_> = sample.iter().collect();
    |                                                       ^^^^^^^
-LL |
+...
 LL |         indirect_len.len()
    |         ------------------ the iterator could be used here instead
    |
@@ -110,21 +115,6 @@ help: take the original Iterator's count instead of collecting it and finding th
    |
 LL ~         
 LL |
-LL ~         sample.iter().count()
-   |
-
-error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:74:57
-   |
-LL |         let indirect_len: LinkedList<_> = sample.iter().collect();
-   |                                                         ^^^^^^^
-LL |
-LL |         indirect_len.len()
-   |         ------------------ the iterator could be used here instead
-   |
-help: take the original Iterator's count instead of collecting it and finding the length
-   |
-LL ~         
 LL |
 LL ~         sample.iter().count()
    |
@@ -132,9 +122,9 @@ LL ~         sample.iter().count()
 error: avoid using `collect()` when not needed
   --> tests/ui/needless_collect_indirect.rs:80:57
    |
-LL |         let indirect_len: BinaryHeap<_> = sample.iter().collect();
+LL |         let indirect_len: LinkedList<_> = sample.iter().collect();
    |                                                         ^^^^^^^
-LL |
+...
 LL |         indirect_len.len()
    |         ------------------ the iterator could be used here instead
    |
@@ -142,11 +132,29 @@ help: take the original Iterator's count instead of collecting it and finding th
    |
 LL ~         
 LL |
+LL |
 LL ~         sample.iter().count()
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:141:59
+  --> tests/ui/needless_collect_indirect.rs:87:57
+   |
+LL |         let indirect_len: BinaryHeap<_> = sample.iter().collect();
+   |                                                         ^^^^^^^
+...
+LL |         indirect_len.len()
+   |         ------------------ the iterator could be used here instead
+   |
+help: take the original Iterator's count instead of collecting it and finding the length
+   |
+LL ~         
+LL |
+LL |
+LL ~         sample.iter().count()
+   |
+
+error: avoid using `collect()` when not needed
+  --> tests/ui/needless_collect_indirect.rs:149:59
    |
 LL |             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
    |                                                           ^^^^^^^
@@ -158,13 +166,13 @@ help: check if the original Iterator contains an element instead of collecting t
    |
 LL ~             
 LL |
-LL |             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+...
 LL |             // Do lint
 LL ~             vec.iter().map(|k| k * k).any(|x| x == i);
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:167:59
+  --> tests/ui/needless_collect_indirect.rs:176:59
    |
 LL |             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
    |                                                           ^^^^^^^
@@ -176,13 +184,13 @@ help: check if the original Iterator contains an element instead of collecting t
    |
 LL ~             
 LL |
-LL |             let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+...
 LL |             // Do lint
 LL ~             vec.iter().map(|k| k * k).any(|x| x == n);
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:197:63
+  --> tests/ui/needless_collect_indirect.rs:207:63
    |
 LL |                 let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
    |                                                               ^^^^^^^
@@ -194,13 +202,13 @@ help: check if the original Iterator contains an element instead of collecting t
    |
 LL ~                 
 LL |
-LL |                 let z: Vec<usize> = vec.iter().map(|k| k * k).collect();
+...
 LL |                 // Do lint
 LL ~                 vec.iter().map(|k| k * k).any(|x| x == n);
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:234:59
+  --> tests/ui/needless_collect_indirect.rs:245:59
    |
 LL |             let y: Vec<usize> = vec.iter().map(|k| k * k).collect();
    |                                                           ^^^^^^^
@@ -218,7 +226,7 @@ LL ~                 vec.iter().map(|k| k * k).any(|x| x == n);
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:260:26
+  --> tests/ui/needless_collect_indirect.rs:272:26
    |
 LL |         let w = v.iter().collect::<Vec<_>>();
    |                          ^^^^^^^
@@ -230,12 +238,13 @@ help: take the original Iterator's count instead of collecting it and finding th
    |
 LL ~         
 LL |
+LL |
 LL |         // Do lint
 LL ~         for _ in 0..v.iter().count() {
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:283:30
+  --> tests/ui/needless_collect_indirect.rs:296:30
    |
 LL |         let mut w = v.iter().collect::<Vec<_>>();
    |                              ^^^^^^^
@@ -247,12 +256,13 @@ help: take the original Iterator's count instead of collecting it and finding th
    |
 LL ~         
 LL |
+LL |
 LL |         // Do lint
 LL ~         while 1 == v.iter().count() {
    |
 
 error: avoid using `collect()` when not needed
-  --> tests/ui/needless_collect_indirect.rs:306:30
+  --> tests/ui/needless_collect_indirect.rs:320:30
    |
 LL |         let mut w = v.iter().collect::<Vec<_>>();
    |                              ^^^^^^^
@@ -264,6 +274,7 @@ help: take the original Iterator's count instead of collecting it and finding th
    |
 LL ~         
 LL |
+LL |
 LL |         // Do lint
 LL ~         while let Some(i) = Some(v.iter().count()) {
    |
diff --git a/src/tools/clippy/tests/ui/needless_continue.rs b/src/tools/clippy/tests/ui/needless_continue.rs
index 334a2b32775f..e873db6dee14 100644
--- a/src/tools/clippy/tests/ui/needless_continue.rs
+++ b/src/tools/clippy/tests/ui/needless_continue.rs
@@ -28,7 +28,8 @@ fn main() {
             let i = 0;
             println!("bar {} ", i);
         } else {
-            //~^ ERROR: this `else` block is redundant
+            //~^ needless_continue
+
             continue;
         }
 
@@ -44,7 +45,8 @@ fn main() {
         }
 
         if (zero!(i % 2) || nonzero!(i % 5)) && i % 3 != 0 {
-            //~^ ERROR: there is no need for an explicit `else` block for this `if` expression
+            //~^ needless_continue
+
             continue;
         } else {
             println!("Blabber");
@@ -58,7 +60,7 @@ fn main() {
 fn simple_loop() {
     loop {
         continue;
-        //~^ ERROR: this `continue` expression is redundant
+        //~^ needless_continue
     }
 }
 
@@ -66,7 +68,7 @@ fn simple_loop2() {
     loop {
         println!("bleh");
         continue;
-        //~^ ERROR: this `continue` expression is redundant
+        //~^ needless_continue
     }
 }
 
@@ -74,7 +76,8 @@ fn simple_loop2() {
 fn simple_loop3() {
     loop {
         continue
-        //~^ ERROR: this `continue` expression is redundant
+        //~^ needless_continue
+
     }
 }
 
@@ -83,7 +86,8 @@ fn simple_loop4() {
     loop {
         println!("bleh");
         continue
-        //~^ ERROR: this `continue` expression is redundant
+        //~^ needless_continue
+
     }
 }
 
@@ -91,7 +95,7 @@ fn simple_loop5() {
     loop {
         println!("bleh");
         { continue }
-        //~^ ERROR: this `continue` expression is redundant
+        //~^ needless_continue
     }
 }
 
@@ -142,14 +146,16 @@ mod issue_2329 {
                 if condition() {
                     println!("bar-3");
                 } else {
-                    //~^ ERROR: this `else` block is redundant
+                    //~^ needless_continue
+
                     continue 'inner;
                 }
                 println!("bar-4");
 
                 update_condition();
                 if condition() {
-                    //~^ ERROR: there is no need for an explicit `else` block for this `if` ex
+                    //~^ needless_continue
+
                     continue;
                 } else {
                     println!("bar-5");
@@ -172,7 +178,7 @@ fn issue_13641() {
     while std::hint::black_box(true) {
         'b: loop {
             continue 'b;
-            //~^ ERROR: this `continue` expression is redundant
+            //~^ needless_continue
         }
     }
 }
@@ -188,9 +194,11 @@ mod issue_4077 {
                 } else if !some_expr() {
                     println!("bar-8");
                     continue 'inner;
+                    //~^ needless_continue
                 } else {
                     println!("bar-9");
                     continue 'inner;
+                    //~^ needless_continue
                 }
             }
         }
@@ -201,6 +209,7 @@ mod issue_4077 {
                 Err(_) => {
                     println!("bar-10");
                     continue;
+                    //~^ needless_continue
                 },
             }
         }
@@ -208,6 +217,7 @@ mod issue_4077 {
         loop {
             if true {
             } else {
+                //~^ needless_continue
                 // redundant `else`
                 continue; // redundant `continue`
             }
@@ -215,6 +225,7 @@ mod issue_4077 {
 
         loop {
             if some_expr() {
+                //~^ needless_continue
                 continue;
             } else {
                 do_something();
diff --git a/src/tools/clippy/tests/ui/needless_continue.stderr b/src/tools/clippy/tests/ui/needless_continue.stderr
index ec39d6234195..878c1e731e32 100644
--- a/src/tools/clippy/tests/ui/needless_continue.stderr
+++ b/src/tools/clippy/tests/ui/needless_continue.stderr
@@ -4,6 +4,7 @@ error: this `else` block is redundant
 LL |           } else {
    |  ________________^
 LL | |
+LL | |
 LL | |             continue;
 LL | |         }
    | |_________^
@@ -27,6 +28,7 @@ LL | |         }
                        }
                        if (zero!(i % 2) || nonzero!(i % 5)) && i % 3 != 0 {
 
+                       
                            continue;
                        } else {
                            println!("Blabber");
@@ -38,13 +40,13 @@ LL | |         }
    = help: to override `-D warnings` add `#[allow(clippy::needless_continue)]`
 
 error: there is no need for an explicit `else` block for this `if` expression
-  --> tests/ui/needless_continue.rs:46:9
+  --> tests/ui/needless_continue.rs:47:9
    |
 LL | /         if (zero!(i % 2) || nonzero!(i % 5)) && i % 3 != 0 {
 LL | |
+LL | |
 LL | |             continue;
-LL | |         } else {
-LL | |             println!("Blabber");
+...  |
 LL | |             println!("Jabber");
 LL | |         }
    | |_________^
@@ -52,6 +54,7 @@ LL | |         }
    = help: consider dropping the `else` clause
                    if (zero!(i % 2) || nonzero!(i % 5)) && i % 3 != 0 {
 
+           
                        continue;
                    }
                    {
@@ -60,7 +63,7 @@ LL | |         }
                    }
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:60:9
+  --> tests/ui/needless_continue.rs:62:9
    |
 LL |         continue;
    |         ^^^^^^^^
@@ -68,7 +71,7 @@ LL |         continue;
    = help: consider dropping the `continue` expression
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:68:9
+  --> tests/ui/needless_continue.rs:70:9
    |
 LL |         continue;
    |         ^^^^^^^^
@@ -76,7 +79,7 @@ LL |         continue;
    = help: consider dropping the `continue` expression
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:76:9
+  --> tests/ui/needless_continue.rs:78:9
    |
 LL |         continue
    |         ^^^^^^^^
@@ -84,7 +87,7 @@ LL |         continue
    = help: consider dropping the `continue` expression
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:85:9
+  --> tests/ui/needless_continue.rs:88:9
    |
 LL |         continue
    |         ^^^^^^^^
@@ -92,7 +95,7 @@ LL |         continue
    = help: consider dropping the `continue` expression
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:93:11
+  --> tests/ui/needless_continue.rs:97:11
    |
 LL |         { continue }
    |           ^^^^^^^^
@@ -100,11 +103,12 @@ LL |         { continue }
    = help: consider dropping the `continue` expression
 
 error: this `else` block is redundant
-  --> tests/ui/needless_continue.rs:144:24
+  --> tests/ui/needless_continue.rs:148:24
    |
 LL |                   } else {
    |  ________________________^
 LL | |
+LL | |
 LL | |                     continue 'inner;
 LL | |                 }
    | |_________________^
@@ -117,6 +121,7 @@ LL | |                 }
                                update_condition();
                                if condition() {
 
+                               
                                    continue;
                                } else {
                                    println!("bar-5");
@@ -125,10 +130,11 @@ LL | |                 }
                            }
 
 error: there is no need for an explicit `else` block for this `if` expression
-  --> tests/ui/needless_continue.rs:151:17
+  --> tests/ui/needless_continue.rs:156:17
    |
 LL | /                 if condition() {
 LL | |
+LL | |
 LL | |                     continue;
 LL | |                 } else {
 LL | |                     println!("bar-5");
@@ -138,6 +144,7 @@ LL | |                 }
    = help: consider dropping the `else` clause
                            if condition() {
 
+           
                                continue;
                            }
                            {
@@ -145,7 +152,7 @@ LL | |                 }
                            }
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:174:13
+  --> tests/ui/needless_continue.rs:180:13
    |
 LL |             continue 'b;
    |             ^^^^^^^^^^^
@@ -153,7 +160,7 @@ LL |             continue 'b;
    = help: consider dropping the `continue` expression
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:190:21
+  --> tests/ui/needless_continue.rs:196:21
    |
 LL |                     continue 'inner;
    |                     ^^^^^^^^^^^^^^^
@@ -161,7 +168,7 @@ LL |                     continue 'inner;
    = help: consider dropping the `continue` expression
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:193:21
+  --> tests/ui/needless_continue.rs:200:21
    |
 LL |                     continue 'inner;
    |                     ^^^^^^^^^^^^^^^
@@ -169,7 +176,7 @@ LL |                     continue 'inner;
    = help: consider dropping the `continue` expression
 
 error: this `continue` expression is redundant
-  --> tests/ui/needless_continue.rs:203:21
+  --> tests/ui/needless_continue.rs:211:21
    |
 LL |                     continue;
    |                     ^^^^^^^^
@@ -177,10 +184,11 @@ LL |                     continue;
    = help: consider dropping the `continue` expression
 
 error: this `else` block is redundant
-  --> tests/ui/needless_continue.rs:210:20
+  --> tests/ui/needless_continue.rs:219:20
    |
 LL |               } else {
    |  ____________________^
+LL | |
 LL | |                 // redundant `else`
 LL | |                 continue; // redundant `continue`
 LL | |             }
@@ -193,9 +201,10 @@ LL | |             }
                        }
 
 error: there is no need for an explicit `else` block for this `if` expression
-  --> tests/ui/needless_continue.rs:217:13
+  --> tests/ui/needless_continue.rs:227:13
    |
 LL | /             if some_expr() {
+LL | |
 LL | |                 continue;
 LL | |             } else {
 LL | |                 do_something();
@@ -204,6 +213,7 @@ LL | |             }
    |
    = help: consider dropping the `else` clause
                        if some_expr() {
+
                            continue;
                        }
                        {
diff --git a/src/tools/clippy/tests/ui/needless_doc_main.rs b/src/tools/clippy/tests/ui/needless_doc_main.rs
index fee05926ce4f..cf01cae2e8fd 100644
--- a/src/tools/clippy/tests/ui/needless_doc_main.rs
+++ b/src/tools/clippy/tests/ui/needless_doc_main.rs
@@ -6,7 +6,6 @@
 /// ```
 /// fn main() {
 //~^ ERROR: needless `fn main` in doctest
-//~| NOTE: `-D clippy::needless-doctest-main` implied by `-D warnings`
 ///     unimplemented!();
 /// }
 /// ```
diff --git a/src/tools/clippy/tests/ui/needless_doc_main.stderr b/src/tools/clippy/tests/ui/needless_doc_main.stderr
index 7e362cf377ce..9ba2ad306dac 100644
--- a/src/tools/clippy/tests/ui/needless_doc_main.stderr
+++ b/src/tools/clippy/tests/ui/needless_doc_main.stderr
@@ -4,7 +4,6 @@ error: needless `fn main` in doctest
 LL |   /// fn main() {
    |  _____^
 LL | |
-LL | |
 LL | | ///     unimplemented!();
 LL | | /// }
    | |_____^
@@ -13,7 +12,7 @@ LL | | /// }
    = help: to override `-D warnings` add `#[allow(clippy::needless_doctest_main)]`
 
 error: needless `fn main` in doctest
-  --> tests/ui/needless_doc_main.rs:16:5
+  --> tests/ui/needless_doc_main.rs:15:5
    |
 LL |   /// fn main() -> () {
    |  _____^
@@ -23,7 +22,7 @@ LL | | /// }
    | |_____^
 
 error: needless `fn main` in doctest
-  --> tests/ui/needless_doc_main.rs:24:5
+  --> tests/ui/needless_doc_main.rs:23:5
    |
 LL |   /// fn main() {
    |  _____^
@@ -33,7 +32,7 @@ LL | | /// }
    | |_____^
 
 error: needless `fn main` in doctest
-  --> tests/ui/needless_doc_main.rs:32:5
+  --> tests/ui/needless_doc_main.rs:31:5
    |
 LL |   /// // the fn is not always the first line
    |  _____^
diff --git a/src/tools/clippy/tests/ui/needless_else.fixed b/src/tools/clippy/tests/ui/needless_else.fixed
index 240b79bae13c..0455910c3ee8 100644
--- a/src/tools/clippy/tests/ui/needless_else.fixed
+++ b/src/tools/clippy/tests/ui/needless_else.fixed
@@ -21,6 +21,7 @@ fn main() {
     if b {
         println!("Foobar");
     } 
+    //~^^ needless_else
 
     if b {
         println!("Foobar");
diff --git a/src/tools/clippy/tests/ui/needless_else.rs b/src/tools/clippy/tests/ui/needless_else.rs
index ad84da170535..236ac631a49e 100644
--- a/src/tools/clippy/tests/ui/needless_else.rs
+++ b/src/tools/clippy/tests/ui/needless_else.rs
@@ -22,6 +22,7 @@ fn main() {
         println!("Foobar");
     } else {
     }
+    //~^^ needless_else
 
     if b {
         println!("Foobar");
diff --git a/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed b/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed
index 2362314290e6..fa23e18318f1 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed
+++ b/src/tools/clippy/tests/ui/needless_for_each_fixable.fixed
@@ -13,27 +13,34 @@ fn should_lint() {
     let v: Vec<i32> = Vec::new();
     let mut acc = 0;
     for elem in v.iter() {
+        //~^ needless_for_each
         acc += elem;
     }
     for elem in v.into_iter() {
+        //~^ needless_for_each
         acc += elem;
     }
 
     for elem in [1, 2, 3].iter() {
+        //~^ needless_for_each
         acc += elem;
     }
 
     let mut hash_map: HashMap<i32, i32> = HashMap::new();
     for (k, v) in hash_map.iter() {
+        //~^ needless_for_each
         acc += k + v;
     }
     for (k, v) in hash_map.iter_mut() {
+        //~^ needless_for_each
         acc += *k + *v;
     }
     for k in hash_map.keys() {
+        //~^ needless_for_each
         acc += k;
     }
     for v in hash_map.values() {
+        //~^ needless_for_each
         acc += v;
     }
 
@@ -41,6 +48,7 @@ fn should_lint() {
         Vec::new()
     }
     for elem in my_vec().iter() {
+        //~^ needless_for_each
         acc += elem;
     }
 }
diff --git a/src/tools/clippy/tests/ui/needless_for_each_fixable.rs b/src/tools/clippy/tests/ui/needless_for_each_fixable.rs
index 5b1186daa229..2c7e68a6f512 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_fixable.rs
+++ b/src/tools/clippy/tests/ui/needless_for_each_fixable.rs
@@ -13,27 +13,34 @@ fn should_lint() {
     let v: Vec<i32> = Vec::new();
     let mut acc = 0;
     v.iter().for_each(|elem| {
+        //~^ needless_for_each
         acc += elem;
     });
     v.into_iter().for_each(|elem| {
+        //~^ needless_for_each
         acc += elem;
     });
 
     [1, 2, 3].iter().for_each(|elem| {
+        //~^ needless_for_each
         acc += elem;
     });
 
     let mut hash_map: HashMap<i32, i32> = HashMap::new();
     hash_map.iter().for_each(|(k, v)| {
+        //~^ needless_for_each
         acc += k + v;
     });
     hash_map.iter_mut().for_each(|(k, v)| {
+        //~^ needless_for_each
         acc += *k + *v;
     });
     hash_map.keys().for_each(|k| {
+        //~^ needless_for_each
         acc += k;
     });
     hash_map.values().for_each(|v| {
+        //~^ needless_for_each
         acc += v;
     });
 
@@ -41,6 +48,7 @@ fn should_lint() {
         Vec::new()
     }
     my_vec().iter().for_each(|elem| {
+        //~^ needless_for_each
         acc += elem;
     });
 }
diff --git a/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr b/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr
index 21342d052561..013a3fa3e36d 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr
+++ b/src/tools/clippy/tests/ui/needless_for_each_fixable.stderr
@@ -2,6 +2,7 @@ error: needless use of `for_each`
   --> tests/ui/needless_for_each_fixable.rs:15:5
    |
 LL | /     v.iter().for_each(|elem| {
+LL | |
 LL | |         acc += elem;
 LL | |     });
    | |_______^
@@ -11,14 +12,16 @@ LL | |     });
 help: try
    |
 LL ~     for elem in v.iter() {
+LL +
 LL +         acc += elem;
 LL +     }
    |
 
 error: needless use of `for_each`
-  --> tests/ui/needless_for_each_fixable.rs:18:5
+  --> tests/ui/needless_for_each_fixable.rs:19:5
    |
 LL | /     v.into_iter().for_each(|elem| {
+LL | |
 LL | |         acc += elem;
 LL | |     });
    | |_______^
@@ -26,14 +29,16 @@ LL | |     });
 help: try
    |
 LL ~     for elem in v.into_iter() {
+LL +
 LL +         acc += elem;
 LL +     }
    |
 
 error: needless use of `for_each`
-  --> tests/ui/needless_for_each_fixable.rs:22:5
+  --> tests/ui/needless_for_each_fixable.rs:24:5
    |
 LL | /     [1, 2, 3].iter().for_each(|elem| {
+LL | |
 LL | |         acc += elem;
 LL | |     });
    | |_______^
@@ -41,14 +46,16 @@ LL | |     });
 help: try
    |
 LL ~     for elem in [1, 2, 3].iter() {
+LL +
 LL +         acc += elem;
 LL +     }
    |
 
 error: needless use of `for_each`
-  --> tests/ui/needless_for_each_fixable.rs:27:5
+  --> tests/ui/needless_for_each_fixable.rs:30:5
    |
 LL | /     hash_map.iter().for_each(|(k, v)| {
+LL | |
 LL | |         acc += k + v;
 LL | |     });
    | |_______^
@@ -56,14 +63,16 @@ LL | |     });
 help: try
    |
 LL ~     for (k, v) in hash_map.iter() {
+LL +
 LL +         acc += k + v;
 LL +     }
    |
 
 error: needless use of `for_each`
-  --> tests/ui/needless_for_each_fixable.rs:30:5
+  --> tests/ui/needless_for_each_fixable.rs:34:5
    |
 LL | /     hash_map.iter_mut().for_each(|(k, v)| {
+LL | |
 LL | |         acc += *k + *v;
 LL | |     });
    | |_______^
@@ -71,14 +80,16 @@ LL | |     });
 help: try
    |
 LL ~     for (k, v) in hash_map.iter_mut() {
+LL +
 LL +         acc += *k + *v;
 LL +     }
    |
 
 error: needless use of `for_each`
-  --> tests/ui/needless_for_each_fixable.rs:33:5
+  --> tests/ui/needless_for_each_fixable.rs:38:5
    |
 LL | /     hash_map.keys().for_each(|k| {
+LL | |
 LL | |         acc += k;
 LL | |     });
    | |_______^
@@ -86,14 +97,16 @@ LL | |     });
 help: try
    |
 LL ~     for k in hash_map.keys() {
+LL +
 LL +         acc += k;
 LL +     }
    |
 
 error: needless use of `for_each`
-  --> tests/ui/needless_for_each_fixable.rs:36:5
+  --> tests/ui/needless_for_each_fixable.rs:42:5
    |
 LL | /     hash_map.values().for_each(|v| {
+LL | |
 LL | |         acc += v;
 LL | |     });
    | |_______^
@@ -101,14 +114,16 @@ LL | |     });
 help: try
    |
 LL ~     for v in hash_map.values() {
+LL +
 LL +         acc += v;
 LL +     }
    |
 
 error: needless use of `for_each`
-  --> tests/ui/needless_for_each_fixable.rs:43:5
+  --> tests/ui/needless_for_each_fixable.rs:50:5
    |
 LL | /     my_vec().iter().for_each(|elem| {
+LL | |
 LL | |         acc += elem;
 LL | |     });
    | |_______^
@@ -116,6 +131,7 @@ LL | |     });
 help: try
    |
 LL ~     for elem in my_vec().iter() {
+LL +
 LL +         acc += elem;
 LL +     }
    |
diff --git a/src/tools/clippy/tests/ui/needless_for_each_unfixable.rs b/src/tools/clippy/tests/ui/needless_for_each_unfixable.rs
index 2220cf9e11ee..159cbe49828f 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_unfixable.rs
+++ b/src/tools/clippy/tests/ui/needless_for_each_unfixable.rs
@@ -6,8 +6,8 @@ fn main() {
     let v: Vec<i32> = Vec::new();
     // This is unfixable because the closure includes `return`.
     v.iter().for_each(|v| {
-        //~^ ERROR: needless use of `for_each`
-        //~| NOTE: `-D clippy::needless-for-each` implied by `-D warnings`
+        //~^ needless_for_each
+
         if *v == 10 {
             return;
         } else {
diff --git a/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr b/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr
index 722016b12125..3a3a240c5a3a 100644
--- a/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/needless_for_each_unfixable.stderr
@@ -15,7 +15,7 @@ help: try
    |
 LL ~     for v in v.iter() {
 LL +
-LL +
+LL + 
 LL +         if *v == 10 {
 LL +             return;
 LL +         } else {
diff --git a/src/tools/clippy/tests/ui/needless_if.fixed b/src/tools/clippy/tests/ui/needless_if.fixed
index 79e33a7218b7..6208ca19b82b 100644
--- a/src/tools/clippy/tests/ui/needless_if.fixed
+++ b/src/tools/clippy/tests/ui/needless_if.fixed
@@ -25,13 +25,16 @@ fn maybe_side_effect() -> bool {
 fn main() {
     // Lint
     
+    //~^ needless_if
     // Do not remove the condition
     maybe_side_effect();
+    //~^ needless_if
     // Do not lint
     if (true) {
     } else {
     }
     ({
+        //~^ needless_if
         return;
     });
     // Do not lint if `else if` is present
@@ -48,6 +51,7 @@ fn main() {
     {}
     // Can lint nested `if let`s
     ({
+        //~^ needless_if
         if let true = true
             && true
         {
@@ -91,12 +95,15 @@ fn main() {
 
     // Must be placed into an expression context to not be interpreted as a block
     ({ maybe_side_effect() });
+    //~^ needless_if
     // Would be a block followed by `&&true` - a double reference to `true`
     ({ maybe_side_effect() } && true);
+    //~^ needless_if
 
     // Don't leave trailing attributes
     #[allow(unused)]
     true;
+    //~^ needless_if
 
     let () = if maybe_side_effect() {};
 }
diff --git a/src/tools/clippy/tests/ui/needless_if.rs b/src/tools/clippy/tests/ui/needless_if.rs
index 2c135fb22bf8..b459ff877be6 100644
--- a/src/tools/clippy/tests/ui/needless_if.rs
+++ b/src/tools/clippy/tests/ui/needless_if.rs
@@ -25,13 +25,16 @@ fn maybe_side_effect() -> bool {
 fn main() {
     // Lint
     if (true) {}
+    //~^ needless_if
     // Do not remove the condition
     if maybe_side_effect() {}
+    //~^ needless_if
     // Do not lint
     if (true) {
     } else {
     }
     if {
+        //~^ needless_if
         return;
     } {}
     // Do not lint if `else if` is present
@@ -48,6 +51,7 @@ fn main() {
     {}
     // Can lint nested `if let`s
     if {
+        //~^ needless_if
         if let true = true
             && true
         {
@@ -92,12 +96,15 @@ fn main() {
 
     // Must be placed into an expression context to not be interpreted as a block
     if { maybe_side_effect() } {}
+    //~^ needless_if
     // Would be a block followed by `&&true` - a double reference to `true`
     if { maybe_side_effect() } && true {}
+    //~^ needless_if
 
     // Don't leave trailing attributes
     #[allow(unused)]
     if true {}
+    //~^ needless_if
 
     let () = if maybe_side_effect() {};
 }
diff --git a/src/tools/clippy/tests/ui/needless_if.stderr b/src/tools/clippy/tests/ui/needless_if.stderr
index cbfeb979d2f2..eeb8d044526d 100644
--- a/src/tools/clippy/tests/ui/needless_if.stderr
+++ b/src/tools/clippy/tests/ui/needless_if.stderr
@@ -8,15 +8,16 @@ LL |     if (true) {}
    = help: to override `-D warnings` add `#[allow(clippy::needless_if)]`
 
 error: this `if` branch is empty
-  --> tests/ui/needless_if.rs:29:5
+  --> tests/ui/needless_if.rs:30:5
    |
 LL |     if maybe_side_effect() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `maybe_side_effect();`
 
 error: this `if` branch is empty
-  --> tests/ui/needless_if.rs:34:5
+  --> tests/ui/needless_if.rs:36:5
    |
 LL | /     if {
+LL | |
 LL | |         return;
 LL | |     } {}
    | |________^
@@ -24,14 +25,16 @@ LL | |     } {}
 help: you can remove it
    |
 LL ~     ({
+LL +
 LL +         return;
 LL +     });
    |
 
 error: this `if` branch is empty
-  --> tests/ui/needless_if.rs:50:5
+  --> tests/ui/needless_if.rs:53:5
    |
 LL | /     if {
+LL | |
 LL | |         if let true = true
 LL | |             && true
 ...  |
@@ -42,6 +45,7 @@ LL | |     {}
 help: you can remove it
    |
 LL ~     ({
+LL +
 LL +         if let true = true
 LL +             && true
 LL +         {
@@ -53,19 +57,19 @@ LL +     } && true);
    |
 
 error: this `if` branch is empty
-  --> tests/ui/needless_if.rs:94:5
+  --> tests/ui/needless_if.rs:98:5
    |
 LL |     if { maybe_side_effect() } {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() });`
 
 error: this `if` branch is empty
-  --> tests/ui/needless_if.rs:96:5
+  --> tests/ui/needless_if.rs:101:5
    |
 LL |     if { maybe_side_effect() } && true {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can remove it: `({ maybe_side_effect() } && true);`
 
 error: this `if` branch is empty
-  --> tests/ui/needless_if.rs:100:5
+  --> tests/ui/needless_if.rs:106:5
    |
 LL |     if true {}
    |     ^^^^^^^^^^ help: you can remove it: `true;`
diff --git a/src/tools/clippy/tests/ui/needless_late_init.fixed b/src/tools/clippy/tests/ui/needless_late_init.fixed
index b4bd53ce7bf7..eb67e6cc8282 100644
--- a/src/tools/clippy/tests/ui/needless_late_init.fixed
+++ b/src/tools/clippy/tests/ui/needless_late_init.fixed
@@ -25,22 +25,28 @@ impl std::ops::Drop for SignificantDrop {
 
 fn simple() {
     
+    //~^ needless_late_init
     let a = "zero";
 
     
+    //~^ needless_late_init
     
+    //~^ needless_late_init
     let b = 1;
     let c = 2;
 
     
+    //~^ needless_late_init
     let d: usize = 1;
 
     
+    //~^ needless_late_init
     let e = format!("{}", d);
 }
 
 fn main() {
     
+    //~^ needless_late_init
     let n = 1;
     let a = match n {
         1 => "one",
@@ -50,6 +56,7 @@ fn main() {
     };
 
     
+    //~^ needless_late_init
     let b = if n == 3 {
         "four"
     } else {
@@ -57,6 +64,7 @@ fn main() {
     };
 
     
+    //~^ needless_late_init
     let d = if true {
         let temp = 5;
         temp
@@ -65,6 +73,7 @@ fn main() {
     };
 
     
+    //~^ needless_late_init
     let e = if true {
         format!("{} {}", a, b)
     } else {
@@ -72,12 +81,14 @@ fn main() {
     };
 
     
+    //~^ needless_late_init
     let f = match 1 {
         1 => "three",
         _ => return,
     }; // has semi
 
     
+    //~^ needless_late_init
     let g: usize = if true {
         5
     } else {
@@ -86,14 +97,17 @@ fn main() {
 
     // Drop order only matters if both are significant
     
+    //~^ needless_late_init
     let y = SignificantDrop;
     let x = 1;
 
     
+    //~^ needless_late_init
     let y = 1;
     let x = SignificantDrop;
 
     
+    //~^ needless_late_init
     // types that should be considered insignificant
     let y = 1;
     let y = "2";
@@ -113,6 +127,7 @@ async fn in_async() -> &'static str {
     }
 
     
+    //~^ needless_late_init
     let n = 1;
     let a = match n {
         1 => f().await,
@@ -130,6 +145,7 @@ const fn in_const() -> &'static str {
     }
 
     
+    //~^ needless_late_init
     let n = 1;
     let a = match n {
         1 => f(),
diff --git a/src/tools/clippy/tests/ui/needless_late_init.rs b/src/tools/clippy/tests/ui/needless_late_init.rs
index e25483625a68..7de2202dc323 100644
--- a/src/tools/clippy/tests/ui/needless_late_init.rs
+++ b/src/tools/clippy/tests/ui/needless_late_init.rs
@@ -25,22 +25,28 @@ impl std::ops::Drop for SignificantDrop {
 
 fn simple() {
     let a;
+    //~^ needless_late_init
     a = "zero";
 
     let b;
+    //~^ needless_late_init
     let c;
+    //~^ needless_late_init
     b = 1;
     c = 2;
 
     let d: usize;
+    //~^ needless_late_init
     d = 1;
 
     let e;
+    //~^ needless_late_init
     e = format!("{}", d);
 }
 
 fn main() {
     let a;
+    //~^ needless_late_init
     let n = 1;
     match n {
         1 => a = "one",
@@ -50,6 +56,7 @@ fn main() {
     }
 
     let b;
+    //~^ needless_late_init
     if n == 3 {
         b = "four";
     } else {
@@ -57,6 +64,7 @@ fn main() {
     }
 
     let d;
+    //~^ needless_late_init
     if true {
         let temp = 5;
         d = temp;
@@ -65,6 +73,7 @@ fn main() {
     }
 
     let e;
+    //~^ needless_late_init
     if true {
         e = format!("{} {}", a, b);
     } else {
@@ -72,12 +81,14 @@ fn main() {
     }
 
     let f;
+    //~^ needless_late_init
     match 1 {
         1 => f = "three",
         _ => return,
     }; // has semi
 
     let g: usize;
+    //~^ needless_late_init
     if true {
         g = 5;
     } else {
@@ -86,14 +97,17 @@ fn main() {
 
     // Drop order only matters if both are significant
     let x;
+    //~^ needless_late_init
     let y = SignificantDrop;
     x = 1;
 
     let x;
+    //~^ needless_late_init
     let y = 1;
     x = SignificantDrop;
 
     let x;
+    //~^ needless_late_init
     // types that should be considered insignificant
     let y = 1;
     let y = "2";
@@ -113,6 +127,7 @@ async fn in_async() -> &'static str {
     }
 
     let a;
+    //~^ needless_late_init
     let n = 1;
     match n {
         1 => a = f().await,
@@ -130,6 +145,7 @@ const fn in_const() -> &'static str {
     }
 
     let a;
+    //~^ needless_late_init
     let n = 1;
     match n {
         1 => a = f(),
diff --git a/src/tools/clippy/tests/ui/needless_late_init.stderr b/src/tools/clippy/tests/ui/needless_late_init.stderr
index de048091cfbe..02fd2811da58 100644
--- a/src/tools/clippy/tests/ui/needless_late_init.stderr
+++ b/src/tools/clippy/tests/ui/needless_late_init.stderr
@@ -3,6 +3,7 @@ error: unneeded late initialization
    |
 LL |     let a;
    |     ^^^^^^ created here
+LL |
 LL |     a = "zero";
    |     ^^^^^^^^^^ initialised here
    |
@@ -11,71 +12,79 @@ LL |     a = "zero";
 help: move the declaration `a` here
    |
 LL ~     
+LL |
 LL ~     let a = "zero";
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:30:5
+  --> tests/ui/needless_late_init.rs:31:5
    |
 LL |     let b;
    |     ^^^^^^ created here
-LL |     let c;
+...
 LL |     b = 1;
    |     ^^^^^ initialised here
    |
 help: move the declaration `b` here
    |
 LL ~     
+LL |
 LL |     let c;
+LL |
 LL ~     let b = 1;
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:31:5
+  --> tests/ui/needless_late_init.rs:33:5
    |
 LL |     let c;
    |     ^^^^^^ created here
-LL |     b = 1;
+...
 LL |     c = 2;
    |     ^^^^^ initialised here
    |
 help: move the declaration `c` here
    |
 LL ~     
+LL |
 LL |     b = 1;
 LL ~     let c = 2;
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:35:5
+  --> tests/ui/needless_late_init.rs:38:5
    |
 LL |     let d: usize;
    |     ^^^^^^^^^^^^^ created here
+LL |
 LL |     d = 1;
    |     ^^^^^ initialised here
    |
 help: move the declaration `d` here
    |
 LL ~     
+LL |
 LL ~     let d: usize = 1;
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:38:5
+  --> tests/ui/needless_late_init.rs:42:5
    |
 LL |     let e;
    |     ^^^^^^ created here
+LL |
 LL |     e = format!("{}", d);
    |     ^^^^^^^^^^^^^^^^^^^^ initialised here
    |
 help: move the declaration `e` here
    |
 LL ~     
+LL |
 LL ~     let e = format!("{}", d);
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:43:5
+  --> tests/ui/needless_late_init.rs:48:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -83,6 +92,7 @@ LL |     let a;
 help: move the declaration `a` here and remove the assignments from the `match` arms
    |
 LL ~     
+LL |
 LL |     let n = 1;
 LL ~     let a = match n {
 LL ~         1 => "one",
@@ -93,7 +103,7 @@ LL ~     };
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:52:5
+  --> tests/ui/needless_late_init.rs:58:5
    |
 LL |     let b;
    |     ^^^^^^
@@ -101,6 +111,7 @@ LL |     let b;
 help: move the declaration `b` here and remove the assignments from the branches
    |
 LL ~     
+LL |
 LL ~     let b = if n == 3 {
 LL ~         "four"
 LL |     } else {
@@ -109,7 +120,7 @@ LL ~     };
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:59:5
+  --> tests/ui/needless_late_init.rs:66:5
    |
 LL |     let d;
    |     ^^^^^^
@@ -117,6 +128,7 @@ LL |     let d;
 help: move the declaration `d` here and remove the assignments from the branches
    |
 LL ~     
+LL |
 LL ~     let d = if true {
 LL |         let temp = 5;
 LL ~         temp
@@ -126,7 +138,7 @@ LL ~     };
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:67:5
+  --> tests/ui/needless_late_init.rs:75:5
    |
 LL |     let e;
    |     ^^^^^^
@@ -134,6 +146,7 @@ LL |     let e;
 help: move the declaration `e` here and remove the assignments from the branches
    |
 LL ~     
+LL |
 LL ~     let e = if true {
 LL ~         format!("{} {}", a, b)
 LL |     } else {
@@ -142,7 +155,7 @@ LL ~     };
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:74:5
+  --> tests/ui/needless_late_init.rs:83:5
    |
 LL |     let f;
    |     ^^^^^^
@@ -150,12 +163,13 @@ LL |     let f;
 help: move the declaration `f` here and remove the assignments from the `match` arms
    |
 LL ~     
+LL |
 LL ~     let f = match 1 {
 LL ~         1 => "three",
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:80:5
+  --> tests/ui/needless_late_init.rs:90:5
    |
 LL |     let g: usize;
    |     ^^^^^^^^^^^^^
@@ -163,6 +177,7 @@ LL |     let g: usize;
 help: move the declaration `g` here and remove the assignments from the branches
    |
 LL ~     
+LL |
 LL ~     let g: usize = if true {
 LL ~         5
 LL |     } else {
@@ -171,39 +186,24 @@ LL ~     };
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:88:5
+  --> tests/ui/needless_late_init.rs:99:5
    |
 LL |     let x;
    |     ^^^^^^ created here
-LL |     let y = SignificantDrop;
+...
 LL |     x = 1;
    |     ^^^^^ initialised here
    |
 help: move the declaration `x` here
    |
 LL ~     
+LL |
 LL |     let y = SignificantDrop;
 LL ~     let x = 1;
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:92:5
-   |
-LL |     let x;
-   |     ^^^^^^ created here
-LL |     let y = 1;
-LL |     x = SignificantDrop;
-   |     ^^^^^^^^^^^^^^^^^^^ initialised here
-   |
-help: move the declaration `x` here
-   |
-LL ~     
-LL |     let y = 1;
-LL ~     let x = SignificantDrop;
-   |
-
-error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:96:5
+  --> tests/ui/needless_late_init.rs:104:5
    |
 LL |     let x;
    |     ^^^^^^ created here
@@ -214,14 +214,31 @@ LL |     x = SignificantDrop;
 help: move the declaration `x` here
    |
 LL ~     
-LL |     // types that should be considered insignificant
+LL |
+LL |     let y = 1;
+LL ~     let x = SignificantDrop;
+   |
+
+error: unneeded late initialization
+  --> tests/ui/needless_late_init.rs:109:5
+   |
+LL |     let x;
+   |     ^^^^^^ created here
+...
+LL |     x = SignificantDrop;
+   |     ^^^^^^^^^^^^^^^^^^^ initialised here
+   |
+help: move the declaration `x` here
+   |
+LL ~     
+LL |
 ...
 LL |     let y = Box::new(4);
 LL ~     let x = SignificantDrop;
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:115:5
+  --> tests/ui/needless_late_init.rs:129:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -229,6 +246,7 @@ LL |     let a;
 help: move the declaration `a` here and remove the assignments from the `match` arms
    |
 LL ~     
+LL |
 LL |     let n = 1;
 LL ~     let a = match n {
 LL ~         1 => f().await,
@@ -239,7 +257,7 @@ LL ~     };
    |
 
 error: unneeded late initialization
-  --> tests/ui/needless_late_init.rs:132:5
+  --> tests/ui/needless_late_init.rs:147:5
    |
 LL |     let a;
    |     ^^^^^^
@@ -247,6 +265,7 @@ LL |     let a;
 help: move the declaration `a` here and remove the assignments from the `match` arms
    |
 LL ~     
+LL |
 LL |     let n = 1;
 LL ~     let a = match n {
 LL ~         1 => f(),
diff --git a/src/tools/clippy/tests/ui/needless_lifetimes.fixed b/src/tools/clippy/tests/ui/needless_lifetimes.fixed
index 86cf9a9cdb63..d59393fb3f3c 100644
--- a/src/tools/clippy/tests/ui/needless_lifetimes.fixed
+++ b/src/tools/clippy/tests/ui/needless_lifetimes.fixed
@@ -1,6 +1,6 @@
 //@aux-build:proc_macros.rs
 
-#![warn(clippy::needless_lifetimes)]
+#![warn(clippy::needless_lifetimes, clippy::elidable_lifetime_names)]
 #![allow(
     unused,
     clippy::boxed_local,
@@ -9,15 +9,18 @@
     clippy::redundant_allocation,
     clippy::unnecessary_wraps,
     dyn_drop,
-    clippy::get_first
+    clippy::get_first,
+    elided_named_lifetimes
 )]
 
 extern crate proc_macros;
 use proc_macros::inline_macros;
 
 fn distinct_lifetimes(_x: &u8, _y: &u8, _z: u8) {}
+//~^ needless_lifetimes
 
 fn distinct_and_static(_x: &u8, _y: &u8, _z: &'static u8) {}
+//~^ needless_lifetimes
 
 // No error; same lifetime on two params.
 fn same_lifetime_on_input<'a>(_x: &'a u8, _y: &'a u8) {}
@@ -28,6 +31,7 @@ fn only_static_on_input(_x: &u8, _y: &u8, _z: &'static u8) {}
 fn mut_and_static_input(_x: &mut u8, _y: &'static str) {}
 
 fn in_and_out(x: &u8, _y: u8) -> &u8 {
+    //~^ needless_lifetimes
     x
 }
 
@@ -40,6 +44,7 @@ fn multiple_in_and_out_1<'a>(x: &'a u8, _y: &'a u8) -> &'a u8 {
 //   fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8
 //                                                ^^^
 fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8 {
+    //~^ needless_lifetimes
     x
 }
 
@@ -47,6 +52,7 @@ fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8 {
 //   fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8
 //                                     ^^^
 fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8 {
+    //~^ needless_lifetimes
     y
 }
 
@@ -64,6 +70,7 @@ fn in_static_and_out<'a>(x: &'a u8, _y: &'static u8) -> &'a u8 {
 //   fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()>
 //                                           ^^^
 fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()> {
+    //~^ needless_lifetimes
     Ok(x)
 }
 
@@ -71,6 +78,7 @@ fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()> {
 //   fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()>
 //                                ^^^
 fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()> {
+    //~^ needless_lifetimes
     Ok(y)
 }
 
@@ -80,53 +88,19 @@ fn deep_reference_2<'a>(x: Result<&'a u8, &'a u8>) -> &'a u8 {
 }
 
 fn deep_reference_3(x: &u8, _y: u8) -> Result<&u8, ()> {
+    //~^ needless_lifetimes
     Ok(x)
 }
 
 // Where-clause, but without lifetimes.
 fn where_clause_without_lt<T>(x: &u8, _y: u8) -> Result<&u8, ()>
+//~^ needless_lifetimes
 where
     T: Copy,
 {
     Ok(x)
 }
 
-type Ref<'r> = &'r u8;
-
-// No error; same lifetime on two params.
-fn lifetime_param_1<'a>(_x: Ref<'a>, _y: &'a u8) {}
-
-fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
-
-// No error; bounded lifetime.
-fn lifetime_param_3<'a, 'b: 'a>(_x: Ref<'a>, _y: &'b u8) {}
-
-// No error; bounded lifetime.
-fn lifetime_param_4<'a, 'b>(_x: Ref<'a>, _y: &'b u8)
-where
-    'b: 'a,
-{
-}
-
-struct Lt<'a, I: 'static> {
-    x: &'a I,
-}
-
-// No error; fn bound references `'a`.
-fn fn_bound<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-where
-    F: Fn(Lt<'a, I>) -> Lt<'a, I>,
-{
-    unreachable!()
-}
-
-fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
-where
-    for<'x> F: Fn(Lt<'x, I>) -> Lt<'x, I>,
-{
-    unreachable!()
-}
-
 // No error; see below.
 fn fn_bound_3<'a, F: FnOnce(&'a i32)>(x: &'a i32, f: F) {
     f(x);
@@ -151,6 +125,7 @@ struct X {
 
 impl X {
     fn self_and_out(&self) -> &u8 {
+        //~^ needless_lifetimes
         &self.x
     }
 
@@ -158,6 +133,7 @@ impl X {
     //   fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8
     //                                          ^^^
     fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8 {
+        //~^ needless_lifetimes
         &self.x
     }
 
@@ -165,10 +141,12 @@ impl X {
     //   fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8
     //                            ^^^^^
     fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8 {
+        //~^ needless_lifetimes
         x
     }
 
     fn distinct_self_and_in(&self, _x: &u8) {}
+    //~^ needless_lifetimes
 
     // No error; same lifetimes on two params.
     fn self_and_same_in<'s>(&'s self, _x: &'s u8) {}
@@ -187,33 +165,12 @@ fn already_elided<'a>(_: &u8, _: &'a u8) -> &'a u8 {
     unimplemented!()
 }
 
-fn struct_with_lt(_foo: Foo<'_>) -> &str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (named on the reference, anonymous on `Foo`).
-fn struct_with_lt2<'a>(_foo: &'a Foo) -> &'a str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (anonymous on the reference, named on `Foo`).
-fn struct_with_lt3<'a>(_foo: &Foo<'a>) -> &'a str {
-    unimplemented!()
-}
-
-// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
-// valid:
-//   fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str
-//                                         ^^
-fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
-    unimplemented!()
-}
-
 // Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
 // valid:
 //   fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str
 //                                 ^^^^
 fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
@@ -229,42 +186,23 @@ fn trait_obj_elided<'a>(_arg: &'a dyn WithLifetime) -> &'a str {
 // Should warn because there is no lifetime on `Drop`, so this would be
 // unambiguous if we elided the lifetime.
 fn trait_obj_elided2(_arg: &dyn Drop) -> &str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
 type FooAlias<'a> = Foo<'a>;
 
-fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (named on the reference, anonymous on `FooAlias`).
-fn alias_with_lt2<'a>(_foo: &'a FooAlias) -> &'a str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (anonymous on the reference, named on `FooAlias`).
-fn alias_with_lt3<'a>(_foo: &FooAlias<'a>) -> &'a str {
-    unimplemented!()
-}
-
-// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
-// valid:
-//   fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str
-//                                             ^^
-fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
-    unimplemented!()
-}
-
 // Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
 // valid:
 //   fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str
 //                                ^^^^^^^^^
 fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
 fn named_input_elided_output(_arg: &str) -> &str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
@@ -273,6 +211,7 @@ fn elided_input_named_output<'a>(_arg: &str) -> &'a str {
 }
 
 fn trait_bound_ok<T: WithLifetime<'static>>(_: &u8, _: T) {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 fn trait_bound<'a, T: WithLifetime<'a>>(_: &'a u8, _: T) {
@@ -304,37 +243,16 @@ fn test<'a>(x: &'a [u8]) -> u8 {
     *y
 }
 
-// Issue #3284: give hint regarding lifetime in return type.
-struct Cow<'a> {
-    x: &'a str,
-}
-fn out_return_type_lts(e: &str) -> Cow<'_> {
-    unimplemented!()
-}
-
 // Make sure we still warn on implementations
 mod issue4291 {
     trait BadTrait {
         fn needless_lt(x: &u8) {}
+        //~^ needless_lifetimes
     }
 
     impl BadTrait for () {
         fn needless_lt(_x: &u8) {}
-    }
-}
-
-mod issue2944 {
-    trait Foo {}
-    struct Bar;
-    struct Baz<'a> {
-        bar: &'a Bar,
-    }
-
-    impl Foo for Baz<'_> {}
-    impl Bar {
-        fn baz(&self) -> impl Foo + '_ {
-            Baz { bar: self }
-        }
+        //~^ needless_lifetimes
     }
 }
 
@@ -365,6 +283,7 @@ mod nested_elision_sites {
         f(i)
     }
     fn impl_trait_elidable_nested_anonymous_lifetimes(i: &i32, f: impl Fn(&i32) -> &i32) -> &i32 {
+        //~^ needless_lifetimes
         f(i)
     }
 
@@ -374,6 +293,7 @@ mod nested_elision_sites {
     }
     // lint
     fn generics_elidable<T: Fn(&i32) -> &i32>(i: &i32, f: T) -> &i32 {
+        //~^ needless_lifetimes
         f(i)
     }
 
@@ -386,6 +306,7 @@ mod nested_elision_sites {
     }
     // lint
     fn where_clause_elidable<T>(i: &i32, f: T) -> &i32
+    //~^ needless_lifetimes
     where
         T: Fn(&i32) -> &i32,
     {
@@ -401,6 +322,7 @@ mod nested_elision_sites {
     }
     // lint
     fn pointer_fn_elidable(i: &i32, f: fn(&i32) -> &i32) -> &i32 {
+        //~^ needless_lifetimes
         f(i)
     }
 
@@ -414,9 +336,11 @@ mod nested_elision_sites {
 
     // lint
     fn nested_fn_pointer_3(_: &i32) -> fn(fn(&i32) -> &i32) -> i32 {
+        //~^ needless_lifetimes
         |f| 42
     }
     fn nested_fn_pointer_4(_: &i32) -> impl Fn(fn(&i32)) {
+        //~^ needless_lifetimes
         |f| ()
     }
 }
@@ -439,17 +363,21 @@ mod issue7296 {
     struct Foo;
     impl Foo {
         fn implicit(&self) -> &() {
+            //~^ needless_lifetimes
             &()
         }
         fn implicit_mut(&mut self) -> &() {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.81"]
         fn explicit(self: &Arc<Self>) -> &() {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.81"]
         fn explicit_mut(self: &mut Rc<Self>) -> &() {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.80"]
@@ -462,20 +390,25 @@ mod issue7296 {
         }
 
         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &() {
+            //~^ needless_lifetimes
             &()
         }
     }
 
     trait Bar {
         fn implicit(&self) -> &();
+        //~^ needless_lifetimes
         fn implicit_provided(&self) -> &() {
+            //~^ needless_lifetimes
             &()
         }
 
         #[clippy::msrv = "1.81"]
         fn explicit(self: &Arc<Self>) -> &();
+        //~^ needless_lifetimes
         #[clippy::msrv = "1.81"]
         fn explicit_provided(self: &Arc<Self>) -> &() {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.80"]
@@ -486,7 +419,9 @@ mod issue7296 {
         }
 
         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &();
+        //~^ needless_lifetimes
         fn lifetime_elsewhere_provided(self: Box<Self>, here: &()) -> &() {
+            //~^ needless_lifetimes
             &()
         }
     }
@@ -496,8 +431,10 @@ mod pr_9743_false_negative_fix {
     #![allow(unused)]
 
     fn foo(x: &u8, y: &'_ u8) {}
+    //~^ needless_lifetimes
 
     fn bar(x: &u8, y: &'_ u8, z: &'_ u8) {}
+    //~^ needless_lifetimes
 }
 
 mod pr_9743_output_lifetime_checks {
@@ -505,11 +442,13 @@ mod pr_9743_output_lifetime_checks {
 
     // lint: only one input
     fn one_input(x: &u8) -> &u8 {
+        //~^ needless_lifetimes
         unimplemented!()
     }
 
     // lint: multiple inputs, output would not be elided
     fn multiple_inputs_output_not_elided<'b>(x: &u8, y: &'b u8, z: &'b u8) -> &'b u8 {
+        //~^ needless_lifetimes
         unimplemented!()
     }
 
@@ -526,6 +465,7 @@ mod in_macro {
     // lint local macro expands to function with needless lifetimes
     inline! {
         fn one_input(x: &u8) -> &u8 {
+        //~^ needless_lifetimes
             unimplemented!()
         }
     }
@@ -594,85 +534,4 @@ mod issue13749bis {
     impl<'a, T: 'a> Generic<T> {}
 }
 
-mod issue13923 {
-    struct Py<'py> {
-        data: &'py str,
-    }
-
-    enum Content<'t, 'py> {
-        Py(Py<'py>),
-        T1(&'t str),
-        T2(&'t str),
-    }
-
-    enum ContentString<'t> {
-        T1(&'t str),
-        T2(&'t str),
-    }
-
-    impl<'t, 'py> ContentString<'t> {
-        // `'py` cannot be elided
-        fn map_content1(self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(content) => Content::T2(f(content)),
-            }
-        }
-    }
-
-    impl<'t> ContentString<'t> {
-        // `'py` can be elided because of `&self`
-        fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(content) => Content::T2(f(content)),
-            }
-        }
-    }
-
-    impl<'t> ContentString<'t> {
-        // `'py` can be elided because of `&'_ self`
-        fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(content) => Content::T2(f(content)),
-            }
-        }
-    }
-
-    impl<'t, 'py> ContentString<'t> {
-        // `'py` should not be elided as the default lifetime, even if working, could be named as `'t`
-        fn map_content4(self, f: impl FnOnce(&'t str) -> &'t str, o: &'t str) -> Content<'t, 'py> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(_) => Content::T2(o),
-            }
-        }
-    }
-
-    impl<'t> ContentString<'t> {
-        // `'py` can be elided because of `&Self`
-        fn map_content5(
-            self: std::pin::Pin<&Self>,
-            f: impl FnOnce(&'t str) -> &'t str,
-            o: &'t str,
-        ) -> Content<'t, '_> {
-            match *self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(_) => Content::T2(o),
-            }
-        }
-    }
-
-    struct Cx<'a, 'b> {
-        a: &'a u32,
-        b: &'b u32,
-    }
-
-    // `'c` cannot be elided because we have several input lifetimes
-    fn one_explicit<'b>(x: Cx<'_, 'b>) -> &'b u32 {
-        x.b
-    }
-}
-
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/needless_lifetimes.rs b/src/tools/clippy/tests/ui/needless_lifetimes.rs
index 1ee0f4c6092a..e24907ab5fcd 100644
--- a/src/tools/clippy/tests/ui/needless_lifetimes.rs
+++ b/src/tools/clippy/tests/ui/needless_lifetimes.rs
@@ -1,6 +1,6 @@
 //@aux-build:proc_macros.rs
 
-#![warn(clippy::needless_lifetimes)]
+#![warn(clippy::needless_lifetimes, clippy::elidable_lifetime_names)]
 #![allow(
     unused,
     clippy::boxed_local,
@@ -9,15 +9,18 @@
     clippy::redundant_allocation,
     clippy::unnecessary_wraps,
     dyn_drop,
-    clippy::get_first
+    clippy::get_first,
+    elided_named_lifetimes
 )]
 
 extern crate proc_macros;
 use proc_macros::inline_macros;
 
 fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
+//~^ needless_lifetimes
 
 fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
+//~^ needless_lifetimes
 
 // No error; same lifetime on two params.
 fn same_lifetime_on_input<'a>(_x: &'a u8, _y: &'a u8) {}
@@ -28,6 +31,7 @@ fn only_static_on_input(_x: &u8, _y: &u8, _z: &'static u8) {}
 fn mut_and_static_input(_x: &mut u8, _y: &'static str) {}
 
 fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
+    //~^ needless_lifetimes
     x
 }
 
@@ -40,6 +44,7 @@ fn multiple_in_and_out_1<'a>(x: &'a u8, _y: &'a u8) -> &'a u8 {
 //   fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8
 //                                                ^^^
 fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
+    //~^ needless_lifetimes
     x
 }
 
@@ -47,6 +52,7 @@ fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
 //   fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8
 //                                     ^^^
 fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
+    //~^ needless_lifetimes
     y
 }
 
@@ -64,6 +70,7 @@ fn in_static_and_out<'a>(x: &'a u8, _y: &'static u8) -> &'a u8 {
 //   fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()>
 //                                           ^^^
 fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
+    //~^ needless_lifetimes
     Ok(x)
 }
 
@@ -71,6 +78,7 @@ fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
 //   fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()>
 //                                ^^^
 fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
+    //~^ needless_lifetimes
     Ok(y)
 }
 
@@ -80,53 +88,19 @@ fn deep_reference_2<'a>(x: Result<&'a u8, &'a u8>) -> &'a u8 {
 }
 
 fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
+    //~^ needless_lifetimes
     Ok(x)
 }
 
 // Where-clause, but without lifetimes.
 fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
+//~^ needless_lifetimes
 where
     T: Copy,
 {
     Ok(x)
 }
 
-type Ref<'r> = &'r u8;
-
-// No error; same lifetime on two params.
-fn lifetime_param_1<'a>(_x: Ref<'a>, _y: &'a u8) {}
-
-fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
-
-// No error; bounded lifetime.
-fn lifetime_param_3<'a, 'b: 'a>(_x: Ref<'a>, _y: &'b u8) {}
-
-// No error; bounded lifetime.
-fn lifetime_param_4<'a, 'b>(_x: Ref<'a>, _y: &'b u8)
-where
-    'b: 'a,
-{
-}
-
-struct Lt<'a, I: 'static> {
-    x: &'a I,
-}
-
-// No error; fn bound references `'a`.
-fn fn_bound<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-where
-    F: Fn(Lt<'a, I>) -> Lt<'a, I>,
-{
-    unreachable!()
-}
-
-fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-where
-    for<'x> F: Fn(Lt<'x, I>) -> Lt<'x, I>,
-{
-    unreachable!()
-}
-
 // No error; see below.
 fn fn_bound_3<'a, F: FnOnce(&'a i32)>(x: &'a i32, f: F) {
     f(x);
@@ -151,6 +125,7 @@ struct X {
 
 impl X {
     fn self_and_out<'s>(&'s self) -> &'s u8 {
+        //~^ needless_lifetimes
         &self.x
     }
 
@@ -158,6 +133,7 @@ impl X {
     //   fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8
     //                                          ^^^
     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
+        //~^ needless_lifetimes
         &self.x
     }
 
@@ -165,10 +141,12 @@ impl X {
     //   fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8
     //                            ^^^^^
     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
+        //~^ needless_lifetimes
         x
     }
 
     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
+    //~^ needless_lifetimes
 
     // No error; same lifetimes on two params.
     fn self_and_same_in<'s>(&'s self, _x: &'s u8) {}
@@ -187,33 +165,12 @@ fn already_elided<'a>(_: &u8, _: &'a u8) -> &'a u8 {
     unimplemented!()
 }
 
-fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (named on the reference, anonymous on `Foo`).
-fn struct_with_lt2<'a>(_foo: &'a Foo) -> &'a str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (anonymous on the reference, named on `Foo`).
-fn struct_with_lt3<'a>(_foo: &Foo<'a>) -> &'a str {
-    unimplemented!()
-}
-
-// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
-// valid:
-//   fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str
-//                                         ^^
-fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
-    unimplemented!()
-}
-
 // Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
 // valid:
 //   fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str
 //                                 ^^^^
 fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
@@ -229,42 +186,23 @@ fn trait_obj_elided<'a>(_arg: &'a dyn WithLifetime) -> &'a str {
 // Should warn because there is no lifetime on `Drop`, so this would be
 // unambiguous if we elided the lifetime.
 fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
 type FooAlias<'a> = Foo<'a>;
 
-fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (named on the reference, anonymous on `FooAlias`).
-fn alias_with_lt2<'a>(_foo: &'a FooAlias) -> &'a str {
-    unimplemented!()
-}
-
-// No warning; two input lifetimes (anonymous on the reference, named on `FooAlias`).
-fn alias_with_lt3<'a>(_foo: &FooAlias<'a>) -> &'a str {
-    unimplemented!()
-}
-
-// Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
-// valid:
-//   fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str
-//                                             ^^
-fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
-    unimplemented!()
-}
-
 // Warning; two input lifetimes, but the output lifetime is not elided, i.e., the following is
 // valid:
 //   fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str
 //                                ^^^^^^^^^
 fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
 fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 
@@ -273,6 +211,7 @@ fn elided_input_named_output<'a>(_arg: &str) -> &'a str {
 }
 
 fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
+    //~^ needless_lifetimes
     unimplemented!()
 }
 fn trait_bound<'a, T: WithLifetime<'a>>(_: &'a u8, _: T) {
@@ -304,37 +243,16 @@ fn test<'a>(x: &'a [u8]) -> u8 {
     *y
 }
 
-// Issue #3284: give hint regarding lifetime in return type.
-struct Cow<'a> {
-    x: &'a str,
-}
-fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
-    unimplemented!()
-}
-
 // Make sure we still warn on implementations
 mod issue4291 {
     trait BadTrait {
         fn needless_lt<'a>(x: &'a u8) {}
+        //~^ needless_lifetimes
     }
 
     impl BadTrait for () {
         fn needless_lt<'a>(_x: &'a u8) {}
-    }
-}
-
-mod issue2944 {
-    trait Foo {}
-    struct Bar;
-    struct Baz<'a> {
-        bar: &'a Bar,
-    }
-
-    impl<'a> Foo for Baz<'a> {}
-    impl Bar {
-        fn baz<'a>(&'a self) -> impl Foo + 'a {
-            Baz { bar: self }
-        }
+        //~^ needless_lifetimes
     }
 }
 
@@ -365,6 +283,7 @@ mod nested_elision_sites {
         f(i)
     }
     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
+        //~^ needless_lifetimes
         f(i)
     }
 
@@ -374,6 +293,7 @@ mod nested_elision_sites {
     }
     // lint
     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
+        //~^ needless_lifetimes
         f(i)
     }
 
@@ -386,6 +306,7 @@ mod nested_elision_sites {
     }
     // lint
     fn where_clause_elidable<'a, T>(i: &'a i32, f: T) -> &'a i32
+    //~^ needless_lifetimes
     where
         T: Fn(&i32) -> &i32,
     {
@@ -401,6 +322,7 @@ mod nested_elision_sites {
     }
     // lint
     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
+        //~^ needless_lifetimes
         f(i)
     }
 
@@ -414,9 +336,11 @@ mod nested_elision_sites {
 
     // lint
     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
+        //~^ needless_lifetimes
         |f| 42
     }
     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
+        //~^ needless_lifetimes
         |f| ()
     }
 }
@@ -439,17 +363,21 @@ mod issue7296 {
     struct Foo;
     impl Foo {
         fn implicit<'a>(&'a self) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
         fn implicit_mut<'a>(&'a mut self) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.81"]
         fn explicit<'a>(self: &'a Arc<Self>) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.81"]
         fn explicit_mut<'a>(self: &'a mut Rc<Self>) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.80"]
@@ -462,20 +390,25 @@ mod issue7296 {
         }
 
         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
     }
 
     trait Bar {
         fn implicit<'a>(&'a self) -> &'a ();
+        //~^ needless_lifetimes
         fn implicit_provided<'a>(&'a self) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
 
         #[clippy::msrv = "1.81"]
         fn explicit<'a>(self: &'a Arc<Self>) -> &'a ();
+        //~^ needless_lifetimes
         #[clippy::msrv = "1.81"]
         fn explicit_provided<'a>(self: &'a Arc<Self>) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
         #[clippy::msrv = "1.80"]
@@ -486,7 +419,9 @@ mod issue7296 {
         }
 
         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
+        //~^ needless_lifetimes
         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
+            //~^ needless_lifetimes
             &()
         }
     }
@@ -496,8 +431,10 @@ mod pr_9743_false_negative_fix {
     #![allow(unused)]
 
     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
+    //~^ needless_lifetimes
 
     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
+    //~^ needless_lifetimes
 }
 
 mod pr_9743_output_lifetime_checks {
@@ -505,11 +442,13 @@ mod pr_9743_output_lifetime_checks {
 
     // lint: only one input
     fn one_input<'a>(x: &'a u8) -> &'a u8 {
+        //~^ needless_lifetimes
         unimplemented!()
     }
 
     // lint: multiple inputs, output would not be elided
     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
+        //~^ needless_lifetimes
         unimplemented!()
     }
 
@@ -526,6 +465,7 @@ mod in_macro {
     // lint local macro expands to function with needless lifetimes
     inline! {
         fn one_input<'a>(x: &'a u8) -> &'a u8 {
+        //~^ needless_lifetimes
             unimplemented!()
         }
     }
@@ -594,85 +534,4 @@ mod issue13749bis {
     impl<'a, T: 'a> Generic<T> {}
 }
 
-mod issue13923 {
-    struct Py<'py> {
-        data: &'py str,
-    }
-
-    enum Content<'t, 'py> {
-        Py(Py<'py>),
-        T1(&'t str),
-        T2(&'t str),
-    }
-
-    enum ContentString<'t> {
-        T1(&'t str),
-        T2(&'t str),
-    }
-
-    impl<'t, 'py> ContentString<'t> {
-        // `'py` cannot be elided
-        fn map_content1(self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(content) => Content::T2(f(content)),
-            }
-        }
-    }
-
-    impl<'t, 'py> ContentString<'t> {
-        // `'py` can be elided because of `&self`
-        fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(content) => Content::T2(f(content)),
-            }
-        }
-    }
-
-    impl<'t, 'py> ContentString<'t> {
-        // `'py` can be elided because of `&'_ self`
-        fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(content) => Content::T2(f(content)),
-            }
-        }
-    }
-
-    impl<'t, 'py> ContentString<'t> {
-        // `'py` should not be elided as the default lifetime, even if working, could be named as `'t`
-        fn map_content4(self, f: impl FnOnce(&'t str) -> &'t str, o: &'t str) -> Content<'t, 'py> {
-            match self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(_) => Content::T2(o),
-            }
-        }
-    }
-
-    impl<'t, 'py> ContentString<'t> {
-        // `'py` can be elided because of `&Self`
-        fn map_content5(
-            self: std::pin::Pin<&Self>,
-            f: impl FnOnce(&'t str) -> &'t str,
-            o: &'t str,
-        ) -> Content<'t, 'py> {
-            match *self {
-                Self::T1(content) => Content::T1(f(content)),
-                Self::T2(_) => Content::T2(o),
-            }
-        }
-    }
-
-    struct Cx<'a, 'b> {
-        a: &'a u32,
-        b: &'b u32,
-    }
-
-    // `'c` cannot be elided because we have several input lifetimes
-    fn one_explicit<'b>(x: Cx<'_, 'b>) -> &'b u32 {
-        &x.b
-    }
-}
-
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/needless_lifetimes.stderr b/src/tools/clippy/tests/ui/needless_lifetimes.stderr
index 465d529bf16c..138d0498c43e 100644
--- a/src/tools/clippy/tests/ui/needless_lifetimes.stderr
+++ b/src/tools/clippy/tests/ui/needless_lifetimes.stderr
@@ -1,16 +1,5 @@
-error: elided lifetime has a name
-  --> tests/ui/needless_lifetimes.rs:267:52
-   |
-LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
-   |                              --                    ^ this elided lifetime gets resolved as `'a`
-   |                              |
-   |                              lifetime `'a` declared here
-   |
-   = note: `-D elided-named-lifetimes` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(elided_named_lifetimes)]`
-
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> tests/ui/needless_lifetimes.rs:18:23
+  --> tests/ui/needless_lifetimes.rs:19:23
    |
 LL | fn distinct_lifetimes<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: u8) {}
    |                       ^^  ^^       ^^          ^^
@@ -24,7 +13,7 @@ LL + fn distinct_lifetimes(_x: &u8, _y: &u8, _z: u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a, 'b
-  --> tests/ui/needless_lifetimes.rs:20:24
+  --> tests/ui/needless_lifetimes.rs:22:24
    |
 LL | fn distinct_and_static<'a, 'b>(_x: &'a u8, _y: &'b u8, _z: &'static u8) {}
    |                        ^^  ^^       ^^          ^^
@@ -36,7 +25,7 @@ LL + fn distinct_and_static(_x: &u8, _y: &u8, _z: &'static u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:30:15
+  --> tests/ui/needless_lifetimes.rs:33:15
    |
 LL | fn in_and_out<'a>(x: &'a u8, _y: u8) -> &'a u8 {
    |               ^^      ^^                 ^^
@@ -48,7 +37,7 @@ LL + fn in_and_out(x: &u8, _y: u8) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> tests/ui/needless_lifetimes.rs:42:31
+  --> tests/ui/needless_lifetimes.rs:46:31
    |
 LL | fn multiple_in_and_out_2a<'a, 'b>(x: &'a u8, _y: &'b u8) -> &'a u8 {
    |                               ^^                  ^^
@@ -60,7 +49,7 @@ LL + fn multiple_in_and_out_2a<'a>(x: &'a u8, _y: &u8) -> &'a u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:49:27
+  --> tests/ui/needless_lifetimes.rs:54:27
    |
 LL | fn multiple_in_and_out_2b<'a, 'b>(_x: &'a u8, y: &'b u8) -> &'b u8 {
    |                           ^^           ^^
@@ -72,7 +61,7 @@ LL + fn multiple_in_and_out_2b<'b>(_x: &u8, y: &'b u8) -> &'b u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'b
-  --> tests/ui/needless_lifetimes.rs:66:26
+  --> tests/ui/needless_lifetimes.rs:72:26
    |
 LL | fn deep_reference_1a<'a, 'b>(x: &'a u8, _y: &'b u8) -> Result<&'a u8, ()> {
    |                          ^^                  ^^
@@ -84,7 +73,7 @@ LL + fn deep_reference_1a<'a>(x: &'a u8, _y: &u8) -> Result<&'a u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:73:22
+  --> tests/ui/needless_lifetimes.rs:80:22
    |
 LL | fn deep_reference_1b<'a, 'b>(_x: &'a u8, y: &'b u8) -> Result<&'b u8, ()> {
    |                      ^^           ^^
@@ -96,7 +85,7 @@ LL + fn deep_reference_1b<'b>(_x: &u8, y: &'b u8) -> Result<&'b u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:82:21
+  --> tests/ui/needless_lifetimes.rs:90:21
    |
 LL | fn deep_reference_3<'a>(x: &'a u8, _y: u8) -> Result<&'a u8, ()> {
    |                     ^^      ^^                        ^^
@@ -108,7 +97,7 @@ LL + fn deep_reference_3(x: &u8, _y: u8) -> Result<&u8, ()> {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:87:28
+  --> tests/ui/needless_lifetimes.rs:96:28
    |
 LL | fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
    |                            ^^         ^^                        ^^
@@ -119,32 +108,8 @@ LL - fn where_clause_without_lt<'a, T>(x: &'a u8, _y: u8) -> Result<&'a u8, ()>
 LL + fn where_clause_without_lt<T>(x: &u8, _y: u8) -> Result<&u8, ()>
    |
 
-error: the following explicit lifetimes could be elided: 'a, 'b
-  --> tests/ui/needless_lifetimes.rs:99:21
-   |
-LL | fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
-   |                     ^^  ^^          ^^        ^^
-   |
-help: elide the lifetimes
-   |
-LL - fn lifetime_param_2<'a, 'b>(_x: Ref<'a>, _y: &'b u8) {}
-LL + fn lifetime_param_2(_x: Ref<'_>, _y: &u8) {}
-   |
-
-error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:123:15
-   |
-LL | fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-   |               ^^               ^^                   ^^
-   |
-help: elide the lifetimes
-   |
-LL - fn fn_bound_2<'a, F, I>(_m: Lt<'a, I>, _f: F) -> Lt<'a, I>
-LL + fn fn_bound_2<F, I>(_m: Lt<'_, I>, _f: F) -> Lt<'_, I>
-   |
-
 error: the following explicit lifetimes could be elided: 's
-  --> tests/ui/needless_lifetimes.rs:153:21
+  --> tests/ui/needless_lifetimes.rs:127:21
    |
 LL |     fn self_and_out<'s>(&'s self) -> &'s u8 {
    |                     ^^   ^^           ^^
@@ -156,7 +121,7 @@ LL +     fn self_and_out(&self) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 't
-  --> tests/ui/needless_lifetimes.rs:160:30
+  --> tests/ui/needless_lifetimes.rs:135:30
    |
 LL |     fn self_and_in_out_1<'s, 't>(&'s self, _x: &'t u8) -> &'s u8 {
    |                              ^^                 ^^
@@ -168,7 +133,7 @@ LL +     fn self_and_in_out_1<'s>(&'s self, _x: &u8) -> &'s u8 {
    |
 
 error: the following explicit lifetimes could be elided: 's
-  --> tests/ui/needless_lifetimes.rs:167:26
+  --> tests/ui/needless_lifetimes.rs:143:26
    |
 LL |     fn self_and_in_out_2<'s, 't>(&'s self, x: &'t u8) -> &'t u8 {
    |                          ^^       ^^
@@ -180,7 +145,7 @@ LL +     fn self_and_in_out_2<'t>(&self, x: &'t u8) -> &'t u8 {
    |
 
 error: the following explicit lifetimes could be elided: 's, 't
-  --> tests/ui/needless_lifetimes.rs:171:29
+  --> tests/ui/needless_lifetimes.rs:148:29
    |
 LL |     fn distinct_self_and_in<'s, 't>(&'s self, _x: &'t u8) {}
    |                             ^^  ^^   ^^            ^^
@@ -192,31 +157,7 @@ LL +     fn distinct_self_and_in(&self, _x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:190:19
-   |
-LL | fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
-   |                   ^^            ^^       ^^
-   |
-help: elide the lifetimes
-   |
-LL - fn struct_with_lt<'a>(_foo: Foo<'a>) -> &'a str {
-LL + fn struct_with_lt(_foo: Foo<'_>) -> &str {
-   |
-
-error: the following explicit lifetimes could be elided: 'b
-  --> tests/ui/needless_lifetimes.rs:208:25
-   |
-LL | fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
-   |                         ^^                ^^
-   |
-help: elide the lifetimes
-   |
-LL - fn struct_with_lt4a<'a, 'b>(_foo: &'a Foo<'b>) -> &'a str {
-LL + fn struct_with_lt4a<'a>(_foo: &'a Foo<'_>) -> &'a str {
-   |
-
-error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:216:21
+  --> tests/ui/needless_lifetimes.rs:172:21
    |
 LL | fn struct_with_lt4b<'a, 'b>(_foo: &'a Foo<'b>) -> &'b str {
    |                     ^^             ^^
@@ -228,7 +169,7 @@ LL + fn struct_with_lt4b<'b>(_foo: &Foo<'b>) -> &'b str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:231:22
+  --> tests/ui/needless_lifetimes.rs:188:22
    |
 LL | fn trait_obj_elided2<'a>(_arg: &'a dyn Drop) -> &'a str {
    |                      ^^         ^^               ^^
@@ -240,31 +181,7 @@ LL + fn trait_obj_elided2(_arg: &dyn Drop) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:237:18
-   |
-LL | fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
-   |                  ^^                 ^^       ^^
-   |
-help: elide the lifetimes
-   |
-LL - fn alias_with_lt<'a>(_foo: FooAlias<'a>) -> &'a str {
-LL + fn alias_with_lt(_foo: FooAlias<'_>) -> &str {
-   |
-
-error: the following explicit lifetimes could be elided: 'b
-  --> tests/ui/needless_lifetimes.rs:255:24
-   |
-LL | fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
-   |                        ^^                     ^^
-   |
-help: elide the lifetimes
-   |
-LL - fn alias_with_lt4a<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'a str {
-LL + fn alias_with_lt4a<'a>(_foo: &'a FooAlias<'_>) -> &'a str {
-   |
-
-error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:263:20
+  --> tests/ui/needless_lifetimes.rs:199:20
    |
 LL | fn alias_with_lt4b<'a, 'b>(_foo: &'a FooAlias<'b>) -> &'b str {
    |                    ^^             ^^
@@ -276,7 +193,7 @@ LL + fn alias_with_lt4b<'b>(_foo: &FooAlias<'b>) -> &'b str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:267:30
+  --> tests/ui/needless_lifetimes.rs:204:30
    |
 LL | fn named_input_elided_output<'a>(_arg: &'a str) -> &str {
    |                              ^^         ^^          ^
@@ -288,7 +205,7 @@ LL + fn named_input_elided_output(_arg: &str) -> &str {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:275:19
+  --> tests/ui/needless_lifetimes.rs:213:19
    |
 LL | fn trait_bound_ok<'a, T: WithLifetime<'static>>(_: &'a u8, _: T) {
    |                   ^^                                ^^
@@ -300,19 +217,7 @@ LL + fn trait_bound_ok<T: WithLifetime<'static>>(_: &u8, _: T) {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:311:24
-   |
-LL | fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
-   |                        ^^      ^^             ^^
-   |
-help: elide the lifetimes
-   |
-LL - fn out_return_type_lts<'a>(e: &'a str) -> Cow<'a> {
-LL + fn out_return_type_lts(e: &str) -> Cow<'_> {
-   |
-
-error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:318:24
+  --> tests/ui/needless_lifetimes.rs:249:24
    |
 LL |         fn needless_lt<'a>(x: &'a u8) {}
    |                        ^^      ^^
@@ -324,7 +229,7 @@ LL +         fn needless_lt(x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:322:24
+  --> tests/ui/needless_lifetimes.rs:254:24
    |
 LL |         fn needless_lt<'a>(_x: &'a u8) {}
    |                        ^^       ^^
@@ -336,31 +241,7 @@ LL +         fn needless_lt(_x: &u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:333:10
-   |
-LL |     impl<'a> Foo for Baz<'a> {}
-   |          ^^              ^^
-   |
-help: elide the lifetimes
-   |
-LL -     impl<'a> Foo for Baz<'a> {}
-LL +     impl Foo for Baz<'_> {}
-   |
-
-error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:335:16
-   |
-LL |         fn baz<'a>(&'a self) -> impl Foo + 'a {
-   |                ^^   ^^                     ^^
-   |
-help: elide the lifetimes
-   |
-LL -         fn baz<'a>(&'a self) -> impl Foo + 'a {
-LL +         fn baz(&self) -> impl Foo + '_ {
-   |
-
-error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:367:55
+  --> tests/ui/needless_lifetimes.rs:285:55
    |
 LL |     fn impl_trait_elidable_nested_anonymous_lifetimes<'a>(i: &'a i32, f: impl Fn(&i32) -> &i32) -> &'a i32 {
    |                                                       ^^      ^^                                    ^^
@@ -372,7 +253,7 @@ LL +     fn impl_trait_elidable_nested_anonymous_lifetimes(i: &i32, f: impl Fn(&
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:376:26
+  --> tests/ui/needless_lifetimes.rs:295:26
    |
 LL |     fn generics_elidable<'a, T: Fn(&i32) -> &i32>(i: &'a i32, f: T) -> &'a i32 {
    |                          ^^                           ^^                ^^
@@ -384,7 +265,7 @@ LL +     fn generics_elidable<T: Fn(&i32) -> &i32>(i: &i32, f: T) -> &i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:388:30
+  --> tests/ui/needless_lifetimes.rs:308:30
    |
 LL |     fn where_clause_elidable<'a, T>(i: &'a i32, f: T) -> &'a i32
    |                              ^^         ^^                ^^
@@ -396,7 +277,7 @@ LL +     fn where_clause_elidable<T>(i: &i32, f: T) -> &i32
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:403:28
+  --> tests/ui/needless_lifetimes.rs:324:28
    |
 LL |     fn pointer_fn_elidable<'a>(i: &'a i32, f: fn(&i32) -> &i32) -> &'a i32 {
    |                            ^^      ^^                               ^^
@@ -408,7 +289,7 @@ LL +     fn pointer_fn_elidable(i: &i32, f: fn(&i32) -> &i32) -> &i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:416:28
+  --> tests/ui/needless_lifetimes.rs:338:28
    |
 LL |     fn nested_fn_pointer_3<'a>(_: &'a i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |                            ^^      ^^
@@ -420,7 +301,7 @@ LL +     fn nested_fn_pointer_3(_: &i32) -> fn(fn(&i32) -> &i32) -> i32 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:419:28
+  --> tests/ui/needless_lifetimes.rs:342:28
    |
 LL |     fn nested_fn_pointer_4<'a>(_: &'a i32) -> impl Fn(fn(&i32)) {
    |                            ^^      ^^
@@ -432,7 +313,7 @@ LL +     fn nested_fn_pointer_4(_: &i32) -> impl Fn(fn(&i32)) {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:441:21
+  --> tests/ui/needless_lifetimes.rs:365:21
    |
 LL |         fn implicit<'a>(&'a self) -> &'a () {
    |                     ^^   ^^           ^^
@@ -444,7 +325,7 @@ LL +         fn implicit(&self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:444:25
+  --> tests/ui/needless_lifetimes.rs:369:25
    |
 LL |         fn implicit_mut<'a>(&'a mut self) -> &'a () {
    |                         ^^   ^^               ^^
@@ -456,7 +337,7 @@ LL +         fn implicit_mut(&mut self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:448:21
+  --> tests/ui/needless_lifetimes.rs:374:21
    |
 LL |         fn explicit<'a>(self: &'a Arc<Self>) -> &'a () {
    |                     ^^         ^^                ^^
@@ -468,7 +349,7 @@ LL +         fn explicit(self: &Arc<Self>) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:452:25
+  --> tests/ui/needless_lifetimes.rs:379:25
    |
 LL |         fn explicit_mut<'a>(self: &'a mut Rc<Self>) -> &'a () {
    |                         ^^         ^^                   ^^
@@ -480,7 +361,7 @@ LL +         fn explicit_mut(self: &mut Rc<Self>) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:464:31
+  --> tests/ui/needless_lifetimes.rs:392:31
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |                               ^^                          ^^         ^^
@@ -492,7 +373,7 @@ LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:470:21
+  --> tests/ui/needless_lifetimes.rs:399:21
    |
 LL |         fn implicit<'a>(&'a self) -> &'a ();
    |                     ^^   ^^           ^^
@@ -504,7 +385,7 @@ LL +         fn implicit(&self) -> &();
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:471:30
+  --> tests/ui/needless_lifetimes.rs:401:30
    |
 LL |         fn implicit_provided<'a>(&'a self) -> &'a () {
    |                              ^^   ^^           ^^
@@ -516,7 +397,7 @@ LL +         fn implicit_provided(&self) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:476:21
+  --> tests/ui/needless_lifetimes.rs:407:21
    |
 LL |         fn explicit<'a>(self: &'a Arc<Self>) -> &'a ();
    |                     ^^         ^^                ^^
@@ -528,7 +409,7 @@ LL +         fn explicit(self: &Arc<Self>) -> &();
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:478:30
+  --> tests/ui/needless_lifetimes.rs:410:30
    |
 LL |         fn explicit_provided<'a>(self: &'a Arc<Self>) -> &'a () {
    |                              ^^         ^^                ^^
@@ -540,7 +421,7 @@ LL +         fn explicit_provided(self: &Arc<Self>) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:488:31
+  --> tests/ui/needless_lifetimes.rs:421:31
    |
 LL |         fn lifetime_elsewhere<'a>(self: Box<Self>, here: &'a ()) -> &'a ();
    |                               ^^                          ^^         ^^
@@ -552,7 +433,7 @@ LL +         fn lifetime_elsewhere(self: Box<Self>, here: &()) -> &();
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:489:40
+  --> tests/ui/needless_lifetimes.rs:423:40
    |
 LL |         fn lifetime_elsewhere_provided<'a>(self: Box<Self>, here: &'a ()) -> &'a () {
    |                                        ^^                          ^^         ^^
@@ -564,7 +445,7 @@ LL +         fn lifetime_elsewhere_provided(self: Box<Self>, here: &()) -> &() {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:498:12
+  --> tests/ui/needless_lifetimes.rs:433:12
    |
 LL |     fn foo<'a>(x: &'a u8, y: &'_ u8) {}
    |            ^^      ^^
@@ -576,7 +457,7 @@ LL +     fn foo(x: &u8, y: &'_ u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:500:12
+  --> tests/ui/needless_lifetimes.rs:436:12
    |
 LL |     fn bar<'a>(x: &'a u8, y: &'_ u8, z: &'_ u8) {}
    |            ^^      ^^
@@ -588,7 +469,7 @@ LL +     fn bar(x: &u8, y: &'_ u8, z: &'_ u8) {}
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:507:18
+  --> tests/ui/needless_lifetimes.rs:444:18
    |
 LL |     fn one_input<'a>(x: &'a u8) -> &'a u8 {
    |                  ^^      ^^         ^^
@@ -600,7 +481,7 @@ LL +     fn one_input(x: &u8) -> &u8 {
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:512:42
+  --> tests/ui/needless_lifetimes.rs:450:42
    |
 LL |     fn multiple_inputs_output_not_elided<'a, 'b>(x: &'a u8, y: &'b u8, z: &'b u8) -> &'b u8 {
    |                                          ^^          ^^
@@ -612,7 +493,7 @@ LL +     fn multiple_inputs_output_not_elided<'b>(x: &u8, y: &'b u8, z: &'b u8)
    |
 
 error: the following explicit lifetimes could be elided: 'a
-  --> tests/ui/needless_lifetimes.rs:528:22
+  --> tests/ui/needless_lifetimes.rs:467:22
    |
 LL |         fn one_input<'a>(x: &'a u8) -> &'a u8 {
    |                      ^^      ^^         ^^
@@ -624,64 +505,5 @@ LL -         fn one_input<'a>(x: &'a u8) -> &'a u8 {
 LL +         fn one_input(x: &u8) -> &u8 {
    |
 
-error: the following explicit lifetimes could be elided: 'py
-  --> tests/ui/needless_lifetimes.rs:623:14
-   |
-LL |     impl<'t, 'py> ContentString<'t> {
-   |              ^^^
-LL |         // `'py` can be elided because of `&self`
-LL |         fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
-   |                                                                                   ^^^
-   |
-help: elide the lifetimes
-   |
-LL ~     impl<'t> ContentString<'t> {
-LL |         // `'py` can be elided because of `&self`
-LL ~         fn map_content2(&self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
-   |
-
-error: the following explicit lifetimes could be elided: 'py
-  --> tests/ui/needless_lifetimes.rs:633:14
-   |
-LL |     impl<'t, 'py> ContentString<'t> {
-   |              ^^^
-LL |         // `'py` can be elided because of `&'_ self`
-LL |         fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, 'py> {
-   |                                                                                      ^^^
-   |
-help: elide the lifetimes
-   |
-LL ~     impl<'t> ContentString<'t> {
-LL |         // `'py` can be elided because of `&'_ self`
-LL ~         fn map_content3(&'_ self, f: impl FnOnce(&'t str) -> &'t str) -> Content<'t, '_> {
-   |
-
-error: the following explicit lifetimes could be elided: 'py
-  --> tests/ui/needless_lifetimes.rs:653:14
-   |
-LL |     impl<'t, 'py> ContentString<'t> {
-   |              ^^^
-...
-LL |         ) -> Content<'t, 'py> {
-   |                          ^^^
-   |
-help: elide the lifetimes
-   |
-LL ~     impl<'t> ContentString<'t> {
-LL |         // `'py` can be elided because of `&Self`
-...
-LL |             o: &'t str,
-LL ~         ) -> Content<'t, '_> {
-   |
-
-error: this expression creates a reference which is immediately dereferenced by the compiler
-  --> tests/ui/needless_lifetimes.rs:674:9
-   |
-LL |         &x.b
-   |         ^^^^ help: change this to: `x.b`
-   |
-   = note: `-D clippy::needless-borrow` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::needless_borrow)]`
-
-error: aborting due to 56 previous errors
+error: aborting due to 42 previous errors
 
diff --git a/src/tools/clippy/tests/ui/needless_match.fixed b/src/tools/clippy/tests/ui/needless_match.fixed
index 06c6169d0da0..b2c2bbfaa361 100644
--- a/src/tools/clippy/tests/ui/needless_match.fixed
+++ b/src/tools/clippy/tests/ui/needless_match.fixed
@@ -61,6 +61,7 @@ fn result_match() {
 
 fn if_let_option() {
     let _ = Some(1);
+    //~^ needless_match
 
     fn do_something() {}
 
@@ -96,7 +97,9 @@ fn if_let_option_result() -> Result<(), ()> {
 fn if_let_result() {
     let x: Result<i32, i32> = Ok(1);
     let _: Result<i32, i32> = x;
+    //~^ needless_match
     let _: Result<i32, i32> = x;
+    //~^ needless_match
     // Input type mismatch, don't trigger
     #[allow(clippy::question_mark)]
     let _: Result<i32, i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
diff --git a/src/tools/clippy/tests/ui/needless_match.rs b/src/tools/clippy/tests/ui/needless_match.rs
index 6b71de68e1be..1cb670edc60f 100644
--- a/src/tools/clippy/tests/ui/needless_match.rs
+++ b/src/tools/clippy/tests/ui/needless_match.rs
@@ -13,6 +13,7 @@ enum Simple {
 fn useless_match() {
     let i = 10;
     let _: i32 = match i {
+        //~^ needless_match
         0 => 0,
         1 => 1,
         2 => 2,
@@ -20,6 +21,7 @@ fn useless_match() {
     };
     let s = "test";
     let _: &str = match s {
+        //~^ needless_match
         "a" => "a",
         "b" => "b",
         s => s,
@@ -29,6 +31,7 @@ fn useless_match() {
 fn custom_type_match() {
     let se = Simple::A;
     let _: Simple = match se {
+        //~^ needless_match
         Simple::A => Simple::A,
         Simple::B => Simple::B,
         Simple::C => Simple::C,
@@ -51,6 +54,7 @@ fn custom_type_match() {
 
 fn option_match(x: Option<i32>) {
     let _: Option<i32> = match x {
+        //~^ needless_match
         Some(a) => Some(a),
         None => None,
     };
@@ -67,10 +71,12 @@ fn func_ret_err<T>(err: T) -> Result<i32, T> {
 
 fn result_match() {
     let _: Result<i32, i32> = match Ok(1) {
+        //~^ needless_match
         Ok(a) => Ok(a),
         Err(err) => Err(err),
     };
     let _: Result<i32, i32> = match func_ret_err(0_i32) {
+        //~^ needless_match
         Err(err) => Err(err),
         Ok(a) => Ok(a),
     };
@@ -84,6 +90,7 @@ fn result_match() {
 
 fn if_let_option() {
     let _ = if let Some(a) = Some(1) { Some(a) } else { None };
+    //~^ needless_match
 
     fn do_something() {}
 
@@ -119,7 +126,9 @@ fn if_let_option_result() -> Result<(), ()> {
 fn if_let_result() {
     let x: Result<i32, i32> = Ok(1);
     let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
+    //~^ needless_match
     let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
+    //~^ needless_match
     // Input type mismatch, don't trigger
     #[allow(clippy::question_mark)]
     let _: Result<i32, i32> = if let Err(e) = Ok(1) { Err(e) } else { x };
@@ -127,6 +136,7 @@ fn if_let_result() {
 
 fn if_let_custom_enum(x: Simple) {
     let _: Simple = if let Simple::A = x {
+        //~^ needless_match
         Simple::A
     } else if let Simple::B = x {
         Simple::B
@@ -166,6 +176,7 @@ mod issue8542 {
         let bb = false;
 
         let _: Complex = match ce {
+            //~^ needless_match
             Complex::A(a) => Complex::A(a),
             Complex::B(a, b) => Complex::B(a, b),
             Complex::C(a, b, c) => Complex::C(a, b, c),
@@ -250,12 +261,14 @@ mod issue9084 {
 
         // should lint
         let _ = match e {
+            //~^ needless_match
             _ if some_bool => e,
             _ => e,
         };
 
         // should lint
         let _ = match e {
+            //~^ needless_match
             Some(i) => Some(i),
             _ if some_bool => e,
             _ => e,
@@ -337,6 +350,7 @@ pub fn issue13574() -> Option<()> {
     // Same const, should lint
     let _ = {
         if let Some(num) = A {
+            //~^ needless_match
             Some(num)
         } else if let Some(num) = A {
             Some(num)
diff --git a/src/tools/clippy/tests/ui/needless_match.stderr b/src/tools/clippy/tests/ui/needless_match.stderr
index 1410585cb2e3..719b0ef88469 100644
--- a/src/tools/clippy/tests/ui/needless_match.stderr
+++ b/src/tools/clippy/tests/ui/needless_match.stderr
@@ -3,6 +3,7 @@ error: this match expression is unnecessary
    |
 LL |       let _: i32 = match i {
    |  __________________^
+LL | |
 LL | |         0 => 0,
 LL | |         1 => 1,
 LL | |         2 => 2,
@@ -14,10 +15,11 @@ LL | |     };
    = help: to override `-D warnings` add `#[allow(clippy::needless_match)]`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:22:19
+  --> tests/ui/needless_match.rs:23:19
    |
 LL |       let _: &str = match s {
    |  ___________________^
+LL | |
 LL | |         "a" => "a",
 LL | |         "b" => "b",
 LL | |         s => s,
@@ -25,10 +27,11 @@ LL | |     };
    | |_____^ help: replace it with: `s`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:31:21
+  --> tests/ui/needless_match.rs:33:21
    |
 LL |       let _: Simple = match se {
    |  _____________________^
+LL | |
 LL | |         Simple::A => Simple::A,
 LL | |         Simple::B => Simple::B,
 LL | |         Simple::C => Simple::C,
@@ -37,94 +40,99 @@ LL | |     };
    | |_____^ help: replace it with: `se`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:53:26
+  --> tests/ui/needless_match.rs:56:26
    |
 LL |       let _: Option<i32> = match x {
    |  __________________________^
+LL | |
 LL | |         Some(a) => Some(a),
 LL | |         None => None,
 LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:69:31
+  --> tests/ui/needless_match.rs:73:31
    |
 LL |       let _: Result<i32, i32> = match Ok(1) {
    |  _______________________________^
+LL | |
 LL | |         Ok(a) => Ok(a),
 LL | |         Err(err) => Err(err),
 LL | |     };
    | |_____^ help: replace it with: `Ok(1)`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:73:31
+  --> tests/ui/needless_match.rs:78:31
    |
 LL |       let _: Result<i32, i32> = match func_ret_err(0_i32) {
    |  _______________________________^
+LL | |
 LL | |         Err(err) => Err(err),
 LL | |         Ok(a) => Ok(a),
 LL | |     };
    | |_____^ help: replace it with: `func_ret_err(0_i32)`
 
 error: this if-let expression is unnecessary
-  --> tests/ui/needless_match.rs:86:13
+  --> tests/ui/needless_match.rs:92:13
    |
 LL |     let _ = if let Some(a) = Some(1) { Some(a) } else { None };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `Some(1)`
 
 error: this if-let expression is unnecessary
-  --> tests/ui/needless_match.rs:121:31
+  --> tests/ui/needless_match.rs:128:31
    |
 LL |     let _: Result<i32, i32> = if let Err(e) = x { Err(e) } else { x };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> tests/ui/needless_match.rs:122:31
+  --> tests/ui/needless_match.rs:130:31
    |
 LL |     let _: Result<i32, i32> = if let Ok(val) = x { Ok(val) } else { x };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x`
 
 error: this if-let expression is unnecessary
-  --> tests/ui/needless_match.rs:129:21
+  --> tests/ui/needless_match.rs:138:21
    |
 LL |       let _: Simple = if let Simple::A = x {
    |  _____________________^
+LL | |
 LL | |         Simple::A
 LL | |     } else if let Simple::B = x {
-LL | |         Simple::B
 ...  |
 LL | |         x
 LL | |     };
    | |_____^ help: replace it with: `x`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:168:26
+  --> tests/ui/needless_match.rs:178:26
    |
 LL |           let _: Complex = match ce {
    |  __________________________^
+LL | |
 LL | |             Complex::A(a) => Complex::A(a),
 LL | |             Complex::B(a, b) => Complex::B(a, b),
-LL | |             Complex::C(a, b, c) => Complex::C(a, b, c),
-LL | |             Complex::D(E::VariantA(ea, eb), b) => Complex::D(E::VariantA(ea, eb), b),
+...  |
 LL | |             Complex::D(E::VariantB(ea, eb), b) => Complex::D(E::VariantB(ea, eb), b),
 LL | |         };
    | |_________^ help: replace it with: `ce`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:252:17
+  --> tests/ui/needless_match.rs:263:17
    |
 LL |           let _ = match e {
    |  _________________^
+LL | |
 LL | |             _ if some_bool => e,
 LL | |             _ => e,
 LL | |         };
    | |_________^ help: replace it with: `e`
 
 error: this match expression is unnecessary
-  --> tests/ui/needless_match.rs:258:17
+  --> tests/ui/needless_match.rs:270:17
    |
 LL |           let _ = match e {
    |  _________________^
+LL | |
 LL | |             Some(i) => Some(i),
 LL | |             _ if some_bool => e,
 LL | |             _ => e,
@@ -132,12 +140,12 @@ LL | |         };
    | |_________^ help: replace it with: `e`
 
 error: this if-let expression is unnecessary
-  --> tests/ui/needless_match.rs:339:9
+  --> tests/ui/needless_match.rs:352:9
    |
 LL | /         if let Some(num) = A {
+LL | |
 LL | |             Some(num)
 LL | |         } else if let Some(num) = A {
-LL | |             Some(num)
 ...  |
 LL | |             None
 LL | |         }
diff --git a/src/tools/clippy/tests/ui/needless_maybe_sized.fixed b/src/tools/clippy/tests/ui/needless_maybe_sized.fixed
index 4d24a7cee619..f8b164396990 100644
--- a/src/tools/clippy/tests/ui/needless_maybe_sized.fixed
+++ b/src/tools/clippy/tests/ui/needless_maybe_sized.fixed
@@ -7,27 +7,34 @@ extern crate proc_macros;
 use proc_macros::external;
 
 fn directly<T: Sized>(t: &T) {}
+//~^ needless_maybe_sized
 
 trait A: Sized {}
 trait B: A {}
 
 fn depth_1<T: A>(t: &T) {}
+//~^ needless_maybe_sized
 fn depth_2<T: B>(t: &T) {}
+//~^ needless_maybe_sized
 
 // We only need to show one
 fn multiple_paths<T: A + B>(t: &T) {}
+//~^ needless_maybe_sized
 
 fn in_where<T>(t: &T)
 where
     T: Sized,
+    //~^ needless_maybe_sized
 {
 }
 
 fn mixed_1<T: Sized>(t: &T)
+    //~^ needless_maybe_sized
 {
 }
 
 fn mixed_2<T>(t: &T)
+//~^ needless_maybe_sized
 where
     T: Sized,
 {
@@ -36,38 +43,50 @@ where
 fn mixed_3<T>(t: &T)
 where
     T: Sized,
+    //~^ needless_maybe_sized
 {
 }
 
 struct Struct<T: Sized>(T);
+//~^ needless_maybe_sized
 
 impl<T: Sized> Struct<T> {
+    //~^ needless_maybe_sized
     fn method<U: Sized>(&self) {}
+    //~^ needless_maybe_sized
 }
 
 enum Enum<T: Sized + 'static> {
+    //~^ needless_maybe_sized
     Variant(&'static T),
 }
 
 union Union<'a, T: Sized> {
+    //~^ needless_maybe_sized
     a: &'a T,
 }
 
 trait Trait<T: Sized> {
+    //~^ needless_maybe_sized
     fn trait_method<U: Sized>() {}
+    //~^ needless_maybe_sized
 
     type GAT<U: Sized>;
+    //~^ needless_maybe_sized
 
     type Assoc: Sized + ?Sized; // False negative
 }
 
 trait SecondInTrait: Send + Sized {}
 fn second_in_trait<T: SecondInTrait>() {}
+//~^ needless_maybe_sized
 
 fn impl_trait(_: &(impl Sized)) {}
+//~^ needless_maybe_sized
 
 trait GenericTrait<T>: Sized {}
 fn in_generic_trait<T: GenericTrait<U>, U>() {}
+//~^ needless_maybe_sized
 
 mod larger_graph {
     // C1  C2  Sized
@@ -83,6 +102,7 @@ mod larger_graph {
     trait A1: B1 + B2 {}
 
     fn larger_graph<T: A1>() {}
+    //~^ needless_maybe_sized
 }
 
 // Should not lint
diff --git a/src/tools/clippy/tests/ui/needless_maybe_sized.rs b/src/tools/clippy/tests/ui/needless_maybe_sized.rs
index ef66f9a4f2ae..e4312b40563f 100644
--- a/src/tools/clippy/tests/ui/needless_maybe_sized.rs
+++ b/src/tools/clippy/tests/ui/needless_maybe_sized.rs
@@ -7,29 +7,36 @@ extern crate proc_macros;
 use proc_macros::external;
 
 fn directly<T: Sized + ?Sized>(t: &T) {}
+//~^ needless_maybe_sized
 
 trait A: Sized {}
 trait B: A {}
 
 fn depth_1<T: A + ?Sized>(t: &T) {}
+//~^ needless_maybe_sized
 fn depth_2<T: B + ?Sized>(t: &T) {}
+//~^ needless_maybe_sized
 
 // We only need to show one
 fn multiple_paths<T: A + B + ?Sized>(t: &T) {}
+//~^ needless_maybe_sized
 
 fn in_where<T>(t: &T)
 where
     T: Sized + ?Sized,
+    //~^ needless_maybe_sized
 {
 }
 
 fn mixed_1<T: Sized>(t: &T)
 where
     T: ?Sized,
+    //~^ needless_maybe_sized
 {
 }
 
 fn mixed_2<T: ?Sized>(t: &T)
+//~^ needless_maybe_sized
 where
     T: Sized,
 {
@@ -39,38 +46,50 @@ fn mixed_3<T>(t: &T)
 where
     T: Sized,
     T: ?Sized,
+    //~^ needless_maybe_sized
 {
 }
 
 struct Struct<T: Sized + ?Sized>(T);
+//~^ needless_maybe_sized
 
 impl<T: Sized + ?Sized> Struct<T> {
+    //~^ needless_maybe_sized
     fn method<U: Sized + ?Sized>(&self) {}
+    //~^ needless_maybe_sized
 }
 
 enum Enum<T: Sized + ?Sized + 'static> {
+    //~^ needless_maybe_sized
     Variant(&'static T),
 }
 
 union Union<'a, T: Sized + ?Sized> {
+    //~^ needless_maybe_sized
     a: &'a T,
 }
 
 trait Trait<T: Sized + ?Sized> {
+    //~^ needless_maybe_sized
     fn trait_method<U: Sized + ?Sized>() {}
+    //~^ needless_maybe_sized
 
     type GAT<U: Sized + ?Sized>;
+    //~^ needless_maybe_sized
 
     type Assoc: Sized + ?Sized; // False negative
 }
 
 trait SecondInTrait: Send + Sized {}
 fn second_in_trait<T: ?Sized + SecondInTrait>() {}
+//~^ needless_maybe_sized
 
 fn impl_trait(_: &(impl Sized + ?Sized)) {}
+//~^ needless_maybe_sized
 
 trait GenericTrait<T>: Sized {}
 fn in_generic_trait<T: GenericTrait<U> + ?Sized, U>() {}
+//~^ needless_maybe_sized
 
 mod larger_graph {
     // C1  C2  Sized
@@ -86,6 +105,7 @@ mod larger_graph {
     trait A1: B1 + B2 {}
 
     fn larger_graph<T: A1 + ?Sized>() {}
+    //~^ needless_maybe_sized
 }
 
 // Should not lint
diff --git a/src/tools/clippy/tests/ui/needless_maybe_sized.stderr b/src/tools/clippy/tests/ui/needless_maybe_sized.stderr
index 3b1d2b49b062..30dcaa48e429 100644
--- a/src/tools/clippy/tests/ui/needless_maybe_sized.stderr
+++ b/src/tools/clippy/tests/ui/needless_maybe_sized.stderr
@@ -18,13 +18,13 @@ LL + fn directly<T: Sized>(t: &T) {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:14:19
+  --> tests/ui/needless_maybe_sized.rs:15:19
    |
 LL | fn depth_1<T: A + ?Sized>(t: &T) {}
    |                   ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:14:15
+  --> tests/ui/needless_maybe_sized.rs:15:15
    |
 LL | fn depth_1<T: A + ?Sized>(t: &T) {}
    |               ^
@@ -36,13 +36,13 @@ LL + fn depth_1<T: A>(t: &T) {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:15:19
+  --> tests/ui/needless_maybe_sized.rs:17:19
    |
 LL | fn depth_2<T: B + ?Sized>(t: &T) {}
    |                   ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:15:15
+  --> tests/ui/needless_maybe_sized.rs:17:15
    |
 LL | fn depth_2<T: B + ?Sized>(t: &T) {}
    |               ^
@@ -55,13 +55,13 @@ LL + fn depth_2<T: B>(t: &T) {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:18:30
+  --> tests/ui/needless_maybe_sized.rs:21:30
    |
 LL | fn multiple_paths<T: A + B + ?Sized>(t: &T) {}
    |                              ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:18:22
+  --> tests/ui/needless_maybe_sized.rs:21:22
    |
 LL | fn multiple_paths<T: A + B + ?Sized>(t: &T) {}
    |                      ^
@@ -73,13 +73,13 @@ LL + fn multiple_paths<T: A + B>(t: &T) {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:22:16
+  --> tests/ui/needless_maybe_sized.rs:26:16
    |
 LL |     T: Sized + ?Sized,
    |                ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:22:8
+  --> tests/ui/needless_maybe_sized.rs:26:8
    |
 LL |     T: Sized + ?Sized,
    |        ^^^^^
@@ -90,13 +90,13 @@ LL +     T: Sized,
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:28:8
+  --> tests/ui/needless_maybe_sized.rs:33:8
    |
 LL |     T: ?Sized,
    |        ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:26:15
+  --> tests/ui/needless_maybe_sized.rs:31:15
    |
 LL | fn mixed_1<T: Sized>(t: &T)
    |               ^^^^^
@@ -107,13 +107,13 @@ LL -     T: ?Sized,
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:32:15
+  --> tests/ui/needless_maybe_sized.rs:38:15
    |
 LL | fn mixed_2<T: ?Sized>(t: &T)
    |               ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:34:8
+  --> tests/ui/needless_maybe_sized.rs:41:8
    |
 LL |     T: Sized,
    |        ^^^^^
@@ -124,13 +124,13 @@ LL + fn mixed_2<T>(t: &T)
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:41:8
+  --> tests/ui/needless_maybe_sized.rs:48:8
    |
 LL |     T: ?Sized,
    |        ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:40:8
+  --> tests/ui/needless_maybe_sized.rs:47:8
    |
 LL |     T: Sized,
    |        ^^^^^
@@ -142,13 +142,13 @@ LL +     T: Sized,
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:45:26
+  --> tests/ui/needless_maybe_sized.rs:53:26
    |
 LL | struct Struct<T: Sized + ?Sized>(T);
    |                          ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:45:18
+  --> tests/ui/needless_maybe_sized.rs:53:18
    |
 LL | struct Struct<T: Sized + ?Sized>(T);
    |                  ^^^^^
@@ -159,13 +159,13 @@ LL + struct Struct<T: Sized>(T);
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:47:17
+  --> tests/ui/needless_maybe_sized.rs:56:17
    |
 LL | impl<T: Sized + ?Sized> Struct<T> {
    |                 ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:47:9
+  --> tests/ui/needless_maybe_sized.rs:56:9
    |
 LL | impl<T: Sized + ?Sized> Struct<T> {
    |         ^^^^^
@@ -176,13 +176,13 @@ LL + impl<T: Sized> Struct<T> {
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:48:26
+  --> tests/ui/needless_maybe_sized.rs:58:26
    |
 LL |     fn method<U: Sized + ?Sized>(&self) {}
    |                          ^^^^^^
    |
 note: `U` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:48:18
+  --> tests/ui/needless_maybe_sized.rs:58:18
    |
 LL |     fn method<U: Sized + ?Sized>(&self) {}
    |                  ^^^^^
@@ -193,13 +193,13 @@ LL +     fn method<U: Sized>(&self) {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:51:22
+  --> tests/ui/needless_maybe_sized.rs:62:22
    |
 LL | enum Enum<T: Sized + ?Sized + 'static> {
    |                      ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:51:14
+  --> tests/ui/needless_maybe_sized.rs:62:14
    |
 LL | enum Enum<T: Sized + ?Sized + 'static> {
    |              ^^^^^
@@ -210,13 +210,13 @@ LL + enum Enum<T: Sized + 'static> {
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:55:28
+  --> tests/ui/needless_maybe_sized.rs:67:28
    |
 LL | union Union<'a, T: Sized + ?Sized> {
    |                            ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:55:20
+  --> tests/ui/needless_maybe_sized.rs:67:20
    |
 LL | union Union<'a, T: Sized + ?Sized> {
    |                    ^^^^^
@@ -227,13 +227,13 @@ LL + union Union<'a, T: Sized> {
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:59:24
+  --> tests/ui/needless_maybe_sized.rs:72:24
    |
 LL | trait Trait<T: Sized + ?Sized> {
    |                        ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:59:16
+  --> tests/ui/needless_maybe_sized.rs:72:16
    |
 LL | trait Trait<T: Sized + ?Sized> {
    |                ^^^^^
@@ -244,13 +244,13 @@ LL + trait Trait<T: Sized> {
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:60:32
+  --> tests/ui/needless_maybe_sized.rs:74:32
    |
 LL |     fn trait_method<U: Sized + ?Sized>() {}
    |                                ^^^^^^
    |
 note: `U` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:60:24
+  --> tests/ui/needless_maybe_sized.rs:74:24
    |
 LL |     fn trait_method<U: Sized + ?Sized>() {}
    |                        ^^^^^
@@ -261,13 +261,13 @@ LL +     fn trait_method<U: Sized>() {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:62:25
+  --> tests/ui/needless_maybe_sized.rs:77:25
    |
 LL |     type GAT<U: Sized + ?Sized>;
    |                         ^^^^^^
    |
 note: `U` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:62:17
+  --> tests/ui/needless_maybe_sized.rs:77:17
    |
 LL |     type GAT<U: Sized + ?Sized>;
    |                 ^^^^^
@@ -278,13 +278,13 @@ LL +     type GAT<U: Sized>;
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:68:23
+  --> tests/ui/needless_maybe_sized.rs:84:23
    |
 LL | fn second_in_trait<T: ?Sized + SecondInTrait>() {}
    |                       ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:68:32
+  --> tests/ui/needless_maybe_sized.rs:84:32
    |
 LL | fn second_in_trait<T: ?Sized + SecondInTrait>() {}
    |                                ^^^^^^^^^^^^^
@@ -296,13 +296,13 @@ LL + fn second_in_trait<T: SecondInTrait>() {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:70:33
+  --> tests/ui/needless_maybe_sized.rs:87:33
    |
 LL | fn impl_trait(_: &(impl Sized + ?Sized)) {}
    |                                 ^^^^^^
    |
 note: `impl Sized + ?Sized` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:70:25
+  --> tests/ui/needless_maybe_sized.rs:87:25
    |
 LL | fn impl_trait(_: &(impl Sized + ?Sized)) {}
    |                         ^^^^^
@@ -313,13 +313,13 @@ LL + fn impl_trait(_: &(impl Sized)) {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:73:42
+  --> tests/ui/needless_maybe_sized.rs:91:42
    |
 LL | fn in_generic_trait<T: GenericTrait<U> + ?Sized, U>() {}
    |                                          ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:73:24
+  --> tests/ui/needless_maybe_sized.rs:91:24
    |
 LL | fn in_generic_trait<T: GenericTrait<U> + ?Sized, U>() {}
    |                        ^^^^^^^^^^^^^^^
@@ -331,13 +331,13 @@ LL + fn in_generic_trait<T: GenericTrait<U>, U>() {}
    |
 
 error: `?Sized` bound is ignored because of a `Sized` requirement
-  --> tests/ui/needless_maybe_sized.rs:88:29
+  --> tests/ui/needless_maybe_sized.rs:107:29
    |
 LL |     fn larger_graph<T: A1 + ?Sized>() {}
    |                             ^^^^^^
    |
 note: `T` cannot be unsized because of the bound
-  --> tests/ui/needless_maybe_sized.rs:88:24
+  --> tests/ui/needless_maybe_sized.rs:107:24
    |
 LL |     fn larger_graph<T: A1 + ?Sized>() {}
    |                        ^^
diff --git a/src/tools/clippy/tests/ui/needless_option_as_deref.fixed b/src/tools/clippy/tests/ui/needless_option_as_deref.fixed
index 84eaf12fc139..fd639f3b57fa 100644
--- a/src/tools/clippy/tests/ui/needless_option_as_deref.fixed
+++ b/src/tools/clippy/tests/ui/needless_option_as_deref.fixed
@@ -5,11 +5,14 @@
 fn main() {
     // should lint
     let _: Option<&usize> = Some(&1);
+    //~^ needless_option_as_deref
     let _: Option<&mut usize> = Some(&mut 1);
+    //~^ needless_option_as_deref
 
     let mut y = 0;
     let mut x = Some(&mut y);
     let _ = x;
+    //~^ needless_option_as_deref
 
     // should not lint
     let _ = Some(Box::new(1)).as_deref();
@@ -70,3 +73,16 @@ mod issue_non_copy_13077 {
         pub field: (),
     }
 }
+
+mod issue14148 {
+    pub trait SomeTrait {
+        fn something(&self, mut maybe_side_effect: Option<&mut String>) {
+            other(maybe_side_effect.as_deref_mut());
+            other(maybe_side_effect);
+        }
+    }
+
+    fn other(_maybe_side_effect: Option<&mut String>) {
+        unimplemented!()
+    }
+}
diff --git a/src/tools/clippy/tests/ui/needless_option_as_deref.rs b/src/tools/clippy/tests/ui/needless_option_as_deref.rs
index fff1e45d846f..cbf7935794b3 100644
--- a/src/tools/clippy/tests/ui/needless_option_as_deref.rs
+++ b/src/tools/clippy/tests/ui/needless_option_as_deref.rs
@@ -5,11 +5,14 @@
 fn main() {
     // should lint
     let _: Option<&usize> = Some(&1).as_deref();
+    //~^ needless_option_as_deref
     let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
+    //~^ needless_option_as_deref
 
     let mut y = 0;
     let mut x = Some(&mut y);
     let _ = x.as_deref_mut();
+    //~^ needless_option_as_deref
 
     // should not lint
     let _ = Some(Box::new(1)).as_deref();
@@ -70,3 +73,16 @@ mod issue_non_copy_13077 {
         pub field: (),
     }
 }
+
+mod issue14148 {
+    pub trait SomeTrait {
+        fn something(&self, mut maybe_side_effect: Option<&mut String>) {
+            other(maybe_side_effect.as_deref_mut());
+            other(maybe_side_effect);
+        }
+    }
+
+    fn other(_maybe_side_effect: Option<&mut String>) {
+        unimplemented!()
+    }
+}
diff --git a/src/tools/clippy/tests/ui/needless_option_as_deref.stderr b/src/tools/clippy/tests/ui/needless_option_as_deref.stderr
index a05d0aa9276a..bd19dc75eed6 100644
--- a/src/tools/clippy/tests/ui/needless_option_as_deref.stderr
+++ b/src/tools/clippy/tests/ui/needless_option_as_deref.stderr
@@ -8,13 +8,13 @@ LL |     let _: Option<&usize> = Some(&1).as_deref();
    = help: to override `-D warnings` add `#[allow(clippy::needless_option_as_deref)]`
 
 error: derefed type is same as origin
-  --> tests/ui/needless_option_as_deref.rs:8:33
+  --> tests/ui/needless_option_as_deref.rs:9:33
    |
 LL |     let _: Option<&mut usize> = Some(&mut 1).as_deref_mut();
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(&mut 1)`
 
 error: derefed type is same as origin
-  --> tests/ui/needless_option_as_deref.rs:12:13
+  --> tests/ui/needless_option_as_deref.rs:14:13
    |
 LL |     let _ = x.as_deref_mut();
    |             ^^^^^^^^^^^^^^^^ help: try: `x`
diff --git a/src/tools/clippy/tests/ui/needless_option_take.fixed b/src/tools/clippy/tests/ui/needless_option_take.fixed
index 6514b67ef7a7..a8bd50b79899 100644
--- a/src/tools/clippy/tests/ui/needless_option_take.fixed
+++ b/src/tools/clippy/tests/ui/needless_option_take.fixed
@@ -21,7 +21,7 @@ fn main() {
 
     let x = Some(3);
     x.as_ref();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     println!("Testing non erroneous option_take_on_temporary");
     let mut x = Some(3);
@@ -29,30 +29,31 @@ fn main() {
 
     let mut x = Some(3);
     let y = x.as_mut();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
+
     let y = x.replace(289);
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let y = Some(3).as_mut();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let y = Option::as_mut(&mut x);
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let x = return_option();
     let x = return_option();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let x = MyStruct::get_option();
     let x = MyStruct::get_option();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let mut my_vec = vec![1, 2, 3];
     my_vec.push(4);
     let y = my_vec.first();
     let y = my_vec.first();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let y = my_vec.first();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 }
diff --git a/src/tools/clippy/tests/ui/needless_option_take.rs b/src/tools/clippy/tests/ui/needless_option_take.rs
index c6807718a758..8141ee43db11 100644
--- a/src/tools/clippy/tests/ui/needless_option_take.rs
+++ b/src/tools/clippy/tests/ui/needless_option_take.rs
@@ -21,7 +21,7 @@ fn main() {
 
     let x = Some(3);
     x.as_ref().take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     println!("Testing non erroneous option_take_on_temporary");
     let mut x = Some(3);
@@ -29,30 +29,31 @@ fn main() {
 
     let mut x = Some(3);
     let y = x.as_mut().take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
+
     let y = x.replace(289).take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let y = Some(3).as_mut().take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let y = Option::as_mut(&mut x).take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let x = return_option();
     let x = return_option().take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let x = MyStruct::get_option();
     let x = MyStruct::get_option().take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let mut my_vec = vec![1, 2, 3];
     my_vec.push(4);
     let y = my_vec.first();
     let y = my_vec.first().take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 
     let y = my_vec.first().take();
-    //~^ ERROR: called `Option::take()` on a temporary value
+    //~^ needless_option_take
 }
diff --git a/src/tools/clippy/tests/ui/needless_option_take.stderr b/src/tools/clippy/tests/ui/needless_option_take.stderr
index 3fc339ed79e2..9054463c07cd 100644
--- a/src/tools/clippy/tests/ui/needless_option_take.stderr
+++ b/src/tools/clippy/tests/ui/needless_option_take.stderr
@@ -21,7 +21,7 @@ LL |     let y = x.as_mut().take();
    = note: `as_mut` creates a temporary value, so calling take() has no effect
 
 error: called `Option::take()` on a temporary value
-  --> tests/ui/needless_option_take.rs:33:13
+  --> tests/ui/needless_option_take.rs:34:13
    |
 LL |     let y = x.replace(289).take();
    |             ^^^^^^^^^^^^^^-------
@@ -31,7 +31,7 @@ LL |     let y = x.replace(289).take();
    = note: `replace` creates a temporary value, so calling take() has no effect
 
 error: called `Option::take()` on a temporary value
-  --> tests/ui/needless_option_take.rs:36:13
+  --> tests/ui/needless_option_take.rs:37:13
    |
 LL |     let y = Some(3).as_mut().take();
    |             ^^^^^^^^^^^^^^^^-------
@@ -41,7 +41,7 @@ LL |     let y = Some(3).as_mut().take();
    = note: `as_mut` creates a temporary value, so calling take() has no effect
 
 error: called `Option::take()` on a temporary value
-  --> tests/ui/needless_option_take.rs:39:13
+  --> tests/ui/needless_option_take.rs:40:13
    |
 LL |     let y = Option::as_mut(&mut x).take();
    |             ^^^^^^^^^^^^^^^^^^^^^^-------
@@ -51,7 +51,7 @@ LL |     let y = Option::as_mut(&mut x).take();
    = note: `as_mut` creates a temporary value, so calling take() has no effect
 
 error: called `Option::take()` on a temporary value
-  --> tests/ui/needless_option_take.rs:43:13
+  --> tests/ui/needless_option_take.rs:44:13
    |
 LL |     let x = return_option().take();
    |             ^^^^^^^^^^^^^^^-------
@@ -61,7 +61,7 @@ LL |     let x = return_option().take();
    = note: `return_option` creates a temporary value, so calling take() has no effect
 
 error: called `Option::take()` on a temporary value
-  --> tests/ui/needless_option_take.rs:47:13
+  --> tests/ui/needless_option_take.rs:48:13
    |
 LL |     let x = MyStruct::get_option().take();
    |             ^^^^^^^^^^^^^^^^^^^^^^-------
@@ -71,7 +71,7 @@ LL |     let x = MyStruct::get_option().take();
    = note: `get_option` creates a temporary value, so calling take() has no effect
 
 error: called `Option::take()` on a temporary value
-  --> tests/ui/needless_option_take.rs:53:13
+  --> tests/ui/needless_option_take.rs:54:13
    |
 LL |     let y = my_vec.first().take();
    |             ^^^^^^^^^^^^^^-------
@@ -81,7 +81,7 @@ LL |     let y = my_vec.first().take();
    = note: `first` creates a temporary value, so calling take() has no effect
 
 error: called `Option::take()` on a temporary value
-  --> tests/ui/needless_option_take.rs:56:13
+  --> tests/ui/needless_option_take.rs:57:13
    |
 LL |     let y = my_vec.first().take();
    |             ^^^^^^^^^^^^^^-------
diff --git a/src/tools/clippy/tests/ui/needless_parens_on_range_literals.fixed b/src/tools/clippy/tests/ui/needless_parens_on_range_literals.fixed
index b4d9e3297c49..7abcbc0c6e32 100644
--- a/src/tools/clippy/tests/ui/needless_parens_on_range_literals.fixed
+++ b/src/tools/clippy/tests/ui/needless_parens_on_range_literals.fixed
@@ -5,9 +5,15 @@
 
 fn main() {
     let _ = 'a'..='z';
+    //~^ needless_parens_on_range_literals
+    //~| needless_parens_on_range_literals
     let _ = 'a'..'z';
+    //~^ needless_parens_on_range_literals
     let _ = (1.)..2.;
     let _ = (1.)..2.;
+    //~^ needless_parens_on_range_literals
     let _ = 'a'..;
+    //~^ needless_parens_on_range_literals
     let _ = ..'z';
+    //~^ needless_parens_on_range_literals
 }
diff --git a/src/tools/clippy/tests/ui/needless_parens_on_range_literals.rs b/src/tools/clippy/tests/ui/needless_parens_on_range_literals.rs
index 2f0e54f80d85..2a6f9305883b 100644
--- a/src/tools/clippy/tests/ui/needless_parens_on_range_literals.rs
+++ b/src/tools/clippy/tests/ui/needless_parens_on_range_literals.rs
@@ -5,9 +5,15 @@
 
 fn main() {
     let _ = ('a')..=('z');
+    //~^ needless_parens_on_range_literals
+    //~| needless_parens_on_range_literals
     let _ = 'a'..('z');
+    //~^ needless_parens_on_range_literals
     let _ = (1.)..2.;
     let _ = (1.)..(2.);
+    //~^ needless_parens_on_range_literals
     let _ = ('a')..;
+    //~^ needless_parens_on_range_literals
     let _ = ..('z');
+    //~^ needless_parens_on_range_literals
 }
diff --git a/src/tools/clippy/tests/ui/needless_parens_on_range_literals.stderr b/src/tools/clippy/tests/ui/needless_parens_on_range_literals.stderr
index d293ecce69fb..082b2cd8cade 100644
--- a/src/tools/clippy/tests/ui/needless_parens_on_range_literals.stderr
+++ b/src/tools/clippy/tests/ui/needless_parens_on_range_literals.stderr
@@ -14,25 +14,25 @@ LL |     let _ = ('a')..=('z');
    |                     ^^^^^ help: try: `'z'`
 
 error: needless parenthesis on range literals can be removed
-  --> tests/ui/needless_parens_on_range_literals.rs:8:18
+  --> tests/ui/needless_parens_on_range_literals.rs:10:18
    |
 LL |     let _ = 'a'..('z');
    |                  ^^^^^ help: try: `'z'`
 
 error: needless parenthesis on range literals can be removed
-  --> tests/ui/needless_parens_on_range_literals.rs:10:19
+  --> tests/ui/needless_parens_on_range_literals.rs:13:19
    |
 LL |     let _ = (1.)..(2.);
    |                   ^^^^ help: try: `2.`
 
 error: needless parenthesis on range literals can be removed
-  --> tests/ui/needless_parens_on_range_literals.rs:11:13
+  --> tests/ui/needless_parens_on_range_literals.rs:15:13
    |
 LL |     let _ = ('a')..;
    |             ^^^^^ help: try: `'a'`
 
 error: needless parenthesis on range literals can be removed
-  --> tests/ui/needless_parens_on_range_literals.rs:12:15
+  --> tests/ui/needless_parens_on_range_literals.rs:17:15
    |
 LL |     let _ = ..('z');
    |               ^^^^^ help: try: `'z'`
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.rs b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.rs
index 162ec82aeded..f0c5a716ac99 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.rs
+++ b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.rs
@@ -9,7 +9,8 @@
 use std::ptr::NonNull;
 
 fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     *x += *b + s.len() as u32;
 }
 
@@ -34,7 +35,8 @@ fn foo5(s: &mut Vec<u32>) {
 }
 
 fn foo6(s: &mut Vec<u32>) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     non_mut_ref(s);
 }
 
@@ -44,10 +46,11 @@ struct Bar;
 
 impl Bar {
     fn bar(&mut self) {}
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
 
     fn mushroom(&self, vec: &mut Vec<i32>) -> usize {
-        //~^ ERROR: this argument is a mutable reference, but not used mutably
+        //~^ needless_pass_by_ref_mut
+
         vec.len()
     }
 }
@@ -124,35 +127,44 @@ async fn f7(x: &mut i32, y: i32, z: &mut i32, a: i32) {
 }
 
 async fn a1(x: &mut i32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     println!("{:?}", x);
 }
 async fn a2(x: &mut i32, y: String) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     println!("{:?}", x);
 }
 async fn a3(x: &mut i32, y: String, z: String) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     println!("{:?}", x);
 }
 async fn a4(x: &mut i32, y: i32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     println!("{:?}", x);
 }
 async fn a5(x: i32, y: &mut i32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     println!("{:?}", x);
 }
 async fn a6(x: i32, y: &mut i32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     println!("{:?}", x);
 }
 async fn a7(x: i32, y: i32, z: &mut i32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     println!("{:?}", z);
 }
 async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+    //~| needless_pass_by_ref_mut
+
     println!("{:?}", z);
 }
 
@@ -186,14 +198,12 @@ fn lint_attr(s: &mut u32) {}
 
 #[cfg(not(feature = "a"))]
 fn cfg_warn(s: &mut u32) {}
-//~^ ERROR: this argument is a mutable reference, but not used mutably
-//~| NOTE: this is cfg-gated and may require further changes
+//~^ needless_pass_by_ref_mut
 
 #[cfg(not(feature = "a"))]
 mod foo {
     fn cfg_warn(s: &mut u32) {}
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
-    //~| NOTE: this is cfg-gated and may require further changes
+    //~^ needless_pass_by_ref_mut
 }
 
 // Should not warn.
@@ -206,7 +216,8 @@ async fn inner_async(x: &mut i32, y: &mut u32) {
 }
 
 async fn inner_async2(x: &mut i32, y: &mut u32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     async {
         *x += 1;
     }
@@ -214,7 +225,8 @@ async fn inner_async2(x: &mut i32, y: &mut u32) {
 }
 
 async fn inner_async3(x: &mut i32, y: &mut u32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     async {
         *y += 1;
     }
@@ -233,6 +245,7 @@ async fn async_vec2(b: &mut Vec<bool>) {
 fn non_mut(n: &str) {}
 //Should warn
 async fn call_in_closure1(n: &mut str) {
+    //~^ needless_pass_by_ref_mut
     (|| non_mut(n))()
 }
 fn str_mut(str: &mut String) -> bool {
@@ -252,7 +265,8 @@ async fn closure(n: &mut usize) -> impl '_ + FnMut() {
 
 // Should warn.
 fn closure2(n: &mut usize) -> impl '_ + FnMut() -> usize {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     || *n + 1
 }
 
@@ -263,7 +277,8 @@ async fn closure3(n: &mut usize) {
 
 // Should warn.
 async fn closure4(n: &mut usize) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     (|| {
         let _x = *n + 1;
     })();
@@ -317,17 +332,20 @@ struct MutSelf {
 
 impl MutSelf {
     fn bar(&mut self) {}
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     async fn foo(&mut self, u: &mut i32, v: &mut u32) {
-        //~^ ERROR: this argument is a mutable reference, but not used mutably
-        //~| ERROR: this argument is a mutable reference, but not used mutably
+        //~^ needless_pass_by_ref_mut
+        //~| needless_pass_by_ref_mut
+
         async {
             *u += 1;
         }
         .await;
     }
     async fn foo2(&mut self, u: &mut i32, v: &mut u32) {
-        //~^ ERROR: this argument is a mutable reference, but not used mutably
+        //~^ needless_pass_by_ref_mut
+
         async {
             self.a += 1;
             *u += 1;
@@ -343,16 +361,26 @@ impl MutSelfTrait for MutSelf {
 
 // `is_from_proc_macro` stress tests
 fn _empty_tup(x: &mut (())) {}
+//~^ needless_pass_by_ref_mut
 fn _single_tup(x: &mut ((i32,))) {}
+//~^ needless_pass_by_ref_mut
 fn _multi_tup(x: &mut ((i32, u32))) {}
+//~^ needless_pass_by_ref_mut
 fn _fn(x: &mut (fn())) {}
+//~^ needless_pass_by_ref_mut
 #[rustfmt::skip]
 fn _extern_rust_fn(x: &mut extern "Rust" fn()) {}
+//~^ needless_pass_by_ref_mut
 fn _extern_c_fn(x: &mut extern "C" fn()) {}
+//~^ needless_pass_by_ref_mut
 fn _unsafe_fn(x: &mut unsafe fn()) {}
+//~^ needless_pass_by_ref_mut
 fn _unsafe_extern_fn(x: &mut unsafe extern "C" fn()) {}
+//~^ needless_pass_by_ref_mut
 fn _fn_with_arg(x: &mut unsafe extern "C" fn(i32)) {}
+//~^ needless_pass_by_ref_mut
 fn _fn_with_ret(x: &mut unsafe extern "C" fn() -> (i32)) {}
+//~^ needless_pass_by_ref_mut
 
 fn main() {
     let mut u = 0;
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.stderr b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.stderr
index f462fa9099ed..6637a255b5f5 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.stderr
+++ b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut.stderr
@@ -8,79 +8,79 @@ LL | fn foo(s: &mut Vec<u32>, b: &u32, x: &mut u32) {
    = help: to override `-D warnings` add `#[allow(clippy::needless_pass_by_ref_mut)]`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:36:12
+  --> tests/ui/needless_pass_by_ref_mut.rs:37:12
    |
 LL | fn foo6(s: &mut Vec<u32>) {
    |            ^^^^^^^^^^^^^ help: consider changing to: `&Vec<u32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:46:12
+  --> tests/ui/needless_pass_by_ref_mut.rs:48:12
    |
 LL |     fn bar(&mut self) {}
    |            ^^^^^^^^^ help: consider changing to: `&self`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:49:29
+  --> tests/ui/needless_pass_by_ref_mut.rs:51:29
    |
 LL |     fn mushroom(&self, vec: &mut Vec<i32>) -> usize {
    |                             ^^^^^^^^^^^^^ help: consider changing to: `&Vec<i32>`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:126:16
+  --> tests/ui/needless_pass_by_ref_mut.rs:129:16
    |
 LL | async fn a1(x: &mut i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:130:16
+  --> tests/ui/needless_pass_by_ref_mut.rs:134:16
    |
 LL | async fn a2(x: &mut i32, y: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:134:16
+  --> tests/ui/needless_pass_by_ref_mut.rs:139:16
    |
 LL | async fn a3(x: &mut i32, y: String, z: String) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:138:16
+  --> tests/ui/needless_pass_by_ref_mut.rs:144:16
    |
 LL | async fn a4(x: &mut i32, y: i32) {
    |                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:142:24
+  --> tests/ui/needless_pass_by_ref_mut.rs:149:24
    |
 LL | async fn a5(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:146:24
+  --> tests/ui/needless_pass_by_ref_mut.rs:154:24
    |
 LL | async fn a6(x: i32, y: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:150:32
+  --> tests/ui/needless_pass_by_ref_mut.rs:159:32
    |
 LL | async fn a7(x: i32, y: i32, z: &mut i32) {
    |                                ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:154:24
+  --> tests/ui/needless_pass_by_ref_mut.rs:164:24
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                        ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:154:45
+  --> tests/ui/needless_pass_by_ref_mut.rs:164:45
    |
 LL | async fn a8(x: i32, a: &mut i32, y: i32, z: &mut i32) {
    |                                             ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:188:16
+  --> tests/ui/needless_pass_by_ref_mut.rs:200:16
    |
 LL | fn cfg_warn(s: &mut u32) {}
    |                ^^^^^^^^ help: consider changing to: `&u32`
@@ -88,7 +88,7 @@ LL | fn cfg_warn(s: &mut u32) {}
    = note: this is cfg-gated and may require further changes
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:194:20
+  --> tests/ui/needless_pass_by_ref_mut.rs:205:20
    |
 LL |     fn cfg_warn(s: &mut u32) {}
    |                    ^^^^^^^^ help: consider changing to: `&u32`
@@ -96,115 +96,115 @@ LL |     fn cfg_warn(s: &mut u32) {}
    = note: this is cfg-gated and may require further changes
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:208:39
+  --> tests/ui/needless_pass_by_ref_mut.rs:218:39
    |
 LL | async fn inner_async2(x: &mut i32, y: &mut u32) {
    |                                       ^^^^^^^^ help: consider changing to: `&u32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:216:26
+  --> tests/ui/needless_pass_by_ref_mut.rs:227:26
    |
 LL | async fn inner_async3(x: &mut i32, y: &mut u32) {
    |                          ^^^^^^^^ help: consider changing to: `&i32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:235:30
+  --> tests/ui/needless_pass_by_ref_mut.rs:247:30
    |
 LL | async fn call_in_closure1(n: &mut str) {
    |                              ^^^^^^^^ help: consider changing to: `&str`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:254:16
+  --> tests/ui/needless_pass_by_ref_mut.rs:267:16
    |
 LL | fn closure2(n: &mut usize) -> impl '_ + FnMut() -> usize {
    |                ^^^^^^^^^^ help: consider changing to: `&usize`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:265:22
+  --> tests/ui/needless_pass_by_ref_mut.rs:279:22
    |
 LL | async fn closure4(n: &mut usize) {
    |                      ^^^^^^^^^^ help: consider changing to: `&usize`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:319:12
+  --> tests/ui/needless_pass_by_ref_mut.rs:334:12
    |
 LL |     fn bar(&mut self) {}
    |            ^^^^^^^^^ help: consider changing to: `&self`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:321:18
+  --> tests/ui/needless_pass_by_ref_mut.rs:337:18
    |
 LL |     async fn foo(&mut self, u: &mut i32, v: &mut u32) {
    |                  ^^^^^^^^^ help: consider changing to: `&self`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:321:45
+  --> tests/ui/needless_pass_by_ref_mut.rs:337:45
    |
 LL |     async fn foo(&mut self, u: &mut i32, v: &mut u32) {
    |                                             ^^^^^^^^ help: consider changing to: `&u32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:329:46
+  --> tests/ui/needless_pass_by_ref_mut.rs:346:46
    |
 LL |     async fn foo2(&mut self, u: &mut i32, v: &mut u32) {
    |                                              ^^^^^^^^ help: consider changing to: `&u32`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:345:18
+  --> tests/ui/needless_pass_by_ref_mut.rs:363:18
    |
 LL | fn _empty_tup(x: &mut (())) {}
    |                  ^^^^^^^^^ help: consider changing to: `&()`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:346:19
+  --> tests/ui/needless_pass_by_ref_mut.rs:365:19
    |
 LL | fn _single_tup(x: &mut ((i32,))) {}
    |                   ^^^^^^^^^^^^^ help: consider changing to: `&(i32,)`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:347:18
+  --> tests/ui/needless_pass_by_ref_mut.rs:367:18
    |
 LL | fn _multi_tup(x: &mut ((i32, u32))) {}
    |                  ^^^^^^^^^^^^^^^^^ help: consider changing to: `&(i32, u32)`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:348:11
+  --> tests/ui/needless_pass_by_ref_mut.rs:369:11
    |
 LL | fn _fn(x: &mut (fn())) {}
    |           ^^^^^^^^^^^ help: consider changing to: `&fn()`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:350:23
+  --> tests/ui/needless_pass_by_ref_mut.rs:372:23
    |
 LL | fn _extern_rust_fn(x: &mut extern "Rust" fn()) {}
    |                       ^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&extern "Rust" fn()`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:351:20
+  --> tests/ui/needless_pass_by_ref_mut.rs:374:20
    |
 LL | fn _extern_c_fn(x: &mut extern "C" fn()) {}
    |                    ^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&extern "C" fn()`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:352:18
+  --> tests/ui/needless_pass_by_ref_mut.rs:376:18
    |
 LL | fn _unsafe_fn(x: &mut unsafe fn()) {}
    |                  ^^^^^^^^^^^^^^^^ help: consider changing to: `&unsafe fn()`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:353:25
+  --> tests/ui/needless_pass_by_ref_mut.rs:378:25
    |
 LL | fn _unsafe_extern_fn(x: &mut unsafe extern "C" fn()) {}
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&unsafe extern "C" fn()`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:354:20
+  --> tests/ui/needless_pass_by_ref_mut.rs:380:20
    |
 LL | fn _fn_with_arg(x: &mut unsafe extern "C" fn(i32)) {}
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&unsafe extern "C" fn(i32)`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut.rs:355:20
+  --> tests/ui/needless_pass_by_ref_mut.rs:382:20
    |
 LL | fn _fn_with_ret(x: &mut unsafe extern "C" fn() -> (i32)) {}
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider changing to: `&unsafe extern "C" fn() -> (i32)`
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.fixed b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.fixed
index f26b39ea6a16..0e2ac0202364 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.fixed
+++ b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.fixed
@@ -6,7 +6,8 @@
 #![warn(clippy::needless_pass_by_ref_mut)]
 
 async fn inner_async3(x: &i32, y: &mut u32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     async {
         *y += 1;
     }
@@ -14,7 +15,8 @@ async fn inner_async3(x: &i32, y: &mut u32) {
 }
 
 async fn inner_async4(u: &mut i32, v: &u32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     async {
         *u += 1;
     }
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.rs b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.rs
index 4220215b1fe9..9201d9a27298 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.rs
+++ b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.rs
@@ -6,7 +6,8 @@
 #![warn(clippy::needless_pass_by_ref_mut)]
 
 async fn inner_async3(x: &mut i32, y: &mut u32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     async {
         *y += 1;
     }
@@ -14,7 +15,8 @@ async fn inner_async3(x: &mut i32, y: &mut u32) {
 }
 
 async fn inner_async4(u: &mut i32, v: &mut u32) {
-    //~^ ERROR: this argument is a mutable reference, but not used mutably
+    //~^ needless_pass_by_ref_mut
+
     async {
         *u += 1;
     }
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.stderr b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.stderr
index 1c0136cf5d59..9876a6b50718 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.stderr
+++ b/src/tools/clippy/tests/ui/needless_pass_by_ref_mut2.stderr
@@ -8,7 +8,7 @@ LL | async fn inner_async3(x: &mut i32, y: &mut u32) {
    = help: to override `-D warnings` add `#[allow(clippy::needless_pass_by_ref_mut)]`
 
 error: this argument is a mutable reference, but not used mutably
-  --> tests/ui/needless_pass_by_ref_mut2.rs:16:39
+  --> tests/ui/needless_pass_by_ref_mut2.rs:17:39
    |
 LL | async fn inner_async4(u: &mut i32, v: &mut u32) {
    |                                       ^^^^^^^^ help: consider changing to: `&u32`
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_value.rs b/src/tools/clippy/tests/ui/needless_pass_by_value.rs
index a8d9db95dcc7..885fb409417b 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_value.rs
+++ b/src/tools/clippy/tests/ui/needless_pass_by_value.rs
@@ -17,8 +17,8 @@ use std::mem::MaybeUninit;
 // `v` should be warned
 // `w`, `x` and `y` are allowed (moved or mutated)
 fn foo<T: Default>(v: Vec<T>, w: Vec<T>, mut x: Vec<T>, y: Vec<T>) -> Vec<T> {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
-    //~| NOTE: `-D clippy::needless-pass-by-value` implied by `-D warnings`
+    //~^ needless_pass_by_value
+
     assert_eq!(v.len(), 42);
 
     consume(w);
@@ -33,15 +33,17 @@ fn consume<T>(_: T) {}
 struct Wrapper(String);
 
 fn bar(x: String, y: Wrapper) {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+    //~| needless_pass_by_value
+
     assert_eq!(x.len(), 42);
     assert_eq!(y.0.len(), 42);
 }
 
 // V implements `Borrow<V>`, but should be warned correctly
 fn test_borrow_trait<T: Borrow<str>, U: AsRef<str>, V>(t: T, u: U, v: V) {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+
     println!("{}", t.borrow());
     println!("{}", u.as_ref());
     consume(&v);
@@ -54,7 +56,8 @@ fn test_fn<F: Fn(i32) -> i32>(f: F) {
 
 // x should be warned, but y is ok
 fn test_match(x: Option<Option<String>>, y: Option<Option<String>>) {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+
     match x {
         Some(Some(_)) => 1, // not moved
         _ => 0,
@@ -68,8 +71,9 @@ fn test_match(x: Option<Option<String>>, y: Option<Option<String>>) {
 
 // x and y should be warned, but z is ok
 fn test_destructure(x: Wrapper, y: Wrapper, z: Wrapper) {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+    //~| needless_pass_by_value
+
     let Wrapper(s) = z; // moved
     let Wrapper(ref t) = y; // not moved
     let Wrapper(_) = y; // still not moved
@@ -86,13 +90,14 @@ impl<'a, T> Serialize for &'a T where T: Serialize {}
 impl Serialize for i32 {}
 
 fn test_blanket_ref<T: Foo, S: Serialize>(vals: T, serializable: S) {}
-//~^ ERROR: this argument is passed by value, but not consumed in the function body
+//~^ needless_pass_by_value
 
 fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+    //~| needless_pass_by_value
+    //~| needless_pass_by_value
+    //~| needless_pass_by_value
+
     s.capacity();
     let _ = t.clone();
     u.capacity();
@@ -106,9 +111,9 @@ impl<T: Serialize, U> S<T, U> {
         self,
         // taking `self` by value is always allowed
         s: String,
-        //~^ ERROR: this argument is passed by value, but not consumed in the function bod
+        //~^ needless_pass_by_value
         t: String,
-        //~^ ERROR: this argument is passed by value, but not consumed in the function bod
+        //~^ needless_pass_by_value
     ) -> usize {
         s.len() + t.capacity()
     }
@@ -118,8 +123,8 @@ impl<T: Serialize, U> S<T, U> {
     }
 
     fn baz(&self, uu: U, ss: Self) {}
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+    //~| needless_pass_by_value
 }
 
 trait FalsePositive {
@@ -142,16 +147,18 @@ fn range<T: ::std::ops::RangeBounds<usize>>(range: T) {
 struct CopyWrapper(u32);
 
 fn bar_copy(x: u32, y: CopyWrapper) {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+
     assert_eq!(x, 42);
     assert_eq!(y.0, 42);
 }
 
 // x and y should be warned, but z is ok
 fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
-    //~^ ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
-    //~| ERROR: this argument is passed by value, but not consumed in the function body
+    //~^ needless_pass_by_value
+    //~| needless_pass_by_value
+    //~| needless_pass_by_value
+
     let CopyWrapper(s) = z; // moved
     let CopyWrapper(ref t) = y; // not moved
     let CopyWrapper(_) = y; // still not moved
@@ -164,13 +171,13 @@ fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
 trait Bar<'a, A> {}
 impl<'b, T> Bar<'b, T> for T {}
 fn some_fun<'b, S: Bar<'b, ()>>(items: S) {}
-//~^ ERROR: this argument is passed by value, but not consumed in the function body
+//~^ needless_pass_by_value
 
 // Also this should not cause an ICE. See #2831
 trait Club<'a, A> {}
 impl<T> Club<'static, T> for T {}
 fn more_fun(items: impl Club<'static, i32>) {}
-//~^ ERROR: this argument is passed by value, but not consumed in the function body
+//~^ needless_pass_by_value
 
 fn is_sync<T>(_: T)
 where
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_value.stderr b/src/tools/clippy/tests/ui/needless_pass_by_value.stderr
index 2c90da51252a..4ac4fdce972d 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_value.stderr
+++ b/src/tools/clippy/tests/ui/needless_pass_by_value.stderr
@@ -20,43 +20,43 @@ LL | fn bar(x: String, y: Wrapper) {
    |                      ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:43:71
+  --> tests/ui/needless_pass_by_value.rs:44:71
    |
 LL | fn test_borrow_trait<T: Borrow<str>, U: AsRef<str>, V>(t: T, u: U, v: V) {
    |                                                                       ^ help: consider taking a reference instead: `&V`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:56:18
+  --> tests/ui/needless_pass_by_value.rs:58:18
    |
 LL | fn test_match(x: Option<Option<String>>, y: Option<Option<String>>) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider taking a reference instead: `&Option<Option<String>>`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:70:24
+  --> tests/ui/needless_pass_by_value.rs:73:24
    |
 LL | fn test_destructure(x: Wrapper, y: Wrapper, z: Wrapper) {
    |                        ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:70:36
+  --> tests/ui/needless_pass_by_value.rs:73:36
    |
 LL | fn test_destructure(x: Wrapper, y: Wrapper, z: Wrapper) {
    |                                    ^^^^^^^ help: consider taking a reference instead: `&Wrapper`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:88:49
+  --> tests/ui/needless_pass_by_value.rs:92:49
    |
 LL | fn test_blanket_ref<T: Foo, S: Serialize>(vals: T, serializable: S) {}
    |                                                 ^ help: consider taking a reference instead: `&T`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:91:18
+  --> tests/ui/needless_pass_by_value.rs:95:18
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                  ^^^^^^ help: consider taking a reference instead: `&String`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:91:29
+  --> tests/ui/needless_pass_by_value.rs:95:29
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                             ^^^^^^
@@ -73,13 +73,13 @@ LL +     let _ = t.to_string();
    |
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:91:40
+  --> tests/ui/needless_pass_by_value.rs:95:40
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                                        ^^^^^^^^ help: consider taking a reference instead: `&Vec<i32>`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:91:53
+  --> tests/ui/needless_pass_by_value.rs:95:53
    |
 LL | fn issue_2114(s: String, t: String, u: Vec<i32>, v: Vec<i32>) {
    |                                                     ^^^^^^^^
@@ -96,85 +96,85 @@ LL +     let _ = v.to_owned();
    |
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:108:12
+  --> tests/ui/needless_pass_by_value.rs:113:12
    |
 LL |         s: String,
    |            ^^^^^^ help: consider changing the type to: `&str`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:110:12
+  --> tests/ui/needless_pass_by_value.rs:115:12
    |
 LL |         t: String,
    |            ^^^^^^ help: consider taking a reference instead: `&String`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:120:23
+  --> tests/ui/needless_pass_by_value.rs:125:23
    |
 LL |     fn baz(&self, uu: U, ss: Self) {}
    |                       ^ help: consider taking a reference instead: `&U`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:120:30
+  --> tests/ui/needless_pass_by_value.rs:125:30
    |
 LL |     fn baz(&self, uu: U, ss: Self) {}
    |                              ^^^^ help: consider taking a reference instead: `&Self`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:144:24
+  --> tests/ui/needless_pass_by_value.rs:149:24
    |
 LL | fn bar_copy(x: u32, y: CopyWrapper) {
    |                        ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: or consider marking this type as `Copy`
-  --> tests/ui/needless_pass_by_value.rs:142:1
+  --> tests/ui/needless_pass_by_value.rs:147:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:151:29
+  --> tests/ui/needless_pass_by_value.rs:157:29
    |
 LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
    |                             ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: or consider marking this type as `Copy`
-  --> tests/ui/needless_pass_by_value.rs:142:1
+  --> tests/ui/needless_pass_by_value.rs:147:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:151:45
+  --> tests/ui/needless_pass_by_value.rs:157:45
    |
 LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
    |                                             ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: or consider marking this type as `Copy`
-  --> tests/ui/needless_pass_by_value.rs:142:1
+  --> tests/ui/needless_pass_by_value.rs:147:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:151:61
+  --> tests/ui/needless_pass_by_value.rs:157:61
    |
 LL | fn test_destructure_copy(x: CopyWrapper, y: CopyWrapper, z: CopyWrapper) {
    |                                                             ^^^^^^^^^^^ help: consider taking a reference instead: `&CopyWrapper`
    |
 help: or consider marking this type as `Copy`
-  --> tests/ui/needless_pass_by_value.rs:142:1
+  --> tests/ui/needless_pass_by_value.rs:147:1
    |
 LL | struct CopyWrapper(u32);
    | ^^^^^^^^^^^^^^^^^^
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:166:40
+  --> tests/ui/needless_pass_by_value.rs:173:40
    |
 LL | fn some_fun<'b, S: Bar<'b, ()>>(items: S) {}
    |                                        ^ help: consider taking a reference instead: `&S`
 
 error: this argument is passed by value, but not consumed in the function body
-  --> tests/ui/needless_pass_by_value.rs:172:20
+  --> tests/ui/needless_pass_by_value.rs:179:20
    |
 LL | fn more_fun(items: impl Club<'static, i32>) {}
    |                    ^^^^^^^^^^^^^^^^^^^^^^^ help: consider taking a reference instead: `&impl Club<'static, i32>`
diff --git a/src/tools/clippy/tests/ui/needless_pass_by_value_proc_macro.rs b/src/tools/clippy/tests/ui/needless_pass_by_value_proc_macro.rs
index c603163c145f..67516a962e75 100644
--- a/src/tools/clippy/tests/ui/needless_pass_by_value_proc_macro.rs
+++ b/src/tools/clippy/tests/ui/needless_pass_by_value_proc_macro.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::needless_pass_by_value)]
 
 extern crate proc_macro;
diff --git a/src/tools/clippy/tests/ui/needless_pub_self.fixed b/src/tools/clippy/tests/ui/needless_pub_self.fixed
index d9f7b92d0901..7b4601ba8a37 100644
--- a/src/tools/clippy/tests/ui/needless_pub_self.fixed
+++ b/src/tools/clippy/tests/ui/needless_pub_self.fixed
@@ -11,13 +11,16 @@
 extern crate proc_macros;
 
  fn a() {}
+//~^ needless_pub_self
  fn b() {}
+//~^ needless_pub_self
 
 pub fn c() {}
 mod a {
     pub(in super) fn d() {}
     pub(super) fn e() {}
      fn f() {}
+    //~^ needless_pub_self
 }
 
 external! {
diff --git a/src/tools/clippy/tests/ui/needless_pub_self.rs b/src/tools/clippy/tests/ui/needless_pub_self.rs
index 9f0ec76477e6..f64a56c37989 100644
--- a/src/tools/clippy/tests/ui/needless_pub_self.rs
+++ b/src/tools/clippy/tests/ui/needless_pub_self.rs
@@ -11,13 +11,16 @@
 extern crate proc_macros;
 
 pub(self) fn a() {}
+//~^ needless_pub_self
 pub(in self) fn b() {}
+//~^ needless_pub_self
 
 pub fn c() {}
 mod a {
     pub(in super) fn d() {}
     pub(super) fn e() {}
     pub(self) fn f() {}
+    //~^ needless_pub_self
 }
 
 external! {
diff --git a/src/tools/clippy/tests/ui/needless_pub_self.stderr b/src/tools/clippy/tests/ui/needless_pub_self.stderr
index 1fdd84165659..c362d11804ec 100644
--- a/src/tools/clippy/tests/ui/needless_pub_self.stderr
+++ b/src/tools/clippy/tests/ui/needless_pub_self.stderr
@@ -9,7 +9,7 @@ LL | pub(self) fn a() {}
    = help: remove it
 
 error: unnecessary `pub(in self)`
-  --> tests/ui/needless_pub_self.rs:14:1
+  --> tests/ui/needless_pub_self.rs:15:1
    |
 LL | pub(in self) fn b() {}
    | ^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | pub(in self) fn b() {}
    = help: remove it
 
 error: unnecessary `pub(self)`
-  --> tests/ui/needless_pub_self.rs:20:5
+  --> tests/ui/needless_pub_self.rs:22:5
    |
 LL |     pub(self) fn f() {}
    |     ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/needless_question_mark.fixed b/src/tools/clippy/tests/ui/needless_question_mark.fixed
index 92f01c217c1c..375c38771eb6 100644
--- a/src/tools/clippy/tests/ui/needless_question_mark.fixed
+++ b/src/tools/clippy/tests/ui/needless_question_mark.fixed
@@ -18,6 +18,7 @@ struct TR {
 fn simple_option_bad1(to: TO) -> Option<usize> {
     // return as a statement
     return to.magic;
+    //~^ needless_question_mark
 }
 
 // formatting will add a semi-colon, which would make
@@ -26,16 +27,19 @@ fn simple_option_bad1(to: TO) -> Option<usize> {
 fn simple_option_bad2(to: TO) -> Option<usize> {
     // return as an expression
     return to.magic
+    //~^ needless_question_mark
 }
 
 fn simple_option_bad3(to: TO) -> Option<usize> {
     // block value "return"
     to.magic
+    //~^ needless_question_mark
 }
 
 fn simple_option_bad4(to: Option<TO>) -> Option<usize> {
     // single line closure
     to.and_then(|t| t.magic)
+    //~^ needless_question_mark
 }
 
 // formatting this will remove the block brackets, making
@@ -45,11 +49,13 @@ fn simple_option_bad5(to: Option<TO>) -> Option<usize> {
     // closure with body
     to.and_then(|t| {
         t.magic
+        //~^ needless_question_mark
     })
 }
 
 fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
     return tr.magic;
+    //~^ needless_question_mark
 }
 
 // formatting will add a semi-colon, which would make
@@ -57,14 +63,17 @@ fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
 #[rustfmt::skip]
 fn simple_result_bad2(tr: TR) -> Result<usize, bool> {
     return tr.magic
+    //~^ needless_question_mark
 }
 
 fn simple_result_bad3(tr: TR) -> Result<usize, bool> {
     tr.magic
+    //~^ needless_question_mark
 }
 
 fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
     tr.and_then(|t| t.magic)
+    //~^ needless_question_mark
 }
 
 // formatting this will remove the block brackets, making
@@ -73,6 +82,7 @@ fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
 fn simple_result_bad5(tr: Result<TR, bool>) -> Result<usize, bool> {
     tr.and_then(|t| {
         t.magic
+        //~^ needless_question_mark
     })
 }
 
@@ -80,6 +90,7 @@ fn also_bad(tr: Result<TR, bool>) -> Result<usize, bool> {
     if tr.is_ok() {
         let t = tr.unwrap();
         return t.magic;
+        //~^ needless_question_mark
     }
     Err(false)
 }
@@ -115,6 +126,7 @@ pub fn test1() {
 macro_rules! some_and_qmark_in_macro {
     ($expr:expr) => {
         || -> Option<_> { Some($expr) }()
+        //~^ needless_question_mark
     };
 }
 
@@ -126,6 +138,7 @@ pub fn test2() {
 async fn async_option_bad(to: TO) -> Option<usize> {
     let _ = Some(3);
     to.magic
+    //~^ needless_question_mark
 }
 
 async fn async_deref_ref(s: Option<&String>) -> Option<&str> {
@@ -134,8 +147,10 @@ async fn async_deref_ref(s: Option<&String>) -> Option<&str> {
 
 async fn async_result_bad(s: TR) -> Result<usize, bool> {
     s.magic
+    //~^ needless_question_mark
 }
 
 async fn async_wrapped<T>(a: Option<T>) -> Option<T> {
     { a }
+    //~^ needless_question_mark
 }
diff --git a/src/tools/clippy/tests/ui/needless_question_mark.rs b/src/tools/clippy/tests/ui/needless_question_mark.rs
index 21c858c291ff..5f6bd0c0f166 100644
--- a/src/tools/clippy/tests/ui/needless_question_mark.rs
+++ b/src/tools/clippy/tests/ui/needless_question_mark.rs
@@ -18,6 +18,7 @@ struct TR {
 fn simple_option_bad1(to: TO) -> Option<usize> {
     // return as a statement
     return Some(to.magic?);
+    //~^ needless_question_mark
 }
 
 // formatting will add a semi-colon, which would make
@@ -26,16 +27,19 @@ fn simple_option_bad1(to: TO) -> Option<usize> {
 fn simple_option_bad2(to: TO) -> Option<usize> {
     // return as an expression
     return Some(to.magic?)
+    //~^ needless_question_mark
 }
 
 fn simple_option_bad3(to: TO) -> Option<usize> {
     // block value "return"
     Some(to.magic?)
+    //~^ needless_question_mark
 }
 
 fn simple_option_bad4(to: Option<TO>) -> Option<usize> {
     // single line closure
     to.and_then(|t| Some(t.magic?))
+    //~^ needless_question_mark
 }
 
 // formatting this will remove the block brackets, making
@@ -45,11 +49,13 @@ fn simple_option_bad5(to: Option<TO>) -> Option<usize> {
     // closure with body
     to.and_then(|t| {
         Some(t.magic?)
+        //~^ needless_question_mark
     })
 }
 
 fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
     return Ok(tr.magic?);
+    //~^ needless_question_mark
 }
 
 // formatting will add a semi-colon, which would make
@@ -57,14 +63,17 @@ fn simple_result_bad1(tr: TR) -> Result<usize, bool> {
 #[rustfmt::skip]
 fn simple_result_bad2(tr: TR) -> Result<usize, bool> {
     return Ok(tr.magic?)
+    //~^ needless_question_mark
 }
 
 fn simple_result_bad3(tr: TR) -> Result<usize, bool> {
     Ok(tr.magic?)
+    //~^ needless_question_mark
 }
 
 fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
     tr.and_then(|t| Ok(t.magic?))
+    //~^ needless_question_mark
 }
 
 // formatting this will remove the block brackets, making
@@ -73,6 +82,7 @@ fn simple_result_bad4(tr: Result<TR, bool>) -> Result<usize, bool> {
 fn simple_result_bad5(tr: Result<TR, bool>) -> Result<usize, bool> {
     tr.and_then(|t| {
         Ok(t.magic?)
+        //~^ needless_question_mark
     })
 }
 
@@ -80,6 +90,7 @@ fn also_bad(tr: Result<TR, bool>) -> Result<usize, bool> {
     if tr.is_ok() {
         let t = tr.unwrap();
         return Ok(t.magic?);
+        //~^ needless_question_mark
     }
     Err(false)
 }
@@ -115,6 +126,7 @@ pub fn test1() {
 macro_rules! some_and_qmark_in_macro {
     ($expr:expr) => {
         || -> Option<_> { Some(Some($expr)?) }()
+        //~^ needless_question_mark
     };
 }
 
@@ -126,6 +138,7 @@ pub fn test2() {
 async fn async_option_bad(to: TO) -> Option<usize> {
     let _ = Some(3);
     Some(to.magic?)
+    //~^ needless_question_mark
 }
 
 async fn async_deref_ref(s: Option<&String>) -> Option<&str> {
@@ -134,8 +147,10 @@ async fn async_deref_ref(s: Option<&String>) -> Option<&str> {
 
 async fn async_result_bad(s: TR) -> Result<usize, bool> {
     Ok(s.magic?)
+    //~^ needless_question_mark
 }
 
 async fn async_wrapped<T>(a: Option<T>) -> Option<T> {
     { Some(a?) }
+    //~^ needless_question_mark
 }
diff --git a/src/tools/clippy/tests/ui/needless_question_mark.stderr b/src/tools/clippy/tests/ui/needless_question_mark.stderr
index 0a1cb5979708..55da4f28976c 100644
--- a/src/tools/clippy/tests/ui/needless_question_mark.stderr
+++ b/src/tools/clippy/tests/ui/needless_question_mark.stderr
@@ -8,67 +8,67 @@ LL |     return Some(to.magic?);
    = help: to override `-D warnings` add `#[allow(clippy::needless_question_mark)]`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:28:12
+  --> tests/ui/needless_question_mark.rs:29:12
    |
 LL |     return Some(to.magic?)
    |            ^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `to.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:33:5
+  --> tests/ui/needless_question_mark.rs:35:5
    |
 LL |     Some(to.magic?)
    |     ^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `to.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:38:21
+  --> tests/ui/needless_question_mark.rs:41:21
    |
 LL |     to.and_then(|t| Some(t.magic?))
    |                     ^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `t.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:47:9
+  --> tests/ui/needless_question_mark.rs:51:9
    |
 LL |         Some(t.magic?)
    |         ^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `t.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:52:12
+  --> tests/ui/needless_question_mark.rs:57:12
    |
 LL |     return Ok(tr.magic?);
    |            ^^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `tr.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:59:12
+  --> tests/ui/needless_question_mark.rs:65:12
    |
 LL |     return Ok(tr.magic?)
    |            ^^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `tr.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:63:5
+  --> tests/ui/needless_question_mark.rs:70:5
    |
 LL |     Ok(tr.magic?)
    |     ^^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `tr.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:67:21
+  --> tests/ui/needless_question_mark.rs:75:21
    |
 LL |     tr.and_then(|t| Ok(t.magic?))
    |                     ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `t.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:75:9
+  --> tests/ui/needless_question_mark.rs:84:9
    |
 LL |         Ok(t.magic?)
    |         ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `t.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:82:16
+  --> tests/ui/needless_question_mark.rs:92:16
    |
 LL |         return Ok(t.magic?);
    |                ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `t.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:117:27
+  --> tests/ui/needless_question_mark.rs:128:27
    |
 LL |         || -> Option<_> { Some(Some($expr)?) }()
    |                           ^^^^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `Some($expr)`
@@ -79,19 +79,19 @@ LL |     let _x = some_and_qmark_in_macro!(x?);
    = note: this error originates in the macro `some_and_qmark_in_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:128:5
+  --> tests/ui/needless_question_mark.rs:140:5
    |
 LL |     Some(to.magic?)
    |     ^^^^^^^^^^^^^^^ help: try removing question mark and `Some()`: `to.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:136:5
+  --> tests/ui/needless_question_mark.rs:149:5
    |
 LL |     Ok(s.magic?)
    |     ^^^^^^^^^^^^ help: try removing question mark and `Ok()`: `s.magic`
 
 error: question mark operator is useless here
-  --> tests/ui/needless_question_mark.rs:140:7
+  --> tests/ui/needless_question_mark.rs:154:7
    |
 LL |     { Some(a?) }
    |       ^^^^^^^^ help: try removing question mark and `Some()`: `a`
diff --git a/src/tools/clippy/tests/ui/needless_range_loop.rs b/src/tools/clippy/tests/ui/needless_range_loop.rs
index 75f1896eded1..8a1c1be289cf 100644
--- a/src/tools/clippy/tests/ui/needless_range_loop.rs
+++ b/src/tools/clippy/tests/ui/needless_range_loop.rs
@@ -14,8 +14,8 @@ fn main() {
     let mut vec = vec![1, 2, 3, 4];
     let vec2 = vec![1, 2, 3, 4];
     for i in 0..vec.len() {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
-        //~| NOTE: `-D clippy::needless-range-loop` implied by `-D warnings`
+        //~^ needless_range_loop
+
         println!("{}", vec[i]);
     }
 
@@ -25,23 +25,27 @@ fn main() {
     }
 
     for i in 0..vec.len() {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         let _ = vec[i];
     }
 
     // ICE #746
     for j in 0..4 {
-        //~^ ERROR: the loop variable `j` is only used to index `STATIC`
+        //~^ needless_range_loop
+
         println!("{:?}", STATIC[j]);
     }
 
     for j in 0..4 {
-        //~^ ERROR: the loop variable `j` is only used to index `CONST`
+        //~^ needless_range_loop
+
         println!("{:?}", CONST[j]);
     }
 
     for i in 0..vec.len() {
-        //~^ ERROR: the loop variable `i` is used to index `vec`
+        //~^ needless_range_loop
+
         println!("{} {}", vec[i], i);
     }
     for i in 0..vec.len() {
@@ -50,48 +54,57 @@ fn main() {
     }
 
     for i in 0..vec.len() {
-        //~^ ERROR: the loop variable `i` is only used to index `vec2`
+        //~^ needless_range_loop
+
         println!("{}", vec2[i]);
     }
 
     for i in 5..vec.len() {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         println!("{}", vec[i]);
     }
 
     for i in 0..MAX_LEN {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         println!("{}", vec[i]);
     }
 
     for i in 0..=MAX_LEN {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         println!("{}", vec[i]);
     }
 
     for i in 5..10 {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         println!("{}", vec[i]);
     }
 
     for i in 5..=10 {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         println!("{}", vec[i]);
     }
 
     for i in 5..vec.len() {
-        //~^ ERROR: the loop variable `i` is used to index `vec`
+        //~^ needless_range_loop
+
         println!("{} {}", vec[i], i);
     }
 
     for i in 5..10 {
-        //~^ ERROR: the loop variable `i` is used to index `vec`
+        //~^ needless_range_loop
+
         println!("{} {}", vec[i], i);
     }
 
     // #2542
     for i in 0..vec.len() {
-        //~^ ERROR: the loop variable `i` is used to index `vec`
+        //~^ needless_range_loop
+
         vec[i] = Some(1).unwrap_or_else(|| panic!("error on {}", i));
     }
 
diff --git a/src/tools/clippy/tests/ui/needless_range_loop.stderr b/src/tools/clippy/tests/ui/needless_range_loop.stderr
index 831b8511e434..23c085f9d3b2 100644
--- a/src/tools/clippy/tests/ui/needless_range_loop.stderr
+++ b/src/tools/clippy/tests/ui/needless_range_loop.stderr
@@ -25,7 +25,7 @@ LL +     for <item> in &vec {
    |
 
 error: the loop variable `j` is only used to index `STATIC`
-  --> tests/ui/needless_range_loop.rs:33:14
+  --> tests/ui/needless_range_loop.rs:34:14
    |
 LL |     for j in 0..4 {
    |              ^^^^
@@ -37,7 +37,7 @@ LL +     for <item> in &STATIC {
    |
 
 error: the loop variable `j` is only used to index `CONST`
-  --> tests/ui/needless_range_loop.rs:38:14
+  --> tests/ui/needless_range_loop.rs:40:14
    |
 LL |     for j in 0..4 {
    |              ^^^^
@@ -49,7 +49,7 @@ LL +     for <item> in &CONST {
    |
 
 error: the loop variable `i` is used to index `vec`
-  --> tests/ui/needless_range_loop.rs:43:14
+  --> tests/ui/needless_range_loop.rs:46:14
    |
 LL |     for i in 0..vec.len() {
    |              ^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     for (i, <item>) in vec.iter().enumerate() {
    |
 
 error: the loop variable `i` is only used to index `vec2`
-  --> tests/ui/needless_range_loop.rs:52:14
+  --> tests/ui/needless_range_loop.rs:56:14
    |
 LL |     for i in 0..vec.len() {
    |              ^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     for <item> in vec2.iter().take(vec.len()) {
    |
 
 error: the loop variable `i` is only used to index `vec`
-  --> tests/ui/needless_range_loop.rs:57:14
+  --> tests/ui/needless_range_loop.rs:62:14
    |
 LL |     for i in 5..vec.len() {
    |              ^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     for <item> in vec.iter().skip(5) {
    |
 
 error: the loop variable `i` is only used to index `vec`
-  --> tests/ui/needless_range_loop.rs:62:14
+  --> tests/ui/needless_range_loop.rs:68:14
    |
 LL |     for i in 0..MAX_LEN {
    |              ^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     for <item> in vec.iter().take(MAX_LEN) {
    |
 
 error: the loop variable `i` is only used to index `vec`
-  --> tests/ui/needless_range_loop.rs:67:14
+  --> tests/ui/needless_range_loop.rs:74:14
    |
 LL |     for i in 0..=MAX_LEN {
    |              ^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     for <item> in vec.iter().take(MAX_LEN + 1) {
    |
 
 error: the loop variable `i` is only used to index `vec`
-  --> tests/ui/needless_range_loop.rs:72:14
+  --> tests/ui/needless_range_loop.rs:80:14
    |
 LL |     for i in 5..10 {
    |              ^^^^^
@@ -121,7 +121,7 @@ LL +     for <item> in vec.iter().take(10).skip(5) {
    |
 
 error: the loop variable `i` is only used to index `vec`
-  --> tests/ui/needless_range_loop.rs:77:14
+  --> tests/ui/needless_range_loop.rs:86:14
    |
 LL |     for i in 5..=10 {
    |              ^^^^^^
@@ -133,7 +133,7 @@ LL +     for <item> in vec.iter().take(10 + 1).skip(5) {
    |
 
 error: the loop variable `i` is used to index `vec`
-  --> tests/ui/needless_range_loop.rs:82:14
+  --> tests/ui/needless_range_loop.rs:92:14
    |
 LL |     for i in 5..vec.len() {
    |              ^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     for (i, <item>) in vec.iter().enumerate().skip(5) {
    |
 
 error: the loop variable `i` is used to index `vec`
-  --> tests/ui/needless_range_loop.rs:87:14
+  --> tests/ui/needless_range_loop.rs:98:14
    |
 LL |     for i in 5..10 {
    |              ^^^^^
@@ -157,7 +157,7 @@ LL +     for (i, <item>) in vec.iter().enumerate().take(10).skip(5) {
    |
 
 error: the loop variable `i` is used to index `vec`
-  --> tests/ui/needless_range_loop.rs:93:14
+  --> tests/ui/needless_range_loop.rs:105:14
    |
 LL |     for i in 0..vec.len() {
    |              ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/needless_range_loop2.rs b/src/tools/clippy/tests/ui/needless_range_loop2.rs
index 787ff18f338d..68784a8df19d 100644
--- a/src/tools/clippy/tests/ui/needless_range_loop2.rs
+++ b/src/tools/clippy/tests/ui/needless_range_loop2.rs
@@ -9,8 +9,8 @@ fn main() {
     let ns = vec![2, 3, 5, 7];
 
     for i in 3..10 {
-        //~^ ERROR: the loop variable `i` is only used to index `ns`
-        //~| NOTE: `-D clippy::needless-range-loop` implied by `-D warnings`
+        //~^ needless_range_loop
+
         println!("{}", ns[i]);
     }
 
@@ -32,14 +32,16 @@ fn main() {
 
     let mut ms = vec![1, 2, 3, 4, 5, 6];
     for i in 0..ms.len() {
-        //~^ ERROR: the loop variable `i` is only used to index `ms`
+        //~^ needless_range_loop
+
         ms[i] *= 2;
     }
     assert_eq!(ms, vec![2, 4, 6, 8, 10, 12]);
 
     let mut ms = vec![1, 2, 3, 4, 5, 6];
     for i in 0..ms.len() {
-        //~^ ERROR: the loop variable `i` is only used to index `ms`
+        //~^ needless_range_loop
+
         let x = &mut ms[i];
         *x *= 2;
     }
@@ -64,7 +66,8 @@ fn main() {
     let mut vec = vec![0; 9];
 
     for i in x..x + 4 {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         vec[i] += 1;
     }
 
@@ -72,24 +75,28 @@ fn main() {
     let mut vec = vec![0; 10];
 
     for i in x..=x + 4 {
-        //~^ ERROR: the loop variable `i` is only used to index `vec`
+        //~^ needless_range_loop
+
         vec[i] += 1;
     }
 
     let arr = [1, 2, 3];
 
     for i in 0..3 {
-        //~^ ERROR: the loop variable `i` is only used to index `arr`
+        //~^ needless_range_loop
+
         println!("{}", arr[i]);
     }
 
     for i in 0..2 {
-        //~^ ERROR: the loop variable `i` is only used to index `arr`
+        //~^ needless_range_loop
+
         println!("{}", arr[i]);
     }
 
     for i in 1..3 {
-        //~^ ERROR: the loop variable `i` is only used to index `arr`
+        //~^ needless_range_loop
+
         println!("{}", arr[i]);
     }
 
diff --git a/src/tools/clippy/tests/ui/needless_range_loop2.stderr b/src/tools/clippy/tests/ui/needless_range_loop2.stderr
index f37e1f2872d0..cb979b3f3c24 100644
--- a/src/tools/clippy/tests/ui/needless_range_loop2.stderr
+++ b/src/tools/clippy/tests/ui/needless_range_loop2.stderr
@@ -25,7 +25,7 @@ LL +     for <item> in &mut ms {
    |
 
 error: the loop variable `i` is only used to index `ms`
-  --> tests/ui/needless_range_loop2.rs:41:14
+  --> tests/ui/needless_range_loop2.rs:42:14
    |
 LL |     for i in 0..ms.len() {
    |              ^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     for <item> in &mut ms {
    |
 
 error: the loop variable `i` is only used to index `vec`
-  --> tests/ui/needless_range_loop2.rs:66:14
+  --> tests/ui/needless_range_loop2.rs:68:14
    |
 LL |     for i in x..x + 4 {
    |              ^^^^^^^^
@@ -49,7 +49,7 @@ LL +     for <item> in vec.iter_mut().skip(x).take(4) {
    |
 
 error: the loop variable `i` is only used to index `vec`
-  --> tests/ui/needless_range_loop2.rs:74:14
+  --> tests/ui/needless_range_loop2.rs:77:14
    |
 LL |     for i in x..=x + 4 {
    |              ^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     for <item> in vec.iter_mut().skip(x).take(4 + 1) {
    |
 
 error: the loop variable `i` is only used to index `arr`
-  --> tests/ui/needless_range_loop2.rs:81:14
+  --> tests/ui/needless_range_loop2.rs:85:14
    |
 LL |     for i in 0..3 {
    |              ^^^^
@@ -73,7 +73,7 @@ LL +     for <item> in &arr {
    |
 
 error: the loop variable `i` is only used to index `arr`
-  --> tests/ui/needless_range_loop2.rs:86:14
+  --> tests/ui/needless_range_loop2.rs:91:14
    |
 LL |     for i in 0..2 {
    |              ^^^^
@@ -85,7 +85,7 @@ LL +     for <item> in arr.iter().take(2) {
    |
 
 error: the loop variable `i` is only used to index `arr`
-  --> tests/ui/needless_range_loop2.rs:91:14
+  --> tests/ui/needless_range_loop2.rs:97:14
    |
 LL |     for i in 1..3 {
    |              ^^^^
diff --git a/src/tools/clippy/tests/ui/needless_raw_string.fixed b/src/tools/clippy/tests/ui/needless_raw_string.fixed
index ab061467488a..88f9096db03c 100644
--- a/src/tools/clippy/tests/ui/needless_raw_string.fixed
+++ b/src/tools/clippy/tests/ui/needless_raw_string.fixed
@@ -3,31 +3,41 @@
 
 fn main() {
     "aaa";
+    //~^ needless_raw_strings
     r#""aaa""#;
     r#"\s"#;
     b"aaa";
+    //~^ needless_raw_strings
     br#""aaa""#;
     br#"\s"#;
     c"aaa";
+    //~^ needless_raw_strings
     cr#""aaa""#;
     cr#"\s"#;
 
     "
+    //~^ needless_raw_strings
         a
         multiline
         string
     ";
 
     "no hashes";
+    //~^ needless_raw_strings
     b"no hashes";
+    //~^ needless_raw_strings
     c"no hashes";
+    //~^ needless_raw_strings
 }
 
 fn issue_13503() {
     println!("SELECT * FROM posts");
+    //~^ needless_raw_strings
     println!("SELECT * FROM posts");
+    //~^ needless_raw_strings
     println!(r##"SELECT * FROM "posts""##);
 
     // Test arguments as well
     println!("{}", "foobar".len());
+    //~^ needless_raw_strings
 }
diff --git a/src/tools/clippy/tests/ui/needless_raw_string.rs b/src/tools/clippy/tests/ui/needless_raw_string.rs
index 5be8bdeb4ad0..6913b8b75546 100644
--- a/src/tools/clippy/tests/ui/needless_raw_string.rs
+++ b/src/tools/clippy/tests/ui/needless_raw_string.rs
@@ -3,31 +3,41 @@
 
 fn main() {
     r#"aaa"#;
+    //~^ needless_raw_strings
     r#""aaa""#;
     r#"\s"#;
     br#"aaa"#;
+    //~^ needless_raw_strings
     br#""aaa""#;
     br#"\s"#;
     cr#"aaa"#;
+    //~^ needless_raw_strings
     cr#""aaa""#;
     cr#"\s"#;
 
     r#"
+    //~^ needless_raw_strings
         a
         multiline
         string
     "#;
 
     r"no hashes";
+    //~^ needless_raw_strings
     br"no hashes";
+    //~^ needless_raw_strings
     cr"no hashes";
+    //~^ needless_raw_strings
 }
 
 fn issue_13503() {
     println!(r"SELECT * FROM posts");
+    //~^ needless_raw_strings
     println!(r#"SELECT * FROM posts"#);
+    //~^ needless_raw_strings
     println!(r##"SELECT * FROM "posts""##);
 
     // Test arguments as well
     println!("{}", r"foobar".len());
+    //~^ needless_raw_strings
 }
diff --git a/src/tools/clippy/tests/ui/needless_raw_string.stderr b/src/tools/clippy/tests/ui/needless_raw_string.stderr
index 5169f0855738..99c60b10b21b 100644
--- a/src/tools/clippy/tests/ui/needless_raw_string.stderr
+++ b/src/tools/clippy/tests/ui/needless_raw_string.stderr
@@ -13,7 +13,7 @@ LL +     "aaa";
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:8:5
+  --> tests/ui/needless_raw_string.rs:9:5
    |
 LL |     br#"aaa"#;
    |     ^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     b"aaa";
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:11:5
+  --> tests/ui/needless_raw_string.rs:13:5
    |
 LL |     cr#"aaa"#;
    |     ^^^^^^^^^
@@ -37,9 +37,10 @@ LL +     c"aaa";
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:15:5
+  --> tests/ui/needless_raw_string.rs:18:5
    |
 LL | /     r#"
+LL | |
 LL | |         a
 LL | |         multiline
 LL | |         string
@@ -49,14 +50,14 @@ LL | |     "#;
 help: use a plain string literal instead
    |
 LL ~     "
-LL |         a
-LL |         multiline
+LL |
+...
 LL |         string
 LL ~     ";
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:21:5
+  --> tests/ui/needless_raw_string.rs:25:5
    |
 LL |     r"no hashes";
    |     ^^^^^^^^^^^^
@@ -68,7 +69,7 @@ LL +     "no hashes";
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:22:5
+  --> tests/ui/needless_raw_string.rs:27:5
    |
 LL |     br"no hashes";
    |     ^^^^^^^^^^^^^
@@ -80,7 +81,7 @@ LL +     b"no hashes";
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:23:5
+  --> tests/ui/needless_raw_string.rs:29:5
    |
 LL |     cr"no hashes";
    |     ^^^^^^^^^^^^^
@@ -92,7 +93,7 @@ LL +     c"no hashes";
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:27:14
+  --> tests/ui/needless_raw_string.rs:34:14
    |
 LL |     println!(r"SELECT * FROM posts");
    |              ^^^^^^^^^^^^^^^^^^^^^^
@@ -104,7 +105,7 @@ LL +     println!("SELECT * FROM posts");
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:28:14
+  --> tests/ui/needless_raw_string.rs:36:14
    |
 LL |     println!(r#"SELECT * FROM posts"#);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -116,7 +117,7 @@ LL +     println!("SELECT * FROM posts");
    |
 
 error: unnecessary raw string literal
-  --> tests/ui/needless_raw_string.rs:32:20
+  --> tests/ui/needless_raw_string.rs:41:20
    |
 LL |     println!("{}", r"foobar".len());
    |                    ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/needless_raw_string_hashes.fixed b/src/tools/clippy/tests/ui/needless_raw_string_hashes.fixed
index 4c1137091071..bc7da202df4a 100644
--- a/src/tools/clippy/tests/ui/needless_raw_string_hashes.fixed
+++ b/src/tools/clippy/tests/ui/needless_raw_string_hashes.fixed
@@ -3,33 +3,51 @@
 
 fn main() {
     r"\aaa";
+    //~^ needless_raw_string_hashes
     r#"Hello "world"!"#;
+    //~^ needless_raw_string_hashes
     r####" "### "## "# "####;
+    //~^ needless_raw_string_hashes
     r###" "aa" "# "## "###;
+    //~^ needless_raw_string_hashes
     br"\aaa";
+    //~^ needless_raw_string_hashes
     br#"Hello "world"!"#;
+    //~^ needless_raw_string_hashes
     br####" "### "## "# "####;
+    //~^ needless_raw_string_hashes
     br###" "aa" "# "## "###;
+    //~^ needless_raw_string_hashes
     cr"\aaa";
+    //~^ needless_raw_string_hashes
     cr#"Hello "world"!"#;
+    //~^ needless_raw_string_hashes
     cr####" "### "## "# "####;
+    //~^ needless_raw_string_hashes
     cr###" "aa" "# "## "###;
+    //~^ needless_raw_string_hashes
 
     r"
+    //~^ needless_raw_string_hashes
         \a
         multiline
         string
     ";
 
     r"rust";
+    //~^ needless_raw_string_hashes
     r"hello world";
+    //~^ needless_raw_string_hashes
 }
 
 fn issue_13503() {
     println!(r"SELECT * FROM posts");
     println!(r"SELECT * FROM posts");
+    //~^ needless_raw_string_hashes
     println!(r#"SELECT * FROM "posts""#);
+    //~^ needless_raw_string_hashes
     println!(r#"SELECT * FROM "posts""#);
+    //~^ needless_raw_string_hashes
 
     // Test arguments as well
     println!("{}", r"foobar".len());
diff --git a/src/tools/clippy/tests/ui/needless_raw_string_hashes.rs b/src/tools/clippy/tests/ui/needless_raw_string_hashes.rs
index 7b6b4e784eea..3f2f92a4097c 100644
--- a/src/tools/clippy/tests/ui/needless_raw_string_hashes.rs
+++ b/src/tools/clippy/tests/ui/needless_raw_string_hashes.rs
@@ -3,33 +3,51 @@
 
 fn main() {
     r#"\aaa"#;
+    //~^ needless_raw_string_hashes
     r##"Hello "world"!"##;
+    //~^ needless_raw_string_hashes
     r######" "### "## "# "######;
+    //~^ needless_raw_string_hashes
     r######" "aa" "# "## "######;
+    //~^ needless_raw_string_hashes
     br#"\aaa"#;
+    //~^ needless_raw_string_hashes
     br##"Hello "world"!"##;
+    //~^ needless_raw_string_hashes
     br######" "### "## "# "######;
+    //~^ needless_raw_string_hashes
     br######" "aa" "# "## "######;
+    //~^ needless_raw_string_hashes
     cr#"\aaa"#;
+    //~^ needless_raw_string_hashes
     cr##"Hello "world"!"##;
+    //~^ needless_raw_string_hashes
     cr######" "### "## "# "######;
+    //~^ needless_raw_string_hashes
     cr######" "aa" "# "## "######;
+    //~^ needless_raw_string_hashes
 
     r#"
+    //~^ needless_raw_string_hashes
         \a
         multiline
         string
     "#;
 
     r###"rust"###;
+    //~^ needless_raw_string_hashes
     r#"hello world"#;
+    //~^ needless_raw_string_hashes
 }
 
 fn issue_13503() {
     println!(r"SELECT * FROM posts");
     println!(r#"SELECT * FROM posts"#);
+    //~^ needless_raw_string_hashes
     println!(r##"SELECT * FROM "posts""##);
+    //~^ needless_raw_string_hashes
     println!(r##"SELECT * FROM "posts""##);
+    //~^ needless_raw_string_hashes
 
     // Test arguments as well
     println!("{}", r"foobar".len());
diff --git a/src/tools/clippy/tests/ui/needless_raw_string_hashes.stderr b/src/tools/clippy/tests/ui/needless_raw_string_hashes.stderr
index a213ba3e7438..853ee7092528 100644
--- a/src/tools/clippy/tests/ui/needless_raw_string_hashes.stderr
+++ b/src/tools/clippy/tests/ui/needless_raw_string_hashes.stderr
@@ -13,7 +13,7 @@ LL +     r"\aaa";
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:6:5
+  --> tests/ui/needless_raw_string_hashes.rs:7:5
    |
 LL |     r##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     r#"Hello "world"!"#;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:7:5
+  --> tests/ui/needless_raw_string_hashes.rs:9:5
    |
 LL |     r######" "### "## "# "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     r####" "### "## "# "####;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:8:5
+  --> tests/ui/needless_raw_string_hashes.rs:11:5
    |
 LL |     r######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     r###" "aa" "# "## "###;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:9:5
+  --> tests/ui/needless_raw_string_hashes.rs:13:5
    |
 LL |     br#"\aaa"#;
    |     ^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     br"\aaa";
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:10:5
+  --> tests/ui/needless_raw_string_hashes.rs:15:5
    |
 LL |     br##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     br#"Hello "world"!"#;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:11:5
+  --> tests/ui/needless_raw_string_hashes.rs:17:5
    |
 LL |     br######" "### "## "# "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     br####" "### "## "# "####;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:12:5
+  --> tests/ui/needless_raw_string_hashes.rs:19:5
    |
 LL |     br######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     br###" "aa" "# "## "###;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:13:5
+  --> tests/ui/needless_raw_string_hashes.rs:21:5
    |
 LL |     cr#"\aaa"#;
    |     ^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     cr"\aaa";
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:14:5
+  --> tests/ui/needless_raw_string_hashes.rs:23:5
    |
 LL |     cr##"Hello "world"!"##;
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     cr#"Hello "world"!"#;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:15:5
+  --> tests/ui/needless_raw_string_hashes.rs:25:5
    |
 LL |     cr######" "### "## "# "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     cr####" "### "## "# "####;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:16:5
+  --> tests/ui/needless_raw_string_hashes.rs:27:5
    |
 LL |     cr######" "aa" "# "## "######;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,9 +145,10 @@ LL +     cr###" "aa" "# "## "###;
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:18:5
+  --> tests/ui/needless_raw_string_hashes.rs:30:5
    |
 LL | /     r#"
+LL | |
 LL | |         \a
 LL | |         multiline
 LL | |         string
@@ -157,14 +158,14 @@ LL | |     "#;
 help: remove all the hashes around the string literal
    |
 LL ~     r"
-LL |         \a
-LL |         multiline
+LL |
+...
 LL |         string
 LL ~     ";
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:24:5
+  --> tests/ui/needless_raw_string_hashes.rs:37:5
    |
 LL |     r###"rust"###;
    |     ^^^^^^^^^^^^^
@@ -176,7 +177,7 @@ LL +     r"rust";
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:25:5
+  --> tests/ui/needless_raw_string_hashes.rs:39:5
    |
 LL |     r#"hello world"#;
    |     ^^^^^^^^^^^^^^^^
@@ -188,7 +189,7 @@ LL +     r"hello world";
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:30:14
+  --> tests/ui/needless_raw_string_hashes.rs:45:14
    |
 LL |     println!(r#"SELECT * FROM posts"#);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -200,7 +201,7 @@ LL +     println!(r"SELECT * FROM posts");
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:31:14
+  --> tests/ui/needless_raw_string_hashes.rs:47:14
    |
 LL |     println!(r##"SELECT * FROM "posts""##);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -212,7 +213,7 @@ LL +     println!(r#"SELECT * FROM "posts""#);
    |
 
 error: unnecessary hashes around raw string literal
-  --> tests/ui/needless_raw_string_hashes.rs:32:14
+  --> tests/ui/needless_raw_string_hashes.rs:49:14
    |
 LL |     println!(r##"SELECT * FROM "posts""##);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/needless_return.fixed b/src/tools/clippy/tests/ui/needless_return.fixed
index aa2a274525bc..efc073ebe874 100644
--- a/src/tools/clippy/tests/ui/needless_return.fixed
+++ b/src/tools/clippy/tests/ui/needless_return.fixed
@@ -27,35 +27,43 @@ fn test_end_of_fn() -> bool {
         return true;
     }
     true
+    //~^ needless_return
 }
 
 fn test_no_semicolon() -> bool {
     true
+    //~^ needless_return
 }
 
 #[rustfmt::skip]
 fn test_multiple_semicolon() -> bool {
     true
+    //~^ needless_return
 }
 
 #[rustfmt::skip]
 fn test_multiple_semicolon_with_spaces() -> bool {
     true
+    //~^ needless_return
 }
 
 fn test_if_block() -> bool {
     if true {
         true
+        //~^ needless_return
     } else {
         false
+        //~^ needless_return
     }
 }
 
 fn test_match(x: bool) -> bool {
     match x {
         true => false,
+        //~^ needless_return
         false => {
             true
+            //~^ needless_return
         },
     }
 }
@@ -63,20 +71,26 @@ fn test_match(x: bool) -> bool {
 fn test_closure() {
     let _ = || {
         true
+        //~^ needless_return
     };
     let _ = || true;
+    //~^ needless_return
 }
 
 fn test_macro_call() -> i32 {
     the_answer!()
+    //~^ needless_return
 }
 
 fn test_void_fun() {
+    //~^^ needless_return
 }
 
 fn test_void_if_fun(b: bool) {
     if b {
+        //~^^ needless_return
     } else {
+        //~^^ needless_return
     }
 }
 
@@ -84,6 +98,7 @@ fn test_void_match(x: u32) {
     match x {
         0 => (),
         _ => (),
+        //~^ needless_return
     }
 }
 
@@ -92,8 +107,10 @@ fn test_nested_match(x: u32) {
         0 => (),
         1 => {
             let _ = 42;
+            //~^^ needless_return
         },
         _ => (),
+        //~^ needless_return
     }
 }
 
@@ -107,8 +124,10 @@ fn borrows_but_not_last(value: bool) -> String {
         let x = RefCell::<String>::default();
         let _a = x.borrow().clone();
         String::from("test")
+        //~^ needless_return
     } else {
         String::new()
+        //~^ needless_return
     }
 }
 
@@ -131,18 +150,22 @@ mod issue6501 {
     #[allow(clippy::unnecessary_lazy_evaluations)]
     fn foo(bar: Result<(), ()>) {
         bar.unwrap_or_else(|_| {})
+        //~^ needless_return
     }
 
     fn test_closure() {
         let _ = || {
+            //~^^ needless_return
         };
         let _ = || {};
+        //~^ needless_return
     }
 
     struct Foo;
     #[allow(clippy::unnecessary_lazy_evaluations)]
     fn bar(res: Result<Foo, u8>) -> Foo {
         res.unwrap_or_else(|_| Foo)
+        //~^ needless_return
     }
 }
 
@@ -152,25 +175,31 @@ async fn async_test_end_of_fn() -> bool {
         return true;
     }
     true
+    //~^ needless_return
 }
 
 async fn async_test_no_semicolon() -> bool {
     true
+    //~^ needless_return
 }
 
 async fn async_test_if_block() -> bool {
     if true {
         true
+        //~^ needless_return
     } else {
         false
+        //~^ needless_return
     }
 }
 
 async fn async_test_match(x: bool) -> bool {
     match x {
         true => false,
+        //~^ needless_return
         false => {
             true
+            //~^ needless_return
         },
     }
 }
@@ -178,20 +207,26 @@ async fn async_test_match(x: bool) -> bool {
 async fn async_test_closure() {
     let _ = || {
         true
+        //~^ needless_return
     };
     let _ = || true;
+    //~^ needless_return
 }
 
 async fn async_test_macro_call() -> i32 {
     the_answer!()
+    //~^ needless_return
 }
 
 async fn async_test_void_fun() {
+    //~^^ needless_return
 }
 
 async fn async_test_void_if_fun(b: bool) {
     if b {
+        //~^^ needless_return
     } else {
+        //~^^ needless_return
     }
 }
 
@@ -199,6 +234,7 @@ async fn async_test_void_match(x: u32) {
     match x {
         0 => (),
         _ => (),
+        //~^ needless_return
     }
 }
 
@@ -212,8 +248,10 @@ async fn async_borrows_but_not_last(value: bool) -> String {
         let x = RefCell::<String>::default();
         let _a = x.borrow().clone();
         String::from("test")
+        //~^ needless_return
     } else {
         String::new()
+        //~^ needless_return
     }
 }
 
@@ -230,6 +268,7 @@ fn needless_return_macro() -> String {
     let _ = "foo";
     let _ = "bar";
     format!("Hello {}", "world!")
+    //~^ needless_return
 }
 
 fn issue_9361(n: i32) -> i32 {
@@ -271,8 +310,10 @@ fn issue8336(x: i32) -> bool {
     if x > 0 {
         println!("something");
         true
+        //~^ needless_return
     } else {
         false
+        //~^ needless_return
     }
 }
 
@@ -280,9 +321,11 @@ fn issue8156(x: u8) -> u64 {
     match x {
         80 => {
             10
+            //~^ needless_return
         },
         _ => {
             100
+            //~^ needless_return
         },
     }
 }
@@ -291,6 +334,7 @@ fn issue8156(x: u8) -> u64 {
 fn issue9192() -> i32 {
     {
         0
+        //~^ needless_return
     }
 }
 
@@ -298,8 +342,10 @@ fn issue9503(x: usize) -> isize {
     unsafe {
         if x > 12 {
             *(x as *const isize)
+            //~^ needless_return
         } else {
             !*(x as *const isize)
+            //~^ needless_return
         }
     }
 }
@@ -307,11 +353,13 @@ fn issue9503(x: usize) -> isize {
 mod issue9416 {
     pub fn with_newline() {
         let _ = 42;
+        //~^^ needless_return
     }
 
     #[rustfmt::skip]
     pub fn oneline() {
         let _ = 42;
+        //~^ needless_return
     }
 }
 
@@ -324,18 +372,22 @@ fn issue9947() -> Result<(), String> {
 fn issue10051() -> Result<String, String> {
     if true {
         Ok(format!("ok!"))
+        //~^ needless_return
     } else {
         Err(format!("err!"))
+        //~^ needless_return
     }
 }
 
 mod issue10049 {
     fn single() -> u32 {
         if true { 1 } else { 2 }
+        //~^ needless_return
     }
 
     fn multiple(b1: bool, b2: bool, b3: bool) -> u32 {
         (if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 })
+        //~^ needless_return
     }
 }
 
@@ -357,10 +409,12 @@ fn allow_works() -> i32 {
 
 fn conjunctive_blocks() -> String {
     ({ "a".to_string() } + "b" + { "c" })
+    //~^ needless_return
 }
 
 fn issue12907() -> String {
     "".split("").next().unwrap().to_string()
+    //~^ needless_return
 }
 
 fn issue13458() {
diff --git a/src/tools/clippy/tests/ui/needless_return.rs b/src/tools/clippy/tests/ui/needless_return.rs
index bf67cfd3698a..283d86f25fe5 100644
--- a/src/tools/clippy/tests/ui/needless_return.rs
+++ b/src/tools/clippy/tests/ui/needless_return.rs
@@ -27,35 +27,43 @@ fn test_end_of_fn() -> bool {
         return true;
     }
     return true;
+    //~^ needless_return
 }
 
 fn test_no_semicolon() -> bool {
     return true;
+    //~^ needless_return
 }
 
 #[rustfmt::skip]
 fn test_multiple_semicolon() -> bool {
     return true;;;
+    //~^ needless_return
 }
 
 #[rustfmt::skip]
 fn test_multiple_semicolon_with_spaces() -> bool {
     return true;; ; ;
+    //~^ needless_return
 }
 
 fn test_if_block() -> bool {
     if true {
         return true;
+        //~^ needless_return
     } else {
         return false;
+        //~^ needless_return
     }
 }
 
 fn test_match(x: bool) -> bool {
     match x {
         true => return false,
+        //~^ needless_return
         false => {
             return true;
+            //~^ needless_return
         },
     }
 }
@@ -63,23 +71,29 @@ fn test_match(x: bool) -> bool {
 fn test_closure() {
     let _ = || {
         return true;
+        //~^ needless_return
     };
     let _ = || return true;
+    //~^ needless_return
 }
 
 fn test_macro_call() -> i32 {
     return the_answer!();
+    //~^ needless_return
 }
 
 fn test_void_fun() {
     return;
+    //~^^ needless_return
 }
 
 fn test_void_if_fun(b: bool) {
     if b {
         return;
+        //~^^ needless_return
     } else {
         return;
+        //~^^ needless_return
     }
 }
 
@@ -87,6 +101,7 @@ fn test_void_match(x: u32) {
     match x {
         0 => (),
         _ => return,
+        //~^ needless_return
     }
 }
 
@@ -96,8 +111,10 @@ fn test_nested_match(x: u32) {
         1 => {
             let _ = 42;
             return;
+            //~^^ needless_return
         },
         _ => return,
+        //~^ needless_return
     }
 }
 
@@ -111,8 +128,10 @@ fn borrows_but_not_last(value: bool) -> String {
         let x = RefCell::<String>::default();
         let _a = x.borrow().clone();
         return String::from("test");
+        //~^ needless_return
     } else {
         return String::new();
+        //~^ needless_return
     }
 }
 
@@ -135,19 +154,23 @@ mod issue6501 {
     #[allow(clippy::unnecessary_lazy_evaluations)]
     fn foo(bar: Result<(), ()>) {
         bar.unwrap_or_else(|_| return)
+        //~^ needless_return
     }
 
     fn test_closure() {
         let _ = || {
             return;
+            //~^^ needless_return
         };
         let _ = || return;
+        //~^ needless_return
     }
 
     struct Foo;
     #[allow(clippy::unnecessary_lazy_evaluations)]
     fn bar(res: Result<Foo, u8>) -> Foo {
         res.unwrap_or_else(|_| return Foo)
+        //~^ needless_return
     }
 }
 
@@ -157,25 +180,31 @@ async fn async_test_end_of_fn() -> bool {
         return true;
     }
     return true;
+    //~^ needless_return
 }
 
 async fn async_test_no_semicolon() -> bool {
     return true;
+    //~^ needless_return
 }
 
 async fn async_test_if_block() -> bool {
     if true {
         return true;
+        //~^ needless_return
     } else {
         return false;
+        //~^ needless_return
     }
 }
 
 async fn async_test_match(x: bool) -> bool {
     match x {
         true => return false,
+        //~^ needless_return
         false => {
             return true;
+            //~^ needless_return
         },
     }
 }
@@ -183,23 +212,29 @@ async fn async_test_match(x: bool) -> bool {
 async fn async_test_closure() {
     let _ = || {
         return true;
+        //~^ needless_return
     };
     let _ = || return true;
+    //~^ needless_return
 }
 
 async fn async_test_macro_call() -> i32 {
     return the_answer!();
+    //~^ needless_return
 }
 
 async fn async_test_void_fun() {
     return;
+    //~^^ needless_return
 }
 
 async fn async_test_void_if_fun(b: bool) {
     if b {
         return;
+        //~^^ needless_return
     } else {
         return;
+        //~^^ needless_return
     }
 }
 
@@ -207,6 +242,7 @@ async fn async_test_void_match(x: u32) {
     match x {
         0 => (),
         _ => return,
+        //~^ needless_return
     }
 }
 
@@ -220,8 +256,10 @@ async fn async_borrows_but_not_last(value: bool) -> String {
         let x = RefCell::<String>::default();
         let _a = x.borrow().clone();
         return String::from("test");
+        //~^ needless_return
     } else {
         return String::new();
+        //~^ needless_return
     }
 }
 
@@ -238,6 +276,7 @@ fn needless_return_macro() -> String {
     let _ = "foo";
     let _ = "bar";
     return format!("Hello {}", "world!");
+    //~^ needless_return
 }
 
 fn issue_9361(n: i32) -> i32 {
@@ -279,8 +318,10 @@ fn issue8336(x: i32) -> bool {
     if x > 0 {
         println!("something");
         return true;
+        //~^ needless_return
     } else {
         return false;
+        //~^ needless_return
     };
 }
 
@@ -288,9 +329,11 @@ fn issue8156(x: u8) -> u64 {
     match x {
         80 => {
             return 10;
+            //~^ needless_return
         },
         _ => {
             return 100;
+            //~^ needless_return
         },
     };
 }
@@ -299,6 +342,7 @@ fn issue8156(x: u8) -> u64 {
 fn issue9192() -> i32 {
     {
         return 0;
+        //~^ needless_return
     };
 }
 
@@ -306,8 +350,10 @@ fn issue9503(x: usize) -> isize {
     unsafe {
         if x > 12 {
             return *(x as *const isize);
+            //~^ needless_return
         } else {
             return !*(x as *const isize);
+            //~^ needless_return
         };
     };
 }
@@ -315,13 +361,14 @@ fn issue9503(x: usize) -> isize {
 mod issue9416 {
     pub fn with_newline() {
         let _ = 42;
-
         return;
+        //~^^ needless_return
     }
 
     #[rustfmt::skip]
     pub fn oneline() {
         let _ = 42; return;
+        //~^ needless_return
     }
 }
 
@@ -334,18 +381,22 @@ fn issue9947() -> Result<(), String> {
 fn issue10051() -> Result<String, String> {
     if true {
         return Ok(format!("ok!"));
+        //~^ needless_return
     } else {
         return Err(format!("err!"));
+        //~^ needless_return
     }
 }
 
 mod issue10049 {
     fn single() -> u32 {
         return if true { 1 } else { 2 };
+        //~^ needless_return
     }
 
     fn multiple(b1: bool, b2: bool, b3: bool) -> u32 {
         return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
+        //~^ needless_return
     }
 }
 
@@ -367,10 +418,12 @@ fn allow_works() -> i32 {
 
 fn conjunctive_blocks() -> String {
     return { "a".to_string() } + "b" + { "c" };
+    //~^ needless_return
 }
 
 fn issue12907() -> String {
     return "".split("").next().unwrap().to_string();
+    //~^ needless_return
 }
 
 fn issue13458() {
diff --git a/src/tools/clippy/tests/ui/needless_return.stderr b/src/tools/clippy/tests/ui/needless_return.stderr
index 8d8b5b9e713d..04c97a41d676 100644
--- a/src/tools/clippy/tests/ui/needless_return.stderr
+++ b/src/tools/clippy/tests/ui/needless_return.stderr
@@ -13,7 +13,7 @@ LL +     true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:33:5
+  --> tests/ui/needless_return.rs:34:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:38:5
+  --> tests/ui/needless_return.rs:40:5
    |
 LL |     return true;;;
    |     ^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:43:5
+  --> tests/ui/needless_return.rs:46:5
    |
 LL |     return true;; ; ;
    |     ^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:48:9
+  --> tests/ui/needless_return.rs:52:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +         true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:50:9
+  --> tests/ui/needless_return.rs:55:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +         false
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:56:17
+  --> tests/ui/needless_return.rs:62:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +         true => false,
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:58:13
+  --> tests/ui/needless_return.rs:65:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +             true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:65:9
+  --> tests/ui/needless_return.rs:73:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +         true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:67:16
+  --> tests/ui/needless_return.rs:76:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let _ = || true;
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:71:5
+  --> tests/ui/needless_return.rs:81:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     the_answer!()
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:74:21
+  --> tests/ui/needless_return.rs:85:21
    |
 LL |   fn test_void_fun() {
    |  _____________________^
@@ -148,7 +148,7 @@ LL + fn test_void_fun() {
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:79:11
+  --> tests/ui/needless_return.rs:91:11
    |
 LL |       if b {
    |  ___________^
@@ -163,7 +163,7 @@ LL +     if b {
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:81:13
+  --> tests/ui/needless_return.rs:94:13
    |
 LL |       } else {
    |  _____________^
@@ -178,7 +178,7 @@ LL +     } else {
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:89:14
+  --> tests/ui/needless_return.rs:103:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -190,7 +190,7 @@ LL +         _ => (),
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:97:24
+  --> tests/ui/needless_return.rs:112:24
    |
 LL |               let _ = 42;
    |  ________________________^
@@ -205,7 +205,7 @@ LL +             let _ = 42;
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:100:14
+  --> tests/ui/needless_return.rs:116:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -217,7 +217,7 @@ LL +         _ => (),
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:113:9
+  --> tests/ui/needless_return.rs:130:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL +         String::from("test")
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:115:9
+  --> tests/ui/needless_return.rs:133:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL +         String::new()
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:137:32
+  --> tests/ui/needless_return.rs:156:32
    |
 LL |         bar.unwrap_or_else(|_| return)
    |                                ^^^^^^
@@ -253,7 +253,7 @@ LL +         bar.unwrap_or_else(|_| {})
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:141:21
+  --> tests/ui/needless_return.rs:161:21
    |
 LL |           let _ = || {
    |  _____________________^
@@ -268,7 +268,7 @@ LL +         let _ = || {
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:144:20
+  --> tests/ui/needless_return.rs:165:20
    |
 LL |         let _ = || return;
    |                    ^^^^^^
@@ -280,7 +280,7 @@ LL +         let _ = || {};
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:150:32
+  --> tests/ui/needless_return.rs:172:32
    |
 LL |         res.unwrap_or_else(|_| return Foo)
    |                                ^^^^^^^^^^
@@ -292,7 +292,7 @@ LL +         res.unwrap_or_else(|_| Foo)
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:159:5
+  --> tests/ui/needless_return.rs:182:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -304,7 +304,7 @@ LL +     true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:163:5
+  --> tests/ui/needless_return.rs:187:5
    |
 LL |     return true;
    |     ^^^^^^^^^^^
@@ -316,7 +316,7 @@ LL +     true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:168:9
+  --> tests/ui/needless_return.rs:193:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -328,7 +328,7 @@ LL +         true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:170:9
+  --> tests/ui/needless_return.rs:196:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -340,7 +340,7 @@ LL +         false
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:176:17
+  --> tests/ui/needless_return.rs:203:17
    |
 LL |         true => return false,
    |                 ^^^^^^^^^^^^
@@ -352,7 +352,7 @@ LL +         true => false,
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:178:13
+  --> tests/ui/needless_return.rs:206:13
    |
 LL |             return true;
    |             ^^^^^^^^^^^
@@ -364,7 +364,7 @@ LL +             true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:185:9
+  --> tests/ui/needless_return.rs:214:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -376,7 +376,7 @@ LL +         true
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:187:16
+  --> tests/ui/needless_return.rs:217:16
    |
 LL |     let _ = || return true;
    |                ^^^^^^^^^^^
@@ -388,7 +388,7 @@ LL +     let _ = || true;
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:191:5
+  --> tests/ui/needless_return.rs:222:5
    |
 LL |     return the_answer!();
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -400,7 +400,7 @@ LL +     the_answer!()
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:194:33
+  --> tests/ui/needless_return.rs:226:33
    |
 LL |   async fn async_test_void_fun() {
    |  _________________________________^
@@ -415,7 +415,7 @@ LL + async fn async_test_void_fun() {
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:199:11
+  --> tests/ui/needless_return.rs:232:11
    |
 LL |       if b {
    |  ___________^
@@ -430,7 +430,7 @@ LL +     if b {
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:201:13
+  --> tests/ui/needless_return.rs:235:13
    |
 LL |       } else {
    |  _____________^
@@ -445,7 +445,7 @@ LL +     } else {
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:209:14
+  --> tests/ui/needless_return.rs:244:14
    |
 LL |         _ => return,
    |              ^^^^^^
@@ -457,7 +457,7 @@ LL +         _ => (),
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:222:9
+  --> tests/ui/needless_return.rs:258:9
    |
 LL |         return String::from("test");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -469,7 +469,7 @@ LL +         String::from("test")
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:224:9
+  --> tests/ui/needless_return.rs:261:9
    |
 LL |         return String::new();
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -481,7 +481,7 @@ LL +         String::new()
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:240:5
+  --> tests/ui/needless_return.rs:278:5
    |
 LL |     return format!("Hello {}", "world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -493,7 +493,7 @@ LL +     format!("Hello {}", "world!")
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:281:9
+  --> tests/ui/needless_return.rs:320:9
    |
 LL |         return true;
    |         ^^^^^^^^^^^
@@ -501,13 +501,14 @@ LL |         return true;
 help: remove `return`
    |
 LL ~         true
-LL |     } else {
-LL |         return false;
+LL |
+...
+LL |
 LL ~     }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:283:9
+  --> tests/ui/needless_return.rs:323:9
    |
 LL |         return false;
    |         ^^^^^^^^^^^^
@@ -515,11 +516,12 @@ LL |         return false;
 help: remove `return`
    |
 LL ~         false
+LL |
 LL ~     }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:290:13
+  --> tests/ui/needless_return.rs:331:13
    |
 LL |             return 10;
    |             ^^^^^^^^^
@@ -527,14 +529,14 @@ LL |             return 10;
 help: remove `return`
    |
 LL ~             10
-LL |         },
+LL |
 ...
 LL |         },
 LL ~     }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:293:13
+  --> tests/ui/needless_return.rs:335:13
    |
 LL |             return 100;
    |             ^^^^^^^^^^
@@ -542,12 +544,13 @@ LL |             return 100;
 help: remove `return`
    |
 LL ~             100
+LL |
 LL |         },
 LL ~     }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:301:9
+  --> tests/ui/needless_return.rs:344:9
    |
 LL |         return 0;
    |         ^^^^^^^^
@@ -555,11 +558,12 @@ LL |         return 0;
 help: remove `return`
    |
 LL ~         0
+LL |
 LL ~     }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:308:13
+  --> tests/ui/needless_return.rs:352:13
    |
 LL |             return *(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -567,14 +571,15 @@ LL |             return *(x as *const isize);
 help: remove `return`
    |
 LL ~             *(x as *const isize)
-LL |         } else {
-LL |             return !*(x as *const isize);
+LL |
+...
+LL |
 LL ~         }
 LL ~     }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:310:13
+  --> tests/ui/needless_return.rs:355:13
    |
 LL |             return !*(x as *const isize);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -582,29 +587,28 @@ LL |             return !*(x as *const isize);
 help: remove `return`
    |
 LL ~             !*(x as *const isize)
+LL |
 LL ~         }
 LL ~     }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:317:20
+  --> tests/ui/needless_return.rs:363:20
    |
 LL |           let _ = 42;
    |  ____________________^
-LL | |
 LL | |         return;
    | |______________^
    |
 help: remove `return`
    |
 LL -         let _ = 42;
-LL - 
 LL -         return;
 LL +         let _ = 42;
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:324:20
+  --> tests/ui/needless_return.rs:370:20
    |
 LL |         let _ = 42; return;
    |                    ^^^^^^^
@@ -616,7 +620,7 @@ LL +         let _ = 42;
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:336:9
+  --> tests/ui/needless_return.rs:383:9
    |
 LL |         return Ok(format!("ok!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -628,7 +632,7 @@ LL +         Ok(format!("ok!"))
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:338:9
+  --> tests/ui/needless_return.rs:386:9
    |
 LL |         return Err(format!("err!"));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -640,7 +644,7 @@ LL +         Err(format!("err!"))
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:344:9
+  --> tests/ui/needless_return.rs:393:9
    |
 LL |         return if true { 1 } else { 2 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -652,7 +656,7 @@ LL +         if true { 1 } else { 2 }
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:348:9
+  --> tests/ui/needless_return.rs:398:9
    |
 LL |         return if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else { 5 };
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -664,7 +668,7 @@ LL +         (if b1 { 0 } else { 1 } | if b2 { 2 } else { 3 } | if b3 { 4 } else
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:369:5
+  --> tests/ui/needless_return.rs:420:5
    |
 LL |     return { "a".to_string() } + "b" + { "c" };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -676,7 +680,7 @@ LL +     ({ "a".to_string() } + "b" + { "c" })
    |
 
 error: unneeded `return` statement
-  --> tests/ui/needless_return.rs:373:5
+  --> tests/ui/needless_return.rs:425:5
    |
 LL |     return "".split("").next().unwrap().to_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/needless_return_with_question_mark.fixed b/src/tools/clippy/tests/ui/needless_return_with_question_mark.fixed
index 9b7da8526631..2c6faf37717d 100644
--- a/src/tools/clippy/tests/ui/needless_return_with_question_mark.fixed
+++ b/src/tools/clippy/tests/ui/needless_return_with_question_mark.fixed
@@ -27,6 +27,7 @@ fn c() -> Option<()> {
 
 fn main() -> Result<(), ()> {
     Err(())?;
+    //~^ needless_return_with_question_mark
     return Ok::<(), ()>(());
     Err(())?;
     Ok::<(), ()>(());
diff --git a/src/tools/clippy/tests/ui/needless_return_with_question_mark.rs b/src/tools/clippy/tests/ui/needless_return_with_question_mark.rs
index 68e76d2b6402..b4411fa19561 100644
--- a/src/tools/clippy/tests/ui/needless_return_with_question_mark.rs
+++ b/src/tools/clippy/tests/ui/needless_return_with_question_mark.rs
@@ -27,6 +27,7 @@ fn c() -> Option<()> {
 
 fn main() -> Result<(), ()> {
     return Err(())?;
+    //~^ needless_return_with_question_mark
     return Ok::<(), ()>(());
     Err(())?;
     Ok::<(), ()>(());
diff --git a/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr b/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr
index 76dd5f953bc6..2af0f46a1ad0 100644
--- a/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr
+++ b/src/tools/clippy/tests/ui/needless_return_with_question_mark.stderr
@@ -8,7 +8,7 @@ LL |     return Err(())?;
    = help: to override `-D warnings` add `#[allow(clippy::needless_return_with_question_mark)]`
 
 error: unneeded `return` statement with `?` operator
-  --> tests/ui/needless_return_with_question_mark.rs:69:9
+  --> tests/ui/needless_return_with_question_mark.rs:70:9
    |
 LL |         return Err(())?;
    |         ^^^^^^^ help: remove it
diff --git a/src/tools/clippy/tests/ui/needless_splitn.fixed b/src/tools/clippy/tests/ui/needless_splitn.fixed
index efc47533e233..bf5c1717ae53 100644
--- a/src/tools/clippy/tests/ui/needless_splitn.fixed
+++ b/src/tools/clippy/tests/ui/needless_splitn.fixed
@@ -11,29 +11,41 @@ use itertools::Itertools;
 fn main() {
     let str = "key=value=end";
     let _ = str.split('=').next();
+    //~^ needless_splitn
     let _ = str.split('=').nth(0);
+    //~^ needless_splitn
     let _ = str.splitn(2, '=').nth(1);
     let (_, _) = str.splitn(2, '=').next_tuple().unwrap();
     let (_, _) = str.split('=').next_tuple().unwrap();
+    //~^ needless_splitn
     let _: Vec<&str> = str.splitn(3, '=').collect();
 
     let _ = str.rsplit('=').next();
+    //~^ needless_splitn
     let _ = str.rsplit('=').nth(0);
+    //~^ needless_splitn
     let _ = str.rsplitn(2, '=').nth(1);
     let (_, _) = str.rsplitn(2, '=').next_tuple().unwrap();
     let (_, _) = str.rsplit('=').next_tuple().unwrap();
+    //~^ needless_splitn
 
     let _ = str.split('=').next();
+    //~^ needless_splitn
     let _ = str.split('=').nth(3);
+    //~^ needless_splitn
     let _ = str.splitn(5, '=').nth(4);
     let _ = str.splitn(5, '=').nth(5);
 }
 
 fn _question_mark(s: &str) -> Option<()> {
     let _ = s.split('=').next()?;
+    //~^ needless_splitn
     let _ = s.split('=').nth(0)?;
+    //~^ needless_splitn
     let _ = s.rsplit('=').next()?;
+    //~^ needless_splitn
     let _ = s.rsplit('=').nth(0)?;
+    //~^ needless_splitn
 
     Some(())
 }
@@ -42,4 +54,5 @@ fn _question_mark(s: &str) -> Option<()> {
 fn _test_msrv() {
     // `manual_split_once` MSRV shouldn't apply to `needless_splitn`
     let _ = "key=value".split('=').nth(0).unwrap();
+    //~^ needless_splitn
 }
diff --git a/src/tools/clippy/tests/ui/needless_splitn.rs b/src/tools/clippy/tests/ui/needless_splitn.rs
index a4a3736eea2f..fdfdcb9d5ca8 100644
--- a/src/tools/clippy/tests/ui/needless_splitn.rs
+++ b/src/tools/clippy/tests/ui/needless_splitn.rs
@@ -11,29 +11,41 @@ use itertools::Itertools;
 fn main() {
     let str = "key=value=end";
     let _ = str.splitn(2, '=').next();
+    //~^ needless_splitn
     let _ = str.splitn(2, '=').nth(0);
+    //~^ needless_splitn
     let _ = str.splitn(2, '=').nth(1);
     let (_, _) = str.splitn(2, '=').next_tuple().unwrap();
     let (_, _) = str.splitn(3, '=').next_tuple().unwrap();
+    //~^ needless_splitn
     let _: Vec<&str> = str.splitn(3, '=').collect();
 
     let _ = str.rsplitn(2, '=').next();
+    //~^ needless_splitn
     let _ = str.rsplitn(2, '=').nth(0);
+    //~^ needless_splitn
     let _ = str.rsplitn(2, '=').nth(1);
     let (_, _) = str.rsplitn(2, '=').next_tuple().unwrap();
     let (_, _) = str.rsplitn(3, '=').next_tuple().unwrap();
+    //~^ needless_splitn
 
     let _ = str.splitn(5, '=').next();
+    //~^ needless_splitn
     let _ = str.splitn(5, '=').nth(3);
+    //~^ needless_splitn
     let _ = str.splitn(5, '=').nth(4);
     let _ = str.splitn(5, '=').nth(5);
 }
 
 fn _question_mark(s: &str) -> Option<()> {
     let _ = s.splitn(2, '=').next()?;
+    //~^ needless_splitn
     let _ = s.splitn(2, '=').nth(0)?;
+    //~^ needless_splitn
     let _ = s.rsplitn(2, '=').next()?;
+    //~^ needless_splitn
     let _ = s.rsplitn(2, '=').nth(0)?;
+    //~^ needless_splitn
 
     Some(())
 }
@@ -42,4 +54,5 @@ fn _question_mark(s: &str) -> Option<()> {
 fn _test_msrv() {
     // `manual_split_once` MSRV shouldn't apply to `needless_splitn`
     let _ = "key=value".splitn(2, '=').nth(0).unwrap();
+    //~^ needless_splitn
 }
diff --git a/src/tools/clippy/tests/ui/needless_splitn.stderr b/src/tools/clippy/tests/ui/needless_splitn.stderr
index ffd82c3fcb13..49387793a122 100644
--- a/src/tools/clippy/tests/ui/needless_splitn.stderr
+++ b/src/tools/clippy/tests/ui/needless_splitn.stderr
@@ -8,73 +8,73 @@ LL |     let _ = str.splitn(2, '=').next();
    = help: to override `-D warnings` add `#[allow(clippy::needless_splitn)]`
 
 error: unnecessary use of `splitn`
-  --> tests/ui/needless_splitn.rs:14:13
+  --> tests/ui/needless_splitn.rs:15:13
    |
 LL |     let _ = str.splitn(2, '=').nth(0);
    |             ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `splitn`
-  --> tests/ui/needless_splitn.rs:17:18
+  --> tests/ui/needless_splitn.rs:19:18
    |
 LL |     let (_, _) = str.splitn(3, '=').next_tuple().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `rsplitn`
-  --> tests/ui/needless_splitn.rs:20:13
+  --> tests/ui/needless_splitn.rs:23:13
    |
 LL |     let _ = str.rsplitn(2, '=').next();
    |             ^^^^^^^^^^^^^^^^^^^ help: try: `str.rsplit('=')`
 
 error: unnecessary use of `rsplitn`
-  --> tests/ui/needless_splitn.rs:21:13
+  --> tests/ui/needless_splitn.rs:25:13
    |
 LL |     let _ = str.rsplitn(2, '=').nth(0);
    |             ^^^^^^^^^^^^^^^^^^^ help: try: `str.rsplit('=')`
 
 error: unnecessary use of `rsplitn`
-  --> tests/ui/needless_splitn.rs:24:18
+  --> tests/ui/needless_splitn.rs:29:18
    |
 LL |     let (_, _) = str.rsplitn(3, '=').next_tuple().unwrap();
    |                  ^^^^^^^^^^^^^^^^^^^ help: try: `str.rsplit('=')`
 
 error: unnecessary use of `splitn`
-  --> tests/ui/needless_splitn.rs:26:13
+  --> tests/ui/needless_splitn.rs:32:13
    |
 LL |     let _ = str.splitn(5, '=').next();
    |             ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `splitn`
-  --> tests/ui/needless_splitn.rs:27:13
+  --> tests/ui/needless_splitn.rs:34:13
    |
 LL |     let _ = str.splitn(5, '=').nth(3);
    |             ^^^^^^^^^^^^^^^^^^ help: try: `str.split('=')`
 
 error: unnecessary use of `splitn`
-  --> tests/ui/needless_splitn.rs:33:13
+  --> tests/ui/needless_splitn.rs:41:13
    |
 LL |     let _ = s.splitn(2, '=').next()?;
    |             ^^^^^^^^^^^^^^^^ help: try: `s.split('=')`
 
 error: unnecessary use of `splitn`
-  --> tests/ui/needless_splitn.rs:34:13
+  --> tests/ui/needless_splitn.rs:43:13
    |
 LL |     let _ = s.splitn(2, '=').nth(0)?;
    |             ^^^^^^^^^^^^^^^^ help: try: `s.split('=')`
 
 error: unnecessary use of `rsplitn`
-  --> tests/ui/needless_splitn.rs:35:13
+  --> tests/ui/needless_splitn.rs:45:13
    |
 LL |     let _ = s.rsplitn(2, '=').next()?;
    |             ^^^^^^^^^^^^^^^^^ help: try: `s.rsplit('=')`
 
 error: unnecessary use of `rsplitn`
-  --> tests/ui/needless_splitn.rs:36:13
+  --> tests/ui/needless_splitn.rs:47:13
    |
 LL |     let _ = s.rsplitn(2, '=').nth(0)?;
    |             ^^^^^^^^^^^^^^^^^ help: try: `s.rsplit('=')`
 
 error: unnecessary use of `splitn`
-  --> tests/ui/needless_splitn.rs:44:13
+  --> tests/ui/needless_splitn.rs:56:13
    |
 LL |     let _ = "key=value".splitn(2, '=').nth(0).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `"key=value".split('=')`
diff --git a/src/tools/clippy/tests/ui/needless_update.rs b/src/tools/clippy/tests/ui/needless_update.rs
index 7c59abf07aba..62e349234319 100644
--- a/src/tools/clippy/tests/ui/needless_update.rs
+++ b/src/tools/clippy/tests/ui/needless_update.rs
@@ -17,8 +17,7 @@ fn main() {
     S { ..base }; // no error
     S { a: 1, ..base }; // no error
     S { a: 1, b: 1, ..base };
-    //~^ ERROR: struct update has no effect, all the fields in the struct have already bee
-    //~| NOTE: `-D clippy::needless-update` implied by `-D warnings`
+    //~^ needless_update
 
     let base = T { x: 0, y: 0 };
     T { ..base }; // no error
diff --git a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs
index c79fd2665260..27b51b428170 100644
--- a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs
+++ b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.rs
@@ -14,20 +14,19 @@ fn main() {
 
     // Not Less but potentially Greater, Equal or Uncomparable.
     let _not_less = !(a_value < another_value);
-    //~^ ERROR: the use of negated comparison operators on partially ordered types produce
-    //~| NOTE: `-D clippy::neg-cmp-op-on-partial-ord` implied by `-D warnings`
+    //~^ neg_cmp_op_on_partial_ord
 
     // Not Less or Equal but potentially Greater or Uncomparable.
     let _not_less_or_equal = !(a_value <= another_value);
-    //~^ ERROR: the use of negated comparison operators on partially ordered types produce
+    //~^ neg_cmp_op_on_partial_ord
 
     // Not Greater but potentially Less, Equal or Uncomparable.
     let _not_greater = !(a_value > another_value);
-    //~^ ERROR: the use of negated comparison operators on partially ordered types produce
+    //~^ neg_cmp_op_on_partial_ord
 
     // Not Greater or Equal but potentially Less or Uncomparable.
     let _not_greater_or_equal = !(a_value >= another_value);
-    //~^ ERROR: the use of negated comparison operators on partially ordered types produce
+    //~^ neg_cmp_op_on_partial_ord
 
     // --- Good ---
 
diff --git a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.stderr b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.stderr
index d4f7f14f59a3..3c11d5b8826a 100644
--- a/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.stderr
+++ b/src/tools/clippy/tests/ui/neg_cmp_op_on_partial_ord.stderr
@@ -8,19 +8,19 @@ LL |     let _not_less = !(a_value < another_value);
    = help: to override `-D warnings` add `#[allow(clippy::neg_cmp_op_on_partial_ord)]`
 
 error: the use of negated comparison operators on partially ordered types produces code that is hard to read and refactor, please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable
-  --> tests/ui/neg_cmp_op_on_partial_ord.rs:21:30
+  --> tests/ui/neg_cmp_op_on_partial_ord.rs:20:30
    |
 LL |     let _not_less_or_equal = !(a_value <= another_value);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the use of negated comparison operators on partially ordered types produces code that is hard to read and refactor, please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable
-  --> tests/ui/neg_cmp_op_on_partial_ord.rs:25:24
+  --> tests/ui/neg_cmp_op_on_partial_ord.rs:24:24
    |
 LL |     let _not_greater = !(a_value > another_value);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: the use of negated comparison operators on partially ordered types produces code that is hard to read and refactor, please consider using the `partial_cmp` method instead, to make it clear that the two values could be incomparable
-  --> tests/ui/neg_cmp_op_on_partial_ord.rs:29:33
+  --> tests/ui/neg_cmp_op_on_partial_ord.rs:28:33
    |
 LL |     let _not_greater_or_equal = !(a_value >= another_value);
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/neg_multiply.fixed b/src/tools/clippy/tests/ui/neg_multiply.fixed
index 52edea73afbb..995470493bfb 100644
--- a/src/tools/clippy/tests/ui/neg_multiply.fixed
+++ b/src/tools/clippy/tests/ui/neg_multiply.fixed
@@ -26,19 +26,27 @@ fn main() {
     let x = 0;
 
     -x;
+    //~^ neg_multiply
 
     -x;
+    //~^ neg_multiply
 
     100 + -x;
+    //~^ neg_multiply
 
     -(100 + x);
+    //~^ neg_multiply
 
     -17;
+    //~^ neg_multiply
 
     0xcafe | -0xff00;
+    //~^ neg_multiply
 
     -(3_usize as i32);
+    //~^ neg_multiply
     -(3_usize as i32);
+    //~^ neg_multiply
 
     -1 * -1; // should be ok
 
diff --git a/src/tools/clippy/tests/ui/neg_multiply.rs b/src/tools/clippy/tests/ui/neg_multiply.rs
index 23092a35e606..95b94e29517f 100644
--- a/src/tools/clippy/tests/ui/neg_multiply.rs
+++ b/src/tools/clippy/tests/ui/neg_multiply.rs
@@ -26,19 +26,27 @@ fn main() {
     let x = 0;
 
     x * -1;
+    //~^ neg_multiply
 
     -1 * x;
+    //~^ neg_multiply
 
     100 + x * -1;
+    //~^ neg_multiply
 
     (100 + x) * -1;
+    //~^ neg_multiply
 
     -1 * 17;
+    //~^ neg_multiply
 
     0xcafe | 0xff00 * -1;
+    //~^ neg_multiply
 
     3_usize as i32 * -1;
+    //~^ neg_multiply
     (3_usize as i32) * -1;
+    //~^ neg_multiply
 
     -1 * -1; // should be ok
 
diff --git a/src/tools/clippy/tests/ui/neg_multiply.stderr b/src/tools/clippy/tests/ui/neg_multiply.stderr
index 13226c7c37b3..9efa5d3ba1f1 100644
--- a/src/tools/clippy/tests/ui/neg_multiply.stderr
+++ b/src/tools/clippy/tests/ui/neg_multiply.stderr
@@ -8,43 +8,43 @@ LL |     x * -1;
    = help: to override `-D warnings` add `#[allow(clippy::neg_multiply)]`
 
 error: this multiplication by -1 can be written more succinctly
-  --> tests/ui/neg_multiply.rs:30:5
+  --> tests/ui/neg_multiply.rs:31:5
    |
 LL |     -1 * x;
    |     ^^^^^^ help: consider using: `-x`
 
 error: this multiplication by -1 can be written more succinctly
-  --> tests/ui/neg_multiply.rs:32:11
+  --> tests/ui/neg_multiply.rs:34:11
    |
 LL |     100 + x * -1;
    |           ^^^^^^ help: consider using: `-x`
 
 error: this multiplication by -1 can be written more succinctly
-  --> tests/ui/neg_multiply.rs:34:5
+  --> tests/ui/neg_multiply.rs:37:5
    |
 LL |     (100 + x) * -1;
    |     ^^^^^^^^^^^^^^ help: consider using: `-(100 + x)`
 
 error: this multiplication by -1 can be written more succinctly
-  --> tests/ui/neg_multiply.rs:36:5
+  --> tests/ui/neg_multiply.rs:40:5
    |
 LL |     -1 * 17;
    |     ^^^^^^^ help: consider using: `-17`
 
 error: this multiplication by -1 can be written more succinctly
-  --> tests/ui/neg_multiply.rs:38:14
+  --> tests/ui/neg_multiply.rs:43:14
    |
 LL |     0xcafe | 0xff00 * -1;
    |              ^^^^^^^^^^^ help: consider using: `-0xff00`
 
 error: this multiplication by -1 can be written more succinctly
-  --> tests/ui/neg_multiply.rs:40:5
+  --> tests/ui/neg_multiply.rs:46:5
    |
 LL |     3_usize as i32 * -1;
    |     ^^^^^^^^^^^^^^^^^^^ help: consider using: `-(3_usize as i32)`
 
 error: this multiplication by -1 can be written more succinctly
-  --> tests/ui/neg_multiply.rs:41:5
+  --> tests/ui/neg_multiply.rs:48:5
    |
 LL |     (3_usize as i32) * -1;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `-(3_usize as i32)`
diff --git a/src/tools/clippy/tests/ui/never_loop.rs b/src/tools/clippy/tests/ui/never_loop.rs
index 93c69209c698..2d8e04c192e4 100644
--- a/src/tools/clippy/tests/ui/never_loop.rs
+++ b/src/tools/clippy/tests/ui/never_loop.rs
@@ -10,8 +10,8 @@
 fn test1() {
     let mut x = 0;
     loop {
-        //~^ ERROR: this loop never actually loops
-        //~| NOTE: `#[deny(clippy::never_loop)]` on by default
+        //~^ never_loop
+
         // clippy::never_loop
         x += 1;
         if x == 1 {
@@ -34,7 +34,8 @@ fn test2() {
 fn test3() {
     let mut x = 0;
     loop {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         // never loops
         x += 1;
         break;
@@ -55,10 +56,12 @@ fn test4() {
 fn test5() {
     let i = 0;
     loop {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         // never loops
         while i == 0 {
-            //~^ ERROR: this loop never actually loops
+            //~^ never_loop
+
             // never loops
             break;
         }
@@ -71,7 +74,8 @@ fn test6() {
     'outer: loop {
         x += 1;
         loop {
-            //~^ ERROR: this loop never actually loops
+            //~^ never_loop
+
             // never loops
             if x == 5 {
                 break;
@@ -108,7 +112,8 @@ fn test8() {
 fn test9() {
     let x = Some(1);
     while let Some(y) = x {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         // never loops
         return;
     }
@@ -116,7 +121,8 @@ fn test9() {
 
 fn test10() {
     for x in 0..10 {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         // never loops
         match x {
             1 => break,
@@ -165,7 +171,8 @@ pub fn test13() {
 pub fn test14() {
     let mut a = true;
     'outer: while a {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         // never loops
         while a {
             if a {
@@ -181,7 +188,8 @@ pub fn test14() {
 pub fn test15() {
     'label: loop {
         while false {
-            //~^ ERROR: this loop never actually loops
+            //~^ never_loop
+
             break 'label;
         }
     }
@@ -233,7 +241,8 @@ pub fn test18() {
     };
     // never loops
     let _ = loop {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         let Some(x) = x else {
             return;
         };
@@ -255,12 +264,12 @@ pub fn test19() {
 
 pub fn test20() {
     'a: loop {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         'b: {
             break 'b 'c: {
                 break 'a;
-                //~^ ERROR: sub-expression diverges
-                //~| NOTE: `-D clippy::diverging-sub-expression` implied by `-D warnings`
+                //~^ diverging_sub_expression
             };
         }
     }
@@ -292,7 +301,8 @@ pub fn test23() {
     for _ in 0..10 {
         'block: {
             for _ in 0..20 {
-                //~^ ERROR: this loop never actually loops
+                //~^ never_loop
+
                 break 'block;
             }
         }
@@ -376,7 +386,8 @@ pub fn test31(b: bool) {
     'a: loop {
         'b: {
             'c: loop {
-                //~^ ERROR: this loop never actually loops
+                //~^ never_loop
+
                 if b { break 'c } else { break 'b }
             }
             continue 'a;
@@ -387,11 +398,13 @@ pub fn test31(b: bool) {
 
 pub fn test32() {
     loop {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         panic!("oh no");
     }
     loop {
-        //~^ ERROR: this loop never actually loops
+        //~^ never_loop
+
         unimplemented!("not yet");
     }
     loop {
diff --git a/src/tools/clippy/tests/ui/never_loop.stderr b/src/tools/clippy/tests/ui/never_loop.stderr
index 203e33258225..f6d6d109542b 100644
--- a/src/tools/clippy/tests/ui/never_loop.stderr
+++ b/src/tools/clippy/tests/ui/never_loop.stderr
@@ -13,64 +13,49 @@ error: this loop never actually loops
   --> tests/ui/never_loop.rs:36:5
    |
 LL | /     loop {
-LL | |
-LL | |         // never loops
-LL | |         x += 1;
+...  |
 LL | |         break;
 LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:57:5
+  --> tests/ui/never_loop.rs:58:5
    |
 LL | /     loop {
-LL | |
-LL | |         // never loops
-LL | |         while i == 0 {
 ...  |
 LL | |         return;
 LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:60:9
+  --> tests/ui/never_loop.rs:62:9
    |
 LL | /         while i == 0 {
-LL | |
-LL | |             // never loops
-LL | |             break;
+...  |
 LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:73:9
+  --> tests/ui/never_loop.rs:76:9
    |
 LL | /         loop {
-LL | |
-LL | |             // never loops
-LL | |             if x == 5 {
 ...  |
 LL | |             continue 'outer;
 LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:110:5
+  --> tests/ui/never_loop.rs:114:5
    |
 LL | /     while let Some(y) = x {
-LL | |
-LL | |         // never loops
-LL | |         return;
+...  |
 LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:118:5
+  --> tests/ui/never_loop.rs:123:5
    |
 LL | /     for x in 0..10 {
-LL | |
-LL | |         // never loops
-LL | |         match x {
 ...  |
 LL | |     }
    | |_____^
@@ -82,52 +67,50 @@ LL +     if let Some(x) = (0..10).next() {
    |
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:167:5
+  --> tests/ui/never_loop.rs:173:5
    |
 LL | /     'outer: while a {
-LL | |
-LL | |         // never loops
-LL | |         while a {
 ...  |
 LL | |         break 'outer;
 LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:183:9
+  --> tests/ui/never_loop.rs:190:9
    |
 LL | /         while false {
 LL | |
+LL | |
 LL | |             break 'label;
 LL | |         }
    | |_________^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:235:13
+  --> tests/ui/never_loop.rs:243:13
    |
 LL |       let _ = loop {
    |  _____________^
 LL | |
+LL | |
 LL | |         let Some(x) = x else {
-LL | |             return;
 ...  |
 LL | |         break x;
 LL | |     };
    | |_____^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:257:5
+  --> tests/ui/never_loop.rs:266:5
    |
 LL | /     'a: loop {
 LL | |
+LL | |
 LL | |         'b: {
-LL | |             break 'b 'c: {
 ...  |
 LL | |     }
    | |_____^
 
 error: sub-expression diverges
-  --> tests/ui/never_loop.rs:261:17
+  --> tests/ui/never_loop.rs:271:17
    |
 LL |                 break 'a;
    |                 ^^^^^^^^
@@ -136,10 +119,11 @@ LL |                 break 'a;
    = help: to override `-D warnings` add `#[allow(clippy::diverging_sub_expression)]`
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:294:13
+  --> tests/ui/never_loop.rs:303:13
    |
 LL | /             for _ in 0..20 {
 LL | |
+LL | |
 LL | |                 break 'block;
 LL | |             }
    | |_____________^
@@ -151,28 +135,31 @@ LL +             if let Some(_) = (0..20).next() {
    |
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:378:13
+  --> tests/ui/never_loop.rs:388:13
    |
 LL | /             'c: loop {
 LL | |
+LL | |
 LL | |                 if b { break 'c } else { break 'b }
 LL | |             }
    | |_____________^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:389:5
+  --> tests/ui/never_loop.rs:400:5
    |
 LL | /     loop {
 LL | |
+LL | |
 LL | |         panic!("oh no");
 LL | |     }
    | |_____^
 
 error: this loop never actually loops
-  --> tests/ui/never_loop.rs:393:5
+  --> tests/ui/never_loop.rs:405:5
    |
 LL | /     loop {
 LL | |
+LL | |
 LL | |         unimplemented!("not yet");
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/new_ret_no_self.rs b/src/tools/clippy/tests/ui/new_ret_no_self.rs
index 175b14d815a2..d61973f09b17 100644
--- a/src/tools/clippy/tests/ui/new_ret_no_self.rs
+++ b/src/tools/clippy/tests/ui/new_ret_no_self.rs
@@ -48,8 +48,8 @@ impl R for S3 {
 impl S3 {
     // should trigger the lint
     pub fn new(_: String) -> impl R<Item = u32> {
-        //~^ ERROR: methods called `new` usually return `Self`
-        //~| NOTE: `-D clippy::new-ret-no-self` implied by `-D warnings`
+        //~^ new_ret_no_self
+
         S3
     }
 }
@@ -82,7 +82,8 @@ struct U;
 impl U {
     // should trigger lint
     pub fn new() -> u32 {
-        //~^ ERROR: methods called `new` usually return `Self`
+        //~^ new_ret_no_self
+
         unimplemented!();
     }
 }
@@ -92,7 +93,8 @@ struct V;
 impl V {
     // should trigger lint
     pub fn new(_: String) -> u32 {
-        //~^ ERROR: methods called `new` usually return `Self`
+        //~^ new_ret_no_self
+
         unimplemented!();
     }
 }
@@ -129,7 +131,8 @@ struct TupleReturnerBad;
 impl TupleReturnerBad {
     // should trigger lint
     pub fn new() -> (u32, u32) {
-        //~^ ERROR: methods called `new` usually return `Self`
+        //~^ new_ret_no_self
+
         unimplemented!();
     }
 }
@@ -157,7 +160,8 @@ struct MutPointerReturnerBad;
 impl MutPointerReturnerBad {
     // should trigger lint
     pub fn new() -> *mut V {
-        //~^ ERROR: methods called `new` usually return `Self`
+        //~^ new_ret_no_self
+
         unimplemented!();
     }
 }
@@ -176,7 +180,8 @@ struct GenericReturnerBad;
 impl GenericReturnerBad {
     // should trigger lint
     pub fn new() -> Option<u32> {
-        //~^ ERROR: methods called `new` usually return `Self`
+        //~^ new_ret_no_self
+
         unimplemented!();
     }
 }
@@ -230,7 +235,7 @@ mod issue5435 {
     pub trait TraitRet {
         // should trigger lint as we are in trait definition
         fn new() -> String;
-        //~^ ERROR: methods called `new` usually return `Self`
+        //~^ new_ret_no_self
     }
     pub struct StructRet;
     impl TraitRet for StructRet {
@@ -243,7 +248,7 @@ mod issue5435 {
     pub trait TraitRet2 {
         // should trigger lint
         fn new(_: String) -> String;
-        //~^ ERROR: methods called `new` usually return `Self`
+        //~^ new_ret_no_self
     }
 
     trait TupleReturnerOk {
@@ -279,7 +284,8 @@ mod issue5435 {
     trait TupleReturnerBad {
         // should trigger lint
         fn new() -> (u32, u32) {
-            //~^ ERROR: methods called `new` usually return `Self`
+            //~^ new_ret_no_self
+
             unimplemented!();
         }
     }
@@ -307,7 +313,8 @@ mod issue5435 {
     trait MutPointerReturnerBad {
         // should trigger lint
         fn new() -> *mut V {
-            //~^ ERROR: methods called `new` usually return `Self`
+            //~^ new_ret_no_self
+
             unimplemented!();
         }
     }
@@ -378,7 +385,8 @@ mod issue7344 {
     impl<T> RetImplTraitNoSelf<T> {
         // should trigger lint
         fn new(t: T) -> impl Into<i32> {
-            //~^ ERROR: methods called `new` usually return `Self`
+            //~^ new_ret_no_self
+
             1
         }
     }
@@ -398,7 +406,7 @@ mod issue7344 {
     impl<T> RetImplTraitNoSelf2<T> {
         // should trigger lint
         fn new(t: T) -> impl Trait2<(), i32> {
-            //~^ ERROR: methods called `new` usually return `Self`
+            //~^ new_ret_no_self
         }
     }
 
diff --git a/src/tools/clippy/tests/ui/new_ret_no_self.stderr b/src/tools/clippy/tests/ui/new_ret_no_self.stderr
index 3597ad65838f..a758c746f918 100644
--- a/src/tools/clippy/tests/ui/new_ret_no_self.stderr
+++ b/src/tools/clippy/tests/ui/new_ret_no_self.stderr
@@ -16,87 +16,95 @@ error: methods called `new` usually return `Self`
    |
 LL | /     pub fn new() -> u32 {
 LL | |
+LL | |
 LL | |         unimplemented!();
 LL | |     }
    | |_____^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:94:5
+  --> tests/ui/new_ret_no_self.rs:95:5
    |
 LL | /     pub fn new(_: String) -> u32 {
 LL | |
+LL | |
 LL | |         unimplemented!();
 LL | |     }
    | |_____^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:131:5
+  --> tests/ui/new_ret_no_self.rs:133:5
    |
 LL | /     pub fn new() -> (u32, u32) {
 LL | |
+LL | |
 LL | |         unimplemented!();
 LL | |     }
    | |_____^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:159:5
+  --> tests/ui/new_ret_no_self.rs:162:5
    |
 LL | /     pub fn new() -> *mut V {
 LL | |
-LL | |         unimplemented!();
-LL | |     }
-   | |_____^
-
-error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:178:5
-   |
-LL | /     pub fn new() -> Option<u32> {
 LL | |
 LL | |         unimplemented!();
 LL | |     }
    | |_____^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:232:9
+  --> tests/ui/new_ret_no_self.rs:182:5
+   |
+LL | /     pub fn new() -> Option<u32> {
+LL | |
+LL | |
+LL | |         unimplemented!();
+LL | |     }
+   | |_____^
+
+error: methods called `new` usually return `Self`
+  --> tests/ui/new_ret_no_self.rs:237:9
    |
 LL |         fn new() -> String;
    |         ^^^^^^^^^^^^^^^^^^^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:245:9
+  --> tests/ui/new_ret_no_self.rs:250:9
    |
 LL |         fn new(_: String) -> String;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:281:9
+  --> tests/ui/new_ret_no_self.rs:286:9
    |
 LL | /         fn new() -> (u32, u32) {
 LL | |
-LL | |             unimplemented!();
-LL | |         }
-   | |_________^
-
-error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:309:9
-   |
-LL | /         fn new() -> *mut V {
 LL | |
 LL | |             unimplemented!();
 LL | |         }
    | |_________^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:380:9
+  --> tests/ui/new_ret_no_self.rs:315:9
+   |
+LL | /         fn new() -> *mut V {
+LL | |
+LL | |
+LL | |             unimplemented!();
+LL | |         }
+   | |_________^
+
+error: methods called `new` usually return `Self`
+  --> tests/ui/new_ret_no_self.rs:387:9
    |
 LL | /         fn new(t: T) -> impl Into<i32> {
 LL | |
+LL | |
 LL | |             1
 LL | |         }
    | |_________^
 
 error: methods called `new` usually return `Self`
-  --> tests/ui/new_ret_no_self.rs:400:9
+  --> tests/ui/new_ret_no_self.rs:408:9
    |
 LL | /         fn new(t: T) -> impl Trait2<(), i32> {
 LL | |
diff --git a/src/tools/clippy/tests/ui/new_ret_no_self_overflow.rs b/src/tools/clippy/tests/ui/new_ret_no_self_overflow.rs
index 7bc6fec10ba6..8a85c5662276 100644
--- a/src/tools/clippy/tests/ui/new_ret_no_self_overflow.rs
+++ b/src/tools/clippy/tests/ui/new_ret_no_self_overflow.rs
@@ -18,6 +18,7 @@ mod issue10041 {
 
     impl Bomb2 {
         pub fn new() -> X {
+            //~^ ERROR: overflow evaluating the requirement
             0i32
         }
     }
diff --git a/src/tools/clippy/tests/ui/new_without_default.fixed b/src/tools/clippy/tests/ui/new_without_default.fixed
index 5a6a92394a7f..277c335cd885 100644
--- a/src/tools/clippy/tests/ui/new_without_default.fixed
+++ b/src/tools/clippy/tests/ui/new_without_default.fixed
@@ -17,8 +17,8 @@ impl Default for Foo {
 
 impl Foo {
     pub fn new() -> Foo {
-        //~^ ERROR: you should consider adding a `Default` implementation for `Foo`
-        //~| NOTE: `-D clippy::new-without-default` implied by `-D warnings`
+        //~^ new_without_default
+
         Foo
     }
 }
@@ -33,7 +33,8 @@ impl Default for Bar {
 
 impl Bar {
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `Bar`
+        //~^ new_without_default
+
         Bar
     }
 }
@@ -104,7 +105,8 @@ impl<'c> Default for LtKo<'c> {
 
 impl<'c> LtKo<'c> {
     pub fn new() -> LtKo<'c> {
-        //~^ ERROR: you should consider adding a `Default` implementation for `LtKo<'c>`
+        //~^ new_without_default
+
         unimplemented!()
     }
 }
@@ -143,6 +145,7 @@ impl Default for Const {
 
 impl Const {
     pub const fn new() -> Const {
+        //~^ new_without_default
         Const
     } // While Default is not const, it can still call const functions, so we should lint this
 }
@@ -209,7 +212,8 @@ impl Default for NewNotEqualToDerive {
 impl NewNotEqualToDerive {
     // This `new` implementation is not equal to a derived `Default`, so do not suggest deriving.
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `NewNotEqualToDe
+        //~^ new_without_default
+
         NewNotEqualToDerive { foo: 1 }
     }
 }
@@ -224,7 +228,8 @@ impl<T> Default for FooGenerics<T> {
 
 impl<T> FooGenerics<T> {
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `FooGenerics<T>`
+        //~^ new_without_default
+
         Self(Default::default())
     }
 }
@@ -238,7 +243,8 @@ impl<T: Copy> Default for BarGenerics<T> {
 
 impl<T: Copy> BarGenerics<T> {
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `BarGenerics<T>`
+        //~^ new_without_default
+
         Self(Default::default())
     }
 }
@@ -256,7 +262,8 @@ pub mod issue7220 {
 
     impl<T> Foo<T> {
         pub fn new() -> Self {
-            //~^ ERROR: you should consider adding a `Default` implementation for `Foo<T>`
+            //~^ new_without_default
+
             todo!()
         }
     }
@@ -311,6 +318,7 @@ where
     K: std::hash::Hash + Eq + PartialEq,
 {
     pub fn new() -> Self {
+        //~^ new_without_default
         Self { _kv: None }
     }
 }
diff --git a/src/tools/clippy/tests/ui/new_without_default.rs b/src/tools/clippy/tests/ui/new_without_default.rs
index 12ea729253ac..f2844897c93d 100644
--- a/src/tools/clippy/tests/ui/new_without_default.rs
+++ b/src/tools/clippy/tests/ui/new_without_default.rs
@@ -11,8 +11,8 @@ pub struct Foo;
 
 impl Foo {
     pub fn new() -> Foo {
-        //~^ ERROR: you should consider adding a `Default` implementation for `Foo`
-        //~| NOTE: `-D clippy::new-without-default` implied by `-D warnings`
+        //~^ new_without_default
+
         Foo
     }
 }
@@ -21,7 +21,8 @@ pub struct Bar;
 
 impl Bar {
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `Bar`
+        //~^ new_without_default
+
         Bar
     }
 }
@@ -86,7 +87,8 @@ pub struct LtKo<'a> {
 
 impl<'c> LtKo<'c> {
     pub fn new() -> LtKo<'c> {
-        //~^ ERROR: you should consider adding a `Default` implementation for `LtKo<'c>`
+        //~^ new_without_default
+
         unimplemented!()
     }
 }
@@ -119,6 +121,7 @@ pub struct Const;
 
 impl Const {
     pub const fn new() -> Const {
+        //~^ new_without_default
         Const
     } // While Default is not const, it can still call const functions, so we should lint this
 }
@@ -179,7 +182,8 @@ pub struct NewNotEqualToDerive {
 impl NewNotEqualToDerive {
     // This `new` implementation is not equal to a derived `Default`, so do not suggest deriving.
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `NewNotEqualToDe
+        //~^ new_without_default
+
         NewNotEqualToDerive { foo: 1 }
     }
 }
@@ -188,7 +192,8 @@ impl NewNotEqualToDerive {
 pub struct FooGenerics<T>(std::marker::PhantomData<T>);
 impl<T> FooGenerics<T> {
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `FooGenerics<T>`
+        //~^ new_without_default
+
         Self(Default::default())
     }
 }
@@ -196,7 +201,8 @@ impl<T> FooGenerics<T> {
 pub struct BarGenerics<T>(std::marker::PhantomData<T>);
 impl<T: Copy> BarGenerics<T> {
     pub fn new() -> Self {
-        //~^ ERROR: you should consider adding a `Default` implementation for `BarGenerics<T>`
+        //~^ new_without_default
+
         Self(Default::default())
     }
 }
@@ -208,7 +214,8 @@ pub mod issue7220 {
 
     impl<T> Foo<T> {
         pub fn new() -> Self {
-            //~^ ERROR: you should consider adding a `Default` implementation for `Foo<T>`
+            //~^ new_without_default
+
             todo!()
         }
     }
@@ -254,6 +261,7 @@ where
     K: std::hash::Hash + Eq + PartialEq,
 {
     pub fn new() -> Self {
+        //~^ new_without_default
         Self { _kv: None }
     }
 }
diff --git a/src/tools/clippy/tests/ui/new_without_default.stderr b/src/tools/clippy/tests/ui/new_without_default.stderr
index 57bf4bd847cc..70a65aba464b 100644
--- a/src/tools/clippy/tests/ui/new_without_default.stderr
+++ b/src/tools/clippy/tests/ui/new_without_default.stderr
@@ -24,6 +24,7 @@ error: you should consider adding a `Default` implementation for `Bar`
    |
 LL | /     pub fn new() -> Self {
 LL | |
+LL | |
 LL | |         Bar
 LL | |     }
    | |_____^
@@ -38,10 +39,11 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `LtKo<'c>`
-  --> tests/ui/new_without_default.rs:88:5
+  --> tests/ui/new_without_default.rs:89:5
    |
 LL | /     pub fn new() -> LtKo<'c> {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -56,9 +58,10 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Const`
-  --> tests/ui/new_without_default.rs:121:5
+  --> tests/ui/new_without_default.rs:123:5
    |
 LL | /     pub const fn new() -> Const {
+LL | |
 LL | |         Const
 LL | |     } // While Default is not const, it can still call const functions, so we should lint this
    | |_____^
@@ -73,10 +76,11 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `NewNotEqualToDerive`
-  --> tests/ui/new_without_default.rs:181:5
+  --> tests/ui/new_without_default.rs:184:5
    |
 LL | /     pub fn new() -> Self {
 LL | |
+LL | |
 LL | |         NewNotEqualToDerive { foo: 1 }
 LL | |     }
    | |_____^
@@ -91,10 +95,11 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `FooGenerics<T>`
-  --> tests/ui/new_without_default.rs:190:5
+  --> tests/ui/new_without_default.rs:194:5
    |
 LL | /     pub fn new() -> Self {
 LL | |
+LL | |
 LL | |         Self(Default::default())
 LL | |     }
    | |_____^
@@ -109,10 +114,11 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `BarGenerics<T>`
-  --> tests/ui/new_without_default.rs:198:5
+  --> tests/ui/new_without_default.rs:203:5
    |
 LL | /     pub fn new() -> Self {
 LL | |
+LL | |
 LL | |         Self(Default::default())
 LL | |     }
    | |_____^
@@ -127,10 +133,11 @@ LL + }
    |
 
 error: you should consider adding a `Default` implementation for `Foo<T>`
-  --> tests/ui/new_without_default.rs:210:9
+  --> tests/ui/new_without_default.rs:216:9
    |
 LL | /         pub fn new() -> Self {
 LL | |
+LL | |
 LL | |             todo!()
 LL | |         }
    | |_________^
@@ -147,9 +154,10 @@ LL ~     impl<T> Foo<T> {
    |
 
 error: you should consider adding a `Default` implementation for `MyStruct<K, V>`
-  --> tests/ui/new_without_default.rs:256:5
+  --> tests/ui/new_without_default.rs:263:5
    |
 LL | /     pub fn new() -> Self {
+LL | |
 LL | |         Self { _kv: None }
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/no_effect.rs b/src/tools/clippy/tests/ui/no_effect.rs
index 0ea911c34348..703c2a3d9847 100644
--- a/src/tools/clippy/tests/ui/no_effect.rs
+++ b/src/tools/clippy/tests/ui/no_effect.rs
@@ -113,62 +113,88 @@ fn main() {
     let s = get_struct();
 
     0;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     Tuple(0);
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     Struct { field: 0 };
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     Struct { ..s };
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     Union { a: 0 };
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     Enum::Tuple(0);
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     Enum::Struct { field: 0 };
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     5 + 6;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     *&42;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     &6;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     (5, 6, 7);
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     ..;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     5..;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     ..5;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     5..6;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     5..=6;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     [42, 55];
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     [42, 55][1];
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     (42, 55).1;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     [42; 55];
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     [42; 55][13];
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     let mut x = 0;
     || x += 5;
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     let s: String = "foo".into();
     FooString { s: s };
-    //~^ ERROR: statement with no effect
+    //~^ no_effect
+
     let _unused = 1;
-    //~^ ERROR: binding to `_` prefixed variable with no side-effect
-    //~| NOTE: `-D clippy::no-effect-underscore-binding` implied by `-D warnings`
+    //~^ no_effect_underscore_binding
+
     let _penguin = || println!("Some helpful closure");
-    //~^ ERROR: binding to `_` prefixed variable with no side-effect
+    //~^ no_effect_underscore_binding
+
     let _duck = Struct { field: 0 };
-    //~^ ERROR: binding to `_` prefixed variable with no side-effect
+    //~^ no_effect_underscore_binding
+
     let _cat = [2, 4, 6, 8][2];
-    //~^ ERROR: binding to `_` prefixed variable with no side-effect
+    //~^ no_effect_underscore_binding
+
     let _issue_12166 = 42;
     let underscore_variable_above_can_be_used_dont_lint = _issue_12166;
 
diff --git a/src/tools/clippy/tests/ui/no_effect.stderr b/src/tools/clippy/tests/ui/no_effect.stderr
index 48ec997d938c..58a9380cbfde 100644
--- a/src/tools/clippy/tests/ui/no_effect.stderr
+++ b/src/tools/clippy/tests/ui/no_effect.stderr
@@ -8,139 +8,139 @@ LL |     0;
    = help: to override `-D warnings` add `#[allow(clippy::no_effect)]`
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:117:5
+  --> tests/ui/no_effect.rs:118:5
    |
 LL |     Tuple(0);
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:119:5
+  --> tests/ui/no_effect.rs:121:5
    |
 LL |     Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:121:5
+  --> tests/ui/no_effect.rs:124:5
    |
 LL |     Struct { ..s };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:123:5
+  --> tests/ui/no_effect.rs:127:5
    |
 LL |     Union { a: 0 };
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:125:5
+  --> tests/ui/no_effect.rs:130:5
    |
 LL |     Enum::Tuple(0);
    |     ^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:127:5
+  --> tests/ui/no_effect.rs:133:5
    |
 LL |     Enum::Struct { field: 0 };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:129:5
+  --> tests/ui/no_effect.rs:136:5
    |
 LL |     5 + 6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:131:5
+  --> tests/ui/no_effect.rs:139:5
    |
 LL |     *&42;
    |     ^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:133:5
+  --> tests/ui/no_effect.rs:142:5
    |
 LL |     &6;
    |     ^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:135:5
+  --> tests/ui/no_effect.rs:145:5
    |
 LL |     (5, 6, 7);
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:137:5
+  --> tests/ui/no_effect.rs:148:5
    |
 LL |     ..;
    |     ^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:139:5
+  --> tests/ui/no_effect.rs:151:5
    |
 LL |     5..;
    |     ^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:141:5
+  --> tests/ui/no_effect.rs:154:5
    |
 LL |     ..5;
    |     ^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:143:5
+  --> tests/ui/no_effect.rs:157:5
    |
 LL |     5..6;
    |     ^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:145:5
+  --> tests/ui/no_effect.rs:160:5
    |
 LL |     5..=6;
    |     ^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:147:5
+  --> tests/ui/no_effect.rs:163:5
    |
 LL |     [42, 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:149:5
+  --> tests/ui/no_effect.rs:166:5
    |
 LL |     [42, 55][1];
    |     ^^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:151:5
+  --> tests/ui/no_effect.rs:169:5
    |
 LL |     (42, 55).1;
    |     ^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:153:5
+  --> tests/ui/no_effect.rs:172:5
    |
 LL |     [42; 55];
    |     ^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:155:5
+  --> tests/ui/no_effect.rs:175:5
    |
 LL |     [42; 55][13];
    |     ^^^^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:158:5
+  --> tests/ui/no_effect.rs:179:5
    |
 LL |     || x += 5;
    |     ^^^^^^^^^^
 
 error: statement with no effect
-  --> tests/ui/no_effect.rs:161:5
+  --> tests/ui/no_effect.rs:183:5
    |
 LL |     FooString { s: s };
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> tests/ui/no_effect.rs:163:9
+  --> tests/ui/no_effect.rs:186:9
    |
 LL |     let _unused = 1;
    |         ^^^^^^^
@@ -149,19 +149,19 @@ LL |     let _unused = 1;
    = help: to override `-D warnings` add `#[allow(clippy::no_effect_underscore_binding)]`
 
 error: binding to `_` prefixed variable with no side-effect
-  --> tests/ui/no_effect.rs:166:9
+  --> tests/ui/no_effect.rs:189:9
    |
 LL |     let _penguin = || println!("Some helpful closure");
    |         ^^^^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> tests/ui/no_effect.rs:168:9
+  --> tests/ui/no_effect.rs:192:9
    |
 LL |     let _duck = Struct { field: 0 };
    |         ^^^^^
 
 error: binding to `_` prefixed variable with no side-effect
-  --> tests/ui/no_effect.rs:170:9
+  --> tests/ui/no_effect.rs:195:9
    |
 LL |     let _cat = [2, 4, 6, 8][2];
    |         ^^^^
diff --git a/src/tools/clippy/tests/ui/no_effect_async_fn.rs b/src/tools/clippy/tests/ui/no_effect_async_fn.rs
index ef0f3d1df1ac..a036a7e27bef 100644
--- a/src/tools/clippy/tests/ui/no_effect_async_fn.rs
+++ b/src/tools/clippy/tests/ui/no_effect_async_fn.rs
@@ -11,14 +11,14 @@ impl AsyncTrait for Bar {
     // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
     async fn bar(_i: u64) {
         let _a = 0;
-        //~^ ERROR: binding to `_` prefixed variable with no side-effect
+        //~^ no_effect_underscore_binding
 
         // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
         let _b = num();
 
         let _ = async {
             let _c = 0;
-            //~^ ERROR: binding to `_` prefixed variable with no side-effect
+            //~^ no_effect_underscore_binding
 
             // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
             let _d = num();
@@ -30,14 +30,14 @@ impl AsyncTrait for Bar {
 // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
 async fn foo(_i: u64) {
     let _a = 0;
-    //~^ ERROR: binding to `_` prefixed variable with no side-effect
+    //~^ no_effect_underscore_binding
 
     // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
     let _b = num();
 
     let _ = async {
         let _c = 0;
-        //~^ ERROR: binding to `_` prefixed variable with no side-effect
+        //~^ no_effect_underscore_binding
 
         // Shouldn't lint `binding to `_` prefixed variable with no side-effect`
         let _d = num();
diff --git a/src/tools/clippy/tests/ui/no_effect_replace.rs b/src/tools/clippy/tests/ui/no_effect_replace.rs
index e4fd5caae2a5..245898f50740 100644
--- a/src/tools/clippy/tests/ui/no_effect_replace.rs
+++ b/src/tools/clippy/tests/ui/no_effect_replace.rs
@@ -2,30 +2,35 @@
 
 fn main() {
     let _ = "12345".replace('1', "1");
-    //~^ ERROR: replacing text with itself
-    //~| NOTE: `-D clippy::no-effect-replace` implied by `-D warnings`
+    //~^ no_effect_replace
+
     let _ = "12345".replace("12", "12");
-    //~^ ERROR: replacing text with itself
+    //~^ no_effect_replace
+
     let _ = String::new().replace("12", "12");
-    //~^ ERROR: replacing text with itself
+    //~^ no_effect_replace
 
     let _ = "12345".replacen('1', "1", 1);
-    //~^ ERROR: replacing text with itself
+    //~^ no_effect_replace
+
     let _ = "12345".replacen("12", "12", 1);
-    //~^ ERROR: replacing text with itself
+    //~^ no_effect_replace
+
     let _ = String::new().replacen("12", "12", 1);
-    //~^ ERROR: replacing text with itself
+    //~^ no_effect_replace
 
     let _ = "12345".replace("12", "22");
     let _ = "12345".replacen("12", "22", 1);
 
     let mut x = X::default();
     let _ = "hello".replace(&x.f(), &x.f());
-    //~^ ERROR: replacing text with itself
+    //~^ no_effect_replace
+
     let _ = "hello".replace(&x.f(), &x.ff());
 
     let _ = "hello".replace(&y(), &y());
-    //~^ ERROR: replacing text with itself
+    //~^ no_effect_replace
+
     let _ = "hello".replace(&y(), &z());
 
     let _ = Replaceme.replace("a", "a");
diff --git a/src/tools/clippy/tests/ui/no_effect_replace.stderr b/src/tools/clippy/tests/ui/no_effect_replace.stderr
index ded86c5c5b8d..33d13b1d72e8 100644
--- a/src/tools/clippy/tests/ui/no_effect_replace.stderr
+++ b/src/tools/clippy/tests/ui/no_effect_replace.stderr
@@ -14,37 +14,37 @@ LL |     let _ = "12345".replace("12", "12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: replacing text with itself
-  --> tests/ui/no_effect_replace.rs:9:13
+  --> tests/ui/no_effect_replace.rs:10:13
    |
 LL |     let _ = String::new().replace("12", "12");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: replacing text with itself
-  --> tests/ui/no_effect_replace.rs:12:13
+  --> tests/ui/no_effect_replace.rs:13:13
    |
 LL |     let _ = "12345".replacen('1', "1", 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: replacing text with itself
-  --> tests/ui/no_effect_replace.rs:14:13
+  --> tests/ui/no_effect_replace.rs:16:13
    |
 LL |     let _ = "12345".replacen("12", "12", 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: replacing text with itself
-  --> tests/ui/no_effect_replace.rs:16:13
+  --> tests/ui/no_effect_replace.rs:19:13
    |
 LL |     let _ = String::new().replacen("12", "12", 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: replacing text with itself
-  --> tests/ui/no_effect_replace.rs:23:13
+  --> tests/ui/no_effect_replace.rs:26:13
    |
 LL |     let _ = "hello".replace(&x.f(), &x.f());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: replacing text with itself
-  --> tests/ui/no_effect_replace.rs:27:13
+  --> tests/ui/no_effect_replace.rs:31:13
    |
 LL |     let _ = "hello".replace(&y(), &y());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/no_effect_return.rs b/src/tools/clippy/tests/ui/no_effect_return.rs
index e46c0d73518b..4ba2fe07785d 100644
--- a/src/tools/clippy/tests/ui/no_effect_return.rs
+++ b/src/tools/clippy/tests/ui/no_effect_return.rs
@@ -7,8 +7,7 @@ use std::ops::ControlFlow;
 fn a() -> u32 {
     {
         0u32;
-        //~^ ERROR: statement with no effect
-        //~| NOTE: `-D clippy::no-effect` implied by `-D warnings`
+        //~^ no_effect
     }
     0
 }
@@ -16,7 +15,7 @@ fn a() -> u32 {
 async fn b() -> u32 {
     {
         0u32;
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
     }
     0
 }
@@ -25,7 +24,7 @@ type C = i32;
 async fn c() -> C {
     {
         0i32 as C;
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
     }
     0
 }
@@ -34,7 +33,8 @@ fn d() -> u128 {
     {
         // not last stmt
         0u128;
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
+
         println!("lol");
     }
     0
@@ -44,7 +44,7 @@ fn e() -> u32 {
     {
         // mismatched types
         0u16;
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
     }
     0
 }
@@ -52,7 +52,7 @@ fn e() -> u32 {
 fn f() -> [u16; 1] {
     {
         [1u16];
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
     }
     [1]
 }
@@ -60,7 +60,7 @@ fn f() -> [u16; 1] {
 fn g() -> ControlFlow<()> {
     {
         ControlFlow::Break::<()>(());
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
     }
     ControlFlow::Continue(())
 }
@@ -78,7 +78,7 @@ fn i() -> () {
     {
         // does not suggest on function with explicit unit return type
         ();
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
     }
     ()
 }
@@ -87,7 +87,7 @@ fn j() {
     {
         // does not suggest on function without explicit return type
         ();
-        //~^ ERROR: statement with no effect
+        //~^ no_effect
     }
     ()
 }
diff --git a/src/tools/clippy/tests/ui/no_effect_return.stderr b/src/tools/clippy/tests/ui/no_effect_return.stderr
index 3cfe375d034a..e7bf7e4cd4f4 100644
--- a/src/tools/clippy/tests/ui/no_effect_return.stderr
+++ b/src/tools/clippy/tests/ui/no_effect_return.stderr
@@ -10,7 +10,7 @@ LL |         0u32;
    = help: to override `-D warnings` add `#[allow(clippy::no_effect)]`
 
 error: statement with no effect
-  --> tests/ui/no_effect_return.rs:18:9
+  --> tests/ui/no_effect_return.rs:17:9
    |
 LL |         0u32;
    |         -^^^^
@@ -18,7 +18,7 @@ LL |         0u32;
    |         help: did you mean to return it?: `return`
 
 error: statement with no effect
-  --> tests/ui/no_effect_return.rs:27:9
+  --> tests/ui/no_effect_return.rs:26:9
    |
 LL |         0i32 as C;
    |         -^^^^^^^^^
@@ -26,7 +26,7 @@ LL |         0i32 as C;
    |         help: did you mean to return it?: `return`
 
 error: statement with no effect
-  --> tests/ui/no_effect_return.rs:36:9
+  --> tests/ui/no_effect_return.rs:35:9
    |
 LL |         0u128;
    |         ^^^^^^
diff --git a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.rs b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.rs
index 8be149d18637..0d09b3ceecde 100644
--- a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.rs
+++ b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.rs
@@ -4,28 +4,27 @@
 
 #[unsafe(no_mangle)]
 fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
-//~| NOTE: `-D clippy::no-mangle-with-rust-abi` implied by `-D warnings`
+//~^ no_mangle_with_rust_abi
 
 #[unsafe(no_mangle)]
 pub fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
+//~^ no_mangle_with_rust_abi
 
 /// # Safety
 /// This function shouldn't be called unless the horsemen are ready
 #[unsafe(no_mangle)]
 pub unsafe fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
+//~^ no_mangle_with_rust_abi
 
 /// # Safety
 /// This function shouldn't be called unless the horsemen are ready
 #[unsafe(no_mangle)]
 unsafe fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
+//~^ no_mangle_with_rust_abi
 
 #[unsafe(no_mangle)]
 fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
-    //~^ ERROR: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
+    //~^ no_mangle_with_rust_abi
     arg_one: u32,
     arg_two: usize,
 ) -> u32 {
@@ -51,6 +50,7 @@ extern "C" {
 mod r#fn {
     #[unsafe(no_mangle)]
     pub(in super::r#fn) fn with_some_fn_around() {}
+    //~^ no_mangle_with_rust_abi
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.stderr b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.stderr
index a00ebe5e1ac7..871f38e94b63 100644
--- a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.stderr
+++ b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi.stderr
@@ -16,7 +16,7 @@ LL | extern "Rust" fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
    | +++++++++++++
 
 error: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi.rs:11:1
+  --> tests/ui/no_mangle_with_rust_abi.rs:10:1
    |
 LL | pub fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -31,7 +31,7 @@ LL | pub extern "Rust" fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
    |     +++++++++++++
 
 error: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi.rs:17:1
+  --> tests/ui/no_mangle_with_rust_abi.rs:16:1
    |
 LL | pub unsafe fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,7 +46,7 @@ LL | pub unsafe extern "Rust" fn rust_abi_fn_three(arg_one: u32, arg_two: usize)
    |            +++++++++++++
 
 error: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi.rs:23:1
+  --> tests/ui/no_mangle_with_rust_abi.rs:22:1
    |
 LL | unsafe fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL | unsafe extern "Rust" fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
    |        +++++++++++++
 
 error: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi.rs:27:1
+  --> tests/ui/no_mangle_with_rust_abi.rs:26:1
    |
 LL | / fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
 LL | |
@@ -80,7 +80,7 @@ LL | extern "Rust" fn rust_abi_multiline_function_really_long_name_to_overflow_a
    | +++++++++++++
 
 error: `#[unsafe(no_mangle)]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi.rs:53:5
+  --> tests/ui/no_mangle_with_rust_abi.rs:52:5
    |
 LL |     pub(in super::r#fn) fn with_some_fn_around() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.rs b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.rs
index c7c973353480..3d5c70cad2f3 100644
--- a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.rs
+++ b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.rs
@@ -8,28 +8,27 @@
 
 #[no_mangle]
 fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[no_mangle]` set on a function with the default (`Rust`) ABI
-//~| NOTE: `-D clippy::no-mangle-with-rust-abi` implied by `-D warnings`
+//~^ no_mangle_with_rust_abi
 
 #[no_mangle]
 pub fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+//~^ no_mangle_with_rust_abi
 
 /// # Safety
 /// This function shouldn't be called unless the horsemen are ready
 #[no_mangle]
 pub unsafe fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+//~^ no_mangle_with_rust_abi
 
 /// # Safety
 /// This function shouldn't be called unless the horsemen are ready
 #[no_mangle]
 unsafe fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
-//~^ ERROR: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+//~^ no_mangle_with_rust_abi
 
 #[no_mangle]
 fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
-    //~^ ERROR: `#[no_mangle]` set on a function with the default (`Rust`) ABI
+    //~^ no_mangle_with_rust_abi
     arg_one: u32,
     arg_two: usize,
 ) -> u32 {
diff --git a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.stderr b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.stderr
index 15075be72d0b..abae8fafbeee 100644
--- a/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.stderr
+++ b/src/tools/clippy/tests/ui/no_mangle_with_rust_abi_2021.stderr
@@ -16,7 +16,7 @@ LL | extern "Rust" fn rust_abi_fn_one(arg_one: u32, arg_two: usize) {}
    | +++++++++++++
 
 error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi_2021.rs:15:1
+  --> tests/ui/no_mangle_with_rust_abi_2021.rs:14:1
    |
 LL | pub fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -31,7 +31,7 @@ LL | pub extern "Rust" fn rust_abi_fn_two(arg_one: u32, arg_two: usize) {}
    |     +++++++++++++
 
 error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi_2021.rs:21:1
+  --> tests/ui/no_mangle_with_rust_abi_2021.rs:20:1
    |
 LL | pub unsafe fn rust_abi_fn_three(arg_one: u32, arg_two: usize) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,7 +46,7 @@ LL | pub unsafe extern "Rust" fn rust_abi_fn_three(arg_one: u32, arg_two: usize)
    |            +++++++++++++
 
 error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi_2021.rs:27:1
+  --> tests/ui/no_mangle_with_rust_abi_2021.rs:26:1
    |
 LL | unsafe fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL | unsafe extern "Rust" fn rust_abi_fn_four(arg_one: u32, arg_two: usize) {}
    |        +++++++++++++
 
 error: `#[no_mangle]` set on a function with the default (`Rust`) ABI
-  --> tests/ui/no_mangle_with_rust_abi_2021.rs:31:1
+  --> tests/ui/no_mangle_with_rust_abi_2021.rs:30:1
    |
 LL | / fn rust_abi_multiline_function_really_long_name_to_overflow_args_to_multiple_lines(
 LL | |
diff --git a/src/tools/clippy/tests/ui/non_canonical_clone_impl.rs b/src/tools/clippy/tests/ui/non_canonical_clone_impl.rs
index a36c7ed44c24..7d101915517f 100644
--- a/src/tools/clippy/tests/ui/non_canonical_clone_impl.rs
+++ b/src/tools/clippy/tests/ui/non_canonical_clone_impl.rs
@@ -12,10 +12,12 @@ struct A(u32);
 
 impl Clone for A {
     fn clone(&self) -> Self {
+        //~^ non_canonical_clone_impl
         Self(self.0)
     }
 
     fn clone_from(&mut self, source: &Self) {
+        //~^ non_canonical_clone_impl
         source.clone();
         *self = source.clone();
     }
@@ -83,10 +85,12 @@ struct F(u32);
 
 impl Clone for F {
     fn clone(&self) -> Self {
+        //~^ non_canonical_clone_impl
         Self(self.0)
     }
 
     fn clone_from(&mut self, source: &Self) {
+        //~^ non_canonical_clone_impl
         source.clone();
         *self = source.clone();
     }
diff --git a/src/tools/clippy/tests/ui/non_canonical_clone_impl.stderr b/src/tools/clippy/tests/ui/non_canonical_clone_impl.stderr
index f7cad58150f7..550098452717 100644
--- a/src/tools/clippy/tests/ui/non_canonical_clone_impl.stderr
+++ b/src/tools/clippy/tests/ui/non_canonical_clone_impl.stderr
@@ -3,6 +3,7 @@ error: non-canonical implementation of `clone` on a `Copy` type
    |
 LL |       fn clone(&self) -> Self {
    |  _____________________________^
+LL | |
 LL | |         Self(self.0)
 LL | |     }
    | |_____^ help: change this to: `{ *self }`
@@ -11,27 +12,30 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::non_canonical_clone_impl)]`
 
 error: unnecessary implementation of `clone_from` on a `Copy` type
-  --> tests/ui/non_canonical_clone_impl.rs:18:5
+  --> tests/ui/non_canonical_clone_impl.rs:19:5
    |
 LL | /     fn clone_from(&mut self, source: &Self) {
+LL | |
 LL | |         source.clone();
 LL | |         *self = source.clone();
 LL | |     }
    | |_____^ help: remove it
 
 error: non-canonical implementation of `clone` on a `Copy` type
-  --> tests/ui/non_canonical_clone_impl.rs:85:29
+  --> tests/ui/non_canonical_clone_impl.rs:87:29
    |
 LL |       fn clone(&self) -> Self {
    |  _____________________________^
+LL | |
 LL | |         Self(self.0)
 LL | |     }
    | |_____^ help: change this to: `{ *self }`
 
 error: unnecessary implementation of `clone_from` on a `Copy` type
-  --> tests/ui/non_canonical_clone_impl.rs:89:5
+  --> tests/ui/non_canonical_clone_impl.rs:92:5
    |
 LL | /     fn clone_from(&mut self, source: &Self) {
+LL | |
 LL | |         source.clone();
 LL | |         *self = source.clone();
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.fixed b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.fixed
index d444a753697f..8774c666db11 100644
--- a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.fixed
+++ b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.fixed
@@ -14,6 +14,7 @@ impl Ord for A {
 }
 
 impl PartialOrd for A {
+    //~^ non_canonical_partial_ord_impl
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
 }
 
@@ -46,6 +47,7 @@ impl Ord for C {
 }
 
 impl PartialOrd for C {
+    //~^ non_canonical_partial_ord_impl
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> { Some(self.cmp(other)) }
 }
 
diff --git a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.rs b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.rs
index dc6c4354604d..568b97c8fff7 100644
--- a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.rs
+++ b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.rs
@@ -14,6 +14,7 @@ impl Ord for A {
 }
 
 impl PartialOrd for A {
+    //~^ non_canonical_partial_ord_impl
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         todo!();
     }
@@ -48,6 +49,7 @@ impl Ord for C {
 }
 
 impl PartialOrd for C {
+    //~^ non_canonical_partial_ord_impl
     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
         todo!();
     }
diff --git a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.stderr b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.stderr
index 9f0c2ec43015..86845df4ea90 100644
--- a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.stderr
+++ b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl.stderr
@@ -2,6 +2,7 @@ error: non-canonical implementation of `partial_cmp` on an `Ord` type
   --> tests/ui/non_canonical_partial_ord_impl.rs:16:1
    |
 LL | /  impl PartialOrd for A {
+LL | |
 LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    | | _____________________________________________________________-
 LL | ||         todo!();
@@ -14,9 +15,10 @@ LL | |  }
    = help: to override `-D warnings` add `#[allow(clippy::non_canonical_partial_ord_impl)]`
 
 error: non-canonical implementation of `partial_cmp` on an `Ord` type
-  --> tests/ui/non_canonical_partial_ord_impl.rs:50:1
+  --> tests/ui/non_canonical_partial_ord_impl.rs:51:1
    |
 LL | / impl PartialOrd for C {
+LL | |
 LL | |     fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
 LL | |         todo!();
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.rs b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.rs
index 2f8d5cf30c77..99cd7ebac60c 100644
--- a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.rs
+++ b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.rs
@@ -21,6 +21,7 @@ impl cmp::Ord for A {
 }
 
 impl PartialOrd for A {
+    //~^ non_canonical_partial_ord_impl
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
         // automatically applied
@@ -44,6 +45,7 @@ impl cmp::Ord for B {
 }
 
 impl PartialOrd for B {
+    //~^ non_canonical_partial_ord_impl
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
         // This calls `B.cmp`, not `Ord::cmp`!
         Some(self.cmp(other))
diff --git a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr
index 8dd7face6ef4..392b81dc8d74 100644
--- a/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr
+++ b/src/tools/clippy/tests/ui/non_canonical_partial_ord_impl_fully_qual.stderr
@@ -2,6 +2,7 @@ error: non-canonical implementation of `partial_cmp` on an `Ord` type
   --> tests/ui/non_canonical_partial_ord_impl_fully_qual.rs:23:1
    |
 LL | /  impl PartialOrd for A {
+LL | |
 LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    | | _____________________________________________________________-
 LL | ||         // NOTE: This suggestion is wrong, as `Ord` is not in scope. But this should be fine as it isn't
@@ -16,9 +17,10 @@ LL | |  }
    = help: to override `-D warnings` add `#[allow(clippy::non_canonical_partial_ord_impl)]`
 
 error: non-canonical implementation of `partial_cmp` on an `Ord` type
-  --> tests/ui/non_canonical_partial_ord_impl_fully_qual.rs:46:1
+  --> tests/ui/non_canonical_partial_ord_impl_fully_qual.rs:47:1
    |
 LL | /  impl PartialOrd for B {
+LL | |
 LL | |      fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
    | | _____________________________________________________________-
 LL | ||         // This calls `B.cmp`, not `Ord::cmp`!
diff --git a/src/tools/clippy/tests/ui/non_expressive_names.rs b/src/tools/clippy/tests/ui/non_expressive_names.rs
index 987a4775ef07..b772c754f8b7 100644
--- a/src/tools/clippy/tests/ui/non_expressive_names.rs
+++ b/src/tools/clippy/tests/ui/non_expressive_names.rs
@@ -25,9 +25,12 @@ impl MaybeInst {
 }
 
 fn underscores_and_numbers() {
-    let _1 = 1; //~ERROR: consider choosing a more descriptive name
-    let ____1 = 1; //~ERROR: consider choosing a more descriptive name
-    let __1___2 = 12; //~ERROR: consider choosing a more descriptive name
+    let _1 = 1;
+    //~^ just_underscores_and_digits
+    let ____1 = 1;
+    //~^ just_underscores_and_digits
+    let __1___2 = 12;
+    //~^ just_underscores_and_digits
     let _1_ok = 1;
 }
 
@@ -48,9 +51,12 @@ struct Bar;
 
 impl Bar {
     fn bar() {
-        let _1 = 1; //~ERROR: consider choosing a more descriptive name
-        let ____1 = 1; //~ERROR: consider choosing a more descriptive name
-        let __1___2 = 12; //~ERROR: consider choosing a more descriptive name
+        let _1 = 1;
+        //~^ just_underscores_and_digits
+        let ____1 = 1;
+        //~^ just_underscores_and_digits
+        let __1___2 = 12;
+        //~^ just_underscores_and_digits
         let _1_ok = 1;
     }
 }
diff --git a/src/tools/clippy/tests/ui/non_expressive_names.stderr b/src/tools/clippy/tests/ui/non_expressive_names.stderr
index d9c745f466b7..3bd77a730fe7 100644
--- a/src/tools/clippy/tests/ui/non_expressive_names.stderr
+++ b/src/tools/clippy/tests/ui/non_expressive_names.stderr
@@ -8,31 +8,31 @@ LL |     let _1 = 1;
    = help: to override `-D warnings` add `#[allow(clippy::just_underscores_and_digits)]`
 
 error: consider choosing a more descriptive name
-  --> tests/ui/non_expressive_names.rs:29:9
+  --> tests/ui/non_expressive_names.rs:30:9
    |
 LL |     let ____1 = 1;
    |         ^^^^^
 
 error: consider choosing a more descriptive name
-  --> tests/ui/non_expressive_names.rs:30:9
+  --> tests/ui/non_expressive_names.rs:32:9
    |
 LL |     let __1___2 = 12;
    |         ^^^^^^^
 
 error: consider choosing a more descriptive name
-  --> tests/ui/non_expressive_names.rs:51:13
+  --> tests/ui/non_expressive_names.rs:54:13
    |
 LL |         let _1 = 1;
    |             ^^
 
 error: consider choosing a more descriptive name
-  --> tests/ui/non_expressive_names.rs:52:13
+  --> tests/ui/non_expressive_names.rs:56:13
    |
 LL |         let ____1 = 1;
    |             ^^^^^
 
 error: consider choosing a more descriptive name
-  --> tests/ui/non_expressive_names.rs:53:13
+  --> tests/ui/non_expressive_names.rs:58:13
    |
 LL |         let __1___2 = 12;
    |             ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/non_minimal_cfg.fixed b/src/tools/clippy/tests/ui/non_minimal_cfg.fixed
index 2fcecab452b8..a2b69d0662ee 100644
--- a/src/tools/clippy/tests/ui/non_minimal_cfg.fixed
+++ b/src/tools/clippy/tests/ui/non_minimal_cfg.fixed
@@ -1,12 +1,16 @@
 #![allow(unused)]
 
 #[cfg(windows)]
+//~^ non_minimal_cfg
 fn hermit() {}
 
 #[cfg(windows)]
+//~^ non_minimal_cfg
 fn wasi() {}
 
 #[cfg(all(unix, not(windows)))]
+//~^ non_minimal_cfg
+//~| non_minimal_cfg
 fn the_end() {}
 
 #[cfg(any())]
diff --git a/src/tools/clippy/tests/ui/non_minimal_cfg.rs b/src/tools/clippy/tests/ui/non_minimal_cfg.rs
index e3ce11b73336..7178cd189c08 100644
--- a/src/tools/clippy/tests/ui/non_minimal_cfg.rs
+++ b/src/tools/clippy/tests/ui/non_minimal_cfg.rs
@@ -1,12 +1,16 @@
 #![allow(unused)]
 
 #[cfg(all(windows))]
+//~^ non_minimal_cfg
 fn hermit() {}
 
 #[cfg(any(windows))]
+//~^ non_minimal_cfg
 fn wasi() {}
 
 #[cfg(all(any(unix), all(not(windows))))]
+//~^ non_minimal_cfg
+//~| non_minimal_cfg
 fn the_end() {}
 
 #[cfg(any())]
diff --git a/src/tools/clippy/tests/ui/non_minimal_cfg.stderr b/src/tools/clippy/tests/ui/non_minimal_cfg.stderr
index 707ff51d430c..3bf306dd89c2 100644
--- a/src/tools/clippy/tests/ui/non_minimal_cfg.stderr
+++ b/src/tools/clippy/tests/ui/non_minimal_cfg.stderr
@@ -8,19 +8,19 @@ LL | #[cfg(all(windows))]
    = help: to override `-D warnings` add `#[allow(clippy::non_minimal_cfg)]`
 
 error: unneeded sub `cfg` when there is only one condition
-  --> tests/ui/non_minimal_cfg.rs:6:7
+  --> tests/ui/non_minimal_cfg.rs:7:7
    |
 LL | #[cfg(any(windows))]
    |       ^^^^^^^^^^^^ help: try: `windows`
 
 error: unneeded sub `cfg` when there is only one condition
-  --> tests/ui/non_minimal_cfg.rs:9:11
+  --> tests/ui/non_minimal_cfg.rs:11:11
    |
 LL | #[cfg(all(any(unix), all(not(windows))))]
    |           ^^^^^^^^^ help: try: `unix`
 
 error: unneeded sub `cfg` when there is only one condition
-  --> tests/ui/non_minimal_cfg.rs:9:22
+  --> tests/ui/non_minimal_cfg.rs:11:22
    |
 LL | #[cfg(all(any(unix), all(not(windows))))]
    |                      ^^^^^^^^^^^^^^^^^ help: try: `not(windows)`
diff --git a/src/tools/clippy/tests/ui/non_minimal_cfg2.rs b/src/tools/clippy/tests/ui/non_minimal_cfg2.rs
index f9e3ba4dacda..d073feedb1da 100644
--- a/src/tools/clippy/tests/ui/non_minimal_cfg2.rs
+++ b/src/tools/clippy/tests/ui/non_minimal_cfg2.rs
@@ -1,3 +1,4 @@
+//@require-annotations-for-level: WARN
 #![allow(unused)]
 
 #[cfg(all())]
diff --git a/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr b/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr
index 6d86e931edce..169d2989aa13 100644
--- a/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr
+++ b/src/tools/clippy/tests/ui/non_minimal_cfg2.stderr
@@ -1,5 +1,5 @@
 error: unneeded sub `cfg` when there is no condition
-  --> tests/ui/non_minimal_cfg2.rs:3:7
+  --> tests/ui/non_minimal_cfg2.rs:4:7
    |
 LL | #[cfg(all())]
    |       ^^^^^
diff --git a/src/tools/clippy/tests/ui/non_octal_unix_permissions.fixed b/src/tools/clippy/tests/ui/non_octal_unix_permissions.fixed
index f68d5e30d27e..83f8991c94f8 100644
--- a/src/tools/clippy/tests/ui/non_octal_unix_permissions.fixed
+++ b/src/tools/clippy/tests/ui/non_octal_unix_permissions.fixed
@@ -10,11 +10,13 @@ fn main() {
     // OpenOptionsExt::mode
     let mut options = OpenOptions::new();
     options.mode(0o440);
+    //~^ non_octal_unix_permissions
     options.mode(0o400);
     options.mode(permissions);
 
     // PermissionsExt::from_mode
     let _permissions = Permissions::from_mode(0o647);
+    //~^ non_octal_unix_permissions
     let _permissions = Permissions::from_mode(0o000);
     let _permissions = Permissions::from_mode(permissions);
 
@@ -24,6 +26,7 @@ fn main() {
     let mut permissions = metadata.permissions();
 
     permissions.set_mode(0o644);
+    //~^ non_octal_unix_permissions
     permissions.set_mode(0o704);
     // no error
     permissions.set_mode(0b111_000_100);
@@ -31,6 +34,7 @@ fn main() {
     // DirBuilderExt::mode
     let mut builder = DirBuilder::new();
     builder.mode(0o755);
+    //~^ non_octal_unix_permissions
     builder.mode(0o406);
     // no error
     permissions.set_mode(0b111000100);
diff --git a/src/tools/clippy/tests/ui/non_octal_unix_permissions.rs b/src/tools/clippy/tests/ui/non_octal_unix_permissions.rs
index 647c3769d2c3..ba1ee10a2787 100644
--- a/src/tools/clippy/tests/ui/non_octal_unix_permissions.rs
+++ b/src/tools/clippy/tests/ui/non_octal_unix_permissions.rs
@@ -10,11 +10,13 @@ fn main() {
     // OpenOptionsExt::mode
     let mut options = OpenOptions::new();
     options.mode(440);
+    //~^ non_octal_unix_permissions
     options.mode(0o400);
     options.mode(permissions);
 
     // PermissionsExt::from_mode
     let _permissions = Permissions::from_mode(647);
+    //~^ non_octal_unix_permissions
     let _permissions = Permissions::from_mode(0o000);
     let _permissions = Permissions::from_mode(permissions);
 
@@ -24,6 +26,7 @@ fn main() {
     let mut permissions = metadata.permissions();
 
     permissions.set_mode(644);
+    //~^ non_octal_unix_permissions
     permissions.set_mode(0o704);
     // no error
     permissions.set_mode(0b111_000_100);
@@ -31,6 +34,7 @@ fn main() {
     // DirBuilderExt::mode
     let mut builder = DirBuilder::new();
     builder.mode(755);
+    //~^ non_octal_unix_permissions
     builder.mode(0o406);
     // no error
     permissions.set_mode(0b111000100);
diff --git a/src/tools/clippy/tests/ui/non_octal_unix_permissions.stderr b/src/tools/clippy/tests/ui/non_octal_unix_permissions.stderr
index 890b308a1dc5..9027617c813a 100644
--- a/src/tools/clippy/tests/ui/non_octal_unix_permissions.stderr
+++ b/src/tools/clippy/tests/ui/non_octal_unix_permissions.stderr
@@ -8,19 +8,19 @@ LL |     options.mode(440);
    = help: to override `-D warnings` add `#[allow(clippy::non_octal_unix_permissions)]`
 
 error: using a non-octal value to set unix file permissions
-  --> tests/ui/non_octal_unix_permissions.rs:17:47
+  --> tests/ui/non_octal_unix_permissions.rs:18:47
    |
 LL |     let _permissions = Permissions::from_mode(647);
    |                                               ^^^ help: consider using an octal literal instead: `0o647`
 
 error: using a non-octal value to set unix file permissions
-  --> tests/ui/non_octal_unix_permissions.rs:26:26
+  --> tests/ui/non_octal_unix_permissions.rs:28:26
    |
 LL |     permissions.set_mode(644);
    |                          ^^^ help: consider using an octal literal instead: `0o644`
 
 error: using a non-octal value to set unix file permissions
-  --> tests/ui/non_octal_unix_permissions.rs:33:18
+  --> tests/ui/non_octal_unix_permissions.rs:36:18
    |
 LL |     builder.mode(755);
    |                  ^^^ help: consider using an octal literal instead: `0o755`
diff --git a/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_no_std.rs b/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_no_std.rs
index 6208612c6983..1170696b2030 100644
--- a/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_no_std.rs
+++ b/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_no_std.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build:once_cell.rs
 //@aux-build:lazy_static.rs
 
diff --git a/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_other_once_cell.rs b/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_other_once_cell.rs
index 8701a4b7729a..f6d4f7250915 100644
--- a/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_other_once_cell.rs
+++ b/src/tools/clippy/tests/ui/non_std_lazy_static/non_std_lazy_static_other_once_cell.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 //@aux-build:once_cell.rs
 
 #![warn(clippy::non_std_lazy_statics)]
diff --git a/src/tools/clippy/tests/ui/non_zero_suggestions.fixed b/src/tools/clippy/tests/ui/non_zero_suggestions.fixed
index e67c992fdde0..4573896ecd67 100644
--- a/src/tools/clippy/tests/ui/non_zero_suggestions.fixed
+++ b/src/tools/clippy/tests/ui/non_zero_suggestions.fixed
@@ -7,19 +7,19 @@ fn main() {
     let x: u64 = 100;
     let y = NonZeroU32::new(10).unwrap();
     let r1 = x / NonZeroU64::from(y);
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     let r2 = x % NonZeroU64::from(y);
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     // U16 -> U32
     let a: u32 = 50;
     let b = NonZeroU16::new(5).unwrap();
     let r3 = a / NonZeroU32::from(b);
-    //~^ ERROR: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     let x = NonZeroU64::from(NonZeroU32::new(5).unwrap());
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     /// Negative test cases (lint should not trigger)
     // Left hand side expressions should not be triggered
@@ -50,7 +50,7 @@ fn main() {
 // Additional function to test the lint in a different context
 fn divide_numbers(x: u64, y: NonZeroU32) -> u64 {
     x / NonZeroU64::from(y)
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 }
 
 struct Calculator {
@@ -60,6 +60,6 @@ struct Calculator {
 impl Calculator {
     fn divide(&self, divisor: NonZeroU32) -> u64 {
         self.value / NonZeroU64::from(divisor)
-        //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+        //~^ non_zero_suggestions
     }
 }
diff --git a/src/tools/clippy/tests/ui/non_zero_suggestions.rs b/src/tools/clippy/tests/ui/non_zero_suggestions.rs
index de82371a8f29..3e7081e0c1c0 100644
--- a/src/tools/clippy/tests/ui/non_zero_suggestions.rs
+++ b/src/tools/clippy/tests/ui/non_zero_suggestions.rs
@@ -7,19 +7,19 @@ fn main() {
     let x: u64 = 100;
     let y = NonZeroU32::new(10).unwrap();
     let r1 = x / u64::from(y.get());
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     let r2 = x % u64::from(y.get());
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     // U16 -> U32
     let a: u32 = 50;
     let b = NonZeroU16::new(5).unwrap();
     let r3 = a / u32::from(b.get());
-    //~^ ERROR: consider using `NonZeroU32::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     let x = u64::from(NonZeroU32::new(5).unwrap().get());
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     /// Negative test cases (lint should not trigger)
     // Left hand side expressions should not be triggered
@@ -50,7 +50,7 @@ fn main() {
 // Additional function to test the lint in a different context
 fn divide_numbers(x: u64, y: NonZeroU32) -> u64 {
     x / u64::from(y.get())
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 }
 
 struct Calculator {
@@ -60,6 +60,6 @@ struct Calculator {
 impl Calculator {
     fn divide(&self, divisor: NonZeroU32) -> u64 {
         self.value / u64::from(divisor.get())
-        //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+        //~^ non_zero_suggestions
     }
 }
diff --git a/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.rs b/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.rs
index 193c710e589f..1224356236c7 100644
--- a/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.rs
+++ b/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.rs
@@ -4,11 +4,12 @@ use std::num::{NonZeroI8, NonZeroI16, NonZeroU8, NonZeroU16, NonZeroU32, NonZero
 
 fn main() {
     let x: u64 = u64::from(NonZeroU32::new(5).unwrap().get());
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 
     let n = NonZeroU32::new(20).unwrap();
     let y = u64::from(n.get());
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
+
     some_fn_that_only_takes_u64(y);
 
     let m = NonZeroU32::try_from(1).unwrap();
@@ -17,7 +18,7 @@ fn main() {
 
 fn return_non_zero(x: u64, y: NonZeroU32) -> u64 {
     u64::from(y.get())
-    //~^ ERROR: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
+    //~^ non_zero_suggestions
 }
 
 fn some_fn_that_only_takes_u64(_: u64) {}
diff --git a/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.stderr b/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.stderr
index 787179f2a2d6..d2ac983d4f7f 100644
--- a/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/non_zero_suggestions_unfixable.stderr
@@ -14,7 +14,7 @@ LL |     let y = u64::from(n.get());
    |             ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(n)`
 
 error: consider using `NonZeroU64::from()` for more efficient and type-safe conversion
-  --> tests/ui/non_zero_suggestions_unfixable.rs:19:5
+  --> tests/ui/non_zero_suggestions_unfixable.rs:20:5
    |
 LL |     u64::from(y.get())
    |     ^^^^^^^^^^^^^^^^^^ help: replace with: `NonZeroU64::from(y)`
diff --git a/src/tools/clippy/tests/ui/nonminimal_bool.rs b/src/tools/clippy/tests/ui/nonminimal_bool.rs
index 52b0155a762e..a155ff3508be 100644
--- a/src/tools/clippy/tests/ui/nonminimal_bool.rs
+++ b/src/tools/clippy/tests/ui/nonminimal_bool.rs
@@ -15,23 +15,28 @@ fn main() {
     let d: bool = unimplemented!();
     let e: bool = unimplemented!();
     let _ = !true;
-    //~^ ERROR: this boolean expression can be simplified
-    //~| NOTE: `-D clippy::nonminimal-bool` implied by `-D warnings`
+    //~^ nonminimal_bool
+
     let _ = !false;
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = !!a;
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = false || a;
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     // don't lint on cfgs
     let _ = cfg!(you_shall_not_not_pass) && a;
     let _ = a || !b || !c || !d || !e;
     let _ = !(!a && b);
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = !(!a || b);
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = !a && !(b && c);
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
 }
 
 fn equality_stuff() {
@@ -40,15 +45,19 @@ fn equality_stuff() {
     let c: i32 = unimplemented!();
     let d: i32 = unimplemented!();
     let _ = a == b && c == 5 && a == b;
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = a == b || c == 5 || a == b;
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = a == b && c == 5 && b == a;
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = a != b || !(a != b || c == d);
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
+
     let _ = a != b && !(a != b && c == d);
-    //~^ ERROR: this boolean expression can be simplified
+    //~^ nonminimal_bool
 }
 
 fn issue3847(a: u32, b: u32) -> bool {
@@ -79,7 +88,8 @@ fn check_expect() {
 
 fn issue9428() {
     if matches!(true, true) && true {
-        //~^ ERROR: this boolean expression can be simplified
+        //~^ nonminimal_bool
+
         println!("foo");
     }
 }
@@ -158,19 +168,35 @@ fn issue11932() {
 
 fn issue_5794() {
     let a = 0;
-    if !(12 == a) {} //~ ERROR: this boolean expression can be simplified
-    if !(a == 12) {} //~ ERROR: this boolean expression can be simplified
-    if !(12 != a) {} //~ ERROR: this boolean expression can be simplified
-    if !(a != 12) {} //~ ERROR: this boolean expression can be simplified
+    if !(12 == a) {}
+    //~^ nonminimal_bool
+    if !(a == 12) {}
+    //~^ nonminimal_bool
+    if !(12 != a) {}
+    //~^ nonminimal_bool
+    if !(a != 12) {}
+    //~^ nonminimal_bool
 
     let b = true;
     let c = false;
-    if !b == true {} //~ ERROR: this boolean expression can be simplified
-    if !b != true {} //~ ERROR: this boolean expression can be simplified
-    if true == !b {} //~ ERROR: this boolean expression can be simplified
-    if true != !b {} //~ ERROR: this boolean expression can be simplified
-    if !b == !c {} //~ ERROR: this boolean expression can be simplified
-    if !b != !c {} //~ ERROR: this boolean expression can be simplified
+    if !b == true {}
+    //~^ nonminimal_bool
+    //~| bool_comparison
+    //~| bool_comparison
+    if !b != true {}
+    //~^ nonminimal_bool
+    //~| bool_comparison
+    if true == !b {}
+    //~^ nonminimal_bool
+    //~| bool_comparison
+    //~| bool_comparison
+    if true != !b {}
+    //~^ nonminimal_bool
+    //~| bool_comparison
+    if !b == !c {}
+    //~^ nonminimal_bool
+    if !b != !c {}
+    //~^ nonminimal_bool
 }
 
 fn issue_12371(x: usize) -> bool {
@@ -183,3 +209,10 @@ fn issue_12371(x: usize) -> bool {
 fn many_ops(a: bool, b: bool, c: bool, d: bool, e: bool, f: bool) -> bool {
     (a && c && f) || (!a && b && !d) || (!b && !c && !e) || (d && e && !f)
 }
+
+fn issue14184(a: f32, b: bool) {
+    if !(a < 2.0 && !b) {
+        //~^ nonminimal_bool
+        println!("Hi");
+    }
+}
diff --git a/src/tools/clippy/tests/ui/nonminimal_bool.stderr b/src/tools/clippy/tests/ui/nonminimal_bool.stderr
index 56d6eb10ac03..336cce40abf0 100644
--- a/src/tools/clippy/tests/ui/nonminimal_bool.stderr
+++ b/src/tools/clippy/tests/ui/nonminimal_bool.stderr
@@ -14,37 +14,37 @@ LL |     let _ = !false;
    |             ^^^^^^ help: try: `true`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:22:13
+  --> tests/ui/nonminimal_bool.rs:23:13
    |
 LL |     let _ = !!a;
    |             ^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:24:13
+  --> tests/ui/nonminimal_bool.rs:26:13
    |
 LL |     let _ = false || a;
    |             ^^^^^^^^^^ help: try: `a`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:29:13
+  --> tests/ui/nonminimal_bool.rs:32:13
    |
 LL |     let _ = !(!a && b);
    |             ^^^^^^^^^^ help: try: `a || !b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:31:13
+  --> tests/ui/nonminimal_bool.rs:35:13
    |
 LL |     let _ = !(!a || b);
    |             ^^^^^^^^^^ help: try: `a && !b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:33:13
+  --> tests/ui/nonminimal_bool.rs:38:13
    |
 LL |     let _ = !a && !(b && c);
    |             ^^^^^^^^^^^^^^^ help: try: `!(a || b && c)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:42:13
+  --> tests/ui/nonminimal_bool.rs:47:13
    |
 LL |     let _ = a == b && c == 5 && a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL +     let _ = a == b && c == 5;
    |
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:44:13
+  --> tests/ui/nonminimal_bool.rs:50:13
    |
 LL |     let _ = a == b || c == 5 || a == b;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL +     let _ = a == b || c == 5;
    |
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:46:13
+  --> tests/ui/nonminimal_bool.rs:53:13
    |
 LL |     let _ = a == b && c == 5 && b == a;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL +     let _ = a == b && c == 5;
    |
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:48:13
+  --> tests/ui/nonminimal_bool.rs:56:13
    |
 LL |     let _ = a != b || !(a != b || c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -104,7 +104,7 @@ LL +     let _ = a != b || c != d;
    |
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:50:13
+  --> tests/ui/nonminimal_bool.rs:59:13
    |
 LL |     let _ = a != b && !(a != b && c == d);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -119,43 +119,43 @@ LL +     let _ = a != b && c != d;
    |
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:81:8
+  --> tests/ui/nonminimal_bool.rs:90:8
    |
 LL |     if matches!(true, true) && true {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `matches!(true, true)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:161:8
+  --> tests/ui/nonminimal_bool.rs:171:8
    |
 LL |     if !(12 == a) {}
    |        ^^^^^^^^^^ help: try: `(12 != a)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:162:8
+  --> tests/ui/nonminimal_bool.rs:173:8
    |
 LL |     if !(a == 12) {}
    |        ^^^^^^^^^^ help: try: `(a != 12)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:163:8
+  --> tests/ui/nonminimal_bool.rs:175:8
    |
 LL |     if !(12 != a) {}
    |        ^^^^^^^^^^ help: try: `(12 == a)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:164:8
+  --> tests/ui/nonminimal_bool.rs:177:8
    |
 LL |     if !(a != 12) {}
    |        ^^^^^^^^^^ help: try: `(a == 12)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:168:8
+  --> tests/ui/nonminimal_bool.rs:182:8
    |
 LL |     if !b == true {}
    |        ^^^^^^^^^^ help: try: `b != true`
 
 error: this comparison might be written more concisely
-  --> tests/ui/nonminimal_bool.rs:168:8
+  --> tests/ui/nonminimal_bool.rs:182:8
    |
 LL |     if !b == true {}
    |        ^^^^^^^^^^ help: try simplifying it as shown: `b != true`
@@ -164,64 +164,70 @@ LL |     if !b == true {}
    = help: to override `-D warnings` add `#[allow(clippy::bool_comparison)]`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/nonminimal_bool.rs:168:8
+  --> tests/ui/nonminimal_bool.rs:182:8
    |
 LL |     if !b == true {}
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:169:8
+  --> tests/ui/nonminimal_bool.rs:186:8
    |
 LL |     if !b != true {}
    |        ^^^^^^^^^^ help: try: `b == true`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:169:8
+  --> tests/ui/nonminimal_bool.rs:186:8
    |
 LL |     if !b != true {}
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!(!b)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:170:8
+  --> tests/ui/nonminimal_bool.rs:189:8
    |
 LL |     if true == !b {}
    |        ^^^^^^^^^^ help: try: `true != b`
 
 error: this comparison might be written more concisely
-  --> tests/ui/nonminimal_bool.rs:170:8
+  --> tests/ui/nonminimal_bool.rs:189:8
    |
 LL |     if true == !b {}
    |        ^^^^^^^^^^ help: try simplifying it as shown: `true != b`
 
 error: equality checks against true are unnecessary
-  --> tests/ui/nonminimal_bool.rs:170:8
+  --> tests/ui/nonminimal_bool.rs:189:8
    |
 LL |     if true == !b {}
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!b`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:171:8
+  --> tests/ui/nonminimal_bool.rs:193:8
    |
 LL |     if true != !b {}
    |        ^^^^^^^^^^ help: try: `true == b`
 
 error: inequality checks against true can be replaced by a negation
-  --> tests/ui/nonminimal_bool.rs:171:8
+  --> tests/ui/nonminimal_bool.rs:193:8
    |
 LL |     if true != !b {}
    |        ^^^^^^^^^^ help: try simplifying it as shown: `!(!b)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:172:8
+  --> tests/ui/nonminimal_bool.rs:196:8
    |
 LL |     if !b == !c {}
    |        ^^^^^^^^ help: try: `b == c`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool.rs:173:8
+  --> tests/ui/nonminimal_bool.rs:198:8
    |
 LL |     if !b != !c {}
    |        ^^^^^^^^ help: try: `b != c`
 
-error: aborting due to 29 previous errors
+error: this boolean expression can be simplified
+  --> tests/ui/nonminimal_bool.rs:214:8
+   |
+LL |     if !(a < 2.0 && !b) {
+   |        ^^^^^^^^^^^^^^^^ help: try: `!(a < 2.0) || b`
+
+error: aborting due to 30 previous errors
 
diff --git a/src/tools/clippy/tests/ui/nonminimal_bool_methods.fixed b/src/tools/clippy/tests/ui/nonminimal_bool_methods.fixed
index 65ccaaca8918..c2377491f25b 100644
--- a/src/tools/clippy/tests/ui/nonminimal_bool_methods.fixed
+++ b/src/tools/clippy/tests/ui/nonminimal_bool_methods.fixed
@@ -6,18 +6,27 @@ fn methods_with_negation() {
     let b: Result<i32, i32> = unimplemented!();
     let _ = a.is_some();
     let _ = a.is_none();
+    //~^ nonminimal_bool
     let _ = a.is_none();
     let _ = a.is_some();
+    //~^ nonminimal_bool
     let _ = b.is_err();
     let _ = b.is_ok();
+    //~^ nonminimal_bool
     let _ = b.is_ok();
     let _ = b.is_err();
+    //~^ nonminimal_bool
     let c = false;
     let _ = a.is_none() || c;
+    //~^ nonminimal_bool
     let _ = a.is_none() && c;
+    //~^ nonminimal_bool
     let _ = !(!c ^ c) || a.is_none();
+    //~^ nonminimal_bool
     let _ = (!c ^ c) || a.is_none();
+    //~^ nonminimal_bool
     let _ = !c ^ c || a.is_none();
+    //~^ nonminimal_bool
 }
 
 // Simplified versions of https://github.com/rust-lang/rust-clippy/issues/2638
@@ -90,11 +99,15 @@ fn dont_warn_for_custom_methods_with_negation() {
 fn warn_for_built_in_methods_with_negation() {
     let res: Result<usize, usize> = Ok(1);
     if res.is_err() {}
+    //~^ nonminimal_bool
     if res.is_ok() {}
+    //~^ nonminimal_bool
 
     let res = Some(1);
     if res.is_none() {}
+    //~^ nonminimal_bool
     if res.is_some() {}
+    //~^ nonminimal_bool
 }
 
 #[allow(clippy::neg_cmp_op_on_partial_ord)]
@@ -110,24 +123,34 @@ fn dont_warn_for_negated_partial_ord_comparison() {
 fn issue_12625() {
     let a = 0;
     let b = 0;
-    if ((a as u64) < b) {} //~ ERROR: this boolean expression can be simplified
-    if ((a as u64) < b) {} //~ ERROR: this boolean expression can be simplified
-    if (a as u64 > b) {} //~ ERROR: this boolean expression can be simplified
+    if ((a as u64) < b) {}
+    //~^ nonminimal_bool
+    if ((a as u64) < b) {}
+    //~^ nonminimal_bool
+    if (a as u64 > b) {}
+    //~^ nonminimal_bool
 }
 
 fn issue_12761() {
     let a = 0;
     let b = 0;
     let c = 0;
-    if (a < b) as i32 == c {} //~ ERROR: this boolean expression can be simplified
-    if (a < b) | (a > c) {} //~ ERROR: this boolean expression can be simplified
+    if (a < b) as i32 == c {}
+    //~^ nonminimal_bool
+    if (a < b) | (a > c) {}
+    //~^ nonminimal_bool
+    //~| nonminimal_bool
     let opt: Option<usize> = Some(1);
     let res: Result<usize, usize> = Ok(1);
-    if res.is_err() as i32 == c {} //~ ERROR: this boolean expression can be simplified
-    if res.is_err() | opt.is_some() {} //~ ERROR: this boolean expression can be simplified
+    if res.is_err() as i32 == c {}
+    //~^ nonminimal_bool
+    if res.is_err() | opt.is_some() {}
+    //~^ nonminimal_bool
+    //~| nonminimal_bool
 
     fn a(a: bool) -> bool {
-        (4 <= 3).b() //~ ERROR: this boolean expression can be simplified
+        (4 <= 3).b()
+        //~^ nonminimal_bool
     }
 
     trait B {
@@ -152,12 +175,18 @@ fn issue_13436() {
     _ = opt.is_some_and(|x| x == 1000);
     _ = opt.is_some_and(|x| x != 1000);
     _ = opt.is_some_and(not_zero);
-    _ = opt.is_none_or(|x| x >= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_none_or(|x| x > 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_none_or(|x| x <= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_none_or(|x| x < 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_none_or(|x| x != 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_none_or(|x| x == 1000); //~ ERROR: this boolean expression can be simplified
+    _ = opt.is_none_or(|x| x >= 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_none_or(|x| x > 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_none_or(|x| x <= 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_none_or(|x| x < 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_none_or(|x| x != 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_none_or(|x| x == 1000);
+    //~^ nonminimal_bool
     _ = !opt.is_some_and(not_zero);
     _ = opt.is_none_or(|x| x < 1000);
     _ = opt.is_none_or(|x| x <= 1000);
@@ -166,33 +195,45 @@ fn issue_13436() {
     _ = opt.is_none_or(|x| x == 1000);
     _ = opt.is_none_or(|x| x != 1000);
     _ = opt.is_none_or(not_zero);
-    _ = opt.is_some_and(|x| x >= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_some_and(|x| x > 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_some_and(|x| x <= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_some_and(|x| x < 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_some_and(|x| x != 1000); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_some_and(|x| x == 1000); //~ ERROR: this boolean expression can be simplified
+    _ = opt.is_some_and(|x| x >= 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_some_and(|x| x > 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_some_and(|x| x <= 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_some_and(|x| x < 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_some_and(|x| x != 1000);
+    //~^ nonminimal_bool
+    _ = opt.is_some_and(|x| x == 1000);
+    //~^ nonminimal_bool
     _ = !opt.is_none_or(not_zero);
 
     let opt = Some(true);
     _ = opt.is_some_and(|x| x);
     _ = opt.is_some_and(|x| !x);
     _ = !opt.is_some_and(|x| x);
-    _ = opt.is_none_or(|x| x); //~ ERROR: this boolean expression can be simplified
+    _ = opt.is_none_or(|x| x);
+    //~^ nonminimal_bool
     _ = opt.is_none_or(|x| x);
     _ = opt.is_none_or(|x| !x);
     _ = !opt.is_none_or(|x| x);
-    _ = opt.is_some_and(|x| x); //~ ERROR: this boolean expression can be simplified
+    _ = opt.is_some_and(|x| x);
+    //~^ nonminimal_bool
 
     let opt: Option<Result<i32, i32>> = Some(Ok(123));
     _ = opt.is_some_and(|x| x.is_ok());
     _ = opt.is_some_and(|x| x.is_err());
     _ = opt.is_none_or(|x| x.is_ok());
     _ = opt.is_none_or(|x| x.is_err());
-    _ = opt.is_none_or(|x| x.is_err()); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_none_or(|x| x.is_ok()); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_some_and(|x| x.is_err()); //~ ERROR: this boolean expression can be simplified
-    _ = opt.is_some_and(|x| x.is_ok()); //~ ERROR: this boolean expression can be simplified
+    _ = opt.is_none_or(|x| x.is_err());
+    //~^ nonminimal_bool
+    _ = opt.is_none_or(|x| x.is_ok());
+    //~^ nonminimal_bool
+    _ = opt.is_some_and(|x| x.is_err());
+    //~^ nonminimal_bool
+    _ = opt.is_some_and(|x| x.is_ok());
+    //~^ nonminimal_bool
 
     #[clippy::msrv = "1.81"]
     fn before_stabilization() {
diff --git a/src/tools/clippy/tests/ui/nonminimal_bool_methods.rs b/src/tools/clippy/tests/ui/nonminimal_bool_methods.rs
index 06db3a1d4a5c..1ae0f0064c6b 100644
--- a/src/tools/clippy/tests/ui/nonminimal_bool_methods.rs
+++ b/src/tools/clippy/tests/ui/nonminimal_bool_methods.rs
@@ -6,18 +6,27 @@ fn methods_with_negation() {
     let b: Result<i32, i32> = unimplemented!();
     let _ = a.is_some();
     let _ = !a.is_some();
+    //~^ nonminimal_bool
     let _ = a.is_none();
     let _ = !a.is_none();
+    //~^ nonminimal_bool
     let _ = b.is_err();
     let _ = !b.is_err();
+    //~^ nonminimal_bool
     let _ = b.is_ok();
     let _ = !b.is_ok();
+    //~^ nonminimal_bool
     let c = false;
     let _ = !(a.is_some() && !c);
+    //~^ nonminimal_bool
     let _ = !(a.is_some() || !c);
+    //~^ nonminimal_bool
     let _ = !(!c ^ c) || !a.is_some();
+    //~^ nonminimal_bool
     let _ = (!c ^ c) || !a.is_some();
+    //~^ nonminimal_bool
     let _ = !c ^ c || !a.is_some();
+    //~^ nonminimal_bool
 }
 
 // Simplified versions of https://github.com/rust-lang/rust-clippy/issues/2638
@@ -90,11 +99,15 @@ fn dont_warn_for_custom_methods_with_negation() {
 fn warn_for_built_in_methods_with_negation() {
     let res: Result<usize, usize> = Ok(1);
     if !res.is_ok() {}
+    //~^ nonminimal_bool
     if !res.is_err() {}
+    //~^ nonminimal_bool
 
     let res = Some(1);
     if !res.is_some() {}
+    //~^ nonminimal_bool
     if !res.is_none() {}
+    //~^ nonminimal_bool
 }
 
 #[allow(clippy::neg_cmp_op_on_partial_ord)]
@@ -110,24 +123,34 @@ fn dont_warn_for_negated_partial_ord_comparison() {
 fn issue_12625() {
     let a = 0;
     let b = 0;
-    if !(a as u64 >= b) {} //~ ERROR: this boolean expression can be simplified
-    if !((a as u64) >= b) {} //~ ERROR: this boolean expression can be simplified
-    if !(a as u64 <= b) {} //~ ERROR: this boolean expression can be simplified
+    if !(a as u64 >= b) {}
+    //~^ nonminimal_bool
+    if !((a as u64) >= b) {}
+    //~^ nonminimal_bool
+    if !(a as u64 <= b) {}
+    //~^ nonminimal_bool
 }
 
 fn issue_12761() {
     let a = 0;
     let b = 0;
     let c = 0;
-    if !(a >= b) as i32 == c {} //~ ERROR: this boolean expression can be simplified
-    if !(a >= b) | !(a <= c) {} //~ ERROR: this boolean expression can be simplified
+    if !(a >= b) as i32 == c {}
+    //~^ nonminimal_bool
+    if !(a >= b) | !(a <= c) {}
+    //~^ nonminimal_bool
+    //~| nonminimal_bool
     let opt: Option<usize> = Some(1);
     let res: Result<usize, usize> = Ok(1);
-    if !res.is_ok() as i32 == c {} //~ ERROR: this boolean expression can be simplified
-    if !res.is_ok() | !opt.is_none() {} //~ ERROR: this boolean expression can be simplified
+    if !res.is_ok() as i32 == c {}
+    //~^ nonminimal_bool
+    if !res.is_ok() | !opt.is_none() {}
+    //~^ nonminimal_bool
+    //~| nonminimal_bool
 
     fn a(a: bool) -> bool {
-        (!(4 > 3)).b() //~ ERROR: this boolean expression can be simplified
+        (!(4 > 3)).b()
+        //~^ nonminimal_bool
     }
 
     trait B {
@@ -152,12 +175,18 @@ fn issue_13436() {
     _ = opt.is_some_and(|x| x == 1000);
     _ = opt.is_some_and(|x| x != 1000);
     _ = opt.is_some_and(not_zero);
-    _ = !opt.is_some_and(|x| x < 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_some_and(|x| x <= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_some_and(|x| x > 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_some_and(|x| x >= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_some_and(|x| x == 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_some_and(|x| x != 1000); //~ ERROR: this boolean expression can be simplified
+    _ = !opt.is_some_and(|x| x < 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_some_and(|x| x <= 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_some_and(|x| x > 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_some_and(|x| x >= 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_some_and(|x| x == 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_some_and(|x| x != 1000);
+    //~^ nonminimal_bool
     _ = !opt.is_some_and(not_zero);
     _ = opt.is_none_or(|x| x < 1000);
     _ = opt.is_none_or(|x| x <= 1000);
@@ -166,33 +195,45 @@ fn issue_13436() {
     _ = opt.is_none_or(|x| x == 1000);
     _ = opt.is_none_or(|x| x != 1000);
     _ = opt.is_none_or(not_zero);
-    _ = !opt.is_none_or(|x| x < 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_none_or(|x| x <= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_none_or(|x| x > 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_none_or(|x| x >= 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_none_or(|x| x == 1000); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_none_or(|x| x != 1000); //~ ERROR: this boolean expression can be simplified
+    _ = !opt.is_none_or(|x| x < 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_none_or(|x| x <= 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_none_or(|x| x > 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_none_or(|x| x >= 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_none_or(|x| x == 1000);
+    //~^ nonminimal_bool
+    _ = !opt.is_none_or(|x| x != 1000);
+    //~^ nonminimal_bool
     _ = !opt.is_none_or(not_zero);
 
     let opt = Some(true);
     _ = opt.is_some_and(|x| x);
     _ = opt.is_some_and(|x| !x);
     _ = !opt.is_some_and(|x| x);
-    _ = !opt.is_some_and(|x| !x); //~ ERROR: this boolean expression can be simplified
+    _ = !opt.is_some_and(|x| !x);
+    //~^ nonminimal_bool
     _ = opt.is_none_or(|x| x);
     _ = opt.is_none_or(|x| !x);
     _ = !opt.is_none_or(|x| x);
-    _ = !opt.is_none_or(|x| !x); //~ ERROR: this boolean expression can be simplified
+    _ = !opt.is_none_or(|x| !x);
+    //~^ nonminimal_bool
 
     let opt: Option<Result<i32, i32>> = Some(Ok(123));
     _ = opt.is_some_and(|x| x.is_ok());
     _ = opt.is_some_and(|x| x.is_err());
     _ = opt.is_none_or(|x| x.is_ok());
     _ = opt.is_none_or(|x| x.is_err());
-    _ = !opt.is_some_and(|x| x.is_ok()); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_some_and(|x| x.is_err()); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_none_or(|x| x.is_ok()); //~ ERROR: this boolean expression can be simplified
-    _ = !opt.is_none_or(|x| x.is_err()); //~ ERROR: this boolean expression can be simplified
+    _ = !opt.is_some_and(|x| x.is_ok());
+    //~^ nonminimal_bool
+    _ = !opt.is_some_and(|x| x.is_err());
+    //~^ nonminimal_bool
+    _ = !opt.is_none_or(|x| x.is_ok());
+    //~^ nonminimal_bool
+    _ = !opt.is_none_or(|x| x.is_err());
+    //~^ nonminimal_bool
 
     #[clippy::msrv = "1.81"]
     fn before_stabilization() {
diff --git a/src/tools/clippy/tests/ui/nonminimal_bool_methods.stderr b/src/tools/clippy/tests/ui/nonminimal_bool_methods.stderr
index 66c50f9ff1e1..b5155b3b1696 100644
--- a/src/tools/clippy/tests/ui/nonminimal_bool_methods.stderr
+++ b/src/tools/clippy/tests/ui/nonminimal_bool_methods.stderr
@@ -8,241 +8,241 @@ LL |     let _ = !a.is_some();
    = help: to override `-D warnings` add `#[allow(clippy::nonminimal_bool)]`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:10:13
+  --> tests/ui/nonminimal_bool_methods.rs:11:13
    |
 LL |     let _ = !a.is_none();
    |             ^^^^^^^^^^^^ help: try: `a.is_some()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:12:13
+  --> tests/ui/nonminimal_bool_methods.rs:14:13
    |
 LL |     let _ = !b.is_err();
    |             ^^^^^^^^^^^ help: try: `b.is_ok()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:14:13
+  --> tests/ui/nonminimal_bool_methods.rs:17:13
    |
 LL |     let _ = !b.is_ok();
    |             ^^^^^^^^^^ help: try: `b.is_err()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:16:13
+  --> tests/ui/nonminimal_bool_methods.rs:20:13
    |
 LL |     let _ = !(a.is_some() && !c);
    |             ^^^^^^^^^^^^^^^^^^^^ help: try: `a.is_none() || c`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:17:13
+  --> tests/ui/nonminimal_bool_methods.rs:22:13
    |
 LL |     let _ = !(a.is_some() || !c);
    |             ^^^^^^^^^^^^^^^^^^^^ help: try: `a.is_none() && c`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:18:26
+  --> tests/ui/nonminimal_bool_methods.rs:24:26
    |
 LL |     let _ = !(!c ^ c) || !a.is_some();
    |                          ^^^^^^^^^^^^ help: try: `a.is_none()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:19:25
+  --> tests/ui/nonminimal_bool_methods.rs:26:25
    |
 LL |     let _ = (!c ^ c) || !a.is_some();
    |                         ^^^^^^^^^^^^ help: try: `a.is_none()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:20:23
+  --> tests/ui/nonminimal_bool_methods.rs:28:23
    |
 LL |     let _ = !c ^ c || !a.is_some();
    |                       ^^^^^^^^^^^^ help: try: `a.is_none()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:92:8
+  --> tests/ui/nonminimal_bool_methods.rs:101:8
    |
 LL |     if !res.is_ok() {}
    |        ^^^^^^^^^^^^ help: try: `res.is_err()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:93:8
+  --> tests/ui/nonminimal_bool_methods.rs:103:8
    |
 LL |     if !res.is_err() {}
    |        ^^^^^^^^^^^^^ help: try: `res.is_ok()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:96:8
+  --> tests/ui/nonminimal_bool_methods.rs:107:8
    |
 LL |     if !res.is_some() {}
    |        ^^^^^^^^^^^^^^ help: try: `res.is_none()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:97:8
+  --> tests/ui/nonminimal_bool_methods.rs:109:8
    |
 LL |     if !res.is_none() {}
    |        ^^^^^^^^^^^^^^ help: try: `res.is_some()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:113:8
+  --> tests/ui/nonminimal_bool_methods.rs:126:8
    |
 LL |     if !(a as u64 >= b) {}
    |        ^^^^^^^^^^^^^^^^ help: try: `((a as u64) < b)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:114:8
+  --> tests/ui/nonminimal_bool_methods.rs:128:8
    |
 LL |     if !((a as u64) >= b) {}
    |        ^^^^^^^^^^^^^^^^^^ help: try: `((a as u64) < b)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:115:8
+  --> tests/ui/nonminimal_bool_methods.rs:130:8
    |
 LL |     if !(a as u64 <= b) {}
    |        ^^^^^^^^^^^^^^^^ help: try: `(a as u64 > b)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:122:8
+  --> tests/ui/nonminimal_bool_methods.rs:138:8
    |
 LL |     if !(a >= b) as i32 == c {}
    |        ^^^^^^^^^ help: try: `(a < b)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:123:8
+  --> tests/ui/nonminimal_bool_methods.rs:140:8
    |
 LL |     if !(a >= b) | !(a <= c) {}
    |        ^^^^^^^^^ help: try: `(a < b)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:123:20
+  --> tests/ui/nonminimal_bool_methods.rs:140:20
    |
 LL |     if !(a >= b) | !(a <= c) {}
    |                    ^^^^^^^^^ help: try: `(a > c)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:126:8
+  --> tests/ui/nonminimal_bool_methods.rs:145:8
    |
 LL |     if !res.is_ok() as i32 == c {}
    |        ^^^^^^^^^^^^ help: try: `res.is_err()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:127:8
+  --> tests/ui/nonminimal_bool_methods.rs:147:8
    |
 LL |     if !res.is_ok() | !opt.is_none() {}
    |        ^^^^^^^^^^^^ help: try: `res.is_err()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:127:23
+  --> tests/ui/nonminimal_bool_methods.rs:147:23
    |
 LL |     if !res.is_ok() | !opt.is_none() {}
    |                       ^^^^^^^^^^^^^^ help: try: `opt.is_some()`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:130:9
+  --> tests/ui/nonminimal_bool_methods.rs:152:9
    |
 LL |         (!(4 > 3)).b()
    |         ^^^^^^^^^^ help: try: `(4 <= 3)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:155:9
+  --> tests/ui/nonminimal_bool_methods.rs:178:9
    |
 LL |     _ = !opt.is_some_and(|x| x < 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x >= 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:156:9
+  --> tests/ui/nonminimal_bool_methods.rs:180:9
    |
 LL |     _ = !opt.is_some_and(|x| x <= 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x > 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:157:9
+  --> tests/ui/nonminimal_bool_methods.rs:182:9
    |
 LL |     _ = !opt.is_some_and(|x| x > 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x <= 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:158:9
+  --> tests/ui/nonminimal_bool_methods.rs:184:9
    |
 LL |     _ = !opt.is_some_and(|x| x >= 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x < 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:159:9
+  --> tests/ui/nonminimal_bool_methods.rs:186:9
    |
 LL |     _ = !opt.is_some_and(|x| x == 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x != 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:160:9
+  --> tests/ui/nonminimal_bool_methods.rs:188:9
    |
 LL |     _ = !opt.is_some_and(|x| x != 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x == 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:169:9
+  --> tests/ui/nonminimal_bool_methods.rs:198:9
    |
 LL |     _ = !opt.is_none_or(|x| x < 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x >= 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:170:9
+  --> tests/ui/nonminimal_bool_methods.rs:200:9
    |
 LL |     _ = !opt.is_none_or(|x| x <= 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x > 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:171:9
+  --> tests/ui/nonminimal_bool_methods.rs:202:9
    |
 LL |     _ = !opt.is_none_or(|x| x > 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x <= 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:172:9
+  --> tests/ui/nonminimal_bool_methods.rs:204:9
    |
 LL |     _ = !opt.is_none_or(|x| x >= 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x < 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:173:9
+  --> tests/ui/nonminimal_bool_methods.rs:206:9
    |
 LL |     _ = !opt.is_none_or(|x| x == 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x != 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:174:9
+  --> tests/ui/nonminimal_bool_methods.rs:208:9
    |
 LL |     _ = !opt.is_none_or(|x| x != 1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x == 1000)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:181:9
+  --> tests/ui/nonminimal_bool_methods.rs:216:9
    |
 LL |     _ = !opt.is_some_and(|x| !x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:185:9
+  --> tests/ui/nonminimal_bool_methods.rs:221:9
    |
 LL |     _ = !opt.is_none_or(|x| !x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x)`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:192:9
+  --> tests/ui/nonminimal_bool_methods.rs:229:9
    |
 LL |     _ = !opt.is_some_and(|x| x.is_ok());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x.is_err())`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:193:9
+  --> tests/ui/nonminimal_bool_methods.rs:231:9
    |
 LL |     _ = !opt.is_some_and(|x| x.is_err());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_none_or(|x| x.is_ok())`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:194:9
+  --> tests/ui/nonminimal_bool_methods.rs:233:9
    |
 LL |     _ = !opt.is_none_or(|x| x.is_ok());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x.is_err())`
 
 error: this boolean expression can be simplified
-  --> tests/ui/nonminimal_bool_methods.rs:195:9
+  --> tests/ui/nonminimal_bool_methods.rs:235:9
    |
 LL |     _ = !opt.is_none_or(|x| x.is_err());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.is_some_and(|x| x.is_ok())`
diff --git a/src/tools/clippy/tests/ui/nonminimal_bool_methods_unfixable.rs b/src/tools/clippy/tests/ui/nonminimal_bool_methods_unfixable.rs
index 60b8da30a2f1..850eba4851b8 100644
--- a/src/tools/clippy/tests/ui/nonminimal_bool_methods_unfixable.rs
+++ b/src/tools/clippy/tests/ui/nonminimal_bool_methods_unfixable.rs
@@ -3,7 +3,9 @@
 
 fn issue_13436() {
     let opt_opt = Some(Some(500));
-    _ = !opt_opt.is_some_and(|x| !x.is_some_and(|y| y != 1000)); //~ ERROR: this boolean expression can be simplified
+    _ = !opt_opt.is_some_and(|x| !x.is_some_and(|y| y != 1000));
+    //~^ nonminimal_bool
+    //~| nonminimal_bool
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/obfuscated_if_else.fixed b/src/tools/clippy/tests/ui/obfuscated_if_else.fixed
index bfe1c5e10cf8..66f5070787b0 100644
--- a/src/tools/clippy/tests/ui/obfuscated_if_else.fixed
+++ b/src/tools/clippy/tests/ui/obfuscated_if_else.fixed
@@ -1,18 +1,77 @@
 #![warn(clippy::obfuscated_if_else)]
-#![allow(clippy::unnecessary_lazy_evaluations, clippy::unit_arg, clippy::unused_unit)]
+#![allow(
+    clippy::unnecessary_lazy_evaluations,
+    clippy::unit_arg,
+    clippy::unused_unit,
+    clippy::unwrap_or_default
+)]
 
 fn main() {
     if true { "a" } else { "b" };
+    //~^ obfuscated_if_else
+
     if true { "a" } else { "b" };
+    //~^ obfuscated_if_else
 
     let a = 1;
     if a == 1 { "a" } else { "b" };
+    //~^ obfuscated_if_else
+
     if a == 1 { "a" } else { "b" };
+    //~^ obfuscated_if_else
 
     let partial = (a == 1).then_some("a");
     partial.unwrap_or("b"); // not lint
 
     let mut a = 0;
     if true { a += 1 } else { () };
+    //~^ obfuscated_if_else
+
     if true { () } else { a += 2 };
+    //~^ obfuscated_if_else
+
+    let mut n = 1;
+    if true { n = 1 } else { n = 2 };
+    //~^ obfuscated_if_else
+    if true { 1 } else { n * 2 };
+    //~^ obfuscated_if_else
+    if true { n += 1 } else { () };
+    //~^ obfuscated_if_else
+
+    let _ = if true { 1 } else { n * 2 };
+    //~^ obfuscated_if_else
+
+    if true { 1 } else { Default::default() };
+    //~^ obfuscated_if_else
+
+    let partial = true.then_some(1);
+    partial.unwrap_or_else(|| n * 2); // not lint
+}
+
+fn issue11141() {
+    // Parentheses are required around the left side of a binary expression
+    let _ = (if true { 40 } else { 17 }) | 2;
+    //~^ obfuscated_if_else
+
+    // Parentheses are required only for the leftmost expression
+    let _ = (if true { 30 } else { 17 }) | if true { 2 } else { 3 } | if true { 10 } else { 1 };
+    //~^ obfuscated_if_else
+    //~| obfuscated_if_else
+    //~| obfuscated_if_else
+
+    // Parentheses are not required around the right side of a binary expression
+    let _ = 2 | if true { 40 } else { 17 };
+    //~^ obfuscated_if_else
+
+    // Parentheses are not required for a cast
+    let _ = if true { 42 } else { 17 } as u8;
+    //~^ obfuscated_if_else
+
+    // Parentheses are not required for a deref
+    let _ = *if true { &42 } else { &17 };
+    //~^ obfuscated_if_else
+
+    // Parentheses are not required for a deref followed by a cast
+    let _ = *if true { &42 } else { &17 } as u8;
+    //~^ obfuscated_if_else
 }
diff --git a/src/tools/clippy/tests/ui/obfuscated_if_else.rs b/src/tools/clippy/tests/ui/obfuscated_if_else.rs
index 0ded2a2ceedf..4efd740eb60b 100644
--- a/src/tools/clippy/tests/ui/obfuscated_if_else.rs
+++ b/src/tools/clippy/tests/ui/obfuscated_if_else.rs
@@ -1,18 +1,77 @@
 #![warn(clippy::obfuscated_if_else)]
-#![allow(clippy::unnecessary_lazy_evaluations, clippy::unit_arg, clippy::unused_unit)]
+#![allow(
+    clippy::unnecessary_lazy_evaluations,
+    clippy::unit_arg,
+    clippy::unused_unit,
+    clippy::unwrap_or_default
+)]
 
 fn main() {
     true.then_some("a").unwrap_or("b");
+    //~^ obfuscated_if_else
+
     true.then(|| "a").unwrap_or("b");
+    //~^ obfuscated_if_else
 
     let a = 1;
     (a == 1).then_some("a").unwrap_or("b");
+    //~^ obfuscated_if_else
+
     (a == 1).then(|| "a").unwrap_or("b");
+    //~^ obfuscated_if_else
 
     let partial = (a == 1).then_some("a");
     partial.unwrap_or("b"); // not lint
 
     let mut a = 0;
     true.then_some(a += 1).unwrap_or(());
+    //~^ obfuscated_if_else
+
     true.then_some(()).unwrap_or(a += 2);
+    //~^ obfuscated_if_else
+
+    let mut n = 1;
+    true.then(|| n = 1).unwrap_or_else(|| n = 2);
+    //~^ obfuscated_if_else
+    true.then_some(1).unwrap_or_else(|| n * 2);
+    //~^ obfuscated_if_else
+    true.then_some(n += 1).unwrap_or_else(|| ());
+    //~^ obfuscated_if_else
+
+    let _ = true.then_some(1).unwrap_or_else(|| n * 2);
+    //~^ obfuscated_if_else
+
+    true.then_some(1).unwrap_or_else(Default::default);
+    //~^ obfuscated_if_else
+
+    let partial = true.then_some(1);
+    partial.unwrap_or_else(|| n * 2); // not lint
+}
+
+fn issue11141() {
+    // Parentheses are required around the left side of a binary expression
+    let _ = true.then_some(40).unwrap_or(17) | 2;
+    //~^ obfuscated_if_else
+
+    // Parentheses are required only for the leftmost expression
+    let _ = true.then_some(30).unwrap_or(17) | true.then_some(2).unwrap_or(3) | true.then_some(10).unwrap_or(1);
+    //~^ obfuscated_if_else
+    //~| obfuscated_if_else
+    //~| obfuscated_if_else
+
+    // Parentheses are not required around the right side of a binary expression
+    let _ = 2 | true.then_some(40).unwrap_or(17);
+    //~^ obfuscated_if_else
+
+    // Parentheses are not required for a cast
+    let _ = true.then_some(42).unwrap_or(17) as u8;
+    //~^ obfuscated_if_else
+
+    // Parentheses are not required for a deref
+    let _ = *true.then_some(&42).unwrap_or(&17);
+    //~^ obfuscated_if_else
+
+    // Parentheses are not required for a deref followed by a cast
+    let _ = *true.then_some(&42).unwrap_or(&17) as u8;
+    //~^ obfuscated_if_else
 }
diff --git a/src/tools/clippy/tests/ui/obfuscated_if_else.stderr b/src/tools/clippy/tests/ui/obfuscated_if_else.stderr
index 9ce1f475c480..d676c2566957 100644
--- a/src/tools/clippy/tests/ui/obfuscated_if_else.stderr
+++ b/src/tools/clippy/tests/ui/obfuscated_if_else.stderr
@@ -1,5 +1,5 @@
 error: this method chain can be written more clearly with `if .. else ..`
-  --> tests/ui/obfuscated_if_else.rs:5:5
+  --> tests/ui/obfuscated_if_else.rs:10:5
    |
 LL |     true.then_some("a").unwrap_or("b");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { "a" } else { "b" }`
@@ -8,34 +8,112 @@ LL |     true.then_some("a").unwrap_or("b");
    = help: to override `-D warnings` add `#[allow(clippy::obfuscated_if_else)]`
 
 error: this method chain can be written more clearly with `if .. else ..`
-  --> tests/ui/obfuscated_if_else.rs:6:5
+  --> tests/ui/obfuscated_if_else.rs:13:5
    |
 LL |     true.then(|| "a").unwrap_or("b");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { "a" } else { "b" }`
 
 error: this method chain can be written more clearly with `if .. else ..`
-  --> tests/ui/obfuscated_if_else.rs:9:5
+  --> tests/ui/obfuscated_if_else.rs:17:5
    |
 LL |     (a == 1).then_some("a").unwrap_or("b");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if a == 1 { "a" } else { "b" }`
 
 error: this method chain can be written more clearly with `if .. else ..`
-  --> tests/ui/obfuscated_if_else.rs:10:5
+  --> tests/ui/obfuscated_if_else.rs:20:5
    |
 LL |     (a == 1).then(|| "a").unwrap_or("b");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if a == 1 { "a" } else { "b" }`
 
 error: this method chain can be written more clearly with `if .. else ..`
-  --> tests/ui/obfuscated_if_else.rs:16:5
+  --> tests/ui/obfuscated_if_else.rs:27:5
    |
 LL |     true.then_some(a += 1).unwrap_or(());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { a += 1 } else { () }`
 
 error: this method chain can be written more clearly with `if .. else ..`
-  --> tests/ui/obfuscated_if_else.rs:17:5
+  --> tests/ui/obfuscated_if_else.rs:30:5
    |
 LL |     true.then_some(()).unwrap_or(a += 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { () } else { a += 2 }`
 
-error: aborting due to 6 previous errors
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:34:5
+   |
+LL |     true.then(|| n = 1).unwrap_or_else(|| n = 2);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { n = 1 } else { n = 2 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:36:5
+   |
+LL |     true.then_some(1).unwrap_or_else(|| n * 2);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { 1 } else { n * 2 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:38:5
+   |
+LL |     true.then_some(n += 1).unwrap_or_else(|| ());
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { n += 1 } else { () }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:41:13
+   |
+LL |     let _ = true.then_some(1).unwrap_or_else(|| n * 2);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { 1 } else { n * 2 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:44:5
+   |
+LL |     true.then_some(1).unwrap_or_else(Default::default);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { 1 } else { Default::default() }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:53:13
+   |
+LL |     let _ = true.then_some(40).unwrap_or(17) | 2;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(if true { 40 } else { 17 })`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:57:13
+   |
+LL |     let _ = true.then_some(30).unwrap_or(17) | true.then_some(2).unwrap_or(3) | true.then_some(10).unwrap_or(1);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(if true { 30 } else { 17 })`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:57:48
+   |
+LL |     let _ = true.then_some(30).unwrap_or(17) | true.then_some(2).unwrap_or(3) | true.then_some(10).unwrap_or(1);
+   |                                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { 2 } else { 3 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:57:81
+   |
+LL |     let _ = true.then_some(30).unwrap_or(17) | true.then_some(2).unwrap_or(3) | true.then_some(10).unwrap_or(1);
+   |                                                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { 10 } else { 1 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:63:17
+   |
+LL |     let _ = 2 | true.then_some(40).unwrap_or(17);
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { 40 } else { 17 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:67:13
+   |
+LL |     let _ = true.then_some(42).unwrap_or(17) as u8;
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { 42 } else { 17 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:71:14
+   |
+LL |     let _ = *true.then_some(&42).unwrap_or(&17);
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { &42 } else { &17 }`
+
+error: this method chain can be written more clearly with `if .. else ..`
+  --> tests/ui/obfuscated_if_else.rs:75:14
+   |
+LL |     let _ = *true.then_some(&42).unwrap_or(&17) as u8;
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `if true { &42 } else { &17 }`
+
+error: aborting due to 19 previous errors
 
diff --git a/src/tools/clippy/tests/ui/octal_escapes.rs b/src/tools/clippy/tests/ui/octal_escapes.rs
index f2664e2fa67f..d91d6c1d7bee 100644
--- a/src/tools/clippy/tests/ui/octal_escapes.rs
+++ b/src/tools/clippy/tests/ui/octal_escapes.rs
@@ -2,20 +2,29 @@
 #![warn(clippy::octal_escapes)]
 
 fn main() {
-    let _bad1 = "\033[0m"; //~ octal_escapes
-    let _bad2 = b"\033[0m"; //~ octal_escapes
-    let _bad3 = "\\\033[0m"; //~ octal_escapes
+    let _bad1 = "\033[0m";
+    //~^ octal_escapes
+    let _bad2 = b"\033[0m";
+    //~^ octal_escapes
+    let _bad3 = "\\\033[0m";
+    //~^ octal_escapes
     // maximum 3 digits (\012 is the escape)
-    let _bad4 = "\01234567"; //~ octal_escapes
-    let _bad5 = "\0\03"; //~ octal_escapes
+    let _bad4 = "\01234567";
+    //~^ octal_escapes
+    let _bad5 = "\0\03";
+    //~^ octal_escapes
     let _bad6 = "Text-\055\077-MoreText";
     //~^ octal_escapes
     //~| octal_escapes
+
     let _bad7 = "EvenMoreText-\01\02-ShortEscapes";
     //~^ octal_escapes
     //~| octal_escapes
-    let _bad8 = "锈\01锈"; //~ octal_escapes
-    let _bad9 = "锈\011锈"; //~ octal_escapes
+
+    let _bad8 = "锈\01锈";
+    //~^ octal_escapes
+    let _bad9 = "锈\011锈";
+    //~^ octal_escapes
 
     let _good1 = "\\033[0m";
     let _good2 = "\0\\0";
diff --git a/src/tools/clippy/tests/ui/octal_escapes.stderr b/src/tools/clippy/tests/ui/octal_escapes.stderr
index 61c781e316ef..5271c13c08bd 100644
--- a/src/tools/clippy/tests/ui/octal_escapes.stderr
+++ b/src/tools/clippy/tests/ui/octal_escapes.stderr
@@ -18,7 +18,7 @@ LL |     let _bad1 = "\x0033[0m";
    |                   ++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:6:19
+  --> tests/ui/octal_escapes.rs:7:19
    |
 LL |     let _bad2 = b"\033[0m";
    |                   ^^^^
@@ -34,7 +34,7 @@ LL |     let _bad2 = b"\x0033[0m";
    |                    ++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:7:20
+  --> tests/ui/octal_escapes.rs:9:20
    |
 LL |     let _bad3 = "\\\033[0m";
    |                    ^^^^
@@ -50,7 +50,7 @@ LL |     let _bad3 = "\\\x0033[0m";
    |                     ++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:9:18
+  --> tests/ui/octal_escapes.rs:12:18
    |
 LL |     let _bad4 = "\01234567";
    |                  ^^^^
@@ -66,7 +66,7 @@ LL |     let _bad4 = "\x001234567";
    |                   ++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:10:20
+  --> tests/ui/octal_escapes.rs:14:20
    |
 LL |     let _bad5 = "\0\03";
    |                    ^^^
@@ -81,7 +81,7 @@ LL |     let _bad5 = "\0\x0003";
    |                     +++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:11:23
+  --> tests/ui/octal_escapes.rs:16:23
    |
 LL |     let _bad6 = "Text-\055\077-MoreText";
    |                       ^^^^
@@ -97,7 +97,7 @@ LL |     let _bad6 = "Text-\x0055\077-MoreText";
    |                        ++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:11:27
+  --> tests/ui/octal_escapes.rs:16:27
    |
 LL |     let _bad6 = "Text-\055\077-MoreText";
    |                           ^^^^
@@ -113,7 +113,7 @@ LL |     let _bad6 = "Text-\055\x0077-MoreText";
    |                            ++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:14:31
+  --> tests/ui/octal_escapes.rs:20:31
    |
 LL |     let _bad7 = "EvenMoreText-\01\02-ShortEscapes";
    |                               ^^^
@@ -128,7 +128,7 @@ LL |     let _bad7 = "EvenMoreText-\x0001\02-ShortEscapes";
    |                                +++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:14:34
+  --> tests/ui/octal_escapes.rs:20:34
    |
 LL |     let _bad7 = "EvenMoreText-\01\02-ShortEscapes";
    |                                  ^^^
@@ -143,7 +143,7 @@ LL |     let _bad7 = "EvenMoreText-\01\x0002-ShortEscapes";
    |                                   +++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:17:19
+  --> tests/ui/octal_escapes.rs:24:19
    |
 LL |     let _bad8 = "锈\01锈";
    |                    ^^^
@@ -158,7 +158,7 @@ LL |     let _bad8 = "锈\x0001锈";
    |                     +++
 
 error: octal-looking escape in a literal
-  --> tests/ui/octal_escapes.rs:18:19
+  --> tests/ui/octal_escapes.rs:26:19
    |
 LL |     let _bad9 = "锈\011锈";
    |                    ^^^^
diff --git a/src/tools/clippy/tests/ui/ok_expect.rs b/src/tools/clippy/tests/ui/ok_expect.rs
index c2ad21e22ff8..efb56f242a74 100644
--- a/src/tools/clippy/tests/ui/ok_expect.rs
+++ b/src/tools/clippy/tests/ui/ok_expect.rs
@@ -14,21 +14,25 @@ fn main() {
     let _ = res.unwrap();
 
     res.ok().expect("disaster!");
-    //~^ ERROR: called `ok().expect()` on a `Result` value
+    //~^ ok_expect
+
     // the following should not warn, since `expect` isn't implemented unless
     // the error type implements `Debug`
     let res2: Result<i32, MyError> = Ok(0);
     res2.ok().expect("oh noes!");
     let res3: Result<u32, MyErrorWithParam<u8>> = Ok(0);
     res3.ok().expect("whoof");
-    //~^ ERROR: called `ok().expect()` on a `Result` value
+    //~^ ok_expect
+
     let res4: Result<u32, io::Error> = Ok(0);
     res4.ok().expect("argh");
-    //~^ ERROR: called `ok().expect()` on a `Result` value
+    //~^ ok_expect
+
     let res5: io::Result<u32> = Ok(0);
     res5.ok().expect("oops");
-    //~^ ERROR: called `ok().expect()` on a `Result` value
+    //~^ ok_expect
+
     let res6: Result<u32, &str> = Ok(0);
     res6.ok().expect("meh");
-    //~^ ERROR: called `ok().expect()` on a `Result` value
+    //~^ ok_expect
 }
diff --git a/src/tools/clippy/tests/ui/ok_expect.stderr b/src/tools/clippy/tests/ui/ok_expect.stderr
index 2fd4f007d06d..a9e3533d8ca1 100644
--- a/src/tools/clippy/tests/ui/ok_expect.stderr
+++ b/src/tools/clippy/tests/ui/ok_expect.stderr
@@ -9,7 +9,7 @@ LL |     res.ok().expect("disaster!");
    = help: to override `-D warnings` add `#[allow(clippy::ok_expect)]`
 
 error: called `ok().expect()` on a `Result` value
-  --> tests/ui/ok_expect.rs:23:5
+  --> tests/ui/ok_expect.rs:24:5
    |
 LL |     res3.ok().expect("whoof");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     res3.ok().expect("whoof");
    = help: you can call `expect()` directly on the `Result`
 
 error: called `ok().expect()` on a `Result` value
-  --> tests/ui/ok_expect.rs:26:5
+  --> tests/ui/ok_expect.rs:28:5
    |
 LL |     res4.ok().expect("argh");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     res4.ok().expect("argh");
    = help: you can call `expect()` directly on the `Result`
 
 error: called `ok().expect()` on a `Result` value
-  --> tests/ui/ok_expect.rs:29:5
+  --> tests/ui/ok_expect.rs:32:5
    |
 LL |     res5.ok().expect("oops");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     res5.ok().expect("oops");
    = help: you can call `expect()` directly on the `Result`
 
 error: called `ok().expect()` on a `Result` value
-  --> tests/ui/ok_expect.rs:32:5
+  --> tests/ui/ok_expect.rs:36:5
    |
 LL |     res6.ok().expect("meh");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/only_used_in_recursion.rs b/src/tools/clippy/tests/ui/only_used_in_recursion.rs
index 169fb790f8c5..7d6075ba9ea4 100644
--- a/src/tools/clippy/tests/ui/only_used_in_recursion.rs
+++ b/src/tools/clippy/tests/ui/only_used_in_recursion.rs
@@ -9,18 +9,21 @@ fn _simple2(x: u32) -> u32 {
 }
 
 fn _one_unused(flag: u32, a: usize) -> usize {
-    //~^ ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+
     if flag == 0 { 0 } else { _one_unused(flag - 1, a) }
 }
 
 fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
-    //~^ ERROR: parameter is only used in recursion
-    //~| ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+    //~| only_used_in_recursion
+
     if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
 }
 
 fn _with_calc(flag: u32, a: i64) -> usize {
-    //~^ ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+
     if flag == 0 {
         0
     } else {
@@ -34,8 +37,9 @@ fn _used_with_flag(flag: u32, a: u32) -> usize {
 }
 
 fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
-    //~^ ERROR: parameter is only used in recursion
-    //~| ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+    //~| only_used_in_recursion
+
     if flag == 0 {
         0
     } else {
@@ -44,8 +48,9 @@ fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
 }
 
 fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
-    //~^ ERROR: parameter is only used in recursion
-    //~| ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+    //~| only_used_in_recursion
+
     if flag == 0 {
         0
     } else {
@@ -54,7 +59,8 @@ fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
 }
 
 fn _not_primitive(flag: u32, b: String) -> usize {
-    //~^ ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+
     if flag == 0 { 0 } else { _not_primitive(flag - 1, b) }
 }
 
@@ -62,13 +68,15 @@ struct A;
 
 impl A {
     fn _method(flag: usize, a: usize) -> usize {
-        //~^ ERROR: parameter is only used in recursion
+        //~^ only_used_in_recursion
+
         if flag == 0 { 0 } else { Self::_method(flag - 1, a) }
     }
 
     fn _method_self(&self, flag: usize, a: usize) -> usize {
-        //~^ ERROR: parameter is only used in recursion
-        //~| ERROR: parameter is only used in recursion
+        //~^ only_used_in_recursion
+        //~| only_used_in_recursion
+
         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
     }
 }
@@ -80,12 +88,14 @@ trait B {
 
 impl B for A {
     fn method(flag: u32, a: usize) -> usize {
-        //~^ ERROR: parameter is only used in recursion
+        //~^ only_used_in_recursion
+
         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
     }
 
     fn method_self(&self, flag: u32, a: usize) -> usize {
-        //~^ ERROR: parameter is only used in recursion
+        //~^ only_used_in_recursion
+
         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
     }
 }
@@ -112,12 +122,14 @@ impl B for u32 {
 
 trait C {
     fn method(flag: u32, a: usize) -> usize {
-        //~^ ERROR: parameter is only used in recursion
+        //~^ only_used_in_recursion
+
         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
     }
 
     fn method_self(&self, flag: u32, a: usize) -> usize {
-        //~^ ERROR: parameter is only used in recursion
+        //~^ only_used_in_recursion
+
         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
     }
 }
diff --git a/src/tools/clippy/tests/ui/only_used_in_recursion.stderr b/src/tools/clippy/tests/ui/only_used_in_recursion.stderr
index a3aee2697f38..ca08319e1120 100644
--- a/src/tools/clippy/tests/ui/only_used_in_recursion.stderr
+++ b/src/tools/clippy/tests/ui/only_used_in_recursion.stderr
@@ -5,7 +5,7 @@ LL | fn _one_unused(flag: u32, a: usize) -> usize {
    |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:13:53
+  --> tests/ui/only_used_in_recursion.rs:14:53
    |
 LL |     if flag == 0 { 0 } else { _one_unused(flag - 1, a) }
    |                                                     ^
@@ -13,181 +13,181 @@ LL |     if flag == 0 { 0 } else { _one_unused(flag - 1, a) }
    = help: to override `-D warnings` add `#[allow(clippy::only_used_in_recursion)]`
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:16:27
+  --> tests/ui/only_used_in_recursion.rs:17:27
    |
 LL | fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
    |                           ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:19:53
+  --> tests/ui/only_used_in_recursion.rs:21:53
    |
 LL |     if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
    |                                                     ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:16:35
+  --> tests/ui/only_used_in_recursion.rs:17:35
    |
 LL | fn _two_unused(flag: u32, a: u32, b: i32) -> usize {
    |                                   ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:19:56
+  --> tests/ui/only_used_in_recursion.rs:21:56
    |
 LL |     if flag == 0 { 0 } else { _two_unused(flag - 1, a, b) }
    |                                                        ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:22:26
+  --> tests/ui/only_used_in_recursion.rs:24:26
    |
 LL | fn _with_calc(flag: u32, a: i64) -> usize {
    |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:27:32
+  --> tests/ui/only_used_in_recursion.rs:30:32
    |
 LL |         _with_calc(flag - 1, (-a + 10) * 5)
    |                                ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:36:33
+  --> tests/ui/only_used_in_recursion.rs:39:33
    |
 LL | fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                 ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:42:38
+  --> tests/ui/only_used_in_recursion.rs:46:38
    |
 LL |         _used_with_unused(flag - 1, -a, a + b)
    |                                      ^  ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:36:41
+  --> tests/ui/only_used_in_recursion.rs:39:41
    |
 LL | fn _used_with_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                         ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:42:45
+  --> tests/ui/only_used_in_recursion.rs:46:45
    |
 LL |         _used_with_unused(flag - 1, -a, a + b)
    |                                             ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:46:35
+  --> tests/ui/only_used_in_recursion.rs:50:35
    |
 LL | fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                   ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:52:39
+  --> tests/ui/only_used_in_recursion.rs:57:39
    |
 LL |         _codependent_unused(flag - 1, a * b, a + b)
    |                                       ^      ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:46:43
+  --> tests/ui/only_used_in_recursion.rs:50:43
    |
 LL | fn _codependent_unused(flag: u32, a: i32, b: i32) -> usize {
    |                                           ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:52:43
+  --> tests/ui/only_used_in_recursion.rs:57:43
    |
 LL |         _codependent_unused(flag - 1, a * b, a + b)
    |                                           ^      ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:56:30
+  --> tests/ui/only_used_in_recursion.rs:61:30
    |
 LL | fn _not_primitive(flag: u32, b: String) -> usize {
    |                              ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:58:56
+  --> tests/ui/only_used_in_recursion.rs:64:56
    |
 LL |     if flag == 0 { 0 } else { _not_primitive(flag - 1, b) }
    |                                                        ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:64:29
+  --> tests/ui/only_used_in_recursion.rs:70:29
    |
 LL |     fn _method(flag: usize, a: usize) -> usize {
    |                             ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:66:59
+  --> tests/ui/only_used_in_recursion.rs:73:59
    |
 LL |         if flag == 0 { 0 } else { Self::_method(flag - 1, a) }
    |                                                           ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:69:22
+  --> tests/ui/only_used_in_recursion.rs:76:22
    |
 LL |     fn _method_self(&self, flag: usize, a: usize) -> usize {
    |                      ^^^^
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:72:35
+  --> tests/ui/only_used_in_recursion.rs:80:35
    |
 LL |         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
    |                                   ^^^^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:69:41
+  --> tests/ui/only_used_in_recursion.rs:76:41
    |
 LL |     fn _method_self(&self, flag: usize, a: usize) -> usize {
    |                                         ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:72:63
+  --> tests/ui/only_used_in_recursion.rs:80:63
    |
 LL |         if flag == 0 { 0 } else { self._method_self(flag - 1, a) }
    |                                                               ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:82:26
+  --> tests/ui/only_used_in_recursion.rs:90:26
    |
 LL |     fn method(flag: u32, a: usize) -> usize {
    |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:84:58
+  --> tests/ui/only_used_in_recursion.rs:93:58
    |
 LL |         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
    |                                                          ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:87:38
+  --> tests/ui/only_used_in_recursion.rs:96:38
    |
 LL |     fn method_self(&self, flag: u32, a: usize) -> usize {
    |                                      ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:89:62
+  --> tests/ui/only_used_in_recursion.rs:99:62
    |
 LL |         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
    |                                                              ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:114:26
+  --> tests/ui/only_used_in_recursion.rs:124:26
    |
 LL |     fn method(flag: u32, a: usize) -> usize {
    |                          ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:116:58
+  --> tests/ui/only_used_in_recursion.rs:127:58
    |
 LL |         if flag == 0 { 0 } else { Self::method(flag - 1, a) }
    |                                                          ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion.rs:119:38
+  --> tests/ui/only_used_in_recursion.rs:130:38
    |
 LL |     fn method_self(&self, flag: u32, a: usize) -> usize {
    |                                      ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion.rs:121:62
+  --> tests/ui/only_used_in_recursion.rs:133:62
    |
 LL |         if flag == 0 { 0 } else { self.method_self(flag - 1, a) }
    |                                                              ^
diff --git a/src/tools/clippy/tests/ui/only_used_in_recursion2.rs b/src/tools/clippy/tests/ui/only_used_in_recursion2.rs
index 1353ff8816ad..2fe4e7b35d38 100644
--- a/src/tools/clippy/tests/ui/only_used_in_recursion2.rs
+++ b/src/tools/clippy/tests/ui/only_used_in_recursion2.rs
@@ -1,9 +1,11 @@
 #![warn(clippy::only_used_in_recursion)]
 //@no-rustfix
 fn _with_inner(flag: u32, a: u32, b: u32) -> usize {
-    //~^ ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+
     fn inner(flag: u32, a: u32) -> u32 {
-        //~^ ERROR: parameter is only used in recursion
+        //~^ only_used_in_recursion
+
         if flag == 0 { 0 } else { inner(flag, a) }
     }
 
@@ -12,7 +14,8 @@ fn _with_inner(flag: u32, a: u32, b: u32) -> usize {
 }
 
 fn _with_closure(a: Option<u32>, b: u32, f: impl Fn(u32, u32) -> Option<u32>) -> u32 {
-    //~^ ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+
     if let Some(x) = a.and_then(|x| f(x, x)) {
         _with_closure(Some(x), b, f)
     } else {
@@ -63,7 +66,8 @@ impl E<()> for () {
 }
 
 fn overwritten_param(flag: u32, mut a: usize) -> usize {
-    //~^ ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+
     if flag == 0 {
         return 0;
     } else if flag > 5 {
@@ -75,7 +79,8 @@ fn overwritten_param(flag: u32, mut a: usize) -> usize {
 }
 
 fn field_direct(flag: u32, mut a: (usize,)) -> usize {
-    //~^ ERROR: parameter is only used in recursion
+    //~^ only_used_in_recursion
+
     if flag == 0 {
         0
     } else {
diff --git a/src/tools/clippy/tests/ui/only_used_in_recursion2.stderr b/src/tools/clippy/tests/ui/only_used_in_recursion2.stderr
index e39460c7e8f3..a7cd8713cf7a 100644
--- a/src/tools/clippy/tests/ui/only_used_in_recursion2.stderr
+++ b/src/tools/clippy/tests/ui/only_used_in_recursion2.stderr
@@ -5,7 +5,7 @@ LL | fn _with_inner(flag: u32, a: u32, b: u32) -> usize {
    |                                   ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion2.rs:11:52
+  --> tests/ui/only_used_in_recursion2.rs:13:52
    |
 LL |     if flag == 0 { 0 } else { _with_inner(flag, a, b + x) }
    |                                                    ^
@@ -13,49 +13,49 @@ LL |     if flag == 0 { 0 } else { _with_inner(flag, a, b + x) }
    = help: to override `-D warnings` add `#[allow(clippy::only_used_in_recursion)]`
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion2.rs:5:25
+  --> tests/ui/only_used_in_recursion2.rs:6:25
    |
 LL |     fn inner(flag: u32, a: u32) -> u32 {
    |                         ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion2.rs:7:47
+  --> tests/ui/only_used_in_recursion2.rs:9:47
    |
 LL |         if flag == 0 { 0 } else { inner(flag, a) }
    |                                               ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion2.rs:14:34
+  --> tests/ui/only_used_in_recursion2.rs:16:34
    |
 LL | fn _with_closure(a: Option<u32>, b: u32, f: impl Fn(u32, u32) -> Option<u32>) -> u32 {
    |                                  ^ help: if this is intentional, prefix it with an underscore: `_b`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion2.rs:17:32
+  --> tests/ui/only_used_in_recursion2.rs:20:32
    |
 LL |         _with_closure(Some(x), b, f)
    |                                ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion2.rs:65:37
+  --> tests/ui/only_used_in_recursion2.rs:68:37
    |
 LL | fn overwritten_param(flag: u32, mut a: usize) -> usize {
    |                                     ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion2.rs:74:29
+  --> tests/ui/only_used_in_recursion2.rs:78:29
    |
 LL |     overwritten_param(flag, a)
    |                             ^
 
 error: parameter is only used in recursion
-  --> tests/ui/only_used_in_recursion2.rs:77:32
+  --> tests/ui/only_used_in_recursion2.rs:81:32
    |
 LL | fn field_direct(flag: u32, mut a: (usize,)) -> usize {
    |                                ^ help: if this is intentional, prefix it with an underscore: `_a`
    |
 note: parameter used here
-  --> tests/ui/only_used_in_recursion2.rs:83:32
+  --> tests/ui/only_used_in_recursion2.rs:88:32
    |
 LL |         field_direct(flag - 1, a)
    |                                ^
diff --git a/src/tools/clippy/tests/ui/op_ref.fixed b/src/tools/clippy/tests/ui/op_ref.fixed
index 183dcf4f0863..46a59e419cce 100644
--- a/src/tools/clippy/tests/ui/op_ref.fixed
+++ b/src/tools/clippy/tests/ui/op_ref.fixed
@@ -9,8 +9,7 @@ fn main() {
     let unwanted = &tracked_fds - &new_fds;
 
     let foo = 5 - 6;
-    //~^ ERROR: needlessly taken reference of both operands
-    //~| NOTE: `-D clippy::op-ref` implied by `-D warnings`
+    //~^ op_ref
 
     let bar = String::new();
     let bar = "foo" == &bar;
@@ -56,7 +55,7 @@ fn main() {
     let x = Y(1);
     let y = Y(2);
     let z = x & y;
-    //~^ ERROR: taken reference of right operand
+    //~^ op_ref
 }
 
 #[derive(Clone, Copy)]
@@ -90,9 +89,11 @@ impl Mul<A> for A {
         let two = 2;
         let three = 3;
         let _ = one * self;
-        //~^ ERROR: taken reference of right operand
+        //~^ op_ref
+
         let _ = two + three;
-        //~^ ERROR: taken reference of right operand
+        //~^ op_ref
+
         // Removing the reference would lead to unconditional recursion
         self * &rhs
     }
diff --git a/src/tools/clippy/tests/ui/op_ref.rs b/src/tools/clippy/tests/ui/op_ref.rs
index 6ed4f23d2bd7..e10840ff4b97 100644
--- a/src/tools/clippy/tests/ui/op_ref.rs
+++ b/src/tools/clippy/tests/ui/op_ref.rs
@@ -9,8 +9,7 @@ fn main() {
     let unwanted = &tracked_fds - &new_fds;
 
     let foo = &5 - &6;
-    //~^ ERROR: needlessly taken reference of both operands
-    //~| NOTE: `-D clippy::op-ref` implied by `-D warnings`
+    //~^ op_ref
 
     let bar = String::new();
     let bar = "foo" == &bar;
@@ -56,7 +55,7 @@ fn main() {
     let x = Y(1);
     let y = Y(2);
     let z = x & &y;
-    //~^ ERROR: taken reference of right operand
+    //~^ op_ref
 }
 
 #[derive(Clone, Copy)]
@@ -90,9 +89,11 @@ impl Mul<A> for A {
         let two = 2;
         let three = 3;
         let _ = one * &self;
-        //~^ ERROR: taken reference of right operand
+        //~^ op_ref
+
         let _ = two + &three;
-        //~^ ERROR: taken reference of right operand
+        //~^ op_ref
+
         // Removing the reference would lead to unconditional recursion
         self * &rhs
     }
diff --git a/src/tools/clippy/tests/ui/op_ref.stderr b/src/tools/clippy/tests/ui/op_ref.stderr
index ad002437c0c6..51c2963a9eed 100644
--- a/src/tools/clippy/tests/ui/op_ref.stderr
+++ b/src/tools/clippy/tests/ui/op_ref.stderr
@@ -13,7 +13,7 @@ LL +     let foo = 5 - 6;
    |
 
 error: taken reference of right operand
-  --> tests/ui/op_ref.rs:58:13
+  --> tests/ui/op_ref.rs:57:13
    |
 LL |     let z = x & &y;
    |             ^^^^--
@@ -21,7 +21,7 @@ LL |     let z = x & &y;
    |                 help: use the right value directly: `y`
 
 error: taken reference of right operand
-  --> tests/ui/op_ref.rs:92:17
+  --> tests/ui/op_ref.rs:91:17
    |
 LL |         let _ = one * &self;
    |                 ^^^^^^-----
diff --git a/src/tools/clippy/tests/ui/open_options.rs b/src/tools/clippy/tests/ui/open_options.rs
index 4acb3780df43..f2f6e6edb4de 100644
--- a/src/tools/clippy/tests/ui/open_options.rs
+++ b/src/tools/clippy/tests/ui/open_options.rs
@@ -15,28 +15,31 @@ impl OpenOptionsExt for OpenOptions {
 
 fn main() {
     OpenOptions::new().read(true).truncate(true).open("foo.txt");
-    //~^ ERROR: file opened with `truncate` and `read`
-    //~| NOTE: `-D clippy::nonsensical-open-options` implied by `-D warnings`
+    //~^ nonsensical_open_options
+
     OpenOptions::new().append(true).truncate(true).open("foo.txt");
-    //~^ ERROR: file opened with `append` and `truncate`
+    //~^ nonsensical_open_options
 
     OpenOptions::new().read(true).read(false).open("foo.txt");
-    //~^ ERROR: the method `read` is called more than once
+    //~^ nonsensical_open_options
+
     OpenOptions::new()
         .create(true)
         .truncate(true) // Ensure we don't trigger suspicious open options by having create without truncate
         .create(false)
-        //~^ ERROR: the method `create` is called more than once
+        //~^ nonsensical_open_options
         .open("foo.txt");
     OpenOptions::new().write(true).write(false).open("foo.txt");
-    //~^ ERROR: the method `write` is called more than once
+    //~^ nonsensical_open_options
+
     OpenOptions::new().append(true).append(false).open("foo.txt");
-    //~^ ERROR: the method `append` is called more than once
+    //~^ nonsensical_open_options
+
     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
-    //~^ ERROR: the method `truncate` is called more than once
+    //~^ nonsensical_open_options
 
     std::fs::File::options().read(true).read(false).open("foo.txt");
-    //~^ ERROR: the method `read` is called more than once
+    //~^ nonsensical_open_options
 
     let mut options = std::fs::OpenOptions::new();
     options.read(true);
diff --git a/src/tools/clippy/tests/ui/open_options.stderr b/src/tools/clippy/tests/ui/open_options.stderr
index 19755bce46c8..11b2d55fa058 100644
--- a/src/tools/clippy/tests/ui/open_options.stderr
+++ b/src/tools/clippy/tests/ui/open_options.stderr
@@ -20,31 +20,31 @@ LL |     OpenOptions::new().read(true).read(false).open("foo.txt");
    |                                   ^^^^^^^^^^^
 
 error: the method `create` is called more than once
-  --> tests/ui/open_options.rs:28:10
+  --> tests/ui/open_options.rs:29:10
    |
 LL |         .create(false)
    |          ^^^^^^^^^^^^^
 
 error: the method `write` is called more than once
-  --> tests/ui/open_options.rs:31:36
+  --> tests/ui/open_options.rs:32:36
    |
 LL |     OpenOptions::new().write(true).write(false).open("foo.txt");
    |                                    ^^^^^^^^^^^^
 
 error: the method `append` is called more than once
-  --> tests/ui/open_options.rs:33:37
+  --> tests/ui/open_options.rs:35:37
    |
 LL |     OpenOptions::new().append(true).append(false).open("foo.txt");
    |                                     ^^^^^^^^^^^^^
 
 error: the method `truncate` is called more than once
-  --> tests/ui/open_options.rs:35:39
+  --> tests/ui/open_options.rs:38:39
    |
 LL |     OpenOptions::new().truncate(true).truncate(false).open("foo.txt");
    |                                       ^^^^^^^^^^^^^^^
 
 error: the method `read` is called more than once
-  --> tests/ui/open_options.rs:38:41
+  --> tests/ui/open_options.rs:41:41
    |
 LL |     std::fs::File::options().read(true).read(false).open("foo.txt");
    |                                         ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/open_options_fixable.fixed b/src/tools/clippy/tests/ui/open_options_fixable.fixed
index 90a129a9bdff..7f601eec2cf0 100644
--- a/src/tools/clippy/tests/ui/open_options_fixable.fixed
+++ b/src/tools/clippy/tests/ui/open_options_fixable.fixed
@@ -3,5 +3,5 @@ use std::fs::OpenOptions;
 #[warn(clippy::suspicious_open_options)]
 fn main() {
     OpenOptions::new().create(true).truncate(true).open("foo.txt");
-    //~^ ERROR: file opened with `create`, but `truncate` behavior not defined
+    //~^ suspicious_open_options
 }
diff --git a/src/tools/clippy/tests/ui/open_options_fixable.rs b/src/tools/clippy/tests/ui/open_options_fixable.rs
index 3a9e522ba150..5f03528d7a56 100644
--- a/src/tools/clippy/tests/ui/open_options_fixable.rs
+++ b/src/tools/clippy/tests/ui/open_options_fixable.rs
@@ -3,5 +3,5 @@ use std::fs::OpenOptions;
 #[warn(clippy::suspicious_open_options)]
 fn main() {
     OpenOptions::new().create(true).open("foo.txt");
-    //~^ ERROR: file opened with `create`, but `truncate` behavior not defined
+    //~^ suspicious_open_options
 }
diff --git a/src/tools/clippy/tests/ui/option_as_ref_cloned.fixed b/src/tools/clippy/tests/ui/option_as_ref_cloned.fixed
index 394dad219f77..cf21d1c0176e 100644
--- a/src/tools/clippy/tests/ui/option_as_ref_cloned.fixed
+++ b/src/tools/clippy/tests/ui/option_as_ref_cloned.fixed
@@ -5,10 +5,13 @@ fn main() {
     let mut x = Some(String::new());
 
     let _: Option<String> = x.clone();
+    //~^ option_as_ref_cloned
     let _: Option<String> = x.clone();
+    //~^ option_as_ref_cloned
 
     let y = x.as_ref();
     let _: Option<&String> = y.clone();
+    //~^ option_as_ref_cloned
 
     macro_rules! cloned_recv {
         () => {
diff --git a/src/tools/clippy/tests/ui/option_as_ref_cloned.rs b/src/tools/clippy/tests/ui/option_as_ref_cloned.rs
index 7243957927b2..354638c4c380 100644
--- a/src/tools/clippy/tests/ui/option_as_ref_cloned.rs
+++ b/src/tools/clippy/tests/ui/option_as_ref_cloned.rs
@@ -5,10 +5,13 @@ fn main() {
     let mut x = Some(String::new());
 
     let _: Option<String> = x.as_ref().cloned();
+    //~^ option_as_ref_cloned
     let _: Option<String> = x.as_mut().cloned();
+    //~^ option_as_ref_cloned
 
     let y = x.as_ref();
     let _: Option<&String> = y.as_ref().cloned();
+    //~^ option_as_ref_cloned
 
     macro_rules! cloned_recv {
         () => {
diff --git a/src/tools/clippy/tests/ui/option_as_ref_cloned.stderr b/src/tools/clippy/tests/ui/option_as_ref_cloned.stderr
index 0eda42b91b96..9f650b90d539 100644
--- a/src/tools/clippy/tests/ui/option_as_ref_cloned.stderr
+++ b/src/tools/clippy/tests/ui/option_as_ref_cloned.stderr
@@ -13,7 +13,7 @@ LL +     let _: Option<String> = x.clone();
    |
 
 error: cloning an `Option<_>` using `.as_mut().cloned()`
-  --> tests/ui/option_as_ref_cloned.rs:8:31
+  --> tests/ui/option_as_ref_cloned.rs:9:31
    |
 LL |     let _: Option<String> = x.as_mut().cloned();
    |                               ^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     let _: Option<String> = x.clone();
    |
 
 error: cloning an `Option<_>` using `.as_ref().cloned()`
-  --> tests/ui/option_as_ref_cloned.rs:11:32
+  --> tests/ui/option_as_ref_cloned.rs:13:32
    |
 LL |     let _: Option<&String> = y.as_ref().cloned();
    |                                ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/option_as_ref_deref.fixed b/src/tools/clippy/tests/ui/option_as_ref_deref.fixed
index c5a959ba566d..9be89b5d484f 100644
--- a/src/tools/clippy/tests/ui/option_as_ref_deref.fixed
+++ b/src/tools/clippy/tests/ui/option_as_ref_deref.fixed
@@ -9,25 +9,38 @@ fn main() {
     let mut opt = Some(String::from("123"));
 
     let _ = opt.clone().as_deref().map(str::len);
+    //~^ option_as_ref_deref
 
     #[rustfmt::skip]
     let _ = opt.clone().as_deref()
         .map(str::len);
 
     let _ = opt.as_deref_mut();
+    //~^ option_as_ref_deref
 
     let _ = opt.as_deref();
+    //~^ option_as_ref_deref
     let _ = opt.as_deref();
+    //~^ option_as_ref_deref
     let _ = opt.as_deref_mut();
+    //~^ option_as_ref_deref
     let _ = opt.as_deref_mut();
+    //~^ option_as_ref_deref
     let _ = Some(CString::new(vec![]).unwrap()).as_deref();
+    //~^ option_as_ref_deref
     let _ = Some(OsString::new()).as_deref();
+    //~^ option_as_ref_deref
     let _ = Some(PathBuf::new()).as_deref();
+    //~^ option_as_ref_deref
     let _ = Some(Vec::<()>::new()).as_deref();
+    //~^ option_as_ref_deref
     let _ = Some(Vec::<()>::new()).as_deref_mut();
+    //~^ option_as_ref_deref
 
     let _ = opt.as_deref();
+    //~^ option_as_ref_deref
     let _ = opt.clone().as_deref_mut().map(|x| x.len());
+    //~^ option_as_ref_deref
 
     let vc = vec![String::new()];
     let _ = Some(1_usize).as_ref().map(|x| vc[*x].as_str()); // should not be linted
@@ -35,10 +48,13 @@ fn main() {
     let _: Option<&str> = Some(&String::new()).as_ref().map(|x| x.as_str()); // should not be linted
 
     let _ = opt.as_deref();
+    //~^ option_as_ref_deref
     let _ = opt.as_deref_mut();
+    //~^ option_as_ref_deref
 
     // Issue #5927
     let _ = opt.as_deref();
+    //~^ option_as_ref_deref
 }
 
 #[clippy::msrv = "1.39"]
@@ -51,4 +67,5 @@ fn msrv_1_39() {
 fn msrv_1_40() {
     let opt = Some(String::from("123"));
     let _ = opt.as_deref();
+    //~^ option_as_ref_deref
 }
diff --git a/src/tools/clippy/tests/ui/option_as_ref_deref.rs b/src/tools/clippy/tests/ui/option_as_ref_deref.rs
index 1aeedf211fe2..d6b29e5e61b1 100644
--- a/src/tools/clippy/tests/ui/option_as_ref_deref.rs
+++ b/src/tools/clippy/tests/ui/option_as_ref_deref.rs
@@ -9,28 +9,42 @@ fn main() {
     let mut opt = Some(String::from("123"));
 
     let _ = opt.clone().as_ref().map(Deref::deref).map(str::len);
+    //~^ option_as_ref_deref
 
     #[rustfmt::skip]
     let _ = opt.clone()
+    //~^ option_as_ref_deref
         .as_ref().map(
             Deref::deref
         )
         .map(str::len);
 
     let _ = opt.as_mut().map(DerefMut::deref_mut);
+    //~^ option_as_ref_deref
 
     let _ = opt.as_ref().map(String::as_str);
+    //~^ option_as_ref_deref
     let _ = opt.as_ref().map(|x| x.as_str());
+    //~^ option_as_ref_deref
     let _ = opt.as_mut().map(String::as_mut_str);
+    //~^ option_as_ref_deref
     let _ = opt.as_mut().map(|x| x.as_mut_str());
+    //~^ option_as_ref_deref
     let _ = Some(CString::new(vec![]).unwrap()).as_ref().map(CString::as_c_str);
+    //~^ option_as_ref_deref
     let _ = Some(OsString::new()).as_ref().map(OsString::as_os_str);
+    //~^ option_as_ref_deref
     let _ = Some(PathBuf::new()).as_ref().map(PathBuf::as_path);
+    //~^ option_as_ref_deref
     let _ = Some(Vec::<()>::new()).as_ref().map(Vec::as_slice);
+    //~^ option_as_ref_deref
     let _ = Some(Vec::<()>::new()).as_mut().map(Vec::as_mut_slice);
+    //~^ option_as_ref_deref
 
     let _ = opt.as_ref().map(|x| x.deref());
+    //~^ option_as_ref_deref
     let _ = opt.clone().as_mut().map(|x| x.deref_mut()).map(|x| x.len());
+    //~^ option_as_ref_deref
 
     let vc = vec![String::new()];
     let _ = Some(1_usize).as_ref().map(|x| vc[*x].as_str()); // should not be linted
@@ -38,10 +52,13 @@ fn main() {
     let _: Option<&str> = Some(&String::new()).as_ref().map(|x| x.as_str()); // should not be linted
 
     let _ = opt.as_ref().map(|x| &**x);
+    //~^ option_as_ref_deref
     let _ = opt.as_mut().map(|x| &mut **x);
+    //~^ option_as_ref_deref
 
     // Issue #5927
     let _ = opt.as_ref().map(std::ops::Deref::deref);
+    //~^ option_as_ref_deref
 }
 
 #[clippy::msrv = "1.39"]
@@ -54,4 +71,5 @@ fn msrv_1_39() {
 fn msrv_1_40() {
     let opt = Some(String::from("123"));
     let _ = opt.as_ref().map(String::as_str);
+    //~^ option_as_ref_deref
 }
diff --git a/src/tools/clippy/tests/ui/option_as_ref_deref.stderr b/src/tools/clippy/tests/ui/option_as_ref_deref.stderr
index 8b7f47a1b9af..ca924aec66dd 100644
--- a/src/tools/clippy/tests/ui/option_as_ref_deref.stderr
+++ b/src/tools/clippy/tests/ui/option_as_ref_deref.stderr
@@ -8,107 +8,108 @@ LL |     let _ = opt.clone().as_ref().map(Deref::deref).map(str::len);
    = help: to override `-D warnings` add `#[allow(clippy::option_as_ref_deref)]`
 
 error: called `.as_ref().map(Deref::deref)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:14:13
+  --> tests/ui/option_as_ref_deref.rs:15:13
    |
 LL |       let _ = opt.clone()
    |  _____________^
+LL | |
 LL | |         .as_ref().map(
 LL | |             Deref::deref
 LL | |         )
    | |_________^ help: consider using as_deref: `opt.clone().as_deref()`
 
 error: called `.as_mut().map(DerefMut::deref_mut)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:20:13
+  --> tests/ui/option_as_ref_deref.rs:22:13
    |
 LL |     let _ = opt.as_mut().map(DerefMut::deref_mut);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref_mut: `opt.as_deref_mut()`
 
 error: called `.as_ref().map(String::as_str)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:22:13
+  --> tests/ui/option_as_ref_deref.rs:25:13
    |
 LL |     let _ = opt.as_ref().map(String::as_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `opt.as_deref()`
 
 error: called `.as_ref().map(|x| x.as_str())` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:23:13
+  --> tests/ui/option_as_ref_deref.rs:27:13
    |
 LL |     let _ = opt.as_ref().map(|x| x.as_str());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `opt.as_deref()`
 
 error: called `.as_mut().map(String::as_mut_str)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:24:13
+  --> tests/ui/option_as_ref_deref.rs:29:13
    |
 LL |     let _ = opt.as_mut().map(String::as_mut_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref_mut: `opt.as_deref_mut()`
 
 error: called `.as_mut().map(|x| x.as_mut_str())` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:25:13
+  --> tests/ui/option_as_ref_deref.rs:31:13
    |
 LL |     let _ = opt.as_mut().map(|x| x.as_mut_str());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref_mut: `opt.as_deref_mut()`
 
 error: called `.as_ref().map(CString::as_c_str)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:26:13
+  --> tests/ui/option_as_ref_deref.rs:33:13
    |
 LL |     let _ = Some(CString::new(vec![]).unwrap()).as_ref().map(CString::as_c_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `Some(CString::new(vec![]).unwrap()).as_deref()`
 
 error: called `.as_ref().map(OsString::as_os_str)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:27:13
+  --> tests/ui/option_as_ref_deref.rs:35:13
    |
 LL |     let _ = Some(OsString::new()).as_ref().map(OsString::as_os_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `Some(OsString::new()).as_deref()`
 
 error: called `.as_ref().map(PathBuf::as_path)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:28:13
+  --> tests/ui/option_as_ref_deref.rs:37:13
    |
 LL |     let _ = Some(PathBuf::new()).as_ref().map(PathBuf::as_path);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `Some(PathBuf::new()).as_deref()`
 
 error: called `.as_ref().map(Vec::as_slice)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:29:13
+  --> tests/ui/option_as_ref_deref.rs:39:13
    |
 LL |     let _ = Some(Vec::<()>::new()).as_ref().map(Vec::as_slice);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `Some(Vec::<()>::new()).as_deref()`
 
 error: called `.as_mut().map(Vec::as_mut_slice)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:30:13
+  --> tests/ui/option_as_ref_deref.rs:41:13
    |
 LL |     let _ = Some(Vec::<()>::new()).as_mut().map(Vec::as_mut_slice);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref_mut: `Some(Vec::<()>::new()).as_deref_mut()`
 
 error: called `.as_ref().map(|x| x.deref())` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:32:13
+  --> tests/ui/option_as_ref_deref.rs:44:13
    |
 LL |     let _ = opt.as_ref().map(|x| x.deref());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `opt.as_deref()`
 
 error: called `.as_mut().map(|x| x.deref_mut())` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:33:13
+  --> tests/ui/option_as_ref_deref.rs:46:13
    |
 LL |     let _ = opt.clone().as_mut().map(|x| x.deref_mut()).map(|x| x.len());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref_mut: `opt.clone().as_deref_mut()`
 
 error: called `.as_ref().map(|x| &**x)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:40:13
+  --> tests/ui/option_as_ref_deref.rs:54:13
    |
 LL |     let _ = opt.as_ref().map(|x| &**x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `opt.as_deref()`
 
 error: called `.as_mut().map(|x| &mut **x)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:41:13
+  --> tests/ui/option_as_ref_deref.rs:56:13
    |
 LL |     let _ = opt.as_mut().map(|x| &mut **x);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref_mut: `opt.as_deref_mut()`
 
 error: called `.as_ref().map(std::ops::Deref::deref)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:44:13
+  --> tests/ui/option_as_ref_deref.rs:60:13
    |
 LL |     let _ = opt.as_ref().map(std::ops::Deref::deref);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `opt.as_deref()`
 
 error: called `.as_ref().map(String::as_str)` on an `Option` value
-  --> tests/ui/option_as_ref_deref.rs:56:13
+  --> tests/ui/option_as_ref_deref.rs:73:13
    |
 LL |     let _ = opt.as_ref().map(String::as_str);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using as_deref: `opt.as_deref()`
diff --git a/src/tools/clippy/tests/ui/option_env_unwrap.rs b/src/tools/clippy/tests/ui/option_env_unwrap.rs
index f8d382340f2f..b8476830efe5 100644
--- a/src/tools/clippy/tests/ui/option_env_unwrap.rs
+++ b/src/tools/clippy/tests/ui/option_env_unwrap.rs
@@ -8,10 +8,18 @@ use proc_macros::{external, inline_macros};
 #[inline_macros]
 fn main() {
     let _ = option_env!("PATH").unwrap();
+    //~^ option_env_unwrap
     let _ = option_env!("PATH").expect("environment variable PATH isn't set");
+    //~^ option_env_unwrap
     let _ = option_env!("__Y__do_not_use").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in your environment.
+    //
+    //~^^ option_env_unwrap
     let _ = inline!(option_env!($"PATH").unwrap());
+    //~^ option_env_unwrap
     let _ = inline!(option_env!($"PATH").expect($"environment variable PATH isn't set"));
+    //~^ option_env_unwrap
     let _ = external!(option_env!($"PATH").unwrap());
+    //~^ option_env_unwrap
     let _ = external!(option_env!($"PATH").expect($"environment variable PATH isn't set"));
+    //~^ option_env_unwrap
 }
diff --git a/src/tools/clippy/tests/ui/option_env_unwrap.stderr b/src/tools/clippy/tests/ui/option_env_unwrap.stderr
index 169523269fbb..bbcbfedb7882 100644
--- a/src/tools/clippy/tests/ui/option_env_unwrap.stderr
+++ b/src/tools/clippy/tests/ui/option_env_unwrap.stderr
@@ -9,7 +9,7 @@ LL |     let _ = option_env!("PATH").unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::option_env_unwrap)]`
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> tests/ui/option_env_unwrap.rs:11:13
+  --> tests/ui/option_env_unwrap.rs:12:13
    |
 LL |     let _ = option_env!("PATH").expect("environment variable PATH isn't set");
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     let _ = option_env!("PATH").expect("environment variable PATH isn't set
    = help: consider using the `env!` macro instead
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> tests/ui/option_env_unwrap.rs:12:13
+  --> tests/ui/option_env_unwrap.rs:14:13
    |
 LL |     let _ = option_env!("__Y__do_not_use").unwrap(); // This test only works if you don't have a __Y__do_not_use env variable in your env...
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     let _ = option_env!("__Y__do_not_use").unwrap(); // This test only work
    = help: consider using the `env!` macro instead
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> tests/ui/option_env_unwrap.rs:13:21
+  --> tests/ui/option_env_unwrap.rs:17:21
    |
 LL |     let _ = inline!(option_env!($"PATH").unwrap());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL |     let _ = inline!(option_env!($"PATH").unwrap());
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> tests/ui/option_env_unwrap.rs:14:21
+  --> tests/ui/option_env_unwrap.rs:19:21
    |
 LL |     let _ = inline!(option_env!($"PATH").expect($"environment variable PATH isn't set"));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -43,7 +43,7 @@ LL |     let _ = inline!(option_env!($"PATH").expect($"environment variable PATH
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> tests/ui/option_env_unwrap.rs:15:13
+  --> tests/ui/option_env_unwrap.rs:21:13
    |
 LL |     let _ = external!(option_env!($"PATH").unwrap());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     let _ = external!(option_env!($"PATH").unwrap());
    = note: this error originates in the macro `external` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this will panic at run-time if the environment variable doesn't exist at compile-time
-  --> tests/ui/option_env_unwrap.rs:16:13
+  --> tests/ui/option_env_unwrap.rs:23:13
    |
 LL |     let _ = external!(option_env!($"PATH").expect($"environment variable PATH isn't set"));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/option_filter_map.fixed b/src/tools/clippy/tests/ui/option_filter_map.fixed
index b1c3cfa48a44..d390c41af53c 100644
--- a/src/tools/clippy/tests/ui/option_filter_map.fixed
+++ b/src/tools/clippy/tests/ui/option_filter_map.fixed
@@ -3,18 +3,23 @@
 
 fn main() {
     let _ = Some(Some(1)).flatten();
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = Some(Some(1)).flatten();
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = Some(1).map(odds_out).flatten();
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = Some(1).map(odds_out).flatten();
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
 
     let _ = vec![Some(1)].into_iter().flatten();
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = vec![Some(1)].into_iter().flatten();
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
diff --git a/src/tools/clippy/tests/ui/option_filter_map.rs b/src/tools/clippy/tests/ui/option_filter_map.rs
index 2550b9cd2b36..2d3b983a7670 100644
--- a/src/tools/clippy/tests/ui/option_filter_map.rs
+++ b/src/tools/clippy/tests/ui/option_filter_map.rs
@@ -3,29 +3,34 @@
 
 fn main() {
     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = Some(Some(1)).filter(|o| o.is_some()).map(|o| o.unwrap());
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = Some(1).map(odds_out).filter(Option::is_some).map(Option::unwrap);
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = Some(1).map(odds_out).filter(|o| o.is_some()).map(|o| o.unwrap());
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
 
     let _ = vec![Some(1)].into_iter().filter(Option::is_some).map(Option::unwrap);
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some()).map(|o| o.unwrap());
-    //~^ ERROR: `filter` for `Some` followed by `unwrap`
+    //~^ option_filter_map
+
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
         .filter(Option::is_some)
-        //~^ ERROR: `filter` for `Some` followed by `unwrap`
+        //~^ option_filter_map
         .map(Option::unwrap);
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
         .filter(|o| o.is_some())
-        //~^ ERROR: `filter` for `Some` followed by `unwrap`
+        //~^ option_filter_map
         .map(|o| o.unwrap());
 }
 
diff --git a/src/tools/clippy/tests/ui/option_filter_map.stderr b/src/tools/clippy/tests/ui/option_filter_map.stderr
index 401ac2b2296d..df3c1f9d47b8 100644
--- a/src/tools/clippy/tests/ui/option_filter_map.stderr
+++ b/src/tools/clippy/tests/ui/option_filter_map.stderr
@@ -8,37 +8,37 @@ LL |     let _ = Some(Some(1)).filter(Option::is_some).map(Option::unwrap);
    = help: to override `-D warnings` add `#[allow(clippy::option_filter_map)]`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> tests/ui/option_filter_map.rs:7:27
+  --> tests/ui/option_filter_map.rs:8:27
    |
 LL |     let _ = Some(Some(1)).filter(|o| o.is_some()).map(|o| o.unwrap());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> tests/ui/option_filter_map.rs:9:35
+  --> tests/ui/option_filter_map.rs:11:35
    |
 LL |     let _ = Some(1).map(odds_out).filter(Option::is_some).map(Option::unwrap);
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> tests/ui/option_filter_map.rs:11:35
+  --> tests/ui/option_filter_map.rs:14:35
    |
 LL |     let _ = Some(1).map(odds_out).filter(|o| o.is_some()).map(|o| o.unwrap());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> tests/ui/option_filter_map.rs:14:39
+  --> tests/ui/option_filter_map.rs:17:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(Option::is_some).map(Option::unwrap);
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> tests/ui/option_filter_map.rs:16:39
+  --> tests/ui/option_filter_map.rs:20:39
    |
 LL |     let _ = vec![Some(1)].into_iter().filter(|o| o.is_some()).map(|o| o.unwrap());
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> tests/ui/option_filter_map.rs:21:10
+  --> tests/ui/option_filter_map.rs:26:10
    |
 LL |           .filter(Option::is_some)
    |  __________^
@@ -47,7 +47,7 @@ LL | |         .map(Option::unwrap);
    | |____________________________^ help: consider using `flatten` instead: `flatten()`
 
 error: `filter` for `Some` followed by `unwrap`
-  --> tests/ui/option_filter_map.rs:27:10
+  --> tests/ui/option_filter_map.rs:32:10
    |
 LL |           .filter(|o| o.is_some())
    |  __________^
diff --git a/src/tools/clippy/tests/ui/option_if_let_else.fixed b/src/tools/clippy/tests/ui/option_if_let_else.fixed
index 0ac89bf0d8ea..f5a869cf2831 100644
--- a/src/tools/clippy/tests/ui/option_if_let_else.fixed
+++ b/src/tools/clippy/tests/ui/option_if_let_else.fixed
@@ -4,6 +4,7 @@
     clippy::equatable_if_let,
     clippy::let_unit_value,
     clippy::redundant_locals,
+    clippy::manual_midpoint,
     clippy::manual_unwrap_or_default,
     clippy::manual_unwrap_or
 )]
@@ -24,17 +25,23 @@ fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
 
 fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
     let _ = string.map_or(0, |s| s.len());
+    //~^ option_if_let_else
     let _ = num.as_ref().map_or(&0, |s| s);
+    //~^ option_if_let_else
     let _ = num.as_mut().map_or(&0, |s| {
+        //~^ option_if_let_else
         *s += 1;
         s
     });
     let _ = num.as_ref().map_or(&0, |s| s);
+    //~^ option_if_let_else
     let _ = num.map_or(0, |mut s| {
+        //~^ option_if_let_else
         s += 1;
         s
     });
     let _ = num.as_mut().map_or(&0, |s| {
+        //~^ option_if_let_else
         *s += 1;
         s
     });
@@ -42,6 +49,7 @@ fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
 
 fn longer_body(arg: Option<u32>) -> u32 {
     arg.map_or(13, |x| {
+        //~^ option_if_let_else
         let y = x * x;
         y * y
     })
@@ -98,6 +106,7 @@ fn test_result_impure_else(variable: Result<u32, &str>) -> bool {
         println!("Err");
         false
     }, |binding| {
+        //~^ option_if_let_else
         println!("Ok {binding}");
         true
     })
@@ -119,6 +128,7 @@ fn complex_subpat() -> DummyEnum {
 fn main() {
     let optional = Some(5);
     let _ = optional.map_or(5, |x| x + 2);
+    //~^ option_if_let_else
     let _ = bad1(None);
     let _ = else_if_option(None);
     unop_bad(&None, None);
@@ -153,10 +163,12 @@ fn main() {
     let s = String::new();
     // Lint, both branches immutably borrow `s`.
     let _ = Some(0).map_or(s.len(), |x| s.len() + x);
+    //~^ option_if_let_else
 
     let s = String::new();
     // Lint, `Some` branch consumes `s`, but else branch doesn't use `s`.
     let _ = Some(0).map_or(1, |x| {
+        //~^ option_if_let_else
         let s = s;
         s.len() + x
     });
@@ -200,6 +212,7 @@ fn main() {
     let _ = res.map_or(1, |a| a + 1);
     let _ = res.map_or(1, |a| a + 1);
     let _ = res.map_or(5, |a| a + 1);
+    //~^ option_if_let_else
 }
 
 #[allow(dead_code)]
@@ -243,6 +256,7 @@ fn issue11429() {
     let mut _hashmap = opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone());
 
     let mut _hm = opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone());
+    //~^ option_if_let_else
 }
 
 fn issue11893() {
diff --git a/src/tools/clippy/tests/ui/option_if_let_else.rs b/src/tools/clippy/tests/ui/option_if_let_else.rs
index b4f1b2cd1f7f..d48272e618ac 100644
--- a/src/tools/clippy/tests/ui/option_if_let_else.rs
+++ b/src/tools/clippy/tests/ui/option_if_let_else.rs
@@ -4,12 +4,14 @@
     clippy::equatable_if_let,
     clippy::let_unit_value,
     clippy::redundant_locals,
+    clippy::manual_midpoint,
     clippy::manual_unwrap_or_default,
     clippy::manual_unwrap_or
 )]
 
 fn bad1(string: Option<&str>) -> (bool, &str) {
     if let Some(x) = string {
+        //~^ option_if_let_else
         (true, x)
     } else {
         (false, "hello")
@@ -28,21 +30,27 @@ fn else_if_option(string: Option<&str>) -> Option<(bool, &str)> {
 
 fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
     let _ = if let Some(s) = *string { s.len() } else { 0 };
+    //~^ option_if_let_else
     let _ = if let Some(s) = &num { s } else { &0 };
+    //~^ option_if_let_else
     let _ = if let Some(s) = &mut num {
+        //~^ option_if_let_else
         *s += 1;
         s
     } else {
         &0
     };
     let _ = if let Some(ref s) = num { s } else { &0 };
+    //~^ option_if_let_else
     let _ = if let Some(mut s) = num {
+        //~^ option_if_let_else
         s += 1;
         s
     } else {
         0
     };
     let _ = if let Some(ref mut s) = num {
+        //~^ option_if_let_else
         *s += 1;
         s
     } else {
@@ -52,6 +60,7 @@ fn unop_bad(string: &Option<&str>, mut num: Option<i32>) {
 
 fn longer_body(arg: Option<u32>) -> u32 {
     if let Some(x) = arg {
+        //~^ option_if_let_else
         let y = x * x;
         y * y
     } else {
@@ -65,6 +74,7 @@ fn impure_else(arg: Option<i32>) {
         1
     };
     let _ = if let Some(x) = arg {
+        //~^ option_if_let_else
         x
     } else {
         // map_or_else must be suggested
@@ -74,6 +84,7 @@ fn impure_else(arg: Option<i32>) {
 
 fn test_map_or_else(arg: Option<u32>) {
     let _ = if let Some(x) = arg {
+        //~^ option_if_let_else
         x * x * x * x
     } else {
         let mut y = 1;
@@ -107,6 +118,7 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
         .split('/')
         .flat_map(|s| {
             if let Some(idx) = s.find('.') {
+                //~^ option_if_let_else
                 vec![s[..idx].to_string(), s[idx..].to_string()]
             } else {
                 vec![s.to_string()]
@@ -118,6 +130,7 @@ fn pattern_to_vec(pattern: &str) -> Vec<String> {
 // #10335
 fn test_result_impure_else(variable: Result<u32, &str>) -> bool {
     if let Ok(binding) = variable {
+        //~^ option_if_let_else
         println!("Ok {binding}");
         true
     } else {
@@ -142,6 +155,7 @@ fn complex_subpat() -> DummyEnum {
 fn main() {
     let optional = Some(5);
     let _ = if let Some(x) = optional { x + 2 } else { 5 };
+    //~^ option_if_let_else
     let _ = bad1(None);
     let _ = else_if_option(None);
     unop_bad(&None, None);
@@ -152,6 +166,7 @@ fn main() {
     let _ = impure_else(None);
 
     let _ = if let Some(x) = Some(0) {
+        //~^ option_if_let_else
         loop {
             if x == 0 {
                 break x;
@@ -180,10 +195,12 @@ fn main() {
     let s = String::new();
     // Lint, both branches immutably borrow `s`.
     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
+    //~^ option_if_let_else
 
     let s = String::new();
     // Lint, `Some` branch consumes `s`, but else branch doesn't use `s`.
     let _ = if let Some(x) = Some(0) {
+        //~^ option_if_let_else
         let s = s;
         s.len() + x
     } else {
@@ -223,24 +240,29 @@ fn main() {
 
     // issue #8492
     let _ = match s {
+        //~^ option_if_let_else
         Some(string) => string.len(),
         None => 1,
     };
     let _ = match Some(10) {
+        //~^ option_if_let_else
         Some(a) => a + 1,
         None => 5,
     };
 
     let res: Result<i32, i32> = Ok(5);
     let _ = match res {
+        //~^ option_if_let_else
         Ok(a) => a + 1,
         _ => 1,
     };
     let _ = match res {
+        //~^ option_if_let_else
         Err(_) => 1,
         Ok(a) => a + 1,
     };
     let _ = if let Ok(a) = res { a + 1 } else { 5 };
+    //~^ option_if_let_else
 }
 
 #[allow(dead_code)]
@@ -258,6 +280,7 @@ mod issue10729 {
     pub fn reproduce(initial: &Option<String>) {
         // 👇 needs `.as_ref()` because initial is an `&Option<_>`
         let _ = match initial {
+            //~^ option_if_let_else
             Some(value) => do_something(value),
             None => 42,
         };
@@ -265,6 +288,7 @@ mod issue10729 {
 
     pub fn reproduce2(initial: &mut Option<String>) {
         let _ = match initial {
+            //~^ option_if_let_else
             Some(value) => do_something2(value),
             None => 42,
         };
@@ -288,12 +312,14 @@ fn issue11429() {
     let opt: Option<HashMap<u8, u8>> = None;
 
     let mut _hashmap = if let Some(hm) = &opt {
+        //~^ option_if_let_else
         hm.clone()
     } else {
         HashMap::new()
     };
 
     let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
+    //~^ option_if_let_else
 }
 
 fn issue11893() {
diff --git a/src/tools/clippy/tests/ui/option_if_let_else.stderr b/src/tools/clippy/tests/ui/option_if_let_else.stderr
index 32ff22763234..9eb41f81a539 100644
--- a/src/tools/clippy/tests/ui/option_if_let_else.stderr
+++ b/src/tools/clippy/tests/ui/option_if_let_else.stderr
@@ -1,7 +1,8 @@
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:12:5
+  --> tests/ui/option_if_let_else.rs:13:5
    |
 LL | /     if let Some(x) = string {
+LL | |
 LL | |         (true, x)
 LL | |     } else {
 LL | |         (false, "hello")
@@ -12,22 +13,23 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::option_if_let_else)]`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:30:13
+  --> tests/ui/option_if_let_else.rs:32:13
    |
 LL |     let _ = if let Some(s) = *string { s.len() } else { 0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `string.map_or(0, |s| s.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:31:13
+  --> tests/ui/option_if_let_else.rs:34:13
    |
 LL |     let _ = if let Some(s) = &num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:32:13
+  --> tests/ui/option_if_let_else.rs:36:13
    |
 LL |       let _ = if let Some(s) = &mut num {
    |  _____________^
+LL | |
 LL | |         *s += 1;
 LL | |         s
 LL | |     } else {
@@ -38,22 +40,24 @@ LL | |     };
 help: try
    |
 LL ~     let _ = num.as_mut().map_or(&0, |s| {
+LL +
 LL +         *s += 1;
 LL +         s
 LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:38:13
+  --> tests/ui/option_if_let_else.rs:43:13
    |
 LL |     let _ = if let Some(ref s) = num { s } else { &0 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `num.as_ref().map_or(&0, |s| s)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:39:13
+  --> tests/ui/option_if_let_else.rs:45:13
    |
 LL |       let _ = if let Some(mut s) = num {
    |  _____________^
+LL | |
 LL | |         s += 1;
 LL | |         s
 LL | |     } else {
@@ -64,16 +68,18 @@ LL | |     };
 help: try
    |
 LL ~     let _ = num.map_or(0, |mut s| {
+LL +
 LL +         s += 1;
 LL +         s
 LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:45:13
+  --> tests/ui/option_if_let_else.rs:52:13
    |
 LL |       let _ = if let Some(ref mut s) = num {
    |  _____________^
+LL | |
 LL | |         *s += 1;
 LL | |         s
 LL | |     } else {
@@ -84,15 +90,17 @@ LL | |     };
 help: try
    |
 LL ~     let _ = num.as_mut().map_or(&0, |s| {
+LL +
 LL +         *s += 1;
 LL +         s
 LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:54:5
+  --> tests/ui/option_if_let_else.rs:62:5
    |
 LL | /     if let Some(x) = arg {
+LL | |
 LL | |         let y = x * x;
 LL | |         y * y
 LL | |     } else {
@@ -103,30 +111,33 @@ LL | |     }
 help: try
    |
 LL ~     arg.map_or(13, |x| {
+LL +
 LL +         let y = x * x;
 LL +         y * y
 LL +     })
    |
 
-error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:67:13
-   |
-LL |       let _ = if let Some(x) = arg {
-   |  _____________^
-LL | |         x
-LL | |     } else {
-...  |
-LL | |     };
-   | |_____^ help: try: `arg.map_or_else(side_effect, |x| x)`
-
 error: use Option::map_or_else instead of an if let/else
   --> tests/ui/option_if_let_else.rs:76:13
    |
 LL |       let _ = if let Some(x) = arg {
    |  _____________^
+LL | |
+LL | |         x
+LL | |     } else {
+LL | |         // map_or_else must be suggested
+LL | |         side_effect()
+LL | |     };
+   | |_____^ help: try: `arg.map_or_else(side_effect, |x| x)`
+
+error: use Option::map_or_else instead of an if let/else
+  --> tests/ui/option_if_let_else.rs:86:13
+   |
+LL |       let _ = if let Some(x) = arg {
+   |  _____________^
+LL | |
 LL | |         x * x * x * x
 LL | |     } else {
-LL | |         let mut y = 1;
 ...  |
 LL | |         y
 LL | |     };
@@ -143,9 +154,10 @@ LL ~     }, |x| x * x * x * x);
    |
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:109:13
+  --> tests/ui/option_if_let_else.rs:120:13
    |
 LL | /             if let Some(idx) = s.find('.') {
+LL | |
 LL | |                 vec![s[..idx].to_string(), s[idx..].to_string()]
 LL | |             } else {
 LL | |                 vec![s.to_string()]
@@ -153,13 +165,13 @@ LL | |             }
    | |_____________^ help: try: `s.find('.').map_or_else(|| vec![s.to_string()], |idx| vec![s[..idx].to_string(), s[idx..].to_string()])`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:120:5
+  --> tests/ui/option_if_let_else.rs:132:5
    |
 LL | /     if let Ok(binding) = variable {
+LL | |
 LL | |         println!("Ok {binding}");
 LL | |         true
-LL | |     } else {
-LL | |         println!("Err");
+...  |
 LL | |         false
 LL | |     }
    | |_____^
@@ -170,25 +182,26 @@ LL ~     variable.map_or_else(|_| {
 LL +         println!("Err");
 LL +         false
 LL +     }, |binding| {
+LL +
 LL +         println!("Ok {binding}");
 LL +         true
 LL +     })
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:144:13
+  --> tests/ui/option_if_let_else.rs:157:13
    |
 LL |     let _ = if let Some(x) = optional { x + 2 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `optional.map_or(5, |x| x + 2)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:154:13
+  --> tests/ui/option_if_let_else.rs:168:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
+LL | |
 LL | |         loop {
 LL | |             if x == 0 {
-LL | |                 break x;
 ...  |
 LL | |         0
 LL | |     };
@@ -204,16 +217,17 @@ LL ~         });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:182:13
+  --> tests/ui/option_if_let_else.rs:197:13
    |
 LL |     let _ = if let Some(x) = Some(0) { s.len() + x } else { s.len() };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(0).map_or(s.len(), |x| s.len() + x)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:186:13
+  --> tests/ui/option_if_let_else.rs:202:13
    |
 LL |       let _ = if let Some(x) = Some(0) {
    |  _____________^
+LL | |
 LL | |         let s = s;
 LL | |         s.len() + x
 LL | |     } else {
@@ -224,82 +238,90 @@ LL | |     };
 help: try
    |
 LL ~     let _ = Some(0).map_or(1, |x| {
+LL +
 LL +         let s = s;
 LL +         s.len() + x
 LL ~     });
    |
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:225:13
+  --> tests/ui/option_if_let_else.rs:242:13
    |
 LL |       let _ = match s {
    |  _____________^
+LL | |
 LL | |         Some(string) => string.len(),
 LL | |         None => 1,
 LL | |     };
    | |_____^ help: try: `s.map_or(1, |string| string.len())`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:229:13
+  --> tests/ui/option_if_let_else.rs:247:13
    |
 LL |       let _ = match Some(10) {
    |  _____________^
+LL | |
 LL | |         Some(a) => a + 1,
 LL | |         None => 5,
 LL | |     };
    | |_____^ help: try: `Some(10).map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:235:13
+  --> tests/ui/option_if_let_else.rs:254:13
    |
 LL |       let _ = match res {
    |  _____________^
+LL | |
 LL | |         Ok(a) => a + 1,
 LL | |         _ => 1,
 LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:239:13
+  --> tests/ui/option_if_let_else.rs:259:13
    |
 LL |       let _ = match res {
    |  _____________^
+LL | |
 LL | |         Err(_) => 1,
 LL | |         Ok(a) => a + 1,
 LL | |     };
    | |_____^ help: try: `res.map_or(1, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:243:13
+  --> tests/ui/option_if_let_else.rs:264:13
    |
 LL |     let _ = if let Ok(a) = res { a + 1 } else { 5 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `res.map_or(5, |a| a + 1)`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:260:17
+  --> tests/ui/option_if_let_else.rs:282:17
    |
 LL |           let _ = match initial {
    |  _________________^
+LL | |
 LL | |             Some(value) => do_something(value),
 LL | |             None => 42,
 LL | |         };
    | |_________^ help: try: `initial.as_ref().map_or(42, |value| do_something(value))`
 
 error: use Option::map_or instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:267:17
+  --> tests/ui/option_if_let_else.rs:290:17
    |
 LL |           let _ = match initial {
    |  _________________^
+LL | |
 LL | |             Some(value) => do_something2(value),
 LL | |             None => 42,
 LL | |         };
    | |_________^ help: try: `initial.as_mut().map_or(42, |value| do_something2(value))`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:290:24
+  --> tests/ui/option_if_let_else.rs:314:24
    |
 LL |       let mut _hashmap = if let Some(hm) = &opt {
    |  ________________________^
+LL | |
 LL | |         hm.clone()
 LL | |     } else {
 LL | |         HashMap::new()
@@ -307,7 +329,7 @@ LL | |     };
    | |_____^ help: try: `opt.as_ref().map_or_else(HashMap::new, |hm| hm.clone())`
 
 error: use Option::map_or_else instead of an if let/else
-  --> tests/ui/option_if_let_else.rs:296:19
+  --> tests/ui/option_if_let_else.rs:321:19
    |
 LL |     let mut _hm = if let Some(hm) = &opt { hm.clone() } else { new_map!() };
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `opt.as_ref().map_or_else(|| new_map!(), |hm| hm.clone())`
diff --git a/src/tools/clippy/tests/ui/option_map_or_err_ok.fixed b/src/tools/clippy/tests/ui/option_map_or_err_ok.fixed
deleted file mode 100644
index 131f4b2093e7..000000000000
--- a/src/tools/clippy/tests/ui/option_map_or_err_ok.fixed
+++ /dev/null
@@ -1,7 +0,0 @@
-#![warn(clippy::option_map_or_err_ok)]
-
-fn main() {
-    let x = Some("a");
-    let _ = x.ok_or("a");
-    //~^ ERROR: called `map_or(Err(_), Ok)` on an `Option` value
-}
diff --git a/src/tools/clippy/tests/ui/option_map_or_err_ok.rs b/src/tools/clippy/tests/ui/option_map_or_err_ok.rs
deleted file mode 100644
index 0f07a592ae5f..000000000000
--- a/src/tools/clippy/tests/ui/option_map_or_err_ok.rs
+++ /dev/null
@@ -1,7 +0,0 @@
-#![warn(clippy::option_map_or_err_ok)]
-
-fn main() {
-    let x = Some("a");
-    let _ = x.map_or(Err("a"), Ok);
-    //~^ ERROR: called `map_or(Err(_), Ok)` on an `Option` value
-}
diff --git a/src/tools/clippy/tests/ui/option_map_or_err_ok.stderr b/src/tools/clippy/tests/ui/option_map_or_err_ok.stderr
deleted file mode 100644
index 1971af80aa8d..000000000000
--- a/src/tools/clippy/tests/ui/option_map_or_err_ok.stderr
+++ /dev/null
@@ -1,11 +0,0 @@
-error: called `map_or(Err(_), Ok)` on an `Option` value
-  --> tests/ui/option_map_or_err_ok.rs:5:13
-   |
-LL |     let _ = x.map_or(Err("a"), Ok);
-   |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using `ok_or`: `x.ok_or("a")`
-   |
-   = note: `-D clippy::option-map-or-err-ok` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::option_map_or_err_ok)]`
-
-error: aborting due to 1 previous error
-
diff --git a/src/tools/clippy/tests/ui/option_map_or_none.fixed b/src/tools/clippy/tests/ui/option_map_or_none.fixed
index 5f0ef34d231c..183bf32e5361 100644
--- a/src/tools/clippy/tests/ui/option_map_or_none.fixed
+++ b/src/tools/clippy/tests/ui/option_map_or_none.fixed
@@ -8,12 +8,15 @@ fn main() {
     // Check `OPTION_MAP_OR_NONE`.
     // Single line case.
     let _: Option<i32> = opt.map(|x| x + 1);
+    //~^ option_map_or_none
     // Multi-line case.
     #[rustfmt::skip]
     let _: Option<i32> = opt.map(|x| x + 1);
     // function returning `Option`
     let _: Option<i32> = opt.and_then(bar);
+    //~^ option_map_or_none
     let _: Option<i32> = opt.and_then(|x| {
+        //~^ option_map_or_none
         let offset = 0;
         let height = x;
         Some(offset + height)
@@ -21,4 +24,5 @@ fn main() {
 
     // Check `RESULT_MAP_OR_INTO_OPTION`.
     let _: Option<i32> = r.ok();
+    //~^ result_map_or_into_option
 }
diff --git a/src/tools/clippy/tests/ui/option_map_or_none.rs b/src/tools/clippy/tests/ui/option_map_or_none.rs
index 56b1f61212d0..626f206b2598 100644
--- a/src/tools/clippy/tests/ui/option_map_or_none.rs
+++ b/src/tools/clippy/tests/ui/option_map_or_none.rs
@@ -8,14 +8,18 @@ fn main() {
     // Check `OPTION_MAP_OR_NONE`.
     // Single line case.
     let _: Option<i32> = opt.map_or(None, |x| Some(x + 1));
+    //~^ option_map_or_none
     // Multi-line case.
     #[rustfmt::skip]
     let _: Option<i32> = opt.map_or(None, |x| {
+    //~^ option_map_or_none
                         Some(x + 1)
                        });
     // function returning `Option`
     let _: Option<i32> = opt.map_or(None, bar);
+    //~^ option_map_or_none
     let _: Option<i32> = opt.map_or(None, |x| {
+        //~^ option_map_or_none
         let offset = 0;
         let height = x;
         Some(offset + height)
@@ -23,4 +27,5 @@ fn main() {
 
     // Check `RESULT_MAP_OR_INTO_OPTION`.
     let _: Option<i32> = r.map_or(None, Some);
+    //~^ result_map_or_into_option
 }
diff --git a/src/tools/clippy/tests/ui/option_map_or_none.stderr b/src/tools/clippy/tests/ui/option_map_or_none.stderr
index cba29861296f..f9290fb99bc1 100644
--- a/src/tools/clippy/tests/ui/option_map_or_none.stderr
+++ b/src/tools/clippy/tests/ui/option_map_or_none.stderr
@@ -8,25 +8,27 @@ LL |     let _: Option<i32> = opt.map_or(None, |x| Some(x + 1));
    = help: to override `-D warnings` add `#[allow(clippy::option_map_or_none)]`
 
 error: called `map_or(None, ..)` on an `Option` value
-  --> tests/ui/option_map_or_none.rs:13:26
+  --> tests/ui/option_map_or_none.rs:14:26
    |
 LL |       let _: Option<i32> = opt.map_or(None, |x| {
    |  __________________________^
+LL | |
 LL | |                         Some(x + 1)
 LL | |                        });
    | |_________________________^ help: consider using `map`: `opt.map(|x| x + 1)`
 
 error: called `map_or(None, ..)` on an `Option` value
-  --> tests/ui/option_map_or_none.rs:17:26
+  --> tests/ui/option_map_or_none.rs:19:26
    |
 LL |     let _: Option<i32> = opt.map_or(None, bar);
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: consider using `and_then`: `opt.and_then(bar)`
 
 error: called `map_or(None, ..)` on an `Option` value
-  --> tests/ui/option_map_or_none.rs:18:26
+  --> tests/ui/option_map_or_none.rs:21:26
    |
 LL |       let _: Option<i32> = opt.map_or(None, |x| {
    |  __________________________^
+LL | |
 LL | |         let offset = 0;
 LL | |         let height = x;
 LL | |         Some(offset + height)
@@ -36,6 +38,7 @@ LL | |     });
 help: consider using `and_then`
    |
 LL ~     let _: Option<i32> = opt.and_then(|x| {
+LL +
 LL +         let offset = 0;
 LL +         let height = x;
 LL +         Some(offset + height)
@@ -43,7 +46,7 @@ LL ~     });
    |
 
 error: called `map_or(None, Some)` on a `Result` value
-  --> tests/ui/option_map_or_none.rs:25:26
+  --> tests/ui/option_map_or_none.rs:29:26
    |
 LL |     let _: Option<i32> = r.map_or(None, Some);
    |                          ^^^^^^^^^^^^^^^^^^^^ help: consider using `ok`: `r.ok()`
diff --git a/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.fixed b/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.fixed
index 5dcc6464ff5f..55c1b8f110ce 100644
--- a/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.fixed
+++ b/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.fixed
@@ -35,52 +35,71 @@ fn option_map_unit_fn() {
     let _ : Option<()> = x.field.map(do_nothing);
 
     if let Some(x_field) = x.field { do_nothing(x_field) }
+    //~^ option_map_unit_fn
 
     if let Some(x_field) = x.field { do_nothing(x_field) }
+    //~^ option_map_unit_fn
 
     if let Some(x_field) = x.field { diverge(x_field) }
+    //~^ option_map_unit_fn
 
     let captured = 10;
     if let Some(value) = x.field { do_nothing(value + captured) };
     let _ : Option<()> = x.field.map(|value| do_nothing(value + captured));
 
     if let Some(value) = x.field { x.do_option_nothing(value + captured) }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { x.do_option_plus_one(value + captured); }
+    //~^ option_map_unit_fn
 
 
     if let Some(value) = x.field { do_nothing(value + captured) }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { do_nothing(value + captured) }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { do_nothing(value + captured); }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { do_nothing(value + captured); }
+    //~^ option_map_unit_fn
 
 
     if let Some(value) = x.field { diverge(value + captured) }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { diverge(value + captured) }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { diverge(value + captured); }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { diverge(value + captured); }
+    //~^ option_map_unit_fn
 
 
     x.field.map(|value| plus_one(value + captured));
     x.field.map(|value| { plus_one(value + captured) });
     if let Some(value) = x.field { let y = plus_one(value + captured); }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { plus_one(value + captured); }
+    //~^ option_map_unit_fn
 
     if let Some(value) = x.field { plus_one(value + captured); }
+    //~^ option_map_unit_fn
 
 
     if let Some(ref value) = x.field { do_nothing(value + captured) }
+    //~^ option_map_unit_fn
 
     if let Some(a) = option() { do_nothing(a) }
+    //~^ option_map_unit_fn
 
     if let Some(value) = option() { println!("{:?}", value) }
+    //~^ option_map_unit_fn
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.rs b/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.rs
index 5489545fe3d9..5ed47e4c60b5 100644
--- a/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.rs
+++ b/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.rs
@@ -35,52 +35,71 @@ fn option_map_unit_fn() {
     let _ : Option<()> = x.field.map(do_nothing);
 
     x.field.map(do_nothing);
+    //~^ option_map_unit_fn
 
     x.field.map(do_nothing);
+    //~^ option_map_unit_fn
 
     x.field.map(diverge);
+    //~^ option_map_unit_fn
 
     let captured = 10;
     if let Some(value) = x.field { do_nothing(value + captured) };
     let _ : Option<()> = x.field.map(|value| do_nothing(value + captured));
 
     x.field.map(|value| x.do_option_nothing(value + captured));
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { x.do_option_plus_one(value + captured); });
+    //~^ option_map_unit_fn
 
 
     x.field.map(|value| do_nothing(value + captured));
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { do_nothing(value + captured) });
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { do_nothing(value + captured); });
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { { do_nothing(value + captured); } });
+    //~^ option_map_unit_fn
 
 
     x.field.map(|value| diverge(value + captured));
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { diverge(value + captured) });
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { diverge(value + captured); });
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { { diverge(value + captured); } });
+    //~^ option_map_unit_fn
 
 
     x.field.map(|value| plus_one(value + captured));
     x.field.map(|value| { plus_one(value + captured) });
     x.field.map(|value| { let y = plus_one(value + captured); });
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { plus_one(value + captured); });
+    //~^ option_map_unit_fn
 
     x.field.map(|value| { { plus_one(value + captured); } });
+    //~^ option_map_unit_fn
 
 
     x.field.map(|ref value| { do_nothing(value + captured) });
+    //~^ option_map_unit_fn
 
     option().map(do_nothing);
+    //~^ option_map_unit_fn
 
     option().map(|value| println!("{:?}", value));
+    //~^ option_map_unit_fn
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.stderr b/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.stderr
index 5fd3dfd071c2..3f7abae34eea 100644
--- a/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.stderr
+++ b/src/tools/clippy/tests/ui/option_map_unit_fn_fixable.stderr
@@ -10,7 +10,7 @@ LL |     x.field.map(do_nothing);
    = help: to override `-D warnings` add `#[allow(clippy::option_map_unit_fn)]`
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:39:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:40:5
    |
 LL |     x.field.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^-
@@ -18,7 +18,7 @@ LL |     x.field.map(do_nothing);
    |     help: try: `if let Some(x_field) = x.field { do_nothing(x_field) }`
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:41:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:43:5
    |
 LL |     x.field.map(diverge);
    |     ^^^^^^^^^^^^^^^^^^^^-
@@ -26,7 +26,7 @@ LL |     x.field.map(diverge);
    |     help: try: `if let Some(x_field) = x.field { diverge(x_field) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:47:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:50:5
    |
 LL |     x.field.map(|value| x.do_option_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -34,7 +34,7 @@ LL |     x.field.map(|value| x.do_option_nothing(value + captured));
    |     help: try: `if let Some(value) = x.field { x.do_option_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:49:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:53:5
    |
 LL |     x.field.map(|value| { x.do_option_plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -42,7 +42,7 @@ LL |     x.field.map(|value| { x.do_option_plus_one(value + captured); });
    |     help: try: `if let Some(value) = x.field { x.do_option_plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:52:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:57:5
    |
 LL |     x.field.map(|value| do_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -50,7 +50,7 @@ LL |     x.field.map(|value| do_nothing(value + captured));
    |     help: try: `if let Some(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:54:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:60:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -58,7 +58,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     help: try: `if let Some(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:56:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:63:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -66,7 +66,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     help: try: `if let Some(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:58:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:66:5
    |
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -74,7 +74,7 @@ LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     help: try: `if let Some(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:61:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:70:5
    |
 LL |     x.field.map(|value| diverge(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -82,7 +82,7 @@ LL |     x.field.map(|value| diverge(value + captured));
    |     help: try: `if let Some(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:63:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:73:5
    |
 LL |     x.field.map(|value| { diverge(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -90,7 +90,7 @@ LL |     x.field.map(|value| { diverge(value + captured) });
    |     help: try: `if let Some(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:65:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:76:5
    |
 LL |     x.field.map(|value| { diverge(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -98,7 +98,7 @@ LL |     x.field.map(|value| { diverge(value + captured); });
    |     help: try: `if let Some(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:67:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:79:5
    |
 LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -106,7 +106,7 @@ LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     help: try: `if let Some(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:72:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:85:5
    |
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -114,7 +114,7 @@ LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     help: try: `if let Some(value) = x.field { let y = plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:74:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:88:5
    |
 LL |     x.field.map(|value| { plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -122,7 +122,7 @@ LL |     x.field.map(|value| { plus_one(value + captured); });
    |     help: try: `if let Some(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:76:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:91:5
    |
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -130,7 +130,7 @@ LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     help: try: `if let Some(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:79:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:95:5
    |
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -138,7 +138,7 @@ LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     help: try: `if let Some(ref value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Option` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:81:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:98:5
    |
 LL |     option().map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -146,7 +146,7 @@ LL |     option().map(do_nothing);
    |     help: try: `if let Some(a) = option() { do_nothing(a) }`
 
 error: called `map(f)` on an `Option` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/option_map_unit_fn_fixable.rs:83:5
+  --> tests/ui/option_map_unit_fn_fixable.rs:101:5
    |
 LL |     option().map(|value| println!("{:?}", value));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
diff --git a/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.rs b/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.rs
index 20e6c15b18d5..dd2f80fefbee 100644
--- a/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.rs
+++ b/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.rs
@@ -15,8 +15,10 @@ fn plus_one(value: usize) -> usize {
 fn option_map_unit_fn() {
 
     x.field.map(|value| { do_nothing(value); do_nothing(value) });
+    //~^ ERROR: cannot find value
 
     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
+    //~^ ERROR: cannot find value
 
     // Suggestion for the let block should be `{ ... }` as it's too difficult to build a
     // proper suggestion for these cases
@@ -24,7 +26,9 @@ fn option_map_unit_fn() {
         do_nothing(value);
         do_nothing(value)
     });
+    //~^^^^ ERROR: cannot find value
     x.field.map(|value| { do_nothing(value); do_nothing(value); });
+    //~^ ERROR: cannot find value
 
     // The following should suggest `if let Some(_X) ...` as it's difficult to generate a proper let variable name for them
     Some(42).map(diverge);
diff --git a/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.stderr b/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.stderr
index 66271036113c..852785014329 100644
--- a/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/option_map_unit_fn_unfixable.stderr
@@ -5,19 +5,19 @@ LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
    |     ^ not found in this scope
 
 error[E0425]: cannot find value `x` in this scope
-  --> tests/ui/option_map_unit_fn_unfixable.rs:19:5
+  --> tests/ui/option_map_unit_fn_unfixable.rs:20:5
    |
 LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
    |     ^ not found in this scope
 
 error[E0425]: cannot find value `x` in this scope
-  --> tests/ui/option_map_unit_fn_unfixable.rs:23:5
+  --> tests/ui/option_map_unit_fn_unfixable.rs:25:5
    |
 LL |     x.field.map(|value| {
    |     ^ not found in this scope
 
 error[E0425]: cannot find value `x` in this scope
-  --> tests/ui/option_map_unit_fn_unfixable.rs:27:5
+  --> tests/ui/option_map_unit_fn_unfixable.rs:30:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
    |     ^ not found in this scope
diff --git a/src/tools/clippy/tests/ui/or_fun_call.fixed b/src/tools/clippy/tests/ui/or_fun_call.fixed
index 625d654dd396..1794ac57fe5b 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.fixed
+++ b/src/tools/clippy/tests/ui/or_fun_call.fixed
@@ -50,61 +50,80 @@ fn or_fun_call() {
 
     let with_constructor = Some(vec![1]);
     with_constructor.unwrap_or_else(make);
+    //~^ or_fun_call
 
     let with_new = Some(vec![1]);
     with_new.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let with_const_args = Some(vec![1]);
     with_const_args.unwrap_or_else(|| Vec::with_capacity(12));
+    //~^ or_fun_call
 
     let with_err: Result<_, ()> = Ok(vec![1]);
     with_err.unwrap_or_else(|_| make());
+    //~^ or_fun_call
 
     let with_err_args: Result<_, ()> = Ok(vec![1]);
     with_err_args.unwrap_or_else(|_| Vec::with_capacity(12));
+    //~^ or_fun_call
 
     let with_default_trait = Some(1);
     with_default_trait.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let with_default_type = Some(1);
     with_default_type.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or_else(<FakeDefault>::default);
+    //~^ or_fun_call
 
     let real_default = None::<FakeDefault>;
     real_default.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let with_vec = Some(vec![1]);
     with_vec.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let without_default = Some(Foo);
     without_default.unwrap_or_else(Foo::new);
+    //~^ or_fun_call
 
     let mut map = HashMap::<u64, String>::new();
     map.entry(42).or_default();
+    //~^ unwrap_or_default
 
     let mut map_vec = HashMap::<u64, Vec<i32>>::new();
     map_vec.entry(42).or_default();
+    //~^ unwrap_or_default
 
     let mut btree = BTreeMap::<u64, String>::new();
     btree.entry(42).or_default();
+    //~^ unwrap_or_default
 
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
     btree_vec.entry(42).or_default();
+    //~^ unwrap_or_default
 
     let stringy = Some(String::new());
     let _ = stringy.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let opt = Some(1);
     let hello = "Hello";
     let _ = opt.ok_or_else(|| format!("{} world.", hello));
+    //~^ or_fun_call
 
     // index
     let map = HashMap::<u64, u64>::new();
     let _ = Some(1).unwrap_or_else(|| map[&1]);
+    //~^ or_fun_call
     let map = BTreeMap::<u64, u64>::new();
     let _ = Some(1).unwrap_or_else(|| map[&1]);
+    //~^ or_fun_call
     // don't lint index vec
     let vec = vec![1];
     let _ = Some(1).unwrap_or(vec[1]);
@@ -129,6 +148,7 @@ fn test_or_with_ctors() {
     let _ = opt.or(Some(two));
 
     let _ = Some("a".to_string()).or_else(|| Some("b".to_string()));
+    //~^ or_fun_call
 
     let b = "b".to_string();
     let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
@@ -168,14 +188,17 @@ mod issue6675 {
         let s = "test".to_owned();
         let s = &s as *const _;
         None.unwrap_or_else(|| ptr_to_ref(s));
+        //~^ or_fun_call
     }
 
     fn bar() {
         let s = "test".to_owned();
         let s = &s as *const _;
         None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
+        //~^ or_fun_call
         #[rustfmt::skip]
         None.unwrap_or_else(|| unsafe { ptr_to_ref(s) });
+        //~^ or_fun_call
     }
 }
 
@@ -251,7 +274,9 @@ mod issue8993 {
 
     fn test_map_or() {
         let _ = Some(4).map_or_else(g, |v| v);
+        //~^ or_fun_call
         let _ = Some(4).map_or_else(g, f);
+        //~^ or_fun_call
         let _ = Some(4).map_or(0, f);
     }
 }
@@ -283,24 +308,31 @@ mod lazy {
 
         let with_new = Some(vec![1]);
         with_new.unwrap_or_default();
+        //~^ unwrap_or_default
 
         let with_default_trait = Some(1);
         with_default_trait.unwrap_or_default();
+        //~^ unwrap_or_default
 
         let with_default_type = Some(1);
         with_default_type.unwrap_or_default();
+        //~^ unwrap_or_default
 
         let real_default = None::<FakeDefault>;
         real_default.unwrap_or_default();
+        //~^ unwrap_or_default
 
         let mut map = HashMap::<u64, String>::new();
         map.entry(42).or_default();
+        //~^ unwrap_or_default
 
         let mut btree = BTreeMap::<u64, String>::new();
         btree.entry(42).or_default();
+        //~^ unwrap_or_default
 
         let stringy = Some(String::new());
         let _ = stringy.unwrap_or_default();
+        //~^ unwrap_or_default
 
         // negative tests
         let self_default = None::<FakeDefault>;
@@ -341,28 +373,36 @@ fn fn_call_in_nested_expr() {
     }
     let opt: Option<i32> = Some(1);
 
-    //~v ERROR: function call inside of `unwrap_or`
     let _ = opt.unwrap_or_else(f); // suggest `.unwrap_or_else(f)`
     //
-    //~v ERROR: function call inside of `unwrap_or`
+    //~^^ or_fun_call
+    //
+
     let _ = opt.unwrap_or_else(|| f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
     //
-    //~v ERROR: function call inside of `unwrap_or`
+    //~^^ or_fun_call
+    //
+
     let _ = opt.unwrap_or_else(|| {
+        //~^ or_fun_call
         let x = f();
         x + 1
     });
-    //~v ERROR: function call inside of `map_or`
+
     let _ = opt.map_or_else(|| f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
     //
-    //~v ERROR: use of `unwrap_or` to construct default value
+    //~^^ or_fun_call
+    //
+
     let _ = opt.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let opt_foo = Some(Foo {
         val: String::from("123"),
     });
-    //~v ERROR: function call inside of `unwrap_or`
+
     let _ = opt_foo.unwrap_or_else(|| Foo { val: String::default() });
+    //~^ or_fun_call
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/or_fun_call.rs b/src/tools/clippy/tests/ui/or_fun_call.rs
index 5b7d8faec7bf..256db343c057 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.rs
+++ b/src/tools/clippy/tests/ui/or_fun_call.rs
@@ -50,61 +50,80 @@ fn or_fun_call() {
 
     let with_constructor = Some(vec![1]);
     with_constructor.unwrap_or(make());
+    //~^ or_fun_call
 
     let with_new = Some(vec![1]);
     with_new.unwrap_or(Vec::new());
+    //~^ unwrap_or_default
 
     let with_const_args = Some(vec![1]);
     with_const_args.unwrap_or(Vec::with_capacity(12));
+    //~^ or_fun_call
 
     let with_err: Result<_, ()> = Ok(vec![1]);
     with_err.unwrap_or(make());
+    //~^ or_fun_call
 
     let with_err_args: Result<_, ()> = Ok(vec![1]);
     with_err_args.unwrap_or(Vec::with_capacity(12));
+    //~^ or_fun_call
 
     let with_default_trait = Some(1);
     with_default_trait.unwrap_or(Default::default());
+    //~^ unwrap_or_default
 
     let with_default_type = Some(1);
     with_default_type.unwrap_or(u64::default());
+    //~^ unwrap_or_default
 
     let self_default = None::<FakeDefault>;
     self_default.unwrap_or(<FakeDefault>::default());
+    //~^ or_fun_call
 
     let real_default = None::<FakeDefault>;
     real_default.unwrap_or(<FakeDefault as Default>::default());
+    //~^ unwrap_or_default
 
     let with_vec = Some(vec![1]);
     with_vec.unwrap_or(vec![]);
+    //~^ unwrap_or_default
 
     let without_default = Some(Foo);
     without_default.unwrap_or(Foo::new());
+    //~^ or_fun_call
 
     let mut map = HashMap::<u64, String>::new();
     map.entry(42).or_insert(String::new());
+    //~^ unwrap_or_default
 
     let mut map_vec = HashMap::<u64, Vec<i32>>::new();
     map_vec.entry(42).or_insert(vec![]);
+    //~^ unwrap_or_default
 
     let mut btree = BTreeMap::<u64, String>::new();
     btree.entry(42).or_insert(String::new());
+    //~^ unwrap_or_default
 
     let mut btree_vec = BTreeMap::<u64, Vec<i32>>::new();
     btree_vec.entry(42).or_insert(vec![]);
+    //~^ unwrap_or_default
 
     let stringy = Some(String::new());
     let _ = stringy.unwrap_or(String::new());
+    //~^ unwrap_or_default
 
     let opt = Some(1);
     let hello = "Hello";
     let _ = opt.ok_or(format!("{} world.", hello));
+    //~^ or_fun_call
 
     // index
     let map = HashMap::<u64, u64>::new();
     let _ = Some(1).unwrap_or(map[&1]);
+    //~^ or_fun_call
     let map = BTreeMap::<u64, u64>::new();
     let _ = Some(1).unwrap_or(map[&1]);
+    //~^ or_fun_call
     // don't lint index vec
     let vec = vec![1];
     let _ = Some(1).unwrap_or(vec[1]);
@@ -129,6 +148,7 @@ fn test_or_with_ctors() {
     let _ = opt.or(Some(two));
 
     let _ = Some("a".to_string()).or(Some("b".to_string()));
+    //~^ or_fun_call
 
     let b = "b".to_string();
     let _ = Some(Bar("a".to_string(), Duration::from_secs(1)))
@@ -168,14 +188,17 @@ mod issue6675 {
         let s = "test".to_owned();
         let s = &s as *const _;
         None.unwrap_or(ptr_to_ref(s));
+        //~^ or_fun_call
     }
 
     fn bar() {
         let s = "test".to_owned();
         let s = &s as *const _;
         None.unwrap_or(unsafe { ptr_to_ref(s) });
+        //~^ or_fun_call
         #[rustfmt::skip]
         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
+        //~^ or_fun_call
     }
 }
 
@@ -251,7 +274,9 @@ mod issue8993 {
 
     fn test_map_or() {
         let _ = Some(4).map_or(g(), |v| v);
+        //~^ or_fun_call
         let _ = Some(4).map_or(g(), f);
+        //~^ or_fun_call
         let _ = Some(4).map_or(0, f);
     }
 }
@@ -283,24 +308,31 @@ mod lazy {
 
         let with_new = Some(vec![1]);
         with_new.unwrap_or_else(Vec::new);
+        //~^ unwrap_or_default
 
         let with_default_trait = Some(1);
         with_default_trait.unwrap_or_else(Default::default);
+        //~^ unwrap_or_default
 
         let with_default_type = Some(1);
         with_default_type.unwrap_or_else(u64::default);
+        //~^ unwrap_or_default
 
         let real_default = None::<FakeDefault>;
         real_default.unwrap_or_else(<FakeDefault as Default>::default);
+        //~^ unwrap_or_default
 
         let mut map = HashMap::<u64, String>::new();
         map.entry(42).or_insert_with(String::new);
+        //~^ unwrap_or_default
 
         let mut btree = BTreeMap::<u64, String>::new();
         btree.entry(42).or_insert_with(String::new);
+        //~^ unwrap_or_default
 
         let stringy = Some(String::new());
         let _ = stringy.unwrap_or_else(String::new);
+        //~^ unwrap_or_default
 
         // negative tests
         let self_default = None::<FakeDefault>;
@@ -341,28 +373,36 @@ fn fn_call_in_nested_expr() {
     }
     let opt: Option<i32> = Some(1);
 
-    //~v ERROR: function call inside of `unwrap_or`
     let _ = opt.unwrap_or({ f() }); // suggest `.unwrap_or_else(f)`
     //
-    //~v ERROR: function call inside of `unwrap_or`
+    //~^^ or_fun_call
+    //
+
     let _ = opt.unwrap_or(f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
     //
-    //~v ERROR: function call inside of `unwrap_or`
+    //~^^ or_fun_call
+    //
+
     let _ = opt.unwrap_or({
+        //~^ or_fun_call
         let x = f();
         x + 1
     });
-    //~v ERROR: function call inside of `map_or`
+
     let _ = opt.map_or(f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
     //
-    //~v ERROR: use of `unwrap_or` to construct default value
+    //~^^ or_fun_call
+    //
+
     let _ = opt.unwrap_or({ i32::default() });
+    //~^ unwrap_or_default
 
     let opt_foo = Some(Foo {
         val: String::from("123"),
     });
-    //~v ERROR: function call inside of `unwrap_or`
+
     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
+    //~^ or_fun_call
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/or_fun_call.stderr b/src/tools/clippy/tests/ui/or_fun_call.stderr
index 9f90a830a211..93c87b2f12cd 100644
--- a/src/tools/clippy/tests/ui/or_fun_call.stderr
+++ b/src/tools/clippy/tests/ui/or_fun_call.stderr
@@ -8,7 +8,7 @@ LL |     with_constructor.unwrap_or(make());
    = help: to override `-D warnings` add `#[allow(clippy::or_fun_call)]`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:55:14
+  --> tests/ui/or_fun_call.rs:56:14
    |
 LL |     with_new.unwrap_or(Vec::new());
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
@@ -17,202 +17,203 @@ LL |     with_new.unwrap_or(Vec::new());
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_or_default)]`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:58:21
+  --> tests/ui/or_fun_call.rs:60:21
    |
 LL |     with_const_args.unwrap_or(Vec::with_capacity(12));
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Vec::with_capacity(12))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:61:14
+  --> tests/ui/or_fun_call.rs:64:14
    |
 LL |     with_err.unwrap_or(make());
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| make())`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:64:19
+  --> tests/ui/or_fun_call.rs:68:19
    |
 LL |     with_err_args.unwrap_or(Vec::with_capacity(12));
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|_| Vec::with_capacity(12))`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:67:24
+  --> tests/ui/or_fun_call.rs:72:24
    |
 LL |     with_default_trait.unwrap_or(Default::default());
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:70:23
+  --> tests/ui/or_fun_call.rs:76:23
    |
 LL |     with_default_type.unwrap_or(u64::default());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:73:18
+  --> tests/ui/or_fun_call.rs:80:18
    |
 LL |     self_default.unwrap_or(<FakeDefault>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(<FakeDefault>::default)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:76:18
+  --> tests/ui/or_fun_call.rs:84:18
    |
 LL |     real_default.unwrap_or(<FakeDefault as Default>::default());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:79:14
+  --> tests/ui/or_fun_call.rs:88:14
    |
 LL |     with_vec.unwrap_or(vec![]);
    |              ^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:82:21
+  --> tests/ui/or_fun_call.rs:92:21
    |
 LL |     without_default.unwrap_or(Foo::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(Foo::new)`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:85:19
+  --> tests/ui/or_fun_call.rs:96:19
    |
 LL |     map.entry(42).or_insert(String::new());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:88:23
+  --> tests/ui/or_fun_call.rs:100:23
    |
 LL |     map_vec.entry(42).or_insert(vec![]);
    |                       ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:91:21
+  --> tests/ui/or_fun_call.rs:104:21
    |
 LL |     btree.entry(42).or_insert(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert` to construct default value
-  --> tests/ui/or_fun_call.rs:94:25
+  --> tests/ui/or_fun_call.rs:108:25
    |
 LL |     btree_vec.entry(42).or_insert(vec![]);
    |                         ^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:97:21
+  --> tests/ui/or_fun_call.rs:112:21
    |
 LL |     let _ = stringy.unwrap_or(String::new());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `ok_or`
-  --> tests/ui/or_fun_call.rs:101:17
+  --> tests/ui/or_fun_call.rs:117:17
    |
 LL |     let _ = opt.ok_or(format!("{} world.", hello));
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ok_or_else(|| format!("{} world.", hello))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:105:21
+  --> tests/ui/or_fun_call.rs:122:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:107:21
+  --> tests/ui/or_fun_call.rs:125:21
    |
 LL |     let _ = Some(1).unwrap_or(map[&1]);
    |                     ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| map[&1])`
 
 error: function call inside of `or`
-  --> tests/ui/or_fun_call.rs:131:35
+  --> tests/ui/or_fun_call.rs:150:35
    |
 LL |     let _ = Some("a".to_string()).or(Some("b".to_string()));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_else(|| Some("b".to_string()))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:170:14
+  --> tests/ui/or_fun_call.rs:190:14
    |
 LL |         None.unwrap_or(ptr_to_ref(s));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| ptr_to_ref(s))`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:176:14
+  --> tests/ui/or_fun_call.rs:197:14
    |
 LL |         None.unwrap_or(unsafe { ptr_to_ref(s) });
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:178:14
+  --> tests/ui/or_fun_call.rs:200:14
    |
 LL |         None.unwrap_or( unsafe { ptr_to_ref(s) }    );
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| unsafe { ptr_to_ref(s) })`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:253:25
+  --> tests/ui/or_fun_call.rs:276:25
    |
 LL |         let _ = Some(4).map_or(g(), |v| v);
    |                         ^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(g, |v| v)`
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:254:25
+  --> tests/ui/or_fun_call.rs:278:25
    |
 LL |         let _ = Some(4).map_or(g(), f);
    |                         ^^^^^^^^^^^^^^ help: try: `map_or_else(g, f)`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:285:18
+  --> tests/ui/or_fun_call.rs:310:18
    |
 LL |         with_new.unwrap_or_else(Vec::new);
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:288:28
+  --> tests/ui/or_fun_call.rs:314:28
    |
 LL |         with_default_trait.unwrap_or_else(Default::default);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:291:27
+  --> tests/ui/or_fun_call.rs:318:27
    |
 LL |         with_default_type.unwrap_or_else(u64::default);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:294:22
+  --> tests/ui/or_fun_call.rs:322:22
    |
 LL |         real_default.unwrap_or_else(<FakeDefault as Default>::default);
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:297:23
+  --> tests/ui/or_fun_call.rs:326:23
    |
 LL |         map.entry(42).or_insert_with(String::new);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/or_fun_call.rs:300:25
+  --> tests/ui/or_fun_call.rs:330:25
    |
 LL |         btree.entry(42).or_insert_with(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/or_fun_call.rs:303:25
+  --> tests/ui/or_fun_call.rs:334:25
    |
 LL |         let _ = stringy.unwrap_or_else(String::new);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:345:17
+  --> tests/ui/or_fun_call.rs:376:17
    |
 LL |     let _ = opt.unwrap_or({ f() }); // suggest `.unwrap_or_else(f)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(f)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:348:17
+  --> tests/ui/or_fun_call.rs:381:17
    |
 LL |     let _ = opt.unwrap_or(f() + 1); // suggest `.unwrap_or_else(|| f() + 1)`
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| f() + 1)`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:351:17
+  --> tests/ui/or_fun_call.rs:386:17
    |
 LL |       let _ = opt.unwrap_or({
    |  _________________^
+LL | |
 LL | |         let x = f();
 LL | |         x + 1
 LL | |     });
@@ -221,25 +222,26 @@ LL | |     });
 help: try
    |
 LL ~     let _ = opt.unwrap_or_else(|| {
+LL +
 LL +         let x = f();
 LL +         x + 1
 LL ~     });
    |
 
 error: function call inside of `map_or`
-  --> tests/ui/or_fun_call.rs:356:17
+  --> tests/ui/or_fun_call.rs:392:17
    |
 LL |     let _ = opt.map_or(f() + 1, |v| v); // suggest `.map_or_else(|| f() + 1, |v| v)`
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `map_or_else(|| f() + 1, |v| v)`
 
 error: use of `unwrap_or` to construct default value
-  --> tests/ui/or_fun_call.rs:359:17
+  --> tests/ui/or_fun_call.rs:397:17
    |
 LL |     let _ = opt.unwrap_or({ i32::default() });
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/or_fun_call.rs:365:21
+  --> tests/ui/or_fun_call.rs:404:21
    |
 LL |     let _ = opt_foo.unwrap_or(Foo { val: String::default() });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| Foo { val: String::default() })`
diff --git a/src/tools/clippy/tests/ui/or_then_unwrap.fixed b/src/tools/clippy/tests/ui/or_then_unwrap.fixed
index c94478614352..ba9beef57afa 100644
--- a/src/tools/clippy/tests/ui/or_then_unwrap.fixed
+++ b/src/tools/clippy/tests/ui/or_then_unwrap.fixed
@@ -20,13 +20,19 @@ impl SomeOtherStruct {
 fn main() {
     let option: Option<&str> = None;
     let _ = option.unwrap_or("fallback"); // should trigger lint
+    //
+    //~^^ or_then_unwrap
 
     let result: Result<&str, &str> = Err("Error");
     let _ = result.unwrap_or("fallback"); // should trigger lint
+    //
+    //~^^ or_then_unwrap
 
     // as part of a method chain
     let option: Option<&str> = None;
     let _ = option.map(|v| v).unwrap_or("fallback").to_string().chars(); // should trigger lint
+    //
+    //~^^ or_then_unwrap
 
     // Not Option/Result
     let instance = SomeStruct {};
diff --git a/src/tools/clippy/tests/ui/or_then_unwrap.rs b/src/tools/clippy/tests/ui/or_then_unwrap.rs
index 10e43e1d1896..fac90249a243 100644
--- a/src/tools/clippy/tests/ui/or_then_unwrap.rs
+++ b/src/tools/clippy/tests/ui/or_then_unwrap.rs
@@ -20,13 +20,19 @@ impl SomeOtherStruct {
 fn main() {
     let option: Option<&str> = None;
     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
+    //
+    //~^^ or_then_unwrap
 
     let result: Result<&str, &str> = Err("Error");
     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
+    //
+    //~^^ or_then_unwrap
 
     // as part of a method chain
     let option: Option<&str> = None;
     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
+    //
+    //~^^ or_then_unwrap
 
     // Not Option/Result
     let instance = SomeStruct {};
diff --git a/src/tools/clippy/tests/ui/or_then_unwrap.stderr b/src/tools/clippy/tests/ui/or_then_unwrap.stderr
index f454316068f2..1160498c6053 100644
--- a/src/tools/clippy/tests/ui/or_then_unwrap.stderr
+++ b/src/tools/clippy/tests/ui/or_then_unwrap.stderr
@@ -8,13 +8,13 @@ LL |     let _ = option.or(Some("fallback")).unwrap(); // should trigger lint
    = help: to override `-D warnings` add `#[allow(clippy::or_then_unwrap)]`
 
 error: found `.or(Ok(…)).unwrap()`
-  --> tests/ui/or_then_unwrap.rs:25:20
+  --> tests/ui/or_then_unwrap.rs:27:20
    |
 LL |     let _ = result.or::<&str>(Ok("fallback")).unwrap(); // should trigger lint
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
 
 error: found `.or(Some(…)).unwrap()`
-  --> tests/ui/or_then_unwrap.rs:29:31
+  --> tests/ui/or_then_unwrap.rs:33:31
    |
 LL |     let _ = option.map(|v| v).or(Some("fallback")).unwrap().to_string().chars(); // should trigger lint
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or("fallback")`
diff --git a/src/tools/clippy/tests/ui/out_of_bounds_indexing/issue-3102.rs b/src/tools/clippy/tests/ui/out_of_bounds_indexing/issue-3102.rs
index 81674653bdd3..e1e0fa02a937 100644
--- a/src/tools/clippy/tests/ui/out_of_bounds_indexing/issue-3102.rs
+++ b/src/tools/clippy/tests/ui/out_of_bounds_indexing/issue-3102.rs
@@ -7,8 +7,8 @@ fn main() {
     // issue 3102
     let num = 1;
     &x[num..10];
-    //~^ ERROR: range is out of bounds
-    //~| NOTE: `-D clippy::out-of-bounds-indexing` implied by `-D warnings`
+    //~^ out_of_bounds_indexing
+
     &x[10..num];
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
 }
diff --git a/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.rs b/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.rs
index c38ca5123816..e613e527eee4 100644
--- a/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.rs
+++ b/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.rs
@@ -5,18 +5,22 @@ fn main() {
     let x = [1, 2, 3, 4];
 
     &x[..=4];
-    //~^ ERROR: range is out of bounds
-    //~| NOTE: `-D clippy::out-of-bounds-indexing` implied by `-D warnings`
+    //~^ out_of_bounds_indexing
+
     &x[1..5];
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
+
     &x[5..];
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
+
     &x[..5];
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
+
     &x[5..].iter().map(|x| 2 * x).collect::<Vec<i32>>();
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
+
     &x[0..=4];
-    //~^ ERROR: range is out of bounds
+    //~^ out_of_bounds_indexing
 
     &x[4..]; // Ok, should not produce stderr.
     &x[..4]; // Ok, should not produce stderr.
diff --git a/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.stderr b/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.stderr
index 87d1d574dcb8..f89531733431 100644
--- a/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.stderr
+++ b/src/tools/clippy/tests/ui/out_of_bounds_indexing/simple.stderr
@@ -14,25 +14,25 @@ LL |     &x[1..5];
    |           ^
 
 error: range is out of bounds
-  --> tests/ui/out_of_bounds_indexing/simple.rs:12:8
+  --> tests/ui/out_of_bounds_indexing/simple.rs:13:8
    |
 LL |     &x[5..];
    |        ^
 
 error: range is out of bounds
-  --> tests/ui/out_of_bounds_indexing/simple.rs:14:10
+  --> tests/ui/out_of_bounds_indexing/simple.rs:16:10
    |
 LL |     &x[..5];
    |          ^
 
 error: range is out of bounds
-  --> tests/ui/out_of_bounds_indexing/simple.rs:16:8
+  --> tests/ui/out_of_bounds_indexing/simple.rs:19:8
    |
 LL |     &x[5..].iter().map(|x| 2 * x).collect::<Vec<i32>>();
    |        ^
 
 error: range is out of bounds
-  --> tests/ui/out_of_bounds_indexing/simple.rs:18:12
+  --> tests/ui/out_of_bounds_indexing/simple.rs:22:12
    |
 LL |     &x[0..=4];
    |            ^
diff --git a/src/tools/clippy/tests/ui/overly_complex_bool_expr.fixed b/src/tools/clippy/tests/ui/overly_complex_bool_expr.fixed
index b21e91aa3ad4..6818f96725e7 100644
--- a/src/tools/clippy/tests/ui/overly_complex_bool_expr.fixed
+++ b/src/tools/clippy/tests/ui/overly_complex_bool_expr.fixed
@@ -8,10 +8,12 @@ fn main() {
     let d: bool = unimplemented!();
     let e: bool = unimplemented!();
     let _ = a;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = !(a && b);
     let _ = false;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     // don't lint on cfgs
     let _ = cfg!(you_shall_not_not_pass) && a;
     let _ = a || !b || !c || !d || !e;
@@ -22,11 +24,14 @@ fn equality_stuff() {
     let a: i32 = unimplemented!();
     let b: i32 = unimplemented!();
     let _ = false;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = false;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = false;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = a > b && a == b;
 }
 
diff --git a/src/tools/clippy/tests/ui/overly_complex_bool_expr.rs b/src/tools/clippy/tests/ui/overly_complex_bool_expr.rs
index 35ef0a1240a5..f1cd9562a855 100644
--- a/src/tools/clippy/tests/ui/overly_complex_bool_expr.rs
+++ b/src/tools/clippy/tests/ui/overly_complex_bool_expr.rs
@@ -8,10 +8,12 @@ fn main() {
     let d: bool = unimplemented!();
     let e: bool = unimplemented!();
     let _ = a && b || a;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = !(a && b);
     let _ = false && a;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     // don't lint on cfgs
     let _ = cfg!(you_shall_not_not_pass) && a;
     let _ = a || !b || !c || !d || !e;
@@ -22,11 +24,14 @@ fn equality_stuff() {
     let a: i32 = unimplemented!();
     let b: i32 = unimplemented!();
     let _ = a == b && a != b;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = a < b && a >= b;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = a > b && a <= b;
-    //~^ ERROR: this boolean expression contains a logic bug
+    //~^ overly_complex_bool_expr
+
     let _ = a > b && a == b;
 }
 
diff --git a/src/tools/clippy/tests/ui/overly_complex_bool_expr.stderr b/src/tools/clippy/tests/ui/overly_complex_bool_expr.stderr
index 5a754236fe4b..42a48a3b5be8 100644
--- a/src/tools/clippy/tests/ui/overly_complex_bool_expr.stderr
+++ b/src/tools/clippy/tests/ui/overly_complex_bool_expr.stderr
@@ -13,49 +13,49 @@ LL |     let _ = a && b || a;
    = help: to override `-D warnings` add `#[allow(clippy::overly_complex_bool_expr)]`
 
 error: this boolean expression contains a logic bug
-  --> tests/ui/overly_complex_bool_expr.rs:13:13
+  --> tests/ui/overly_complex_bool_expr.rs:14:13
    |
 LL |     let _ = false && a;
    |             ^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> tests/ui/overly_complex_bool_expr.rs:13:22
+  --> tests/ui/overly_complex_bool_expr.rs:14:22
    |
 LL |     let _ = false && a;
    |                      ^
 
 error: this boolean expression contains a logic bug
-  --> tests/ui/overly_complex_bool_expr.rs:24:13
+  --> tests/ui/overly_complex_bool_expr.rs:26:13
    |
 LL |     let _ = a == b && a != b;
    |             ^^^^^^^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> tests/ui/overly_complex_bool_expr.rs:24:13
+  --> tests/ui/overly_complex_bool_expr.rs:26:13
    |
 LL |     let _ = a == b && a != b;
    |             ^^^^^^
 
 error: this boolean expression contains a logic bug
-  --> tests/ui/overly_complex_bool_expr.rs:26:13
+  --> tests/ui/overly_complex_bool_expr.rs:29:13
    |
 LL |     let _ = a < b && a >= b;
    |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> tests/ui/overly_complex_bool_expr.rs:26:13
+  --> tests/ui/overly_complex_bool_expr.rs:29:13
    |
 LL |     let _ = a < b && a >= b;
    |             ^^^^^
 
 error: this boolean expression contains a logic bug
-  --> tests/ui/overly_complex_bool_expr.rs:28:13
+  --> tests/ui/overly_complex_bool_expr.rs:32:13
    |
 LL |     let _ = a > b && a <= b;
    |             ^^^^^^^^^^^^^^^ help: it would look like the following: `false`
    |
 help: this expression can be optimized out by applying boolean operations to the outer expression
-  --> tests/ui/overly_complex_bool_expr.rs:28:13
+  --> tests/ui/overly_complex_bool_expr.rs:32:13
    |
 LL |     let _ = a > b && a <= b;
    |             ^^^^^
diff --git a/src/tools/clippy/tests/ui/owned_cow.fixed b/src/tools/clippy/tests/ui/owned_cow.fixed
new file mode 100644
index 000000000000..b62e9107a561
--- /dev/null
+++ b/src/tools/clippy/tests/ui/owned_cow.fixed
@@ -0,0 +1,23 @@
+#![warn(clippy::owned_cow)]
+
+use std::borrow::Cow;
+use std::ffi::{CString, OsString};
+use std::path::PathBuf;
+
+fn main() {
+    let x: Cow<'static, str> = Cow::Owned(String::from("Hi!"));
+    //~^ ERROR: needlessly owned Cow type
+    let y: Cow<'_, [u8]> = Cow::Owned(vec![]);
+    //~^ ERROR: needlessly owned Cow type
+    let z: Cow<'_, [_]> = Cow::Owned(vec![2_i32]);
+    //~^ ERROR: needlessly owned Cow type
+    let o: Cow<'_, std::ffi::OsStr> = Cow::Owned(OsString::new());
+    //~^ ERROR: needlessly owned Cow type
+    let c: Cow<'_, std::ffi::CStr> = Cow::Owned(CString::new("").unwrap());
+    //~^ ERROR: needlessly owned Cow type
+    let p: Cow<'_, std::path::Path> = Cow::Owned(PathBuf::new());
+    //~^ ERROR: needlessly owned Cow type
+
+    // false positive: borrowed type
+    let b: Cow<'_, str> = Cow::Borrowed("Hi!");
+}
diff --git a/src/tools/clippy/tests/ui/owned_cow.rs b/src/tools/clippy/tests/ui/owned_cow.rs
new file mode 100644
index 000000000000..0e0f14711b7f
--- /dev/null
+++ b/src/tools/clippy/tests/ui/owned_cow.rs
@@ -0,0 +1,23 @@
+#![warn(clippy::owned_cow)]
+
+use std::borrow::Cow;
+use std::ffi::{CString, OsString};
+use std::path::PathBuf;
+
+fn main() {
+    let x: Cow<'static, String> = Cow::Owned(String::from("Hi!"));
+    //~^ ERROR: needlessly owned Cow type
+    let y: Cow<'_, Vec<u8>> = Cow::Owned(vec![]);
+    //~^ ERROR: needlessly owned Cow type
+    let z: Cow<'_, Vec<_>> = Cow::Owned(vec![2_i32]);
+    //~^ ERROR: needlessly owned Cow type
+    let o: Cow<'_, OsString> = Cow::Owned(OsString::new());
+    //~^ ERROR: needlessly owned Cow type
+    let c: Cow<'_, CString> = Cow::Owned(CString::new("").unwrap());
+    //~^ ERROR: needlessly owned Cow type
+    let p: Cow<'_, PathBuf> = Cow::Owned(PathBuf::new());
+    //~^ ERROR: needlessly owned Cow type
+
+    // false positive: borrowed type
+    let b: Cow<'_, str> = Cow::Borrowed("Hi!");
+}
diff --git a/src/tools/clippy/tests/ui/owned_cow.stderr b/src/tools/clippy/tests/ui/owned_cow.stderr
new file mode 100644
index 000000000000..8985d6db623d
--- /dev/null
+++ b/src/tools/clippy/tests/ui/owned_cow.stderr
@@ -0,0 +1,41 @@
+error: needlessly owned Cow type
+  --> tests/ui/owned_cow.rs:8:25
+   |
+LL |     let x: Cow<'static, String> = Cow::Owned(String::from("Hi!"));
+   |                         ^^^^^^ help: use: `str`
+   |
+   = note: `-D clippy::owned-cow` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::owned_cow)]`
+
+error: needlessly owned Cow type
+  --> tests/ui/owned_cow.rs:10:20
+   |
+LL |     let y: Cow<'_, Vec<u8>> = Cow::Owned(vec![]);
+   |                    ^^^^^^^ help: use: `[u8]`
+
+error: needlessly owned Cow type
+  --> tests/ui/owned_cow.rs:12:20
+   |
+LL |     let z: Cow<'_, Vec<_>> = Cow::Owned(vec![2_i32]);
+   |                    ^^^^^^ help: use: `[_]`
+
+error: needlessly owned Cow type
+  --> tests/ui/owned_cow.rs:14:20
+   |
+LL |     let o: Cow<'_, OsString> = Cow::Owned(OsString::new());
+   |                    ^^^^^^^^ help: use: `std::ffi::OsStr`
+
+error: needlessly owned Cow type
+  --> tests/ui/owned_cow.rs:16:20
+   |
+LL |     let c: Cow<'_, CString> = Cow::Owned(CString::new("").unwrap());
+   |                    ^^^^^^^ help: use: `std::ffi::CStr`
+
+error: needlessly owned Cow type
+  --> tests/ui/owned_cow.rs:18:20
+   |
+LL |     let p: Cow<'_, PathBuf> = Cow::Owned(PathBuf::new());
+   |                    ^^^^^^^ help: use: `std::path::Path`
+
+error: aborting due to 6 previous errors
+
diff --git a/src/tools/clippy/tests/ui/panic_in_result_fn.rs b/src/tools/clippy/tests/ui/panic_in_result_fn.rs
index e2375aa996f7..005e38db9021 100644
--- a/src/tools/clippy/tests/ui/panic_in_result_fn.rs
+++ b/src/tools/clippy/tests/ui/panic_in_result_fn.rs
@@ -4,7 +4,7 @@ struct A;
 
 impl A {
     fn result_with_panic() -> Result<bool, String> // should emit lint
-    //~^ ERROR: used `panic!()` or assertion in a function that returns `Result`
+    //~^ panic_in_result_fn
     {
         panic!("error");
     }
@@ -51,12 +51,13 @@ impl A {
 }
 
 fn function_result_with_panic() -> Result<bool, String> // should emit lint
-//~^ ERROR: used `panic!()` or assertion in a function that returns `Result`
+//~^ panic_in_result_fn
 {
     panic!("error");
 }
 
 fn in_closure() -> Result<bool, String> {
+    //~^ panic_in_result_fn
     let c = || panic!();
     c()
 }
diff --git a/src/tools/clippy/tests/ui/panic_in_result_fn.stderr b/src/tools/clippy/tests/ui/panic_in_result_fn.stderr
index 2d49b5ab1b8f..1067f4fac11c 100644
--- a/src/tools/clippy/tests/ui/panic_in_result_fn.stderr
+++ b/src/tools/clippy/tests/ui/panic_in_result_fn.stderr
@@ -38,6 +38,7 @@ error: used `panic!()` or assertion in a function that returns `Result`
   --> tests/ui/panic_in_result_fn.rs:59:1
    |
 LL | / fn in_closure() -> Result<bool, String> {
+LL | |
 LL | |     let c = || panic!();
 LL | |     c()
 LL | | }
@@ -45,7 +46,7 @@ LL | | }
    |
    = help: `panic!()` or assertions should not be used in a function that returns `Result` as `Result` is expected to return an error instead of crashing
 note: return Err() instead of panicking
-  --> tests/ui/panic_in_result_fn.rs:60:16
+  --> tests/ui/panic_in_result_fn.rs:61:16
    |
 LL |     let c = || panic!();
    |                ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/panic_in_result_fn_assertions.rs b/src/tools/clippy/tests/ui/panic_in_result_fn_assertions.rs
index 672c4c738339..4e7028241579 100644
--- a/src/tools/clippy/tests/ui/panic_in_result_fn_assertions.rs
+++ b/src/tools/clippy/tests/ui/panic_in_result_fn_assertions.rs
@@ -5,21 +5,21 @@ struct A;
 
 impl A {
     fn result_with_assert_with_message(x: i32) -> Result<bool, String> // should emit lint
-    //~^ ERROR: used `panic!()` or assertion in a function that returns `Result`
+    //~^ panic_in_result_fn
     {
         assert!(x == 5, "wrong argument");
         Ok(true)
     }
 
     fn result_with_assert_eq(x: i32) -> Result<bool, String> // should emit lint
-    //~^ ERROR: used `panic!()` or assertion in a function that returns `Result`
+    //~^ panic_in_result_fn
     {
         assert_eq!(x, 5);
         Ok(true)
     }
 
     fn result_with_assert_ne(x: i32) -> Result<bool, String> // should emit lint
-    //~^ ERROR: used `panic!()` or assertion in a function that returns `Result`
+    //~^ panic_in_result_fn
     {
         assert_ne!(x, 1);
         Ok(true)
diff --git a/src/tools/clippy/tests/ui/panic_in_result_fn_debug_assertions.rs b/src/tools/clippy/tests/ui/panic_in_result_fn_debug_assertions.rs
index df89d8c50246..c4549c6b8412 100644
--- a/src/tools/clippy/tests/ui/panic_in_result_fn_debug_assertions.rs
+++ b/src/tools/clippy/tests/ui/panic_in_result_fn_debug_assertions.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::panic_in_result_fn)]
 #![allow(clippy::uninlined_format_args, clippy::unnecessary_wraps)]
 
diff --git a/src/tools/clippy/tests/ui/panicking_macros.rs b/src/tools/clippy/tests/ui/panicking_macros.rs
index 2bbf5792ec4c..65854d7eb4bf 100644
--- a/src/tools/clippy/tests/ui/panicking_macros.rs
+++ b/src/tools/clippy/tests/ui/panicking_macros.rs
@@ -20,61 +20,72 @@ fn inline_const() {
 fn panic() {
     let a = 2;
     panic!();
-    //~^ ERROR: `panic` should not be present in production code
-    //~| NOTE: `-D clippy::panic` implied by `-D warnings`
+    //~^ panic
+
     panic!("message");
-    //~^ ERROR: `panic` should not be present in production code
+    //~^ panic
+
     panic!("{} {}", "panic with", "multiple arguments");
-    //~^ ERROR: `panic` should not be present in production code
+    //~^ panic
+
     let b = a + 2;
 }
 
 fn todo() {
     let a = 2;
     todo!();
-    //~^ ERROR: `todo` should not be present in production code
-    //~| NOTE: `-D clippy::todo` implied by `-D warnings`
+    //~^ todo
+
     todo!("message");
-    //~^ ERROR: `todo` should not be present in production code
+    //~^ todo
+
     todo!("{} {}", "panic with", "multiple arguments");
-    //~^ ERROR: `todo` should not be present in production code
+    //~^ todo
+
     let b = a + 2;
 }
 
 fn unimplemented() {
     let a = 2;
     unimplemented!();
-    //~^ ERROR: `unimplemented` should not be present in production code
-    //~| NOTE: `-D clippy::unimplemented` implied by `-D warnings`
+    //~^ unimplemented
+
     unimplemented!("message");
-    //~^ ERROR: `unimplemented` should not be present in production code
+    //~^ unimplemented
+
     unimplemented!("{} {}", "panic with", "multiple arguments");
-    //~^ ERROR: `unimplemented` should not be present in production code
+    //~^ unimplemented
+
     let b = a + 2;
 }
 
 fn unreachable() {
     let a = 2;
     unreachable!();
-    //~^ ERROR: usage of the `unreachable!` macro
-    //~| NOTE: `-D clippy::unreachable` implied by `-D warnings`
+    //~^ unreachable
+
     unreachable!("message");
-    //~^ ERROR: usage of the `unreachable!` macro
+    //~^ unreachable
+
     unreachable!("{} {}", "panic with", "multiple arguments");
-    //~^ ERROR: usage of the `unreachable!` macro
+    //~^ unreachable
+
     let b = a + 2;
 }
 
 fn core_versions() {
     use core::{panic, todo, unimplemented, unreachable};
     panic!();
-    //~^ ERROR: `panic` should not be present in production code
+    //~^ panic
+
     todo!();
-    //~^ ERROR: `todo` should not be present in production code
+    //~^ todo
+
     unimplemented!();
-    //~^ ERROR: `unimplemented` should not be present in production code
+    //~^ unimplemented
+
     unreachable!();
-    //~^ ERROR: usage of the `unreachable!` macro
+    //~^ unreachable
 }
 
 fn assert() {
diff --git a/src/tools/clippy/tests/ui/panicking_macros.stderr b/src/tools/clippy/tests/ui/panicking_macros.stderr
index 7c0f0a7d3764..03e459e4ec6e 100644
--- a/src/tools/clippy/tests/ui/panicking_macros.stderr
+++ b/src/tools/clippy/tests/ui/panicking_macros.stderr
@@ -14,13 +14,13 @@ LL |     panic!("message");
    |     ^^^^^^^^^^^^^^^^^
 
 error: `panic` should not be present in production code
-  --> tests/ui/panicking_macros.rs:27:5
+  --> tests/ui/panicking_macros.rs:28:5
    |
 LL |     panic!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:34:5
+  --> tests/ui/panicking_macros.rs:36:5
    |
 LL |     todo!();
    |     ^^^^^^^
@@ -29,19 +29,19 @@ LL |     todo!();
    = help: to override `-D warnings` add `#[allow(clippy::todo)]`
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:37:5
+  --> tests/ui/panicking_macros.rs:39:5
    |
 LL |     todo!("message");
    |     ^^^^^^^^^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:39:5
+  --> tests/ui/panicking_macros.rs:42:5
    |
 LL |     todo!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:46:5
+  --> tests/ui/panicking_macros.rs:50:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
@@ -50,19 +50,19 @@ LL |     unimplemented!();
    = help: to override `-D warnings` add `#[allow(clippy::unimplemented)]`
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:49:5
+  --> tests/ui/panicking_macros.rs:53:5
    |
 LL |     unimplemented!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:51:5
+  --> tests/ui/panicking_macros.rs:56:5
    |
 LL |     unimplemented!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:58:5
+  --> tests/ui/panicking_macros.rs:64:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
@@ -71,37 +71,37 @@ LL |     unreachable!();
    = help: to override `-D warnings` add `#[allow(clippy::unreachable)]`
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:61:5
+  --> tests/ui/panicking_macros.rs:67:5
    |
 LL |     unreachable!("message");
    |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:63:5
+  --> tests/ui/panicking_macros.rs:70:5
    |
 LL |     unreachable!("{} {}", "panic with", "multiple arguments");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: `panic` should not be present in production code
-  --> tests/ui/panicking_macros.rs:70:5
+  --> tests/ui/panicking_macros.rs:78:5
    |
 LL |     panic!();
    |     ^^^^^^^^
 
 error: `todo` should not be present in production code
-  --> tests/ui/panicking_macros.rs:72:5
+  --> tests/ui/panicking_macros.rs:81:5
    |
 LL |     todo!();
    |     ^^^^^^^
 
 error: `unimplemented` should not be present in production code
-  --> tests/ui/panicking_macros.rs:74:5
+  --> tests/ui/panicking_macros.rs:84:5
    |
 LL |     unimplemented!();
    |     ^^^^^^^^^^^^^^^^
 
 error: usage of the `unreachable!` macro
-  --> tests/ui/panicking_macros.rs:76:5
+  --> tests/ui/panicking_macros.rs:87:5
    |
 LL |     unreachable!();
    |     ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/panicking_overflow_checks.rs b/src/tools/clippy/tests/ui/panicking_overflow_checks.rs
index dc2ddeada1e9..29789c949756 100644
--- a/src/tools/clippy/tests/ui/panicking_overflow_checks.rs
+++ b/src/tools/clippy/tests/ui/panicking_overflow_checks.rs
@@ -2,14 +2,20 @@
 #![allow(clippy::needless_if)]
 
 fn test(a: u32, b: u32, c: u32) {
-    if a + b < a {} //~ panicking_overflow_checks
-    if a > a + b {} //~ panicking_overflow_checks
-    if a + b < b {} //~ panicking_overflow_checks
-    if b > a + b {} //~ panicking_overflow_checks
+    if a + b < a {}
+    //~^ panicking_overflow_checks
+    if a > a + b {}
+    //~^ panicking_overflow_checks
+    if a + b < b {}
+    //~^ panicking_overflow_checks
+    if b > a + b {}
+    //~^ panicking_overflow_checks
     if a - b > b {}
     if b < a - b {}
-    if a - b > a {} //~ panicking_overflow_checks
-    if a < a - b {} //~ panicking_overflow_checks
+    if a - b > a {}
+    //~^ panicking_overflow_checks
+    if a < a - b {}
+    //~^ panicking_overflow_checks
     if a + b < c {}
     if c > a + b {}
     if a - b < c {}
diff --git a/src/tools/clippy/tests/ui/panicking_overflow_checks.stderr b/src/tools/clippy/tests/ui/panicking_overflow_checks.stderr
index 1fae04578899..3022c9e52b0c 100644
--- a/src/tools/clippy/tests/ui/panicking_overflow_checks.stderr
+++ b/src/tools/clippy/tests/ui/panicking_overflow_checks.stderr
@@ -8,31 +8,31 @@ LL |     if a + b < a {}
    = help: to override `-D warnings` add `#[allow(clippy::panicking_overflow_checks)]`
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> tests/ui/panicking_overflow_checks.rs:6:8
+  --> tests/ui/panicking_overflow_checks.rs:7:8
    |
 LL |     if a > a + b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> tests/ui/panicking_overflow_checks.rs:7:8
+  --> tests/ui/panicking_overflow_checks.rs:9:8
    |
 LL |     if a + b < b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> tests/ui/panicking_overflow_checks.rs:8:8
+  --> tests/ui/panicking_overflow_checks.rs:11:8
    |
 LL |     if b > a + b {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> tests/ui/panicking_overflow_checks.rs:11:8
+  --> tests/ui/panicking_overflow_checks.rs:15:8
    |
 LL |     if a - b > a {}
    |        ^^^^^^^^^
 
 error: you are trying to use classic C overflow conditions that will fail in Rust
-  --> tests/ui/panicking_overflow_checks.rs:12:8
+  --> tests/ui/panicking_overflow_checks.rs:17:8
    |
 LL |     if a < a - b {}
    |        ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/partial_pub_fields.rs b/src/tools/clippy/tests/ui/partial_pub_fields.rs
index 316b36c25eac..27f4b2a0b4fc 100644
--- a/src/tools/clippy/tests/ui/partial_pub_fields.rs
+++ b/src/tools/clippy/tests/ui/partial_pub_fields.rs
@@ -8,23 +8,23 @@ fn main() {
     pub struct FileSet {
         files: HashMap<String, u32>,
         pub paths: HashMap<u32, String>,
-        //~^ ERROR: mixed usage of pub and non-pub fields
+        //~^ partial_pub_fields
     }
 
     pub struct Color {
         pub r: u8,
         pub g: u8,
         b: u8,
-        //~^ ERROR: mixed usage of pub and non-pub fields
+        //~^ partial_pub_fields
     }
 
     pub struct Point(i32, pub i32);
-    //~^ ERROR: mixed usage of pub and non-pub fields
+    //~^ partial_pub_fields
 
     pub struct Visibility {
         r#pub: bool,
         pub pos: u32,
-        //~^ ERROR: mixed usage of pub and non-pub fields
+        //~^ partial_pub_fields
     }
 
     // Don't lint on empty structs;
diff --git a/src/tools/clippy/tests/ui/partialeq_ne_impl.rs b/src/tools/clippy/tests/ui/partialeq_ne_impl.rs
index 555eeebe1c78..a3b2b68708ba 100644
--- a/src/tools/clippy/tests/ui/partialeq_ne_impl.rs
+++ b/src/tools/clippy/tests/ui/partialeq_ne_impl.rs
@@ -7,8 +7,8 @@ impl PartialEq for Foo {
         true
     }
     fn ne(&self, _: &Foo) -> bool {
-        //~^ ERROR: re-implementing `PartialEq::ne` is unnecessary
-        //~| NOTE: `-D clippy::partialeq-ne-impl` implied by `-D warnings`
+        //~^ partialeq_ne_impl
+
         false
     }
 }
diff --git a/src/tools/clippy/tests/ui/partialeq_to_none.fixed b/src/tools/clippy/tests/ui/partialeq_to_none.fixed
index 87adbca39484..e700cc56349f 100644
--- a/src/tools/clippy/tests/ui/partialeq_to_none.fixed
+++ b/src/tools/clippy/tests/ui/partialeq_to_none.fixed
@@ -12,6 +12,7 @@ impl PartialEq<Option<()>> for Foobar {
 #[allow(dead_code)]
 fn foo(f: Option<u32>) -> &'static str {
     if f.is_some() { "yay" } else { "nay" }
+    //~^ partialeq_to_none
 }
 
 fn foobar() -> Option<()> {
@@ -42,19 +43,28 @@ fn main() {
     let x = Some(0);
 
     let _ = x.is_none();
+    //~^ partialeq_to_none
     let _ = x.is_some();
+    //~^ partialeq_to_none
     let _ = x.is_none();
+    //~^ partialeq_to_none
     let _ = x.is_some();
+    //~^ partialeq_to_none
 
     if foobar().is_none() {}
+    //~^ partialeq_to_none
 
     if bar().ok().is_some() {}
+    //~^ partialeq_to_none
 
     let _ = Some(1 + 2).is_some();
+    //~^ partialeq_to_none
 
     let _ = { Some(0) }.is_none();
+    //~^ partialeq_to_none
 
     let _ = {
+        //~^ partialeq_to_none
         /*
           This comment runs long
         */
@@ -65,10 +75,15 @@ fn main() {
     let _ = Foobar == None;
 
     let _ = optref().is_none();
+    //~^ partialeq_to_none
     let _ = optref().is_some();
+    //~^ partialeq_to_none
     let _ = optref().is_none();
+    //~^ partialeq_to_none
     let _ = optref().is_some();
+    //~^ partialeq_to_none
 
     let x = Box::new(Option::<()>::None);
     let _ = (*x).is_some();
+    //~^ partialeq_to_none
 }
diff --git a/src/tools/clippy/tests/ui/partialeq_to_none.rs b/src/tools/clippy/tests/ui/partialeq_to_none.rs
index b623e6a66268..1bae076dd337 100644
--- a/src/tools/clippy/tests/ui/partialeq_to_none.rs
+++ b/src/tools/clippy/tests/ui/partialeq_to_none.rs
@@ -12,6 +12,7 @@ impl PartialEq<Option<()>> for Foobar {
 #[allow(dead_code)]
 fn foo(f: Option<u32>) -> &'static str {
     if f != None { "yay" } else { "nay" }
+    //~^ partialeq_to_none
 }
 
 fn foobar() -> Option<()> {
@@ -42,19 +43,28 @@ fn main() {
     let x = Some(0);
 
     let _ = x == None;
+    //~^ partialeq_to_none
     let _ = x != None;
+    //~^ partialeq_to_none
     let _ = None == x;
+    //~^ partialeq_to_none
     let _ = None != x;
+    //~^ partialeq_to_none
 
     if foobar() == None {}
+    //~^ partialeq_to_none
 
     if bar().ok() != None {}
+    //~^ partialeq_to_none
 
     let _ = Some(1 + 2) != None;
+    //~^ partialeq_to_none
 
     let _ = { Some(0) } == None;
+    //~^ partialeq_to_none
 
     let _ = {
+        //~^ partialeq_to_none
         /*
           This comment runs long
         */
@@ -65,10 +75,15 @@ fn main() {
     let _ = Foobar == None;
 
     let _ = optref() == &&None;
+    //~^ partialeq_to_none
     let _ = &&None != optref();
+    //~^ partialeq_to_none
     let _ = **optref() == None;
+    //~^ partialeq_to_none
     let _ = &None != *optref();
+    //~^ partialeq_to_none
 
     let x = Box::new(Option::<()>::None);
     let _ = None != *x;
+    //~^ partialeq_to_none
 }
diff --git a/src/tools/clippy/tests/ui/partialeq_to_none.stderr b/src/tools/clippy/tests/ui/partialeq_to_none.stderr
index b588fbf32b60..b09bd7fa0f42 100644
--- a/src/tools/clippy/tests/ui/partialeq_to_none.stderr
+++ b/src/tools/clippy/tests/ui/partialeq_to_none.stderr
@@ -8,58 +8,59 @@ LL |     if f != None { "yay" } else { "nay" }
    = help: to override `-D warnings` add `#[allow(clippy::partialeq_to_none)]`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:44:13
+  --> tests/ui/partialeq_to_none.rs:45:13
    |
 LL |     let _ = x == None;
    |             ^^^^^^^^^ help: use `Option::is_none()` instead: `x.is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:45:13
+  --> tests/ui/partialeq_to_none.rs:47:13
    |
 LL |     let _ = x != None;
    |             ^^^^^^^^^ help: use `Option::is_some()` instead: `x.is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:46:13
+  --> tests/ui/partialeq_to_none.rs:49:13
    |
 LL |     let _ = None == x;
    |             ^^^^^^^^^ help: use `Option::is_none()` instead: `x.is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:47:13
+  --> tests/ui/partialeq_to_none.rs:51:13
    |
 LL |     let _ = None != x;
    |             ^^^^^^^^^ help: use `Option::is_some()` instead: `x.is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:49:8
+  --> tests/ui/partialeq_to_none.rs:54:8
    |
 LL |     if foobar() == None {}
    |        ^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `foobar().is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:51:8
+  --> tests/ui/partialeq_to_none.rs:57:8
    |
 LL |     if bar().ok() != None {}
    |        ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `bar().ok().is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:53:13
+  --> tests/ui/partialeq_to_none.rs:60:13
    |
 LL |     let _ = Some(1 + 2) != None;
    |             ^^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `Some(1 + 2).is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:55:13
+  --> tests/ui/partialeq_to_none.rs:63:13
    |
 LL |     let _ = { Some(0) } == None;
    |             ^^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `{ Some(0) }.is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:57:13
+  --> tests/ui/partialeq_to_none.rs:66:13
    |
 LL |       let _ = {
    |  _____________^
+LL | |
 LL | |         /*
 LL | |           This comment runs long
 LL | |         */
@@ -70,6 +71,7 @@ LL | |     } != None;
 help: use `Option::is_some()` instead
    |
 LL ~     let _ = {
+LL +
 LL +         /*
 LL +           This comment runs long
 LL +         */
@@ -78,31 +80,31 @@ LL ~     }.is_some();
    |
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:67:13
+  --> tests/ui/partialeq_to_none.rs:77:13
    |
 LL |     let _ = optref() == &&None;
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `optref().is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:68:13
+  --> tests/ui/partialeq_to_none.rs:79:13
    |
 LL |     let _ = &&None != optref();
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `optref().is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:69:13
+  --> tests/ui/partialeq_to_none.rs:81:13
    |
 LL |     let _ = **optref() == None;
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_none()` instead: `optref().is_none()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:70:13
+  --> tests/ui/partialeq_to_none.rs:83:13
    |
 LL |     let _ = &None != *optref();
    |             ^^^^^^^^^^^^^^^^^^ help: use `Option::is_some()` instead: `optref().is_some()`
 
 error: binary comparison to literal `Option::None`
-  --> tests/ui/partialeq_to_none.rs:73:13
+  --> tests/ui/partialeq_to_none.rs:87:13
    |
 LL |     let _ = None != *x;
    |             ^^^^^^^^^^ help: use `Option::is_some()` instead: `(*x).is_some()`
diff --git a/src/tools/clippy/tests/ui/path_buf_push_overwrite.fixed b/src/tools/clippy/tests/ui/path_buf_push_overwrite.fixed
index 1a46d72378f8..5c818bad3d53 100644
--- a/src/tools/clippy/tests/ui/path_buf_push_overwrite.fixed
+++ b/src/tools/clippy/tests/ui/path_buf_push_overwrite.fixed
@@ -5,4 +5,5 @@ use std::path::PathBuf;
 fn main() {
     let mut x = PathBuf::from("/foo");
     x.push("bar");
+    //~^ path_buf_push_overwrite
 }
diff --git a/src/tools/clippy/tests/ui/path_buf_push_overwrite.rs b/src/tools/clippy/tests/ui/path_buf_push_overwrite.rs
index 3e3f84b17a4b..650ae3286a0c 100644
--- a/src/tools/clippy/tests/ui/path_buf_push_overwrite.rs
+++ b/src/tools/clippy/tests/ui/path_buf_push_overwrite.rs
@@ -5,4 +5,5 @@ use std::path::PathBuf;
 fn main() {
     let mut x = PathBuf::from("/foo");
     x.push("/bar");
+    //~^ path_buf_push_overwrite
 }
diff --git a/src/tools/clippy/tests/ui/path_ends_with_ext.fixed b/src/tools/clippy/tests/ui/path_ends_with_ext.fixed
index 49767e242cee..fa4286e11644 100644
--- a/src/tools/clippy/tests/ui/path_ends_with_ext.fixed
+++ b/src/tools/clippy/tests/ui/path_ends_with_ext.fixed
@@ -9,7 +9,7 @@ macro_rules! arg {
 
 fn test(path: &Path) {
     path.extension().is_some_and(|ext| ext == "md");
-    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+    //~^ path_ends_with_ext
 
     // some "extensions" are allowed by default
     path.ends_with(".git");
@@ -30,7 +30,7 @@ fn test(path: &Path) {
 #[clippy::msrv = "1.69"]
 fn under_msv(path: &Path) -> bool {
     path.extension().map_or(false, |ext| ext == "md")
-    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+    //~^ path_ends_with_ext
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/path_ends_with_ext.rs b/src/tools/clippy/tests/ui/path_ends_with_ext.rs
index 2dfd046218af..00d7ede8ef93 100644
--- a/src/tools/clippy/tests/ui/path_ends_with_ext.rs
+++ b/src/tools/clippy/tests/ui/path_ends_with_ext.rs
@@ -9,7 +9,7 @@ macro_rules! arg {
 
 fn test(path: &Path) {
     path.ends_with(".md");
-    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+    //~^ path_ends_with_ext
 
     // some "extensions" are allowed by default
     path.ends_with(".git");
@@ -30,7 +30,7 @@ fn test(path: &Path) {
 #[clippy::msrv = "1.69"]
 fn under_msv(path: &Path) -> bool {
     path.ends_with(".md")
-    //~^ ERROR: this looks like a failed attempt at checking for the file extension
+    //~^ path_ends_with_ext
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/pathbuf_init_then_push.rs b/src/tools/clippy/tests/ui/pathbuf_init_then_push.rs
index 4a7ae00a7352..7b65392e9519 100644
--- a/src/tools/clippy/tests/ui/pathbuf_init_then_push.rs
+++ b/src/tools/clippy/tests/ui/pathbuf_init_then_push.rs
@@ -3,17 +3,21 @@
 use std::path::PathBuf;
 
 fn main() {
-    let mut path_buf = PathBuf::new(); //~ ERROR: calls to `push` immediately after creation
+    let mut path_buf = PathBuf::new();
+    //~^ pathbuf_init_then_push
     path_buf.push("foo");
 
-    path_buf = PathBuf::from("foo"); //~ ERROR: calls to `push` immediately after creation
+    path_buf = PathBuf::from("foo");
+    //~^ pathbuf_init_then_push
     path_buf.push("bar");
 
     let bar = "bar";
-    path_buf = PathBuf::from("foo"); //~ ERROR: calls to `push` immediately after creation
+    path_buf = PathBuf::from("foo");
+    //~^ pathbuf_init_then_push
     path_buf.push(bar);
 
-    let mut path_buf = PathBuf::from("foo").join("bar"); //~ ERROR: calls to `push` immediately after creation
+    let mut path_buf = PathBuf::from("foo").join("bar");
+    //~^ pathbuf_init_then_push
     path_buf.push("buz");
 
     let mut x = PathBuf::new();
diff --git a/src/tools/clippy/tests/ui/pathbuf_init_then_push.stderr b/src/tools/clippy/tests/ui/pathbuf_init_then_push.stderr
index e7aa291035d2..1aa730a0bea2 100644
--- a/src/tools/clippy/tests/ui/pathbuf_init_then_push.stderr
+++ b/src/tools/clippy/tests/ui/pathbuf_init_then_push.stderr
@@ -2,6 +2,7 @@ error: calls to `push` immediately after creation
   --> tests/ui/pathbuf_init_then_push.rs:6:5
    |
 LL | /     let mut path_buf = PathBuf::new();
+LL | |
 LL | |     path_buf.push("foo");
    | |_________________________^ help: consider using the `.join()`: `let mut path_buf = PathBuf::from("foo");`
    |
@@ -9,23 +10,26 @@ LL | |     path_buf.push("foo");
    = help: to override `-D warnings` add `#[allow(clippy::pathbuf_init_then_push)]`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/pathbuf_init_then_push.rs:9:5
+  --> tests/ui/pathbuf_init_then_push.rs:10:5
    |
 LL | /     path_buf = PathBuf::from("foo");
+LL | |
 LL | |     path_buf.push("bar");
    | |_________________________^ help: consider using the `.join()`: `path_buf = PathBuf::from("foo").join("bar");`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/pathbuf_init_then_push.rs:13:5
+  --> tests/ui/pathbuf_init_then_push.rs:15:5
    |
 LL | /     path_buf = PathBuf::from("foo");
+LL | |
 LL | |     path_buf.push(bar);
    | |_______________________^ help: consider using the `.join()`: `path_buf = PathBuf::from("foo").join(bar);`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/pathbuf_init_then_push.rs:16:5
+  --> tests/ui/pathbuf_init_then_push.rs:19:5
    |
 LL | /     let mut path_buf = PathBuf::from("foo").join("bar");
+LL | |
 LL | |     path_buf.push("buz");
    | |_________________________^ help: consider using the `.join()`: `let mut path_buf = PathBuf::from("foo").join("bar").join("buz");`
 
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/mutability.rs b/src/tools/clippy/tests/ui/pattern_type_mismatch/mutability.rs
index 61dee47cb192..bdac3764bf16 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/mutability.rs
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/mutability.rs
@@ -7,14 +7,14 @@ fn should_lint() {
     let value = &Some(23);
     match value {
         Some(_) => (),
-        //~^ ERROR: type of pattern does not match the expression type
+        //~^ pattern_type_mismatch
         _ => (),
     }
 
     let value = &mut Some(23);
     match value {
         Some(_) => (),
-        //~^ ERROR: type of pattern does not match the expression type
+        //~^ pattern_type_mismatch
         _ => (),
     }
 }
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.rs b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.rs
index 558d496ae2c0..3c789f570b03 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.rs
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.rs
@@ -13,11 +13,13 @@ fn alternatives() {
 
     // not ok
     if let Value::B | Value::A(_) = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let &Value::B | &Value::A(Some(_)) = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let Value::B | Value::A(Some(_)) = *ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     if let &Value::B | &Value::A(_) = ref_value {}
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.stderr b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.stderr
index e1aec2497cd1..763f688ea897 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.stderr
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_alternatives.stderr
@@ -9,7 +9,7 @@ LL |     if let Value::B | Value::A(_) = ref_value {}
    = help: to override `-D warnings` add `#[allow(clippy::pattern_type_mismatch)]`
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_alternatives.rs:17:34
+  --> tests/ui/pattern_type_mismatch/pattern_alternatives.rs:18:34
    |
 LL |     if let &Value::B | &Value::A(Some(_)) = ref_value {}
    |                                  ^^^^^^^
@@ -17,7 +17,7 @@ LL |     if let &Value::B | &Value::A(Some(_)) = ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_alternatives.rs:19:32
+  --> tests/ui/pattern_type_mismatch/pattern_alternatives.rs:21:32
    |
 LL |     if let Value::B | Value::A(Some(_)) = *ref_value {}
    |                                ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.rs b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.rs
index d9b22693f297..7fc53d591a91 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.rs
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.rs
@@ -11,11 +11,13 @@ fn struct_types() {
 
     // not ok
     let Struct { .. } = ref_value;
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let &Struct { ref_inner: Some(_) } = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let Struct { ref_inner: Some(_) } = *ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     let &Struct { .. } = ref_value;
@@ -33,15 +35,19 @@ fn struct_enum_variants() {
 
     // not ok
     if let StructEnum::Var { .. } = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let StructEnum::Var { inner_ref: Some(_) } = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let &StructEnum::Var { inner_ref: Some(_) } = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let StructEnum::Var { inner_ref: Some(_) } = *ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let StructEnum::Empty = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     if let &StructEnum::Var { .. } = ref_value {}
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.stderr b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.stderr
index e5d6e9ed6f81..70f7bdc38906 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.stderr
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_structs.stderr
@@ -9,7 +9,7 @@ LL |     let Struct { .. } = ref_value;
    = help: to override `-D warnings` add `#[allow(clippy::pattern_type_mismatch)]`
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:15:33
+  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:16:33
    |
 LL |     if let &Struct { ref_inner: Some(_) } = ref_value {}
    |                                 ^^^^^^^
@@ -17,7 +17,7 @@ LL |     if let &Struct { ref_inner: Some(_) } = ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:17:32
+  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:19:32
    |
 LL |     if let Struct { ref_inner: Some(_) } = *ref_value {}
    |                                ^^^^^^^
@@ -25,7 +25,7 @@ LL |     if let Struct { ref_inner: Some(_) } = *ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:35:12
+  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:37:12
    |
 LL |     if let StructEnum::Var { .. } = ref_value {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     if let StructEnum::Var { .. } = ref_value {}
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:37:12
+  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:40:12
    |
 LL |     if let StructEnum::Var { inner_ref: Some(_) } = ref_value {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     if let StructEnum::Var { inner_ref: Some(_) } = ref_value {}
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:39:42
+  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:43:42
    |
 LL |     if let &StructEnum::Var { inner_ref: Some(_) } = ref_value {}
    |                                          ^^^^^^^
@@ -49,7 +49,7 @@ LL |     if let &StructEnum::Var { inner_ref: Some(_) } = ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:41:41
+  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:46:41
    |
 LL |     if let StructEnum::Var { inner_ref: Some(_) } = *ref_value {}
    |                                         ^^^^^^^
@@ -57,7 +57,7 @@ LL |     if let StructEnum::Var { inner_ref: Some(_) } = *ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:43:12
+  --> tests/ui/pattern_type_mismatch/pattern_structs.rs:49:12
    |
 LL |     if let StructEnum::Empty = ref_value {}
    |            ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.rs b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.rs
index f44e3543c96a..ecd95d9ae2b3 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.rs
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.rs
@@ -9,11 +9,13 @@ fn tuple_types() {
 
     // not ok
     let TupleStruct(_) = ref_value;
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let &TupleStruct(Some(_)) = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let TupleStruct(Some(_)) = *ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     let &TupleStruct(_) = ref_value;
@@ -31,13 +33,16 @@ fn tuple_enum_variants() {
 
     // not ok
     if let TupleEnum::Var(_) = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let &TupleEnum::Var(Some(_)) = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let TupleEnum::Var(Some(_)) = *ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let TupleEnum::Empty = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     if let &TupleEnum::Var(_) = ref_value {}
@@ -53,11 +58,13 @@ fn plain_tuples() {
 
     // not ok
     let (_a, _b) = ref_value;
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let &(_a, Some(_)) = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
+
     if let (_a, Some(_)) = *ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     let &(_a, _b) = ref_value;
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.stderr b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.stderr
index 9ecf12a1d639..d47c5d509c3f 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.stderr
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/pattern_tuples.stderr
@@ -9,7 +9,7 @@ LL |     let TupleStruct(_) = ref_value;
    = help: to override `-D warnings` add `#[allow(clippy::pattern_type_mismatch)]`
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:13:25
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:14:25
    |
 LL |     if let &TupleStruct(Some(_)) = ref_value {}
    |                         ^^^^^^^
@@ -17,7 +17,7 @@ LL |     if let &TupleStruct(Some(_)) = ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:15:24
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:17:24
    |
 LL |     if let TupleStruct(Some(_)) = *ref_value {}
    |                        ^^^^^^^
@@ -25,7 +25,7 @@ LL |     if let TupleStruct(Some(_)) = *ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:33:12
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:35:12
    |
 LL |     if let TupleEnum::Var(_) = ref_value {}
    |            ^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     if let TupleEnum::Var(_) = ref_value {}
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:35:28
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:38:28
    |
 LL |     if let &TupleEnum::Var(Some(_)) = ref_value {}
    |                            ^^^^^^^
@@ -41,7 +41,7 @@ LL |     if let &TupleEnum::Var(Some(_)) = ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:37:27
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:41:27
    |
 LL |     if let TupleEnum::Var(Some(_)) = *ref_value {}
    |                           ^^^^^^^
@@ -49,7 +49,7 @@ LL |     if let TupleEnum::Var(Some(_)) = *ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:39:12
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:44:12
    |
 LL |     if let TupleEnum::Empty = ref_value {}
    |            ^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     if let TupleEnum::Empty = ref_value {}
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:55:9
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:60:9
    |
 LL |     let (_a, _b) = ref_value;
    |         ^^^^^^^^
@@ -65,7 +65,7 @@ LL |     let (_a, _b) = ref_value;
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:57:18
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:63:18
    |
 LL |     if let &(_a, Some(_)) = ref_value {}
    |                  ^^^^^^^
@@ -73,7 +73,7 @@ LL |     if let &(_a, Some(_)) = ref_value {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:59:17
+  --> tests/ui/pattern_type_mismatch/pattern_tuples.rs:66:17
    |
 LL |     if let (_a, Some(_)) = *ref_value {}
    |                 ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.rs b/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.rs
index dbc7c3f31061..0bbc26a0c27c 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.rs
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.rs
@@ -9,7 +9,7 @@ fn syntax_match() {
     // not ok
     match ref_value {
         Some(_) => (),
-        //~^ ERROR: type of pattern does not match the expression type
+        //~^ pattern_type_mismatch
         None => (),
     }
 
@@ -29,7 +29,7 @@ fn syntax_if_let() {
 
     // not ok
     if let Some(_) = ref_value {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     if let &Some(_) = ref_value {}
@@ -41,7 +41,8 @@ fn syntax_while_let() {
 
     // not ok
     while let Some(_) = ref_value {
-        //~^ ERROR: type of pattern does not match the expression type
+        //~^ pattern_type_mismatch
+
         break;
     }
 
@@ -60,7 +61,7 @@ fn syntax_for() {
 
     // not ok
     for (_a, _b) in slice.iter() {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     for &(_a, _b) in slice.iter() {}
@@ -71,7 +72,7 @@ fn syntax_let() {
 
     // not ok
     let (_n, _m) = ref_value;
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     let &(_n, _m) = ref_value;
@@ -81,7 +82,7 @@ fn syntax_let() {
 fn syntax_fn() {
     // not ok
     fn foo((_a, _b): &(i32, i32)) {}
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     fn foo_ok_1(&(_a, _b): &(i32, i32)) {}
@@ -96,7 +97,7 @@ fn syntax_closure() {
 
     // not ok
     foo(|(_a, _b)| ());
-    //~^ ERROR: type of pattern does not match the expression type
+    //~^ pattern_type_mismatch
 
     // ok
     foo(|&(_a, _b)| ());
@@ -113,7 +114,7 @@ fn macro_with_expression() {
     // not ok
     matching_macro!(match value {
         Some(_) => (),
-        //~^ ERROR: type of pattern does not match the expression type
+        //~^ pattern_type_mismatch
         _ => (),
     });
 
@@ -134,6 +135,7 @@ fn macro_expansion() {
             // not ok
             match $e {
                 Some(_) => (),
+                //~^ pattern_type_mismatch
                 _ => (),
             }
 
diff --git a/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.stderr b/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.stderr
index 9186a01b9c75..3f6b5feb9b07 100644
--- a/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.stderr
+++ b/src/tools/clippy/tests/ui/pattern_type_mismatch/syntax.stderr
@@ -25,7 +25,7 @@ LL |     while let Some(_) = ref_value {
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/syntax.rs:62:9
+  --> tests/ui/pattern_type_mismatch/syntax.rs:63:9
    |
 LL |     for (_a, _b) in slice.iter() {}
    |         ^^^^^^^^
@@ -33,7 +33,7 @@ LL |     for (_a, _b) in slice.iter() {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/syntax.rs:73:9
+  --> tests/ui/pattern_type_mismatch/syntax.rs:74:9
    |
 LL |     let (_n, _m) = ref_value;
    |         ^^^^^^^^
@@ -41,7 +41,7 @@ LL |     let (_n, _m) = ref_value;
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/syntax.rs:83:12
+  --> tests/ui/pattern_type_mismatch/syntax.rs:84:12
    |
 LL |     fn foo((_a, _b): &(i32, i32)) {}
    |            ^^^^^^^^
@@ -49,7 +49,7 @@ LL |     fn foo((_a, _b): &(i32, i32)) {}
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/syntax.rs:98:10
+  --> tests/ui/pattern_type_mismatch/syntax.rs:99:10
    |
 LL |     foo(|(_a, _b)| ());
    |          ^^^^^^^^
@@ -57,7 +57,7 @@ LL |     foo(|(_a, _b)| ());
    = help: explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/syntax.rs:115:9
+  --> tests/ui/pattern_type_mismatch/syntax.rs:116:9
    |
 LL |         Some(_) => (),
    |         ^^^^^^^
@@ -65,7 +65,7 @@ LL |         Some(_) => (),
    = help: use `*` to dereference the match expression or explicitly match against a `&_` pattern and adjust the enclosed variable bindings
 
 error: type of pattern does not match the expression type
-  --> tests/ui/pattern_type_mismatch/syntax.rs:136:17
+  --> tests/ui/pattern_type_mismatch/syntax.rs:137:17
    |
 LL |                 Some(_) => (),
    |                 ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/patterns.fixed b/src/tools/clippy/tests/ui/patterns.fixed
index feaec33ac15a..bcb8ecfc38d2 100644
--- a/src/tools/clippy/tests/ui/patterns.fixed
+++ b/src/tools/clippy/tests/ui/patterns.fixed
@@ -12,6 +12,7 @@ fn main() {
     match v {
         Some(x) => (),
         y => (),
+        //~^ redundant_pattern
     }
     match v {
         Some(x) => (),
@@ -27,6 +28,7 @@ fn main() {
     // required "ref" left out in suggestion: #5271
     match mutv {
         ref mut x => {
+            //~^ redundant_pattern
             x.push(4);
             println!("vec: {:?}", x);
         },
@@ -35,6 +37,7 @@ fn main() {
 
     match mutv {
         ref x => println!("vec: {:?}", x),
+        //~^ redundant_pattern
         ref y if y == &vec![0] => (),
     }
     external! {
diff --git a/src/tools/clippy/tests/ui/patterns.rs b/src/tools/clippy/tests/ui/patterns.rs
index 53812c7deec3..19639ebd13d6 100644
--- a/src/tools/clippy/tests/ui/patterns.rs
+++ b/src/tools/clippy/tests/ui/patterns.rs
@@ -12,6 +12,7 @@ fn main() {
     match v {
         Some(x) => (),
         y @ _ => (),
+        //~^ redundant_pattern
     }
     match v {
         Some(x) => (),
@@ -27,6 +28,7 @@ fn main() {
     // required "ref" left out in suggestion: #5271
     match mutv {
         ref mut x @ _ => {
+            //~^ redundant_pattern
             x.push(4);
             println!("vec: {:?}", x);
         },
@@ -35,6 +37,7 @@ fn main() {
 
     match mutv {
         ref x @ _ => println!("vec: {:?}", x),
+        //~^ redundant_pattern
         ref y if y == &vec![0] => (),
     }
     external! {
diff --git a/src/tools/clippy/tests/ui/patterns.stderr b/src/tools/clippy/tests/ui/patterns.stderr
index fa4cf7f83562..b9950fe181cc 100644
--- a/src/tools/clippy/tests/ui/patterns.stderr
+++ b/src/tools/clippy/tests/ui/patterns.stderr
@@ -8,13 +8,13 @@ LL |         y @ _ => (),
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern)]`
 
 error: the `x @ _` pattern can be written as just `x`
-  --> tests/ui/patterns.rs:29:9
+  --> tests/ui/patterns.rs:30:9
    |
 LL |         ref mut x @ _ => {
    |         ^^^^^^^^^^^^^ help: try: `ref mut x`
 
 error: the `x @ _` pattern can be written as just `x`
-  --> tests/ui/patterns.rs:37:9
+  --> tests/ui/patterns.rs:39:9
    |
 LL |         ref x @ _ => println!("vec: {:?}", x),
    |         ^^^^^^^^^ help: try: `ref x`
diff --git a/src/tools/clippy/tests/ui/permissions_set_readonly_false.rs b/src/tools/clippy/tests/ui/permissions_set_readonly_false.rs
index 5a84a64fd2d1..ccca523da551 100644
--- a/src/tools/clippy/tests/ui/permissions_set_readonly_false.rs
+++ b/src/tools/clippy/tests/ui/permissions_set_readonly_false.rs
@@ -17,8 +17,8 @@ fn main() {
     let mut permissions = metadata.permissions();
     // lint here
     permissions.set_readonly(false);
-    //~^ ERROR: call to `set_readonly` with argument `false`
-    //~| NOTE: on Unix platforms this results in the file being world writable
+    //~^ permissions_set_readonly_false
+
     // no lint
     permissions.set_readonly(true);
 
diff --git a/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.rs b/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.rs
index b5abcbb3474c..171716be2602 100644
--- a/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.rs
+++ b/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.rs
@@ -9,7 +9,8 @@ unsafe fn nomem_bad(p: &i32) {
     asm!(
         "asdf {p1}, {p2}, {p3}",
         p1 = in(reg) p,
-        //~^ ERROR: passing pointers to nomem asm block
+        //~^ pointers_in_nomem_asm_block
+
         p2 = in(reg) p as *const _ as usize,
         p3 = in(reg) p,
         options(nomem, nostack, preserves_flags)
@@ -24,10 +25,10 @@ unsafe fn nomem_good(p: &i32) {
 
 unsafe fn nomem_bad2(p: &mut i32) {
     asm!("asdf {p}", p = in(reg) p, options(nomem, nostack, preserves_flags));
-    //~^ ERROR: passing pointers to nomem asm block
+    //~^ pointers_in_nomem_asm_block
 }
 
 unsafe fn nomem_fn(p: extern "C" fn()) {
     asm!("call {p}", p = in(reg) p, options(nomem));
-    //~^ ERROR: passing pointers to nomem asm block
+    //~^ pointers_in_nomem_asm_block
 }
diff --git a/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.stderr b/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.stderr
index cabeb37344f2..ca24e34f63c0 100644
--- a/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.stderr
+++ b/src/tools/clippy/tests/ui/pointers_in_nomem_asm_block.stderr
@@ -13,7 +13,7 @@ LL |         p3 = in(reg) p,
    = help: to override `-D warnings` add `#[allow(clippy::pointers_in_nomem_asm_block)]`
 
 error: passing pointers to nomem asm block
-  --> tests/ui/pointers_in_nomem_asm_block.rs:26:22
+  --> tests/ui/pointers_in_nomem_asm_block.rs:27:22
    |
 LL |     asm!("asdf {p}", p = in(reg) p, options(nomem, nostack, preserves_flags));
    |                      ^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |     asm!("asdf {p}", p = in(reg) p, options(nomem, nostack, preserves_flags
    = note: if this is intentional and no pointers are read or written to, consider allowing the lint
 
 error: passing pointers to nomem asm block
-  --> tests/ui/pointers_in_nomem_asm_block.rs:31:22
+  --> tests/ui/pointers_in_nomem_asm_block.rs:32:22
    |
 LL |     asm!("call {p}", p = in(reg) p, options(nomem));
    |                      ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/precedence.fixed b/src/tools/clippy/tests/ui/precedence.fixed
index 52144a18bac0..cbb78bff68bf 100644
--- a/src/tools/clippy/tests/ui/precedence.fixed
+++ b/src/tools/clippy/tests/ui/precedence.fixed
@@ -14,12 +14,19 @@ macro_rules! trip {
 
 fn main() {
     1 << (2 + 3);
+    //~^ precedence
     (1 + 2) << 3;
+    //~^ precedence
     4 >> (1 + 1);
+    //~^ precedence
     (1 + 3) >> 2;
+    //~^ precedence
     1 ^ (1 - 1);
+    //~^ precedence
     3 | (2 - 1);
+    //~^ precedence
     3 & (5 - 2);
+    //~^ precedence
     0x0F00 & 0x00F0 << 4;
     0x0F00 & 0xF000 >> 4;
     0x0F00 << 1 ^ 3;
diff --git a/src/tools/clippy/tests/ui/precedence.rs b/src/tools/clippy/tests/ui/precedence.rs
index 9ef5c43833f8..c73a4020e2e5 100644
--- a/src/tools/clippy/tests/ui/precedence.rs
+++ b/src/tools/clippy/tests/ui/precedence.rs
@@ -14,12 +14,19 @@ macro_rules! trip {
 
 fn main() {
     1 << 2 + 3;
+    //~^ precedence
     1 + 2 << 3;
+    //~^ precedence
     4 >> 1 + 1;
+    //~^ precedence
     1 + 3 >> 2;
+    //~^ precedence
     1 ^ 1 - 1;
+    //~^ precedence
     3 | 2 - 1;
+    //~^ precedence
     3 & 5 - 2;
+    //~^ precedence
     0x0F00 & 0x00F0 << 4;
     0x0F00 & 0xF000 >> 4;
     0x0F00 << 1 ^ 3;
diff --git a/src/tools/clippy/tests/ui/precedence.stderr b/src/tools/clippy/tests/ui/precedence.stderr
index 68ad5cb4829a..50cd8f4b8146 100644
--- a/src/tools/clippy/tests/ui/precedence.stderr
+++ b/src/tools/clippy/tests/ui/precedence.stderr
@@ -8,37 +8,37 @@ LL |     1 << 2 + 3;
    = help: to override `-D warnings` add `#[allow(clippy::precedence)]`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence.rs:17:5
+  --> tests/ui/precedence.rs:18:5
    |
 LL |     1 + 2 << 3;
    |     ^^^^^^^^^^ help: consider parenthesizing your expression: `(1 + 2) << 3`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence.rs:18:5
+  --> tests/ui/precedence.rs:20:5
    |
 LL |     4 >> 1 + 1;
    |     ^^^^^^^^^^ help: consider parenthesizing your expression: `4 >> (1 + 1)`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence.rs:19:5
+  --> tests/ui/precedence.rs:22:5
    |
 LL |     1 + 3 >> 2;
    |     ^^^^^^^^^^ help: consider parenthesizing your expression: `(1 + 3) >> 2`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence.rs:20:5
+  --> tests/ui/precedence.rs:24:5
    |
 LL |     1 ^ 1 - 1;
    |     ^^^^^^^^^ help: consider parenthesizing your expression: `1 ^ (1 - 1)`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence.rs:21:5
+  --> tests/ui/precedence.rs:26:5
    |
 LL |     3 | 2 - 1;
    |     ^^^^^^^^^ help: consider parenthesizing your expression: `3 | (2 - 1)`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence.rs:22:5
+  --> tests/ui/precedence.rs:28:5
    |
 LL |     3 & 5 - 2;
    |     ^^^^^^^^^ help: consider parenthesizing your expression: `3 & (5 - 2)`
diff --git a/src/tools/clippy/tests/ui/precedence_bits.fixed b/src/tools/clippy/tests/ui/precedence_bits.fixed
index 82fea0d14e43..e0ce4a992bb1 100644
--- a/src/tools/clippy/tests/ui/precedence_bits.fixed
+++ b/src/tools/clippy/tests/ui/precedence_bits.fixed
@@ -26,9 +26,13 @@ fn main() {
     3 | 2 - 1;
     3 & 5 - 2;
     0x0F00 & (0x00F0 << 4);
+    //~^ precedence_bits
     0x0F00 & (0xF000 >> 4);
+    //~^ precedence_bits
     (0x0F00 << 1) ^ 3;
+    //~^ precedence_bits
     (0x0F00 << 1) | 2;
+    //~^ precedence_bits
 
     let b = 3;
     trip!(b * 8);
diff --git a/src/tools/clippy/tests/ui/precedence_bits.rs b/src/tools/clippy/tests/ui/precedence_bits.rs
index 9b353308b6ee..20d17e26c355 100644
--- a/src/tools/clippy/tests/ui/precedence_bits.rs
+++ b/src/tools/clippy/tests/ui/precedence_bits.rs
@@ -26,9 +26,13 @@ fn main() {
     3 | 2 - 1;
     3 & 5 - 2;
     0x0F00 & 0x00F0 << 4;
+    //~^ precedence_bits
     0x0F00 & 0xF000 >> 4;
+    //~^ precedence_bits
     0x0F00 << 1 ^ 3;
+    //~^ precedence_bits
     0x0F00 << 1 | 2;
+    //~^ precedence_bits
 
     let b = 3;
     trip!(b * 8);
diff --git a/src/tools/clippy/tests/ui/precedence_bits.stderr b/src/tools/clippy/tests/ui/precedence_bits.stderr
index f468186b363c..9cbdca8956d6 100644
--- a/src/tools/clippy/tests/ui/precedence_bits.stderr
+++ b/src/tools/clippy/tests/ui/precedence_bits.stderr
@@ -8,19 +8,19 @@ LL |     0x0F00 & 0x00F0 << 4;
    = help: to override `-D warnings` add `#[allow(clippy::precedence_bits)]`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence_bits.rs:29:5
+  --> tests/ui/precedence_bits.rs:30:5
    |
 LL |     0x0F00 & 0xF000 >> 4;
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider parenthesizing your expression: `0x0F00 & (0xF000 >> 4)`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence_bits.rs:30:5
+  --> tests/ui/precedence_bits.rs:32:5
    |
 LL |     0x0F00 << 1 ^ 3;
    |     ^^^^^^^^^^^^^^^ help: consider parenthesizing your expression: `(0x0F00 << 1) ^ 3`
 
 error: operator precedence might not be obvious
-  --> tests/ui/precedence_bits.rs:31:5
+  --> tests/ui/precedence_bits.rs:34:5
    |
 LL |     0x0F00 << 1 | 2;
    |     ^^^^^^^^^^^^^^^ help: consider parenthesizing your expression: `(0x0F00 << 1) | 2`
diff --git a/src/tools/clippy/tests/ui/print.rs b/src/tools/clippy/tests/ui/print.rs
index 9ac4b51e1afd..ee3d9dc0de03 100644
--- a/src/tools/clippy/tests/ui/print.rs
+++ b/src/tools/clippy/tests/ui/print.rs
@@ -9,8 +9,7 @@ struct Foo;
 impl Display for Foo {
     fn fmt(&self, f: &mut Formatter) -> Result {
         write!(f, "{:?}", 43.1415)
-        //~^ ERROR: use of `Debug`-based formatting
-        //~| NOTE: `-D clippy::use-debug` implied by `-D warnings`
+        //~^ use_debug
     }
 }
 
@@ -23,21 +22,21 @@ impl Debug for Foo {
 
 fn main() {
     println!("Hello");
-    //~^ ERROR: use of `println!`
-    //~| NOTE: `-D clippy::print-stdout` implied by `-D warnings`
+    //~^ print_stdout
+
     print!("Hello");
-    //~^ ERROR: use of `print!`
+    //~^ print_stdout
 
     print!("Hello {}", "World");
-    //~^ ERROR: use of `print!`
+    //~^ print_stdout
 
     print!("Hello {:?}", "World");
-    //~^ ERROR: use of `print!`
-    //~| ERROR: use of `Debug`-based formatting
+    //~^ print_stdout
+    //~| use_debug
 
     print!("Hello {:#?}", "#orld");
-    //~^ ERROR: use of `print!`
-    //~| ERROR: use of `Debug`-based formatting
+    //~^ print_stdout
+    //~| use_debug
 
     assert_eq!(42, 1337);
 
diff --git a/src/tools/clippy/tests/ui/print.stderr b/src/tools/clippy/tests/ui/print.stderr
index a8374241c831..9dd216bd1449 100644
--- a/src/tools/clippy/tests/ui/print.stderr
+++ b/src/tools/clippy/tests/ui/print.stderr
@@ -8,7 +8,7 @@ LL |         write!(f, "{:?}", 43.1415)
    = help: to override `-D warnings` add `#[allow(clippy::use_debug)]`
 
 error: use of `println!`
-  --> tests/ui/print.rs:25:5
+  --> tests/ui/print.rs:24:5
    |
 LL |     println!("Hello");
    |     ^^^^^^^^^^^^^^^^^
@@ -17,37 +17,37 @@ LL |     println!("Hello");
    = help: to override `-D warnings` add `#[allow(clippy::print_stdout)]`
 
 error: use of `print!`
-  --> tests/ui/print.rs:28:5
+  --> tests/ui/print.rs:27:5
    |
 LL |     print!("Hello");
    |     ^^^^^^^^^^^^^^^
 
 error: use of `print!`
-  --> tests/ui/print.rs:31:5
+  --> tests/ui/print.rs:30:5
    |
 LL |     print!("Hello {}", "World");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of `print!`
-  --> tests/ui/print.rs:34:5
+  --> tests/ui/print.rs:33:5
    |
 LL |     print!("Hello {:?}", "World");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of `Debug`-based formatting
-  --> tests/ui/print.rs:34:19
+  --> tests/ui/print.rs:33:19
    |
 LL |     print!("Hello {:?}", "World");
    |                   ^^^^
 
 error: use of `print!`
-  --> tests/ui/print.rs:38:5
+  --> tests/ui/print.rs:37:5
    |
 LL |     print!("Hello {:#?}", "#orld");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: use of `Debug`-based formatting
-  --> tests/ui/print.rs:38:19
+  --> tests/ui/print.rs:37:19
    |
 LL |     print!("Hello {:#?}", "#orld");
    |                   ^^^^^
diff --git a/src/tools/clippy/tests/ui/print_in_format_impl.rs b/src/tools/clippy/tests/ui/print_in_format_impl.rs
index 261f50832199..8bc704921220 100644
--- a/src/tools/clippy/tests/ui/print_in_format_impl.rs
+++ b/src/tools/clippy/tests/ui/print_in_format_impl.rs
@@ -18,17 +18,21 @@ impl Debug for Foo {
         static WORKS_WITH_NESTED_ITEMS: bool = true;
 
         print!("{}", 1);
-        //~^ ERROR: use of `print!` in `Debug` impl
-        //~| NOTE: `-D clippy::print-in-format-impl` implied by `-D warnings`
+        //~^ print_in_format_impl
+
         println!("{}", 2);
-        //~^ ERROR: use of `println!` in `Debug` impl
+        //~^ print_in_format_impl
+
         eprint!("{}", 3);
-        //~^ ERROR: use of `eprint!` in `Debug` impl
+        //~^ print_in_format_impl
+
         eprintln!("{}", 4);
-        //~^ ERROR: use of `eprintln!` in `Debug` impl
+        //~^ print_in_format_impl
+
         nested! {
             println!("nested");
-            //~^ ERROR: use of `println!` in `Debug` impl
+            //~^ print_in_format_impl
+
         };
 
         write!(f, "{}", 5);
@@ -42,7 +46,8 @@ impl Debug for Foo {
 impl Display for Foo {
     fn fmt(&self, f: &mut Formatter) -> Result<(), Error> {
         print!("Display");
-        //~^ ERROR: use of `print!` in `Display` impl
+        //~^ print_in_format_impl
+
         write!(f, "Display");
 
         Ok(())
@@ -53,7 +58,8 @@ struct UnnamedFormatter;
 impl Debug for UnnamedFormatter {
     fn fmt(&self, _: &mut Formatter) -> Result<(), Error> {
         println!("UnnamedFormatter");
-        //~^ ERROR: use of `println!` in `Debug` impl
+        //~^ print_in_format_impl
+
         Ok(())
     }
 }
diff --git a/src/tools/clippy/tests/ui/print_in_format_impl.stderr b/src/tools/clippy/tests/ui/print_in_format_impl.stderr
index 3fb6b3f9c911..91d6ce953849 100644
--- a/src/tools/clippy/tests/ui/print_in_format_impl.stderr
+++ b/src/tools/clippy/tests/ui/print_in_format_impl.stderr
@@ -14,31 +14,31 @@ LL |         println!("{}", 2);
    |         ^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(f, ..)`
 
 error: use of `eprint!` in `Debug` impl
-  --> tests/ui/print_in_format_impl.rs:25:9
+  --> tests/ui/print_in_format_impl.rs:26:9
    |
 LL |         eprint!("{}", 3);
    |         ^^^^^^^^^^^^^^^^ help: replace with: `write!(f, ..)`
 
 error: use of `eprintln!` in `Debug` impl
-  --> tests/ui/print_in_format_impl.rs:27:9
+  --> tests/ui/print_in_format_impl.rs:29:9
    |
 LL |         eprintln!("{}", 4);
    |         ^^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(f, ..)`
 
 error: use of `println!` in `Debug` impl
-  --> tests/ui/print_in_format_impl.rs:30:13
+  --> tests/ui/print_in_format_impl.rs:33:13
    |
 LL |             println!("nested");
    |             ^^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(f, ..)`
 
 error: use of `print!` in `Display` impl
-  --> tests/ui/print_in_format_impl.rs:44:9
+  --> tests/ui/print_in_format_impl.rs:48:9
    |
 LL |         print!("Display");
    |         ^^^^^^^^^^^^^^^^^ help: replace with: `write!(f, ..)`
 
 error: use of `println!` in `Debug` impl
-  --> tests/ui/print_in_format_impl.rs:55:9
+  --> tests/ui/print_in_format_impl.rs:60:9
    |
 LL |         println!("UnnamedFormatter");
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `writeln!(..)`
diff --git a/src/tools/clippy/tests/ui/print_literal.fixed b/src/tools/clippy/tests/ui/print_literal.fixed
index 328e9a9b999f..24c45a4a61b9 100644
--- a/src/tools/clippy/tests/ui/print_literal.fixed
+++ b/src/tools/clippy/tests/ui/print_literal.fixed
@@ -25,28 +25,32 @@ fn main() {
 
     // these should throw warnings
     print!("Hello world");
-    //~^ ERROR: literal with an empty format string
-    //~| NOTE: `-D clippy::print-literal` implied by `-D warnings`
+    //~^ print_literal
+
     println!("Hello {} world", world);
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("Hello world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("a literal {:.4}", 5);
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
 
     // positional args don't change the fact
     // that we're using a literal -- this should
     // throw a warning
     println!("hello world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("world hello");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
 
     // named args shouldn't change anything either
     println!("hello world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("world hello");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
 
     // The string literal from `file!()` has a callsite span that isn't marked as coming from an
     // expansion
@@ -54,23 +58,33 @@ fn main() {
 
     // Braces in unicode escapes should not be escaped
     println!("{{}} \x00 \u{ab123} \\\u{ab123} {{:?}}");
+    //~^ print_literal
     println!("\\\u{1234}");
+    //~^ print_literal
     // This does not lint because it would have to suggest unescaping the character
     println!(r"{}", "\u{ab123}");
     // These are not unicode escapes
     println!("\\u{{ab123}} \\u{{{{");
+    //~^ print_literal
     println!(r"\u{{ab123}} \u{{{{");
+    //~^ print_literal
     println!("\\{{ab123}} \\u{{{{");
+    //~^ print_literal
     println!("\\u{{ab123}}");
+    //~^ print_literal
     println!("\\\\u{{1234}}");
+    //~^ print_literal
 
     println!("mixed: {{hello}} {world}");
+    //~^ print_literal
 }
 
 fn issue_13959() {
     println!("\"");
+    //~^ print_literal
     println!(
         "
+        //~^ print_literal
         foo
         \\
         \\\\
diff --git a/src/tools/clippy/tests/ui/print_literal.rs b/src/tools/clippy/tests/ui/print_literal.rs
index 3130d0b6998e..42ae589ca639 100644
--- a/src/tools/clippy/tests/ui/print_literal.rs
+++ b/src/tools/clippy/tests/ui/print_literal.rs
@@ -25,28 +25,32 @@ fn main() {
 
     // these should throw warnings
     print!("Hello {}", "world");
-    //~^ ERROR: literal with an empty format string
-    //~| NOTE: `-D clippy::print-literal` implied by `-D warnings`
+    //~^ print_literal
+
     println!("Hello {} {}", world, "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("Hello {}", "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("{} {:.4}", "a literal", 5);
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
 
     // positional args don't change the fact
     // that we're using a literal -- this should
     // throw a warning
     println!("{0} {1}", "hello", "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("{1} {0}", "hello", "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
 
     // named args shouldn't change anything either
     println!("{foo} {bar}", foo = "hello", bar = "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
+
     println!("{bar} {foo}", foo = "hello", bar = "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ print_literal
 
     // The string literal from `file!()` has a callsite span that isn't marked as coming from an
     // expansion
@@ -54,24 +58,34 @@ fn main() {
 
     // Braces in unicode escapes should not be escaped
     println!("{}", "{} \x00 \u{ab123} \\\u{ab123} {:?}");
+    //~^ print_literal
     println!("{}", "\\\u{1234}");
+    //~^ print_literal
     // This does not lint because it would have to suggest unescaping the character
     println!(r"{}", "\u{ab123}");
     // These are not unicode escapes
     println!("{}", r"\u{ab123} \u{{");
+    //~^ print_literal
     println!(r"{}", r"\u{ab123} \u{{");
+    //~^ print_literal
     println!("{}", r"\{ab123} \u{{");
+    //~^ print_literal
     println!("{}", "\\u{ab123}");
+    //~^ print_literal
     println!("{}", "\\\\u{1234}");
+    //~^ print_literal
 
     println!("mixed: {} {world}", "{hello}");
+    //~^ print_literal
 }
 
 fn issue_13959() {
     println!("{}", r#"""#);
+    //~^ print_literal
     println!(
         "{}",
         r#"
+        //~^ print_literal
         foo
         \
         \\
diff --git a/src/tools/clippy/tests/ui/print_literal.stderr b/src/tools/clippy/tests/ui/print_literal.stderr
index d967b7c24070..da663000686f 100644
--- a/src/tools/clippy/tests/ui/print_literal.stderr
+++ b/src/tools/clippy/tests/ui/print_literal.stderr
@@ -25,7 +25,7 @@ LL +     println!("Hello {} world", world);
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:32:26
+  --> tests/ui/print_literal.rs:33:26
    |
 LL |     println!("Hello {}", "world");
    |                          ^^^^^^^
@@ -37,7 +37,7 @@ LL +     println!("Hello world");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:34:26
+  --> tests/ui/print_literal.rs:36:26
    |
 LL |     println!("{} {:.4}", "a literal", 5);
    |                          ^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     println!("a literal {:.4}", 5);
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:40:25
+  --> tests/ui/print_literal.rs:42:25
    |
 LL |     println!("{0} {1}", "hello", "world");
    |                         ^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     println!("hello world");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:42:25
+  --> tests/ui/print_literal.rs:45:25
    |
 LL |     println!("{1} {0}", "hello", "world");
    |                         ^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     println!("world hello");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:46:35
+  --> tests/ui/print_literal.rs:49:35
    |
 LL |     println!("{foo} {bar}", foo = "hello", bar = "world");
    |                                   ^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     println!("hello world");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:48:35
+  --> tests/ui/print_literal.rs:52:35
    |
 LL |     println!("{bar} {foo}", foo = "hello", bar = "world");
    |                                   ^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     println!("world hello");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:56:20
+  --> tests/ui/print_literal.rs:60:20
    |
 LL |     println!("{}", "{} \x00 \u{ab123} \\\u{ab123} {:?}");
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     println!("{{}} \x00 \u{ab123} \\\u{ab123} {{:?}}");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:57:20
+  --> tests/ui/print_literal.rs:62:20
    |
 LL |     println!("{}", "\\\u{1234}");
    |                    ^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     println!("\\\u{1234}");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:61:20
+  --> tests/ui/print_literal.rs:67:20
    |
 LL |     println!("{}", r"\u{ab123} \u{{");
    |                    ^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     println!("\\u{{ab123}} \\u{{{{");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:62:21
+  --> tests/ui/print_literal.rs:69:21
    |
 LL |     println!(r"{}", r"\u{ab123} \u{{");
    |                     ^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     println!(r"\u{{ab123}} \u{{{{");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:63:20
+  --> tests/ui/print_literal.rs:71:20
    |
 LL |     println!("{}", r"\{ab123} \u{{");
    |                    ^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     println!("\\{{ab123}} \\u{{{{");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:64:20
+  --> tests/ui/print_literal.rs:73:20
    |
 LL |     println!("{}", "\\u{ab123}");
    |                    ^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     println!("\\u{{ab123}}");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:65:20
+  --> tests/ui/print_literal.rs:75:20
    |
 LL |     println!("{}", "\\\\u{1234}");
    |                    ^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     println!("\\\\u{{1234}}");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:67:35
+  --> tests/ui/print_literal.rs:78:35
    |
 LL |     println!("mixed: {} {world}", "{hello}");
    |                                   ^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     println!("mixed: {{hello}} {world}");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:71:20
+  --> tests/ui/print_literal.rs:83:20
    |
 LL |     println!("{}", r#"""#);
    |                    ^^^^^^
@@ -205,12 +205,12 @@ LL +     println!("\"");
    |
 
 error: literal with an empty format string
-  --> tests/ui/print_literal.rs:74:9
+  --> tests/ui/print_literal.rs:87:9
    |
 LL | /         r#"
+LL | |
 LL | |         foo
 LL | |         \
-LL | |         \\
 ...  |
 LL | |         bar
 LL | | "#
@@ -219,6 +219,7 @@ LL | | "#
 help: try
    |
 LL ~         "
+LL +
 LL +         foo
 LL +         \\
 LL +         \\\\
diff --git a/src/tools/clippy/tests/ui/print_stderr.rs b/src/tools/clippy/tests/ui/print_stderr.rs
index 109f43ffe25d..a086dfd37758 100644
--- a/src/tools/clippy/tests/ui/print_stderr.rs
+++ b/src/tools/clippy/tests/ui/print_stderr.rs
@@ -2,10 +2,11 @@
 
 fn main() {
     eprintln!("Hello");
-    //~^ ERROR: use of `eprintln!`
-    //~| NOTE: `-D clippy::print-stderr` implied by `-D warnings`
+    //~^ print_stderr
+
     println!("This should not do anything");
     eprint!("World");
-    //~^ ERROR: use of `eprint!`
+    //~^ print_stderr
+
     print!("Nor should this");
 }
diff --git a/src/tools/clippy/tests/ui/print_stdout_build_script.rs b/src/tools/clippy/tests/ui/print_stdout_build_script.rs
index 91448cb0faf8..f01b8538ef49 100644
--- a/src/tools/clippy/tests/ui/print_stdout_build_script.rs
+++ b/src/tools/clippy/tests/ui/print_stdout_build_script.rs
@@ -1,4 +1,5 @@
 //@compile-flags: --crate-name=build_script_build
+//@ check-pass
 
 #![warn(clippy::print_stdout)]
 
diff --git a/src/tools/clippy/tests/ui/print_with_newline.fixed b/src/tools/clippy/tests/ui/print_with_newline.fixed
index 7ac6d2870c12..96c5ee4c1e92 100644
--- a/src/tools/clippy/tests/ui/print_with_newline.fixed
+++ b/src/tools/clippy/tests/ui/print_with_newline.fixed
@@ -5,16 +5,19 @@
 
 fn main() {
     println!("Hello");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
-    //~| NOTE: `-D clippy::print-with-newline` implied by `-D warnings`
+    //~^ print_with_newline
+
     println!("Hello {}", "world");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     println!("Hello {} {}", "world", "#2");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     println!("{}", 1265);
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     println!();
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
 
     // these are all fine
     print!("");
@@ -37,7 +40,8 @@ fn main() {
     // #3514
     print!("\\n");
     println!("\\");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     print!("\\\\n");
 
     // Raw strings
@@ -46,11 +50,11 @@ fn main() {
 
     // Literal newlines should also fail
     println!(
-        //~^ ERROR: using `print!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         
     );
     println!(
-        //~^ ERROR: using `print!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         
     );
 
@@ -59,7 +63,8 @@ fn main() {
     print!("foo\r\n");
     // should fail
     println!("\\r");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     print!("foo\rbar\n");
 
     // Ignore expanded format strings
diff --git a/src/tools/clippy/tests/ui/print_with_newline.rs b/src/tools/clippy/tests/ui/print_with_newline.rs
index 602d1ea3ec0e..60d1e4788308 100644
--- a/src/tools/clippy/tests/ui/print_with_newline.rs
+++ b/src/tools/clippy/tests/ui/print_with_newline.rs
@@ -5,16 +5,19 @@
 
 fn main() {
     print!("Hello\n");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
-    //~| NOTE: `-D clippy::print-with-newline` implied by `-D warnings`
+    //~^ print_with_newline
+
     print!("Hello {}\n", "world");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     print!("Hello {} {}\n", "world", "#2");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     print!("{}\n", 1265);
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     print!("\n");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
 
     // these are all fine
     print!("");
@@ -37,7 +40,8 @@ fn main() {
     // #3514
     print!("\\n");
     print!("\\\n");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     print!("\\\\n");
 
     // Raw strings
@@ -46,12 +50,12 @@ fn main() {
 
     // Literal newlines should also fail
     print!(
-        //~^ ERROR: using `print!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         "
 "
     );
     print!(
-        //~^ ERROR: using `print!()` with a format string that ends in a single newline
+        //~^ print_with_newline
         r"
 "
     );
@@ -61,7 +65,8 @@ fn main() {
     print!("foo\r\n");
     // should fail
     print!("\\r\n");
-    //~^ ERROR: using `print!()` with a format string that ends in a single newline
+    //~^ print_with_newline
+
     print!("foo\rbar\n");
 
     // Ignore expanded format strings
diff --git a/src/tools/clippy/tests/ui/print_with_newline.stderr b/src/tools/clippy/tests/ui/print_with_newline.stderr
index 9b07299e61d3..9ead0fca113b 100644
--- a/src/tools/clippy/tests/ui/print_with_newline.stderr
+++ b/src/tools/clippy/tests/ui/print_with_newline.stderr
@@ -25,7 +25,7 @@ LL +     println!("Hello {}", "world");
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> tests/ui/print_with_newline.rs:12:5
+  --> tests/ui/print_with_newline.rs:13:5
    |
 LL |     print!("Hello {} {}\n", "world", "#2");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     println!("Hello {} {}", "world", "#2");
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> tests/ui/print_with_newline.rs:14:5
+  --> tests/ui/print_with_newline.rs:16:5
    |
 LL |     print!("{}\n", 1265);
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     println!("{}", 1265);
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> tests/ui/print_with_newline.rs:16:5
+  --> tests/ui/print_with_newline.rs:19:5
    |
 LL |     print!("\n");
    |     ^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     println!();
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> tests/ui/print_with_newline.rs:39:5
+  --> tests/ui/print_with_newline.rs:42:5
    |
 LL |     print!("\\\n");
    |     ^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     println!("\\");
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> tests/ui/print_with_newline.rs:48:5
+  --> tests/ui/print_with_newline.rs:52:5
    |
 LL | /     print!(
 LL | |
@@ -90,7 +90,7 @@ LL ~
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> tests/ui/print_with_newline.rs:53:5
+  --> tests/ui/print_with_newline.rs:57:5
    |
 LL | /     print!(
 LL | |
@@ -107,7 +107,7 @@ LL ~
    |
 
 error: using `print!()` with a format string that ends in a single newline
-  --> tests/ui/print_with_newline.rs:63:5
+  --> tests/ui/print_with_newline.rs:67:5
    |
 LL |     print!("\\r\n");
    |     ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/println_empty_string.fixed b/src/tools/clippy/tests/ui/println_empty_string.fixed
index 20811fc75323..05e262ec7786 100644
--- a/src/tools/clippy/tests/ui/println_empty_string.fixed
+++ b/src/tools/clippy/tests/ui/println_empty_string.fixed
@@ -3,15 +3,19 @@
 fn main() {
     println!();
     println!();
+    //~^ println_empty_string
 
     match "a" {
         _ => println!(),
+        //~^ println_empty_string
     }
 
     eprintln!();
     eprintln!();
+    //~^ println_empty_string
 
     match "a" {
         _ => eprintln!(),
+        //~^ println_empty_string
     }
 }
diff --git a/src/tools/clippy/tests/ui/println_empty_string.rs b/src/tools/clippy/tests/ui/println_empty_string.rs
index 47f7277dce79..028ddb60dbce 100644
--- a/src/tools/clippy/tests/ui/println_empty_string.rs
+++ b/src/tools/clippy/tests/ui/println_empty_string.rs
@@ -3,15 +3,19 @@
 fn main() {
     println!();
     println!("");
+    //~^ println_empty_string
 
     match "a" {
         _ => println!(""),
+        //~^ println_empty_string
     }
 
     eprintln!();
     eprintln!("");
+    //~^ println_empty_string
 
     match "a" {
         _ => eprintln!(""),
+        //~^ println_empty_string
     }
 }
diff --git a/src/tools/clippy/tests/ui/println_empty_string.stderr b/src/tools/clippy/tests/ui/println_empty_string.stderr
index 17de05fa25a4..8b997aef9069 100644
--- a/src/tools/clippy/tests/ui/println_empty_string.stderr
+++ b/src/tools/clippy/tests/ui/println_empty_string.stderr
@@ -10,7 +10,7 @@ LL |     println!("");
    = help: to override `-D warnings` add `#[allow(clippy::println_empty_string)]`
 
 error: empty string literal in `println!`
-  --> tests/ui/println_empty_string.rs:8:14
+  --> tests/ui/println_empty_string.rs:9:14
    |
 LL |         _ => println!(""),
    |              ^^^^^^^^^--^
@@ -18,7 +18,7 @@ LL |         _ => println!(""),
    |                       help: remove the empty string
 
 error: empty string literal in `eprintln!`
-  --> tests/ui/println_empty_string.rs:12:5
+  --> tests/ui/println_empty_string.rs:14:5
    |
 LL |     eprintln!("");
    |     ^^^^^^^^^^--^
@@ -26,7 +26,7 @@ LL |     eprintln!("");
    |               help: remove the empty string
 
 error: empty string literal in `eprintln!`
-  --> tests/ui/println_empty_string.rs:15:14
+  --> tests/ui/println_empty_string.rs:18:14
    |
 LL |         _ => eprintln!(""),
    |              ^^^^^^^^^^--^
diff --git a/src/tools/clippy/tests/ui/ptr_arg.rs b/src/tools/clippy/tests/ui/ptr_arg.rs
index e8b42d3b913b..2d77bf06ff94 100644
--- a/src/tools/clippy/tests/ui/ptr_arg.rs
+++ b/src/tools/clippy/tests/ui/ptr_arg.rs
@@ -11,39 +11,45 @@ use std::borrow::Cow;
 use std::path::{Path, PathBuf};
 
 fn do_vec(x: &Vec<i64>) {
-    //~^ ERROR: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-    //~| NOTE: `-D clippy::ptr-arg` implied by `-D warnings`
+    //~^ ptr_arg
+
     //Nothing here
 }
 
 fn do_vec_mut(x: &mut Vec<i64>) {
-    //~^ ERROR: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice w
+    //~^ ptr_arg
+
     //Nothing here
 }
 
 fn do_vec_mut2(x: &mut Vec<i64>) {
-    //~^ ERROR: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice w
+    //~^ ptr_arg
+
     x.len();
     x.is_empty();
 }
 
 fn do_str(x: &String) {
-    //~^ ERROR: writing `&String` instead of `&str` involves a new object where a slice will d
+    //~^ ptr_arg
+
     //Nothing here either
 }
 
 fn do_str_mut(x: &mut String) {
-    //~^ ERROR: writing `&mut String` instead of `&mut str` involves a new object where a slic
+    //~^ ptr_arg
+
     //Nothing here either
 }
 
 fn do_path(x: &PathBuf) {
-    //~^ ERROR: writing `&PathBuf` instead of `&Path` involves a new object where a slice will
+    //~^ ptr_arg
+
     //Nothing here either
 }
 
 fn do_path_mut(x: &mut PathBuf) {
-    //~^ ERROR: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a sl
+    //~^ ptr_arg
+
     //Nothing here either
 }
 
@@ -52,7 +58,8 @@ fn main() {}
 trait Foo {
     type Item;
     fn do_vec(x: &Vec<i64>);
-    //~^ ERROR: writing `&Vec` instead of `&[_]` involves a new object where a slice will
+    //~^ ptr_arg
+
     fn do_item(x: &Self::Item);
 }
 
@@ -66,7 +73,8 @@ impl Foo for Bar {
 }
 
 fn cloned(x: &Vec<u8>) -> Vec<u8> {
-    //~^ ERROR: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
+    //~^ ptr_arg
+
     let e = x.clone();
     let f = e.clone(); // OK
     let g = x;
@@ -76,7 +84,8 @@ fn cloned(x: &Vec<u8>) -> Vec<u8> {
 }
 
 fn str_cloned(x: &String) -> String {
-    //~^ ERROR: writing `&String` instead of `&str` involves a new object where a slice will d
+    //~^ ptr_arg
+
     let a = x.clone();
     let b = x.clone();
     let c = b.clone();
@@ -85,7 +94,8 @@ fn str_cloned(x: &String) -> String {
 }
 
 fn path_cloned(x: &PathBuf) -> PathBuf {
-    //~^ ERROR: writing `&PathBuf` instead of `&Path` involves a new object where a slice will
+    //~^ ptr_arg
+
     let a = x.clone();
     let b = x.clone();
     let c = b.clone();
@@ -94,7 +104,8 @@ fn path_cloned(x: &PathBuf) -> PathBuf {
 }
 
 fn false_positive_capacity(x: &Vec<u8>, y: &String) {
-    //~^ ERROR: writing `&String` instead of `&str` involves a new object where a slice will d
+    //~^ ptr_arg
+
     let a = x.capacity();
     let b = y.clone();
     let c = y.as_str();
@@ -109,7 +120,7 @@ fn false_positive_capacity_too(x: &String) -> String {
 
 #[allow(dead_code)]
 fn test_cow_with_ref(c: &Cow<[i32]>) {}
-//~^ ERROR: using a reference to `Cow` is not recommended
+//~^ ptr_arg
 
 fn test_cow(c: Cow<[i32]>) {
     let _c = c;
@@ -139,7 +150,7 @@ mod issue_5644 {
     }
 
     fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}
-    //~^ ERROR: writing `&String` instead of `&str` involves a new object where a slice wi
+    //~^ ptr_arg
 
     struct S;
     impl S {
@@ -169,26 +180,30 @@ mod issue6509 {
     use std::path::PathBuf;
 
     fn foo_vec(vec: &Vec<u8>) {
-        //~^ ERROR: writing `&Vec` instead of `&[_]` involves a new object where a slice will
+        //~^ ptr_arg
+
         let _ = vec.clone().pop();
         let _ = vec.clone().clone();
     }
 
     fn foo_path(path: &PathBuf) {
-        //~^ ERROR: writing `&PathBuf` instead of `&Path` involves a new object where a slice
+        //~^ ptr_arg
+
         let _ = path.clone().pop();
         let _ = path.clone().clone();
     }
 
     fn foo_str(str: &PathBuf) {
-        //~^ ERROR: writing `&PathBuf` instead of `&Path` involves a new object where a slice
+        //~^ ptr_arg
+
         let _ = str.clone().pop();
         let _ = str.clone().clone();
     }
 }
 
 fn mut_vec_slice_methods(v: &mut Vec<u32>) {
-    //~^ ERROR: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice w
+    //~^ ptr_arg
+
     v.copy_within(1..5, 10);
 }
 
@@ -251,9 +266,10 @@ fn dyn_trait_ok(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
 }
 
 fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
-    //~^ ERROR: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice w
-    //~| ERROR: writing `&mut String` instead of `&mut str` involves a new object where a slic
-    //~| ERROR: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a sl
+    //~^ ptr_arg
+    //~| ptr_arg
+    //~| ptr_arg
+
     trait T {}
     impl<U> T for Vec<U> {}
     impl<U> T for [U] {}
@@ -277,22 +293,26 @@ mod issue_9218 {
 
     // This one has an anonymous lifetime so it's not okay
     fn cow_elided_lifetime<'a>(input: &'a Cow<str>) -> &'a str {
-        //~^ ERROR: using a reference to `Cow` is not recommended
+        //~^ ptr_arg
+
         todo!()
     }
 
     // These two's return types don't use 'a so it's not okay
     fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {
-        //~^ ERROR: using a reference to `Cow` is not recommended
+        //~^ ptr_arg
+
         todo!()
     }
     fn cow_bad_ret_ty_2<'a, 'b>(input: &'a Cow<'a, str>) -> &'b str {
-        //~^ ERROR: using a reference to `Cow` is not recommended
+        //~^ ptr_arg
+
         todo!()
     }
 
     // Inferred to be `&'a str`, afaik.
     fn cow_good_ret_ty<'a>(input: &'a Cow<'a, str>) -> &str {
+        //~^ ERROR: elided lifetime has a name
         todo!()
     }
 }
@@ -325,8 +345,9 @@ mod issue_13308 {
 
     // Other cases that are still ok to lint and ideally shouldn't regress
     fn good(v1: &String, v2: &String) {
-        //~^ ERROR: writing `&String` instead of `&str`
-        //~^^ ERROR: writing `&String` instead of `&str`
+        //~^ ptr_arg
+        //~| ptr_arg
+
         h1(v1);
         h2(String::new(), v2);
     }
diff --git a/src/tools/clippy/tests/ui/ptr_arg.stderr b/src/tools/clippy/tests/ui/ptr_arg.stderr
index 1a6b3aa1f8d4..741e60cbd749 100644
--- a/src/tools/clippy/tests/ui/ptr_arg.stderr
+++ b/src/tools/clippy/tests/ui/ptr_arg.stderr
@@ -1,5 +1,5 @@
 error: elided lifetime has a name
-  --> tests/ui/ptr_arg.rs:295:56
+  --> tests/ui/ptr_arg.rs:314:56
    |
 LL |     fn cow_good_ret_ty<'a>(input: &'a Cow<'a, str>) -> &str {
    |                        -- lifetime `'a` declared here  ^ this elided lifetime gets resolved as `'a`
@@ -23,43 +23,43 @@ LL | fn do_vec_mut(x: &mut Vec<i64>) {
    |                  ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:24:19
+  --> tests/ui/ptr_arg.rs:25:19
    |
 LL | fn do_vec_mut2(x: &mut Vec<i64>) {
    |                   ^^^^^^^^^^^^^ help: change this to: `&mut [i64]`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:30:14
+  --> tests/ui/ptr_arg.rs:32:14
    |
 LL | fn do_str(x: &String) {
    |              ^^^^^^^ help: change this to: `&str`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:35:18
+  --> tests/ui/ptr_arg.rs:38:18
    |
 LL | fn do_str_mut(x: &mut String) {
    |                  ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:40:15
+  --> tests/ui/ptr_arg.rs:44:15
    |
 LL | fn do_path(x: &PathBuf) {
    |               ^^^^^^^^ help: change this to: `&Path`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:45:19
+  --> tests/ui/ptr_arg.rs:50:19
    |
 LL | fn do_path_mut(x: &mut PathBuf) {
    |                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:54:18
+  --> tests/ui/ptr_arg.rs:60:18
    |
 LL |     fn do_vec(x: &Vec<i64>);
    |                  ^^^^^^^^^ help: change this to: `&[i64]`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:68:14
+  --> tests/ui/ptr_arg.rs:75:14
    |
 LL | fn cloned(x: &Vec<u8>) -> Vec<u8> {
    |              ^^^^^^^^
@@ -68,6 +68,7 @@ help: change this to
    |
 LL ~ fn cloned(x: &[u8]) -> Vec<u8> {
 LL |
+LL |
 LL ~     let e = x.to_owned();
 LL |     let f = e.clone(); // OK
 LL |     let g = x;
@@ -77,7 +78,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:78:18
+  --> tests/ui/ptr_arg.rs:86:18
    |
 LL | fn str_cloned(x: &String) -> String {
    |                  ^^^^^^^
@@ -86,6 +87,7 @@ help: change this to
    |
 LL ~ fn str_cloned(x: &str) -> String {
 LL |
+LL |
 LL ~     let a = x.to_owned();
 LL ~     let b = x.to_owned();
 LL |     let c = b.clone();
@@ -94,7 +96,7 @@ LL ~     x.to_owned()
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:87:19
+  --> tests/ui/ptr_arg.rs:96:19
    |
 LL | fn path_cloned(x: &PathBuf) -> PathBuf {
    |                   ^^^^^^^^
@@ -103,6 +105,7 @@ help: change this to
    |
 LL ~ fn path_cloned(x: &Path) -> PathBuf {
 LL |
+LL |
 LL ~     let a = x.to_path_buf();
 LL ~     let b = x.to_path_buf();
 LL |     let c = b.clone();
@@ -111,7 +114,7 @@ LL ~     x.to_path_buf()
    |
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:96:44
+  --> tests/ui/ptr_arg.rs:106:44
    |
 LL | fn false_positive_capacity(x: &Vec<u8>, y: &String) {
    |                                            ^^^^^^^
@@ -120,25 +123,26 @@ help: change this to
    |
 LL ~ fn false_positive_capacity(x: &Vec<u8>, y: &str) {
 LL |
+LL |
 LL |     let a = x.capacity();
 LL ~     let b = y.to_owned();
 LL ~     let c = y;
    |
 
 error: using a reference to `Cow` is not recommended
-  --> tests/ui/ptr_arg.rs:111:25
+  --> tests/ui/ptr_arg.rs:122:25
    |
 LL | fn test_cow_with_ref(c: &Cow<[i32]>) {}
    |                         ^^^^^^^^^^^ help: change this to: `&[i32]`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:141:66
+  --> tests/ui/ptr_arg.rs:152:66
    |
 LL |     fn some_allowed(#[allow(clippy::ptr_arg)] _v: &Vec<u32>, _s: &String) {}
    |                                                                  ^^^^^^^ help: change this to: `&str`
 
 error: writing `&Vec` instead of `&[_]` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:171:21
+  --> tests/ui/ptr_arg.rs:182:21
    |
 LL |     fn foo_vec(vec: &Vec<u8>) {
    |                     ^^^^^^^^
@@ -147,12 +151,13 @@ help: change this to
    |
 LL ~     fn foo_vec(vec: &[u8]) {
 LL |
+LL |
 LL ~         let _ = vec.to_owned().pop();
 LL ~         let _ = vec.to_owned().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:177:23
+  --> tests/ui/ptr_arg.rs:189:23
    |
 LL |     fn foo_path(path: &PathBuf) {
    |                       ^^^^^^^^
@@ -161,12 +166,13 @@ help: change this to
    |
 LL ~     fn foo_path(path: &Path) {
 LL |
+LL |
 LL ~         let _ = path.to_path_buf().pop();
 LL ~         let _ = path.to_path_buf().clone();
    |
 
 error: writing `&PathBuf` instead of `&Path` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:183:21
+  --> tests/ui/ptr_arg.rs:196:21
    |
 LL |     fn foo_str(str: &PathBuf) {
    |                     ^^^^^^^^
@@ -175,60 +181,61 @@ help: change this to
    |
 LL ~     fn foo_str(str: &Path) {
 LL |
+LL |
 LL ~         let _ = str.to_path_buf().pop();
 LL ~         let _ = str.to_path_buf().clone();
    |
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:190:29
+  --> tests/ui/ptr_arg.rs:204:29
    |
 LL | fn mut_vec_slice_methods(v: &mut Vec<u32>) {
    |                             ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut Vec` instead of `&mut [_]` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:253:17
+  --> tests/ui/ptr_arg.rs:268:17
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                 ^^^^^^^^^^^^^ help: change this to: `&mut [u32]`
 
 error: writing `&mut String` instead of `&mut str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:253:35
+  --> tests/ui/ptr_arg.rs:268:35
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                   ^^^^^^^^^^^ help: change this to: `&mut str`
 
 error: writing `&mut PathBuf` instead of `&mut Path` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:253:51
+  --> tests/ui/ptr_arg.rs:268:51
    |
 LL | fn dyn_trait(a: &mut Vec<u32>, b: &mut String, c: &mut PathBuf) {
    |                                                   ^^^^^^^^^^^^ help: change this to: `&mut Path`
 
 error: using a reference to `Cow` is not recommended
-  --> tests/ui/ptr_arg.rs:279:39
+  --> tests/ui/ptr_arg.rs:295:39
    |
 LL |     fn cow_elided_lifetime<'a>(input: &'a Cow<str>) -> &'a str {
    |                                       ^^^^^^^^^^^^ help: change this to: `&str`
 
 error: using a reference to `Cow` is not recommended
-  --> tests/ui/ptr_arg.rs:285:36
+  --> tests/ui/ptr_arg.rs:302:36
    |
 LL |     fn cow_bad_ret_ty_1<'a>(input: &'a Cow<'a, str>) -> &'static str {
    |                                    ^^^^^^^^^^^^^^^^ help: change this to: `&str`
 
 error: using a reference to `Cow` is not recommended
-  --> tests/ui/ptr_arg.rs:289:40
+  --> tests/ui/ptr_arg.rs:307:40
    |
 LL |     fn cow_bad_ret_ty_2<'a, 'b>(input: &'a Cow<'a, str>) -> &'b str {
    |                                        ^^^^^^^^^^^^^^^^ help: change this to: `&str`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:327:17
+  --> tests/ui/ptr_arg.rs:347:17
    |
 LL |     fn good(v1: &String, v2: &String) {
    |                 ^^^^^^^ help: change this to: `&str`
 
 error: writing `&String` instead of `&str` involves a new object where a slice will do
-  --> tests/ui/ptr_arg.rs:327:30
+  --> tests/ui/ptr_arg.rs:347:30
    |
 LL |     fn good(v1: &String, v2: &String) {
    |                              ^^^^^^^ help: change this to: `&str`
diff --git a/src/tools/clippy/tests/ui/ptr_as_ptr.fixed b/src/tools/clippy/tests/ui/ptr_as_ptr.fixed
index fa15c323540f..2033f31c1eec 100644
--- a/src/tools/clippy/tests/ui/ptr_as_ptr.fixed
+++ b/src/tools/clippy/tests/ui/ptr_as_ptr.fixed
@@ -16,6 +16,7 @@ mod issue_11278_b {
     pub fn f(o: &mut super::issue_11278_a::T<dyn std::fmt::Debug>) -> super::issue_11278_a::T<String> {
         // Retain `super`
         *unsafe { Box::from_raw(Box::into_raw(Box::new(o)).cast::<super::issue_11278_a::T<String>>()) }
+        //~^ ptr_as_ptr
     }
 }
 
@@ -25,12 +26,15 @@ fn main() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     let _ = ptr.cast::<i32>();
+    //~^ ptr_as_ptr
     let _ = mut_ptr.cast::<i32>();
+    //~^ ptr_as_ptr
 
     // Make sure the lint can handle the difference in their operator precedences.
     unsafe {
         let ptr_ptr: *const *const u32 = &ptr;
         let _ = (*ptr_ptr).cast::<i32>();
+        //~^ ptr_as_ptr
     }
 
     // Changes in mutability. Do not lint this.
@@ -44,10 +48,13 @@ fn main() {
 
     // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
     let _: *const i32 = ptr.cast();
+    //~^ ptr_as_ptr
     let _: *mut i32 = mut_ptr.cast();
+    //~^ ptr_as_ptr
 
     // Make sure the lint is triggered inside a macro
     let _ = inline!($ptr.cast::<i32>());
+    //~^ ptr_as_ptr
 
     // Do not lint inside macros from external crates
     let _ = external!($ptr as *const i32);
@@ -69,7 +76,9 @@ fn _msrv_1_38() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     let _ = ptr.cast::<i32>();
+    //~^ ptr_as_ptr
     let _ = mut_ptr.cast::<i32>();
+    //~^ ptr_as_ptr
 }
 
 #[allow(clippy::unnecessary_cast)]
@@ -77,37 +86,45 @@ mod null {
     fn use_path_mut() -> *mut u32 {
         use std::ptr;
         ptr::null_mut::<u32>()
+        //~^ ptr_as_ptr
     }
 
     fn full_path_mut() -> *mut u32 {
         std::ptr::null_mut::<u32>()
+        //~^ ptr_as_ptr
     }
 
     fn core_path_mut() -> *mut u32 {
         use core::ptr;
         ptr::null_mut::<u32>()
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path_mut() -> *mut u32 {
         core::ptr::null_mut::<u32>()
+        //~^ ptr_as_ptr
     }
 
     fn use_path() -> *const u32 {
         use std::ptr;
         ptr::null::<u32>()
+        //~^ ptr_as_ptr
     }
 
     fn full_path() -> *const u32 {
         std::ptr::null::<u32>()
+        //~^ ptr_as_ptr
     }
 
     fn core_path() -> *const u32 {
         use core::ptr;
         ptr::null::<u32>()
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path() -> *const u32 {
         core::ptr::null::<u32>()
+        //~^ ptr_as_ptr
     }
 }
 
@@ -115,37 +132,45 @@ mod null_ptr_infer {
     fn use_path_mut() -> *mut u32 {
         use std::ptr;
         ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn full_path_mut() -> *mut u32 {
         std::ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn core_path_mut() -> *mut u32 {
         use core::ptr;
         ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path_mut() -> *mut u32 {
         core::ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn use_path() -> *const u32 {
         use std::ptr;
         ptr::null()
+        //~^ ptr_as_ptr
     }
 
     fn full_path() -> *const u32 {
         std::ptr::null()
+        //~^ ptr_as_ptr
     }
 
     fn core_path() -> *const u32 {
         use core::ptr;
         ptr::null()
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path() -> *const u32 {
         core::ptr::null()
+        //~^ ptr_as_ptr
     }
 }
 
@@ -153,36 +178,44 @@ mod null_entire_infer {
     fn use_path_mut() -> *mut u32 {
         use std::ptr;
         ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn full_path_mut() -> *mut u32 {
         std::ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn core_path_mut() -> *mut u32 {
         use core::ptr;
         ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path_mut() -> *mut u32 {
         core::ptr::null_mut()
+        //~^ ptr_as_ptr
     }
 
     fn use_path() -> *const u32 {
         use std::ptr;
         ptr::null()
+        //~^ ptr_as_ptr
     }
 
     fn full_path() -> *const u32 {
         std::ptr::null()
+        //~^ ptr_as_ptr
     }
 
     fn core_path() -> *const u32 {
         use core::ptr;
         ptr::null()
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path() -> *const u32 {
         core::ptr::null()
+        //~^ ptr_as_ptr
     }
 }
diff --git a/src/tools/clippy/tests/ui/ptr_as_ptr.rs b/src/tools/clippy/tests/ui/ptr_as_ptr.rs
index 7ab52e63da55..224d09b0eb6e 100644
--- a/src/tools/clippy/tests/ui/ptr_as_ptr.rs
+++ b/src/tools/clippy/tests/ui/ptr_as_ptr.rs
@@ -16,6 +16,7 @@ mod issue_11278_b {
     pub fn f(o: &mut super::issue_11278_a::T<dyn std::fmt::Debug>) -> super::issue_11278_a::T<String> {
         // Retain `super`
         *unsafe { Box::from_raw(Box::into_raw(Box::new(o)) as *mut super::issue_11278_a::T<String>) }
+        //~^ ptr_as_ptr
     }
 }
 
@@ -25,12 +26,15 @@ fn main() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     let _ = ptr as *const i32;
+    //~^ ptr_as_ptr
     let _ = mut_ptr as *mut i32;
+    //~^ ptr_as_ptr
 
     // Make sure the lint can handle the difference in their operator precedences.
     unsafe {
         let ptr_ptr: *const *const u32 = &ptr;
         let _ = *ptr_ptr as *const i32;
+        //~^ ptr_as_ptr
     }
 
     // Changes in mutability. Do not lint this.
@@ -44,10 +48,13 @@ fn main() {
 
     // Ensure the lint doesn't produce unnecessary turbofish for inferred types.
     let _: *const i32 = ptr as *const _;
+    //~^ ptr_as_ptr
     let _: *mut i32 = mut_ptr as _;
+    //~^ ptr_as_ptr
 
     // Make sure the lint is triggered inside a macro
     let _ = inline!($ptr as *const i32);
+    //~^ ptr_as_ptr
 
     // Do not lint inside macros from external crates
     let _ = external!($ptr as *const i32);
@@ -69,7 +76,9 @@ fn _msrv_1_38() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     let _ = ptr as *const i32;
+    //~^ ptr_as_ptr
     let _ = mut_ptr as *mut i32;
+    //~^ ptr_as_ptr
 }
 
 #[allow(clippy::unnecessary_cast)]
@@ -77,37 +86,45 @@ mod null {
     fn use_path_mut() -> *mut u32 {
         use std::ptr;
         ptr::null_mut() as *mut u32
+        //~^ ptr_as_ptr
     }
 
     fn full_path_mut() -> *mut u32 {
         std::ptr::null_mut() as *mut u32
+        //~^ ptr_as_ptr
     }
 
     fn core_path_mut() -> *mut u32 {
         use core::ptr;
         ptr::null_mut() as *mut u32
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path_mut() -> *mut u32 {
         core::ptr::null_mut() as *mut u32
+        //~^ ptr_as_ptr
     }
 
     fn use_path() -> *const u32 {
         use std::ptr;
         ptr::null() as *const u32
+        //~^ ptr_as_ptr
     }
 
     fn full_path() -> *const u32 {
         std::ptr::null() as *const u32
+        //~^ ptr_as_ptr
     }
 
     fn core_path() -> *const u32 {
         use core::ptr;
         ptr::null() as *const u32
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path() -> *const u32 {
         core::ptr::null() as *const u32
+        //~^ ptr_as_ptr
     }
 }
 
@@ -115,37 +132,45 @@ mod null_ptr_infer {
     fn use_path_mut() -> *mut u32 {
         use std::ptr;
         ptr::null_mut() as *mut _
+        //~^ ptr_as_ptr
     }
 
     fn full_path_mut() -> *mut u32 {
         std::ptr::null_mut() as *mut _
+        //~^ ptr_as_ptr
     }
 
     fn core_path_mut() -> *mut u32 {
         use core::ptr;
         ptr::null_mut() as *mut _
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path_mut() -> *mut u32 {
         core::ptr::null_mut() as *mut _
+        //~^ ptr_as_ptr
     }
 
     fn use_path() -> *const u32 {
         use std::ptr;
         ptr::null() as *const _
+        //~^ ptr_as_ptr
     }
 
     fn full_path() -> *const u32 {
         std::ptr::null() as *const _
+        //~^ ptr_as_ptr
     }
 
     fn core_path() -> *const u32 {
         use core::ptr;
         ptr::null() as *const _
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path() -> *const u32 {
         core::ptr::null() as *const _
+        //~^ ptr_as_ptr
     }
 }
 
@@ -153,36 +178,44 @@ mod null_entire_infer {
     fn use_path_mut() -> *mut u32 {
         use std::ptr;
         ptr::null_mut() as _
+        //~^ ptr_as_ptr
     }
 
     fn full_path_mut() -> *mut u32 {
         std::ptr::null_mut() as _
+        //~^ ptr_as_ptr
     }
 
     fn core_path_mut() -> *mut u32 {
         use core::ptr;
         ptr::null_mut() as _
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path_mut() -> *mut u32 {
         core::ptr::null_mut() as _
+        //~^ ptr_as_ptr
     }
 
     fn use_path() -> *const u32 {
         use std::ptr;
         ptr::null() as _
+        //~^ ptr_as_ptr
     }
 
     fn full_path() -> *const u32 {
         std::ptr::null() as _
+        //~^ ptr_as_ptr
     }
 
     fn core_path() -> *const u32 {
         use core::ptr;
         ptr::null() as _
+        //~^ ptr_as_ptr
     }
 
     fn full_core_path() -> *const u32 {
         core::ptr::null() as _
+        //~^ ptr_as_ptr
     }
 }
diff --git a/src/tools/clippy/tests/ui/ptr_as_ptr.stderr b/src/tools/clippy/tests/ui/ptr_as_ptr.stderr
index 18462620b0a3..66dae8e0135e 100644
--- a/src/tools/clippy/tests/ui/ptr_as_ptr.stderr
+++ b/src/tools/clippy/tests/ui/ptr_as_ptr.stderr
@@ -8,37 +8,37 @@ LL |         *unsafe { Box::from_raw(Box::into_raw(Box::new(o)) as *mut super::i
    = help: to override `-D warnings` add `#[allow(clippy::ptr_as_ptr)]`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:27:13
+  --> tests/ui/ptr_as_ptr.rs:28:13
    |
 LL |     let _ = ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:28:13
+  --> tests/ui/ptr_as_ptr.rs:30:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:33:17
+  --> tests/ui/ptr_as_ptr.rs:36:17
    |
 LL |         let _ = *ptr_ptr as *const i32;
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `(*ptr_ptr).cast::<i32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:46:25
+  --> tests/ui/ptr_as_ptr.rs:50:25
    |
 LL |     let _: *const i32 = ptr as *const _;
    |                         ^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:47:23
+  --> tests/ui/ptr_as_ptr.rs:52:23
    |
 LL |     let _: *mut i32 = mut_ptr as _;
    |                       ^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:50:21
+  --> tests/ui/ptr_as_ptr.rs:56:21
    |
 LL |     let _ = inline!($ptr as *const i32);
    |                     ^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `$ptr.cast::<i32>()`
@@ -46,29 +46,17 @@ LL |     let _ = inline!($ptr as *const i32);
    = note: this error originates in the macro `__inline_mac_fn_main` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:71:13
+  --> tests/ui/ptr_as_ptr.rs:78:13
    |
 LL |     let _ = ptr as *const i32;
    |             ^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `ptr.cast::<i32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:72:13
+  --> tests/ui/ptr_as_ptr.rs:80:13
    |
 LL |     let _ = mut_ptr as *mut i32;
    |             ^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast`, a safer alternative: `mut_ptr.cast::<i32>()`
 
-error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:79:9
-   |
-LL |         ptr::null_mut() as *mut u32
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut::<u32>()`
-
-error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:83:9
-   |
-LL |         std::ptr::null_mut() as *mut u32
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut::<u32>()`
-
 error: `as` casting between raw pointers without changing their constness
   --> tests/ui/ptr_as_ptr.rs:88:9
    |
@@ -76,127 +64,139 @@ LL |         ptr::null_mut() as *mut u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:92:9
+  --> tests/ui/ptr_as_ptr.rs:93:9
+   |
+LL |         std::ptr::null_mut() as *mut u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut::<u32>()`
+
+error: `as` casting between raw pointers without changing their constness
+  --> tests/ui/ptr_as_ptr.rs:99:9
+   |
+LL |         ptr::null_mut() as *mut u32
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut::<u32>()`
+
+error: `as` casting between raw pointers without changing their constness
+  --> tests/ui/ptr_as_ptr.rs:104:9
    |
 LL |         core::ptr::null_mut() as *mut u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:97:9
+  --> tests/ui/ptr_as_ptr.rs:110:9
    |
 LL |         ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:101:9
+  --> tests/ui/ptr_as_ptr.rs:115:9
    |
 LL |         std::ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:106:9
+  --> tests/ui/ptr_as_ptr.rs:121:9
    |
 LL |         ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:110:9
+  --> tests/ui/ptr_as_ptr.rs:126:9
    |
 LL |         core::ptr::null() as *const u32
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null::<u32>()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:117:9
+  --> tests/ui/ptr_as_ptr.rs:134:9
    |
 LL |         ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:121:9
+  --> tests/ui/ptr_as_ptr.rs:139:9
    |
 LL |         std::ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:126:9
+  --> tests/ui/ptr_as_ptr.rs:145:9
    |
 LL |         ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:130:9
+  --> tests/ui/ptr_as_ptr.rs:150:9
    |
 LL |         core::ptr::null_mut() as *mut _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:135:9
+  --> tests/ui/ptr_as_ptr.rs:156:9
    |
 LL |         ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:139:9
+  --> tests/ui/ptr_as_ptr.rs:161:9
    |
 LL |         std::ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:144:9
+  --> tests/ui/ptr_as_ptr.rs:167:9
    |
 LL |         ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:148:9
+  --> tests/ui/ptr_as_ptr.rs:172:9
    |
 LL |         core::ptr::null() as *const _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:155:9
+  --> tests/ui/ptr_as_ptr.rs:180:9
    |
 LL |         ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:159:9
+  --> tests/ui/ptr_as_ptr.rs:185:9
    |
 LL |         std::ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:164:9
+  --> tests/ui/ptr_as_ptr.rs:191:9
    |
 LL |         ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:168:9
+  --> tests/ui/ptr_as_ptr.rs:196:9
    |
 LL |         core::ptr::null_mut() as _
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null_mut()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:173:9
+  --> tests/ui/ptr_as_ptr.rs:202:9
    |
 LL |         ptr::null() as _
    |         ^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:177:9
+  --> tests/ui/ptr_as_ptr.rs:207:9
    |
 LL |         std::ptr::null() as _
    |         ^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `std::ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:182:9
+  --> tests/ui/ptr_as_ptr.rs:213:9
    |
 LL |         ptr::null() as _
    |         ^^^^^^^^^^^^^^^^ help: try call directly: `ptr::null()`
 
 error: `as` casting between raw pointers without changing their constness
-  --> tests/ui/ptr_as_ptr.rs:186:9
+  --> tests/ui/ptr_as_ptr.rs:218:9
    |
 LL |         core::ptr::null() as _
    |         ^^^^^^^^^^^^^^^^^^^^^^ help: try call directly: `core::ptr::null()`
diff --git a/src/tools/clippy/tests/ui/ptr_cast_constness.fixed b/src/tools/clippy/tests/ui/ptr_cast_constness.fixed
index 9a5272c7adc3..6dded72d3e19 100644
--- a/src/tools/clippy/tests/ui/ptr_cast_constness.fixed
+++ b/src/tools/clippy/tests/ui/ptr_cast_constness.fixed
@@ -13,7 +13,9 @@ use proc_macros::{external, inline_macros};
 
 unsafe fn ptr_to_ref<T, U>(p: *const T, om: *mut U) {
     let _: &mut T = std::mem::transmute(p.cast_mut());
+    //~^ ptr_cast_constness
     let _ = &mut *p.cast_mut();
+    //~^ ptr_cast_constness
     let _: &T = &*(om as *const T);
 }
 
@@ -29,10 +31,13 @@ fn main() {
     unsafe {
         let ptr_ptr: *const *const u32 = &ptr;
         let _ = (*ptr_ptr).cast_mut();
+        //~^ ptr_cast_constness
     }
 
     let _ = ptr.cast_mut();
+    //~^ ptr_cast_constness
     let _ = mut_ptr.cast_const();
+    //~^ ptr_cast_constness
 
     // Lint this, since pointer::cast_mut and pointer::cast_const have ?Sized
     let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
@@ -66,20 +71,28 @@ fn _msrv_1_65() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     let _ = ptr.cast_mut();
+    //~^ ptr_cast_constness
     let _ = mut_ptr.cast_const();
+    //~^ ptr_cast_constness
 }
 
 #[inline_macros]
 fn null_pointers() {
     use std::ptr;
     let _ = std::ptr::null_mut::<String>();
+    //~^ ptr_cast_constness
     let _ = std::ptr::null::<u32>();
+    //~^ ptr_cast_constness
     let _ = std::ptr::null_mut::<u32>();
+    //~^ ptr_cast_constness
     let _ = std::ptr::null::<u32>();
+    //~^ ptr_cast_constness
 
     // Make sure the lint is triggered inside a macro
     let _ = inline!(std::ptr::null_mut::<u32>());
+    //~^ ptr_cast_constness
     let _ = inline!(std::ptr::null_mut::<u32>());
+    //~^ ptr_cast_constness
 
     // Do not lint inside macros from external crates
     let _ = external!(ptr::null::<u32>() as *mut u32);
diff --git a/src/tools/clippy/tests/ui/ptr_cast_constness.rs b/src/tools/clippy/tests/ui/ptr_cast_constness.rs
index 43ab5f5ba7cc..e9629f5290ec 100644
--- a/src/tools/clippy/tests/ui/ptr_cast_constness.rs
+++ b/src/tools/clippy/tests/ui/ptr_cast_constness.rs
@@ -13,7 +13,9 @@ use proc_macros::{external, inline_macros};
 
 unsafe fn ptr_to_ref<T, U>(p: *const T, om: *mut U) {
     let _: &mut T = std::mem::transmute(p as *mut T);
+    //~^ ptr_cast_constness
     let _ = &mut *(p as *mut T);
+    //~^ ptr_cast_constness
     let _: &T = &*(om as *const T);
 }
 
@@ -29,10 +31,13 @@ fn main() {
     unsafe {
         let ptr_ptr: *const *const u32 = &ptr;
         let _ = *ptr_ptr as *mut u32;
+        //~^ ptr_cast_constness
     }
 
     let _ = ptr as *mut u32;
+    //~^ ptr_cast_constness
     let _ = mut_ptr as *const u32;
+    //~^ ptr_cast_constness
 
     // Lint this, since pointer::cast_mut and pointer::cast_const have ?Sized
     let ptr_of_array: *const [u32; 4] = &[1, 2, 3, 4];
@@ -66,20 +71,28 @@ fn _msrv_1_65() {
     let mut_ptr: *mut u32 = &mut 42_u32;
 
     let _ = ptr as *mut u32;
+    //~^ ptr_cast_constness
     let _ = mut_ptr as *const u32;
+    //~^ ptr_cast_constness
 }
 
 #[inline_macros]
 fn null_pointers() {
     use std::ptr;
     let _ = ptr::null::<String>() as *mut String;
+    //~^ ptr_cast_constness
     let _ = ptr::null_mut::<u32>() as *const u32;
+    //~^ ptr_cast_constness
     let _ = ptr::null::<u32>().cast_mut();
+    //~^ ptr_cast_constness
     let _ = ptr::null_mut::<u32>().cast_const();
+    //~^ ptr_cast_constness
 
     // Make sure the lint is triggered inside a macro
     let _ = inline!(ptr::null::<u32>() as *mut u32);
+    //~^ ptr_cast_constness
     let _ = inline!(ptr::null::<u32>().cast_mut());
+    //~^ ptr_cast_constness
 
     // Do not lint inside macros from external crates
     let _ = external!(ptr::null::<u32>() as *mut u32);
diff --git a/src/tools/clippy/tests/ui/ptr_cast_constness.stderr b/src/tools/clippy/tests/ui/ptr_cast_constness.stderr
index a693793a4ae9..1eeeef747013 100644
--- a/src/tools/clippy/tests/ui/ptr_cast_constness.stderr
+++ b/src/tools/clippy/tests/ui/ptr_cast_constness.stderr
@@ -8,67 +8,67 @@ LL |     let _: &mut T = std::mem::transmute(p as *mut T);
    = help: to override `-D warnings` add `#[allow(clippy::ptr_cast_constness)]`
 
 error: `as` casting between raw pointers while changing only its constness
-  --> tests/ui/ptr_cast_constness.rs:16:19
+  --> tests/ui/ptr_cast_constness.rs:17:19
    |
 LL |     let _ = &mut *(p as *mut T);
    |                   ^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `p.cast_mut()`
 
 error: `as` casting between raw pointers while changing only its constness
-  --> tests/ui/ptr_cast_constness.rs:31:17
+  --> tests/ui/ptr_cast_constness.rs:33:17
    |
 LL |         let _ = *ptr_ptr as *mut u32;
    |                 ^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `(*ptr_ptr).cast_mut()`
 
 error: `as` casting between raw pointers while changing only its constness
-  --> tests/ui/ptr_cast_constness.rs:34:13
+  --> tests/ui/ptr_cast_constness.rs:37:13
    |
 LL |     let _ = ptr as *mut u32;
    |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
 
 error: `as` casting between raw pointers while changing only its constness
-  --> tests/ui/ptr_cast_constness.rs:35:13
+  --> tests/ui/ptr_cast_constness.rs:39:13
    |
 LL |     let _ = mut_ptr as *const u32;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
 
 error: `as` casting between raw pointers while changing only its constness
-  --> tests/ui/ptr_cast_constness.rs:68:13
+  --> tests/ui/ptr_cast_constness.rs:73:13
    |
 LL |     let _ = ptr as *mut u32;
    |             ^^^^^^^^^^^^^^^ help: try `pointer::cast_mut`, a safer alternative: `ptr.cast_mut()`
 
 error: `as` casting between raw pointers while changing only its constness
-  --> tests/ui/ptr_cast_constness.rs:69:13
+  --> tests/ui/ptr_cast_constness.rs:75:13
    |
 LL |     let _ = mut_ptr as *const u32;
    |             ^^^^^^^^^^^^^^^^^^^^^ help: try `pointer::cast_const`, a safer alternative: `mut_ptr.cast_const()`
 
 error: `as` casting to make a const null pointer into a mutable null pointer
-  --> tests/ui/ptr_cast_constness.rs:75:13
+  --> tests/ui/ptr_cast_constness.rs:82:13
    |
 LL |     let _ = ptr::null::<String>() as *mut String;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `null_mut()` directly instead: `std::ptr::null_mut::<String>()`
 
 error: `as` casting to make a mutable null pointer into a const null pointer
-  --> tests/ui/ptr_cast_constness.rs:76:13
+  --> tests/ui/ptr_cast_constness.rs:84:13
    |
 LL |     let _ = ptr::null_mut::<u32>() as *const u32;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `null()` directly instead: `std::ptr::null::<u32>()`
 
 error: changing constness of a null pointer
-  --> tests/ui/ptr_cast_constness.rs:77:13
+  --> tests/ui/ptr_cast_constness.rs:86:13
    |
 LL |     let _ = ptr::null::<u32>().cast_mut();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `null_mut()` directly instead: `std::ptr::null_mut::<u32>()`
 
 error: changing constness of a null pointer
-  --> tests/ui/ptr_cast_constness.rs:78:13
+  --> tests/ui/ptr_cast_constness.rs:88:13
    |
 LL |     let _ = ptr::null_mut::<u32>().cast_const();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `null()` directly instead: `std::ptr::null::<u32>()`
 
 error: `as` casting to make a const null pointer into a mutable null pointer
-  --> tests/ui/ptr_cast_constness.rs:81:21
+  --> tests/ui/ptr_cast_constness.rs:92:21
    |
 LL |     let _ = inline!(ptr::null::<u32>() as *mut u32);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `null_mut()` directly instead: `std::ptr::null_mut::<u32>()`
@@ -76,7 +76,7 @@ LL |     let _ = inline!(ptr::null::<u32>() as *mut u32);
    = note: this error originates in the macro `__inline_mac_fn_null_pointers` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: changing constness of a null pointer
-  --> tests/ui/ptr_cast_constness.rs:82:21
+  --> tests/ui/ptr_cast_constness.rs:94:21
    |
 LL |     let _ = inline!(ptr::null::<u32>().cast_mut());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `null_mut()` directly instead: `std::ptr::null_mut::<u32>()`
diff --git a/src/tools/clippy/tests/ui/ptr_eq.fixed b/src/tools/clippy/tests/ui/ptr_eq.fixed
index 3ae6df18c0a0..1ccd2c2237de 100644
--- a/src/tools/clippy/tests/ui/ptr_eq.fixed
+++ b/src/tools/clippy/tests/ui/ptr_eq.fixed
@@ -17,7 +17,9 @@ fn main() {
     let b = &[1, 2, 3];
 
     let _ = std::ptr::eq(a, b);
+    //~^ ptr_eq
     let _ = std::ptr::eq(a, b);
+    //~^ ptr_eq
     let _ = a.as_ptr() == b as *const _;
     let _ = a.as_ptr() == b.as_ptr();
 
diff --git a/src/tools/clippy/tests/ui/ptr_eq.rs b/src/tools/clippy/tests/ui/ptr_eq.rs
index 440d5d94a831..0bc58a57fa53 100644
--- a/src/tools/clippy/tests/ui/ptr_eq.rs
+++ b/src/tools/clippy/tests/ui/ptr_eq.rs
@@ -17,7 +17,9 @@ fn main() {
     let b = &[1, 2, 3];
 
     let _ = a as *const _ as usize == b as *const _ as usize;
+    //~^ ptr_eq
     let _ = a as *const _ == b as *const _;
+    //~^ ptr_eq
     let _ = a.as_ptr() == b as *const _;
     let _ = a.as_ptr() == b.as_ptr();
 
diff --git a/src/tools/clippy/tests/ui/ptr_eq.stderr b/src/tools/clippy/tests/ui/ptr_eq.stderr
index bf8c2b5c08fb..8e8b34f26ff7 100644
--- a/src/tools/clippy/tests/ui/ptr_eq.stderr
+++ b/src/tools/clippy/tests/ui/ptr_eq.stderr
@@ -8,7 +8,7 @@ LL |     let _ = a as *const _ as usize == b as *const _ as usize;
    = help: to override `-D warnings` add `#[allow(clippy::ptr_eq)]`
 
 error: use `std::ptr::eq` when comparing raw pointers
-  --> tests/ui/ptr_eq.rs:20:13
+  --> tests/ui/ptr_eq.rs:21:13
    |
 LL |     let _ = a as *const _ == b as *const _;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::eq(a, b)`
diff --git a/src/tools/clippy/tests/ui/ptr_eq_no_std.fixed b/src/tools/clippy/tests/ui/ptr_eq_no_std.fixed
index 97c8c394c03d..b3e82fae38f3 100644
--- a/src/tools/clippy/tests/ui/ptr_eq_no_std.fixed
+++ b/src/tools/clippy/tests/ui/ptr_eq_no_std.fixed
@@ -29,7 +29,9 @@ fn main() {
     let b = &[1, 2, 3];
 
     let _ = core::ptr::eq(a, b);
+    //~^ ptr_eq
     let _ = core::ptr::eq(a, b);
+    //~^ ptr_eq
     let _ = a.as_ptr() == b as *const _;
     let _ = a.as_ptr() == b.as_ptr();
 
diff --git a/src/tools/clippy/tests/ui/ptr_eq_no_std.rs b/src/tools/clippy/tests/ui/ptr_eq_no_std.rs
index a7ba9b4d8174..ba78f5ee5f84 100644
--- a/src/tools/clippy/tests/ui/ptr_eq_no_std.rs
+++ b/src/tools/clippy/tests/ui/ptr_eq_no_std.rs
@@ -29,7 +29,9 @@ fn main() {
     let b = &[1, 2, 3];
 
     let _ = a as *const _ as usize == b as *const _ as usize;
+    //~^ ptr_eq
     let _ = a as *const _ == b as *const _;
+    //~^ ptr_eq
     let _ = a.as_ptr() == b as *const _;
     let _ = a.as_ptr() == b.as_ptr();
 
diff --git a/src/tools/clippy/tests/ui/ptr_eq_no_std.stderr b/src/tools/clippy/tests/ui/ptr_eq_no_std.stderr
index 0463b75b720b..8c7b1ff76661 100644
--- a/src/tools/clippy/tests/ui/ptr_eq_no_std.stderr
+++ b/src/tools/clippy/tests/ui/ptr_eq_no_std.stderr
@@ -8,7 +8,7 @@ LL |     let _ = a as *const _ as usize == b as *const _ as usize;
    = help: to override `-D warnings` add `#[allow(clippy::ptr_eq)]`
 
 error: use `core::ptr::eq` when comparing raw pointers
-  --> tests/ui/ptr_eq_no_std.rs:32:13
+  --> tests/ui/ptr_eq_no_std.rs:33:13
    |
 LL |     let _ = a as *const _ == b as *const _;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `core::ptr::eq(a, b)`
diff --git a/src/tools/clippy/tests/ui/ptr_offset_with_cast.fixed b/src/tools/clippy/tests/ui/ptr_offset_with_cast.fixed
index 929512be63d4..4fe9dcf46c35 100644
--- a/src/tools/clippy/tests/ui/ptr_offset_with_cast.fixed
+++ b/src/tools/clippy/tests/ui/ptr_offset_with_cast.fixed
@@ -10,10 +10,12 @@ fn main() {
 
     unsafe {
         let _ = ptr.add(offset_usize);
+        //~^ ptr_offset_with_cast
         let _ = ptr.offset(offset_isize as isize);
         let _ = ptr.offset(offset_u8 as isize);
 
         let _ = ptr.wrapping_add(offset_usize);
+        //~^ ptr_offset_with_cast
         let _ = ptr.wrapping_offset(offset_isize as isize);
         let _ = ptr.wrapping_offset(offset_u8 as isize);
     }
diff --git a/src/tools/clippy/tests/ui/ptr_offset_with_cast.rs b/src/tools/clippy/tests/ui/ptr_offset_with_cast.rs
index 146bc27765ad..a1fb892733d3 100644
--- a/src/tools/clippy/tests/ui/ptr_offset_with_cast.rs
+++ b/src/tools/clippy/tests/ui/ptr_offset_with_cast.rs
@@ -10,10 +10,12 @@ fn main() {
 
     unsafe {
         let _ = ptr.offset(offset_usize as isize);
+        //~^ ptr_offset_with_cast
         let _ = ptr.offset(offset_isize as isize);
         let _ = ptr.offset(offset_u8 as isize);
 
         let _ = ptr.wrapping_offset(offset_usize as isize);
+        //~^ ptr_offset_with_cast
         let _ = ptr.wrapping_offset(offset_isize as isize);
         let _ = ptr.wrapping_offset(offset_u8 as isize);
     }
diff --git a/src/tools/clippy/tests/ui/ptr_offset_with_cast.stderr b/src/tools/clippy/tests/ui/ptr_offset_with_cast.stderr
index 87ff10adc946..dcd5e027d182 100644
--- a/src/tools/clippy/tests/ui/ptr_offset_with_cast.stderr
+++ b/src/tools/clippy/tests/ui/ptr_offset_with_cast.stderr
@@ -8,7 +8,7 @@ LL |         let _ = ptr.offset(offset_usize as isize);
    = help: to override `-D warnings` add `#[allow(clippy::ptr_offset_with_cast)]`
 
 error: use of `wrapping_offset` with a `usize` casted to an `isize`
-  --> tests/ui/ptr_offset_with_cast.rs:16:17
+  --> tests/ui/ptr_offset_with_cast.rs:17:17
    |
 LL |         let _ = ptr.wrapping_offset(offset_usize as isize);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr.wrapping_add(offset_usize)`
diff --git a/src/tools/clippy/tests/ui/pub_use.rs b/src/tools/clippy/tests/ui/pub_use.rs
index aef947e406a6..be4d1b2a964b 100644
--- a/src/tools/clippy/tests/ui/pub_use.rs
+++ b/src/tools/clippy/tests/ui/pub_use.rs
@@ -8,7 +8,7 @@ pub mod outer {
     }
     // should be linted
     pub use inner::Test;
-    //~^ ERROR: using `pub use`
+    //~^ pub_use
 }
 
 // should not be linted
diff --git a/src/tools/clippy/tests/ui/pub_with_shorthand.fixed b/src/tools/clippy/tests/ui/pub_with_shorthand.fixed
index 028209de0666..4036de8bbc0a 100644
--- a/src/tools/clippy/tests/ui/pub_with_shorthand.fixed
+++ b/src/tools/clippy/tests/ui/pub_with_shorthand.fixed
@@ -11,14 +11,18 @@
 extern crate proc_macros;
 
 pub(in self) fn a() {}
+//~^ pub_with_shorthand
 pub(in self) fn b() {}
 
 pub fn c() {}
 mod a {
     pub(in super) fn d() {}
     pub(in super) fn e() {}
+    //~^ pub_with_shorthand
     pub(in self) fn f() {}
+    //~^ pub_with_shorthand
     pub(in crate) fn k() {}
+    //~^ pub_with_shorthand
     pub(in crate) fn m() {}
     mod b {
         pub(in crate::a) fn l() {}
diff --git a/src/tools/clippy/tests/ui/pub_with_shorthand.rs b/src/tools/clippy/tests/ui/pub_with_shorthand.rs
index 8578e3e0c434..fac4ba990447 100644
--- a/src/tools/clippy/tests/ui/pub_with_shorthand.rs
+++ b/src/tools/clippy/tests/ui/pub_with_shorthand.rs
@@ -11,14 +11,18 @@
 extern crate proc_macros;
 
 pub(self) fn a() {}
+//~^ pub_with_shorthand
 pub(in self) fn b() {}
 
 pub fn c() {}
 mod a {
     pub(in super) fn d() {}
     pub(super) fn e() {}
+    //~^ pub_with_shorthand
     pub(self) fn f() {}
+    //~^ pub_with_shorthand
     pub(crate) fn k() {}
+    //~^ pub_with_shorthand
     pub(in crate) fn m() {}
     mod b {
         pub(in crate::a) fn l() {}
diff --git a/src/tools/clippy/tests/ui/pub_with_shorthand.stderr b/src/tools/clippy/tests/ui/pub_with_shorthand.stderr
index 8978244c4c04..00a3fc28ecb6 100644
--- a/src/tools/clippy/tests/ui/pub_with_shorthand.stderr
+++ b/src/tools/clippy/tests/ui/pub_with_shorthand.stderr
@@ -8,19 +8,19 @@ LL | pub(self) fn a() {}
    = help: to override `-D warnings` add `#[allow(clippy::pub_with_shorthand)]`
 
 error: usage of `pub` without `in`
-  --> tests/ui/pub_with_shorthand.rs:19:5
+  --> tests/ui/pub_with_shorthand.rs:20:5
    |
 LL |     pub(super) fn e() {}
    |     ^^^^^^^^^^ help: add it: `pub(in super)`
 
 error: usage of `pub` without `in`
-  --> tests/ui/pub_with_shorthand.rs:20:5
+  --> tests/ui/pub_with_shorthand.rs:22:5
    |
 LL |     pub(self) fn f() {}
    |     ^^^^^^^^^ help: add it: `pub(in self)`
 
 error: usage of `pub` without `in`
-  --> tests/ui/pub_with_shorthand.rs:21:5
+  --> tests/ui/pub_with_shorthand.rs:24:5
    |
 LL |     pub(crate) fn k() {}
    |     ^^^^^^^^^^ help: add it: `pub(in crate)`
diff --git a/src/tools/clippy/tests/ui/pub_without_shorthand.fixed b/src/tools/clippy/tests/ui/pub_without_shorthand.fixed
index 715e86c17645..fbe3326400cb 100644
--- a/src/tools/clippy/tests/ui/pub_without_shorthand.fixed
+++ b/src/tools/clippy/tests/ui/pub_without_shorthand.fixed
@@ -12,14 +12,17 @@ extern crate proc_macros;
 
 pub(self) fn a() {}
 pub(self) fn b() {}
+//~^ pub_without_shorthand
 
 pub fn c() {}
 mod a {
     pub(super) fn d() {}
+    //~^ pub_without_shorthand
     pub(super) fn e() {}
     pub(self) fn f() {}
     pub(crate) fn k() {}
     pub(crate) fn m() {}
+    //~^ pub_without_shorthand
     mod b {
         pub(in crate::a) fn l() {}
     }
diff --git a/src/tools/clippy/tests/ui/pub_without_shorthand.rs b/src/tools/clippy/tests/ui/pub_without_shorthand.rs
index ed2fd6f0f617..fb756096c9d9 100644
--- a/src/tools/clippy/tests/ui/pub_without_shorthand.rs
+++ b/src/tools/clippy/tests/ui/pub_without_shorthand.rs
@@ -12,14 +12,17 @@ extern crate proc_macros;
 
 pub(self) fn a() {}
 pub(in self) fn b() {}
+//~^ pub_without_shorthand
 
 pub fn c() {}
 mod a {
     pub(in super) fn d() {}
+    //~^ pub_without_shorthand
     pub(super) fn e() {}
     pub(self) fn f() {}
     pub(crate) fn k() {}
     pub(in crate) fn m() {}
+    //~^ pub_without_shorthand
     mod b {
         pub(in crate::a) fn l() {}
     }
diff --git a/src/tools/clippy/tests/ui/pub_without_shorthand.stderr b/src/tools/clippy/tests/ui/pub_without_shorthand.stderr
index e37c731732ba..c823af6432de 100644
--- a/src/tools/clippy/tests/ui/pub_without_shorthand.stderr
+++ b/src/tools/clippy/tests/ui/pub_without_shorthand.stderr
@@ -8,13 +8,13 @@ LL | pub(in self) fn b() {}
    = help: to override `-D warnings` add `#[allow(clippy::pub_without_shorthand)]`
 
 error: usage of `pub` with `in`
-  --> tests/ui/pub_without_shorthand.rs:18:5
+  --> tests/ui/pub_without_shorthand.rs:19:5
    |
 LL |     pub(in super) fn d() {}
    |     ^^^^^^^^^^^^^ help: remove it: `pub(super)`
 
 error: usage of `pub` with `in`
-  --> tests/ui/pub_without_shorthand.rs:22:5
+  --> tests/ui/pub_without_shorthand.rs:24:5
    |
 LL |     pub(in crate) fn m() {}
    |     ^^^^^^^^^^^^^ help: remove it: `pub(crate)`
diff --git a/src/tools/clippy/tests/ui/question_mark.fixed b/src/tools/clippy/tests/ui/question_mark.fixed
index b6e148e9f772..8dfef3202be9 100644
--- a/src/tools/clippy/tests/ui/question_mark.fixed
+++ b/src/tools/clippy/tests/ui/question_mark.fixed
@@ -141,6 +141,7 @@ fn func_returning_result() -> Result<i32, i32> {
 
 fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
     let _ = x?;
+    //~^ question_mark
 
     x?;
 
@@ -371,5 +372,6 @@ fn issue12412(foo: &Foo, bar: &Bar) -> Option<()> {
     };
     // lint
     let v = bar.foo.owned.clone()?;
+    //~^^^ question_mark
     Some(())
 }
diff --git a/src/tools/clippy/tests/ui/question_mark.rs b/src/tools/clippy/tests/ui/question_mark.rs
index 48dc9eb0a626..fffaa803f39c 100644
--- a/src/tools/clippy/tests/ui/question_mark.rs
+++ b/src/tools/clippy/tests/ui/question_mark.rs
@@ -5,6 +5,7 @@
 
 fn some_func(a: Option<u32>) -> Option<u32> {
     if a.is_none() {
+        //~^ question_mark
         return None;
     }
 
@@ -50,20 +51,24 @@ impl CopyStruct {
     #[rustfmt::skip]
     pub fn func(&self) -> Option<u32> {
         if (self.opt).is_none() {
+        //~^ question_mark
             return None;
         }
 
         if self.opt.is_none() {
+        //~^ question_mark
             return None
         }
 
         let _ = if self.opt.is_none() {
+        //~^ question_mark
             return None;
         } else {
             self.opt
         };
 
         let _ = if let Some(x) = self.opt {
+        //~^ question_mark
             x
         } else {
             return None;
@@ -81,6 +86,7 @@ pub struct MoveStruct {
 impl MoveStruct {
     pub fn ref_func(&self) -> Option<Vec<u32>> {
         if self.opt.is_none() {
+            //~^ question_mark
             return None;
         }
 
@@ -89,6 +95,7 @@ impl MoveStruct {
 
     pub fn mov_func_reuse(self) -> Option<Vec<u32>> {
         if self.opt.is_none() {
+            //~^ question_mark
             return None;
         }
 
@@ -97,6 +104,7 @@ impl MoveStruct {
 
     pub fn mov_func_no_use(self) -> Option<Vec<u32>> {
         if self.opt.is_none() {
+            //~^ question_mark
             return None;
         }
         Some(Vec::new())
@@ -104,6 +112,7 @@ impl MoveStruct {
 
     pub fn if_let_ref_func(self) -> Option<Vec<u32>> {
         let v: &Vec<_> = if let Some(ref v) = self.opt {
+            //~^ question_mark
             v
         } else {
             return None;
@@ -114,6 +123,7 @@ impl MoveStruct {
 
     pub fn if_let_mov_func(self) -> Option<Vec<u32>> {
         let v = if let Some(v) = self.opt {
+            //~^ question_mark
             v
         } else {
             return None;
@@ -135,10 +145,12 @@ fn func() -> Option<i32> {
     }
 
     if f().is_none() {
+        //~^ question_mark
         return None;
     }
 
     let _val = match f() {
+        //~^ question_mark
         Some(val) => val,
         None => return None,
     };
@@ -149,11 +161,13 @@ fn func() -> Option<i32> {
     };
 
     match f() {
+        //~^ question_mark
         Some(val) => val,
         None => return None,
     };
 
     match opt_none!() {
+        //~^ question_mark
         Some(x) => x,
         None => return None,
     };
@@ -180,17 +194,21 @@ fn func_returning_result() -> Result<i32, i32> {
 
 fn result_func(x: Result<i32, i32>) -> Result<i32, i32> {
     let _ = if let Ok(x) = x { x } else { return x };
+    //~^ question_mark
 
     if x.is_err() {
+        //~^ question_mark
         return x;
     }
 
     let _val = match func_returning_result() {
+        //~^ question_mark
         Ok(val) => val,
         Err(err) => return Err(err),
     };
 
     match func_returning_result() {
+        //~^ question_mark
         Ok(val) => val,
         Err(err) => return Err(err),
     };
@@ -282,6 +300,7 @@ fn do_something() {}
 
 fn err_immediate_return() -> Result<i32, i32> {
     if let Err(err) = func_returning_result() {
+        //~^ question_mark
         return Err(err);
     }
     Ok(1)
@@ -289,6 +308,7 @@ fn err_immediate_return() -> Result<i32, i32> {
 
 fn err_immediate_return_and_do_something() -> Result<i32, i32> {
     if let Err(err) = func_returning_result() {
+        //~^ question_mark
         return Err(err);
     }
     do_something();
@@ -366,6 +386,7 @@ fn issue6828_nested_body() -> Option<u32> {
     try {
         fn f2(a: Option<i32>) -> Option<i32> {
             if a.is_none() {
+                //~^ question_mark
                 return None;
                 // do lint here, the outer `try` is not relevant here
                 // https://github.com/rust-lang/rust-clippy/pull/11001#issuecomment-1610636867
@@ -428,5 +449,6 @@ fn issue12412(foo: &Foo, bar: &Bar) -> Option<()> {
     let Some(v) = bar.foo.owned.clone() else {
         return None;
     };
+    //~^^^ question_mark
     Some(())
 }
diff --git a/src/tools/clippy/tests/ui/question_mark.stderr b/src/tools/clippy/tests/ui/question_mark.stderr
index 06a8bd0de349..c4db0fbc3022 100644
--- a/src/tools/clippy/tests/ui/question_mark.stderr
+++ b/src/tools/clippy/tests/ui/question_mark.stderr
@@ -2,6 +2,7 @@ error: this block may be rewritten with the `?` operator
   --> tests/ui/question_mark.rs:7:5
    |
 LL | /     if a.is_none() {
+LL | |
 LL | |         return None;
 LL | |     }
    | |_____^ help: replace it with: `a?;`
@@ -10,26 +11,29 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::question_mark)]`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:52:9
+  --> tests/ui/question_mark.rs:53:9
    |
 LL | /         if (self.opt).is_none() {
+LL | |
 LL | |             return None;
 LL | |         }
    | |_________^ help: replace it with: `(self.opt)?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:56:9
+  --> tests/ui/question_mark.rs:58:9
    |
 LL | /         if self.opt.is_none() {
+LL | |
 LL | |             return None
 LL | |         }
    | |_________^ help: replace it with: `self.opt?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:60:17
+  --> tests/ui/question_mark.rs:63:17
    |
 LL |           let _ = if self.opt.is_none() {
    |  _________________^
+LL | |
 LL | |             return None;
 LL | |         } else {
 LL | |             self.opt
@@ -37,10 +41,11 @@ LL | |         };
    | |_________^ help: replace it with: `Some(self.opt?)`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:66:17
+  --> tests/ui/question_mark.rs:70:17
    |
 LL |           let _ = if let Some(x) = self.opt {
    |  _________________^
+LL | |
 LL | |             x
 LL | |         } else {
 LL | |             return None;
@@ -48,34 +53,38 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:83:9
+  --> tests/ui/question_mark.rs:88:9
    |
 LL | /         if self.opt.is_none() {
+LL | |
 LL | |             return None;
 LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:91:9
+  --> tests/ui/question_mark.rs:97:9
    |
 LL | /         if self.opt.is_none() {
+LL | |
 LL | |             return None;
 LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:99:9
+  --> tests/ui/question_mark.rs:106:9
    |
 LL | /         if self.opt.is_none() {
+LL | |
 LL | |             return None;
 LL | |         }
    | |_________^ help: replace it with: `self.opt.as_ref()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:106:26
+  --> tests/ui/question_mark.rs:114:26
    |
 LL |           let v: &Vec<_> = if let Some(ref v) = self.opt {
    |  __________________________^
+LL | |
 LL | |             v
 LL | |         } else {
 LL | |             return None;
@@ -83,10 +92,11 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt.as_ref()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:116:17
+  --> tests/ui/question_mark.rs:125:17
    |
 LL |           let v = if let Some(v) = self.opt {
    |  _________________^
+LL | |
 LL | |             v
 LL | |         } else {
 LL | |             return None;
@@ -94,101 +104,111 @@ LL | |         };
    | |_________^ help: replace it with: `self.opt?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:137:5
+  --> tests/ui/question_mark.rs:147:5
    |
 LL | /     if f().is_none() {
+LL | |
 LL | |         return None;
 LL | |     }
    | |_____^ help: replace it with: `f()?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:141:16
+  --> tests/ui/question_mark.rs:152:16
    |
 LL |       let _val = match f() {
    |  ________________^
+LL | |
 LL | |         Some(val) => val,
 LL | |         None => return None,
 LL | |     };
    | |_____^ help: try instead: `f()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:151:5
+  --> tests/ui/question_mark.rs:163:5
    |
 LL | /     match f() {
+LL | |
 LL | |         Some(val) => val,
 LL | |         None => return None,
 LL | |     };
    | |_____^ help: try instead: `f()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:156:5
+  --> tests/ui/question_mark.rs:169:5
    |
 LL | /     match opt_none!() {
+LL | |
 LL | |         Some(x) => x,
 LL | |         None => return None,
 LL | |     };
    | |_____^ help: try instead: `opt_none!()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:182:13
+  --> tests/ui/question_mark.rs:196:13
    |
 LL |     let _ = if let Ok(x) = x { x } else { return x };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `x?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:184:5
+  --> tests/ui/question_mark.rs:199:5
    |
 LL | /     if x.is_err() {
+LL | |
 LL | |         return x;
 LL | |     }
    | |_____^ help: replace it with: `x?;`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:188:16
+  --> tests/ui/question_mark.rs:204:16
    |
 LL |       let _val = match func_returning_result() {
    |  ________________^
+LL | |
 LL | |         Ok(val) => val,
 LL | |         Err(err) => return Err(err),
 LL | |     };
    | |_____^ help: try instead: `func_returning_result()?`
 
 error: this `match` expression can be replaced with `?`
-  --> tests/ui/question_mark.rs:193:5
+  --> tests/ui/question_mark.rs:210:5
    |
 LL | /     match func_returning_result() {
+LL | |
 LL | |         Ok(val) => val,
 LL | |         Err(err) => return Err(err),
 LL | |     };
    | |_____^ help: try instead: `func_returning_result()?`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:284:5
+  --> tests/ui/question_mark.rs:302:5
    |
 LL | /     if let Err(err) = func_returning_result() {
+LL | |
 LL | |         return Err(err);
 LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:291:5
+  --> tests/ui/question_mark.rs:310:5
    |
 LL | /     if let Err(err) = func_returning_result() {
+LL | |
 LL | |         return Err(err);
 LL | |     }
    | |_____^ help: replace it with: `func_returning_result()?;`
 
 error: this block may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:368:13
+  --> tests/ui/question_mark.rs:388:13
    |
 LL | /             if a.is_none() {
+LL | |
 LL | |                 return None;
 ...  |
 LL | |             }
    | |_____________^ help: replace it with: `a?;`
 
 error: this `let...else` may be rewritten with the `?` operator
-  --> tests/ui/question_mark.rs:428:5
+  --> tests/ui/question_mark.rs:449:5
    |
 LL | /     let Some(v) = bar.foo.owned.clone() else {
 LL | |         return None;
diff --git a/src/tools/clippy/tests/ui/question_mark_used.rs b/src/tools/clippy/tests/ui/question_mark_used.rs
index 715d7fab8eed..9e204d1e9f3c 100644
--- a/src/tools/clippy/tests/ui/question_mark_used.rs
+++ b/src/tools/clippy/tests/ui/question_mark_used.rs
@@ -9,7 +9,8 @@ fn other_function() -> Option<i32> {
 
 fn my_function() -> Option<i32> {
     other_function()?;
-    //~^ ERROR: question mark operator was used
+    //~^ question_mark_used
+
     None
 }
 
diff --git a/src/tools/clippy/tests/ui/range.fixed b/src/tools/clippy/tests/ui/range.fixed
new file mode 100644
index 000000000000..0e951d88091b
--- /dev/null
+++ b/src/tools/clippy/tests/ui/range.fixed
@@ -0,0 +1,19 @@
+#![allow(clippy::useless_vec)]
+#[warn(clippy::range_zip_with_len)]
+fn main() {
+    let v1 = vec![1, 2, 3];
+    let v2 = vec![4, 5];
+    let _x = v1.iter().enumerate();
+    //~^ range_zip_with_len
+
+    let _y = v1.iter().zip(0..v2.len()); // No error
+}
+
+#[allow(unused)]
+fn no_panic_with_fake_range_types() {
+    struct Range {
+        foo: i32,
+    }
+
+    let _ = Range { foo: 0 };
+}
diff --git a/src/tools/clippy/tests/ui/range.rs b/src/tools/clippy/tests/ui/range.rs
index 9541812b0691..534380164743 100644
--- a/src/tools/clippy/tests/ui/range.rs
+++ b/src/tools/clippy/tests/ui/range.rs
@@ -4,8 +4,8 @@ fn main() {
     let v1 = vec![1, 2, 3];
     let v2 = vec![4, 5];
     let _x = v1.iter().zip(0..v1.len());
-    //~^ ERROR: it is more idiomatic to use `v1.iter().enumerate()`
-    //~| NOTE: `-D clippy::range-zip-with-len` implied by `-D warnings`
+    //~^ range_zip_with_len
+
     let _y = v1.iter().zip(0..v2.len()); // No error
 }
 
diff --git a/src/tools/clippy/tests/ui/range.stderr b/src/tools/clippy/tests/ui/range.stderr
index 8c71a209700e..798ce1842d8b 100644
--- a/src/tools/clippy/tests/ui/range.stderr
+++ b/src/tools/clippy/tests/ui/range.stderr
@@ -1,8 +1,8 @@
-error: it is more idiomatic to use `v1.iter().enumerate()`
+error: using `.zip()` with a range and `.len()`
   --> tests/ui/range.rs:6:14
    |
 LL |     let _x = v1.iter().zip(0..v1.len());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `v1.iter().enumerate()`
    |
    = note: `-D clippy::range-zip-with-len` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::range_zip_with_len)]`
diff --git a/src/tools/clippy/tests/ui/range_contains.fixed b/src/tools/clippy/tests/ui/range_contains.fixed
index ed248df374d1..19d6165e9820 100644
--- a/src/tools/clippy/tests/ui/range_contains.fixed
+++ b/src/tools/clippy/tests/ui/range_contains.fixed
@@ -11,23 +11,35 @@ fn main() {
 
     // order shouldn't matter
     (8..12).contains(&x);
+    //~^ manual_range_contains
     (21..42).contains(&x);
+    //~^ manual_range_contains
     (1..100).contains(&x);
+    //~^ manual_range_contains
 
     // also with inclusive ranges
     (9..=99).contains(&x);
+    //~^ manual_range_contains
     (1..=33).contains(&x);
+    //~^ manual_range_contains
     (1..=999).contains(&x);
+    //~^ manual_range_contains
 
     // and the outside
     !(8..12).contains(&x);
+    //~^ manual_range_contains
     !(21..42).contains(&x);
+    //~^ manual_range_contains
     !(1..100).contains(&x);
+    //~^ manual_range_contains
 
     // also with the outside of inclusive ranges
     !(9..=99).contains(&x);
+    //~^ manual_range_contains
     !(1..=33).contains(&x);
+    //~^ manual_range_contains
     !(1..=999).contains(&x);
+    //~^ manual_range_contains
 
     // not a range.contains
     x > 8 && x < 12; // lower bound not inclusive
@@ -43,18 +55,26 @@ fn main() {
     // Fix #6315
     let y = 3.;
     (0. ..1.).contains(&y);
+    //~^ manual_range_contains
     !(0. ..=1.).contains(&y);
+    //~^ manual_range_contains
 
     // handle negatives #8721
     (-10..=10).contains(&x);
+    //~^ manual_range_contains
     x >= 10 && x <= -10;
     (-3. ..=3.).contains(&y);
+    //~^ manual_range_contains
     y >= 3. && y <= -3.;
 
     // Fix #8745
     let z = 42;
     (0..=10).contains(&x) && (0..=10).contains(&z);
+    //~^ manual_range_contains
+    //~| manual_range_contains
     !(0..10).contains(&x) || !(0..10).contains(&z);
+    //~^ manual_range_contains
+    //~| manual_range_contains
     // Make sure operators in parens don't give a breaking suggestion
     ((x % 2 == 0) || (x < 0)) || (x >= 10);
 }
@@ -74,4 +94,5 @@ fn msrv_1_34() {
 fn msrv_1_35() {
     let x = 5;
     (8..35).contains(&x);
+    //~^ manual_range_contains
 }
diff --git a/src/tools/clippy/tests/ui/range_contains.rs b/src/tools/clippy/tests/ui/range_contains.rs
index c3188ec6d92b..80bf40806697 100644
--- a/src/tools/clippy/tests/ui/range_contains.rs
+++ b/src/tools/clippy/tests/ui/range_contains.rs
@@ -11,23 +11,35 @@ fn main() {
 
     // order shouldn't matter
     x >= 8 && x < 12;
+    //~^ manual_range_contains
     x < 42 && x >= 21;
+    //~^ manual_range_contains
     100 > x && 1 <= x;
+    //~^ manual_range_contains
 
     // also with inclusive ranges
     x >= 9 && x <= 99;
+    //~^ manual_range_contains
     x <= 33 && x >= 1;
+    //~^ manual_range_contains
     999 >= x && 1 <= x;
+    //~^ manual_range_contains
 
     // and the outside
     x < 8 || x >= 12;
+    //~^ manual_range_contains
     x >= 42 || x < 21;
+    //~^ manual_range_contains
     100 <= x || 1 > x;
+    //~^ manual_range_contains
 
     // also with the outside of inclusive ranges
     x < 9 || x > 99;
+    //~^ manual_range_contains
     x > 33 || x < 1;
+    //~^ manual_range_contains
     999 < x || 1 > x;
+    //~^ manual_range_contains
 
     // not a range.contains
     x > 8 && x < 12; // lower bound not inclusive
@@ -43,18 +55,26 @@ fn main() {
     // Fix #6315
     let y = 3.;
     y >= 0. && y < 1.;
+    //~^ manual_range_contains
     y < 0. || y > 1.;
+    //~^ manual_range_contains
 
     // handle negatives #8721
     x >= -10 && x <= 10;
+    //~^ manual_range_contains
     x >= 10 && x <= -10;
     y >= -3. && y <= 3.;
+    //~^ manual_range_contains
     y >= 3. && y <= -3.;
 
     // Fix #8745
     let z = 42;
     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
+    //~^ manual_range_contains
+    //~| manual_range_contains
     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
+    //~^ manual_range_contains
+    //~| manual_range_contains
     // Make sure operators in parens don't give a breaking suggestion
     ((x % 2 == 0) || (x < 0)) || (x >= 10);
 }
@@ -74,4 +94,5 @@ fn msrv_1_34() {
 fn msrv_1_35() {
     let x = 5;
     x >= 8 && x < 35;
+    //~^ manual_range_contains
 }
diff --git a/src/tools/clippy/tests/ui/range_contains.stderr b/src/tools/clippy/tests/ui/range_contains.stderr
index 58ed1292ac7c..67bd5aad093d 100644
--- a/src/tools/clippy/tests/ui/range_contains.stderr
+++ b/src/tools/clippy/tests/ui/range_contains.stderr
@@ -8,121 +8,121 @@ LL |     x >= 8 && x < 12;
    = help: to override `-D warnings` add `#[allow(clippy::manual_range_contains)]`
 
 error: manual `Range::contains` implementation
-  --> tests/ui/range_contains.rs:14:5
+  --> tests/ui/range_contains.rs:15:5
    |
 LL |     x < 42 && x >= 21;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(21..42).contains(&x)`
 
 error: manual `Range::contains` implementation
-  --> tests/ui/range_contains.rs:15:5
+  --> tests/ui/range_contains.rs:17:5
    |
 LL |     100 > x && 1 <= x;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(1..100).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:18:5
+  --> tests/ui/range_contains.rs:21:5
    |
 LL |     x >= 9 && x <= 99;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(9..=99).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:19:5
+  --> tests/ui/range_contains.rs:23:5
    |
 LL |     x <= 33 && x >= 1;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(1..=33).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:20:5
+  --> tests/ui/range_contains.rs:25:5
    |
 LL |     999 >= x && 1 <= x;
    |     ^^^^^^^^^^^^^^^^^^ help: use: `(1..=999).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> tests/ui/range_contains.rs:23:5
+  --> tests/ui/range_contains.rs:29:5
    |
 LL |     x < 8 || x >= 12;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(8..12).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> tests/ui/range_contains.rs:24:5
+  --> tests/ui/range_contains.rs:31:5
    |
 LL |     x >= 42 || x < 21;
    |     ^^^^^^^^^^^^^^^^^ help: use: `!(21..42).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> tests/ui/range_contains.rs:25:5
+  --> tests/ui/range_contains.rs:33:5
    |
 LL |     100 <= x || 1 > x;
    |     ^^^^^^^^^^^^^^^^^ help: use: `!(1..100).contains(&x)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:28:5
+  --> tests/ui/range_contains.rs:37:5
    |
 LL |     x < 9 || x > 99;
    |     ^^^^^^^^^^^^^^^ help: use: `!(9..=99).contains(&x)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:29:5
+  --> tests/ui/range_contains.rs:39:5
    |
 LL |     x > 33 || x < 1;
    |     ^^^^^^^^^^^^^^^ help: use: `!(1..=33).contains(&x)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:30:5
+  --> tests/ui/range_contains.rs:41:5
    |
 LL |     999 < x || 1 > x;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(1..=999).contains(&x)`
 
 error: manual `Range::contains` implementation
-  --> tests/ui/range_contains.rs:45:5
+  --> tests/ui/range_contains.rs:57:5
    |
 LL |     y >= 0. && y < 1.;
    |     ^^^^^^^^^^^^^^^^^ help: use: `(0. ..1.).contains(&y)`
 
 error: manual `!RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:46:5
+  --> tests/ui/range_contains.rs:59:5
    |
 LL |     y < 0. || y > 1.;
    |     ^^^^^^^^^^^^^^^^ help: use: `!(0. ..=1.).contains(&y)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:49:5
+  --> tests/ui/range_contains.rs:63:5
    |
 LL |     x >= -10 && x <= 10;
    |     ^^^^^^^^^^^^^^^^^^^ help: use: `(-10..=10).contains(&x)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:51:5
+  --> tests/ui/range_contains.rs:66:5
    |
 LL |     y >= -3. && y <= 3.;
    |     ^^^^^^^^^^^^^^^^^^^ help: use: `(-3. ..=3.).contains(&y)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:56:30
+  --> tests/ui/range_contains.rs:72:30
    |
 LL |     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: use: `(0..=10).contains(&z)`
 
 error: manual `RangeInclusive::contains` implementation
-  --> tests/ui/range_contains.rs:56:5
+  --> tests/ui/range_contains.rs:72:5
    |
 LL |     (x >= 0) && (x <= 10) && (z >= 0) && (z <= 10);
    |     ^^^^^^^^^^^^^^^^^^^^^ help: use: `(0..=10).contains(&x)`
 
 error: manual `!Range::contains` implementation
-  --> tests/ui/range_contains.rs:57:29
+  --> tests/ui/range_contains.rs:75:29
    |
 LL |     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
    |                             ^^^^^^^^^^^^^^^^^^^^ help: use: `!(0..10).contains(&z)`
 
 error: manual `!Range::contains` implementation
-  --> tests/ui/range_contains.rs:57:5
+  --> tests/ui/range_contains.rs:75:5
    |
 LL |     (x < 0) || (x >= 10) || (z < 0) || (z >= 10);
    |     ^^^^^^^^^^^^^^^^^^^^ help: use: `!(0..10).contains(&x)`
 
 error: manual `Range::contains` implementation
-  --> tests/ui/range_contains.rs:76:5
+  --> tests/ui/range_contains.rs:96:5
    |
 LL |     x >= 8 && x < 35;
    |     ^^^^^^^^^^^^^^^^ help: use: `(8..35).contains(&x)`
diff --git a/src/tools/clippy/tests/ui/range_plus_minus_one.fixed b/src/tools/clippy/tests/ui/range_plus_minus_one.fixed
index e701dde86933..ee716ef3a6a0 100644
--- a/src/tools/clippy/tests/ui/range_plus_minus_one.fixed
+++ b/src/tools/clippy/tests/ui/range_plus_minus_one.fixed
@@ -27,29 +27,38 @@ fn main() {
     for _ in 0..=2 {}
 
     for _ in 0..=3 {}
+    //~^ range_plus_one
     for _ in 0..=3 + 1 {}
 
     for _ in 0..=5 {}
+    //~^ range_plus_one
     for _ in 0..=1 + 5 {}
 
     for _ in 1..=1 {}
+    //~^ range_plus_one
     for _ in 1..=1 + 1 {}
 
     for _ in 0..13 + 13 {}
     for _ in 0..=13 - 7 {}
 
     for _ in 0..=f() {}
+    //~^ range_plus_one
     for _ in 0..=(1 + f()) {}
 
     let _ = ..11 - 1;
     let _ = ..11;
+    //~^ range_minus_one
     let _ = ..11;
+    //~^ range_minus_one
     let _ = (1..=11);
+    //~^ range_plus_one
     let _ = ((f() + 1)..=f());
+    //~^ range_plus_one
 
     const ONE: usize = 1;
     // integer consts are linted, too
     for _ in 1..=ONE {}
+    //~^ range_plus_one
 
     let mut vec: Vec<()> = std::vec::Vec::new();
     vec.drain(..);
diff --git a/src/tools/clippy/tests/ui/range_plus_minus_one.rs b/src/tools/clippy/tests/ui/range_plus_minus_one.rs
index 7057fa8e3f0d..f2d5ae2c1506 100644
--- a/src/tools/clippy/tests/ui/range_plus_minus_one.rs
+++ b/src/tools/clippy/tests/ui/range_plus_minus_one.rs
@@ -27,29 +27,38 @@ fn main() {
     for _ in 0..=2 {}
 
     for _ in 0..3 + 1 {}
+    //~^ range_plus_one
     for _ in 0..=3 + 1 {}
 
     for _ in 0..1 + 5 {}
+    //~^ range_plus_one
     for _ in 0..=1 + 5 {}
 
     for _ in 1..1 + 1 {}
+    //~^ range_plus_one
     for _ in 1..=1 + 1 {}
 
     for _ in 0..13 + 13 {}
     for _ in 0..=13 - 7 {}
 
     for _ in 0..(1 + f()) {}
+    //~^ range_plus_one
     for _ in 0..=(1 + f()) {}
 
     let _ = ..11 - 1;
     let _ = ..=11 - 1;
+    //~^ range_minus_one
     let _ = ..=(11 - 1);
+    //~^ range_minus_one
     let _ = (1..11 + 1);
+    //~^ range_plus_one
     let _ = (f() + 1)..(f() + 1);
+    //~^ range_plus_one
 
     const ONE: usize = 1;
     // integer consts are linted, too
     for _ in 1..ONE + ONE {}
+    //~^ range_plus_one
 
     let mut vec: Vec<()> = std::vec::Vec::new();
     vec.drain(..);
diff --git a/src/tools/clippy/tests/ui/range_plus_minus_one.stderr b/src/tools/clippy/tests/ui/range_plus_minus_one.stderr
index 0b1883bc5ff2..9b23a8b8c0b4 100644
--- a/src/tools/clippy/tests/ui/range_plus_minus_one.stderr
+++ b/src/tools/clippy/tests/ui/range_plus_minus_one.stderr
@@ -8,25 +8,25 @@ LL |     for _ in 0..3 + 1 {}
    = help: to override `-D warnings` add `#[allow(clippy::range_plus_one)]`
 
 error: an inclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:32:14
+  --> tests/ui/range_plus_minus_one.rs:33:14
    |
 LL |     for _ in 0..1 + 5 {}
    |              ^^^^^^^^ help: use: `0..=5`
 
 error: an inclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:35:14
+  --> tests/ui/range_plus_minus_one.rs:37:14
    |
 LL |     for _ in 1..1 + 1 {}
    |              ^^^^^^^^ help: use: `1..=1`
 
 error: an inclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:41:14
+  --> tests/ui/range_plus_minus_one.rs:44:14
    |
 LL |     for _ in 0..(1 + f()) {}
    |              ^^^^^^^^^^^^ help: use: `0..=f()`
 
 error: an exclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:45:13
+  --> tests/ui/range_plus_minus_one.rs:49:13
    |
 LL |     let _ = ..=11 - 1;
    |             ^^^^^^^^^ help: use: `..11`
@@ -35,25 +35,25 @@ LL |     let _ = ..=11 - 1;
    = help: to override `-D warnings` add `#[allow(clippy::range_minus_one)]`
 
 error: an exclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:46:13
+  --> tests/ui/range_plus_minus_one.rs:51:13
    |
 LL |     let _ = ..=(11 - 1);
    |             ^^^^^^^^^^^ help: use: `..11`
 
 error: an inclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:47:13
+  --> tests/ui/range_plus_minus_one.rs:53:13
    |
 LL |     let _ = (1..11 + 1);
    |             ^^^^^^^^^^^ help: use: `(1..=11)`
 
 error: an inclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:48:13
+  --> tests/ui/range_plus_minus_one.rs:55:13
    |
 LL |     let _ = (f() + 1)..(f() + 1);
    |             ^^^^^^^^^^^^^^^^^^^^ help: use: `((f() + 1)..=f())`
 
 error: an inclusive range would be more readable
-  --> tests/ui/range_plus_minus_one.rs:52:14
+  --> tests/ui/range_plus_minus_one.rs:60:14
    |
 LL |     for _ in 1..ONE + ONE {}
    |              ^^^^^^^^^^^^ help: use: `1..=ONE`
diff --git a/src/tools/clippy/tests/ui/rc_buffer.fixed b/src/tools/clippy/tests/ui/rc_buffer.fixed
index 35ac95a76a91..c71a4072b962 100644
--- a/src/tools/clippy/tests/ui/rc_buffer.fixed
+++ b/src/tools/clippy/tests/ui/rc_buffer.fixed
@@ -9,18 +9,26 @@ use std::rc::Rc;
 struct S {
     // triggers lint
     bad1: Rc<str>,
+    //~^ rc_buffer
     bad2: Rc<std::path::Path>,
+    //~^ rc_buffer
     bad3: Rc<[u8]>,
+    //~^ rc_buffer
     bad4: Rc<std::ffi::OsStr>,
+    //~^ rc_buffer
     // does not trigger lint
     good1: Rc<RefCell<String>>,
 }
 
 // triggers lint
 fn func_bad1(_: Rc<str>) {}
+//~^ rc_buffer
 fn func_bad2(_: Rc<std::path::Path>) {}
+//~^ rc_buffer
 fn func_bad3(_: Rc<[u8]>) {}
+//~^ rc_buffer
 fn func_bad4(_: Rc<std::ffi::OsStr>) {}
+//~^ rc_buffer
 // does not trigger lint
 fn func_good1(_: Rc<RefCell<String>>) {}
 
diff --git a/src/tools/clippy/tests/ui/rc_buffer.rs b/src/tools/clippy/tests/ui/rc_buffer.rs
index e78fb5a6d9d8..686c2644da17 100644
--- a/src/tools/clippy/tests/ui/rc_buffer.rs
+++ b/src/tools/clippy/tests/ui/rc_buffer.rs
@@ -9,18 +9,26 @@ use std::rc::Rc;
 struct S {
     // triggers lint
     bad1: Rc<String>,
+    //~^ rc_buffer
     bad2: Rc<PathBuf>,
+    //~^ rc_buffer
     bad3: Rc<Vec<u8>>,
+    //~^ rc_buffer
     bad4: Rc<OsString>,
+    //~^ rc_buffer
     // does not trigger lint
     good1: Rc<RefCell<String>>,
 }
 
 // triggers lint
 fn func_bad1(_: Rc<String>) {}
+//~^ rc_buffer
 fn func_bad2(_: Rc<PathBuf>) {}
+//~^ rc_buffer
 fn func_bad3(_: Rc<Vec<u8>>) {}
+//~^ rc_buffer
 fn func_bad4(_: Rc<OsString>) {}
+//~^ rc_buffer
 // does not trigger lint
 fn func_good1(_: Rc<RefCell<String>>) {}
 
diff --git a/src/tools/clippy/tests/ui/rc_buffer.stderr b/src/tools/clippy/tests/ui/rc_buffer.stderr
index 922f09288bf3..7500523ab4ac 100644
--- a/src/tools/clippy/tests/ui/rc_buffer.stderr
+++ b/src/tools/clippy/tests/ui/rc_buffer.stderr
@@ -8,43 +8,43 @@ LL |     bad1: Rc<String>,
    = help: to override `-D warnings` add `#[allow(clippy::rc_buffer)]`
 
 error: usage of `Rc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer.rs:12:11
+  --> tests/ui/rc_buffer.rs:13:11
    |
 LL |     bad2: Rc<PathBuf>,
    |           ^^^^^^^^^^^ help: try: `Rc<std::path::Path>`
 
 error: usage of `Rc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer.rs:13:11
+  --> tests/ui/rc_buffer.rs:15:11
    |
 LL |     bad3: Rc<Vec<u8>>,
    |           ^^^^^^^^^^^ help: try: `Rc<[u8]>`
 
 error: usage of `Rc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer.rs:14:11
+  --> tests/ui/rc_buffer.rs:17:11
    |
 LL |     bad4: Rc<OsString>,
    |           ^^^^^^^^^^^^ help: try: `Rc<std::ffi::OsStr>`
 
 error: usage of `Rc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer.rs:20:17
+  --> tests/ui/rc_buffer.rs:24:17
    |
 LL | fn func_bad1(_: Rc<String>) {}
    |                 ^^^^^^^^^^ help: try: `Rc<str>`
 
 error: usage of `Rc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer.rs:21:17
+  --> tests/ui/rc_buffer.rs:26:17
    |
 LL | fn func_bad2(_: Rc<PathBuf>) {}
    |                 ^^^^^^^^^^^ help: try: `Rc<std::path::Path>`
 
 error: usage of `Rc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer.rs:22:17
+  --> tests/ui/rc_buffer.rs:28:17
    |
 LL | fn func_bad3(_: Rc<Vec<u8>>) {}
    |                 ^^^^^^^^^^^ help: try: `Rc<[u8]>`
 
 error: usage of `Rc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer.rs:23:17
+  --> tests/ui/rc_buffer.rs:30:17
    |
 LL | fn func_bad4(_: Rc<OsString>) {}
    |                 ^^^^^^^^^^^^ help: try: `Rc<std::ffi::OsStr>`
diff --git a/src/tools/clippy/tests/ui/rc_buffer_arc.fixed b/src/tools/clippy/tests/ui/rc_buffer_arc.fixed
index 0d01c7c476f7..27059e3f2e1f 100644
--- a/src/tools/clippy/tests/ui/rc_buffer_arc.fixed
+++ b/src/tools/clippy/tests/ui/rc_buffer_arc.fixed
@@ -8,18 +8,26 @@ use std::sync::{Arc, Mutex};
 struct S {
     // triggers lint
     bad1: Arc<str>,
+    //~^ rc_buffer
     bad2: Arc<std::path::Path>,
+    //~^ rc_buffer
     bad3: Arc<[u8]>,
+    //~^ rc_buffer
     bad4: Arc<std::ffi::OsStr>,
+    //~^ rc_buffer
     // does not trigger lint
     good1: Arc<Mutex<String>>,
 }
 
 // triggers lint
 fn func_bad1(_: Arc<str>) {}
+//~^ rc_buffer
 fn func_bad2(_: Arc<std::path::Path>) {}
+//~^ rc_buffer
 fn func_bad3(_: Arc<[u8]>) {}
+//~^ rc_buffer
 fn func_bad4(_: Arc<std::ffi::OsStr>) {}
+//~^ rc_buffer
 // does not trigger lint
 fn func_good1(_: Arc<Mutex<String>>) {}
 
diff --git a/src/tools/clippy/tests/ui/rc_buffer_arc.rs b/src/tools/clippy/tests/ui/rc_buffer_arc.rs
index 61ab16dc1829..5261eae2f26a 100644
--- a/src/tools/clippy/tests/ui/rc_buffer_arc.rs
+++ b/src/tools/clippy/tests/ui/rc_buffer_arc.rs
@@ -8,18 +8,26 @@ use std::sync::{Arc, Mutex};
 struct S {
     // triggers lint
     bad1: Arc<String>,
+    //~^ rc_buffer
     bad2: Arc<PathBuf>,
+    //~^ rc_buffer
     bad3: Arc<Vec<u8>>,
+    //~^ rc_buffer
     bad4: Arc<OsString>,
+    //~^ rc_buffer
     // does not trigger lint
     good1: Arc<Mutex<String>>,
 }
 
 // triggers lint
 fn func_bad1(_: Arc<String>) {}
+//~^ rc_buffer
 fn func_bad2(_: Arc<PathBuf>) {}
+//~^ rc_buffer
 fn func_bad3(_: Arc<Vec<u8>>) {}
+//~^ rc_buffer
 fn func_bad4(_: Arc<OsString>) {}
+//~^ rc_buffer
 // does not trigger lint
 fn func_good1(_: Arc<Mutex<String>>) {}
 
diff --git a/src/tools/clippy/tests/ui/rc_buffer_arc.stderr b/src/tools/clippy/tests/ui/rc_buffer_arc.stderr
index 5ef5da2f67f8..786715463232 100644
--- a/src/tools/clippy/tests/ui/rc_buffer_arc.stderr
+++ b/src/tools/clippy/tests/ui/rc_buffer_arc.stderr
@@ -8,43 +8,43 @@ LL |     bad1: Arc<String>,
    = help: to override `-D warnings` add `#[allow(clippy::rc_buffer)]`
 
 error: usage of `Arc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer_arc.rs:11:11
+  --> tests/ui/rc_buffer_arc.rs:12:11
    |
 LL |     bad2: Arc<PathBuf>,
    |           ^^^^^^^^^^^^ help: try: `Arc<std::path::Path>`
 
 error: usage of `Arc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer_arc.rs:12:11
+  --> tests/ui/rc_buffer_arc.rs:14:11
    |
 LL |     bad3: Arc<Vec<u8>>,
    |           ^^^^^^^^^^^^ help: try: `Arc<[u8]>`
 
 error: usage of `Arc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer_arc.rs:13:11
+  --> tests/ui/rc_buffer_arc.rs:16:11
    |
 LL |     bad4: Arc<OsString>,
    |           ^^^^^^^^^^^^^ help: try: `Arc<std::ffi::OsStr>`
 
 error: usage of `Arc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer_arc.rs:19:17
+  --> tests/ui/rc_buffer_arc.rs:23:17
    |
 LL | fn func_bad1(_: Arc<String>) {}
    |                 ^^^^^^^^^^^ help: try: `Arc<str>`
 
 error: usage of `Arc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer_arc.rs:20:17
+  --> tests/ui/rc_buffer_arc.rs:25:17
    |
 LL | fn func_bad2(_: Arc<PathBuf>) {}
    |                 ^^^^^^^^^^^^ help: try: `Arc<std::path::Path>`
 
 error: usage of `Arc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer_arc.rs:21:17
+  --> tests/ui/rc_buffer_arc.rs:27:17
    |
 LL | fn func_bad3(_: Arc<Vec<u8>>) {}
    |                 ^^^^^^^^^^^^ help: try: `Arc<[u8]>`
 
 error: usage of `Arc<T>` when T is a buffer type
-  --> tests/ui/rc_buffer_arc.rs:22:17
+  --> tests/ui/rc_buffer_arc.rs:29:17
    |
 LL | fn func_bad4(_: Arc<OsString>) {}
    |                 ^^^^^^^^^^^^^ help: try: `Arc<std::ffi::OsStr>`
diff --git a/src/tools/clippy/tests/ui/rc_buffer_redefined_string.rs b/src/tools/clippy/tests/ui/rc_buffer_redefined_string.rs
index 5d31a848cf72..49a8ba3e2efb 100644
--- a/src/tools/clippy/tests/ui/rc_buffer_redefined_string.rs
+++ b/src/tools/clippy/tests/ui/rc_buffer_redefined_string.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::rc_buffer)]
 
 use std::rc::Rc;
diff --git a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.rs b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.rs
index 1c9e9aa7ef47..ad5d131f34bc 100644
--- a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.rs
+++ b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.rs
@@ -7,8 +7,7 @@ fn main() {}
 
 fn should_warn_simple_case() {
     let v = vec![Arc::new("x".to_string()); 2];
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Arc` instance
+    //~^ rc_clone_in_vec_init
 }
 
 fn should_warn_simple_case_with_big_indentation() {
@@ -17,16 +16,16 @@ fn should_warn_simple_case_with_big_indentation() {
         dbg!(k);
         if true {
             let v = vec![Arc::new("x".to_string()); 2];
-            //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-            //~| NOTE: each element will point to the same `Arc` instance
+            //~^ rc_clone_in_vec_init
         }
     }
 }
 
 fn should_warn_complex_case() {
     let v = vec![
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Arc` instance
+    //~^ rc_clone_in_vec_init
+
+
         std::sync::Arc::new(Mutex::new({
             let x = 1;
             dbg!(x);
@@ -36,8 +35,9 @@ fn should_warn_complex_case() {
     ];
 
     let v1 = vec![
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Arc` instance
+    //~^ rc_clone_in_vec_init
+
+
         Arc::new(Mutex::new({
             let x = 1;
             dbg!(x);
diff --git a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.stderr b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.stderr
index 1078a97542f2..598d3c0ae577 100644
--- a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.stderr
+++ b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/arc.stderr
@@ -24,7 +24,7 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/arc.rs:19:21
+  --> tests/ui/rc_clone_in_vec_init/arc.rs:18:21
    |
 LL |             let v = vec![Arc::new("x".to_string()); 2];
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -47,13 +47,10 @@ LL ~             };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/arc.rs:27:13
+  --> tests/ui/rc_clone_in_vec_init/arc.rs:25:13
    |
 LL |       let v = vec![
    |  _____________^
-LL | |
-LL | |
-LL | |         std::sync::Arc::new(Mutex::new({
 ...  |
 LL | |         2
 LL | |     ];
@@ -77,13 +74,10 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/arc.rs:38:14
+  --> tests/ui/rc_clone_in_vec_init/arc.rs:37:14
    |
 LL |       let v1 = vec![
    |  ______________^
-LL | |
-LL | |
-LL | |         Arc::new(Mutex::new({
 ...  |
 LL | |         2
 LL | |     ];
diff --git a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.rs b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.rs
index 01cc433cbdae..d5af17c29e1d 100644
--- a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.rs
+++ b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.rs
@@ -8,8 +8,7 @@ fn main() {}
 
 fn should_warn_simple_case() {
     let v = vec![Rc::new("x".to_string()); 2];
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Rc` instance
+    //~^ rc_clone_in_vec_init
 }
 
 fn should_warn_simple_case_with_big_indentation() {
@@ -18,16 +17,16 @@ fn should_warn_simple_case_with_big_indentation() {
         dbg!(k);
         if true {
             let v = vec![Rc::new("x".to_string()); 2];
-            //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-            //~| NOTE: each element will point to the same `Rc` instance
+            //~^ rc_clone_in_vec_init
         }
     }
 }
 
 fn should_warn_complex_case() {
     let v = vec![
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Rc` instance
+    //~^ rc_clone_in_vec_init
+
+
         std::rc::Rc::new(Mutex::new({
             let x = 1;
             dbg!(x);
@@ -37,8 +36,9 @@ fn should_warn_complex_case() {
     ];
 
     let v1 = vec![
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Rc` instance
+    //~^ rc_clone_in_vec_init
+
+
         Rc::new(Mutex::new({
             let x = 1;
             dbg!(x);
diff --git a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.stderr b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.stderr
index 702266d62d2c..60d7f33ada9c 100644
--- a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.stderr
+++ b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/rc.stderr
@@ -24,7 +24,7 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/rc.rs:20:21
+  --> tests/ui/rc_clone_in_vec_init/rc.rs:19:21
    |
 LL |             let v = vec![Rc::new("x".to_string()); 2];
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -47,13 +47,10 @@ LL ~             };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/rc.rs:28:13
+  --> tests/ui/rc_clone_in_vec_init/rc.rs:26:13
    |
 LL |       let v = vec![
    |  _____________^
-LL | |
-LL | |
-LL | |         std::rc::Rc::new(Mutex::new({
 ...  |
 LL | |         2
 LL | |     ];
@@ -77,13 +74,10 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/rc.rs:39:14
+  --> tests/ui/rc_clone_in_vec_init/rc.rs:38:14
    |
 LL |       let v1 = vec![
    |  ______________^
-LL | |
-LL | |
-LL | |         Rc::new(Mutex::new({
 ...  |
 LL | |         2
 LL | |     ];
diff --git a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.rs b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.rs
index fd2895d40458..add09b6ba859 100644
--- a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.rs
+++ b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.rs
@@ -8,18 +8,16 @@ fn main() {}
 
 fn should_warn_simple_case() {
     let v = vec![SyncWeak::<u32>::new(); 2];
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Weak` instance
+    //~^ rc_clone_in_vec_init
+
     let v2 = vec![UnSyncWeak::<u32>::new(); 2];
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Weak` instance
+    //~^ rc_clone_in_vec_init
 
     let v = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Weak` instance
+    //~^ rc_clone_in_vec_init
+
     let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Weak` instance
+    //~^ rc_clone_in_vec_init
 }
 
 fn should_warn_simple_case_with_big_indentation() {
@@ -28,19 +26,19 @@ fn should_warn_simple_case_with_big_indentation() {
         dbg!(k);
         if true {
             let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
-            //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-            //~| NOTE: each element will point to the same `Weak` instance
+            //~^ rc_clone_in_vec_init
+
             let v2 = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
-            //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-            //~| NOTE: each element will point to the same `Weak` instance
+            //~^ rc_clone_in_vec_init
         }
     }
 }
 
 fn should_warn_complex_case() {
     let v = vec![
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Weak` instance
+    //~^ rc_clone_in_vec_init
+
+
         Arc::downgrade(&Arc::new(Mutex::new({
             let x = 1;
             dbg!(x);
@@ -50,8 +48,9 @@ fn should_warn_complex_case() {
     ];
 
     let v1 = vec![
-    //~^ ERROR: initializing a reference-counted pointer in `vec![elem; len]`
-    //~| NOTE: each element will point to the same `Weak` instance
+    //~^ rc_clone_in_vec_init
+
+
         Rc::downgrade(&Rc::new(Mutex::new({
             let x = 1;
             dbg!(x);
diff --git a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.stderr b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.stderr
index 68ca2a7eb848..8bd018ab586c 100644
--- a/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.stderr
+++ b/src/tools/clippy/tests/ui/rc_clone_in_vec_init/weak.stderr
@@ -47,7 +47,7 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/weak.rs:17:13
+  --> tests/ui/rc_clone_in_vec_init/weak.rs:16:13
    |
 LL |     let v = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -70,7 +70,7 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/weak.rs:20:13
+  --> tests/ui/rc_clone_in_vec_init/weak.rs:19:13
    |
 LL |     let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -93,7 +93,7 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/weak.rs:30:21
+  --> tests/ui/rc_clone_in_vec_init/weak.rs:28:21
    |
 LL |             let v = vec![Arc::downgrade(&Arc::new("x".to_string())); 2];
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -116,7 +116,7 @@ LL ~             };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/weak.rs:33:22
+  --> tests/ui/rc_clone_in_vec_init/weak.rs:31:22
    |
 LL |             let v2 = vec![Rc::downgrade(&Rc::new("x".to_string())); 2];
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -139,13 +139,10 @@ LL ~             };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/weak.rs:41:13
+  --> tests/ui/rc_clone_in_vec_init/weak.rs:38:13
    |
 LL |       let v = vec![
    |  _____________^
-LL | |
-LL | |
-LL | |         Arc::downgrade(&Arc::new(Mutex::new({
 ...  |
 LL | |         2
 LL | |     ];
@@ -169,13 +166,10 @@ LL ~     };
    |
 
 error: initializing a reference-counted pointer in `vec![elem; len]`
-  --> tests/ui/rc_clone_in_vec_init/weak.rs:52:14
+  --> tests/ui/rc_clone_in_vec_init/weak.rs:50:14
    |
 LL |       let v1 = vec![
    |  ______________^
-LL | |
-LL | |
-LL | |         Rc::downgrade(&Rc::new(Mutex::new({
 ...  |
 LL | |         2
 LL | |     ];
diff --git a/src/tools/clippy/tests/ui/rc_mutex.rs b/src/tools/clippy/tests/ui/rc_mutex.rs
index 40adb3ddce95..c8700e13b11e 100644
--- a/src/tools/clippy/tests/ui/rc_mutex.rs
+++ b/src/tools/clippy/tests/ui/rc_mutex.rs
@@ -6,7 +6,7 @@ use std::sync::Mutex;
 
 pub struct MyStructWithPrivItem {
     foo: Rc<Mutex<i32>>,
-    //~^ ERROR: usage of `Rc<Mutex<_>>`
+    //~^ rc_mutex
 }
 
 pub struct MyStructWithPubItem {
@@ -25,11 +25,13 @@ pub enum MyEnum {
 // All of these test should be trigger the lint because they are not
 // part of the public api
 fn test1<T>(foo: Rc<Mutex<T>>) {}
-//~^ ERROR: usage of `Rc<Mutex<_>>`
+//~^ rc_mutex
+
 fn test2(foo: Rc<Mutex<MyEnum>>) {}
-//~^ ERROR: usage of `Rc<Mutex<_>>`
+//~^ rc_mutex
+
 fn test3(foo: Rc<Mutex<SubT<usize>>>) {}
-//~^ ERROR: usage of `Rc<Mutex<_>>`
+//~^ rc_mutex
 
 // All of these test should be allowed because they are part of the
 // public api and `avoid_breaking_exported_api` is `false` by default.
diff --git a/src/tools/clippy/tests/ui/rc_mutex.stderr b/src/tools/clippy/tests/ui/rc_mutex.stderr
index 9aa18336df00..5b589cfa309a 100644
--- a/src/tools/clippy/tests/ui/rc_mutex.stderr
+++ b/src/tools/clippy/tests/ui/rc_mutex.stderr
@@ -17,7 +17,7 @@ LL | fn test1<T>(foo: Rc<Mutex<T>>) {}
    = help: consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
 
 error: usage of `Rc<Mutex<_>>`
-  --> tests/ui/rc_mutex.rs:29:15
+  --> tests/ui/rc_mutex.rs:30:15
    |
 LL | fn test2(foo: Rc<Mutex<MyEnum>>) {}
    |               ^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL | fn test2(foo: Rc<Mutex<MyEnum>>) {}
    = help: consider using `Rc<RefCell<_>>` or `Arc<Mutex<_>>` instead
 
 error: usage of `Rc<Mutex<_>>`
-  --> tests/ui/rc_mutex.rs:31:15
+  --> tests/ui/rc_mutex.rs:33:15
    |
 LL | fn test3(foo: Rc<Mutex<SubT<usize>>>) {}
    |               ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/read_line_without_trim.fixed b/src/tools/clippy/tests/ui/read_line_without_trim.fixed
index 523ad5552747..e7f208e78d20 100644
--- a/src/tools/clippy/tests/ui/read_line_without_trim.fixed
+++ b/src/tools/clippy/tests/ui/read_line_without_trim.fixed
@@ -10,22 +10,27 @@ fn main() {
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x: i32 = input.trim_end().parse().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.trim_end().parse::<i32>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.trim_end().parse::<u32>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.trim_end().parse::<f32>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.trim_end().parse::<bool>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
@@ -36,12 +41,14 @@ fn main() {
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     if input.trim_end() == "foo" {
+        //~^ read_line_without_trim
         println!("This will never ever execute!");
     }
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     if input.trim_end().ends_with("foo") {
+        //~^ read_line_without_trim
         println!("Neither will this");
     }
 }
diff --git a/src/tools/clippy/tests/ui/read_line_without_trim.rs b/src/tools/clippy/tests/ui/read_line_without_trim.rs
index e31ff0cde61d..6664278b5a87 100644
--- a/src/tools/clippy/tests/ui/read_line_without_trim.rs
+++ b/src/tools/clippy/tests/ui/read_line_without_trim.rs
@@ -10,22 +10,27 @@ fn main() {
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x: i32 = input.parse().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.parse::<i32>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.parse::<u32>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.parse::<f32>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     let _x = input.parse::<bool>().unwrap();
+    //~^ read_line_without_trim
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
@@ -36,12 +41,14 @@ fn main() {
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     if input == "foo" {
+        //~^ read_line_without_trim
         println!("This will never ever execute!");
     }
 
     let mut input = String::new();
     std::io::stdin().read_line(&mut input).unwrap();
     if input.ends_with("foo") {
+        //~^ read_line_without_trim
         println!("Neither will this");
     }
 }
diff --git a/src/tools/clippy/tests/ui/read_line_without_trim.stderr b/src/tools/clippy/tests/ui/read_line_without_trim.stderr
index b54229f762a3..5e5618111432 100644
--- a/src/tools/clippy/tests/ui/read_line_without_trim.stderr
+++ b/src/tools/clippy/tests/ui/read_line_without_trim.stderr
@@ -15,7 +15,7 @@ LL |     std::io::stdin().read_line(&mut input).unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::read_line_without_trim)]`
 
 error: calling `.parse()` on a string without trimming the trailing newline character
-  --> tests/ui/read_line_without_trim.rs:16:20
+  --> tests/ui/read_line_without_trim.rs:17:20
    |
 LL |     let _x = input.parse::<i32>().unwrap();
    |              ----- ^^^^^^^^^^^^^^
@@ -23,13 +23,13 @@ LL |     let _x = input.parse::<i32>().unwrap();
    |              help: try: `input.trim_end()`
    |
 note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause the checking to always fail
-  --> tests/ui/read_line_without_trim.rs:15:5
+  --> tests/ui/read_line_without_trim.rs:16:5
    |
 LL |     std::io::stdin().read_line(&mut input).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `.parse()` on a string without trimming the trailing newline character
-  --> tests/ui/read_line_without_trim.rs:20:20
+  --> tests/ui/read_line_without_trim.rs:22:20
    |
 LL |     let _x = input.parse::<u32>().unwrap();
    |              ----- ^^^^^^^^^^^^^^
@@ -37,13 +37,13 @@ LL |     let _x = input.parse::<u32>().unwrap();
    |              help: try: `input.trim_end()`
    |
 note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause the checking to always fail
-  --> tests/ui/read_line_without_trim.rs:19:5
+  --> tests/ui/read_line_without_trim.rs:21:5
    |
 LL |     std::io::stdin().read_line(&mut input).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `.parse()` on a string without trimming the trailing newline character
-  --> tests/ui/read_line_without_trim.rs:24:20
+  --> tests/ui/read_line_without_trim.rs:27:20
    |
 LL |     let _x = input.parse::<f32>().unwrap();
    |              ----- ^^^^^^^^^^^^^^
@@ -51,13 +51,13 @@ LL |     let _x = input.parse::<f32>().unwrap();
    |              help: try: `input.trim_end()`
    |
 note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause the checking to always fail
-  --> tests/ui/read_line_without_trim.rs:23:5
+  --> tests/ui/read_line_without_trim.rs:26:5
    |
 LL |     std::io::stdin().read_line(&mut input).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: calling `.parse()` on a string without trimming the trailing newline character
-  --> tests/ui/read_line_without_trim.rs:28:20
+  --> tests/ui/read_line_without_trim.rs:32:20
    |
 LL |     let _x = input.parse::<bool>().unwrap();
    |              ----- ^^^^^^^^^^^^^^^
@@ -65,13 +65,13 @@ LL |     let _x = input.parse::<bool>().unwrap();
    |              help: try: `input.trim_end()`
    |
 note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause the checking to always fail
-  --> tests/ui/read_line_without_trim.rs:27:5
+  --> tests/ui/read_line_without_trim.rs:31:5
    |
 LL |     std::io::stdin().read_line(&mut input).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: comparing a string literal without trimming the trailing newline character
-  --> tests/ui/read_line_without_trim.rs:38:8
+  --> tests/ui/read_line_without_trim.rs:43:8
    |
 LL |     if input == "foo" {
    |        -----^^^^^^^^^
@@ -79,13 +79,13 @@ LL |     if input == "foo" {
    |        help: try: `input.trim_end()`
    |
 note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause the comparison to always fail
-  --> tests/ui/read_line_without_trim.rs:37:5
+  --> tests/ui/read_line_without_trim.rs:42:5
    |
 LL |     std::io::stdin().read_line(&mut input).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: checking the end of a string without trimming the trailing newline character
-  --> tests/ui/read_line_without_trim.rs:44:8
+  --> tests/ui/read_line_without_trim.rs:50:8
    |
 LL |     if input.ends_with("foo") {
    |        -----^^^^^^^^^^^^^^^^^
@@ -93,7 +93,7 @@ LL |     if input.ends_with("foo") {
    |        help: try: `input.trim_end()`
    |
 note: call to `.read_line()` here, which leaves a trailing newline character in the buffer, which in turn will cause the parsing to always fail
-  --> tests/ui/read_line_without_trim.rs:43:5
+  --> tests/ui/read_line_without_trim.rs:49:5
    |
 LL |     std::io::stdin().read_line(&mut input).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/read_zero_byte_vec.rs b/src/tools/clippy/tests/ui/read_zero_byte_vec.rs
index 68acf4334699..938d61b68607 100644
--- a/src/tools/clippy/tests/ui/read_zero_byte_vec.rs
+++ b/src/tools/clippy/tests/ui/read_zero_byte_vec.rs
@@ -8,6 +8,7 @@ use std::fs::File;
 use std::io;
 use std::io::prelude::*;
 //@no-rustfix
+//@require-annotations-for-level: WARN
 extern crate futures;
 use futures::io::{AsyncRead, AsyncReadExt};
 use tokio::io::{AsyncRead as TokioAsyncRead, AsyncReadExt as _, AsyncWrite as TokioAsyncWrite, AsyncWriteExt as _};
diff --git a/src/tools/clippy/tests/ui/read_zero_byte_vec.stderr b/src/tools/clippy/tests/ui/read_zero_byte_vec.stderr
index e2356f1cb56b..8f255bc87ab8 100644
--- a/src/tools/clippy/tests/ui/read_zero_byte_vec.stderr
+++ b/src/tools/clippy/tests/ui/read_zero_byte_vec.stderr
@@ -1,5 +1,5 @@
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:21:5
+  --> tests/ui/read_zero_byte_vec.rs:22:5
    |
 LL |     f.read_exact(&mut data).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data.resize(20, 0); f.read_exact(&mut data)`
@@ -8,61 +8,61 @@ LL |     f.read_exact(&mut data).unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::read_zero_byte_vec)]`
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:27:5
+  --> tests/ui/read_zero_byte_vec.rs:28:5
    |
 LL |     f.read_exact(&mut data2)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `data2.resize(cap, 0); f.read_exact(&mut data2)`
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:32:5
+  --> tests/ui/read_zero_byte_vec.rs:33:5
    |
 LL |     f.read_exact(&mut data3)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:37:13
+  --> tests/ui/read_zero_byte_vec.rs:38:13
    |
 LL |     let _ = f.read(&mut data4)?;
    |             ^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:43:9
+  --> tests/ui/read_zero_byte_vec.rs:44:9
    |
 LL |         f.read(&mut data5)
    |         ^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:50:9
+  --> tests/ui/read_zero_byte_vec.rs:51:9
    |
 LL |         f.read(&mut data6)
    |         ^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:84:9
+  --> tests/ui/read_zero_byte_vec.rs:85:9
    |
 LL |         f.read(&mut v)?;
    |         ^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:94:5
+  --> tests/ui/read_zero_byte_vec.rs:95:5
    |
 LL |     r.read(&mut data).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:99:5
+  --> tests/ui/read_zero_byte_vec.rs:100:5
    |
 LL |     r.read_exact(&mut data2).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:106:5
+  --> tests/ui/read_zero_byte_vec.rs:107:5
    |
 LL |     r.read(&mut data).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^
 
 error: reading zero byte data to `Vec`
-  --> tests/ui/read_zero_byte_vec.rs:111:5
+  --> tests/ui/read_zero_byte_vec.rs:112:5
    |
 LL |     r.read_exact(&mut data2).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/readonly_write_lock.fixed b/src/tools/clippy/tests/ui/readonly_write_lock.fixed
index 4db13482ac78..0cb91247232b 100644
--- a/src/tools/clippy/tests/ui/readonly_write_lock.fixed
+++ b/src/tools/clippy/tests/ui/readonly_write_lock.fixed
@@ -14,14 +14,15 @@ fn main() {
 
     {
         let writer = lock.read().unwrap();
-        //~^ ERROR: this write lock is used only for reading
-        //~| NOTE: `-D clippy::readonly-write-lock` implied by `-D warnings`
+        //~^ readonly_write_lock
+
         dbg!(&writer);
     }
 
     {
         let writer = lock.read().unwrap();
-        //~^ ERROR: this write lock is used only for reading
+        //~^ readonly_write_lock
+
         accept_i32(*writer);
     }
 
diff --git a/src/tools/clippy/tests/ui/readonly_write_lock.rs b/src/tools/clippy/tests/ui/readonly_write_lock.rs
index 66ba1b2d6969..843755fe792c 100644
--- a/src/tools/clippy/tests/ui/readonly_write_lock.rs
+++ b/src/tools/clippy/tests/ui/readonly_write_lock.rs
@@ -14,14 +14,15 @@ fn main() {
 
     {
         let writer = lock.write().unwrap();
-        //~^ ERROR: this write lock is used only for reading
-        //~| NOTE: `-D clippy::readonly-write-lock` implied by `-D warnings`
+        //~^ readonly_write_lock
+
         dbg!(&writer);
     }
 
     {
         let writer = lock.write().unwrap();
-        //~^ ERROR: this write lock is used only for reading
+        //~^ readonly_write_lock
+
         accept_i32(*writer);
     }
 
diff --git a/src/tools/clippy/tests/ui/recursive_format_impl.rs b/src/tools/clippy/tests/ui/recursive_format_impl.rs
index b3eafc6dad7a..9f46fef62354 100644
--- a/src/tools/clippy/tests/ui/recursive_format_impl.rs
+++ b/src/tools/clippy/tests/ui/recursive_format_impl.rs
@@ -29,8 +29,7 @@ impl B for A {
 impl fmt::Display for A {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
         write!(f, "{}", self.to_string())
-        //~^ ERROR: using `self.to_string` in `fmt::Display` implementation will cause inf
-        //~| NOTE: `-D clippy::recursive-format-impl` implied by `-D warnings`
+        //~^ recursive_format_impl
     }
 }
 
@@ -75,7 +74,7 @@ struct G;
 impl std::fmt::Display for G {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", self)
-        //~^ ERROR: using `self` as `Display` in `impl Display` will cause infinite recurs
+        //~^ recursive_format_impl
     }
 }
 
@@ -85,14 +84,14 @@ struct H;
 impl std::fmt::Display for H {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", &self)
-        //~^ ERROR: using `self` as `Display` in `impl Display` will cause infinite recurs
+        //~^ recursive_format_impl
     }
 }
 
 impl std::fmt::Debug for H {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{:?}", &self)
-        //~^ ERROR: using `self` as `Debug` in `impl Debug` will cause infinite recursion
+        //~^ recursive_format_impl
     }
 }
 
@@ -102,7 +101,7 @@ struct H2;
 impl std::fmt::Display for H2 {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         write!(f, "{}", &&&self)
-        //~^ ERROR: using `self` as `Display` in `impl Display` will cause infinite recurs
+        //~^ recursive_format_impl
     }
 }
 
@@ -177,14 +176,14 @@ impl std::ops::Deref for J {
 impl std::fmt::Display for J {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}", &*self)
-        //~^ ERROR: using `self` as `Display` in `impl Display` will cause infinite recurs
+        //~^ recursive_format_impl
     }
 }
 
 impl std::fmt::Debug for J {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{:?}", &*self)
-        //~^ ERROR: using `self` as `Debug` in `impl Debug` will cause infinite recursion
+        //~^ recursive_format_impl
     }
 }
 
@@ -201,7 +200,7 @@ impl std::ops::Deref for J2 {
 impl std::fmt::Display for J2 {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}", *self)
-        //~^ ERROR: using `self` as `Display` in `impl Display` will cause infinite recurs
+        //~^ recursive_format_impl
     }
 }
 
@@ -218,7 +217,7 @@ impl std::ops::Deref for J3 {
 impl std::fmt::Display for J3 {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}", **&&*self)
-        //~^ ERROR: using `self` as `Display` in `impl Display` will cause infinite recurs
+        //~^ recursive_format_impl
     }
 }
 
@@ -235,7 +234,7 @@ impl std::ops::Deref for J4 {
 impl std::fmt::Display for J4 {
     fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
         write!(f, "{}", &&**&&*self)
-        //~^ ERROR: using `self` as `Display` in `impl Display` will cause infinite recurs
+        //~^ recursive_format_impl
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/recursive_format_impl.stderr b/src/tools/clippy/tests/ui/recursive_format_impl.stderr
index f80aff01eb53..31960c7193b4 100644
--- a/src/tools/clippy/tests/ui/recursive_format_impl.stderr
+++ b/src/tools/clippy/tests/ui/recursive_format_impl.stderr
@@ -8,7 +8,7 @@ LL |         write!(f, "{}", self.to_string())
    = help: to override `-D warnings` add `#[allow(clippy::recursive_format_impl)]`
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:77:9
+  --> tests/ui/recursive_format_impl.rs:76:9
    |
 LL |         write!(f, "{}", self)
    |         ^^^^^^^^^^^^^^^^^^^^^
@@ -16,7 +16,7 @@ LL |         write!(f, "{}", self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:87:9
+  --> tests/ui/recursive_format_impl.rs:86:9
    |
 LL |         write!(f, "{}", &self)
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -24,7 +24,7 @@ LL |         write!(f, "{}", &self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Debug` in `impl Debug` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:94:9
+  --> tests/ui/recursive_format_impl.rs:93:9
    |
 LL |         write!(f, "{:?}", &self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -32,7 +32,7 @@ LL |         write!(f, "{:?}", &self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:104:9
+  --> tests/ui/recursive_format_impl.rs:103:9
    |
 LL |         write!(f, "{}", &&&self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -40,7 +40,7 @@ LL |         write!(f, "{}", &&&self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:179:9
+  --> tests/ui/recursive_format_impl.rs:178:9
    |
 LL |         write!(f, "{}", &*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -48,7 +48,7 @@ LL |         write!(f, "{}", &*self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Debug` in `impl Debug` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:186:9
+  --> tests/ui/recursive_format_impl.rs:185:9
    |
 LL |         write!(f, "{:?}", &*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -56,7 +56,7 @@ LL |         write!(f, "{:?}", &*self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:203:9
+  --> tests/ui/recursive_format_impl.rs:202:9
    |
 LL |         write!(f, "{}", *self)
    |         ^^^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |         write!(f, "{}", *self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:220:9
+  --> tests/ui/recursive_format_impl.rs:219:9
    |
 LL |         write!(f, "{}", **&&*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +72,7 @@ LL |         write!(f, "{}", **&&*self)
    = note: this error originates in the macro `write` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: using `self` as `Display` in `impl Display` will cause infinite recursion
-  --> tests/ui/recursive_format_impl.rs:237:9
+  --> tests/ui/recursive_format_impl.rs:236:9
    |
 LL |         write!(f, "{}", &&**&&*self)
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/redundant_allocation.rs b/src/tools/clippy/tests/ui/redundant_allocation.rs
index e70f8e71fae8..0562f7dcc761 100644
--- a/src/tools/clippy/tests/ui/redundant_allocation.rs
+++ b/src/tools/clippy/tests/ui/redundant_allocation.rs
@@ -14,24 +14,21 @@ mod outer_box {
     use std::sync::Arc;
 
     pub fn box_test6<T>(foo: Box<Rc<T>>) {}
-    //~^ ERROR: usage of `Box<Rc<T>>`
-    //~| NOTE: `Rc<T>` is already on the heap, `Box<Rc<T>>` makes an extra allocation
+    //~^ redundant_allocation
 
     pub fn box_test7<T>(foo: Box<Arc<T>>) {}
-    //~^ ERROR: usage of `Box<Arc<T>>`
-    //~| NOTE: `Arc<T>` is already on the heap, `Box<Arc<T>>` makes an extra allocation
+    //~^ redundant_allocation
 
     pub fn box_test8() -> Box<Rc<SubT<usize>>> {
-        //~^ ERROR: usage of `Box<Rc<SubT<usize>>>`
-        //~| NOTE: `Rc<SubT<usize>>` is already on the heap, `Box<Rc<SubT<usize>>>` makes an e
+        //~^ redundant_allocation
+
         unimplemented!();
     }
 
     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
-        //~^ ERROR: usage of `Box<Arc<T>>`
-        //~| NOTE: `Arc<T>` is already on the heap, `Box<Arc<T>>` makes an extra allocation
-        //~| ERROR: usage of `Box<Arc<SubT<T>>>`
-        //~| NOTE: `Arc<SubT<T>>` is already on the heap, `Box<Arc<SubT<T>>>` makes an extra a
+        //~^ redundant_allocation
+        //~| redundant_allocation
+
         unimplemented!();
     }
 }
@@ -43,24 +40,21 @@ mod outer_rc {
     use std::sync::Arc;
 
     pub fn rc_test5(a: Rc<Box<bool>>) {}
-    //~^ ERROR: usage of `Rc<Box<bool>>`
-    //~| NOTE: `Box<bool>` is already on the heap, `Rc<Box<bool>>` makes an extra allocati
+    //~^ redundant_allocation
 
     pub fn rc_test7(a: Rc<Arc<bool>>) {}
-    //~^ ERROR: usage of `Rc<Arc<bool>>`
-    //~| NOTE: `Arc<bool>` is already on the heap, `Rc<Arc<bool>>` makes an extra allocati
+    //~^ redundant_allocation
 
     pub fn rc_test8() -> Rc<Box<SubT<usize>>> {
-        //~^ ERROR: usage of `Rc<Box<SubT<usize>>>`
-        //~| NOTE: `Box<SubT<usize>>` is already on the heap, `Rc<Box<SubT<usize>>>` makes an
+        //~^ redundant_allocation
+
         unimplemented!();
     }
 
     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
-        //~^ ERROR: usage of `Rc<Arc<T>>`
-        //~| NOTE: `Arc<T>` is already on the heap, `Rc<Arc<T>>` makes an extra allocation
-        //~| ERROR: usage of `Rc<Arc<SubT<T>>>`
-        //~| NOTE: `Arc<SubT<T>>` is already on the heap, `Rc<Arc<SubT<T>>>` makes an extra al
+        //~^ redundant_allocation
+        //~| redundant_allocation
+
         unimplemented!();
     }
 }
@@ -72,24 +66,21 @@ mod outer_arc {
     use std::sync::Arc;
 
     pub fn arc_test5(a: Arc<Box<bool>>) {}
-    //~^ ERROR: usage of `Arc<Box<bool>>`
-    //~| NOTE: `Box<bool>` is already on the heap, `Arc<Box<bool>>` makes an extra allocat
+    //~^ redundant_allocation
 
     pub fn arc_test6(a: Arc<Rc<bool>>) {}
-    //~^ ERROR: usage of `Arc<Rc<bool>>`
-    //~| NOTE: `Rc<bool>` is already on the heap, `Arc<Rc<bool>>` makes an extra allocatio
+    //~^ redundant_allocation
 
     pub fn arc_test8() -> Arc<Box<SubT<usize>>> {
-        //~^ ERROR: usage of `Arc<Box<SubT<usize>>>`
-        //~| NOTE: `Box<SubT<usize>>` is already on the heap, `Arc<Box<SubT<usize>>>` makes an
+        //~^ redundant_allocation
+
         unimplemented!();
     }
 
     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
-        //~^ ERROR: usage of `Arc<Rc<T>>`
-        //~| NOTE: `Rc<T>` is already on the heap, `Arc<Rc<T>>` makes an extra allocation
-        //~| ERROR: usage of `Arc<Rc<SubT<T>>>`
-        //~| NOTE: `Rc<SubT<T>>` is already on the heap, `Arc<Rc<SubT<T>>>` makes an extra all
+        //~^ redundant_allocation
+        //~| redundant_allocation
+
         unimplemented!();
     }
 }
@@ -112,8 +103,7 @@ mod box_dyn {
     pub fn test_rc(_: Rc<Box<dyn T>>) {}
     pub fn test_arc(_: Arc<Box<dyn T>>) {}
     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
-    //~^ ERROR: usage of `Rc<Box<Box<dyn T>>>`
-    //~| NOTE: `Box<Box<dyn T>>` is already on the heap, `Rc<Box<Box<dyn T>>>` makes an ex
+    //~^ redundant_allocation
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/8604
@@ -146,17 +136,16 @@ mod box_fat_ptr {
     pub fn test_box_custom(_: Box<Box<DynSized>>) {}
 
     pub fn test_rc_box_str(_: Rc<Box<Box<str>>>) {}
-    //~^ ERROR: usage of `Rc<Box<Box<str>>>`
-    //~| NOTE: `Box<Box<str>>` is already on the heap, `Rc<Box<Box<str>>>` makes an extra
+    //~^ redundant_allocation
+
     pub fn test_rc_box_slice(_: Rc<Box<Box<[usize]>>>) {}
-    //~^ ERROR: usage of `Rc<Box<Box<[usize]>>>`
-    //~| NOTE: `Box<Box<[usize]>>` is already on the heap, `Rc<Box<Box<[usize]>>>` makes a
+    //~^ redundant_allocation
+
     pub fn test_rc_box_path(_: Rc<Box<Box<Path>>>) {}
-    //~^ ERROR: usage of `Rc<Box<Box<Path>>>`
-    //~| NOTE: `Box<Box<Path>>` is already on the heap, `Rc<Box<Box<Path>>>` makes an extr
+    //~^ redundant_allocation
+
     pub fn test_rc_box_custom(_: Rc<Box<Box<DynSized>>>) {}
-    //~^ ERROR: usage of `Rc<Box<Box<DynSized>>>`
-    //~| NOTE: `Box<Box<DynSized>>` is already on the heap, `Rc<Box<Box<DynSized>>>` makes
+    //~^ redundant_allocation
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/11417
diff --git a/src/tools/clippy/tests/ui/redundant_allocation.stderr b/src/tools/clippy/tests/ui/redundant_allocation.stderr
index 8a043013e07a..44d30f95d7bc 100644
--- a/src/tools/clippy/tests/ui/redundant_allocation.stderr
+++ b/src/tools/clippy/tests/ui/redundant_allocation.stderr
@@ -10,7 +10,7 @@ LL |     pub fn box_test6<T>(foo: Box<Rc<T>>) {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_allocation)]`
 
 error: usage of `Box<Arc<T>>`
-  --> tests/ui/redundant_allocation.rs:20:30
+  --> tests/ui/redundant_allocation.rs:19:30
    |
 LL |     pub fn box_test7<T>(foo: Box<Arc<T>>) {}
    |                              ^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     pub fn box_test7<T>(foo: Box<Arc<T>>) {}
    = help: consider using just `Box<T>` or `Arc<T>`
 
 error: usage of `Box<Rc<SubT<usize>>>`
-  --> tests/ui/redundant_allocation.rs:24:27
+  --> tests/ui/redundant_allocation.rs:22:27
    |
 LL |     pub fn box_test8() -> Box<Rc<SubT<usize>>> {
    |                           ^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     pub fn box_test8() -> Box<Rc<SubT<usize>>> {
    = help: consider using just `Box<SubT<usize>>` or `Rc<SubT<usize>>`
 
 error: usage of `Box<Arc<T>>`
-  --> tests/ui/redundant_allocation.rs:30:30
+  --> tests/ui/redundant_allocation.rs:28:30
    |
 LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    |                              ^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    = help: consider using just `Box<T>` or `Arc<T>`
 
 error: usage of `Box<Arc<SubT<T>>>`
-  --> tests/ui/redundant_allocation.rs:30:46
+  --> tests/ui/redundant_allocation.rs:28:46
    |
 LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    |                                              ^^^^^^^^^^^^^^^^^
@@ -46,7 +46,7 @@ LL |     pub fn box_test9<T>(foo: Box<Arc<T>>) -> Box<Arc<SubT<T>>> {
    = help: consider using just `Box<SubT<T>>` or `Arc<SubT<T>>`
 
 error: usage of `Rc<Box<bool>>`
-  --> tests/ui/redundant_allocation.rs:45:24
+  --> tests/ui/redundant_allocation.rs:42:24
    |
 LL |     pub fn rc_test5(a: Rc<Box<bool>>) {}
    |                        ^^^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     pub fn rc_test5(a: Rc<Box<bool>>) {}
    = help: consider using just `Rc<bool>` or `Box<bool>`
 
 error: usage of `Rc<Arc<bool>>`
-  --> tests/ui/redundant_allocation.rs:49:24
+  --> tests/ui/redundant_allocation.rs:45:24
    |
 LL |     pub fn rc_test7(a: Rc<Arc<bool>>) {}
    |                        ^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL |     pub fn rc_test7(a: Rc<Arc<bool>>) {}
    = help: consider using just `Rc<bool>` or `Arc<bool>`
 
 error: usage of `Rc<Box<SubT<usize>>>`
-  --> tests/ui/redundant_allocation.rs:53:26
+  --> tests/ui/redundant_allocation.rs:48:26
    |
 LL |     pub fn rc_test8() -> Rc<Box<SubT<usize>>> {
    |                          ^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     pub fn rc_test8() -> Rc<Box<SubT<usize>>> {
    = help: consider using just `Rc<SubT<usize>>` or `Box<SubT<usize>>`
 
 error: usage of `Rc<Arc<T>>`
-  --> tests/ui/redundant_allocation.rs:59:29
+  --> tests/ui/redundant_allocation.rs:54:29
    |
 LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    |                             ^^^^^^^^^^
@@ -82,7 +82,7 @@ LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    = help: consider using just `Rc<T>` or `Arc<T>`
 
 error: usage of `Rc<Arc<SubT<T>>>`
-  --> tests/ui/redundant_allocation.rs:59:44
+  --> tests/ui/redundant_allocation.rs:54:44
    |
 LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    |                                            ^^^^^^^^^^^^^^^^
@@ -91,7 +91,7 @@ LL |     pub fn rc_test9<T>(foo: Rc<Arc<T>>) -> Rc<Arc<SubT<T>>> {
    = help: consider using just `Rc<SubT<T>>` or `Arc<SubT<T>>`
 
 error: usage of `Arc<Box<bool>>`
-  --> tests/ui/redundant_allocation.rs:74:25
+  --> tests/ui/redundant_allocation.rs:68:25
    |
 LL |     pub fn arc_test5(a: Arc<Box<bool>>) {}
    |                         ^^^^^^^^^^^^^^
@@ -100,7 +100,7 @@ LL |     pub fn arc_test5(a: Arc<Box<bool>>) {}
    = help: consider using just `Arc<bool>` or `Box<bool>`
 
 error: usage of `Arc<Rc<bool>>`
-  --> tests/ui/redundant_allocation.rs:78:25
+  --> tests/ui/redundant_allocation.rs:71:25
    |
 LL |     pub fn arc_test6(a: Arc<Rc<bool>>) {}
    |                         ^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL |     pub fn arc_test6(a: Arc<Rc<bool>>) {}
    = help: consider using just `Arc<bool>` or `Rc<bool>`
 
 error: usage of `Arc<Box<SubT<usize>>>`
-  --> tests/ui/redundant_allocation.rs:82:27
+  --> tests/ui/redundant_allocation.rs:74:27
    |
 LL |     pub fn arc_test8() -> Arc<Box<SubT<usize>>> {
    |                           ^^^^^^^^^^^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL |     pub fn arc_test8() -> Arc<Box<SubT<usize>>> {
    = help: consider using just `Arc<SubT<usize>>` or `Box<SubT<usize>>`
 
 error: usage of `Arc<Rc<T>>`
-  --> tests/ui/redundant_allocation.rs:88:30
+  --> tests/ui/redundant_allocation.rs:80:30
    |
 LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    |                              ^^^^^^^^^^
@@ -127,7 +127,7 @@ LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    = help: consider using just `Arc<T>` or `Rc<T>`
 
 error: usage of `Arc<Rc<SubT<T>>>`
-  --> tests/ui/redundant_allocation.rs:88:45
+  --> tests/ui/redundant_allocation.rs:80:45
    |
 LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    |                                             ^^^^^^^^^^^^^^^^
@@ -136,7 +136,7 @@ LL |     pub fn arc_test9<T>(foo: Arc<Rc<T>>) -> Arc<Rc<SubT<T>>> {
    = help: consider using just `Arc<SubT<T>>` or `Rc<SubT<T>>`
 
 error: usage of `Rc<Box<Box<dyn T>>>`
-  --> tests/ui/redundant_allocation.rs:114:27
+  --> tests/ui/redundant_allocation.rs:105:27
    |
 LL |     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
    |                           ^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL |     pub fn test_rc_box(_: Rc<Box<Box<dyn T>>>) {}
    = help: consider using just `Rc<Box<dyn T>>` or `Box<Box<dyn T>>`
 
 error: usage of `Rc<Box<Box<str>>>`
-  --> tests/ui/redundant_allocation.rs:148:31
+  --> tests/ui/redundant_allocation.rs:138:31
    |
 LL |     pub fn test_rc_box_str(_: Rc<Box<Box<str>>>) {}
    |                               ^^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |     pub fn test_rc_box_str(_: Rc<Box<Box<str>>>) {}
    = help: consider using just `Rc<Box<str>>` or `Box<Box<str>>`
 
 error: usage of `Rc<Box<Box<[usize]>>>`
-  --> tests/ui/redundant_allocation.rs:151:33
+  --> tests/ui/redundant_allocation.rs:141:33
    |
 LL |     pub fn test_rc_box_slice(_: Rc<Box<Box<[usize]>>>) {}
    |                                 ^^^^^^^^^^^^^^^^^^^^^
@@ -163,7 +163,7 @@ LL |     pub fn test_rc_box_slice(_: Rc<Box<Box<[usize]>>>) {}
    = help: consider using just `Rc<Box<[usize]>>` or `Box<Box<[usize]>>`
 
 error: usage of `Rc<Box<Box<Path>>>`
-  --> tests/ui/redundant_allocation.rs:154:32
+  --> tests/ui/redundant_allocation.rs:144:32
    |
 LL |     pub fn test_rc_box_path(_: Rc<Box<Box<Path>>>) {}
    |                                ^^^^^^^^^^^^^^^^^^
@@ -172,7 +172,7 @@ LL |     pub fn test_rc_box_path(_: Rc<Box<Box<Path>>>) {}
    = help: consider using just `Rc<Box<Path>>` or `Box<Box<Path>>`
 
 error: usage of `Rc<Box<Box<DynSized>>>`
-  --> tests/ui/redundant_allocation.rs:157:34
+  --> tests/ui/redundant_allocation.rs:147:34
    |
 LL |     pub fn test_rc_box_custom(_: Rc<Box<Box<DynSized>>>) {}
    |                                  ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/redundant_allocation_fixable.fixed b/src/tools/clippy/tests/ui/redundant_allocation_fixable.fixed
index 61c989c67a1a..7773ba11f973 100644
--- a/src/tools/clippy/tests/ui/redundant_allocation_fixable.fixed
+++ b/src/tools/clippy/tests/ui/redundant_allocation_fixable.fixed
@@ -21,14 +21,18 @@ mod outer_box {
     use std::sync::Arc;
 
     pub fn box_test1<T>(foo: &T) {}
+    //~^ redundant_allocation
 
     pub fn box_test2(foo: &MyStruct) {}
+    //~^ redundant_allocation
 
     pub fn box_test3(foo: &MyEnum) {}
+    //~^ redundant_allocation
 
     pub fn box_test4_neg(foo: Box<SubT<&usize>>) {}
 
     pub fn box_test5<T>(foo: Box<T>) {}
+    //~^ redundant_allocation
 }
 
 mod outer_rc {
@@ -38,14 +42,18 @@ mod outer_rc {
     use std::sync::Arc;
 
     pub fn rc_test1<T>(foo: &T) {}
+    //~^ redundant_allocation
 
     pub fn rc_test2(foo: &MyStruct) {}
+    //~^ redundant_allocation
 
     pub fn rc_test3(foo: &MyEnum) {}
+    //~^ redundant_allocation
 
     pub fn rc_test4_neg(foo: Rc<SubT<&usize>>) {}
 
     pub fn rc_test6(a: Rc<bool>) {}
+    //~^ redundant_allocation
 }
 
 mod outer_arc {
@@ -55,14 +63,18 @@ mod outer_arc {
     use std::sync::Arc;
 
     pub fn arc_test1<T>(foo: &T) {}
+    //~^ redundant_allocation
 
     pub fn arc_test2(foo: &MyStruct) {}
+    //~^ redundant_allocation
 
     pub fn arc_test3(foo: &MyEnum) {}
+    //~^ redundant_allocation
 
     pub fn arc_test4_neg(foo: Arc<SubT<&usize>>) {}
 
     pub fn arc_test7(a: Arc<bool>) {}
+    //~^ redundant_allocation
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/redundant_allocation_fixable.rs b/src/tools/clippy/tests/ui/redundant_allocation_fixable.rs
index 3ad1e9a978df..fb86ed2b3cfd 100644
--- a/src/tools/clippy/tests/ui/redundant_allocation_fixable.rs
+++ b/src/tools/clippy/tests/ui/redundant_allocation_fixable.rs
@@ -21,14 +21,18 @@ mod outer_box {
     use std::sync::Arc;
 
     pub fn box_test1<T>(foo: Box<&T>) {}
+    //~^ redundant_allocation
 
     pub fn box_test2(foo: Box<&MyStruct>) {}
+    //~^ redundant_allocation
 
     pub fn box_test3(foo: Box<&MyEnum>) {}
+    //~^ redundant_allocation
 
     pub fn box_test4_neg(foo: Box<SubT<&usize>>) {}
 
     pub fn box_test5<T>(foo: Box<Box<T>>) {}
+    //~^ redundant_allocation
 }
 
 mod outer_rc {
@@ -38,14 +42,18 @@ mod outer_rc {
     use std::sync::Arc;
 
     pub fn rc_test1<T>(foo: Rc<&T>) {}
+    //~^ redundant_allocation
 
     pub fn rc_test2(foo: Rc<&MyStruct>) {}
+    //~^ redundant_allocation
 
     pub fn rc_test3(foo: Rc<&MyEnum>) {}
+    //~^ redundant_allocation
 
     pub fn rc_test4_neg(foo: Rc<SubT<&usize>>) {}
 
     pub fn rc_test6(a: Rc<Rc<bool>>) {}
+    //~^ redundant_allocation
 }
 
 mod outer_arc {
@@ -55,14 +63,18 @@ mod outer_arc {
     use std::sync::Arc;
 
     pub fn arc_test1<T>(foo: Arc<&T>) {}
+    //~^ redundant_allocation
 
     pub fn arc_test2(foo: Arc<&MyStruct>) {}
+    //~^ redundant_allocation
 
     pub fn arc_test3(foo: Arc<&MyEnum>) {}
+    //~^ redundant_allocation
 
     pub fn arc_test4_neg(foo: Arc<SubT<&usize>>) {}
 
     pub fn arc_test7(a: Arc<Arc<bool>>) {}
+    //~^ redundant_allocation
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/redundant_allocation_fixable.stderr b/src/tools/clippy/tests/ui/redundant_allocation_fixable.stderr
index 34a1a21bdadc..ed8282cc82ce 100644
--- a/src/tools/clippy/tests/ui/redundant_allocation_fixable.stderr
+++ b/src/tools/clippy/tests/ui/redundant_allocation_fixable.stderr
@@ -9,7 +9,7 @@ LL |     pub fn box_test1<T>(foo: Box<&T>) {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_allocation)]`
 
 error: usage of `Box<&MyStruct>`
-  --> tests/ui/redundant_allocation_fixable.rs:25:27
+  --> tests/ui/redundant_allocation_fixable.rs:26:27
    |
 LL |     pub fn box_test2(foo: Box<&MyStruct>) {}
    |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
@@ -17,7 +17,7 @@ LL |     pub fn box_test2(foo: Box<&MyStruct>) {}
    = note: `&MyStruct` is already a pointer, `Box<&MyStruct>` allocates a pointer on the heap
 
 error: usage of `Box<&MyEnum>`
-  --> tests/ui/redundant_allocation_fixable.rs:27:27
+  --> tests/ui/redundant_allocation_fixable.rs:29:27
    |
 LL |     pub fn box_test3(foo: Box<&MyEnum>) {}
    |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
@@ -25,7 +25,7 @@ LL |     pub fn box_test3(foo: Box<&MyEnum>) {}
    = note: `&MyEnum` is already a pointer, `Box<&MyEnum>` allocates a pointer on the heap
 
 error: usage of `Box<Box<T>>`
-  --> tests/ui/redundant_allocation_fixable.rs:31:30
+  --> tests/ui/redundant_allocation_fixable.rs:34:30
    |
 LL |     pub fn box_test5<T>(foo: Box<Box<T>>) {}
    |                              ^^^^^^^^^^^ help: try: `Box<T>`
@@ -33,7 +33,7 @@ LL |     pub fn box_test5<T>(foo: Box<Box<T>>) {}
    = note: `Box<T>` is already on the heap, `Box<Box<T>>` makes an extra allocation
 
 error: usage of `Rc<&T>`
-  --> tests/ui/redundant_allocation_fixable.rs:40:29
+  --> tests/ui/redundant_allocation_fixable.rs:44:29
    |
 LL |     pub fn rc_test1<T>(foo: Rc<&T>) {}
    |                             ^^^^^^ help: try: `&T`
@@ -41,7 +41,7 @@ LL |     pub fn rc_test1<T>(foo: Rc<&T>) {}
    = note: `&T` is already a pointer, `Rc<&T>` allocates a pointer on the heap
 
 error: usage of `Rc<&MyStruct>`
-  --> tests/ui/redundant_allocation_fixable.rs:42:26
+  --> tests/ui/redundant_allocation_fixable.rs:47:26
    |
 LL |     pub fn rc_test2(foo: Rc<&MyStruct>) {}
    |                          ^^^^^^^^^^^^^ help: try: `&MyStruct`
@@ -49,7 +49,7 @@ LL |     pub fn rc_test2(foo: Rc<&MyStruct>) {}
    = note: `&MyStruct` is already a pointer, `Rc<&MyStruct>` allocates a pointer on the heap
 
 error: usage of `Rc<&MyEnum>`
-  --> tests/ui/redundant_allocation_fixable.rs:44:26
+  --> tests/ui/redundant_allocation_fixable.rs:50:26
    |
 LL |     pub fn rc_test3(foo: Rc<&MyEnum>) {}
    |                          ^^^^^^^^^^^ help: try: `&MyEnum`
@@ -57,7 +57,7 @@ LL |     pub fn rc_test3(foo: Rc<&MyEnum>) {}
    = note: `&MyEnum` is already a pointer, `Rc<&MyEnum>` allocates a pointer on the heap
 
 error: usage of `Rc<Rc<bool>>`
-  --> tests/ui/redundant_allocation_fixable.rs:48:24
+  --> tests/ui/redundant_allocation_fixable.rs:55:24
    |
 LL |     pub fn rc_test6(a: Rc<Rc<bool>>) {}
    |                        ^^^^^^^^^^^^ help: try: `Rc<bool>`
@@ -65,7 +65,7 @@ LL |     pub fn rc_test6(a: Rc<Rc<bool>>) {}
    = note: `Rc<bool>` is already on the heap, `Rc<Rc<bool>>` makes an extra allocation
 
 error: usage of `Arc<&T>`
-  --> tests/ui/redundant_allocation_fixable.rs:57:30
+  --> tests/ui/redundant_allocation_fixable.rs:65:30
    |
 LL |     pub fn arc_test1<T>(foo: Arc<&T>) {}
    |                              ^^^^^^^ help: try: `&T`
@@ -73,7 +73,7 @@ LL |     pub fn arc_test1<T>(foo: Arc<&T>) {}
    = note: `&T` is already a pointer, `Arc<&T>` allocates a pointer on the heap
 
 error: usage of `Arc<&MyStruct>`
-  --> tests/ui/redundant_allocation_fixable.rs:59:27
+  --> tests/ui/redundant_allocation_fixable.rs:68:27
    |
 LL |     pub fn arc_test2(foo: Arc<&MyStruct>) {}
    |                           ^^^^^^^^^^^^^^ help: try: `&MyStruct`
@@ -81,7 +81,7 @@ LL |     pub fn arc_test2(foo: Arc<&MyStruct>) {}
    = note: `&MyStruct` is already a pointer, `Arc<&MyStruct>` allocates a pointer on the heap
 
 error: usage of `Arc<&MyEnum>`
-  --> tests/ui/redundant_allocation_fixable.rs:61:27
+  --> tests/ui/redundant_allocation_fixable.rs:71:27
    |
 LL |     pub fn arc_test3(foo: Arc<&MyEnum>) {}
    |                           ^^^^^^^^^^^^ help: try: `&MyEnum`
@@ -89,7 +89,7 @@ LL |     pub fn arc_test3(foo: Arc<&MyEnum>) {}
    = note: `&MyEnum` is already a pointer, `Arc<&MyEnum>` allocates a pointer on the heap
 
 error: usage of `Arc<Arc<bool>>`
-  --> tests/ui/redundant_allocation_fixable.rs:65:25
+  --> tests/ui/redundant_allocation_fixable.rs:76:25
    |
 LL |     pub fn arc_test7(a: Arc<Arc<bool>>) {}
    |                         ^^^^^^^^^^^^^^ help: try: `Arc<bool>`
diff --git a/src/tools/clippy/tests/ui/redundant_as_str.fixed b/src/tools/clippy/tests/ui/redundant_as_str.fixed
index 708a1cc91506..4c5f7893d42e 100644
--- a/src/tools/clippy/tests/ui/redundant_as_str.fixed
+++ b/src/tools/clippy/tests/ui/redundant_as_str.fixed
@@ -6,7 +6,9 @@ fn main() {
 
     // These methods are redundant and the `as_str` can be removed
     let _redundant = string.as_bytes();
+    //~^ redundant_as_str
     let _redundant = string.is_empty();
+    //~^ redundant_as_str
 
     // These methods don't use `as_str` when they are redundant
     let _no_as_str = string.as_bytes();
diff --git a/src/tools/clippy/tests/ui/redundant_as_str.rs b/src/tools/clippy/tests/ui/redundant_as_str.rs
index 257af591ceff..e3baec754595 100644
--- a/src/tools/clippy/tests/ui/redundant_as_str.rs
+++ b/src/tools/clippy/tests/ui/redundant_as_str.rs
@@ -6,7 +6,9 @@ fn main() {
 
     // These methods are redundant and the `as_str` can be removed
     let _redundant = string.as_str().as_bytes();
+    //~^ redundant_as_str
     let _redundant = string.as_str().is_empty();
+    //~^ redundant_as_str
 
     // These methods don't use `as_str` when they are redundant
     let _no_as_str = string.as_bytes();
diff --git a/src/tools/clippy/tests/ui/redundant_as_str.stderr b/src/tools/clippy/tests/ui/redundant_as_str.stderr
index f5379d701db8..fc99c008220e 100644
--- a/src/tools/clippy/tests/ui/redundant_as_str.stderr
+++ b/src/tools/clippy/tests/ui/redundant_as_str.stderr
@@ -8,7 +8,7 @@ LL |     let _redundant = string.as_str().as_bytes();
    = help: to override `-D warnings` add `#[allow(clippy::redundant_as_str)]`
 
 error: this `as_str` is redundant and can be removed as the method immediately following exists on `String` too
-  --> tests/ui/redundant_as_str.rs:9:29
+  --> tests/ui/redundant_as_str.rs:10:29
    |
 LL |     let _redundant = string.as_str().is_empty();
    |                             ^^^^^^^^^^^^^^^^^ help: try: `is_empty`
diff --git a/src/tools/clippy/tests/ui/redundant_async_block.fixed b/src/tools/clippy/tests/ui/redundant_async_block.fixed
index a1875c1c06e1..2f14f27e7056 100644
--- a/src/tools/clippy/tests/ui/redundant_async_block.fixed
+++ b/src/tools/clippy/tests/ui/redundant_async_block.fixed
@@ -11,6 +11,7 @@ async fn func2() -> String {
     let s = String::from("some string");
     let f = async { (*s).to_owned() };
     let x = f;
+    //~^ redundant_async_block
     x.await
 }
 
@@ -18,13 +19,16 @@ fn main() {
     let fut1 = async { 17 };
     // Lint
     let fut2 = fut1;
+    //~^ redundant_async_block
 
     let fut1 = async { 25 };
     // Lint
     let fut2 = fut1;
+    //~^ redundant_async_block
 
     // Lint
     let fut = async { 42 };
+    //~^ redundant_async_block
 
     // Do not lint: not a single expression
     let fut = async {
@@ -41,6 +45,7 @@ fn capture_local() -> impl Future<Output = i32> {
     let fut = async { 17 };
     // Lint
     fut
+    //~^ redundant_async_block
 }
 
 fn capture_local_closure(s: &str) -> impl Future<Output = &str> {
@@ -54,11 +59,13 @@ fn capture_arg(s: &str) -> impl Future<Output = &str> {
     let fut = async move { s };
     // Lint
     fut
+    //~^ redundant_async_block
 }
 
 fn capture_future_arg<T>(f: impl Future<Output = T>) -> impl Future<Output = T> {
     // Lint
     f
+    //~^ redundant_async_block
 }
 
 fn capture_func_result<FN, F, T>(f: FN) -> impl Future<Output = T>
@@ -82,6 +89,7 @@ where
 {
     // Lint
     async { f().await + 1 }
+    //~^ redundant_async_block
 }
 
 #[derive(Debug, Clone)]
@@ -145,6 +153,7 @@ fn all_from_macro() -> impl Future<Output = u32> {
         () => {
             // Lint
             async { 42 }
+            //~^ redundant_async_block
         };
     }
     mac!()
@@ -165,6 +174,7 @@ fn safe_parts_from_macro() -> impl Future<Output = u32> {
         ($e: expr) => {
             // Lint
             async { $e }
+            //~^ redundant_async_block
         };
     }
     mac!(42)
diff --git a/src/tools/clippy/tests/ui/redundant_async_block.rs b/src/tools/clippy/tests/ui/redundant_async_block.rs
index bb43403a043e..f5fe26b19cc8 100644
--- a/src/tools/clippy/tests/ui/redundant_async_block.rs
+++ b/src/tools/clippy/tests/ui/redundant_async_block.rs
@@ -11,6 +11,7 @@ async fn func2() -> String {
     let s = String::from("some string");
     let f = async { (*s).to_owned() };
     let x = async { f.await };
+    //~^ redundant_async_block
     x.await
 }
 
@@ -18,13 +19,16 @@ fn main() {
     let fut1 = async { 17 };
     // Lint
     let fut2 = async { fut1.await };
+    //~^ redundant_async_block
 
     let fut1 = async { 25 };
     // Lint
     let fut2 = async move { fut1.await };
+    //~^ redundant_async_block
 
     // Lint
     let fut = async { async { 42 }.await };
+    //~^ redundant_async_block
 
     // Do not lint: not a single expression
     let fut = async {
@@ -41,6 +45,7 @@ fn capture_local() -> impl Future<Output = i32> {
     let fut = async { 17 };
     // Lint
     async move { fut.await }
+    //~^ redundant_async_block
 }
 
 fn capture_local_closure(s: &str) -> impl Future<Output = &str> {
@@ -54,11 +59,13 @@ fn capture_arg(s: &str) -> impl Future<Output = &str> {
     let fut = async move { s };
     // Lint
     async move { fut.await }
+    //~^ redundant_async_block
 }
 
 fn capture_future_arg<T>(f: impl Future<Output = T>) -> impl Future<Output = T> {
     // Lint
     async { f.await }
+    //~^ redundant_async_block
 }
 
 fn capture_func_result<FN, F, T>(f: FN) -> impl Future<Output = T>
@@ -82,6 +89,7 @@ where
 {
     // Lint
     async { async { f().await + 1 }.await }
+    //~^ redundant_async_block
 }
 
 #[derive(Debug, Clone)]
@@ -145,6 +153,7 @@ fn all_from_macro() -> impl Future<Output = u32> {
         () => {
             // Lint
             async { async { 42 }.await }
+            //~^ redundant_async_block
         };
     }
     mac!()
@@ -165,6 +174,7 @@ fn safe_parts_from_macro() -> impl Future<Output = u32> {
         ($e: expr) => {
             // Lint
             async { async { $e }.await }
+            //~^ redundant_async_block
         };
     }
     mac!(42)
diff --git a/src/tools/clippy/tests/ui/redundant_async_block.stderr b/src/tools/clippy/tests/ui/redundant_async_block.stderr
index c6a5e2f28ada..386f00a25c2f 100644
--- a/src/tools/clippy/tests/ui/redundant_async_block.stderr
+++ b/src/tools/clippy/tests/ui/redundant_async_block.stderr
@@ -8,31 +8,25 @@ LL |     let x = async { f.await };
    = help: to override `-D warnings` add `#[allow(clippy::redundant_async_block)]`
 
 error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:20:16
+  --> tests/ui/redundant_async_block.rs:21:16
    |
 LL |     let fut2 = async { fut1.await };
    |                ^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
 
 error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:24:16
+  --> tests/ui/redundant_async_block.rs:26:16
    |
 LL |     let fut2 = async move { fut1.await };
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut1`
 
 error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:27:15
+  --> tests/ui/redundant_async_block.rs:30:15
    |
 LL |     let fut = async { async { 42 }.await };
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { 42 }`
 
 error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:43:5
-   |
-LL |     async move { fut.await }
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut`
-
-error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:56:5
+  --> tests/ui/redundant_async_block.rs:47:5
    |
 LL |     async move { fut.await }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut`
@@ -40,17 +34,23 @@ LL |     async move { fut.await }
 error: this async expression only awaits a single future
   --> tests/ui/redundant_async_block.rs:61:5
    |
+LL |     async move { fut.await }
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `fut`
+
+error: this async expression only awaits a single future
+  --> tests/ui/redundant_async_block.rs:67:5
+   |
 LL |     async { f.await }
    |     ^^^^^^^^^^^^^^^^^ help: you can reduce it to: `f`
 
 error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:84:5
+  --> tests/ui/redundant_async_block.rs:91:5
    |
 LL |     async { async { f().await + 1 }.await }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { f().await + 1 }`
 
 error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:147:13
+  --> tests/ui/redundant_async_block.rs:155:13
    |
 LL |             async { async { 42 }.await }
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { 42 }`
@@ -61,7 +61,7 @@ LL |     mac!()
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: this async expression only awaits a single future
-  --> tests/ui/redundant_async_block.rs:167:13
+  --> tests/ui/redundant_async_block.rs:176:13
    |
 LL |             async { async { $e }.await }
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can reduce it to: `async { $e }`
diff --git a/src/tools/clippy/tests/ui/redundant_at_rest_pattern.fixed b/src/tools/clippy/tests/ui/redundant_at_rest_pattern.fixed
index a7997637372e..908b9051b7ef 100644
--- a/src/tools/clippy/tests/ui/redundant_at_rest_pattern.fixed
+++ b/src/tools/clippy/tests/ui/redundant_at_rest_pattern.fixed
@@ -7,13 +7,19 @@ extern crate proc_macros;
 
 fn main() {
     if let a = [()] {}
+    //~^ redundant_at_rest_pattern
     if let ref a = [()] {}
+    //~^ redundant_at_rest_pattern
     if let mut a = [()] {}
+    //~^ redundant_at_rest_pattern
     if let ref mut a = [()] {}
+    //~^ redundant_at_rest_pattern
     let v = vec![()];
     if let a = &*v {}
+    //~^ redundant_at_rest_pattern
     let s = &[()];
     if let a = s {}
+    //~^ redundant_at_rest_pattern
     // Don't lint
     if let [..] = &*v {}
     if let [a] = &*v {}
diff --git a/src/tools/clippy/tests/ui/redundant_at_rest_pattern.rs b/src/tools/clippy/tests/ui/redundant_at_rest_pattern.rs
index f103d1f1a179..0f19459773a9 100644
--- a/src/tools/clippy/tests/ui/redundant_at_rest_pattern.rs
+++ b/src/tools/clippy/tests/ui/redundant_at_rest_pattern.rs
@@ -7,13 +7,19 @@ extern crate proc_macros;
 
 fn main() {
     if let [a @ ..] = [()] {}
+    //~^ redundant_at_rest_pattern
     if let [ref a @ ..] = [()] {}
+    //~^ redundant_at_rest_pattern
     if let [mut a @ ..] = [()] {}
+    //~^ redundant_at_rest_pattern
     if let [ref mut a @ ..] = [()] {}
+    //~^ redundant_at_rest_pattern
     let v = vec![()];
     if let [a @ ..] = &*v {}
+    //~^ redundant_at_rest_pattern
     let s = &[()];
     if let [a @ ..] = s {}
+    //~^ redundant_at_rest_pattern
     // Don't lint
     if let [..] = &*v {}
     if let [a] = &*v {}
diff --git a/src/tools/clippy/tests/ui/redundant_at_rest_pattern.stderr b/src/tools/clippy/tests/ui/redundant_at_rest_pattern.stderr
index 012ba550ca11..3a6f6cf6500a 100644
--- a/src/tools/clippy/tests/ui/redundant_at_rest_pattern.stderr
+++ b/src/tools/clippy/tests/ui/redundant_at_rest_pattern.stderr
@@ -8,31 +8,31 @@ LL |     if let [a @ ..] = [()] {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_at_rest_pattern)]`
 
 error: using a rest pattern to bind an entire slice to a local
-  --> tests/ui/redundant_at_rest_pattern.rs:10:12
+  --> tests/ui/redundant_at_rest_pattern.rs:11:12
    |
 LL |     if let [ref a @ ..] = [()] {}
    |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `ref a`
 
 error: using a rest pattern to bind an entire slice to a local
-  --> tests/ui/redundant_at_rest_pattern.rs:11:12
+  --> tests/ui/redundant_at_rest_pattern.rs:13:12
    |
 LL |     if let [mut a @ ..] = [()] {}
    |            ^^^^^^^^^^^^ help: this is better represented with just the binding: `mut a`
 
 error: using a rest pattern to bind an entire slice to a local
-  --> tests/ui/redundant_at_rest_pattern.rs:12:12
+  --> tests/ui/redundant_at_rest_pattern.rs:15:12
    |
 LL |     if let [ref mut a @ ..] = [()] {}
    |            ^^^^^^^^^^^^^^^^ help: this is better represented with just the binding: `ref mut a`
 
 error: using a rest pattern to bind an entire slice to a local
-  --> tests/ui/redundant_at_rest_pattern.rs:14:12
+  --> tests/ui/redundant_at_rest_pattern.rs:18:12
    |
 LL |     if let [a @ ..] = &*v {}
    |            ^^^^^^^^ help: this is better represented with just the binding: `a`
 
 error: using a rest pattern to bind an entire slice to a local
-  --> tests/ui/redundant_at_rest_pattern.rs:16:12
+  --> tests/ui/redundant_at_rest_pattern.rs:21:12
    |
 LL |     if let [a @ ..] = s {}
    |            ^^^^^^^^ help: this is better represented with just the binding: `a`
diff --git a/src/tools/clippy/tests/ui/redundant_clone.fixed b/src/tools/clippy/tests/ui/redundant_clone.fixed
index 1d04cca9b9ed..23c00b34a00a 100644
--- a/src/tools/clippy/tests/ui/redundant_clone.fixed
+++ b/src/tools/clippy/tests/ui/redundant_clone.fixed
@@ -13,23 +13,31 @@ use std::path::Path;
 
 fn main() {
     let _s = ["lorem", "ipsum"].join(" ");
+    //~^ redundant_clone
 
     let s = String::from("foo");
     let _s = s;
+    //~^ redundant_clone
 
     let s = String::from("foo");
     let _s = s;
+    //~^ redundant_clone
 
     let s = String::from("foo");
     let _s = s;
+    //~^ redundant_clone
 
     let _s = Path::new("/a/b/").join("c");
+    //~^ redundant_clone
 
     let _s = Path::new("/a/b/").join("c");
+    //~^ redundant_clone
 
     let _s = OsString::new();
+    //~^ redundant_clone
 
     let _s = OsString::new();
+    //~^ redundant_clone
 
     // Check that lint level works
     #[allow(clippy::redundant_clone)]
@@ -41,6 +49,7 @@ fn main() {
 
     let tup = (String::from("foo"),);
     let _t = tup.0;
+    //~^ redundant_clone
 
     let tup_ref = &(String::from("foo"),);
     let _s = tup_ref.0.clone(); // this `.clone()` cannot be removed
@@ -73,6 +82,7 @@ fn main() {
 struct Alpha;
 fn with_branch(a: Alpha, b: bool) -> (Alpha, Alpha) {
     if b { (a.clone(), a) } else { (Alpha, a) }
+    //~^ redundant_clone
 }
 
 fn cannot_double_move(a: Alpha) -> (Alpha, Alpha) {
@@ -130,7 +140,9 @@ fn borrower_propagation() {
     }
 
     let _s = s;
+    //~^ redundant_clone
     let _t = t;
+    //~^ redundant_clone
 
     #[derive(Clone)]
     struct Foo {
@@ -141,6 +153,7 @@ fn borrower_propagation() {
         let f = Foo { x: 123 };
         let _x = Some(f.x);
         let _f = f;
+        //~^ redundant_clone
     }
 
     {
@@ -153,6 +166,7 @@ fn borrower_propagation() {
 fn not_consumed() {
     let x = std::path::PathBuf::from("home");
     let y = x.join("matthias");
+    //~^ redundant_clone
     // join() creates a new owned PathBuf, does not take a &mut to x variable, thus the .clone() is
     // redundant. (It also does not consume the PathBuf)
 
@@ -207,6 +221,7 @@ fn clone_then_move_cloned() {
     let x = Alpha;
     // ok, data is moved while the clone is in use.
     foo(&x, move || {
+        //~^ redundant_clone
         let _ = x;
     });
 
diff --git a/src/tools/clippy/tests/ui/redundant_clone.rs b/src/tools/clippy/tests/ui/redundant_clone.rs
index 738744fec98f..f9fe8ba0236d 100644
--- a/src/tools/clippy/tests/ui/redundant_clone.rs
+++ b/src/tools/clippy/tests/ui/redundant_clone.rs
@@ -13,23 +13,31 @@ use std::path::Path;
 
 fn main() {
     let _s = ["lorem", "ipsum"].join(" ").to_string();
+    //~^ redundant_clone
 
     let s = String::from("foo");
     let _s = s.clone();
+    //~^ redundant_clone
 
     let s = String::from("foo");
     let _s = s.to_string();
+    //~^ redundant_clone
 
     let s = String::from("foo");
     let _s = s.to_owned();
+    //~^ redundant_clone
 
     let _s = Path::new("/a/b/").join("c").to_owned();
+    //~^ redundant_clone
 
     let _s = Path::new("/a/b/").join("c").to_path_buf();
+    //~^ redundant_clone
 
     let _s = OsString::new().to_owned();
+    //~^ redundant_clone
 
     let _s = OsString::new().to_os_string();
+    //~^ redundant_clone
 
     // Check that lint level works
     #[allow(clippy::redundant_clone)]
@@ -41,6 +49,7 @@ fn main() {
 
     let tup = (String::from("foo"),);
     let _t = tup.0.clone();
+    //~^ redundant_clone
 
     let tup_ref = &(String::from("foo"),);
     let _s = tup_ref.0.clone(); // this `.clone()` cannot be removed
@@ -73,6 +82,7 @@ fn main() {
 struct Alpha;
 fn with_branch(a: Alpha, b: bool) -> (Alpha, Alpha) {
     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
+    //~^ redundant_clone
 }
 
 fn cannot_double_move(a: Alpha) -> (Alpha, Alpha) {
@@ -130,7 +140,9 @@ fn borrower_propagation() {
     }
 
     let _s = s.clone();
+    //~^ redundant_clone
     let _t = t.clone();
+    //~^ redundant_clone
 
     #[derive(Clone)]
     struct Foo {
@@ -141,6 +153,7 @@ fn borrower_propagation() {
         let f = Foo { x: 123 };
         let _x = Some(f.x);
         let _f = f.clone();
+        //~^ redundant_clone
     }
 
     {
@@ -153,6 +166,7 @@ fn borrower_propagation() {
 fn not_consumed() {
     let x = std::path::PathBuf::from("home");
     let y = x.clone().join("matthias");
+    //~^ redundant_clone
     // join() creates a new owned PathBuf, does not take a &mut to x variable, thus the .clone() is
     // redundant. (It also does not consume the PathBuf)
 
@@ -207,6 +221,7 @@ fn clone_then_move_cloned() {
     let x = Alpha;
     // ok, data is moved while the clone is in use.
     foo(&x.clone(), move || {
+        //~^ redundant_clone
         let _ = x;
     });
 
diff --git a/src/tools/clippy/tests/ui/redundant_clone.stderr b/src/tools/clippy/tests/ui/redundant_clone.stderr
index 3c37288f5507..5be081f0f2f8 100644
--- a/src/tools/clippy/tests/ui/redundant_clone.stderr
+++ b/src/tools/clippy/tests/ui/redundant_clone.stderr
@@ -13,169 +13,169 @@ LL |     let _s = ["lorem", "ipsum"].join(" ").to_string();
    = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:18:15
+  --> tests/ui/redundant_clone.rs:19:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:18:14
+  --> tests/ui/redundant_clone.rs:19:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:21:15
+  --> tests/ui/redundant_clone.rs:23:15
    |
 LL |     let _s = s.to_string();
    |               ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:21:14
+  --> tests/ui/redundant_clone.rs:23:14
    |
 LL |     let _s = s.to_string();
    |              ^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:24:15
+  --> tests/ui/redundant_clone.rs:27:15
    |
 LL |     let _s = s.to_owned();
    |               ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:24:14
+  --> tests/ui/redundant_clone.rs:27:14
    |
 LL |     let _s = s.to_owned();
    |              ^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:26:42
+  --> tests/ui/redundant_clone.rs:30:42
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_owned();
    |                                          ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:26:14
+  --> tests/ui/redundant_clone.rs:30:14
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_owned();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:28:42
+  --> tests/ui/redundant_clone.rs:33:42
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
    |                                          ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:28:14
+  --> tests/ui/redundant_clone.rs:33:14
    |
 LL |     let _s = Path::new("/a/b/").join("c").to_path_buf();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:30:29
+  --> tests/ui/redundant_clone.rs:36:29
    |
 LL |     let _s = OsString::new().to_owned();
    |                             ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:30:14
+  --> tests/ui/redundant_clone.rs:36:14
    |
 LL |     let _s = OsString::new().to_owned();
    |              ^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:32:29
+  --> tests/ui/redundant_clone.rs:39:29
    |
 LL |     let _s = OsString::new().to_os_string();
    |                             ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:32:14
+  --> tests/ui/redundant_clone.rs:39:14
    |
 LL |     let _s = OsString::new().to_os_string();
    |              ^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:43:19
+  --> tests/ui/redundant_clone.rs:51:19
    |
 LL |     let _t = tup.0.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:43:14
+  --> tests/ui/redundant_clone.rs:51:14
    |
 LL |     let _t = tup.0.clone();
    |              ^^^^^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:75:25
+  --> tests/ui/redundant_clone.rs:84:25
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                         ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:75:24
+  --> tests/ui/redundant_clone.rs:84:24
    |
 LL |     if b { (a.clone(), a.clone()) } else { (Alpha, a) }
    |                        ^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:132:15
+  --> tests/ui/redundant_clone.rs:142:15
    |
 LL |     let _s = s.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:132:14
+  --> tests/ui/redundant_clone.rs:142:14
    |
 LL |     let _s = s.clone();
    |              ^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:133:15
+  --> tests/ui/redundant_clone.rs:144:15
    |
 LL |     let _t = t.clone();
    |               ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:133:14
+  --> tests/ui/redundant_clone.rs:144:14
    |
 LL |     let _t = t.clone();
    |              ^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:143:19
+  --> tests/ui/redundant_clone.rs:155:19
    |
 LL |         let _f = f.clone();
    |                   ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:143:18
+  --> tests/ui/redundant_clone.rs:155:18
    |
 LL |         let _f = f.clone();
    |                  ^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:155:14
+  --> tests/ui/redundant_clone.rs:168:14
    |
 LL |     let y = x.clone().join("matthias");
    |              ^^^^^^^^ help: remove this
    |
 note: cloned value is neither consumed nor mutated
-  --> tests/ui/redundant_clone.rs:155:13
+  --> tests/ui/redundant_clone.rs:168:13
    |
 LL |     let y = x.clone().join("matthias");
    |             ^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/redundant_clone.rs:209:11
+  --> tests/ui/redundant_clone.rs:223:11
    |
 LL |     foo(&x.clone(), move || {
    |           ^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/redundant_clone.rs:209:10
+  --> tests/ui/redundant_clone.rs:223:10
    |
 LL |     foo(&x.clone(), move || {
    |          ^
diff --git a/src/tools/clippy/tests/ui/redundant_closure_call_early.rs b/src/tools/clippy/tests/ui/redundant_closure_call_early.rs
index 6f9c9fd52224..722f7c03909f 100644
--- a/src/tools/clippy/tests/ui/redundant_closure_call_early.rs
+++ b/src/tools/clippy/tests/ui/redundant_closure_call_early.rs
@@ -7,12 +7,11 @@ fn main() {
 
     // lint here
     let mut k = (|m| m + 1)(i);
-    //~^ ERROR: try not to call a closure in the expression where it is declared
-    //~| NOTE: `-D clippy::redundant-closure-call` implied by `-D warnings`
+    //~^ redundant_closure_call
 
     // lint here
     k = (|a, b| a * b)(1, 5);
-    //~^ ERROR: try not to call a closure in the expression where it is declared
+    //~^ redundant_closure_call
 
     // don't lint these
     #[allow(clippy::needless_return)]
diff --git a/src/tools/clippy/tests/ui/redundant_closure_call_early.stderr b/src/tools/clippy/tests/ui/redundant_closure_call_early.stderr
index 038144a5d613..1dd24baf9dae 100644
--- a/src/tools/clippy/tests/ui/redundant_closure_call_early.stderr
+++ b/src/tools/clippy/tests/ui/redundant_closure_call_early.stderr
@@ -8,7 +8,7 @@ LL |     let mut k = (|m| m + 1)(i);
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_call)]`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_early.rs:14:9
+  --> tests/ui/redundant_closure_call_early.rs:13:9
    |
 LL |     k = (|a, b| a * b)(1, 5);
    |         ^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/redundant_closure_call_fixable.fixed b/src/tools/clippy/tests/ui/redundant_closure_call_fixable.fixed
index 9138a8bacfe1..099c118e64e3 100644
--- a/src/tools/clippy/tests/ui/redundant_closure_call_fixable.fixed
+++ b/src/tools/clippy/tests/ui/redundant_closure_call_fixable.fixed
@@ -13,17 +13,21 @@ async fn something_else() -> u32 {
 
 fn main() {
     let a = 42;
+    //~^ redundant_closure_call
     let b = async {
+        //~^ redundant_closure_call
         let x = something().await;
         let y = something_else().await;
         x * y
     };
     let c = {
+        //~^ redundant_closure_call
         let x = 21;
         let y = 2;
         x * y
     };
     let d = async { something().await };
+    //~^ redundant_closure_call
 
     macro_rules! m {
         () => {
@@ -33,14 +37,17 @@ fn main() {
     macro_rules! m2 {
         () => {
             m!()
+            //~^ redundant_closure_call
         };
     }
     m2!();
+    //~^ redundant_closure_call
     issue9956();
 }
 
 fn issue9956() {
     assert_eq!(43, 42);
+    //~^ redundant_closure_call
 
     // ... and some more interesting cases I've found while implementing the fix
 
@@ -50,13 +57,16 @@ fn issue9956() {
 
     // immediately calling it inside of a macro
     dbg!(42);
+    //~^ redundant_closure_call
 
     // immediately calling only one closure, so we can't remove the other ones
     let a = (|| || 123);
+    //~^ redundant_closure_call
     dbg!(a()());
 
     // nested async closures
     let a = async { 1 };
+    //~^ redundant_closure_call
     let h = async { a.await };
 
     // macro expansion tests
@@ -66,8 +76,10 @@ fn issue9956() {
         };
     }
     let a = 1;
+    //~^ redundant_closure_call
     assert_eq!(a, 1);
     let a = 123;
+    //~^ redundant_closure_call
     assert_eq!(a, 123);
 
     // chaining calls, but not closures
@@ -81,11 +93,14 @@ fn issue9956() {
     }
     fn foo(_: i32, _: i32) {}
     bar()(42, 5);
+    //~^ redundant_closure_call
     foo(42, 5);
+    //~^ redundant_closure_call
 }
 
 async fn issue11357() {
     async {}.await;
+    //~^ redundant_closure_call
 }
 
 mod issue11707 {
@@ -95,11 +110,13 @@ mod issue11707 {
 
     fn demo() {
         spawn_on(async move {});
+        //~^ redundant_closure_call
     }
 }
 
 fn avoid_double_parens() {
     std::convert::identity(13_i32 + 36_i32).leading_zeros();
+    //~^ redundant_closure_call
 }
 
 fn fp_11274() {
diff --git a/src/tools/clippy/tests/ui/redundant_closure_call_fixable.rs b/src/tools/clippy/tests/ui/redundant_closure_call_fixable.rs
index ede6fa27778b..da5dd7ef263b 100644
--- a/src/tools/clippy/tests/ui/redundant_closure_call_fixable.rs
+++ b/src/tools/clippy/tests/ui/redundant_closure_call_fixable.rs
@@ -13,17 +13,21 @@ async fn something_else() -> u32 {
 
 fn main() {
     let a = (|| 42)();
+    //~^ redundant_closure_call
     let b = (async || {
+        //~^ redundant_closure_call
         let x = something().await;
         let y = something_else().await;
         x * y
     })();
     let c = (|| {
+        //~^ redundant_closure_call
         let x = 21;
         let y = 2;
         x * y
     })();
     let d = (async || something().await)();
+    //~^ redundant_closure_call
 
     macro_rules! m {
         () => {
@@ -33,14 +37,17 @@ fn main() {
     macro_rules! m2 {
         () => {
             (|| m!())()
+            //~^ redundant_closure_call
         };
     }
     m2!();
+    //~^ redundant_closure_call
     issue9956();
 }
 
 fn issue9956() {
     assert_eq!((|| || 43)()(), 42);
+    //~^ redundant_closure_call
 
     // ... and some more interesting cases I've found while implementing the fix
 
@@ -50,13 +57,16 @@ fn issue9956() {
 
     // immediately calling it inside of a macro
     dbg!((|| 42)());
+    //~^ redundant_closure_call
 
     // immediately calling only one closure, so we can't remove the other ones
     let a = (|| || || 123)();
+    //~^ redundant_closure_call
     dbg!(a()());
 
     // nested async closures
     let a = (|| || || || async || 1)()()()()();
+    //~^ redundant_closure_call
     let h = async { a.await };
 
     // macro expansion tests
@@ -66,8 +76,10 @@ fn issue9956() {
         };
     }
     let a = (|| echo!(|| echo!(|| 1)))()()();
+    //~^ redundant_closure_call
     assert_eq!(a, 1);
     let a = (|| echo!((|| 123)))()();
+    //~^ redundant_closure_call
     assert_eq!(a, 123);
 
     // chaining calls, but not closures
@@ -81,11 +93,14 @@ fn issue9956() {
     }
     fn foo(_: i32, _: i32) {}
     bar()((|| || 42)()(), 5);
+    //~^ redundant_closure_call
     foo((|| || 42)()(), 5);
+    //~^ redundant_closure_call
 }
 
 async fn issue11357() {
     (|| async {})().await;
+    //~^ redundant_closure_call
 }
 
 mod issue11707 {
@@ -95,11 +110,13 @@ mod issue11707 {
 
     fn demo() {
         spawn_on((|| async move {})());
+        //~^ redundant_closure_call
     }
 }
 
 fn avoid_double_parens() {
     std::convert::identity((|| 13_i32 + 36_i32)()).leading_zeros();
+    //~^ redundant_closure_call
 }
 
 fn fp_11274() {
diff --git a/src/tools/clippy/tests/ui/redundant_closure_call_fixable.stderr b/src/tools/clippy/tests/ui/redundant_closure_call_fixable.stderr
index 8e0d37df96b8..2c35aafbe310 100644
--- a/src/tools/clippy/tests/ui/redundant_closure_call_fixable.stderr
+++ b/src/tools/clippy/tests/ui/redundant_closure_call_fixable.stderr
@@ -8,10 +8,11 @@ LL |     let a = (|| 42)();
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_call)]`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:16:13
+  --> tests/ui/redundant_closure_call_fixable.rs:17:13
    |
 LL |       let b = (async || {
    |  _____________^
+LL | |
 LL | |         let x = something().await;
 LL | |         let y = something_else().await;
 LL | |         x * y
@@ -21,6 +22,7 @@ LL | |     })();
 help: try doing something like
    |
 LL ~     let b = async {
+LL +
 LL +         let x = something().await;
 LL +         let y = something_else().await;
 LL +         x * y
@@ -28,10 +30,11 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:21:13
+  --> tests/ui/redundant_closure_call_fixable.rs:23:13
    |
 LL |       let c = (|| {
    |  _____________^
+LL | |
 LL | |         let x = 21;
 LL | |         let y = 2;
 LL | |         x * y
@@ -41,6 +44,7 @@ LL | |     })();
 help: try doing something like
    |
 LL ~     let c = {
+LL +
 LL +         let x = 21;
 LL +         let y = 2;
 LL +         x * y
@@ -48,13 +52,13 @@ LL ~     };
    |
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:26:13
+  --> tests/ui/redundant_closure_call_fixable.rs:29:13
    |
 LL |     let d = (async || something().await)();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { something().await }`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:35:13
+  --> tests/ui/redundant_closure_call_fixable.rs:39:13
    |
 LL |             (|| m!())()
    |             ^^^^^^^^^^^ help: try doing something like: `m!()`
@@ -65,7 +69,7 @@ LL |     m2!();
    = note: this error originates in the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:30:13
+  --> tests/ui/redundant_closure_call_fixable.rs:34:13
    |
 LL |             (|| 0)()
    |             ^^^^^^^^ help: try doing something like: `0`
@@ -76,67 +80,67 @@ LL |     m2!();
    = note: this error originates in the macro `m` which comes from the expansion of the macro `m2` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:43:16
+  --> tests/ui/redundant_closure_call_fixable.rs:49:16
    |
 LL |     assert_eq!((|| || 43)()(), 42);
    |                ^^^^^^^^^^^^^^ help: try doing something like: `43`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:52:10
+  --> tests/ui/redundant_closure_call_fixable.rs:59:10
    |
 LL |     dbg!((|| 42)());
    |          ^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:55:13
+  --> tests/ui/redundant_closure_call_fixable.rs:63:13
    |
 LL |     let a = (|| || || 123)();
    |             ^^^^^^^^^^^^^^^^ help: try doing something like: `(|| || 123)`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:59:13
+  --> tests/ui/redundant_closure_call_fixable.rs:68:13
    |
 LL |     let a = (|| || || || async || 1)()()()()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async { 1 }`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:68:13
+  --> tests/ui/redundant_closure_call_fixable.rs:78:13
    |
 LL |     let a = (|| echo!(|| echo!(|| 1)))()()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `1`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:70:13
+  --> tests/ui/redundant_closure_call_fixable.rs:81:13
    |
 LL |     let a = (|| echo!((|| 123)))()();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `123`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:83:11
+  --> tests/ui/redundant_closure_call_fixable.rs:95:11
    |
 LL |     bar()((|| || 42)()(), 5);
    |           ^^^^^^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:84:9
+  --> tests/ui/redundant_closure_call_fixable.rs:97:9
    |
 LL |     foo((|| || 42)()(), 5);
    |         ^^^^^^^^^^^^^^ help: try doing something like: `42`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:88:5
+  --> tests/ui/redundant_closure_call_fixable.rs:102:5
    |
 LL |     (|| async {})().await;
    |     ^^^^^^^^^^^^^^^ help: try doing something like: `async {}`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:97:18
+  --> tests/ui/redundant_closure_call_fixable.rs:112:18
    |
 LL |         spawn_on((|| async move {})());
    |                  ^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `async move {}`
 
 error: try not to call a closure in the expression where it is declared
-  --> tests/ui/redundant_closure_call_fixable.rs:102:28
+  --> tests/ui/redundant_closure_call_fixable.rs:118:28
    |
 LL |     std::convert::identity((|| 13_i32 + 36_i32)()).leading_zeros();
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: try doing something like: `13_i32 + 36_i32`
diff --git a/src/tools/clippy/tests/ui/redundant_closure_call_late.rs b/src/tools/clippy/tests/ui/redundant_closure_call_late.rs
index dc369c3bc092..fd997b1b5fa7 100644
--- a/src/tools/clippy/tests/ui/redundant_closure_call_late.rs
+++ b/src/tools/clippy/tests/ui/redundant_closure_call_late.rs
@@ -14,16 +14,16 @@ fn main() {
     // lint here
     let redun_closure = || 1;
     i = redun_closure();
-    //~^ ERROR: closure called just once immediately after it was declared
-    //~| NOTE: `-D clippy::redundant-closure-call` implied by `-D warnings`
+    //~^ redundant_closure_call
 
     // shadowed closures are supported, lint here
     let shadowed_closure = || 1;
     i = shadowed_closure();
-    //~^ ERROR: closure called just once immediately after it was declared
+    //~^ redundant_closure_call
+
     let shadowed_closure = || 2;
     i = shadowed_closure();
-    //~^ ERROR: closure called just once immediately after it was declared
+    //~^ redundant_closure_call
 
     // don't lint here
     let shadowed_closure = || 2;
diff --git a/src/tools/clippy/tests/ui/redundant_closure_call_late.stderr b/src/tools/clippy/tests/ui/redundant_closure_call_late.stderr
index 023e766a5d2b..ce2a21c23872 100644
--- a/src/tools/clippy/tests/ui/redundant_closure_call_late.stderr
+++ b/src/tools/clippy/tests/ui/redundant_closure_call_late.stderr
@@ -8,7 +8,7 @@ LL |     i = redun_closure();
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure_call)]`
 
 error: closure called just once immediately after it was declared
-  --> tests/ui/redundant_closure_call_late.rs:22:5
+  --> tests/ui/redundant_closure_call_late.rs:21:5
    |
 LL |     i = shadowed_closure();
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/redundant_else.fixed b/src/tools/clippy/tests/ui/redundant_else.fixed
index 47aa79302d2c..8a3279f50180 100644
--- a/src/tools/clippy/tests/ui/redundant_else.fixed
+++ b/src/tools/clippy/tests/ui/redundant_else.fixed
@@ -8,14 +8,16 @@ fn main() {
             println!("Love your neighbor;");
             break;
         }
-        //~^ ERROR: redundant else block
+        //~^ redundant_else
+
         println!("yet don't pull down your hedge.");
         // continue
         if foo() {
             println!("He that lies down with Dogs,");
             continue;
         }
-        //~^ ERROR: redundant else block
+        //~^ redundant_else
+
         println!("shall rise up with fleas.");
         // match block
         if foo() {
@@ -24,7 +26,8 @@ fn main() {
                 _ => return,
             }
         }
-        //~^ ERROR: redundant else block
+        //~^ redundant_else
+
         println!("You may delay, but time will not.");
     }
     // else if
@@ -33,14 +36,16 @@ fn main() {
     } else if foo() {
         return;
     }
-    //~^ ERROR: redundant else block
+    //~^ redundant_else
+
     println!("A fat kitchen makes a lean will.");
     // let binding outside of block
     let _ = {
         if foo() {
             return;
         }
-        //~^ ERROR: redundant else block
+        //~^ redundant_else
+
         1
     };
     // else if with let binding outside of block
@@ -50,7 +55,8 @@ fn main() {
         } else if foo() {
             return;
         }
-        //~^ ERROR: redundant else block
+        //~^ redundant_else
+
         2
     };
     // inside if let
@@ -59,7 +65,8 @@ fn main() {
         if foo() {
             return;
         }
-        //~^ ERROR: redundant else block
+        //~^ redundant_else
+
         1
     } else {
         1
diff --git a/src/tools/clippy/tests/ui/redundant_else.rs b/src/tools/clippy/tests/ui/redundant_else.rs
index 8bcf2ce5233d..78abf4247a56 100644
--- a/src/tools/clippy/tests/ui/redundant_else.rs
+++ b/src/tools/clippy/tests/ui/redundant_else.rs
@@ -8,7 +8,8 @@ fn main() {
             println!("Love your neighbor;");
             break;
         } else {
-            //~^ ERROR: redundant else block
+            //~^ redundant_else
+
             println!("yet don't pull down your hedge.");
         }
         // continue
@@ -16,7 +17,8 @@ fn main() {
             println!("He that lies down with Dogs,");
             continue;
         } else {
-            //~^ ERROR: redundant else block
+            //~^ redundant_else
+
             println!("shall rise up with fleas.");
         }
         // match block
@@ -26,7 +28,8 @@ fn main() {
                 _ => return,
             }
         } else {
-            //~^ ERROR: redundant else block
+            //~^ redundant_else
+
             println!("You may delay, but time will not.");
         }
     }
@@ -36,7 +39,8 @@ fn main() {
     } else if foo() {
         return;
     } else {
-        //~^ ERROR: redundant else block
+        //~^ redundant_else
+
         println!("A fat kitchen makes a lean will.");
     }
     // let binding outside of block
@@ -44,7 +48,8 @@ fn main() {
         if foo() {
             return;
         } else {
-            //~^ ERROR: redundant else block
+            //~^ redundant_else
+
             1
         }
     };
@@ -55,7 +60,8 @@ fn main() {
         } else if foo() {
             return;
         } else {
-            //~^ ERROR: redundant else block
+            //~^ redundant_else
+
             2
         }
     };
@@ -65,7 +71,8 @@ fn main() {
         if foo() {
             return;
         } else {
-            //~^ ERROR: redundant else block
+            //~^ redundant_else
+
             1
         }
     } else {
diff --git a/src/tools/clippy/tests/ui/redundant_else.stderr b/src/tools/clippy/tests/ui/redundant_else.stderr
index ecc16f7cda5e..0902c97af0dd 100644
--- a/src/tools/clippy/tests/ui/redundant_else.stderr
+++ b/src/tools/clippy/tests/ui/redundant_else.stderr
@@ -4,6 +4,7 @@ error: redundant else block
 LL |           } else {
    |  __________^
 LL | |
+LL | |
 LL | |             println!("yet don't pull down your hedge.");
 LL | |         }
    | |_________^
@@ -14,15 +15,17 @@ help: remove the `else` block and move the contents out
    |
 LL ~         }
 LL +
+LL + 
 LL +         println!("yet don't pull down your hedge.");
    |
 
 error: redundant else block
-  --> tests/ui/redundant_else.rs:18:10
+  --> tests/ui/redundant_else.rs:19:10
    |
 LL |           } else {
    |  __________^
 LL | |
+LL | |
 LL | |             println!("shall rise up with fleas.");
 LL | |         }
    | |_________^
@@ -31,15 +34,17 @@ help: remove the `else` block and move the contents out
    |
 LL ~         }
 LL +
+LL + 
 LL +         println!("shall rise up with fleas.");
    |
 
 error: redundant else block
-  --> tests/ui/redundant_else.rs:28:10
+  --> tests/ui/redundant_else.rs:30:10
    |
 LL |           } else {
    |  __________^
 LL | |
+LL | |
 LL | |             println!("You may delay, but time will not.");
 LL | |         }
    | |_________^
@@ -48,15 +53,17 @@ help: remove the `else` block and move the contents out
    |
 LL ~         }
 LL +
+LL + 
 LL +         println!("You may delay, but time will not.");
    |
 
 error: redundant else block
-  --> tests/ui/redundant_else.rs:38:6
+  --> tests/ui/redundant_else.rs:41:6
    |
 LL |       } else {
    |  ______^
 LL | |
+LL | |
 LL | |         println!("A fat kitchen makes a lean will.");
 LL | |     }
    | |_____^
@@ -65,15 +72,17 @@ help: remove the `else` block and move the contents out
    |
 LL ~     }
 LL +
+LL + 
 LL +     println!("A fat kitchen makes a lean will.");
    |
 
 error: redundant else block
-  --> tests/ui/redundant_else.rs:46:10
+  --> tests/ui/redundant_else.rs:50:10
    |
 LL |           } else {
    |  __________^
 LL | |
+LL | |
 LL | |             1
 LL | |         }
    | |_________^
@@ -82,15 +91,17 @@ help: remove the `else` block and move the contents out
    |
 LL ~         }
 LL +
+LL + 
 LL +         1
    |
 
 error: redundant else block
-  --> tests/ui/redundant_else.rs:57:10
+  --> tests/ui/redundant_else.rs:62:10
    |
 LL |           } else {
    |  __________^
 LL | |
+LL | |
 LL | |             2
 LL | |         }
    | |_________^
@@ -99,15 +110,17 @@ help: remove the `else` block and move the contents out
    |
 LL ~         }
 LL +
+LL + 
 LL +         2
    |
 
 error: redundant else block
-  --> tests/ui/redundant_else.rs:67:10
+  --> tests/ui/redundant_else.rs:73:10
    |
 LL |           } else {
    |  __________^
 LL | |
+LL | |
 LL | |             1
 LL | |         }
    | |_________^
@@ -116,6 +129,7 @@ help: remove the `else` block and move the contents out
    |
 LL ~         }
 LL +
+LL + 
 LL +         1
    |
 
diff --git a/src/tools/clippy/tests/ui/redundant_field_names.fixed b/src/tools/clippy/tests/ui/redundant_field_names.fixed
index 72fc4cb7333e..4c922030eb66 100644
--- a/src/tools/clippy/tests/ui/redundant_field_names.fixed
+++ b/src/tools/clippy/tests/ui/redundant_field_names.fixed
@@ -31,8 +31,9 @@ fn main() {
 
     let me = Person {
         gender,
+        //~^ redundant_field_names
         age,
-
+        //~^ redundant_field_names
         name,          //should be ok
         buzz: fizz,    //should be ok
         foo: foo::BAR, //should be ok
@@ -53,10 +54,15 @@ fn main() {
 
     // hand-written Range family structs are linted
     let _ = RangeFrom { start };
+    //~^ redundant_field_names
     let _ = RangeTo { end };
+    //~^ redundant_field_names
     let _ = Range { start, end };
+    //~^ redundant_field_names
+    //~| redundant_field_names
     let _ = RangeInclusive::new(start, end);
     let _ = RangeToInclusive { end };
+    //~^ redundant_field_names
 
     external! {
         let v = 1;
@@ -69,6 +75,7 @@ fn main() {
     macro_rules! internal {
         ($i:ident) => {
             let _ = S { v };
+            //~^ redundant_field_names
             let _ = S { $i: v };
             let _ = S { v: $i };
             let _ = S { $i: $i };
@@ -97,4 +104,5 @@ fn msrv_1_16() {
 fn msrv_1_17() {
     let start = 0;
     let _ = RangeFrom { start };
+    //~^ redundant_field_names
 }
diff --git a/src/tools/clippy/tests/ui/redundant_field_names.rs b/src/tools/clippy/tests/ui/redundant_field_names.rs
index 2617d7e72837..7d03e269cf25 100644
--- a/src/tools/clippy/tests/ui/redundant_field_names.rs
+++ b/src/tools/clippy/tests/ui/redundant_field_names.rs
@@ -31,8 +31,9 @@ fn main() {
 
     let me = Person {
         gender: gender,
+        //~^ redundant_field_names
         age: age,
-
+        //~^ redundant_field_names
         name,          //should be ok
         buzz: fizz,    //should be ok
         foo: foo::BAR, //should be ok
@@ -53,10 +54,15 @@ fn main() {
 
     // hand-written Range family structs are linted
     let _ = RangeFrom { start: start };
+    //~^ redundant_field_names
     let _ = RangeTo { end: end };
+    //~^ redundant_field_names
     let _ = Range { start: start, end: end };
+    //~^ redundant_field_names
+    //~| redundant_field_names
     let _ = RangeInclusive::new(start, end);
     let _ = RangeToInclusive { end: end };
+    //~^ redundant_field_names
 
     external! {
         let v = 1;
@@ -69,6 +75,7 @@ fn main() {
     macro_rules! internal {
         ($i:ident) => {
             let _ = S { v: v };
+            //~^ redundant_field_names
             let _ = S { $i: v };
             let _ = S { v: $i };
             let _ = S { $i: $i };
@@ -97,4 +104,5 @@ fn msrv_1_16() {
 fn msrv_1_17() {
     let start = 0;
     let _ = RangeFrom { start: start };
+    //~^ redundant_field_names
 }
diff --git a/src/tools/clippy/tests/ui/redundant_field_names.stderr b/src/tools/clippy/tests/ui/redundant_field_names.stderr
index 38c021fdba37..5554c28b7cff 100644
--- a/src/tools/clippy/tests/ui/redundant_field_names.stderr
+++ b/src/tools/clippy/tests/ui/redundant_field_names.stderr
@@ -8,43 +8,43 @@ LL |         gender: gender,
    = help: to override `-D warnings` add `#[allow(clippy::redundant_field_names)]`
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:34:9
+  --> tests/ui/redundant_field_names.rs:35:9
    |
 LL |         age: age,
    |         ^^^^^^^^ help: replace it with: `age`
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:55:25
+  --> tests/ui/redundant_field_names.rs:56:25
    |
 LL |     let _ = RangeFrom { start: start };
    |                         ^^^^^^^^^^^^ help: replace it with: `start`
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:56:23
+  --> tests/ui/redundant_field_names.rs:58:23
    |
 LL |     let _ = RangeTo { end: end };
    |                       ^^^^^^^^ help: replace it with: `end`
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:57:21
+  --> tests/ui/redundant_field_names.rs:60:21
    |
 LL |     let _ = Range { start: start, end: end };
    |                     ^^^^^^^^^^^^ help: replace it with: `start`
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:57:35
+  --> tests/ui/redundant_field_names.rs:60:35
    |
 LL |     let _ = Range { start: start, end: end };
    |                                   ^^^^^^^^ help: replace it with: `end`
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:59:32
+  --> tests/ui/redundant_field_names.rs:64:32
    |
 LL |     let _ = RangeToInclusive { end: end };
    |                                ^^^^^^^^ help: replace it with: `end`
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:71:25
+  --> tests/ui/redundant_field_names.rs:77:25
    |
 LL |             let _ = S { v: v };
    |                         ^^^^ help: replace it with: `v`
@@ -55,7 +55,7 @@ LL |     internal!(v);
    = note: this error originates in the macro `internal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: redundant field names in struct initialization
-  --> tests/ui/redundant_field_names.rs:99:25
+  --> tests/ui/redundant_field_names.rs:106:25
    |
 LL |     let _ = RangeFrom { start: start };
    |                         ^^^^^^^^^^^^ help: replace it with: `start`
diff --git a/src/tools/clippy/tests/ui/redundant_guards.fixed b/src/tools/clippy/tests/ui/redundant_guards.fixed
index ff7b233f004e..9dd9d341db2e 100644
--- a/src/tools/clippy/tests/ui/redundant_guards.fixed
+++ b/src/tools/clippy/tests/ui/redundant_guards.fixed
@@ -20,12 +20,14 @@ struct FloatWrapper(f32);
 fn issue11304() {
     match 0.1 {
         0.0 => todo!(),
+        //~^ redundant_guards
         // Pattern matching NAN is illegal
         x if x == f64::NAN => todo!(),
         _ => todo!(),
     }
     match FloatWrapper(0.1) {
         FloatWrapper(0.0) => todo!(),
+        //~^ redundant_guards
         _ => todo!(),
     }
 }
@@ -41,19 +43,25 @@ fn main() {
     let c = C(1, 2);
     match c {
         C(x, 1) => ..,
+        //~^ redundant_guards
         _ => todo!(),
     };
 
     let x = Some(Some(1));
     match x {
         Some(Some(1)) if true => ..,
+        //~^ redundant_guards
         Some(Some(1)) => {
+            //~^ redundant_guards
             println!("a");
             ..
         },
         Some(Some(1)) => ..,
+        //~^ redundant_guards
         Some(Some(2)) => ..,
+        //~^ redundant_guards
         Some(Some(2)) => ..,
+        //~^ redundant_guards
         // Don't lint, since x is used in the body
         Some(x) if let Some(1) = x => {
             x;
@@ -79,6 +87,7 @@ fn main() {
     let b = B { e: Some(A(0)) };
     match b {
         B { e: Some(A(2)) } => ..,
+        //~^ redundant_guards
         _ => todo!(),
     };
     // Do not lint, since we cannot represent this as a pattern (at least, without a conversion)
@@ -116,6 +125,7 @@ fn i() {
         // Do not lint
         E::A(x) | E::B(x) | E::C(x) if x == "from an or pattern" => {},
         E::A("not from an or pattern") => {},
+        //~^ redundant_guards
         _ => {},
     };
 }
@@ -123,6 +133,7 @@ fn i() {
 fn h(v: Option<u32>) {
     match v {
         Some(0) => ..,
+        //~^ redundant_guards
         _ => ..,
     };
 }
@@ -130,7 +141,9 @@ fn h(v: Option<u32>) {
 fn negative_literal(i: i32) {
     match i {
         -1 => {},
+        //~^ redundant_guards
         1 => {},
+        //~^ redundant_guards
         _ => {},
     }
 }
@@ -193,9 +206,13 @@ mod issue11465 {
         let c = Some(1);
         match c {
             Some(1) => {},
+            //~^ redundant_guards
             Some(1) => {},
+            //~^ redundant_guards
             Some(2) => {},
+            //~^ redundant_guards
             Some(3) => {},
+            //~^ redundant_guards
             _ => {},
         };
 
@@ -216,9 +233,13 @@ mod issue11465 {
             B { ref b, .. } if b == "bar" => {},
             B { ref b, .. } if "bar" == b => {},
             B { c: 1, .. } => {},
+            //~^ redundant_guards
             B { c: 1, .. } => {},
+            //~^ redundant_guards
             B { c: 1, .. } => {},
+            //~^ redundant_guards
             B { c: 1, .. } => {},
+            //~^ redundant_guards
             _ => {},
         }
     }
@@ -229,6 +250,7 @@ fn issue11807() {
 
     match Some(Some("")) {
         Some(Some("")) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
@@ -240,11 +262,13 @@ fn issue11807() {
 
     match Some(Some(&[] as &[i32])) {
         Some(Some([])) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some([] as [i32; 0])) {
         Some(Some([])) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
@@ -256,21 +280,25 @@ fn issue11807() {
 
     match Some(Some(&[] as &[i32])) {
         Some(Some([..])) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some(&[] as &[i32])) {
         Some(Some([1, ..])) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some(&[] as &[i32])) {
         Some(Some([1, 2, ..])) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some(&[] as &[i32])) {
         Some(Some([.., 1, 2])) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
diff --git a/src/tools/clippy/tests/ui/redundant_guards.rs b/src/tools/clippy/tests/ui/redundant_guards.rs
index b4d4ef5b170d..e9950d3bbd1d 100644
--- a/src/tools/clippy/tests/ui/redundant_guards.rs
+++ b/src/tools/clippy/tests/ui/redundant_guards.rs
@@ -20,12 +20,14 @@ struct FloatWrapper(f32);
 fn issue11304() {
     match 0.1 {
         x if x == 0.0 => todo!(),
+        //~^ redundant_guards
         // Pattern matching NAN is illegal
         x if x == f64::NAN => todo!(),
         _ => todo!(),
     }
     match FloatWrapper(0.1) {
         x if x == FloatWrapper(0.0) => todo!(),
+        //~^ redundant_guards
         _ => todo!(),
     }
 }
@@ -41,19 +43,25 @@ fn main() {
     let c = C(1, 2);
     match c {
         C(x, y) if let 1 = y => ..,
+        //~^ redundant_guards
         _ => todo!(),
     };
 
     let x = Some(Some(1));
     match x {
         Some(x) if matches!(x, Some(1) if true) => ..,
+        //~^ redundant_guards
         Some(x) if matches!(x, Some(1)) => {
+            //~^ redundant_guards
             println!("a");
             ..
         },
         Some(x) if let Some(1) = x => ..,
+        //~^ redundant_guards
         Some(x) if x == Some(2) => ..,
+        //~^ redundant_guards
         Some(x) if Some(2) == x => ..,
+        //~^ redundant_guards
         // Don't lint, since x is used in the body
         Some(x) if let Some(1) = x => {
             x;
@@ -79,6 +87,7 @@ fn main() {
     let b = B { e: Some(A(0)) };
     match b {
         B { e } if matches!(e, Some(A(2))) => ..,
+        //~^ redundant_guards
         _ => todo!(),
     };
     // Do not lint, since we cannot represent this as a pattern (at least, without a conversion)
@@ -116,6 +125,7 @@ fn i() {
         // Do not lint
         E::A(x) | E::B(x) | E::C(x) if x == "from an or pattern" => {},
         E::A(y) if y == "not from an or pattern" => {},
+        //~^ redundant_guards
         _ => {},
     };
 }
@@ -123,6 +133,7 @@ fn i() {
 fn h(v: Option<u32>) {
     match v {
         x if matches!(x, Some(0)) => ..,
+        //~^ redundant_guards
         _ => ..,
     };
 }
@@ -130,7 +141,9 @@ fn h(v: Option<u32>) {
 fn negative_literal(i: i32) {
     match i {
         i if i == -1 => {},
+        //~^ redundant_guards
         i if i == 1 => {},
+        //~^ redundant_guards
         _ => {},
     }
 }
@@ -193,9 +206,13 @@ mod issue11465 {
         let c = Some(1);
         match c {
             Some(ref x) if x == &1 => {},
+            //~^ redundant_guards
             Some(ref x) if &1 == x => {},
+            //~^ redundant_guards
             Some(ref x) if let &2 = x => {},
+            //~^ redundant_guards
             Some(ref x) if matches!(x, &3) => {},
+            //~^ redundant_guards
             _ => {},
         };
 
@@ -216,9 +233,13 @@ mod issue11465 {
             B { ref b, .. } if b == "bar" => {},
             B { ref b, .. } if "bar" == b => {},
             B { ref c, .. } if c == &1 => {},
+            //~^ redundant_guards
             B { ref c, .. } if &1 == c => {},
+            //~^ redundant_guards
             B { ref c, .. } if let &1 = c => {},
+            //~^ redundant_guards
             B { ref c, .. } if matches!(c, &1) => {},
+            //~^ redundant_guards
             _ => {},
         }
     }
@@ -229,6 +250,7 @@ fn issue11807() {
 
     match Some(Some("")) {
         Some(Some(x)) if x.is_empty() => {},
+        //~^ redundant_guards
         _ => {},
     }
 
@@ -240,11 +262,13 @@ fn issue11807() {
 
     match Some(Some(&[] as &[i32])) {
         Some(Some(x)) if x.is_empty() => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some([] as [i32; 0])) {
         Some(Some(x)) if x.is_empty() => {},
+        //~^ redundant_guards
         _ => {},
     }
 
@@ -256,21 +280,25 @@ fn issue11807() {
 
     match Some(Some(&[] as &[i32])) {
         Some(Some(x)) if x.starts_with(&[]) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some(&[] as &[i32])) {
         Some(Some(x)) if x.starts_with(&[1]) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some(&[] as &[i32])) {
         Some(Some(x)) if x.starts_with(&[1, 2]) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
     match Some(Some(&[] as &[i32])) {
         Some(Some(x)) if x.ends_with(&[1, 2]) => {},
+        //~^ redundant_guards
         _ => {},
     }
 
diff --git a/src/tools/clippy/tests/ui/redundant_guards.stderr b/src/tools/clippy/tests/ui/redundant_guards.stderr
index a10cd5c2f481..cb7b9b119e20 100644
--- a/src/tools/clippy/tests/ui/redundant_guards.stderr
+++ b/src/tools/clippy/tests/ui/redundant_guards.stderr
@@ -13,7 +13,7 @@ LL +         0.0 => todo!(),
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:28:14
+  --> tests/ui/redundant_guards.rs:29:14
    |
 LL |         x if x == FloatWrapper(0.0) => todo!(),
    |              ^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +         FloatWrapper(0.0) => todo!(),
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:43:20
+  --> tests/ui/redundant_guards.rs:45:20
    |
 LL |         C(x, y) if let 1 = y => ..,
    |                    ^^^^^^^^^
@@ -37,7 +37,7 @@ LL +         C(x, 1) => ..,
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:49:20
+  --> tests/ui/redundant_guards.rs:52:20
    |
 LL |         Some(x) if matches!(x, Some(1) if true) => ..,
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +         Some(Some(1)) if true => ..,
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:50:20
+  --> tests/ui/redundant_guards.rs:54:20
    |
 LL |         Some(x) if matches!(x, Some(1)) => {
    |                    ^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +         Some(Some(1)) => {
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:54:20
+  --> tests/ui/redundant_guards.rs:59:20
    |
 LL |         Some(x) if let Some(1) = x => ..,
    |                    ^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +         Some(Some(1)) => ..,
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:55:20
+  --> tests/ui/redundant_guards.rs:61:20
    |
 LL |         Some(x) if x == Some(2) => ..,
    |                    ^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +         Some(Some(2)) => ..,
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:56:20
+  --> tests/ui/redundant_guards.rs:63:20
    |
 LL |         Some(x) if Some(2) == x => ..,
    |                    ^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +         Some(Some(2)) => ..,
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:81:20
+  --> tests/ui/redundant_guards.rs:89:20
    |
 LL |         B { e } if matches!(e, Some(A(2))) => ..,
    |                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +         B { e: Some(A(2)) } => ..,
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:118:20
+  --> tests/ui/redundant_guards.rs:127:20
    |
 LL |         E::A(y) if y == "not from an or pattern" => {},
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +         E::A("not from an or pattern") => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:125:14
+  --> tests/ui/redundant_guards.rs:135:14
    |
 LL |         x if matches!(x, Some(0)) => ..,
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +         Some(0) => ..,
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:132:14
+  --> tests/ui/redundant_guards.rs:143:14
    |
 LL |         i if i == -1 => {},
    |              ^^^^^^^
@@ -145,7 +145,7 @@ LL +         -1 => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:133:14
+  --> tests/ui/redundant_guards.rs:145:14
    |
 LL |         i if i == 1 => {},
    |              ^^^^^^
@@ -157,7 +157,7 @@ LL +         1 => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:195:28
+  --> tests/ui/redundant_guards.rs:208:28
    |
 LL |             Some(ref x) if x == &1 => {},
    |                            ^^^^^^^
@@ -169,7 +169,7 @@ LL +             Some(1) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:196:28
+  --> tests/ui/redundant_guards.rs:210:28
    |
 LL |             Some(ref x) if &1 == x => {},
    |                            ^^^^^^^
@@ -181,7 +181,7 @@ LL +             Some(1) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:197:28
+  --> tests/ui/redundant_guards.rs:212:28
    |
 LL |             Some(ref x) if let &2 = x => {},
    |                            ^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +             Some(2) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:198:28
+  --> tests/ui/redundant_guards.rs:214:28
    |
 LL |             Some(ref x) if matches!(x, &3) => {},
    |                            ^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL +             Some(3) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:218:32
+  --> tests/ui/redundant_guards.rs:235:32
    |
 LL |             B { ref c, .. } if c == &1 => {},
    |                                ^^^^^^^
@@ -217,7 +217,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:219:32
+  --> tests/ui/redundant_guards.rs:237:32
    |
 LL |             B { ref c, .. } if &1 == c => {},
    |                                ^^^^^^^
@@ -229,7 +229,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:220:32
+  --> tests/ui/redundant_guards.rs:239:32
    |
 LL |             B { ref c, .. } if let &1 = c => {},
    |                                ^^^^^^^^^^
@@ -241,7 +241,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:221:32
+  --> tests/ui/redundant_guards.rs:241:32
    |
 LL |             B { ref c, .. } if matches!(c, &1) => {},
    |                                ^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL +             B { c: 1, .. } => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:231:26
+  --> tests/ui/redundant_guards.rs:252:26
    |
 LL |         Some(Some(x)) if x.is_empty() => {},
    |                          ^^^^^^^^^^^^
@@ -265,7 +265,7 @@ LL +         Some(Some("")) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:242:26
+  --> tests/ui/redundant_guards.rs:264:26
    |
 LL |         Some(Some(x)) if x.is_empty() => {},
    |                          ^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL +         Some(Some([])) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:247:26
+  --> tests/ui/redundant_guards.rs:270:26
    |
 LL |         Some(Some(x)) if x.is_empty() => {},
    |                          ^^^^^^^^^^^^
@@ -289,7 +289,7 @@ LL +         Some(Some([])) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:258:26
+  --> tests/ui/redundant_guards.rs:282:26
    |
 LL |         Some(Some(x)) if x.starts_with(&[]) => {},
    |                          ^^^^^^^^^^^^^^^^^^
@@ -301,7 +301,7 @@ LL +         Some(Some([..])) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:263:26
+  --> tests/ui/redundant_guards.rs:288:26
    |
 LL |         Some(Some(x)) if x.starts_with(&[1]) => {},
    |                          ^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL +         Some(Some([1, ..])) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:268:26
+  --> tests/ui/redundant_guards.rs:294:26
    |
 LL |         Some(Some(x)) if x.starts_with(&[1, 2]) => {},
    |                          ^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL +         Some(Some([1, 2, ..])) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:273:26
+  --> tests/ui/redundant_guards.rs:300:26
    |
 LL |         Some(Some(x)) if x.ends_with(&[1, 2]) => {},
    |                          ^^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL +         Some(Some([.., 1, 2])) => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:295:18
+  --> tests/ui/redundant_guards.rs:323:18
    |
 LL |             y if y.is_empty() => {},
    |                  ^^^^^^^^^^^^
@@ -349,7 +349,7 @@ LL +             "" => {},
    |
 
 error: redundant guard
-  --> tests/ui/redundant_guards.rs:314:22
+  --> tests/ui/redundant_guards.rs:342:22
    |
 LL |                 y if y.is_empty() => {},
    |                      ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/redundant_locals.rs b/src/tools/clippy/tests/ui/redundant_locals.rs
index 3e7695106a7f..b66532dd22ee 100644
--- a/src/tools/clippy/tests/ui/redundant_locals.rs
+++ b/src/tools/clippy/tests/ui/redundant_locals.rs
@@ -11,11 +11,13 @@ fn main() {}
 fn immutable() {
     let x = 1;
     let x = x;
+    //~^ redundant_locals
 }
 
 fn mutable() {
     let mut x = 1;
     let mut x = x;
+    //~^ redundant_locals
 }
 
 fn upgraded_mutability() {
@@ -46,27 +48,35 @@ fn coercion(par: &mut i32) {
 
 fn parameter(x: i32) {
     let x = x;
+    //~^ redundant_locals
 }
 
 fn many() {
     let x = 1;
     let x = x;
+    //~^ redundant_locals
     let x = x;
+    //~^ redundant_locals
     let x = x;
+    //~^ redundant_locals
     let x = x;
+    //~^ redundant_locals
 }
 
 fn interleaved() {
     let a = 1;
     let b = 2;
     let a = a;
+    //~^ redundant_locals
     let b = b;
+    //~^ redundant_locals
 }
 
 fn block() {
     {
         let x = 1;
         let x = x;
+        //~^ redundant_locals
     }
 }
 
@@ -74,9 +84,11 @@ fn closure() {
     || {
         let x = 1;
         let x = x;
+        //~^ redundant_locals
     };
     |x: i32| {
         let x = x;
+        //~^ redundant_locals
     };
 }
 
@@ -96,6 +108,7 @@ fn inconsequential_drop_order() {
 
     {
         let x = x;
+        //~^ redundant_locals
     }
 }
 
@@ -151,6 +164,7 @@ fn without_drop() {
     let a = WithoutDrop(1);
     let b = WithoutDrop(2);
     let a = a;
+    //~^ redundant_locals
 }
 
 fn drop_inner() {
diff --git a/src/tools/clippy/tests/ui/redundant_locals.stderr b/src/tools/clippy/tests/ui/redundant_locals.stderr
index 541b988eefe9..ae3631cdf15f 100644
--- a/src/tools/clippy/tests/ui/redundant_locals.stderr
+++ b/src/tools/clippy/tests/ui/redundant_locals.stderr
@@ -13,65 +13,29 @@ LL |     let x = 1;
    = help: to override `-D warnings` add `#[allow(clippy::redundant_locals)]`
 
 error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:18:5
+  --> tests/ui/redundant_locals.rs:19:5
    |
 LL |     let mut x = x;
    |     ^^^^^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:17:9
+  --> tests/ui/redundant_locals.rs:18:9
    |
 LL |     let mut x = 1;
    |         ^^^^^
 
 error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:48:5
+  --> tests/ui/redundant_locals.rs:50:5
    |
 LL |     let x = x;
    |     ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:47:14
+  --> tests/ui/redundant_locals.rs:49:14
    |
 LL | fn parameter(x: i32) {
    |              ^
 
-error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:53:5
-   |
-LL |     let x = x;
-   |     ^^^^^^^^^^
-   |
-help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:52:9
-   |
-LL |     let x = 1;
-   |         ^
-
-error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:54:5
-   |
-LL |     let x = x;
-   |     ^^^^^^^^^^
-   |
-help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:53:9
-   |
-LL |     let x = x;
-   |         ^
-
-error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:55:5
-   |
-LL |     let x = x;
-   |     ^^^^^^^^^^
-   |
-help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:54:9
-   |
-LL |     let x = x;
-   |         ^
-
 error: redundant redefinition of a binding `x`
   --> tests/ui/redundant_locals.rs:56:5
    |
@@ -81,89 +45,125 @@ LL |     let x = x;
 help: `x` is initially defined here
   --> tests/ui/redundant_locals.rs:55:9
    |
+LL |     let x = 1;
+   |         ^
+
+error: redundant redefinition of a binding `x`
+  --> tests/ui/redundant_locals.rs:58:5
+   |
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+help: `x` is initially defined here
+  --> tests/ui/redundant_locals.rs:56:9
+   |
+LL |     let x = x;
+   |         ^
+
+error: redundant redefinition of a binding `x`
+  --> tests/ui/redundant_locals.rs:60:5
+   |
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+help: `x` is initially defined here
+  --> tests/ui/redundant_locals.rs:58:9
+   |
+LL |     let x = x;
+   |         ^
+
+error: redundant redefinition of a binding `x`
+  --> tests/ui/redundant_locals.rs:62:5
+   |
+LL |     let x = x;
+   |     ^^^^^^^^^^
+   |
+help: `x` is initially defined here
+  --> tests/ui/redundant_locals.rs:60:9
+   |
 LL |     let x = x;
    |         ^
 
 error: redundant redefinition of a binding `a`
-  --> tests/ui/redundant_locals.rs:62:5
+  --> tests/ui/redundant_locals.rs:69:5
    |
 LL |     let a = a;
    |     ^^^^^^^^^^
    |
 help: `a` is initially defined here
-  --> tests/ui/redundant_locals.rs:60:9
+  --> tests/ui/redundant_locals.rs:67:9
    |
 LL |     let a = 1;
    |         ^
 
 error: redundant redefinition of a binding `b`
-  --> tests/ui/redundant_locals.rs:63:5
+  --> tests/ui/redundant_locals.rs:71:5
    |
 LL |     let b = b;
    |     ^^^^^^^^^^
    |
 help: `b` is initially defined here
-  --> tests/ui/redundant_locals.rs:61:9
+  --> tests/ui/redundant_locals.rs:68:9
    |
 LL |     let b = 2;
    |         ^
 
 error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:69:9
+  --> tests/ui/redundant_locals.rs:78:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:68:13
+  --> tests/ui/redundant_locals.rs:77:13
    |
 LL |         let x = 1;
    |             ^
 
 error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:76:9
+  --> tests/ui/redundant_locals.rs:86:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:75:13
+  --> tests/ui/redundant_locals.rs:85:13
    |
 LL |         let x = 1;
    |             ^
 
 error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:79:9
+  --> tests/ui/redundant_locals.rs:90:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:78:6
+  --> tests/ui/redundant_locals.rs:89:6
    |
 LL |     |x: i32| {
    |      ^
 
 error: redundant redefinition of a binding `x`
-  --> tests/ui/redundant_locals.rs:98:9
+  --> tests/ui/redundant_locals.rs:110:9
    |
 LL |         let x = x;
    |         ^^^^^^^^^^
    |
 help: `x` is initially defined here
-  --> tests/ui/redundant_locals.rs:95:9
+  --> tests/ui/redundant_locals.rs:107:9
    |
 LL |     let x = 1;
    |         ^
 
 error: redundant redefinition of a binding `a`
-  --> tests/ui/redundant_locals.rs:153:5
+  --> tests/ui/redundant_locals.rs:166:5
    |
 LL |     let a = a;
    |     ^^^^^^^^^^
    |
 help: `a` is initially defined here
-  --> tests/ui/redundant_locals.rs:151:9
+  --> tests/ui/redundant_locals.rs:164:9
    |
 LL |     let a = WithoutDrop(1);
    |         ^
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.fixed
index 148eaa4b33a6..1141b5db3ebf 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.fixed
@@ -13,49 +13,71 @@ fn main() {
 
     // Result
     if m.lock().is_ok() {}
+    //~^ redundant_pattern_matching
     if Err::<(), _>(m.lock().unwrap().0).is_err() {}
+    //~^ redundant_pattern_matching
 
     {
         if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok() {}
+        //~^ redundant_pattern_matching
     }
     if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok() {
+        //~^ redundant_pattern_matching
     } else {
     }
     if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok() {}
+    //~^ redundant_pattern_matching
     if Err::<std::sync::MutexGuard<()>, _>(()).is_err() {}
+    //~^ redundant_pattern_matching
 
     if Ok::<_, ()>(String::new()).is_ok() {}
+    //~^ redundant_pattern_matching
     if Err::<(), _>((String::new(), ())).is_err() {}
+    //~^ redundant_pattern_matching
 
     // Option
     if Some(m.lock()).is_some() {}
+    //~^ redundant_pattern_matching
     if Some(m.lock().unwrap().0).is_some() {}
+    //~^ redundant_pattern_matching
 
     {
         if None::<std::sync::MutexGuard<()>>.is_none() {}
+        //~^ redundant_pattern_matching
     }
     if None::<std::sync::MutexGuard<()>>.is_none() {
+        //~^ redundant_pattern_matching
     } else {
     }
 
     if None::<std::sync::MutexGuard<()>>.is_none() {}
+    //~^ redundant_pattern_matching
 
     if Some(String::new()).is_some() {}
+    //~^ redundant_pattern_matching
     if Some((String::new(), ())).is_some() {}
+    //~^ redundant_pattern_matching
 
     // Poll
     if Ready(m.lock()).is_ready() {}
+    //~^ redundant_pattern_matching
     if Ready(m.lock().unwrap().0).is_ready() {}
+    //~^ redundant_pattern_matching
 
     {
         if Pending::<std::sync::MutexGuard<()>>.is_pending() {}
+        //~^ redundant_pattern_matching
     }
     if Pending::<std::sync::MutexGuard<()>>.is_pending() {
+        //~^ redundant_pattern_matching
     } else {
     }
 
     if Pending::<std::sync::MutexGuard<()>>.is_pending() {}
+    //~^ redundant_pattern_matching
 
     if Ready(String::new()).is_ready() {}
+    //~^ redundant_pattern_matching
     if Ready((String::new(), ())).is_ready() {}
+    //~^ redundant_pattern_matching
 }
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.rs
index 5bc06f3cc529..f60ddf468309 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.rs
@@ -13,49 +13,71 @@ fn main() {
 
     // Result
     if let Ok(_) = m.lock() {}
+    //~^ redundant_pattern_matching
     if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
+    //~^ redundant_pattern_matching
 
     {
         if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
+        //~^ redundant_pattern_matching
     }
     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
+        //~^ redundant_pattern_matching
     } else {
     }
     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
+    //~^ redundant_pattern_matching
     if let Err(_) = Err::<std::sync::MutexGuard<()>, _>(()) {}
+    //~^ redundant_pattern_matching
 
     if let Ok(_) = Ok::<_, ()>(String::new()) {}
+    //~^ redundant_pattern_matching
     if let Err(_) = Err::<(), _>((String::new(), ())) {}
+    //~^ redundant_pattern_matching
 
     // Option
     if let Some(_) = Some(m.lock()) {}
+    //~^ redundant_pattern_matching
     if let Some(_) = Some(m.lock().unwrap().0) {}
+    //~^ redundant_pattern_matching
 
     {
         if let None = None::<std::sync::MutexGuard<()>> {}
+        //~^ redundant_pattern_matching
     }
     if let None = None::<std::sync::MutexGuard<()>> {
+        //~^ redundant_pattern_matching
     } else {
     }
 
     if let None = None::<std::sync::MutexGuard<()>> {}
+    //~^ redundant_pattern_matching
 
     if let Some(_) = Some(String::new()) {}
+    //~^ redundant_pattern_matching
     if let Some(_) = Some((String::new(), ())) {}
+    //~^ redundant_pattern_matching
 
     // Poll
     if let Ready(_) = Ready(m.lock()) {}
+    //~^ redundant_pattern_matching
     if let Ready(_) = Ready(m.lock().unwrap().0) {}
+    //~^ redundant_pattern_matching
 
     {
         if let Pending = Pending::<std::sync::MutexGuard<()>> {}
+        //~^ redundant_pattern_matching
     }
     if let Pending = Pending::<std::sync::MutexGuard<()>> {
+        //~^ redundant_pattern_matching
     } else {
     }
 
     if let Pending = Pending::<std::sync::MutexGuard<()>> {}
+    //~^ redundant_pattern_matching
 
     if let Ready(_) = Ready(String::new()) {}
+    //~^ redundant_pattern_matching
     if let Ready(_) = Ready((String::new(), ())) {}
+    //~^ redundant_pattern_matching
 }
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.stderr
index 1a99cb9fc32b..74462f022f70 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_drop_order.stderr
@@ -10,7 +10,7 @@ LL |     if let Ok(_) = m.lock() {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:16:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:17:12
    |
 LL |     if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
    |     -------^^^^^^------------------------------------ help: try: `if Err::<(), _>(m.lock().unwrap().0).is_err()`
@@ -19,7 +19,7 @@ LL |     if let Err(_) = Err::<(), _>(m.lock().unwrap().0) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:19:16
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:21:16
    |
 LL |         if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
    |         -------^^^^^----------------------------------------- help: try: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
@@ -28,7 +28,7 @@ LL |         if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:21:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:24:12
    |
 LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
    |     -------^^^^^----------------------------------------- help: try: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
@@ -37,31 +37,31 @@ LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:24:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:28:12
    |
 LL |     if let Ok(_) = Ok::<_, std::sync::MutexGuard<()>>(()) {}
    |     -------^^^^^----------------------------------------- help: try: `if Ok::<_, std::sync::MutexGuard<()>>(()).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:25:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:30:12
    |
 LL |     if let Err(_) = Err::<std::sync::MutexGuard<()>, _>(()) {}
    |     -------^^^^^^------------------------------------------ help: try: `if Err::<std::sync::MutexGuard<()>, _>(()).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:27:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:33:12
    |
 LL |     if let Ok(_) = Ok::<_, ()>(String::new()) {}
    |     -------^^^^^----------------------------- help: try: `if Ok::<_, ()>(String::new()).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:28:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:35:12
    |
 LL |     if let Err(_) = Err::<(), _>((String::new(), ())) {}
    |     -------^^^^^^------------------------------------ help: try: `if Err::<(), _>((String::new(), ())).is_err()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:31:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:39:12
    |
 LL |     if let Some(_) = Some(m.lock()) {}
    |     -------^^^^^^^----------------- help: try: `if Some(m.lock()).is_some()`
@@ -70,7 +70,7 @@ LL |     if let Some(_) = Some(m.lock()) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:32:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:41:12
    |
 LL |     if let Some(_) = Some(m.lock().unwrap().0) {}
    |     -------^^^^^^^---------------------------- help: try: `if Some(m.lock().unwrap().0).is_some()`
@@ -79,7 +79,7 @@ LL |     if let Some(_) = Some(m.lock().unwrap().0) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:35:16
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:45:16
    |
 LL |         if let None = None::<std::sync::MutexGuard<()>> {}
    |         -------^^^^------------------------------------ help: try: `if None::<std::sync::MutexGuard<()>>.is_none()`
@@ -88,7 +88,7 @@ LL |         if let None = None::<std::sync::MutexGuard<()>> {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:37:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:48:12
    |
 LL |     if let None = None::<std::sync::MutexGuard<()>> {
    |     -------^^^^------------------------------------ help: try: `if None::<std::sync::MutexGuard<()>>.is_none()`
@@ -97,25 +97,25 @@ LL |     if let None = None::<std::sync::MutexGuard<()>> {
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:41:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:53:12
    |
 LL |     if let None = None::<std::sync::MutexGuard<()>> {}
    |     -------^^^^------------------------------------ help: try: `if None::<std::sync::MutexGuard<()>>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:43:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:56:12
    |
 LL |     if let Some(_) = Some(String::new()) {}
    |     -------^^^^^^^---------------------- help: try: `if Some(String::new()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:44:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:58:12
    |
 LL |     if let Some(_) = Some((String::new(), ())) {}
    |     -------^^^^^^^---------------------------- help: try: `if Some((String::new(), ())).is_some()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:47:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:62:12
    |
 LL |     if let Ready(_) = Ready(m.lock()) {}
    |     -------^^^^^^^^------------------ help: try: `if Ready(m.lock()).is_ready()`
@@ -124,7 +124,7 @@ LL |     if let Ready(_) = Ready(m.lock()) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:48:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:64:12
    |
 LL |     if let Ready(_) = Ready(m.lock().unwrap().0) {}
    |     -------^^^^^^^^----------------------------- help: try: `if Ready(m.lock().unwrap().0).is_ready()`
@@ -133,7 +133,7 @@ LL |     if let Ready(_) = Ready(m.lock().unwrap().0) {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:51:16
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:68:16
    |
 LL |         if let Pending = Pending::<std::sync::MutexGuard<()>> {}
    |         -------^^^^^^^--------------------------------------- help: try: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
@@ -142,7 +142,7 @@ LL |         if let Pending = Pending::<std::sync::MutexGuard<()>> {}
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:53:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:71:12
    |
 LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {
    |     -------^^^^^^^--------------------------------------- help: try: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
@@ -151,19 +151,19 @@ LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {
    = note: add `#[allow(clippy::redundant_pattern_matching)]` if this is important
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:57:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:76:12
    |
 LL |     if let Pending = Pending::<std::sync::MutexGuard<()>> {}
    |     -------^^^^^^^--------------------------------------- help: try: `if Pending::<std::sync::MutexGuard<()>>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:59:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:79:12
    |
 LL |     if let Ready(_) = Ready(String::new()) {}
    |     -------^^^^^^^^----------------------- help: try: `if Ready(String::new()).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_drop_order.rs:60:12
+  --> tests/ui/redundant_pattern_matching_drop_order.rs:81:12
    |
 LL |     if let Ready(_) = Ready((String::new(), ())) {}
    |     -------^^^^^^^^----------------------------- help: try: `if Ready((String::new(), ())).is_ready()`
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.fixed
index 6d9106789340..980455da2ee7 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.fixed
@@ -20,18 +20,25 @@ fn main() {
     let mut k = 5;
 
     if k > 1 {}
+    //~^ redundant_pattern_matching
     if !(k > 5) {}
+    //~^ redundant_pattern_matching
     if k > 1 {}
+    //~^ redundant_pattern_matching
     if let (true, true) = (k > 1, k > 2) {}
     while k > 1 {
+        //~^ redundant_pattern_matching
         k += 1;
     }
     while condition!() {
+        //~^ redundant_pattern_matching
         k += 1;
     }
 
     k > 5;
+    //~^ redundant_pattern_matching
     !(k > 5);
+    //~^ redundant_pattern_matching
     // Whole loop is from a macro expansion, don't lint:
     lettrue!(if);
     lettrue!(while);
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.rs
index a82e673982a3..9cb0fe2e65f6 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.rs
@@ -20,18 +20,25 @@ fn main() {
     let mut k = 5;
 
     if let true = k > 1 {}
+    //~^ redundant_pattern_matching
     if let false = k > 5 {}
+    //~^ redundant_pattern_matching
     if let (true) = k > 1 {}
+    //~^ redundant_pattern_matching
     if let (true, true) = (k > 1, k > 2) {}
     while let true = k > 1 {
+        //~^ redundant_pattern_matching
         k += 1;
     }
     while let true = condition!() {
+        //~^ redundant_pattern_matching
         k += 1;
     }
 
     matches!(k > 5, true);
+    //~^ redundant_pattern_matching
     matches!(k > 5, false);
+    //~^ redundant_pattern_matching
     // Whole loop is from a macro expansion, don't lint:
     lettrue!(if);
     lettrue!(while);
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.stderr
index 43d5cd07cec7..db8646270609 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_if_let_true.stderr
@@ -8,37 +8,37 @@ LL |     if let true = k > 1 {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: using `if let` to pattern match a bool
-  --> tests/ui/redundant_pattern_matching_if_let_true.rs:23:8
+  --> tests/ui/redundant_pattern_matching_if_let_true.rs:24:8
    |
 LL |     if let false = k > 5 {}
    |        ^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `!(k > 5)`
 
 error: using `if let` to pattern match a bool
-  --> tests/ui/redundant_pattern_matching_if_let_true.rs:24:8
+  --> tests/ui/redundant_pattern_matching_if_let_true.rs:26:8
    |
 LL |     if let (true) = k > 1 {}
    |        ^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `k > 1`
 
 error: using `if let` to pattern match a bool
-  --> tests/ui/redundant_pattern_matching_if_let_true.rs:26:11
+  --> tests/ui/redundant_pattern_matching_if_let_true.rs:29:11
    |
 LL |     while let true = k > 1 {
    |           ^^^^^^^^^^^^^^^^ help: consider using the condition directly: `k > 1`
 
 error: using `if let` to pattern match a bool
-  --> tests/ui/redundant_pattern_matching_if_let_true.rs:29:11
+  --> tests/ui/redundant_pattern_matching_if_let_true.rs:33:11
    |
 LL |     while let true = condition!() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `condition!()`
 
 error: using `matches!` to pattern match a bool
-  --> tests/ui/redundant_pattern_matching_if_let_true.rs:33:5
+  --> tests/ui/redundant_pattern_matching_if_let_true.rs:38:5
    |
 LL |     matches!(k > 5, true);
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `k > 5`
 
 error: using `matches!` to pattern match a bool
-  --> tests/ui/redundant_pattern_matching_if_let_true.rs:34:5
+  --> tests/ui/redundant_pattern_matching_if_let_true.rs:40:5
    |
 LL |     matches!(k > 5, false);
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: consider using the condition directly: `!(k > 5)`
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.fixed
index 429d33118a58..549c97d9534a 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.fixed
@@ -13,20 +13,27 @@ use std::net::{Ipv4Addr, Ipv6Addr};
 fn main() {
     let ipaddr: IpAddr = V4(Ipv4Addr::LOCALHOST);
     if ipaddr.is_ipv4() {}
+    //~^ redundant_pattern_matching
 
     if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    //~^ redundant_pattern_matching
 
     if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    //~^ redundant_pattern_matching
 
     // Issue 6459
     if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    //~^ redundant_pattern_matching
 
     // Issue 6459
     if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    //~^ redundant_pattern_matching
 
     while V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    //~^ redundant_pattern_matching
 
     while V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    //~^ redundant_pattern_matching
 
     if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
 
@@ -45,6 +52,7 @@ fn main() {
     V6(Ipv6Addr::LOCALHOST).is_ipv4();
 
     let _ = if V4(Ipv4Addr::LOCALHOST).is_ipv4() {
+        //~^ redundant_pattern_matching
         true
     } else {
         false
@@ -53,8 +61,10 @@ fn main() {
     ipaddr_const();
 
     let _ = if gen_ipaddr().is_ipv4() {
+        //~^ redundant_pattern_matching
         1
     } else if gen_ipaddr().is_ipv6() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
@@ -67,12 +77,16 @@ fn gen_ipaddr() -> IpAddr {
 
 const fn ipaddr_const() {
     if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    //~^ redundant_pattern_matching
 
     if V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    //~^ redundant_pattern_matching
 
     while V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
+    //~^ redundant_pattern_matching
 
     while V6(Ipv6Addr::LOCALHOST).is_ipv6() {}
+    //~^ redundant_pattern_matching
 
     V4(Ipv4Addr::LOCALHOST).is_ipv4();
 
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.rs
index e7136b72c20c..decb1396d56d 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.rs
@@ -13,20 +13,27 @@ use std::net::{Ipv4Addr, Ipv6Addr};
 fn main() {
     let ipaddr: IpAddr = V4(Ipv4Addr::LOCALHOST);
     if let V4(_) = &ipaddr {}
+    //~^ redundant_pattern_matching
 
     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     // Issue 6459
     if matches!(V4(Ipv4Addr::LOCALHOST), V4(_)) {}
+    //~^ redundant_pattern_matching
 
     // Issue 6459
     if matches!(V6(Ipv6Addr::LOCALHOST), V6(_)) {}
+    //~^ redundant_pattern_matching
 
     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     if V4(Ipv4Addr::LOCALHOST).is_ipv4() {}
 
@@ -37,26 +44,31 @@ fn main() {
     }
 
     match V4(Ipv4Addr::LOCALHOST) {
+        //~^ redundant_pattern_matching
         V4(_) => true,
         V6(_) => false,
     };
 
     match V4(Ipv4Addr::LOCALHOST) {
+        //~^ redundant_pattern_matching
         V4(_) => false,
         V6(_) => true,
     };
 
     match V6(Ipv6Addr::LOCALHOST) {
+        //~^ redundant_pattern_matching
         V4(_) => false,
         V6(_) => true,
     };
 
     match V6(Ipv6Addr::LOCALHOST) {
+        //~^ redundant_pattern_matching
         V4(_) => true,
         V6(_) => false,
     };
 
     let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
+        //~^ redundant_pattern_matching
         true
     } else {
         false
@@ -65,8 +77,10 @@ fn main() {
     ipaddr_const();
 
     let _ = if let V4(_) = gen_ipaddr() {
+        //~^ redundant_pattern_matching
         1
     } else if let V6(_) = gen_ipaddr() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
@@ -79,19 +93,25 @@ fn gen_ipaddr() -> IpAddr {
 
 const fn ipaddr_const() {
     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
+    //~^ redundant_pattern_matching
 
     match V4(Ipv4Addr::LOCALHOST) {
+        //~^ redundant_pattern_matching
         V4(_) => true,
         V6(_) => false,
     };
 
     match V6(Ipv6Addr::LOCALHOST) {
+        //~^ redundant_pattern_matching
         V4(_) => false,
         V6(_) => true,
     };
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.stderr
index a4930ad839f9..66d2cecdc0c9 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_ipaddr.stderr
@@ -8,132 +8,138 @@ LL |     if let V4(_) = &ipaddr {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:17:12
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:18:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:19:12
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:21:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:22:8
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:25:8
    |
 LL |     if matches!(V4(Ipv4Addr::LOCALHOST), V4(_)) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:25:8
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:29:8
    |
 LL |     if matches!(V6(Ipv6Addr::LOCALHOST), V6(_)) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:27:15
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:32:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:29:15
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:35:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:39:5
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:46:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
+LL | |
 LL | |         V4(_) => true,
 LL | |         V6(_) => false,
 LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:44:5
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:52:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
+LL | |
 LL | |         V4(_) => false,
 LL | |         V6(_) => true,
 LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:49:5
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:58:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
+LL | |
 LL | |         V4(_) => false,
 LL | |         V6(_) => true,
 LL | |     };
    | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:54:5
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:64:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
+LL | |
 LL | |         V4(_) => true,
 LL | |         V6(_) => false,
 LL | |     };
    | |_____^ help: try: `V6(Ipv6Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:59:20
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:70:20
    |
 LL |     let _ = if let V4(_) = V4(Ipv4Addr::LOCALHOST) {
    |             -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:67:20
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:79:20
    |
 LL |     let _ = if let V4(_) = gen_ipaddr() {
    |             -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:69:19
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:82:19
    |
 LL |     } else if let V6(_) = gen_ipaddr() {
    |            -------^^^^^--------------- help: try: `if gen_ipaddr().is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:81:12
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:95:12
    |
 LL |     if let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:83:12
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:98:12
    |
 LL |     if let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     -------^^^^^-------------------------- help: try: `if V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:85:15
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:101:15
    |
 LL |     while let V4(_) = V4(Ipv4Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:87:15
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:104:15
    |
 LL |     while let V6(_) = V6(Ipv6Addr::LOCALHOST) {}
    |     ----------^^^^^-------------------------- help: try: `while V6(Ipv6Addr::LOCALHOST).is_ipv6()`
 
 error: redundant pattern matching, consider using `is_ipv4()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:89:5
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:107:5
    |
 LL | /     match V4(Ipv4Addr::LOCALHOST) {
+LL | |
 LL | |         V4(_) => true,
 LL | |         V6(_) => false,
 LL | |     };
    | |_____^ help: try: `V4(Ipv4Addr::LOCALHOST).is_ipv4()`
 
 error: redundant pattern matching, consider using `is_ipv6()`
-  --> tests/ui/redundant_pattern_matching_ipaddr.rs:94:5
+  --> tests/ui/redundant_pattern_matching_ipaddr.rs:113:5
    |
 LL | /     match V6(Ipv6Addr::LOCALHOST) {
+LL | |
 LL | |         V4(_) => false,
 LL | |         V6(_) => true,
 LL | |     };
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed
index c7e0cd2610f0..5585006dc362 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.fixed
@@ -12,10 +12,13 @@
 
 fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
     maybe_some.is_none() && (!boolean)
+    //~^ redundant_pattern_matching
 }
 
 fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T>) {
     let _ = maybe_some.is_none() && (boolean || boolean2); // guard needs parentheses
+    //
+    //~^^ redundant_pattern_matching
     let _ = match maybe_some {
         // can't use `matches!` here
         // because `expr` metavars in macros don't allow let exprs
@@ -30,23 +33,30 @@ fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T
 
 fn main() {
     if None::<()>.is_none() {}
+    //~^ redundant_pattern_matching
 
     if Some(42).is_some() {}
+    //~^ redundant_pattern_matching
 
     if Some(42).is_some() {
+        //~^ redundant_pattern_matching
         foo();
     } else {
         bar();
     }
 
     while Some(42).is_some() {}
+    //~^ redundant_pattern_matching
 
     while Some(42).is_none() {}
+    //~^ redundant_pattern_matching
 
     while None::<()>.is_none() {}
+    //~^ redundant_pattern_matching
 
     let mut v = vec![1, 2, 3];
     while v.pop().is_some() {
+        //~^ redundant_pattern_matching
         foo();
     }
 
@@ -62,20 +72,24 @@ fn main() {
 
     let opt = Some(false);
     let _ = if opt.is_some() { true } else { false };
+    //~^ redundant_pattern_matching
 
     issue6067();
     issue10726();
     issue10803();
 
     let _ = if gen_opt().is_some() {
+        //~^ redundant_pattern_matching
         1
     } else if gen_opt().is_none() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
     };
 
     if gen_opt().is_some() {}
+    //~^ redundant_pattern_matching
 }
 
 fn gen_opt() -> Option<()> {
@@ -91,12 +105,16 @@ fn bar() {}
 // so the following should be linted.
 const fn issue6067() {
     if Some(42).is_some() {}
+    //~^ redundant_pattern_matching
 
     if None::<()>.is_none() {}
+    //~^ redundant_pattern_matching
 
     while Some(42).is_some() {}
+    //~^ redundant_pattern_matching
 
     while None::<()>.is_none() {}
+    //~^ redundant_pattern_matching
 
     Some(42).is_some();
 
@@ -106,7 +124,9 @@ const fn issue6067() {
 #[allow(clippy::deref_addrof, dead_code, clippy::needless_borrow)]
 fn issue7921() {
     if (&None::<()>).is_none() {}
+    //~^ redundant_pattern_matching
     if (&None::<()>).is_none() {}
+    //~^ redundant_pattern_matching
 }
 
 fn issue10726() {
@@ -131,8 +151,10 @@ fn issue10803() {
     let x = Some(42);
 
     let _ = x.is_some();
+    //~^ redundant_pattern_matching
 
     let _ = x.is_none();
+    //~^ redundant_pattern_matching
 
     // Don't lint
     let _ = matches!(x, Some(16));
@@ -143,5 +165,6 @@ fn issue13902() {
     let p = &raw const x;
     unsafe {
         let _ = (*p).is_none();
+        //~^ redundant_pattern_matching
     }
 }
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs
index 6d9a9f7f9428..581a432f38e1 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.rs
@@ -12,10 +12,13 @@
 
 fn issue_11174<T>(boolean: bool, maybe_some: Option<T>) -> bool {
     matches!(maybe_some, None if !boolean)
+    //~^ redundant_pattern_matching
 }
 
 fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T>) {
     let _ = matches!(maybe_some, None if boolean || boolean2); // guard needs parentheses
+    //
+    //~^^ redundant_pattern_matching
     let _ = match maybe_some {
         // can't use `matches!` here
         // because `expr` metavars in macros don't allow let exprs
@@ -30,23 +33,30 @@ fn issue_11174_edge_cases<T>(boolean: bool, boolean2: bool, maybe_some: Option<T
 
 fn main() {
     if let None = None::<()> {}
+    //~^ redundant_pattern_matching
 
     if let Some(_) = Some(42) {}
+    //~^ redundant_pattern_matching
 
     if let Some(_) = Some(42) {
+        //~^ redundant_pattern_matching
         foo();
     } else {
         bar();
     }
 
     while let Some(_) = Some(42) {}
+    //~^ redundant_pattern_matching
 
     while let None = Some(42) {}
+    //~^ redundant_pattern_matching
 
     while let None = None::<()> {}
+    //~^ redundant_pattern_matching
 
     let mut v = vec![1, 2, 3];
     while let Some(_) = v.pop() {
+        //~^ redundant_pattern_matching
         foo();
     }
 
@@ -55,36 +65,43 @@ fn main() {
     if Some(42).is_some() {}
 
     match Some(42) {
+        //~^ redundant_pattern_matching
         Some(_) => true,
         None => false,
     };
 
     match None::<()> {
+        //~^ redundant_pattern_matching
         Some(_) => false,
         None => true,
     };
 
     let _ = match None::<()> {
+        //~^ redundant_pattern_matching
         Some(_) => false,
         None => true,
     };
 
     let opt = Some(false);
     let _ = if let Some(_) = opt { true } else { false };
+    //~^ redundant_pattern_matching
 
     issue6067();
     issue10726();
     issue10803();
 
     let _ = if let Some(_) = gen_opt() {
+        //~^ redundant_pattern_matching
         1
     } else if let None = gen_opt() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
     };
 
     if let Some(..) = gen_opt() {}
+    //~^ redundant_pattern_matching
 }
 
 fn gen_opt() -> Option<()> {
@@ -100,19 +117,25 @@ fn bar() {}
 // so the following should be linted.
 const fn issue6067() {
     if let Some(_) = Some(42) {}
+    //~^ redundant_pattern_matching
 
     if let None = None::<()> {}
+    //~^ redundant_pattern_matching
 
     while let Some(_) = Some(42) {}
+    //~^ redundant_pattern_matching
 
     while let None = None::<()> {}
+    //~^ redundant_pattern_matching
 
     match Some(42) {
+        //~^ redundant_pattern_matching
         Some(_) => true,
         None => false,
     };
 
     match None::<()> {
+        //~^ redundant_pattern_matching
         Some(_) => false,
         None => true,
     };
@@ -121,28 +144,34 @@ const fn issue6067() {
 #[allow(clippy::deref_addrof, dead_code, clippy::needless_borrow)]
 fn issue7921() {
     if let None = *(&None::<()>) {}
+    //~^ redundant_pattern_matching
     if let None = *&None::<()> {}
+    //~^ redundant_pattern_matching
 }
 
 fn issue10726() {
     let x = Some(42);
 
     match x {
+        //~^ redundant_pattern_matching
         Some(_) => true,
         _ => false,
     };
 
     match x {
+        //~^ redundant_pattern_matching
         None => true,
         _ => false,
     };
 
     match x {
+        //~^ redundant_pattern_matching
         Some(_) => false,
         _ => true,
     };
 
     match x {
+        //~^ redundant_pattern_matching
         None => false,
         _ => true,
     };
@@ -158,8 +187,10 @@ fn issue10803() {
     let x = Some(42);
 
     let _ = matches!(x, Some(_));
+    //~^ redundant_pattern_matching
 
     let _ = matches!(x, None);
+    //~^ redundant_pattern_matching
 
     // Don't lint
     let _ = matches!(x, Some(16));
@@ -170,5 +201,6 @@ fn issue13902() {
     let p = &raw const x;
     unsafe {
         let _ = matches!(*p, None);
+        //~^ redundant_pattern_matching
     }
 }
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr
index 34d80f5ca782..681602567d2f 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_option.stderr
@@ -8,209 +8,218 @@ LL |     matches!(maybe_some, None if !boolean)
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:18:13
+  --> tests/ui/redundant_pattern_matching_option.rs:19:13
    |
 LL |     let _ = matches!(maybe_some, None if boolean || boolean2); // guard needs parentheses
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `maybe_some.is_none() && (boolean || boolean2)`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:32:12
+  --> tests/ui/redundant_pattern_matching_option.rs:35:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try: `if None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:34:12
+  --> tests/ui/redundant_pattern_matching_option.rs:38:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:36:12
+  --> tests/ui/redundant_pattern_matching_option.rs:41:12
    |
 LL |     if let Some(_) = Some(42) {
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:42:15
+  --> tests/ui/redundant_pattern_matching_option.rs:48:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:44:15
+  --> tests/ui/redundant_pattern_matching_option.rs:51:15
    |
 LL |     while let None = Some(42) {}
    |     ----------^^^^----------- help: try: `while Some(42).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:46:15
+  --> tests/ui/redundant_pattern_matching_option.rs:54:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:49:15
+  --> tests/ui/redundant_pattern_matching_option.rs:58:15
    |
 LL |     while let Some(_) = v.pop() {
    |     ----------^^^^^^^---------- help: try: `while v.pop().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:57:5
+  --> tests/ui/redundant_pattern_matching_option.rs:67:5
    |
 LL | /     match Some(42) {
+LL | |
 LL | |         Some(_) => true,
 LL | |         None => false,
 LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:62:5
+  --> tests/ui/redundant_pattern_matching_option.rs:73:5
    |
 LL | /     match None::<()> {
+LL | |
 LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:67:13
+  --> tests/ui/redundant_pattern_matching_option.rs:79:13
    |
 LL |       let _ = match None::<()> {
    |  _____________^
+LL | |
 LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:73:20
+  --> tests/ui/redundant_pattern_matching_option.rs:86:20
    |
 LL |     let _ = if let Some(_) = opt { true } else { false };
    |             -------^^^^^^^------ help: try: `if opt.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:79:20
+  --> tests/ui/redundant_pattern_matching_option.rs:93:20
    |
 LL |     let _ = if let Some(_) = gen_opt() {
    |             -------^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:81:19
+  --> tests/ui/redundant_pattern_matching_option.rs:96:19
    |
 LL |     } else if let None = gen_opt() {
    |            -------^^^^------------ help: try: `if gen_opt().is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:87:12
+  --> tests/ui/redundant_pattern_matching_option.rs:103:12
    |
 LL |     if let Some(..) = gen_opt() {}
    |     -------^^^^^^^^------------ help: try: `if gen_opt().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:102:12
+  --> tests/ui/redundant_pattern_matching_option.rs:119:12
    |
 LL |     if let Some(_) = Some(42) {}
    |     -------^^^^^^^----------- help: try: `if Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:104:12
+  --> tests/ui/redundant_pattern_matching_option.rs:122:12
    |
 LL |     if let None = None::<()> {}
    |     -------^^^^------------- help: try: `if None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:106:15
+  --> tests/ui/redundant_pattern_matching_option.rs:125:15
    |
 LL |     while let Some(_) = Some(42) {}
    |     ----------^^^^^^^----------- help: try: `while Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:108:15
+  --> tests/ui/redundant_pattern_matching_option.rs:128:15
    |
 LL |     while let None = None::<()> {}
    |     ----------^^^^------------- help: try: `while None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:110:5
+  --> tests/ui/redundant_pattern_matching_option.rs:131:5
    |
 LL | /     match Some(42) {
+LL | |
 LL | |         Some(_) => true,
 LL | |         None => false,
 LL | |     };
    | |_____^ help: try: `Some(42).is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:115:5
+  --> tests/ui/redundant_pattern_matching_option.rs:137:5
    |
 LL | /     match None::<()> {
+LL | |
 LL | |         Some(_) => false,
 LL | |         None => true,
 LL | |     };
    | |_____^ help: try: `None::<()>.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:123:12
+  --> tests/ui/redundant_pattern_matching_option.rs:146:12
    |
 LL |     if let None = *(&None::<()>) {}
    |     -------^^^^----------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:124:12
+  --> tests/ui/redundant_pattern_matching_option.rs:148:12
    |
 LL |     if let None = *&None::<()> {}
    |     -------^^^^--------------- help: try: `if (&None::<()>).is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:130:5
+  --> tests/ui/redundant_pattern_matching_option.rs:155:5
    |
 LL | /     match x {
+LL | |
 LL | |         Some(_) => true,
 LL | |         _ => false,
 LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:135:5
+  --> tests/ui/redundant_pattern_matching_option.rs:161:5
    |
 LL | /     match x {
+LL | |
 LL | |         None => true,
 LL | |         _ => false,
 LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:140:5
+  --> tests/ui/redundant_pattern_matching_option.rs:167:5
    |
 LL | /     match x {
+LL | |
 LL | |         Some(_) => false,
 LL | |         _ => true,
 LL | |     };
    | |_____^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:145:5
+  --> tests/ui/redundant_pattern_matching_option.rs:173:5
    |
 LL | /     match x {
+LL | |
 LL | |         None => false,
 LL | |         _ => true,
 LL | |     };
    | |_____^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_option.rs:160:13
+  --> tests/ui/redundant_pattern_matching_option.rs:189:13
    |
 LL |     let _ = matches!(x, Some(_));
    |             ^^^^^^^^^^^^^^^^^^^^ help: try: `x.is_some()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:162:13
+  --> tests/ui/redundant_pattern_matching_option.rs:192:13
    |
 LL |     let _ = matches!(x, None);
    |             ^^^^^^^^^^^^^^^^^ help: try: `x.is_none()`
 
 error: redundant pattern matching, consider using `is_none()`
-  --> tests/ui/redundant_pattern_matching_option.rs:172:17
+  --> tests/ui/redundant_pattern_matching_option.rs:203:17
    |
 LL |         let _ = matches!(*p, None);
    |                 ^^^^^^^^^^^^^^^^^^ help: try: `(*p).is_none()`
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.fixed
index 08d83f87e4c3..c8e18e8676f2 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.fixed
@@ -13,10 +13,13 @@ use std::task::Poll::{self, Pending, Ready};
 
 fn main() {
     if Pending::<()>.is_pending() {}
+    //~^ redundant_pattern_matching
 
     if Ready(42).is_ready() {}
+    //~^ redundant_pattern_matching
 
     if Ready(42).is_ready() {
+        //~^ redundant_pattern_matching
         foo();
     } else {
         bar();
@@ -24,15 +27,20 @@ fn main() {
 
     // Issue 6459
     if Ready(42).is_ready() {}
+    //~^ redundant_pattern_matching
 
     // Issue 6459
     if Pending::<()>.is_pending() {}
+    //~^ redundant_pattern_matching
 
     while Ready(42).is_ready() {}
+    //~^ redundant_pattern_matching
 
     while Ready(42).is_pending() {}
+    //~^ redundant_pattern_matching
 
     while Pending::<()>.is_pending() {}
+    //~^ redundant_pattern_matching
 
     if Pending::<i32>.is_pending() {}
 
@@ -46,12 +54,15 @@ fn main() {
 
     let poll = Ready(false);
     let _ = if poll.is_ready() { true } else { false };
+    //~^ redundant_pattern_matching
 
     poll_const();
 
     let _ = if gen_poll().is_ready() {
+        //~^ redundant_pattern_matching
         1
     } else if gen_poll().is_pending() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
@@ -68,12 +79,16 @@ fn bar() {}
 
 const fn poll_const() {
     if Ready(42).is_ready() {}
+    //~^ redundant_pattern_matching
 
     if Pending::<()>.is_pending() {}
+    //~^ redundant_pattern_matching
 
     while Ready(42).is_ready() {}
+    //~^ redundant_pattern_matching
 
     while Pending::<()>.is_pending() {}
+    //~^ redundant_pattern_matching
 
     Ready(42).is_ready();
 
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.rs
index 7bc2b3be4d34..727503d21a54 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.rs
@@ -13,10 +13,13 @@ use std::task::Poll::{self, Pending, Ready};
 
 fn main() {
     if let Pending = Pending::<()> {}
+    //~^ redundant_pattern_matching
 
     if let Ready(_) = Ready(42) {}
+    //~^ redundant_pattern_matching
 
     if let Ready(_) = Ready(42) {
+        //~^ redundant_pattern_matching
         foo();
     } else {
         bar();
@@ -24,43 +27,54 @@ fn main() {
 
     // Issue 6459
     if matches!(Ready(42), Ready(_)) {}
+    //~^ redundant_pattern_matching
 
     // Issue 6459
     if matches!(Pending::<()>, Pending) {}
+    //~^ redundant_pattern_matching
 
     while let Ready(_) = Ready(42) {}
+    //~^ redundant_pattern_matching
 
     while let Pending = Ready(42) {}
+    //~^ redundant_pattern_matching
 
     while let Pending = Pending::<()> {}
+    //~^ redundant_pattern_matching
 
     if Pending::<i32>.is_pending() {}
 
     if Ready(42).is_ready() {}
 
     match Ready(42) {
+        //~^ redundant_pattern_matching
         Ready(_) => true,
         Pending => false,
     };
 
     match Pending::<()> {
+        //~^ redundant_pattern_matching
         Ready(_) => false,
         Pending => true,
     };
 
     let _ = match Pending::<()> {
+        //~^ redundant_pattern_matching
         Ready(_) => false,
         Pending => true,
     };
 
     let poll = Ready(false);
     let _ = if let Ready(_) = poll { true } else { false };
+    //~^ redundant_pattern_matching
 
     poll_const();
 
     let _ = if let Ready(_) = gen_poll() {
+        //~^ redundant_pattern_matching
         1
     } else if let Pending = gen_poll() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
@@ -77,19 +91,25 @@ fn bar() {}
 
 const fn poll_const() {
     if let Ready(_) = Ready(42) {}
+    //~^ redundant_pattern_matching
 
     if let Pending = Pending::<()> {}
+    //~^ redundant_pattern_matching
 
     while let Ready(_) = Ready(42) {}
+    //~^ redundant_pattern_matching
 
     while let Pending = Pending::<()> {}
+    //~^ redundant_pattern_matching
 
     match Ready(42) {
+        //~^ redundant_pattern_matching
         Ready(_) => true,
         Pending => false,
     };
 
     match Pending::<()> {
+        //~^ redundant_pattern_matching
         Ready(_) => false,
         Pending => true,
     };
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.stderr
index 2b0f087fb993..5f659184f7b3 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_poll.stderr
@@ -8,130 +8,135 @@ LL |     if let Pending = Pending::<()> {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:17:12
+  --> tests/ui/redundant_pattern_matching_poll.rs:18:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:19:12
+  --> tests/ui/redundant_pattern_matching_poll.rs:21:12
    |
 LL |     if let Ready(_) = Ready(42) {
    |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:26:8
+  --> tests/ui/redundant_pattern_matching_poll.rs:29:8
    |
 LL |     if matches!(Ready(42), Ready(_)) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:29:8
+  --> tests/ui/redundant_pattern_matching_poll.rs:33:8
    |
 LL |     if matches!(Pending::<()>, Pending) {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:31:15
+  --> tests/ui/redundant_pattern_matching_poll.rs:36:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:33:15
+  --> tests/ui/redundant_pattern_matching_poll.rs:39:15
    |
 LL |     while let Pending = Ready(42) {}
    |     ----------^^^^^^^------------ help: try: `while Ready(42).is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:35:15
+  --> tests/ui/redundant_pattern_matching_poll.rs:42:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:41:5
+  --> tests/ui/redundant_pattern_matching_poll.rs:49:5
    |
 LL | /     match Ready(42) {
+LL | |
 LL | |         Ready(_) => true,
 LL | |         Pending => false,
 LL | |     };
    | |_____^ help: try: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:46:5
+  --> tests/ui/redundant_pattern_matching_poll.rs:55:5
    |
 LL | /     match Pending::<()> {
+LL | |
 LL | |         Ready(_) => false,
 LL | |         Pending => true,
 LL | |     };
    | |_____^ help: try: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:51:13
+  --> tests/ui/redundant_pattern_matching_poll.rs:61:13
    |
 LL |       let _ = match Pending::<()> {
    |  _____________^
+LL | |
 LL | |         Ready(_) => false,
 LL | |         Pending => true,
 LL | |     };
    | |_____^ help: try: `Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:57:20
+  --> tests/ui/redundant_pattern_matching_poll.rs:68:20
    |
 LL |     let _ = if let Ready(_) = poll { true } else { false };
    |             -------^^^^^^^^------- help: try: `if poll.is_ready()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:61:20
+  --> tests/ui/redundant_pattern_matching_poll.rs:73:20
    |
 LL |     let _ = if let Ready(_) = gen_poll() {
    |             -------^^^^^^^^------------- help: try: `if gen_poll().is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:63:19
+  --> tests/ui/redundant_pattern_matching_poll.rs:76:19
    |
 LL |     } else if let Pending = gen_poll() {
    |            -------^^^^^^^------------- help: try: `if gen_poll().is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:79:12
+  --> tests/ui/redundant_pattern_matching_poll.rs:93:12
    |
 LL |     if let Ready(_) = Ready(42) {}
    |     -------^^^^^^^^------------ help: try: `if Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:81:12
+  --> tests/ui/redundant_pattern_matching_poll.rs:96:12
    |
 LL |     if let Pending = Pending::<()> {}
    |     -------^^^^^^^---------------- help: try: `if Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:83:15
+  --> tests/ui/redundant_pattern_matching_poll.rs:99:15
    |
 LL |     while let Ready(_) = Ready(42) {}
    |     ----------^^^^^^^^------------ help: try: `while Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:85:15
+  --> tests/ui/redundant_pattern_matching_poll.rs:102:15
    |
 LL |     while let Pending = Pending::<()> {}
    |     ----------^^^^^^^---------------- help: try: `while Pending::<()>.is_pending()`
 
 error: redundant pattern matching, consider using `is_ready()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:87:5
+  --> tests/ui/redundant_pattern_matching_poll.rs:105:5
    |
 LL | /     match Ready(42) {
+LL | |
 LL | |         Ready(_) => true,
 LL | |         Pending => false,
 LL | |     };
    | |_____^ help: try: `Ready(42).is_ready()`
 
 error: redundant pattern matching, consider using `is_pending()`
-  --> tests/ui/redundant_pattern_matching_poll.rs:92:5
+  --> tests/ui/redundant_pattern_matching_poll.rs:111:5
    |
 LL | /     match Pending::<()> {
+LL | |
 LL | |         Ready(_) => false,
 LL | |         Pending => true,
 LL | |     };
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed
index 9571aaee7424..115879608314 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.fixed
@@ -13,14 +13,19 @@
 fn main() {
     let result: Result<usize, usize> = Err(5);
     if result.is_ok() {}
+    //~^ redundant_pattern_matching
 
     if Ok::<i32, i32>(42).is_ok() {}
+    //~^ redundant_pattern_matching
 
     if Err::<i32, i32>(42).is_err() {}
+    //~^ redundant_pattern_matching
 
     while Ok::<i32, i32>(10).is_ok() {}
+    //~^ redundant_pattern_matching
 
     while Ok::<i32, i32>(10).is_err() {}
+    //~^ redundant_pattern_matching
 
     if Ok::<i32, i32>(42).is_ok() {}
 
@@ -39,6 +44,7 @@ fn main() {
     Err::<i32, i32>(42).is_ok();
 
     let _ = if Ok::<usize, ()>(4).is_ok() { true } else { false };
+    //~^ redundant_pattern_matching
 
     issue5504();
     issue6067();
@@ -47,8 +53,10 @@ fn main() {
     issue10803();
 
     let _ = if gen_res().is_ok() {
+        //~^ redundant_pattern_matching
         1
     } else if gen_res().is_err() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
@@ -72,14 +80,18 @@ fn issue5504() {
 
     fn try_result_opt() -> Result<i32, i32> {
         while r#try!(result_opt()).is_some() {}
+        //~^ redundant_pattern_matching
         if r#try!(result_opt()).is_some() {}
+        //~^ redundant_pattern_matching
         Ok(42)
     }
 
     try_result_opt();
 
     if m!().is_some() {}
+    //~^ redundant_pattern_matching
     while m!().is_some() {}
+    //~^ redundant_pattern_matching
 }
 
 fn issue6065() {
@@ -98,12 +110,16 @@ fn issue6065() {
 // so the following should be linted.
 const fn issue6067() {
     if Ok::<i32, i32>(42).is_ok() {}
+    //~^ redundant_pattern_matching
 
     if Err::<i32, i32>(42).is_err() {}
+    //~^ redundant_pattern_matching
 
     while Ok::<i32, i32>(10).is_ok() {}
+    //~^ redundant_pattern_matching
 
     while Ok::<i32, i32>(10).is_err() {}
+    //~^ redundant_pattern_matching
 
     Ok::<i32, i32>(42).is_ok();
 
@@ -139,8 +155,10 @@ fn issue10803() {
     let x: Result<i32, i32> = Ok(42);
 
     let _ = x.is_ok();
+    //~^ redundant_pattern_matching
 
     let _ = x.is_err();
+    //~^ redundant_pattern_matching
 
     // Don't lint
     let _ = matches!(x, Ok(16));
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs
index 4fc65aa70b54..35f8f91b3152 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.rs
@@ -13,14 +13,19 @@
 fn main() {
     let result: Result<usize, usize> = Err(5);
     if let Ok(_) = &result {}
+    //~^ redundant_pattern_matching
 
     if let Ok(_) = Ok::<i32, i32>(42) {}
+    //~^ redundant_pattern_matching
 
     if let Err(_) = Err::<i32, i32>(42) {}
+    //~^ redundant_pattern_matching
 
     while let Ok(_) = Ok::<i32, i32>(10) {}
+    //~^ redundant_pattern_matching
 
     while let Err(_) = Ok::<i32, i32>(10) {}
+    //~^ redundant_pattern_matching
 
     if Ok::<i32, i32>(42).is_ok() {}
 
@@ -31,26 +36,31 @@ fn main() {
     }
 
     match Ok::<i32, i32>(42) {
+        //~^ redundant_pattern_matching
         Ok(_) => true,
         Err(_) => false,
     };
 
     match Ok::<i32, i32>(42) {
+        //~^ redundant_pattern_matching
         Ok(_) => false,
         Err(_) => true,
     };
 
     match Err::<i32, i32>(42) {
+        //~^ redundant_pattern_matching
         Ok(_) => false,
         Err(_) => true,
     };
 
     match Err::<i32, i32>(42) {
+        //~^ redundant_pattern_matching
         Ok(_) => true,
         Err(_) => false,
     };
 
     let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
+    //~^ redundant_pattern_matching
 
     issue5504();
     issue6067();
@@ -59,8 +69,10 @@ fn main() {
     issue10803();
 
     let _ = if let Ok(_) = gen_res() {
+        //~^ redundant_pattern_matching
         1
     } else if let Err(_) = gen_res() {
+        //~^ redundant_pattern_matching
         2
     } else {
         3
@@ -84,14 +96,18 @@ fn issue5504() {
 
     fn try_result_opt() -> Result<i32, i32> {
         while let Some(_) = r#try!(result_opt()) {}
+        //~^ redundant_pattern_matching
         if let Some(_) = r#try!(result_opt()) {}
+        //~^ redundant_pattern_matching
         Ok(42)
     }
 
     try_result_opt();
 
     if let Some(_) = m!() {}
+    //~^ redundant_pattern_matching
     while let Some(_) = m!() {}
+    //~^ redundant_pattern_matching
 }
 
 fn issue6065() {
@@ -110,19 +126,25 @@ fn issue6065() {
 // so the following should be linted.
 const fn issue6067() {
     if let Ok(_) = Ok::<i32, i32>(42) {}
+    //~^ redundant_pattern_matching
 
     if let Err(_) = Err::<i32, i32>(42) {}
+    //~^ redundant_pattern_matching
 
     while let Ok(_) = Ok::<i32, i32>(10) {}
+    //~^ redundant_pattern_matching
 
     while let Err(_) = Ok::<i32, i32>(10) {}
+    //~^ redundant_pattern_matching
 
     match Ok::<i32, i32>(42) {
+        //~^ redundant_pattern_matching
         Ok(_) => true,
         Err(_) => false,
     };
 
     match Err::<i32, i32>(42) {
+        //~^ redundant_pattern_matching
         Ok(_) => false,
         Err(_) => true,
     };
@@ -133,21 +155,25 @@ fn issue10726() {
     let x: Result<i32, i32> = Ok(42);
 
     match x {
+        //~^ redundant_pattern_matching
         Ok(_) => true,
         _ => false,
     };
 
     match x {
+        //~^ redundant_pattern_matching
         Ok(_) => false,
         _ => true,
     };
 
     match x {
+        //~^ redundant_pattern_matching
         Err(_) => true,
         _ => false,
     };
 
     match x {
+        //~^ redundant_pattern_matching
         Err(_) => false,
         _ => true,
     };
@@ -169,8 +195,10 @@ fn issue10803() {
     let x: Result<i32, i32> = Ok(42);
 
     let _ = matches!(x, Ok(_));
+    //~^ redundant_pattern_matching
 
     let _ = matches!(x, Err(_));
+    //~^ redundant_pattern_matching
 
     // Don't lint
     let _ = matches!(x, Ok(16));
diff --git a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr
index 991e6225ecb6..4f78b95356c2 100644
--- a/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pattern_matching_result.stderr
@@ -8,193 +8,203 @@ LL |     if let Ok(_) = &result {}
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pattern_matching)]`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:17:12
+  --> tests/ui/redundant_pattern_matching_result.rs:18:12
    |
 LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
    |     -------^^^^^--------------------- help: try: `if Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:19:12
+  --> tests/ui/redundant_pattern_matching_result.rs:21:12
    |
 LL |     if let Err(_) = Err::<i32, i32>(42) {}
    |     -------^^^^^^---------------------- help: try: `if Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:21:15
+  --> tests/ui/redundant_pattern_matching_result.rs:24:15
    |
 LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:23:15
+  --> tests/ui/redundant_pattern_matching_result.rs:27:15
    |
 LL |     while let Err(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:33:5
+  --> tests/ui/redundant_pattern_matching_result.rs:38:5
    |
 LL | /     match Ok::<i32, i32>(42) {
+LL | |
 LL | |         Ok(_) => true,
 LL | |         Err(_) => false,
 LL | |     };
    | |_____^ help: try: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:38:5
+  --> tests/ui/redundant_pattern_matching_result.rs:44:5
    |
 LL | /     match Ok::<i32, i32>(42) {
+LL | |
 LL | |         Ok(_) => false,
 LL | |         Err(_) => true,
 LL | |     };
    | |_____^ help: try: `Ok::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:43:5
+  --> tests/ui/redundant_pattern_matching_result.rs:50:5
    |
 LL | /     match Err::<i32, i32>(42) {
+LL | |
 LL | |         Ok(_) => false,
 LL | |         Err(_) => true,
 LL | |     };
    | |_____^ help: try: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:48:5
+  --> tests/ui/redundant_pattern_matching_result.rs:56:5
    |
 LL | /     match Err::<i32, i32>(42) {
+LL | |
 LL | |         Ok(_) => true,
 LL | |         Err(_) => false,
 LL | |     };
    | |_____^ help: try: `Err::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:53:20
+  --> tests/ui/redundant_pattern_matching_result.rs:62:20
    |
 LL |     let _ = if let Ok(_) = Ok::<usize, ()>(4) { true } else { false };
    |             -------^^^^^--------------------- help: try: `if Ok::<usize, ()>(4).is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:61:20
+  --> tests/ui/redundant_pattern_matching_result.rs:71:20
    |
 LL |     let _ = if let Ok(_) = gen_res() {
    |             -------^^^^^------------ help: try: `if gen_res().is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:63:19
+  --> tests/ui/redundant_pattern_matching_result.rs:74:19
    |
 LL |     } else if let Err(_) = gen_res() {
    |            -------^^^^^^------------ help: try: `if gen_res().is_err()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_result.rs:86:19
+  --> tests/ui/redundant_pattern_matching_result.rs:98:19
    |
 LL |         while let Some(_) = r#try!(result_opt()) {}
    |         ----------^^^^^^^----------------------- help: try: `while r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_result.rs:87:16
+  --> tests/ui/redundant_pattern_matching_result.rs:100:16
    |
 LL |         if let Some(_) = r#try!(result_opt()) {}
    |         -------^^^^^^^----------------------- help: try: `if r#try!(result_opt()).is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_result.rs:93:12
+  --> tests/ui/redundant_pattern_matching_result.rs:107:12
    |
 LL |     if let Some(_) = m!() {}
    |     -------^^^^^^^------- help: try: `if m!().is_some()`
 
 error: redundant pattern matching, consider using `is_some()`
-  --> tests/ui/redundant_pattern_matching_result.rs:94:15
+  --> tests/ui/redundant_pattern_matching_result.rs:109:15
    |
 LL |     while let Some(_) = m!() {}
    |     ----------^^^^^^^------- help: try: `while m!().is_some()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:112:12
+  --> tests/ui/redundant_pattern_matching_result.rs:128:12
    |
 LL |     if let Ok(_) = Ok::<i32, i32>(42) {}
    |     -------^^^^^--------------------- help: try: `if Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:114:12
+  --> tests/ui/redundant_pattern_matching_result.rs:131:12
    |
 LL |     if let Err(_) = Err::<i32, i32>(42) {}
    |     -------^^^^^^---------------------- help: try: `if Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:116:15
+  --> tests/ui/redundant_pattern_matching_result.rs:134:15
    |
 LL |     while let Ok(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:118:15
+  --> tests/ui/redundant_pattern_matching_result.rs:137:15
    |
 LL |     while let Err(_) = Ok::<i32, i32>(10) {}
    |     ----------^^^^^^--------------------- help: try: `while Ok::<i32, i32>(10).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:120:5
+  --> tests/ui/redundant_pattern_matching_result.rs:140:5
    |
 LL | /     match Ok::<i32, i32>(42) {
+LL | |
 LL | |         Ok(_) => true,
 LL | |         Err(_) => false,
 LL | |     };
    | |_____^ help: try: `Ok::<i32, i32>(42).is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:125:5
+  --> tests/ui/redundant_pattern_matching_result.rs:146:5
    |
 LL | /     match Err::<i32, i32>(42) {
+LL | |
 LL | |         Ok(_) => false,
 LL | |         Err(_) => true,
 LL | |     };
    | |_____^ help: try: `Err::<i32, i32>(42).is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:135:5
+  --> tests/ui/redundant_pattern_matching_result.rs:157:5
    |
 LL | /     match x {
+LL | |
 LL | |         Ok(_) => true,
 LL | |         _ => false,
 LL | |     };
    | |_____^ help: try: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:140:5
+  --> tests/ui/redundant_pattern_matching_result.rs:163:5
    |
 LL | /     match x {
+LL | |
 LL | |         Ok(_) => false,
 LL | |         _ => true,
 LL | |     };
    | |_____^ help: try: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:145:5
+  --> tests/ui/redundant_pattern_matching_result.rs:169:5
    |
 LL | /     match x {
+LL | |
 LL | |         Err(_) => true,
 LL | |         _ => false,
 LL | |     };
    | |_____^ help: try: `x.is_err()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:150:5
+  --> tests/ui/redundant_pattern_matching_result.rs:175:5
    |
 LL | /     match x {
+LL | |
 LL | |         Err(_) => false,
 LL | |         _ => true,
 LL | |     };
    | |_____^ help: try: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_ok()`
-  --> tests/ui/redundant_pattern_matching_result.rs:171:13
+  --> tests/ui/redundant_pattern_matching_result.rs:197:13
    |
 LL |     let _ = matches!(x, Ok(_));
    |             ^^^^^^^^^^^^^^^^^^ help: try: `x.is_ok()`
 
 error: redundant pattern matching, consider using `is_err()`
-  --> tests/ui/redundant_pattern_matching_result.rs:173:13
+  --> tests/ui/redundant_pattern_matching_result.rs:200:13
    |
 LL |     let _ = matches!(x, Err(_));
    |             ^^^^^^^^^^^^^^^^^^^ help: try: `x.is_err()`
diff --git a/src/tools/clippy/tests/ui/redundant_pub_crate.fixed b/src/tools/clippy/tests/ui/redundant_pub_crate.fixed
index 8882a4d50a5f..a6450123f4c9 100644
--- a/src/tools/clippy/tests/ui/redundant_pub_crate.fixed
+++ b/src/tools/clippy/tests/ui/redundant_pub_crate.fixed
@@ -5,24 +5,33 @@
 mod m1 {
     fn f() {}
     pub fn g() {} // private due to m1
+    //
+    //~^^ redundant_pub_crate
     pub fn h() {}
 
     mod m1_1 {
         fn f() {}
         pub fn g() {} // private due to m1_1 and m1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub mod m1_2 {
+        //~^ redundant_pub_crate
         //:^ private due to m1
         fn f() {}
         pub fn g() {} // private due to m1_2 and m1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub mod m1_3 {
         fn f() {}
         pub fn g() {} // private due to m1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 }
@@ -30,24 +39,33 @@ mod m1 {
 pub(crate) mod m2 {
     fn f() {}
     pub fn g() {} // already crate visible due to m2
+    //
+    //~^^ redundant_pub_crate
     pub fn h() {}
 
     mod m2_1 {
         fn f() {}
         pub fn g() {} // private due to m2_1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub mod m2_2 {
+        //~^ redundant_pub_crate
         //:^ already crate visible due to m2
         fn f() {}
         pub fn g() {} // already crate visible due to m2_2 and m2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub mod m2_3 {
         fn f() {}
         pub fn g() {} // already crate visible due to m2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 }
@@ -60,6 +78,8 @@ pub mod m3 {
     mod m3_1 {
         fn f() {}
         pub fn g() {} // private due to m3_1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
@@ -67,6 +87,8 @@ pub mod m3 {
         //:^ ok
         fn f() {}
         pub fn g() {} // already crate visible due to m3_2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
@@ -80,18 +102,25 @@ pub mod m3 {
 mod m4 {
     fn f() {}
     pub fn g() {} // private: not re-exported by `pub use m4::*`
+    //
+    //~^^ redundant_pub_crate
     pub fn h() {}
 
     mod m4_1 {
         fn f() {}
         pub fn g() {} // private due to m4_1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub mod m4_2 {
+        //~^ redundant_pub_crate
         //:^ private: not re-exported by `pub use m4::*`
         fn f() {}
         pub fn g() {} // private due to m4_2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
diff --git a/src/tools/clippy/tests/ui/redundant_pub_crate.rs b/src/tools/clippy/tests/ui/redundant_pub_crate.rs
index 5c8cab9be161..7415d34d50cc 100644
--- a/src/tools/clippy/tests/ui/redundant_pub_crate.rs
+++ b/src/tools/clippy/tests/ui/redundant_pub_crate.rs
@@ -5,24 +5,33 @@
 mod m1 {
     fn f() {}
     pub(crate) fn g() {} // private due to m1
+    //
+    //~^^ redundant_pub_crate
     pub fn h() {}
 
     mod m1_1 {
         fn f() {}
         pub(crate) fn g() {} // private due to m1_1 and m1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub(crate) mod m1_2 {
+        //~^ redundant_pub_crate
         //:^ private due to m1
         fn f() {}
         pub(crate) fn g() {} // private due to m1_2 and m1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub mod m1_3 {
         fn f() {}
         pub(crate) fn g() {} // private due to m1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 }
@@ -30,24 +39,33 @@ mod m1 {
 pub(crate) mod m2 {
     fn f() {}
     pub(crate) fn g() {} // already crate visible due to m2
+    //
+    //~^^ redundant_pub_crate
     pub fn h() {}
 
     mod m2_1 {
         fn f() {}
         pub(crate) fn g() {} // private due to m2_1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub(crate) mod m2_2 {
+        //~^ redundant_pub_crate
         //:^ already crate visible due to m2
         fn f() {}
         pub(crate) fn g() {} // already crate visible due to m2_2 and m2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub mod m2_3 {
         fn f() {}
         pub(crate) fn g() {} // already crate visible due to m2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 }
@@ -60,6 +78,8 @@ pub mod m3 {
     mod m3_1 {
         fn f() {}
         pub(crate) fn g() {} // private due to m3_1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
@@ -67,6 +87,8 @@ pub mod m3 {
         //:^ ok
         fn f() {}
         pub(crate) fn g() {} // already crate visible due to m3_2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
@@ -80,18 +102,25 @@ pub mod m3 {
 mod m4 {
     fn f() {}
     pub(crate) fn g() {} // private: not re-exported by `pub use m4::*`
+    //
+    //~^^ redundant_pub_crate
     pub fn h() {}
 
     mod m4_1 {
         fn f() {}
         pub(crate) fn g() {} // private due to m4_1
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
     pub(crate) mod m4_2 {
+        //~^ redundant_pub_crate
         //:^ private: not re-exported by `pub use m4::*`
         fn f() {}
         pub(crate) fn g() {} // private due to m4_2
+        //
+        //~^^ redundant_pub_crate
         pub fn h() {}
     }
 
diff --git a/src/tools/clippy/tests/ui/redundant_pub_crate.stderr b/src/tools/clippy/tests/ui/redundant_pub_crate.stderr
index 699e19b1abcf..95909ea8b066 100644
--- a/src/tools/clippy/tests/ui/redundant_pub_crate.stderr
+++ b/src/tools/clippy/tests/ui/redundant_pub_crate.stderr
@@ -10,7 +10,7 @@ LL |     pub(crate) fn g() {} // private due to m1
    = help: to override `-D warnings` add `#[allow(clippy::redundant_pub_crate)]`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:12:9
+  --> tests/ui/redundant_pub_crate.rs:14:9
    |
 LL |         pub(crate) fn g() {} // private due to m1_1 and m1
    |         ----------^^^^^
@@ -18,7 +18,7 @@ LL |         pub(crate) fn g() {} // private due to m1_1 and m1
    |         help: consider using: `pub`
 
 error: pub(crate) module inside private module
-  --> tests/ui/redundant_pub_crate.rs:16:5
+  --> tests/ui/redundant_pub_crate.rs:20:5
    |
 LL |     pub(crate) mod m1_2 {
    |     ----------^^^^^^^^^
@@ -26,7 +26,7 @@ LL |     pub(crate) mod m1_2 {
    |     help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:19:9
+  --> tests/ui/redundant_pub_crate.rs:24:9
    |
 LL |         pub(crate) fn g() {} // private due to m1_2 and m1
    |         ----------^^^^^
@@ -34,7 +34,7 @@ LL |         pub(crate) fn g() {} // private due to m1_2 and m1
    |         help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:25:9
+  --> tests/ui/redundant_pub_crate.rs:32:9
    |
 LL |         pub(crate) fn g() {} // private due to m1
    |         ----------^^^^^
@@ -42,7 +42,7 @@ LL |         pub(crate) fn g() {} // private due to m1
    |         help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:32:5
+  --> tests/ui/redundant_pub_crate.rs:41:5
    |
 LL |     pub(crate) fn g() {} // already crate visible due to m2
    |     ----------^^^^^
@@ -50,7 +50,7 @@ LL |     pub(crate) fn g() {} // already crate visible due to m2
    |     help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:37:9
+  --> tests/ui/redundant_pub_crate.rs:48:9
    |
 LL |         pub(crate) fn g() {} // private due to m2_1
    |         ----------^^^^^
@@ -58,7 +58,7 @@ LL |         pub(crate) fn g() {} // private due to m2_1
    |         help: consider using: `pub`
 
 error: pub(crate) module inside private module
-  --> tests/ui/redundant_pub_crate.rs:41:5
+  --> tests/ui/redundant_pub_crate.rs:54:5
    |
 LL |     pub(crate) mod m2_2 {
    |     ----------^^^^^^^^^
@@ -66,7 +66,7 @@ LL |     pub(crate) mod m2_2 {
    |     help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:44:9
+  --> tests/ui/redundant_pub_crate.rs:58:9
    |
 LL |         pub(crate) fn g() {} // already crate visible due to m2_2 and m2
    |         ----------^^^^^
@@ -74,7 +74,7 @@ LL |         pub(crate) fn g() {} // already crate visible due to m2_2 and m2
    |         help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:50:9
+  --> tests/ui/redundant_pub_crate.rs:66:9
    |
 LL |         pub(crate) fn g() {} // already crate visible due to m2
    |         ----------^^^^^
@@ -82,7 +82,7 @@ LL |         pub(crate) fn g() {} // already crate visible due to m2
    |         help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:62:9
+  --> tests/ui/redundant_pub_crate.rs:80:9
    |
 LL |         pub(crate) fn g() {} // private due to m3_1
    |         ----------^^^^^
@@ -90,7 +90,7 @@ LL |         pub(crate) fn g() {} // private due to m3_1
    |         help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:69:9
+  --> tests/ui/redundant_pub_crate.rs:89:9
    |
 LL |         pub(crate) fn g() {} // already crate visible due to m3_2
    |         ----------^^^^^
@@ -98,7 +98,7 @@ LL |         pub(crate) fn g() {} // already crate visible due to m3_2
    |         help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:82:5
+  --> tests/ui/redundant_pub_crate.rs:104:5
    |
 LL |     pub(crate) fn g() {} // private: not re-exported by `pub use m4::*`
    |     ----------^^^^^
@@ -106,7 +106,7 @@ LL |     pub(crate) fn g() {} // private: not re-exported by `pub use m4::*`
    |     help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:87:9
+  --> tests/ui/redundant_pub_crate.rs:111:9
    |
 LL |         pub(crate) fn g() {} // private due to m4_1
    |         ----------^^^^^
@@ -114,7 +114,7 @@ LL |         pub(crate) fn g() {} // private due to m4_1
    |         help: consider using: `pub`
 
 error: pub(crate) module inside private module
-  --> tests/ui/redundant_pub_crate.rs:91:5
+  --> tests/ui/redundant_pub_crate.rs:117:5
    |
 LL |     pub(crate) mod m4_2 {
    |     ----------^^^^^^^^^
@@ -122,7 +122,7 @@ LL |     pub(crate) mod m4_2 {
    |     help: consider using: `pub`
 
 error: pub(crate) function inside private module
-  --> tests/ui/redundant_pub_crate.rs:94:9
+  --> tests/ui/redundant_pub_crate.rs:121:9
    |
 LL |         pub(crate) fn g() {} // private due to m4_2
    |         ----------^^^^^
diff --git a/src/tools/clippy/tests/ui/redundant_slicing.fixed b/src/tools/clippy/tests/ui/redundant_slicing.fixed
index a4c035ba8407..385a5d97cf1a 100644
--- a/src/tools/clippy/tests/ui/redundant_slicing.fixed
+++ b/src/tools/clippy/tests/ui/redundant_slicing.fixed
@@ -6,10 +6,14 @@ use std::io::Read;
 fn main() {
     let slice: &[u32] = &[0];
     let _ = slice; // Redundant slice
+    //
+    //~^^ redundant_slicing
 
     let v = vec![0];
     let _ = &v[..]; // Ok, results in `&[_]`
     let _ = (&*v); // Outer borrow is redundant
+    //
+    //~^^ redundant_slicing
 
     static S: &[u8] = &[0, 1, 2];
     let _ = &mut &S[..]; // Ok, re-borrows slice
@@ -27,6 +31,7 @@ fn main() {
         };
     }
     let _ = slice;
+    //~^ redundant_slicing
 
     macro_rules! m2 {
         ($e:expr) => {
diff --git a/src/tools/clippy/tests/ui/redundant_slicing.rs b/src/tools/clippy/tests/ui/redundant_slicing.rs
index 67fe702acf54..04f181da250d 100644
--- a/src/tools/clippy/tests/ui/redundant_slicing.rs
+++ b/src/tools/clippy/tests/ui/redundant_slicing.rs
@@ -6,10 +6,14 @@ use std::io::Read;
 fn main() {
     let slice: &[u32] = &[0];
     let _ = &slice[..]; // Redundant slice
+    //
+    //~^^ redundant_slicing
 
     let v = vec![0];
     let _ = &v[..]; // Ok, results in `&[_]`
     let _ = &(&*v)[..]; // Outer borrow is redundant
+    //
+    //~^^ redundant_slicing
 
     static S: &[u8] = &[0, 1, 2];
     let _ = &mut &S[..]; // Ok, re-borrows slice
@@ -27,6 +31,7 @@ fn main() {
         };
     }
     let _ = &m!(slice)[..];
+    //~^ redundant_slicing
 
     macro_rules! m2 {
         ($e:expr) => {
diff --git a/src/tools/clippy/tests/ui/redundant_slicing.stderr b/src/tools/clippy/tests/ui/redundant_slicing.stderr
index 269a597b3226..964111bccf88 100644
--- a/src/tools/clippy/tests/ui/redundant_slicing.stderr
+++ b/src/tools/clippy/tests/ui/redundant_slicing.stderr
@@ -8,13 +8,13 @@ LL |     let _ = &slice[..]; // Redundant slice
    = help: to override `-D warnings` add `#[allow(clippy::redundant_slicing)]`
 
 error: redundant slicing of the whole range
-  --> tests/ui/redundant_slicing.rs:12:13
+  --> tests/ui/redundant_slicing.rs:14:13
    |
 LL |     let _ = &(&*v)[..]; // Outer borrow is redundant
    |             ^^^^^^^^^^ help: use the original value instead: `(&*v)`
 
 error: redundant slicing of the whole range
-  --> tests/ui/redundant_slicing.rs:29:13
+  --> tests/ui/redundant_slicing.rs:33:13
    |
 LL |     let _ = &m!(slice)[..];
    |             ^^^^^^^^^^^^^^ help: use the original value instead: `slice`
diff --git a/src/tools/clippy/tests/ui/redundant_static_lifetimes.fixed b/src/tools/clippy/tests/ui/redundant_static_lifetimes.fixed
index 3d1c78bd12d9..86c6ca17eb20 100644
--- a/src/tools/clippy/tests/ui/redundant_static_lifetimes.fixed
+++ b/src/tools/clippy/tests/ui/redundant_static_lifetimes.fixed
@@ -6,40 +6,57 @@
 struct Foo;
 
 const VAR_ONE: &str = "Test constant #1"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 const VAR_TWO: &str = "Test constant #2"; // This line should not raise a warning.
 
 const VAR_THREE: &[&str] = &["one", "two"]; // ERROR: Consider removing 'static
+//~^ redundant_static_lifetimes
 
 const VAR_FOUR: (&str, (&str, &str), &str) = ("on", ("th", "th"), "on"); // ERROR: Consider removing 'static
+//~^ redundant_static_lifetimes
+//~| redundant_static_lifetimes
 
 const VAR_SIX: &u8 = &5;
+//~^ redundant_static_lifetimes
 
 const VAR_HEIGHT: &Foo = &Foo {};
+//~^ redundant_static_lifetimes
 
 const VAR_SLICE: &[u8] = b"Test constant #1"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 const VAR_TUPLE: &(u8, u8) = &(1, 2); // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 const VAR_ARRAY: &[u8; 1] = b"T"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_ONE: &str = "Test static #1"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_TWO: &str = "Test static #2"; // This line should not raise a warning.
 
 static STATIC_VAR_THREE: &[&str] = &["one", "two"]; // ERROR: Consider removing 'static
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_SIX: &u8 = &5;
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_HEIGHT: &Foo = &Foo {};
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_SLICE: &[u8] = b"Test static #3"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_TUPLE: &(u8, u8) = &(1, 2); // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_ARRAY: &[u8; 1] = b"T"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static mut STATIC_MUT_SLICE: &mut [u32] = &mut [0];
+//~^ redundant_static_lifetimes
 
 fn main() {
     let false_positive: &'static str = "test";
@@ -69,4 +86,5 @@ fn msrv_1_16() {
 #[clippy::msrv = "1.17"]
 fn msrv_1_17() {
     static V: &u8 = &17;
+    //~^ redundant_static_lifetimes
 }
diff --git a/src/tools/clippy/tests/ui/redundant_static_lifetimes.rs b/src/tools/clippy/tests/ui/redundant_static_lifetimes.rs
index 5932f14b8d9a..6fefe6c232d2 100644
--- a/src/tools/clippy/tests/ui/redundant_static_lifetimes.rs
+++ b/src/tools/clippy/tests/ui/redundant_static_lifetimes.rs
@@ -6,40 +6,57 @@
 struct Foo;
 
 const VAR_ONE: &'static str = "Test constant #1"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 const VAR_TWO: &str = "Test constant #2"; // This line should not raise a warning.
 
 const VAR_THREE: &[&'static str] = &["one", "two"]; // ERROR: Consider removing 'static
+//~^ redundant_static_lifetimes
 
 const VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR: Consider removing 'static
+//~^ redundant_static_lifetimes
+//~| redundant_static_lifetimes
 
 const VAR_SIX: &'static u8 = &5;
+//~^ redundant_static_lifetimes
 
 const VAR_HEIGHT: &'static Foo = &Foo {};
+//~^ redundant_static_lifetimes
 
 const VAR_SLICE: &'static [u8] = b"Test constant #1"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 const VAR_TUPLE: &'static (u8, u8) = &(1, 2); // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 const VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_ONE: &'static str = "Test static #1"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_TWO: &str = "Test static #2"; // This line should not raise a warning.
 
 static STATIC_VAR_THREE: &[&'static str] = &["one", "two"]; // ERROR: Consider removing 'static
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_SIX: &'static u8 = &5;
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_HEIGHT: &'static Foo = &Foo {};
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_SLICE: &'static [u8] = b"Test static #3"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_TUPLE: &'static (u8, u8) = &(1, 2); // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static STATIC_VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR: Consider removing 'static.
+//~^ redundant_static_lifetimes
 
 static mut STATIC_MUT_SLICE: &'static mut [u32] = &mut [0];
+//~^ redundant_static_lifetimes
 
 fn main() {
     let false_positive: &'static str = "test";
@@ -69,4 +86,5 @@ fn msrv_1_16() {
 #[clippy::msrv = "1.17"]
 fn msrv_1_17() {
     static V: &'static u8 = &17;
+    //~^ redundant_static_lifetimes
 }
diff --git a/src/tools/clippy/tests/ui/redundant_static_lifetimes.stderr b/src/tools/clippy/tests/ui/redundant_static_lifetimes.stderr
index 48871eba2dc7..955882703955 100644
--- a/src/tools/clippy/tests/ui/redundant_static_lifetimes.stderr
+++ b/src/tools/clippy/tests/ui/redundant_static_lifetimes.stderr
@@ -8,103 +8,103 @@ LL | const VAR_ONE: &'static str = "Test constant #1"; // ERROR: Consider removi
    = help: to override `-D warnings` add `#[allow(clippy::redundant_static_lifetimes)]`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:12:21
+  --> tests/ui/redundant_static_lifetimes.rs:13:21
    |
 LL | const VAR_THREE: &[&'static str] = &["one", "two"]; // ERROR: Consider removing 'static
    |                    -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:14:32
+  --> tests/ui/redundant_static_lifetimes.rs:16:32
    |
 LL | const VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR: Consider removing 'static
    |                               -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:14:47
+  --> tests/ui/redundant_static_lifetimes.rs:16:47
    |
 LL | const VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR: Consider removing 'static
    |                                              -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:16:17
+  --> tests/ui/redundant_static_lifetimes.rs:20:17
    |
 LL | const VAR_SIX: &'static u8 = &5;
    |                -^^^^^^^--- help: consider removing `'static`: `&u8`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:18:20
+  --> tests/ui/redundant_static_lifetimes.rs:23:20
    |
 LL | const VAR_HEIGHT: &'static Foo = &Foo {};
    |                   -^^^^^^^---- help: consider removing `'static`: `&Foo`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:20:19
+  --> tests/ui/redundant_static_lifetimes.rs:26:19
    |
 LL | const VAR_SLICE: &'static [u8] = b"Test constant #1"; // ERROR: Consider removing 'static.
    |                  -^^^^^^^----- help: consider removing `'static`: `&[u8]`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:22:19
+  --> tests/ui/redundant_static_lifetimes.rs:29:19
    |
 LL | const VAR_TUPLE: &'static (u8, u8) = &(1, 2); // ERROR: Consider removing 'static.
    |                  -^^^^^^^--------- help: consider removing `'static`: `&(u8, u8)`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:24:19
+  --> tests/ui/redundant_static_lifetimes.rs:32:19
    |
 LL | const VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR: Consider removing 'static.
    |                  -^^^^^^^-------- help: consider removing `'static`: `&[u8; 1]`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:26:25
+  --> tests/ui/redundant_static_lifetimes.rs:35:25
    |
 LL | static STATIC_VAR_ONE: &'static str = "Test static #1"; // ERROR: Consider removing 'static.
    |                        -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:30:29
+  --> tests/ui/redundant_static_lifetimes.rs:40:29
    |
 LL | static STATIC_VAR_THREE: &[&'static str] = &["one", "two"]; // ERROR: Consider removing 'static
    |                            -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:32:25
+  --> tests/ui/redundant_static_lifetimes.rs:43:25
    |
 LL | static STATIC_VAR_SIX: &'static u8 = &5;
    |                        -^^^^^^^--- help: consider removing `'static`: `&u8`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:34:28
+  --> tests/ui/redundant_static_lifetimes.rs:46:28
    |
 LL | static STATIC_VAR_HEIGHT: &'static Foo = &Foo {};
    |                           -^^^^^^^---- help: consider removing `'static`: `&Foo`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:36:27
+  --> tests/ui/redundant_static_lifetimes.rs:49:27
    |
 LL | static STATIC_VAR_SLICE: &'static [u8] = b"Test static #3"; // ERROR: Consider removing 'static.
    |                          -^^^^^^^----- help: consider removing `'static`: `&[u8]`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:38:27
+  --> tests/ui/redundant_static_lifetimes.rs:52:27
    |
 LL | static STATIC_VAR_TUPLE: &'static (u8, u8) = &(1, 2); // ERROR: Consider removing 'static.
    |                          -^^^^^^^--------- help: consider removing `'static`: `&(u8, u8)`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:40:27
+  --> tests/ui/redundant_static_lifetimes.rs:55:27
    |
 LL | static STATIC_VAR_ARRAY: &'static [u8; 1] = b"T"; // ERROR: Consider removing 'static.
    |                          -^^^^^^^-------- help: consider removing `'static`: `&[u8; 1]`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:42:31
+  --> tests/ui/redundant_static_lifetimes.rs:58:31
    |
 LL | static mut STATIC_MUT_SLICE: &'static mut [u32] = &mut [0];
    |                              -^^^^^^^---------- help: consider removing `'static`: `&mut [u32]`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes.rs:71:16
+  --> tests/ui/redundant_static_lifetimes.rs:88:16
    |
 LL |     static V: &'static u8 = &17;
    |               -^^^^^^^--- help: consider removing `'static`: `&u8`
diff --git a/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.rs b/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.rs
index bfcab420b1f4..8cb6e4491842 100644
--- a/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.rs
+++ b/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.rs
@@ -2,24 +2,23 @@
 // these are rustfixable, but run-rustfix tests cannot handle them
 
 const VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR: Consider removing 'static
-//~^ ERROR: constants have by default a `'static` lifetime
-//~| NOTE: `-D clippy::redundant-static-lifetimes` implied by `-D warnings`
-//~| ERROR: constants have by default a `'static` lifetime
+//~^ redundant_static_lifetimes
+//~| redundant_static_lifetimes
 
 const VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
-//~^ ERROR: constants have by default a `'static` lifetime
-//~| ERROR: constants have by default a `'static` lifetime
+//~^ redundant_static_lifetimes
+//~| redundant_static_lifetimes
 
 static STATIC_VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR: Consider removing 'static
-//~^ ERROR: statics have by default a `'static` lifetime
-//~| ERROR: statics have by default a `'static` lifetime
+//~^ redundant_static_lifetimes
+//~| redundant_static_lifetimes
 
 static STATIC_VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR: Consider removing 'static
-//~^ ERROR: statics have by default a `'static` lifetime
-//~| ERROR: statics have by default a `'static` lifetime
+//~^ redundant_static_lifetimes
+//~| redundant_static_lifetimes
 
 static STATIC_VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
-//~^ ERROR: statics have by default a `'static` lifetime
-//~| ERROR: statics have by default a `'static` lifetime
+//~^ redundant_static_lifetimes
+//~| redundant_static_lifetimes
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.stderr b/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.stderr
index 330703d9eff1..aed16204f1c2 100644
--- a/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.stderr
+++ b/src/tools/clippy/tests/ui/redundant_static_lifetimes_multiple.stderr
@@ -14,49 +14,49 @@ LL | const VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]];
    |                             -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:9:29
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:8:29
    |
 LL | const VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
    |                            -^^^^^^^--------------- help: consider removing `'static`: `&[&'static str]`
 
 error: constants have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:9:39
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:8:39
    |
 LL | const VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
    |                                      -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:13:40
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:12:40
    |
 LL | static STATIC_VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR: Consider removing 'static
    |                                       -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:13:55
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:12:55
    |
 LL | static STATIC_VAR_FOUR: (&str, (&str, &'static str), &'static str) = ("on", ("th", "th"), "on"); // ERROR: Consider removing 'static
    |                                                      -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:17:26
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:16:26
    |
 LL | static STATIC_VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR: Consider removing 'static
    |                         -^^^^^^^------------------ help: consider removing `'static`: `&[&[&'static str]]`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:17:38
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:16:38
    |
 LL | static STATIC_VAR_FIVE: &'static [&[&'static str]] = &[&["test"], &["other one"]]; // ERROR: Consider removing 'static
    |                                     -^^^^^^^---- help: consider removing `'static`: `&str`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:21:37
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:20:37
    |
 LL | static STATIC_VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
    |                                    -^^^^^^^--------------- help: consider removing `'static`: `&[&'static str]`
 
 error: statics have by default a `'static` lifetime
-  --> tests/ui/redundant_static_lifetimes_multiple.rs:21:47
+  --> tests/ui/redundant_static_lifetimes_multiple.rs:20:47
    |
 LL | static STATIC_VAR_SEVEN: &[&(&str, &'static [&'static str])] = &[&("one", &["other one"])];
    |                                              -^^^^^^^---- help: consider removing `'static`: `&str`
diff --git a/src/tools/clippy/tests/ui/redundant_type_annotations.rs b/src/tools/clippy/tests/ui/redundant_type_annotations.rs
index dc9b073ffba8..55c19d194a49 100644
--- a/src/tools/clippy/tests/ui/redundant_type_annotations.rs
+++ b/src/tools/clippy/tests/ui/redundant_type_annotations.rs
@@ -79,12 +79,13 @@ impl Pie {
         // Everything here should be lint
 
         let v: u32 = self.return_an_int();
-        //~^ ERROR: redundant type annotation
-        //~| NOTE: `-D clippy::redundant-type-annotations` implied by `-D warnings`
+        //~^ redundant_type_annotations
+
         let v: &u32 = self.return_a_ref();
-        //~^ ERROR: redundant type annotation
+        //~^ redundant_type_annotations
+
         let v: &Slice = self.return_a_ref_to_struct();
-        //~^ ERROR: redundant type annotation
+        //~^ redundant_type_annotations
     }
 }
 
@@ -157,50 +158,50 @@ fn test_functions() {
     // Everything here should be lint
 
     let _return: String = return_a_string();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _return: Pie = return_a_struct();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _return: Pizza = return_an_enum();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _return: u32 = return_an_int();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _return: String = String::new();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let new_pie: Pie = Pie::new();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _return: u32 = new_pie.return_an_int();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _return: u32 = Pie::associated_return_an_int();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _return: String = Pie::associated_return_a_string();
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 }
 
 fn test_simple_types() {
     // Everything here should be lint
 
     let _var: u32 = u32::MAX;
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _var: u32 = 5_u32;
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _var: &str = "test";
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _var: &[u8; 4] = b"test";
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 
     let _var: bool = false;
-    //~^ ERROR: redundant type annotation
+    //~^ redundant_type_annotations
 }
 
 fn issue12212() {
diff --git a/src/tools/clippy/tests/ui/redundant_type_annotations.stderr b/src/tools/clippy/tests/ui/redundant_type_annotations.stderr
index 4768f4d3c57c..d2f04cc4768e 100644
--- a/src/tools/clippy/tests/ui/redundant_type_annotations.stderr
+++ b/src/tools/clippy/tests/ui/redundant_type_annotations.stderr
@@ -14,91 +14,91 @@ LL |         let v: &u32 = self.return_a_ref();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:86:9
+  --> tests/ui/redundant_type_annotations.rs:87:9
    |
 LL |         let v: &Slice = self.return_a_ref_to_struct();
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:159:5
+  --> tests/ui/redundant_type_annotations.rs:160:5
    |
 LL |     let _return: String = return_a_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:162:5
+  --> tests/ui/redundant_type_annotations.rs:163:5
    |
 LL |     let _return: Pie = return_a_struct();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:165:5
+  --> tests/ui/redundant_type_annotations.rs:166:5
    |
 LL |     let _return: Pizza = return_an_enum();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:168:5
+  --> tests/ui/redundant_type_annotations.rs:169:5
    |
 LL |     let _return: u32 = return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:171:5
+  --> tests/ui/redundant_type_annotations.rs:172:5
    |
 LL |     let _return: String = String::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:174:5
+  --> tests/ui/redundant_type_annotations.rs:175:5
    |
 LL |     let new_pie: Pie = Pie::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:177:5
+  --> tests/ui/redundant_type_annotations.rs:178:5
    |
 LL |     let _return: u32 = new_pie.return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:180:5
+  --> tests/ui/redundant_type_annotations.rs:181:5
    |
 LL |     let _return: u32 = Pie::associated_return_an_int();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:183:5
+  --> tests/ui/redundant_type_annotations.rs:184:5
    |
 LL |     let _return: String = Pie::associated_return_a_string();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:190:5
+  --> tests/ui/redundant_type_annotations.rs:191:5
    |
 LL |     let _var: u32 = u32::MAX;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:193:5
+  --> tests/ui/redundant_type_annotations.rs:194:5
    |
 LL |     let _var: u32 = 5_u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:196:5
+  --> tests/ui/redundant_type_annotations.rs:197:5
    |
 LL |     let _var: &str = "test";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:199:5
+  --> tests/ui/redundant_type_annotations.rs:200:5
    |
 LL |     let _var: &[u8; 4] = b"test";
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant type annotation
-  --> tests/ui/redundant_type_annotations.rs:202:5
+  --> tests/ui/redundant_type_annotations.rs:203:5
    |
 LL |     let _var: bool = false;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/ref_as_ptr.fixed b/src/tools/clippy/tests/ui/ref_as_ptr.fixed
index 6048267092f1..ce144508581e 100644
--- a/src/tools/clippy/tests/ui/ref_as_ptr.fixed
+++ b/src/tools/clippy/tests/ui/ref_as_ptr.fixed
@@ -5,53 +5,86 @@ fn f<T>(_: T) {}
 
 fn main() {
     f(std::ptr::from_ref(&1u8));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<u32>(&2u32));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<f64>(&3.0f64));
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref(&4) as *const f32);
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<f32>(&5.0f32) as *const u32);
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref(&mut 6u8));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<u32>(&mut 7u32));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<f64>(&mut 8.0f64));
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref(&mut 9) as *const f32);
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<f32>(&mut 10.0f32) as *const u32);
+    //~^ ref_as_ptr
 
     f(std::ptr::from_mut(&mut 11u8));
+    //~^ ref_as_ptr
     f(std::ptr::from_mut::<u32>(&mut 12u32));
+    //~^ ref_as_ptr
     f(std::ptr::from_mut::<f64>(&mut 13.0f64));
+    //~^ ref_as_ptr
 
     f(std::ptr::from_mut(&mut 14) as *const f32);
+    //~^ ref_as_ptr
     f(std::ptr::from_mut::<f32>(&mut 15.0f32) as *const u32);
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref(&1u8));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<u32>(&2u32));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<f64>(&3.0f64));
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref(&4) as *const f32);
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<f32>(&5.0f32) as *const u32);
+    //~^ ref_as_ptr
 
     let val = 1;
     f(std::ptr::from_ref(&val));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<i32>(&val));
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref(&val) as *const f32);
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<i32>(&val) as *const f64);
+    //~^ ref_as_ptr
 
     let mut val: u8 = 2;
     f(std::ptr::from_mut::<u8>(&mut val));
+    //~^ ref_as_ptr
     f(std::ptr::from_mut(&mut val));
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref::<u8>(&mut val));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref(&mut val));
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref::<u8>(&mut val) as *const f64);
+    //~^ ref_as_ptr
     f::<*const Option<u8>>(std::ptr::from_ref(&mut val) as *const _);
+    //~^ ref_as_ptr
 
     f(std::ptr::from_ref::<[usize; 7]>(&std::array::from_fn(|i| i * i)));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<[usize; 8]>(&mut std::array::from_fn(|i| i * i)));
+    //~^ ref_as_ptr
     f(std::ptr::from_mut::<[usize; 9]>(&mut std::array::from_fn(|i| i * i)));
+    //~^ ref_as_ptr
 
     let _ = &String::new() as *const _;
     let _ = &mut String::new() as *mut _;
@@ -74,17 +107,23 @@ fn _msrv_1_76() {
     let mut_val = &mut 42_i32;
 
     f(std::ptr::from_ref::<i32>(val));
+    //~^ ref_as_ptr
     f(std::ptr::from_mut::<i32>(mut_val));
+    //~^ ref_as_ptr
 }
 
 fn foo(val: &[u8]) {
     f(std::ptr::from_ref(val));
+    //~^ ref_as_ptr
     f(std::ptr::from_ref::<[u8]>(val));
+    //~^ ref_as_ptr
 }
 
 fn bar(val: &mut str) {
     f(std::ptr::from_mut(val));
+    //~^ ref_as_ptr
     f(std::ptr::from_mut::<str>(val));
+    //~^ ref_as_ptr
 }
 
 struct X<'a>(&'a i32);
@@ -92,10 +131,12 @@ struct X<'a>(&'a i32);
 impl<'a> X<'a> {
     fn foo(&self) -> *const i64 {
         std::ptr::from_ref(self.0) as *const _
+        //~^ ref_as_ptr
     }
 
     fn bar(&mut self) -> *const i64 {
         std::ptr::from_ref(self.0) as *const _
+        //~^ ref_as_ptr
     }
 }
 
@@ -104,13 +145,16 @@ struct Y<'a>(&'a mut i32);
 impl<'a> Y<'a> {
     fn foo(&self) -> *const i64 {
         std::ptr::from_ref(self.0) as *const _
+        //~^ ref_as_ptr
     }
 
     fn bar(&mut self) -> *const i64 {
         std::ptr::from_ref(self.0) as *const _
+        //~^ ref_as_ptr
     }
 
     fn baz(&mut self) -> *const i64 {
         std::ptr::from_mut(self.0) as *mut _
+        //~^ ref_as_ptr
     }
 }
diff --git a/src/tools/clippy/tests/ui/ref_as_ptr.rs b/src/tools/clippy/tests/ui/ref_as_ptr.rs
index 7f1d59b856e4..acdff2c2ba29 100644
--- a/src/tools/clippy/tests/ui/ref_as_ptr.rs
+++ b/src/tools/clippy/tests/ui/ref_as_ptr.rs
@@ -5,53 +5,86 @@ fn f<T>(_: T) {}
 
 fn main() {
     f(&1u8 as *const _);
+    //~^ ref_as_ptr
     f(&2u32 as *const u32);
+    //~^ ref_as_ptr
     f(&3.0f64 as *const f64);
+    //~^ ref_as_ptr
 
     f(&4 as *const _ as *const f32);
+    //~^ ref_as_ptr
     f(&5.0f32 as *const f32 as *const u32);
+    //~^ ref_as_ptr
 
     f(&mut 6u8 as *const _);
+    //~^ ref_as_ptr
     f(&mut 7u32 as *const u32);
+    //~^ ref_as_ptr
     f(&mut 8.0f64 as *const f64);
+    //~^ ref_as_ptr
 
     f(&mut 9 as *const _ as *const f32);
+    //~^ ref_as_ptr
     f(&mut 10.0f32 as *const f32 as *const u32);
+    //~^ ref_as_ptr
 
     f(&mut 11u8 as *mut _);
+    //~^ ref_as_ptr
     f(&mut 12u32 as *mut u32);
+    //~^ ref_as_ptr
     f(&mut 13.0f64 as *mut f64);
+    //~^ ref_as_ptr
 
     f(&mut 14 as *mut _ as *const f32);
+    //~^ ref_as_ptr
     f(&mut 15.0f32 as *mut f32 as *const u32);
+    //~^ ref_as_ptr
 
     f(&1u8 as *const _);
+    //~^ ref_as_ptr
     f(&2u32 as *const u32);
+    //~^ ref_as_ptr
     f(&3.0f64 as *const f64);
+    //~^ ref_as_ptr
 
     f(&4 as *const _ as *const f32);
+    //~^ ref_as_ptr
     f(&5.0f32 as *const f32 as *const u32);
+    //~^ ref_as_ptr
 
     let val = 1;
     f(&val as *const _);
+    //~^ ref_as_ptr
     f(&val as *const i32);
+    //~^ ref_as_ptr
 
     f(&val as *const _ as *const f32);
+    //~^ ref_as_ptr
     f(&val as *const i32 as *const f64);
+    //~^ ref_as_ptr
 
     let mut val: u8 = 2;
     f(&mut val as *mut u8);
+    //~^ ref_as_ptr
     f(&mut val as *mut _);
+    //~^ ref_as_ptr
 
     f(&mut val as *const u8);
+    //~^ ref_as_ptr
     f(&mut val as *const _);
+    //~^ ref_as_ptr
 
     f(&mut val as *const u8 as *const f64);
+    //~^ ref_as_ptr
     f::<*const Option<u8>>(&mut val as *const _ as *const _);
+    //~^ ref_as_ptr
 
     f(&std::array::from_fn(|i| i * i) as *const [usize; 7]);
+    //~^ ref_as_ptr
     f(&mut std::array::from_fn(|i| i * i) as *const [usize; 8]);
+    //~^ ref_as_ptr
     f(&mut std::array::from_fn(|i| i * i) as *mut [usize; 9]);
+    //~^ ref_as_ptr
 
     let _ = &String::new() as *const _;
     let _ = &mut String::new() as *mut _;
@@ -74,17 +107,23 @@ fn _msrv_1_76() {
     let mut_val = &mut 42_i32;
 
     f(val as *const i32);
+    //~^ ref_as_ptr
     f(mut_val as *mut i32);
+    //~^ ref_as_ptr
 }
 
 fn foo(val: &[u8]) {
     f(val as *const _);
+    //~^ ref_as_ptr
     f(val as *const [u8]);
+    //~^ ref_as_ptr
 }
 
 fn bar(val: &mut str) {
     f(val as *mut _);
+    //~^ ref_as_ptr
     f(val as *mut str);
+    //~^ ref_as_ptr
 }
 
 struct X<'a>(&'a i32);
@@ -92,10 +131,12 @@ struct X<'a>(&'a i32);
 impl<'a> X<'a> {
     fn foo(&self) -> *const i64 {
         self.0 as *const _ as *const _
+        //~^ ref_as_ptr
     }
 
     fn bar(&mut self) -> *const i64 {
         self.0 as *const _ as *const _
+        //~^ ref_as_ptr
     }
 }
 
@@ -104,13 +145,16 @@ struct Y<'a>(&'a mut i32);
 impl<'a> Y<'a> {
     fn foo(&self) -> *const i64 {
         self.0 as *const _ as *const _
+        //~^ ref_as_ptr
     }
 
     fn bar(&mut self) -> *const i64 {
         self.0 as *const _ as *const _
+        //~^ ref_as_ptr
     }
 
     fn baz(&mut self) -> *const i64 {
         self.0 as *mut _ as *mut _
+        //~^ ref_as_ptr
     }
 }
diff --git a/src/tools/clippy/tests/ui/ref_as_ptr.stderr b/src/tools/clippy/tests/ui/ref_as_ptr.stderr
index c5e9af38aea0..79db29e596bd 100644
--- a/src/tools/clippy/tests/ui/ref_as_ptr.stderr
+++ b/src/tools/clippy/tests/ui/ref_as_ptr.stderr
@@ -8,259 +8,259 @@ LL |     f(&1u8 as *const _);
    = help: to override `-D warnings` add `#[allow(clippy::ref_as_ptr)]`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:8:7
+  --> tests/ui/ref_as_ptr.rs:9:7
    |
 LL |     f(&2u32 as *const u32);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u32>(&2u32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:9:7
+  --> tests/ui/ref_as_ptr.rs:11:7
    |
 LL |     f(&3.0f64 as *const f64);
    |       ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f64>(&3.0f64)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:11:7
+  --> tests/ui/ref_as_ptr.rs:14:7
    |
 LL |     f(&4 as *const _ as *const f32);
    |       ^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&4)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:12:7
+  --> tests/ui/ref_as_ptr.rs:16:7
    |
 LL |     f(&5.0f32 as *const f32 as *const u32);
    |       ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f32>(&5.0f32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:14:7
+  --> tests/ui/ref_as_ptr.rs:19:7
    |
 LL |     f(&mut 6u8 as *const _);
    |       ^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut 6u8)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:15:7
+  --> tests/ui/ref_as_ptr.rs:21:7
    |
 LL |     f(&mut 7u32 as *const u32);
    |       ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u32>(&mut 7u32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:16:7
+  --> tests/ui/ref_as_ptr.rs:23:7
    |
 LL |     f(&mut 8.0f64 as *const f64);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f64>(&mut 8.0f64)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:18:7
+  --> tests/ui/ref_as_ptr.rs:26:7
    |
 LL |     f(&mut 9 as *const _ as *const f32);
    |       ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut 9)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:19:7
+  --> tests/ui/ref_as_ptr.rs:28:7
    |
 LL |     f(&mut 10.0f32 as *const f32 as *const u32);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f32>(&mut 10.0f32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:21:7
+  --> tests/ui/ref_as_ptr.rs:31:7
    |
 LL |     f(&mut 11u8 as *mut _);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(&mut 11u8)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:22:7
+  --> tests/ui/ref_as_ptr.rs:33:7
    |
 LL |     f(&mut 12u32 as *mut u32);
    |       ^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<u32>(&mut 12u32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:23:7
+  --> tests/ui/ref_as_ptr.rs:35:7
    |
 LL |     f(&mut 13.0f64 as *mut f64);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<f64>(&mut 13.0f64)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:25:7
+  --> tests/ui/ref_as_ptr.rs:38:7
    |
 LL |     f(&mut 14 as *mut _ as *const f32);
    |       ^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(&mut 14)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:26:7
+  --> tests/ui/ref_as_ptr.rs:40:7
    |
 LL |     f(&mut 15.0f32 as *mut f32 as *const u32);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<f32>(&mut 15.0f32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:28:7
+  --> tests/ui/ref_as_ptr.rs:43:7
    |
 LL |     f(&1u8 as *const _);
    |       ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&1u8)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:29:7
+  --> tests/ui/ref_as_ptr.rs:45:7
    |
 LL |     f(&2u32 as *const u32);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u32>(&2u32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:30:7
+  --> tests/ui/ref_as_ptr.rs:47:7
    |
 LL |     f(&3.0f64 as *const f64);
    |       ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f64>(&3.0f64)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:32:7
+  --> tests/ui/ref_as_ptr.rs:50:7
    |
 LL |     f(&4 as *const _ as *const f32);
    |       ^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&4)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:33:7
+  --> tests/ui/ref_as_ptr.rs:52:7
    |
 LL |     f(&5.0f32 as *const f32 as *const u32);
    |       ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<f32>(&5.0f32)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:36:7
+  --> tests/ui/ref_as_ptr.rs:56:7
    |
 LL |     f(&val as *const _);
    |       ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:37:7
+  --> tests/ui/ref_as_ptr.rs:58:7
    |
 LL |     f(&val as *const i32);
    |       ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<i32>(&val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:39:7
+  --> tests/ui/ref_as_ptr.rs:61:7
    |
 LL |     f(&val as *const _ as *const f32);
    |       ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:40:7
+  --> tests/ui/ref_as_ptr.rs:63:7
    |
 LL |     f(&val as *const i32 as *const f64);
    |       ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<i32>(&val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:43:7
+  --> tests/ui/ref_as_ptr.rs:67:7
    |
 LL |     f(&mut val as *mut u8);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<u8>(&mut val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:44:7
+  --> tests/ui/ref_as_ptr.rs:69:7
    |
 LL |     f(&mut val as *mut _);
    |       ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(&mut val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:46:7
+  --> tests/ui/ref_as_ptr.rs:72:7
    |
 LL |     f(&mut val as *const u8);
    |       ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u8>(&mut val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:47:7
+  --> tests/ui/ref_as_ptr.rs:74:7
    |
 LL |     f(&mut val as *const _);
    |       ^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:49:7
+  --> tests/ui/ref_as_ptr.rs:77:7
    |
 LL |     f(&mut val as *const u8 as *const f64);
    |       ^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<u8>(&mut val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:50:28
+  --> tests/ui/ref_as_ptr.rs:79:28
    |
 LL |     f::<*const Option<u8>>(&mut val as *const _ as *const _);
    |                            ^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(&mut val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:52:7
+  --> tests/ui/ref_as_ptr.rs:82:7
    |
 LL |     f(&std::array::from_fn(|i| i * i) as *const [usize; 7]);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<[usize; 7]>(&std::array::from_fn(|i| i * i))`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:53:7
+  --> tests/ui/ref_as_ptr.rs:84:7
    |
 LL |     f(&mut std::array::from_fn(|i| i * i) as *const [usize; 8]);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<[usize; 8]>(&mut std::array::from_fn(|i| i * i))`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:54:7
+  --> tests/ui/ref_as_ptr.rs:86:7
    |
 LL |     f(&mut std::array::from_fn(|i| i * i) as *mut [usize; 9]);
    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<[usize; 9]>(&mut std::array::from_fn(|i| i * i))`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:76:7
+  --> tests/ui/ref_as_ptr.rs:109:7
    |
 LL |     f(val as *const i32);
    |       ^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<i32>(val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:77:7
+  --> tests/ui/ref_as_ptr.rs:111:7
    |
 LL |     f(mut_val as *mut i32);
    |       ^^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<i32>(mut_val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:81:7
+  --> tests/ui/ref_as_ptr.rs:116:7
    |
 LL |     f(val as *const _);
    |       ^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:82:7
+  --> tests/ui/ref_as_ptr.rs:118:7
    |
 LL |     f(val as *const [u8]);
    |       ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref::<[u8]>(val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:86:7
+  --> tests/ui/ref_as_ptr.rs:123:7
    |
 LL |     f(val as *mut _);
    |       ^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:87:7
+  --> tests/ui/ref_as_ptr.rs:125:7
    |
 LL |     f(val as *mut str);
    |       ^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut::<str>(val)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:94:9
+  --> tests/ui/ref_as_ptr.rs:133:9
    |
 LL |         self.0 as *const _ as *const _
    |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:98:9
+  --> tests/ui/ref_as_ptr.rs:138:9
    |
 LL |         self.0 as *const _ as *const _
    |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:106:9
+  --> tests/ui/ref_as_ptr.rs:147:9
    |
 LL |         self.0 as *const _ as *const _
    |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:110:9
+  --> tests/ui/ref_as_ptr.rs:152:9
    |
 LL |         self.0 as *const _ as *const _
    |         ^^^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_ref(self.0)`
 
 error: reference as raw pointer
-  --> tests/ui/ref_as_ptr.rs:114:9
+  --> tests/ui/ref_as_ptr.rs:157:9
    |
 LL |         self.0 as *mut _ as *mut _
    |         ^^^^^^^^^^^^^^^^ help: try: `std::ptr::from_mut(self.0)`
diff --git a/src/tools/clippy/tests/ui/ref_binding_to_reference.rs b/src/tools/clippy/tests/ui/ref_binding_to_reference.rs
index 001ed3119490..365fd8edea78 100644
--- a/src/tools/clippy/tests/ui/ref_binding_to_reference.rs
+++ b/src/tools/clippy/tests/ui/ref_binding_to_reference.rs
@@ -28,15 +28,15 @@ fn main() {
     // Err, reference to a &String
     let _: &&String = match Some(&x) {
         Some(ref x) => x,
-        //~^ ERROR: this pattern creates a reference to a reference
-        //~| NOTE: `-D clippy::ref-binding-to-reference` implied by `-D warnings`
+        //~^ ref_binding_to_reference
         None => return,
     };
 
     // Err, reference to a &String
     let _: &&String = match Some(&x) {
         Some(ref x) => {
-            //~^ ERROR: this pattern creates a reference to a reference
+            //~^ ref_binding_to_reference
+
             f1(x);
             f1(*x);
             x
@@ -47,20 +47,22 @@ fn main() {
     // Err, reference to a &String
     match Some(&x) {
         Some(ref x) => m2!(x),
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ ref_binding_to_reference
         None => return,
     }
 
     // Err, reference to a &String
     let _ = |&ref x: &&String| {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ ref_binding_to_reference
+
         let _: &&String = x;
     };
 }
 
 // Err, reference to a &String
 fn f2<'a>(&ref x: &&'a String) -> &'a String {
-    //~^ ERROR: this pattern creates a reference to a reference
+    //~^ ref_binding_to_reference
+
     let _: &&String = x;
     *x
 }
@@ -68,7 +70,8 @@ fn f2<'a>(&ref x: &&'a String) -> &'a String {
 trait T1 {
     // Err, reference to a &String
     fn f(&ref x: &&String) {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ ref_binding_to_reference
+
         let _: &&String = x;
     }
 }
@@ -77,7 +80,8 @@ struct S;
 impl T1 for S {
     // Err, reference to a &String
     fn f(&ref x: &&String) {
-        //~^ ERROR: this pattern creates a reference to a reference
+        //~^ ref_binding_to_reference
+
         let _: &&String = x;
     }
 }
diff --git a/src/tools/clippy/tests/ui/ref_binding_to_reference.stderr b/src/tools/clippy/tests/ui/ref_binding_to_reference.stderr
index 233416351a0a..c1adfab12bcb 100644
--- a/src/tools/clippy/tests/ui/ref_binding_to_reference.stderr
+++ b/src/tools/clippy/tests/ui/ref_binding_to_reference.stderr
@@ -13,7 +13,7 @@ LL +         Some(x) => &x,
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/ref_binding_to_reference.rs:38:14
+  --> tests/ui/ref_binding_to_reference.rs:37:14
    |
 LL |         Some(ref x) => {
    |              ^^^^^
@@ -22,6 +22,7 @@ help: try
    |
 LL ~         Some(x) => {
 LL |
+LL |
 LL |             f1(x);
 LL ~             f1(x);
 LL ~             &x
@@ -49,11 +50,12 @@ help: try
    |
 LL ~     let _ = |&x: &&String| {
 LL |
+LL |
 LL ~         let _: &&String = &x;
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/ref_binding_to_reference.rs:62:12
+  --> tests/ui/ref_binding_to_reference.rs:63:12
    |
 LL | fn f2<'a>(&ref x: &&'a String) -> &'a String {
    |            ^^^^^
@@ -62,12 +64,13 @@ help: try
    |
 LL ~ fn f2<'a>(&x: &&'a String) -> &'a String {
 LL |
+LL |
 LL ~     let _: &&String = &x;
 LL ~     x
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/ref_binding_to_reference.rs:70:11
+  --> tests/ui/ref_binding_to_reference.rs:72:11
    |
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
@@ -76,11 +79,12 @@ help: try
    |
 LL ~     fn f(&x: &&String) {
 LL |
+LL |
 LL ~         let _: &&String = &x;
    |
 
 error: this pattern creates a reference to a reference
-  --> tests/ui/ref_binding_to_reference.rs:79:11
+  --> tests/ui/ref_binding_to_reference.rs:82:11
    |
 LL |     fn f(&ref x: &&String) {
    |           ^^^^^
@@ -89,6 +93,7 @@ help: try
    |
 LL ~     fn f(&x: &&String) {
 LL |
+LL |
 LL ~         let _: &&String = &x;
    |
 
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option.all.fixed b/src/tools/clippy/tests/ui/ref_option/ref_option.all.fixed
index 47781a97c983..4159e916f199 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option.all.fixed
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option.all.fixed
@@ -6,42 +6,59 @@
 #![warn(clippy::ref_option)]
 
 fn opt_u8(a: Option<&u8>) {}
+//~^ ref_option
 fn opt_gen<T>(a: Option<&T>) {}
+//~^ ref_option
 fn opt_string(a: std::option::Option<&String>) {}
+//~^ ref_option
 fn ret_string<'a>(p: &'a str) -> Option<&'a u8> {
+    //~^ ref_option
     panic!()
 }
 fn ret_string_static() -> Option<&'static u8> {
+    //~^ ref_option
     panic!()
 }
 fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
+//~^ ref_option
 fn ret_box<'a>() -> Option<&'a Box<u8>> {
+    //~^ ref_option
     panic!()
 }
 
 pub fn pub_opt_string(a: Option<&String>) {}
+//~[all]^ ref_option
 pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
+//~[all]^ ref_option
 
 pub trait PubTrait {
     fn pub_trait_opt(&self, a: Option<&Vec<u8>>);
+    //~[all]^ ref_option
     fn pub_trait_ret(&self) -> Option<&Vec<u8>>;
+    //~[all]^ ref_option
 }
 
 trait PrivateTrait {
     fn trait_opt(&self, a: Option<&String>);
+    //~^ ref_option
     fn trait_ret(&self) -> Option<&String>;
+    //~^ ref_option
 }
 
 pub struct PubStruct;
 
 impl PubStruct {
     pub fn pub_opt_params(&self, a: Option<&()>) {}
+    //~[all]^ ref_option
     pub fn pub_opt_ret(&self) -> Option<&String> {
+        //~[all]^ ref_option
         panic!()
     }
 
     fn private_opt_params(&self, a: Option<&()>) {}
+    //~^ ref_option
     fn private_opt_ret(&self) -> Option<&String> {
+        //~^ ref_option
         panic!()
     }
 }
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option.all.stderr b/src/tools/clippy/tests/ui/ref_option/ref_option.all.stderr
index fd30628bdd81..bd43c28336eb 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option.all.stderr
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option.all.stderr
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:9:1
+  --> tests/ui/ref_option/ref_option.rs:10:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:10:1
+  --> tests/ui/ref_option/ref_option.rs:12:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,29 +26,31 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:11:1
+  --> tests/ui/ref_option/ref_option.rs:14:1
    |
 LL |   fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
    |   ^                                -------------- help: change this to: `Option<&'a u8>`
    |  _|
    | |
+LL | |
 LL | |     panic!()
 LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:14:1
+  --> tests/ui/ref_option/ref_option.rs:18:1
    |
 LL |   fn ret_string_static() -> &'static Option<u8> {
    |   ^                         ------------------- help: change this to: `Option<&'static u8>`
    |  _|
    | |
+LL | |
 LL | |     panic!()
 LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:17:1
+  --> tests/ui/ref_option/ref_option.rs:22:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,18 +62,19 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:18:1
+  --> tests/ui/ref_option/ref_option.rs:24:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
    |  _|
    | |
+LL | |
 LL | |     panic!()
 LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:22:1
+  --> tests/ui/ref_option/ref_option.rs:29:1
    |
 LL | pub fn pub_opt_string(a: &Option<String>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^---------------^^^^
@@ -79,7 +82,7 @@ LL | pub fn pub_opt_string(a: &Option<String>) {}
    |                          help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:23:1
+  --> tests/ui/ref_option/ref_option.rs:31:1
    |
 LL | pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -91,7 +94,7 @@ LL + pub fn pub_mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:26:5
+  --> tests/ui/ref_option/ref_option.rs:35:5
    |
 LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^^
@@ -99,7 +102,7 @@ LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    |                                help: change this to: `Option<&Vec<u8>>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:27:5
+  --> tests/ui/ref_option/ref_option.rs:37:5
    |
 LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^
@@ -107,7 +110,7 @@ LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |                                help: change this to: `Option<&Vec<u8>>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:31:5
+  --> tests/ui/ref_option/ref_option.rs:42:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -115,7 +118,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:32:5
+  --> tests/ui/ref_option/ref_option.rs:44:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
@@ -123,7 +126,7 @@ LL |     fn trait_ret(&self) -> &Option<String>;
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:38:5
+  --> tests/ui/ref_option/ref_option.rs:51:5
    |
 LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -131,18 +134,19 @@ LL |     pub fn pub_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:39:5
+  --> tests/ui/ref_option/ref_option.rs:53:5
    |
 LL |       pub fn pub_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
    |  _____|
    | |
+LL | |
 LL | |         panic!()
 LL | |     }
    | |_____^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:43:5
+  --> tests/ui/ref_option/ref_option.rs:58:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -150,12 +154,13 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:44:5
+  --> tests/ui/ref_option/ref_option.rs:60:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
    |  _____|
    | |
+LL | |
 LL | |         panic!()
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option.private.fixed b/src/tools/clippy/tests/ui/ref_option/ref_option.private.fixed
index 8c42556e9b0d..3b158befb926 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option.private.fixed
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option.private.fixed
@@ -6,42 +6,59 @@
 #![warn(clippy::ref_option)]
 
 fn opt_u8(a: Option<&u8>) {}
+//~^ ref_option
 fn opt_gen<T>(a: Option<&T>) {}
+//~^ ref_option
 fn opt_string(a: std::option::Option<&String>) {}
+//~^ ref_option
 fn ret_string<'a>(p: &'a str) -> Option<&'a u8> {
+    //~^ ref_option
     panic!()
 }
 fn ret_string_static() -> Option<&'static u8> {
+    //~^ ref_option
     panic!()
 }
 fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
+//~^ ref_option
 fn ret_box<'a>() -> Option<&'a Box<u8>> {
+    //~^ ref_option
     panic!()
 }
 
 pub fn pub_opt_string(a: &Option<String>) {}
+//~[all]^ ref_option
 pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
+//~[all]^ ref_option
 
 pub trait PubTrait {
     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+    //~[all]^ ref_option
     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+    //~[all]^ ref_option
 }
 
 trait PrivateTrait {
     fn trait_opt(&self, a: Option<&String>);
+    //~^ ref_option
     fn trait_ret(&self) -> Option<&String>;
+    //~^ ref_option
 }
 
 pub struct PubStruct;
 
 impl PubStruct {
     pub fn pub_opt_params(&self, a: &Option<()>) {}
+    //~[all]^ ref_option
     pub fn pub_opt_ret(&self) -> &Option<String> {
+        //~[all]^ ref_option
         panic!()
     }
 
     fn private_opt_params(&self, a: Option<&()>) {}
+    //~^ ref_option
     fn private_opt_ret(&self) -> Option<&String> {
+        //~^ ref_option
         panic!()
     }
 }
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option.private.stderr b/src/tools/clippy/tests/ui/ref_option/ref_option.private.stderr
index d3428f1891f3..88c65e429d87 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option.private.stderr
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option.private.stderr
@@ -10,7 +10,7 @@ LL | fn opt_u8(a: &Option<u8>) {}
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:9:1
+  --> tests/ui/ref_option/ref_option.rs:10:1
    |
 LL | fn opt_gen<T>(a: &Option<T>) {}
    | ^^^^^^^^^^^^^^^^^----------^^^^
@@ -18,7 +18,7 @@ LL | fn opt_gen<T>(a: &Option<T>) {}
    |                  help: change this to: `Option<&T>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:10:1
+  --> tests/ui/ref_option/ref_option.rs:12:1
    |
 LL | fn opt_string(a: &std::option::Option<String>) {}
    | ^^^^^^^^^^^^^^^^^----------------------------^^^^
@@ -26,29 +26,31 @@ LL | fn opt_string(a: &std::option::Option<String>) {}
    |                  help: change this to: `std::option::Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:11:1
+  --> tests/ui/ref_option/ref_option.rs:14:1
    |
 LL |   fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
    |   ^                                -------------- help: change this to: `Option<&'a u8>`
    |  _|
    | |
+LL | |
 LL | |     panic!()
 LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:14:1
+  --> tests/ui/ref_option/ref_option.rs:18:1
    |
 LL |   fn ret_string_static() -> &'static Option<u8> {
    |   ^                         ------------------- help: change this to: `Option<&'static u8>`
    |  _|
    | |
+LL | |
 LL | |     panic!()
 LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:17:1
+  --> tests/ui/ref_option/ref_option.rs:22:1
    |
 LL | fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,18 +62,19 @@ LL + fn mult_string(a: Option<&String>, b: Option<&Vec<u8>>) {}
    |
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:18:1
+  --> tests/ui/ref_option/ref_option.rs:24:1
    |
 LL |   fn ret_box<'a>() -> &'a Option<Box<u8>> {
    |   ^                   ------------------- help: change this to: `Option<&'a Box<u8>>`
    |  _|
    | |
+LL | |
 LL | |     panic!()
 LL | | }
    | |_^
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:31:5
+  --> tests/ui/ref_option/ref_option.rs:42:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -79,7 +82,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:32:5
+  --> tests/ui/ref_option/ref_option.rs:44:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
@@ -87,7 +90,7 @@ LL |     fn trait_ret(&self) -> &Option<String>;
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:43:5
+  --> tests/ui/ref_option/ref_option.rs:58:5
    |
 LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-----------^^^^
@@ -95,12 +98,13 @@ LL |     fn private_opt_params(&self, a: &Option<()>) {}
    |                                     help: change this to: `Option<&()>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option.rs:44:5
+  --> tests/ui/ref_option/ref_option.rs:60:5
    |
 LL |       fn private_opt_ret(&self) -> &Option<String> {
    |       ^                            --------------- help: change this to: `Option<&String>`
    |  _____|
    | |
+LL | |
 LL | |         panic!()
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option.rs b/src/tools/clippy/tests/ui/ref_option/ref_option.rs
index 05251bcf12cd..35cd94174f8b 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option.rs
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option.rs
@@ -6,42 +6,59 @@
 #![warn(clippy::ref_option)]
 
 fn opt_u8(a: &Option<u8>) {}
+//~^ ref_option
 fn opt_gen<T>(a: &Option<T>) {}
+//~^ ref_option
 fn opt_string(a: &std::option::Option<String>) {}
+//~^ ref_option
 fn ret_string<'a>(p: &'a str) -> &'a Option<u8> {
+    //~^ ref_option
     panic!()
 }
 fn ret_string_static() -> &'static Option<u8> {
+    //~^ ref_option
     panic!()
 }
 fn mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
+//~^ ref_option
 fn ret_box<'a>() -> &'a Option<Box<u8>> {
+    //~^ ref_option
     panic!()
 }
 
 pub fn pub_opt_string(a: &Option<String>) {}
+//~[all]^ ref_option
 pub fn pub_mult_string(a: &Option<String>, b: &Option<Vec<u8>>) {}
+//~[all]^ ref_option
 
 pub trait PubTrait {
     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+    //~[all]^ ref_option
     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+    //~[all]^ ref_option
 }
 
 trait PrivateTrait {
     fn trait_opt(&self, a: &Option<String>);
+    //~^ ref_option
     fn trait_ret(&self) -> &Option<String>;
+    //~^ ref_option
 }
 
 pub struct PubStruct;
 
 impl PubStruct {
     pub fn pub_opt_params(&self, a: &Option<()>) {}
+    //~[all]^ ref_option
     pub fn pub_opt_ret(&self) -> &Option<String> {
+        //~[all]^ ref_option
         panic!()
     }
 
     fn private_opt_params(&self, a: &Option<()>) {}
+    //~^ ref_option
     fn private_opt_ret(&self) -> &Option<String> {
+        //~^ ref_option
         panic!()
     }
 }
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option_traits.all.stderr b/src/tools/clippy/tests/ui/ref_option/ref_option_traits.all.stderr
index a9967168c12e..030a9a28ec68 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option_traits.all.stderr
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option_traits.all.stderr
@@ -10,7 +10,7 @@ LL |     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:11:5
+  --> tests/ui/ref_option/ref_option_traits.rs:12:5
    |
 LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^----------------^
@@ -18,7 +18,7 @@ LL |     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
    |                                help: change this to: `Option<&Vec<u8>>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:15:5
+  --> tests/ui/ref_option/ref_option_traits.rs:17:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -26,7 +26,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    |                            help: change this to: `Option<&String>`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui/ref_option/ref_option_traits.rs:19:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option_traits.private.stderr b/src/tools/clippy/tests/ui/ref_option/ref_option_traits.private.stderr
index 36d0833af8a2..2837ee80fb2e 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option_traits.private.stderr
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option_traits.private.stderr
@@ -1,5 +1,5 @@
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:15:5
+  --> tests/ui/ref_option/ref_option_traits.rs:17:5
    |
 LL |     fn trait_opt(&self, a: &Option<String>);
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^^
@@ -10,7 +10,7 @@ LL |     fn trait_opt(&self, a: &Option<String>);
    = help: to override `-D warnings` add `#[allow(clippy::ref_option)]`
 
 error: it is more idiomatic to use `Option<&T>` instead of `&Option<T>`
-  --> tests/ui/ref_option/ref_option_traits.rs:16:5
+  --> tests/ui/ref_option/ref_option_traits.rs:19:5
    |
 LL |     fn trait_ret(&self) -> &Option<String>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^---------------^
diff --git a/src/tools/clippy/tests/ui/ref_option/ref_option_traits.rs b/src/tools/clippy/tests/ui/ref_option/ref_option_traits.rs
index 5d5f113c83db..811da2eb4d50 100644
--- a/src/tools/clippy/tests/ui/ref_option/ref_option_traits.rs
+++ b/src/tools/clippy/tests/ui/ref_option/ref_option_traits.rs
@@ -8,12 +8,16 @@
 
 pub trait PubTrait {
     fn pub_trait_opt(&self, a: &Option<Vec<u8>>);
+    //~[all]^ ref_option
     fn pub_trait_ret(&self) -> &Option<Vec<u8>>;
+    //~[all]^ ref_option
 }
 
 trait PrivateTrait {
     fn trait_opt(&self, a: &Option<String>);
+    //~^ ref_option
     fn trait_ret(&self) -> &Option<String>;
+    //~^ ref_option
 }
 
 pub struct PubStruct;
diff --git a/src/tools/clippy/tests/ui/ref_option_ref.rs b/src/tools/clippy/tests/ui/ref_option_ref.rs
index 44001c45e99a..9632611f7df4 100644
--- a/src/tools/clippy/tests/ui/ref_option_ref.rs
+++ b/src/tools/clippy/tests/ui/ref_option_ref.rs
@@ -8,37 +8,39 @@
 
 static THRESHOLD: i32 = 10;
 static REF_THRESHOLD: &Option<&i32> = &Some(&THRESHOLD);
-//~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Opt
-//~| NOTE: `-D clippy::ref-option-ref` implied by `-D warnings`
+//~^ ref_option_ref
+
 const CONST_THRESHOLD: &i32 = &10;
 const REF_CONST: &Option<&i32> = &Some(CONST_THRESHOLD);
-//~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Opt
+//~^ ref_option_ref
 
 type RefOptRefU32<'a> = &'a Option<&'a u32>;
-//~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Opt
+//~^ ref_option_ref
+
 type RefOptRef<'a, T> = &'a Option<&'a T>;
-//~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Opt
+//~^ ref_option_ref
 
 fn foo(data: &Option<&u32>) {}
-//~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Opt
+//~^ ref_option_ref
 
 fn bar(data: &u32) -> &Option<&u32> {
-    //~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Opt
+    //~^ ref_option_ref
+
     &None
 }
 
 struct StructRef<'a> {
     data: &'a Option<&'a u32>,
-    //~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to
+    //~^ ref_option_ref
 }
 
 struct StructTupleRef<'a>(u32, &'a Option<&'a u32>);
-//~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Opt
+//~^ ref_option_ref
 
 enum EnumRef<'a> {
     Variant1(u32),
     Variant2(&'a Option<&'a u32>),
-    //~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to
+    //~^ ref_option_ref
 }
 
 trait RefOptTrait {
@@ -48,14 +50,14 @@ trait RefOptTrait {
 
 impl RefOptTrait for u32 {
     type A = &'static Option<&'static Self>;
-    //~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to
+    //~^ ref_option_ref
 
     fn foo(&self, _: Self::A) {}
 }
 
 fn main() {
     let x: &Option<&u32> = &None;
-    //~^ ERROR: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to
+    //~^ ref_option_ref
 }
 
 fn issue9682(arg: &Option<&mut String>) {
diff --git a/src/tools/clippy/tests/ui/ref_option_ref.stderr b/src/tools/clippy/tests/ui/ref_option_ref.stderr
index 1cb64e1182a5..25064a61ee88 100644
--- a/src/tools/clippy/tests/ui/ref_option_ref.stderr
+++ b/src/tools/clippy/tests/ui/ref_option_ref.stderr
@@ -20,49 +20,49 @@ LL | type RefOptRefU32<'a> = &'a Option<&'a u32>;
    |                         ^^^^^^^^^^^^^^^^^^^ help: try: `Option<&'a u32>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:19:25
+  --> tests/ui/ref_option_ref.rs:20:25
    |
 LL | type RefOptRef<'a, T> = &'a Option<&'a T>;
    |                         ^^^^^^^^^^^^^^^^^ help: try: `Option<&'a T>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:22:14
+  --> tests/ui/ref_option_ref.rs:23:14
    |
 LL | fn foo(data: &Option<&u32>) {}
    |              ^^^^^^^^^^^^^ help: try: `Option<&u32>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:25:23
+  --> tests/ui/ref_option_ref.rs:26:23
    |
 LL | fn bar(data: &u32) -> &Option<&u32> {
    |                       ^^^^^^^^^^^^^ help: try: `Option<&u32>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:31:11
+  --> tests/ui/ref_option_ref.rs:33:11
    |
 LL |     data: &'a Option<&'a u32>,
    |           ^^^^^^^^^^^^^^^^^^^ help: try: `Option<&'a u32>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:35:32
+  --> tests/ui/ref_option_ref.rs:37:32
    |
 LL | struct StructTupleRef<'a>(u32, &'a Option<&'a u32>);
    |                                ^^^^^^^^^^^^^^^^^^^ help: try: `Option<&'a u32>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:40:14
+  --> tests/ui/ref_option_ref.rs:42:14
    |
 LL |     Variant2(&'a Option<&'a u32>),
    |              ^^^^^^^^^^^^^^^^^^^ help: try: `Option<&'a u32>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:50:14
+  --> tests/ui/ref_option_ref.rs:52:14
    |
 LL |     type A = &'static Option<&'static Self>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Option<&'static Self>`
 
 error: since `&` implements the `Copy` trait, `&Option<&T>` can be simplified to `Option<&T>`
-  --> tests/ui/ref_option_ref.rs:57:12
+  --> tests/ui/ref_option_ref.rs:59:12
    |
 LL |     let x: &Option<&u32> = &None;
    |            ^^^^^^^^^^^^^ help: try: `Option<&u32>`
diff --git a/src/tools/clippy/tests/ui/ref_patterns.rs b/src/tools/clippy/tests/ui/ref_patterns.rs
index acd42ec89b62..2905af13ccb6 100644
--- a/src/tools/clippy/tests/ui/ref_patterns.rs
+++ b/src/tools/clippy/tests/ui/ref_patterns.rs
@@ -6,17 +6,17 @@ fn use_in_pattern() {
     match opt {
         None => {},
         Some(ref opt) => {},
-        //~^ ERROR: usage of ref pattern
+        //~^ ref_patterns
     }
 }
 
 fn use_in_binding() {
     let x = 5;
     let ref y = x;
-    //~^ ERROR: usage of ref pattern
+    //~^ ref_patterns
 }
 
 fn use_in_parameter(ref x: i32) {}
-//~^ ERROR: usage of ref pattern
+//~^ ref_patterns
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/regex.rs b/src/tools/clippy/tests/ui/regex.rs
index f607a2d50c6d..c63d549b7553 100644
--- a/src/tools/clippy/tests/ui/regex.rs
+++ b/src/tools/clippy/tests/ui/regex.rs
@@ -1,3 +1,4 @@
+//@require-annotations-for-level: WARN
 #![allow(
     unused,
     clippy::needless_raw_strings,
@@ -27,11 +28,14 @@ fn syntax_error() {
     //~^ ERROR: regex syntax error: invalid character class range, the start must be <= th
 
     let some_regex = Regex::new(OPENING_PAREN);
+    //~^ invalid_regex
 
     let binary_pipe_in_wrong_position = BRegex::new("|");
     //~^ ERROR: trivial regex
     let some_binary_regex = BRegex::new(OPENING_PAREN);
+    //~^ invalid_regex
     let some_binary_regex_builder = BRegexBuilder::new(OPENING_PAREN);
+    //~^ invalid_regex
 
     let closing_paren = ")";
     let not_linted = Regex::new(closing_paren);
@@ -44,7 +48,9 @@ fn syntax_error() {
     ]);
 
     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
+    //~^ invalid_regex
     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
+    //~^ invalid_regex
 
     // These following three cases are considering valid since regex-1.8.0
     let raw_string_error = Regex::new(r"[...\/...]");
@@ -52,6 +58,7 @@ fn syntax_error() {
     let _ = Regex::new(r"(?<hi>hi)").unwrap();
 
     let escaped_string_span = Regex::new("\\b\\c");
+    //~^ invalid_regex
 
     let aux_span = Regex::new("(?ixi)");
     //~^ ERROR: regex syntax error: duplicate flag
diff --git a/src/tools/clippy/tests/ui/regex.stderr b/src/tools/clippy/tests/ui/regex.stderr
index 18dd538c68b4..aaec3bc14200 100644
--- a/src/tools/clippy/tests/ui/regex.stderr
+++ b/src/tools/clippy/tests/ui/regex.stderr
@@ -1,5 +1,5 @@
 error: trivial regex
-  --> tests/ui/regex.rs:19:45
+  --> tests/ui/regex.rs:20:45
    |
 LL |     let pipe_in_wrong_position = Regex::new("|");
    |                                             ^^^
@@ -9,7 +9,7 @@ LL |     let pipe_in_wrong_position = Regex::new("|");
    = help: to override `-D warnings` add `#[allow(clippy::trivial_regex)]`
 
 error: trivial regex
-  --> tests/ui/regex.rs:21:60
+  --> tests/ui/regex.rs:22:60
    |
 LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    |                                                            ^^^
@@ -17,7 +17,7 @@ LL |     let pipe_in_wrong_position_builder = RegexBuilder::new("|");
    = help: the regex is unlikely to be useful as it is
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> tests/ui/regex.rs:23:42
+  --> tests/ui/regex.rs:24:42
    |
 LL |     let wrong_char_ranice = Regex::new("[z-a]");
    |                                          ^^^
@@ -26,7 +26,7 @@ LL |     let wrong_char_ranice = Regex::new("[z-a]");
    = help: to override `-D warnings` add `#[allow(clippy::invalid_regex)]`
 
 error: regex syntax error: invalid character class range, the start must be <= the end
-  --> tests/ui/regex.rs:26:37
+  --> tests/ui/regex.rs:27:37
    |
 LL |     let some_unicode = Regex::new("[é-è]");
    |                                     ^^^
@@ -35,13 +35,13 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> tests/ui/regex.rs:29:33
+  --> tests/ui/regex.rs:30:33
    |
 LL |     let some_regex = Regex::new(OPENING_PAREN);
    |                                 ^^^^^^^^^^^^^
 
 error: trivial regex
-  --> tests/ui/regex.rs:31:53
+  --> tests/ui/regex.rs:33:53
    |
 LL |     let binary_pipe_in_wrong_position = BRegex::new("|");
    |                                                     ^^^
@@ -52,7 +52,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> tests/ui/regex.rs:33:41
+  --> tests/ui/regex.rs:35:41
    |
 LL |     let some_binary_regex = BRegex::new(OPENING_PAREN);
    |                                         ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> tests/ui/regex.rs:34:56
+  --> tests/ui/regex.rs:37:56
    |
 LL |     let some_binary_regex_builder = BRegexBuilder::new(OPENING_PAREN);
    |                                                        ^^^^^^^^^^^^^
@@ -70,7 +70,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> tests/ui/regex.rs:46:37
+  --> tests/ui/regex.rs:50:37
    |
 LL |     let set_error = RegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
    |                                     ^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ error: regex parse error:
            (
            ^
        error: unclosed group
-  --> tests/ui/regex.rs:47:39
+  --> tests/ui/regex.rs:52:39
    |
 LL |     let bset_error = BRegexSet::new(&[OPENING_PAREN, r"[a-z]+\.(com|org|net)"]);
    |                                       ^^^^^^^^^^^^^
@@ -88,7 +88,7 @@ error: regex parse error:
            \b\c
              ^^
        error: unrecognized escape sequence
-  --> tests/ui/regex.rs:54:42
+  --> tests/ui/regex.rs:60:42
    |
 LL |     let escaped_string_span = Regex::new("\\b\\c");
    |                                          ^^^^^^^^
@@ -96,19 +96,19 @@ LL |     let escaped_string_span = Regex::new("\\b\\c");
    = help: consider using a raw string literal: `r".."`
 
 error: regex syntax error: duplicate flag
-  --> tests/ui/regex.rs:56:34
+  --> tests/ui/regex.rs:63:34
    |
 LL |     let aux_span = Regex::new("(?ixi)");
    |                                  ^ ^
 
 error: regex syntax error: pattern can match invalid UTF-8
-  --> tests/ui/regex.rs:62:53
+  --> tests/ui/regex.rs:69:53
    |
 LL |     let invalid_utf8_should_lint = Regex::new("(?-u).");
    |                                                     ^
 
 error: trivial regex
-  --> tests/ui/regex.rs:67:33
+  --> tests/ui/regex.rs:74:33
    |
 LL |     let trivial_eq = Regex::new("^foobar$");
    |                                 ^^^^^^^^^^
@@ -116,7 +116,7 @@ LL |     let trivial_eq = Regex::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> tests/ui/regex.rs:70:48
+  --> tests/ui/regex.rs:77:48
    |
 LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    |                                                ^^^^^^^^^^
@@ -124,7 +124,7 @@ LL |     let trivial_eq_builder = RegexBuilder::new("^foobar$");
    = help: consider using `==` on `str`s
 
 error: trivial regex
-  --> tests/ui/regex.rs:73:42
+  --> tests/ui/regex.rs:80:42
    |
 LL |     let trivial_starts_with = Regex::new("^foobar");
    |                                          ^^^^^^^^^
@@ -132,7 +132,7 @@ LL |     let trivial_starts_with = Regex::new("^foobar");
    = help: consider using `str::starts_with`
 
 error: trivial regex
-  --> tests/ui/regex.rs:76:40
+  --> tests/ui/regex.rs:83:40
    |
 LL |     let trivial_ends_with = Regex::new("foobar$");
    |                                        ^^^^^^^^^
@@ -140,7 +140,7 @@ LL |     let trivial_ends_with = Regex::new("foobar$");
    = help: consider using `str::ends_with`
 
 error: trivial regex
-  --> tests/ui/regex.rs:79:39
+  --> tests/ui/regex.rs:86:39
    |
 LL |     let trivial_contains = Regex::new("foobar");
    |                                       ^^^^^^^^
@@ -148,7 +148,7 @@ LL |     let trivial_contains = Regex::new("foobar");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> tests/ui/regex.rs:82:39
+  --> tests/ui/regex.rs:89:39
    |
 LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    |                                       ^^^^^^^^^^^^^^^^
@@ -156,7 +156,7 @@ LL |     let trivial_contains = Regex::new(NOT_A_REAL_REGEX);
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> tests/ui/regex.rs:85:40
+  --> tests/ui/regex.rs:92:40
    |
 LL |     let trivial_backslash = Regex::new("a\\.b");
    |                                        ^^^^^^^
@@ -164,7 +164,7 @@ LL |     let trivial_backslash = Regex::new("a\\.b");
    = help: consider using `str::contains`
 
 error: trivial regex
-  --> tests/ui/regex.rs:89:36
+  --> tests/ui/regex.rs:96:36
    |
 LL |     let trivial_empty = Regex::new("");
    |                                    ^^
@@ -172,7 +172,7 @@ LL |     let trivial_empty = Regex::new("");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> tests/ui/regex.rs:92:36
+  --> tests/ui/regex.rs:99:36
    |
 LL |     let trivial_empty = Regex::new("^");
    |                                    ^^^
@@ -180,7 +180,7 @@ LL |     let trivial_empty = Regex::new("^");
    = help: the regex is unlikely to be useful as it is
 
 error: trivial regex
-  --> tests/ui/regex.rs:95:36
+  --> tests/ui/regex.rs:102:36
    |
 LL |     let trivial_empty = Regex::new("^$");
    |                                    ^^^^
@@ -188,7 +188,7 @@ LL |     let trivial_empty = Regex::new("^$");
    = help: consider using `str::is_empty`
 
 error: trivial regex
-  --> tests/ui/regex.rs:98:44
+  --> tests/ui/regex.rs:105:44
    |
 LL |     let binary_trivial_empty = BRegex::new("^$");
    |                                            ^^^^
@@ -196,13 +196,13 @@ LL |     let binary_trivial_empty = BRegex::new("^$");
    = help: consider using `str::is_empty`
 
 error: compiling a regex in a loop
-  --> tests/ui/regex.rs:125:21
+  --> tests/ui/regex.rs:132:21
    |
 LL |         let regex = Regex::new("a.b");
    |                     ^^^^^^^^^^
    |
 help: move the regex construction outside this loop
-  --> tests/ui/regex.rs:122:5
+  --> tests/ui/regex.rs:129:5
    |
 LL |     loop {
    |     ^^^^
@@ -210,37 +210,37 @@ LL |     loop {
    = help: to override `-D warnings` add `#[allow(clippy::regex_creation_in_loops)]`
 
 error: compiling a regex in a loop
-  --> tests/ui/regex.rs:127:21
+  --> tests/ui/regex.rs:134:21
    |
 LL |         let regex = BRegex::new("a.b");
    |                     ^^^^^^^^^^^
    |
 help: move the regex construction outside this loop
-  --> tests/ui/regex.rs:122:5
+  --> tests/ui/regex.rs:129:5
    |
 LL |     loop {
    |     ^^^^
 
 error: compiling a regex in a loop
-  --> tests/ui/regex.rs:133:25
+  --> tests/ui/regex.rs:140:25
    |
 LL |             let regex = Regex::new("a.b");
    |                         ^^^^^^^^^^
    |
 help: move the regex construction outside this loop
-  --> tests/ui/regex.rs:122:5
+  --> tests/ui/regex.rs:129:5
    |
 LL |     loop {
    |     ^^^^
 
 error: compiling a regex in a loop
-  --> tests/ui/regex.rs:138:32
+  --> tests/ui/regex.rs:145:32
    |
 LL |             let nested_regex = Regex::new("a.b");
    |                                ^^^^^^^^^^
    |
 help: move the regex construction outside this loop
-  --> tests/ui/regex.rs:137:9
+  --> tests/ui/regex.rs:144:9
    |
 LL |         for _ in 0..10 {
    |         ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/renamed_builtin_attr.fixed b/src/tools/clippy/tests/ui/renamed_builtin_attr.fixed
index aebf8712dd92..1ad7d8702bc0 100644
--- a/src/tools/clippy/tests/ui/renamed_builtin_attr.fixed
+++ b/src/tools/clippy/tests/ui/renamed_builtin_attr.fixed
@@ -1,4 +1,5 @@
 //@compile-flags: -Zdeduplicate-diagnostics=yes
 
 #[clippy::cognitive_complexity = "1"]
+//~^ ERROR: usage of deprecated attribute
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/renamed_builtin_attr.rs b/src/tools/clippy/tests/ui/renamed_builtin_attr.rs
index 6c18151195f5..0fb43b7f4901 100644
--- a/src/tools/clippy/tests/ui/renamed_builtin_attr.rs
+++ b/src/tools/clippy/tests/ui/renamed_builtin_attr.rs
@@ -1,4 +1,5 @@
 //@compile-flags: -Zdeduplicate-diagnostics=yes
 
 #[clippy::cyclomatic_complexity = "1"]
+//~^ ERROR: usage of deprecated attribute
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/repeat_once.fixed b/src/tools/clippy/tests/ui/repeat_once.fixed
index 72e97350a0c8..e739e176f0ac 100644
--- a/src/tools/clippy/tests/ui/repeat_once.fixed
+++ b/src/tools/clippy/tests/ui/repeat_once.fixed
@@ -7,9 +7,15 @@ fn main() {
     let slice = [1; 5];
 
     let a = [1; 5].to_vec();
+    //~^ repeat_once
     let b = slice.to_vec();
+    //~^ repeat_once
     let c = "hello".to_string();
+    //~^ repeat_once
     let d = "hi".to_string();
+    //~^ repeat_once
     let e = s.to_string();
+    //~^ repeat_once
     let f = string.clone();
+    //~^ repeat_once
 }
diff --git a/src/tools/clippy/tests/ui/repeat_once.rs b/src/tools/clippy/tests/ui/repeat_once.rs
index 7557c4d0bd41..89ab94bbaee8 100644
--- a/src/tools/clippy/tests/ui/repeat_once.rs
+++ b/src/tools/clippy/tests/ui/repeat_once.rs
@@ -7,9 +7,15 @@ fn main() {
     let slice = [1; 5];
 
     let a = [1; 5].repeat(1);
+    //~^ repeat_once
     let b = slice.repeat(1);
+    //~^ repeat_once
     let c = "hello".repeat(N);
+    //~^ repeat_once
     let d = "hi".repeat(1);
+    //~^ repeat_once
     let e = s.repeat(1);
+    //~^ repeat_once
     let f = string.repeat(1);
+    //~^ repeat_once
 }
diff --git a/src/tools/clippy/tests/ui/repeat_once.stderr b/src/tools/clippy/tests/ui/repeat_once.stderr
index 6996dc5eee7d..3db7a3568f8e 100644
--- a/src/tools/clippy/tests/ui/repeat_once.stderr
+++ b/src/tools/clippy/tests/ui/repeat_once.stderr
@@ -8,31 +8,31 @@ LL |     let a = [1; 5].repeat(1);
    = help: to override `-D warnings` add `#[allow(clippy::repeat_once)]`
 
 error: calling `repeat(1)` on slice
-  --> tests/ui/repeat_once.rs:10:13
+  --> tests/ui/repeat_once.rs:11:13
    |
 LL |     let b = slice.repeat(1);
    |             ^^^^^^^^^^^^^^^ help: consider using `.to_vec()` instead: `slice.to_vec()`
 
 error: calling `repeat(1)` on str
-  --> tests/ui/repeat_once.rs:11:13
+  --> tests/ui/repeat_once.rs:13:13
    |
 LL |     let c = "hello".repeat(N);
    |             ^^^^^^^^^^^^^^^^^ help: consider using `.to_string()` instead: `"hello".to_string()`
 
 error: calling `repeat(1)` on str
-  --> tests/ui/repeat_once.rs:12:13
+  --> tests/ui/repeat_once.rs:15:13
    |
 LL |     let d = "hi".repeat(1);
    |             ^^^^^^^^^^^^^^ help: consider using `.to_string()` instead: `"hi".to_string()`
 
 error: calling `repeat(1)` on str
-  --> tests/ui/repeat_once.rs:13:13
+  --> tests/ui/repeat_once.rs:17:13
    |
 LL |     let e = s.repeat(1);
    |             ^^^^^^^^^^^ help: consider using `.to_string()` instead: `s.to_string()`
 
 error: calling `repeat(1)` on a string literal
-  --> tests/ui/repeat_once.rs:14:13
+  --> tests/ui/repeat_once.rs:19:13
    |
 LL |     let f = string.repeat(1);
    |             ^^^^^^^^^^^^^^^^ help: consider using `.clone()` instead: `string.clone()`
diff --git a/src/tools/clippy/tests/ui/repeat_vec_with_capacity.fixed b/src/tools/clippy/tests/ui/repeat_vec_with_capacity.fixed
index f72b61b5f6cd..8a3b0b4f193f 100644
--- a/src/tools/clippy/tests/ui/repeat_vec_with_capacity.fixed
+++ b/src/tools/clippy/tests/ui/repeat_vec_with_capacity.fixed
@@ -4,13 +4,13 @@
 fn main() {
     {
         (0..123).map(|_| Vec::<()>::with_capacity(42)).collect::<Vec<_>>();
-        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+        //~^ repeat_vec_with_capacity
     }
 
     {
         let n = 123;
         (0..n).map(|_| Vec::<()>::with_capacity(42)).collect::<Vec<_>>();
-        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+        //~^ repeat_vec_with_capacity
     }
 
     {
@@ -25,7 +25,7 @@ fn main() {
 
     {
         std::iter::repeat_with(|| Vec::<()>::with_capacity(42));
-        //~^ ERROR: repeating `Vec::with_capacity` using `iter::repeat`, which does not retain capacity
+        //~^ repeat_vec_with_capacity
     }
 
     {
@@ -37,3 +37,8 @@ fn main() {
         from_macro!(Vec::<()>::with_capacity(42));
     }
 }
+
+#[clippy::msrv = "1.27.0"]
+fn msrv_check() {
+    std::iter::repeat(Vec::<()>::with_capacity(42));
+}
diff --git a/src/tools/clippy/tests/ui/repeat_vec_with_capacity.rs b/src/tools/clippy/tests/ui/repeat_vec_with_capacity.rs
index c0cc81f78436..011202d84757 100644
--- a/src/tools/clippy/tests/ui/repeat_vec_with_capacity.rs
+++ b/src/tools/clippy/tests/ui/repeat_vec_with_capacity.rs
@@ -4,13 +4,13 @@
 fn main() {
     {
         vec![Vec::<()>::with_capacity(42); 123];
-        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+        //~^ repeat_vec_with_capacity
     }
 
     {
         let n = 123;
         vec![Vec::<()>::with_capacity(42); n];
-        //~^ ERROR: repeating `Vec::with_capacity` using `vec![x; n]`, which does not retain capacity
+        //~^ repeat_vec_with_capacity
     }
 
     {
@@ -25,7 +25,7 @@ fn main() {
 
     {
         std::iter::repeat(Vec::<()>::with_capacity(42));
-        //~^ ERROR: repeating `Vec::with_capacity` using `iter::repeat`, which does not retain capacity
+        //~^ repeat_vec_with_capacity
     }
 
     {
@@ -37,3 +37,8 @@ fn main() {
         from_macro!(Vec::<()>::with_capacity(42));
     }
 }
+
+#[clippy::msrv = "1.27.0"]
+fn msrv_check() {
+    std::iter::repeat(Vec::<()>::with_capacity(42));
+}
diff --git a/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.fixed b/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.fixed
index ef316f1def41..dcff18723b6c 100644
--- a/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.fixed
+++ b/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.fixed
@@ -7,4 +7,5 @@ use alloc::vec::Vec;
 
 fn nostd() {
     let _: Vec<Vec<u8>> = core::iter::repeat_with(|| Vec::with_capacity(42)).take(123).collect();
+    //~^ repeat_vec_with_capacity
 }
diff --git a/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.rs b/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.rs
index 83b418a56674..84cc78de35ec 100644
--- a/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.rs
+++ b/src/tools/clippy/tests/ui/repeat_vec_with_capacity_nostd.rs
@@ -7,4 +7,5 @@ use alloc::vec::Vec;
 
 fn nostd() {
     let _: Vec<Vec<u8>> = iter::repeat(Vec::with_capacity(42)).take(123).collect();
+    //~^ repeat_vec_with_capacity
 }
diff --git a/src/tools/clippy/tests/ui/repl_uninit.rs b/src/tools/clippy/tests/ui/repl_uninit.rs
index 01bdf79e6422..e9469d4c5e2f 100644
--- a/src/tools/clippy/tests/ui/repl_uninit.rs
+++ b/src/tools/clippy/tests/ui/repl_uninit.rs
@@ -13,22 +13,24 @@ fn main() {
     // the following is UB if `might_panic` panics
     unsafe {
         let taken_v = mem::replace(&mut v, mem::uninitialized());
-        //~^ ERROR: replacing with `mem::uninitialized()`
-        //~| NOTE: `-D clippy::mem-replace-with-uninit` implied by `-D warnings`
+        //~^ mem_replace_with_uninit
+
         let new_v = might_panic(taken_v);
         std::mem::forget(mem::replace(&mut v, new_v));
     }
 
     unsafe {
         let taken_v = mem::replace(&mut v, mem::MaybeUninit::uninit().assume_init());
-        //~^ ERROR: replacing with `mem::MaybeUninit::uninit().assume_init()`
+        //~^ mem_replace_with_uninit
+
         let new_v = might_panic(taken_v);
         std::mem::forget(mem::replace(&mut v, new_v));
     }
 
     unsafe {
         let taken_v = mem::replace(&mut v, mem::zeroed());
-        //~^ ERROR: replacing with `mem::zeroed()`
+        //~^ mem_replace_with_uninit
+
         let new_v = might_panic(taken_v);
         std::mem::forget(mem::replace(&mut v, new_v));
     }
@@ -41,6 +43,7 @@ fn main() {
 
     // this is still not OK, because uninit
     let taken_u = unsafe { mem::replace(uref, mem::uninitialized()) };
-    //~^ ERROR: replacing with `mem::uninitialized()`
+    //~^ mem_replace_with_uninit
+
     *uref = taken_u + 1;
 }
diff --git a/src/tools/clippy/tests/ui/repl_uninit.stderr b/src/tools/clippy/tests/ui/repl_uninit.stderr
index 645c4a16a07e..08b0b265942d 100644
--- a/src/tools/clippy/tests/ui/repl_uninit.stderr
+++ b/src/tools/clippy/tests/ui/repl_uninit.stderr
@@ -14,7 +14,7 @@ LL |         let taken_v = mem::replace(&mut v, mem::MaybeUninit::uninit().assum
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::ptr::read(&mut v)`
 
 error: replacing with `mem::zeroed()`
-  --> tests/ui/repl_uninit.rs:30:23
+  --> tests/ui/repl_uninit.rs:31:23
    |
 LL |         let taken_v = mem::replace(&mut v, mem::zeroed());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL |         let taken_v = mem::replace(&mut v, mem::zeroed());
    = help: consider using a default value or the `take_mut` crate instead
 
 error: replacing with `mem::uninitialized()`
-  --> tests/ui/repl_uninit.rs:43:28
+  --> tests/ui/repl_uninit.rs:45:28
    |
 LL |     let taken_u = unsafe { mem::replace(uref, mem::uninitialized()) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::ptr::read(uref)`
diff --git a/src/tools/clippy/tests/ui/repr_packed_without_abi.rs b/src/tools/clippy/tests/ui/repr_packed_without_abi.rs
index 16b5ededee99..c5f1852e98b8 100644
--- a/src/tools/clippy/tests/ui/repr_packed_without_abi.rs
+++ b/src/tools/clippy/tests/ui/repr_packed_without_abi.rs
@@ -2,12 +2,14 @@
 
 #[repr(packed)]
 struct NetworkPacketHeader {
+    //~^ repr_packed_without_abi
     header_length: u8,
     header_version: u16,
 }
 
 #[repr(packed)]
 union Foo {
+    //~^ repr_packed_without_abi
     a: u8,
     b: u16,
 }
diff --git a/src/tools/clippy/tests/ui/repr_packed_without_abi.stderr b/src/tools/clippy/tests/ui/repr_packed_without_abi.stderr
index 4f7acd00db3d..d1078b3e8e48 100644
--- a/src/tools/clippy/tests/ui/repr_packed_without_abi.stderr
+++ b/src/tools/clippy/tests/ui/repr_packed_without_abi.stderr
@@ -4,6 +4,7 @@ error: item uses `packed` representation without ABI-qualification
 LL |   #[repr(packed)]
    |          ------ `packed` representation set here
 LL | / struct NetworkPacketHeader {
+LL | |
 LL | |     header_length: u8,
 LL | |     header_version: u16,
 LL | | }
@@ -18,11 +19,12 @@ LL | #![deny(clippy::repr_packed_without_abi)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: item uses `packed` representation without ABI-qualification
-  --> tests/ui/repr_packed_without_abi.rs:10:1
+  --> tests/ui/repr_packed_without_abi.rs:11:1
    |
 LL |   #[repr(packed)]
    |          ------ `packed` representation set here
 LL | / union Foo {
+LL | |
 LL | |     a: u8,
 LL | |     b: u16,
 LL | | }
diff --git a/src/tools/clippy/tests/ui/reserve_after_initialization.rs b/src/tools/clippy/tests/ui/reserve_after_initialization.rs
index b57a8e162c53..7f79dac46536 100644
--- a/src/tools/clippy/tests/ui/reserve_after_initialization.rs
+++ b/src/tools/clippy/tests/ui/reserve_after_initialization.rs
@@ -8,6 +8,7 @@ use proc_macros::{external, with_span};
 // Should lint
 fn standard() {
     let mut v1: Vec<usize> = vec![];
+    //~^ reserve_after_initialization
     v1.reserve(10);
 }
 
@@ -15,6 +16,7 @@ fn standard() {
 fn capacity_as_expr() {
     let capacity = 10;
     let mut v2: Vec<usize> = vec![];
+    //~^ reserve_after_initialization
     v2.reserve(capacity);
 }
 
@@ -33,6 +35,7 @@ fn called_with_capacity() {
 fn assign_expression() {
     let mut v5: Vec<usize> = Vec::new();
     v5 = Vec::new();
+    //~^ reserve_after_initialization
     v5.reserve(10);
 }
 
diff --git a/src/tools/clippy/tests/ui/reserve_after_initialization.stderr b/src/tools/clippy/tests/ui/reserve_after_initialization.stderr
index b6dbebb3f14c..e79b59a35d41 100644
--- a/src/tools/clippy/tests/ui/reserve_after_initialization.stderr
+++ b/src/tools/clippy/tests/ui/reserve_after_initialization.stderr
@@ -2,6 +2,7 @@ error: call to `reserve` immediately after creation
   --> tests/ui/reserve_after_initialization.rs:10:5
    |
 LL | /     let mut v1: Vec<usize> = vec![];
+LL | |
 LL | |     v1.reserve(10);
    | |___________________^ help: consider using `Vec::with_capacity(/* Space hint */)`: `let mut v1: Vec<usize> = Vec::with_capacity(10);`
    |
@@ -9,16 +10,18 @@ LL | |     v1.reserve(10);
    = help: to override `-D warnings` add `#[allow(clippy::reserve_after_initialization)]`
 
 error: call to `reserve` immediately after creation
-  --> tests/ui/reserve_after_initialization.rs:17:5
+  --> tests/ui/reserve_after_initialization.rs:18:5
    |
 LL | /     let mut v2: Vec<usize> = vec![];
+LL | |
 LL | |     v2.reserve(capacity);
    | |_________________________^ help: consider using `Vec::with_capacity(/* Space hint */)`: `let mut v2: Vec<usize> = Vec::with_capacity(capacity);`
 
 error: call to `reserve` immediately after creation
-  --> tests/ui/reserve_after_initialization.rs:35:5
+  --> tests/ui/reserve_after_initialization.rs:37:5
    |
 LL | /     v5 = Vec::new();
+LL | |
 LL | |     v5.reserve(10);
    | |___________________^ help: consider using `Vec::with_capacity(/* Space hint */)`: `v5 = Vec::with_capacity(10);`
 
diff --git a/src/tools/clippy/tests/ui/rest_pat_in_fully_bound_structs.rs b/src/tools/clippy/tests/ui/rest_pat_in_fully_bound_structs.rs
index 51fe346d0926..bede01688972 100644
--- a/src/tools/clippy/tests/ui/rest_pat_in_fully_bound_structs.rs
+++ b/src/tools/clippy/tests/ui/rest_pat_in_fully_bound_structs.rs
@@ -21,16 +21,16 @@ fn main() {
 
     match a_struct {
         A { a: 5, b: 42, c: "", .. } => {}, // Lint
-        //~^ ERROR: unnecessary use of `..` pattern in struct binding. All fields were alr
+        //~^ rest_pat_in_fully_bound_structs
         A { a: 0, b: 0, c: "", .. } => {}, // Lint
-        //~^ ERROR: unnecessary use of `..` pattern in struct binding. All fields were alr
+        //~^ rest_pat_in_fully_bound_structs
         _ => {},
     }
 
     match a_struct {
         A { a: 5, b: 42, .. } => {},
         A { a: 0, b: 0, c: "", .. } => {}, // Lint
-        //~^ ERROR: unnecessary use of `..` pattern in struct binding. All fields were alr
+        //~^ rest_pat_in_fully_bound_structs
         _ => {},
     }
 
diff --git a/src/tools/clippy/tests/ui/result_filter_map.rs b/src/tools/clippy/tests/ui/result_filter_map.rs
index bfe47ffcf380..ebd9c4288e3b 100644
--- a/src/tools/clippy/tests/ui/result_filter_map.rs
+++ b/src/tools/clippy/tests/ui/result_filter_map.rs
@@ -11,25 +11,25 @@ fn main() {
     let _ = vec![Ok(1) as Result<i32, ()>]
         .into_iter()
         .filter(Result::is_ok)
-        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        //~^ result_filter_map
         .map(Result::unwrap);
 
     let _ = vec![Ok(1) as Result<i32, ()>]
         .into_iter()
         .filter(|o| o.is_ok())
-        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        //~^ result_filter_map
         .map(|o| o.unwrap());
 
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
         .filter(Result::is_ok)
-        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        //~^ result_filter_map
         .map(Result::unwrap);
     let _ = vec![1]
         .into_iter()
         .map(odds_out)
         .filter(|o| o.is_ok())
-        //~^ ERROR: `filter` for `Ok` followed by `unwrap`
+        //~^ result_filter_map
         .map(|o| o.unwrap());
 }
diff --git a/src/tools/clippy/tests/ui/result_large_err.rs b/src/tools/clippy/tests/ui/result_large_err.rs
index 9c39f023da2d..fa57b3f553fc 100644
--- a/src/tools/clippy/tests/ui/result_large_err.rs
+++ b/src/tools/clippy/tests/ui/result_large_err.rs
@@ -8,7 +8,8 @@ pub fn small_err() -> Result<(), u128> {
 }
 
 pub fn large_err() -> Result<(), [u8; 512]> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(())
 }
 
@@ -20,19 +21,22 @@ pub struct FullyDefinedLargeError {
 
 impl FullyDefinedLargeError {
     pub fn ret() -> Result<(), Self> {
-        //~^ ERROR: the `Err`-variant returned from this function is very large
+        //~^ result_large_err
+
         Ok(())
     }
 }
 
 pub fn struct_error() -> Result<(), FullyDefinedLargeError> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(())
 }
 
 type Fdlr<T> = std::result::Result<T, FullyDefinedLargeError>;
 pub fn large_err_via_type_alias<T>(x: T) -> Fdlr<T> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(x)
 }
 
@@ -41,7 +45,8 @@ pub fn param_small_error<R>() -> Result<(), (R, u128)> {
 }
 
 pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeError)> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(())
 }
 
@@ -53,7 +58,8 @@ pub enum LargeErrorVariants<T> {
 
 impl LargeErrorVariants<()> {
     pub fn large_enum_error() -> Result<(), Self> {
-        //~^ ERROR: the `Err`-variant returned from this function is very large
+        //~^ result_large_err
+
         Ok(())
     }
 }
@@ -66,14 +72,16 @@ enum MultipleLargeVariants {
 
 impl MultipleLargeVariants {
     fn large_enum_error() -> Result<(), Self> {
-        //~^ ERROR: the `Err`-variant returned from this function is very large
+        //~^ result_large_err
+
         Ok(())
     }
 }
 
 trait TraitForcesLargeError {
     fn large_error() -> Result<(), [u8; 512]> {
-        //~^ ERROR: the `Err`-variant returned from this function is very large
+        //~^ result_large_err
+
         Ok(())
     }
 }
@@ -93,7 +101,8 @@ pub union FullyDefinedUnionError {
 }
 
 pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(())
 }
 
@@ -103,7 +112,8 @@ pub union UnionError<T: Copy> {
 }
 
 pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(())
 }
 
@@ -113,12 +123,14 @@ pub struct ArrayError<T, U> {
 }
 
 pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(())
 }
 
 pub fn array_error<T, U>() -> Result<(), ArrayError<(i32, T), U>> {
-    //~^ ERROR: the `Err`-variant returned from this function is very large
+    //~^ result_large_err
+
     Ok(())
 }
 
diff --git a/src/tools/clippy/tests/ui/result_large_err.stderr b/src/tools/clippy/tests/ui/result_large_err.stderr
index 1dff3f9efe81..72fbc3f58961 100644
--- a/src/tools/clippy/tests/ui/result_large_err.stderr
+++ b/src/tools/clippy/tests/ui/result_large_err.stderr
@@ -9,7 +9,7 @@ LL | pub fn large_err() -> Result<(), [u8; 512]> {
    = help: to override `-D warnings` add `#[allow(clippy::result_large_err)]`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:22:21
+  --> tests/ui/result_large_err.rs:23:21
    |
 LL |     pub fn ret() -> Result<(), Self> {
    |                     ^^^^^^^^^^^^^^^^ the `Err`-variant is at least 240 bytes
@@ -17,7 +17,7 @@ LL |     pub fn ret() -> Result<(), Self> {
    = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:28:26
+  --> tests/ui/result_large_err.rs:30:26
    |
 LL | pub fn struct_error() -> Result<(), FullyDefinedLargeError> {
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 240 bytes
@@ -25,7 +25,7 @@ LL | pub fn struct_error() -> Result<(), FullyDefinedLargeError> {
    = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:34:45
+  --> tests/ui/result_large_err.rs:37:45
    |
 LL | pub fn large_err_via_type_alias<T>(x: T) -> Fdlr<T> {
    |                                             ^^^^^^^ the `Err`-variant is at least 240 bytes
@@ -33,7 +33,7 @@ LL | pub fn large_err_via_type_alias<T>(x: T) -> Fdlr<T> {
    = help: try reducing the size of `FullyDefinedLargeError`, for example by boxing large elements or replacing it with `Box<FullyDefinedLargeError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:43:34
+  --> tests/ui/result_large_err.rs:47:34
    |
 LL | pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeError)> {
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 256 bytes
@@ -41,7 +41,7 @@ LL | pub fn param_large_error<R>() -> Result<(), (u128, R, FullyDefinedLargeErro
    = help: try reducing the size of `(u128, R, FullyDefinedLargeError)`, for example by boxing large elements or replacing it with `Box<(u128, R, FullyDefinedLargeError)>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:55:34
+  --> tests/ui/result_large_err.rs:60:34
    |
 LL |     _Omg([u8; 512]),
    |     --------------- the largest variant contains at least 512 bytes
@@ -52,7 +52,7 @@ LL |     pub fn large_enum_error() -> Result<(), Self> {
    = help: try reducing the size of `LargeErrorVariants<()>`, for example by boxing large elements or replacing it with `Box<LargeErrorVariants<()>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:68:30
+  --> tests/ui/result_large_err.rs:74:30
    |
 LL |     _Biggest([u8; 1024]),
    |     -------------------- the largest variant contains at least 1024 bytes
@@ -65,7 +65,7 @@ LL |     fn large_enum_error() -> Result<(), Self> {
    = help: try reducing the size of `MultipleLargeVariants`, for example by boxing large elements or replacing it with `Box<MultipleLargeVariants>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:75:25
+  --> tests/ui/result_large_err.rs:82:25
    |
 LL |     fn large_error() -> Result<(), [u8; 512]> {
    |                         ^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -73,7 +73,7 @@ LL |     fn large_error() -> Result<(), [u8; 512]> {
    = help: try reducing the size of `[u8; 512]`, for example by boxing large elements or replacing it with `Box<[u8; 512]>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:95:29
+  --> tests/ui/result_large_err.rs:103:29
    |
 LL | pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -81,7 +81,7 @@ LL | pub fn large_union_err() -> Result<(), FullyDefinedUnionError> {
    = help: try reducing the size of `FullyDefinedUnionError`, for example by boxing large elements or replacing it with `Box<FullyDefinedUnionError>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:105:40
+  --> tests/ui/result_large_err.rs:114:40
    |
 LL | pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
    |                                        ^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 512 bytes
@@ -89,7 +89,7 @@ LL | pub fn param_large_union<T: Copy>() -> Result<(), UnionError<T>> {
    = help: try reducing the size of `UnionError<T>`, for example by boxing large elements or replacing it with `Box<UnionError<T>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:115:34
+  --> tests/ui/result_large_err.rs:125:34
    |
 LL | pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
@@ -97,7 +97,7 @@ LL | pub fn array_error_subst<U>() -> Result<(), ArrayError<i32, U>> {
    = help: try reducing the size of `ArrayError<i32, U>`, for example by boxing large elements or replacing it with `Box<ArrayError<i32, U>>`
 
 error: the `Err`-variant returned from this function is very large
-  --> tests/ui/result_large_err.rs:120:31
+  --> tests/ui/result_large_err.rs:131:31
    |
 LL | pub fn array_error<T, U>() -> Result<(), ArrayError<(i32, T), U>> {
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the `Err`-variant is at least 128 bytes
diff --git a/src/tools/clippy/tests/ui/result_map_or_into_option.fixed b/src/tools/clippy/tests/ui/result_map_or_into_option.fixed
index cf42b24b2dda..4cf218b84642 100644
--- a/src/tools/clippy/tests/ui/result_map_or_into_option.fixed
+++ b/src/tools/clippy/tests/ui/result_map_or_into_option.fixed
@@ -3,12 +3,14 @@
 fn main() {
     let opt: Result<u32, &str> = Ok(1);
     let _ = opt.ok();
-    //~^ ERROR: called `map_or(None, Some)` on a `Result` value
+    //~^ result_map_or_into_option
+
     let _ = opt.ok();
-    //~^ ERROR: called `map_or_else(|_| None, Some)` on a `Result` value
+    //~^ result_map_or_into_option
+
     #[rustfmt::skip]
     let _ = opt.ok();
-    //~^ ERROR: called `map_or_else(|_| None, Some)` on a `Result` value
+    //~^ result_map_or_into_option
 
     let rewrap = |s: u32| -> Option<u32> { Some(s) };
 
diff --git a/src/tools/clippy/tests/ui/result_map_or_into_option.rs b/src/tools/clippy/tests/ui/result_map_or_into_option.rs
index cdb45d6b82a0..9a0bde8569e8 100644
--- a/src/tools/clippy/tests/ui/result_map_or_into_option.rs
+++ b/src/tools/clippy/tests/ui/result_map_or_into_option.rs
@@ -3,12 +3,14 @@
 fn main() {
     let opt: Result<u32, &str> = Ok(1);
     let _ = opt.map_or(None, Some);
-    //~^ ERROR: called `map_or(None, Some)` on a `Result` value
+    //~^ result_map_or_into_option
+
     let _ = opt.map_or_else(|_| None, Some);
-    //~^ ERROR: called `map_or_else(|_| None, Some)` on a `Result` value
+    //~^ result_map_or_into_option
+
     #[rustfmt::skip]
     let _ = opt.map_or_else(|_| { None }, Some);
-    //~^ ERROR: called `map_or_else(|_| None, Some)` on a `Result` value
+    //~^ result_map_or_into_option
 
     let rewrap = |s: u32| -> Option<u32> { Some(s) };
 
diff --git a/src/tools/clippy/tests/ui/result_map_or_into_option.stderr b/src/tools/clippy/tests/ui/result_map_or_into_option.stderr
index 4cb510d77a06..f9058d35e6c6 100644
--- a/src/tools/clippy/tests/ui/result_map_or_into_option.stderr
+++ b/src/tools/clippy/tests/ui/result_map_or_into_option.stderr
@@ -8,13 +8,13 @@ LL |     let _ = opt.map_or(None, Some);
    = help: to override `-D warnings` add `#[allow(clippy::result_map_or_into_option)]`
 
 error: called `map_or_else(|_| None, Some)` on a `Result` value
-  --> tests/ui/result_map_or_into_option.rs:7:13
+  --> tests/ui/result_map_or_into_option.rs:8:13
    |
 LL |     let _ = opt.map_or_else(|_| None, Some);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `ok`: `opt.ok()`
 
 error: called `map_or_else(|_| None, Some)` on a `Result` value
-  --> tests/ui/result_map_or_into_option.rs:10:13
+  --> tests/ui/result_map_or_into_option.rs:12:13
    |
 LL |     let _ = opt.map_or_else(|_| { None }, Some);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `ok`: `opt.ok()`
diff --git a/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.fixed b/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.fixed
index 3890f916b606..6bee013c3f47 100644
--- a/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.fixed
+++ b/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.fixed
@@ -32,50 +32,68 @@ fn result_map_unit_fn() {
     let _: Result<(), usize> = x.field.map(do_nothing);
 
     if let Ok(x_field) = x.field { do_nothing(x_field) }
+    //~^ result_map_unit_fn
 
     if let Ok(x_field) = x.field { do_nothing(x_field) }
+    //~^ result_map_unit_fn
 
     if let Ok(x_field) = x.field { diverge(x_field) }
+    //~^ result_map_unit_fn
 
     let captured = 10;
     if let Ok(value) = x.field { do_nothing(value + captured) };
     let _: Result<(), usize> = x.field.map(|value| do_nothing(value + captured));
 
     if let Ok(value) = x.field { x.do_result_nothing(value + captured) }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { x.do_result_plus_one(value + captured); }
+    //~^ result_map_unit_fn
 
 
     if let Ok(value) = x.field { do_nothing(value + captured) }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { do_nothing(value + captured) }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { do_nothing(value + captured); }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { do_nothing(value + captured); }
+    //~^ result_map_unit_fn
 
 
     if let Ok(value) = x.field { diverge(value + captured) }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { diverge(value + captured) }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { diverge(value + captured); }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { diverge(value + captured); }
+    //~^ result_map_unit_fn
 
 
     x.field.map(|value| plus_one(value + captured));
     x.field.map(|value| { plus_one(value + captured) });
     if let Ok(value) = x.field { let y = plus_one(value + captured); }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { plus_one(value + captured); }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { plus_one(value + captured); }
+    //~^ result_map_unit_fn
 
 
     if let Ok(ref value) = x.field { do_nothing(value + captured) }
+    //~^ result_map_unit_fn
 
     if let Ok(value) = x.field { println!("{:?}", value) }
+    //~^ result_map_unit_fn
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.rs b/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.rs
index c3f5aca7bfbe..a206cfe6842f 100644
--- a/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.rs
+++ b/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.rs
@@ -32,50 +32,68 @@ fn result_map_unit_fn() {
     let _: Result<(), usize> = x.field.map(do_nothing);
 
     x.field.map(do_nothing);
+    //~^ result_map_unit_fn
 
     x.field.map(do_nothing);
+    //~^ result_map_unit_fn
 
     x.field.map(diverge);
+    //~^ result_map_unit_fn
 
     let captured = 10;
     if let Ok(value) = x.field { do_nothing(value + captured) };
     let _: Result<(), usize> = x.field.map(|value| do_nothing(value + captured));
 
     x.field.map(|value| x.do_result_nothing(value + captured));
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { x.do_result_plus_one(value + captured); });
+    //~^ result_map_unit_fn
 
 
     x.field.map(|value| do_nothing(value + captured));
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { do_nothing(value + captured) });
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { do_nothing(value + captured); });
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { { do_nothing(value + captured); } });
+    //~^ result_map_unit_fn
 
 
     x.field.map(|value| diverge(value + captured));
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { diverge(value + captured) });
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { diverge(value + captured); });
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { { diverge(value + captured); } });
+    //~^ result_map_unit_fn
 
 
     x.field.map(|value| plus_one(value + captured));
     x.field.map(|value| { plus_one(value + captured) });
     x.field.map(|value| { let y = plus_one(value + captured); });
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { plus_one(value + captured); });
+    //~^ result_map_unit_fn
 
     x.field.map(|value| { { plus_one(value + captured); } });
+    //~^ result_map_unit_fn
 
 
     x.field.map(|ref value| { do_nothing(value + captured) });
+    //~^ result_map_unit_fn
 
     x.field.map(|value| println!("{:?}", value));
+    //~^ result_map_unit_fn
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.stderr b/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.stderr
index 4f3bc2e95449..eca844e06cc0 100644
--- a/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.stderr
+++ b/src/tools/clippy/tests/ui/result_map_unit_fn_fixable.stderr
@@ -10,7 +10,7 @@ LL |     x.field.map(do_nothing);
    = help: to override `-D warnings` add `#[allow(clippy::result_map_unit_fn)]`
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:36:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:37:5
    |
 LL |     x.field.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^^^^^^^-
@@ -18,7 +18,7 @@ LL |     x.field.map(do_nothing);
    |     help: try: `if let Ok(x_field) = x.field { do_nothing(x_field) }`
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:38:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:40:5
    |
 LL |     x.field.map(diverge);
    |     ^^^^^^^^^^^^^^^^^^^^-
@@ -26,7 +26,7 @@ LL |     x.field.map(diverge);
    |     help: try: `if let Ok(x_field) = x.field { diverge(x_field) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:44:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:47:5
    |
 LL |     x.field.map(|value| x.do_result_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -34,7 +34,7 @@ LL |     x.field.map(|value| x.do_result_nothing(value + captured));
    |     help: try: `if let Ok(value) = x.field { x.do_result_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:46:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:50:5
    |
 LL |     x.field.map(|value| { x.do_result_plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -42,7 +42,7 @@ LL |     x.field.map(|value| { x.do_result_plus_one(value + captured); });
    |     help: try: `if let Ok(value) = x.field { x.do_result_plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:49:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:54:5
    |
 LL |     x.field.map(|value| do_nothing(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -50,7 +50,7 @@ LL |     x.field.map(|value| do_nothing(value + captured));
    |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:51:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:57:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -58,7 +58,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured) });
    |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:53:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:60:5
    |
 LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -66,7 +66,7 @@ LL |     x.field.map(|value| { do_nothing(value + captured); });
    |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:55:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:63:5
    |
 LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -74,7 +74,7 @@ LL |     x.field.map(|value| { { do_nothing(value + captured); } });
    |     help: try: `if let Ok(value) = x.field { do_nothing(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:58:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:67:5
    |
 LL |     x.field.map(|value| diverge(value + captured));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -82,7 +82,7 @@ LL |     x.field.map(|value| diverge(value + captured));
    |     help: try: `if let Ok(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:60:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:70:5
    |
 LL |     x.field.map(|value| { diverge(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -90,7 +90,7 @@ LL |     x.field.map(|value| { diverge(value + captured) });
    |     help: try: `if let Ok(value) = x.field { diverge(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:62:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:73:5
    |
 LL |     x.field.map(|value| { diverge(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -98,7 +98,7 @@ LL |     x.field.map(|value| { diverge(value + captured); });
    |     help: try: `if let Ok(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:64:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:76:5
    |
 LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -106,7 +106,7 @@ LL |     x.field.map(|value| { { diverge(value + captured); } });
    |     help: try: `if let Ok(value) = x.field { diverge(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:69:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:82:5
    |
 LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -114,7 +114,7 @@ LL |     x.field.map(|value| { let y = plus_one(value + captured); });
    |     help: try: `if let Ok(value) = x.field { let y = plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:71:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:85:5
    |
 LL |     x.field.map(|value| { plus_one(value + captured); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -122,7 +122,7 @@ LL |     x.field.map(|value| { plus_one(value + captured); });
    |     help: try: `if let Ok(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:73:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:88:5
    |
 LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -130,7 +130,7 @@ LL |     x.field.map(|value| { { plus_one(value + captured); } });
    |     help: try: `if let Ok(value) = x.field { plus_one(value + captured); }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:76:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:92:5
    |
 LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -138,7 +138,7 @@ LL |     x.field.map(|ref value| { do_nothing(value + captured) });
    |     help: try: `if let Ok(ref value) = x.field { do_nothing(value + captured) }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_fixable.rs:78:5
+  --> tests/ui/result_map_unit_fn_fixable.rs:95:5
    |
 LL |     x.field.map(|value| println!("{:?}", value));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
diff --git a/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.rs b/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.rs
index 62798b6d3d6f..fe3d8ece39f4 100644
--- a/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.rs
+++ b/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.rs
@@ -21,33 +21,39 @@ fn result_map_unit_fn() {
     let x = HasResult { field: Ok(10) };
 
     x.field.map(|value| { do_nothing(value); do_nothing(value) });
-    //~^ ERROR: called `map(f)` on an `Result` value where `f` is a closure that returns t
-    //~| NOTE: `-D clippy::result-map-unit-fn` implied by `-D warnings`
+    //~^ result_map_unit_fn
+
+
 
     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
-    //~^ ERROR: called `map(f)` on an `Result` value where `f` is a closure that returns t
+    //~^ result_map_unit_fn
+
 
     // Suggestion for the let block should be `{ ... }` as it's too difficult to build a
     // proper suggestion for these cases
     x.field.map(|value| {
-    //~^ ERROR: called `map(f)` on an `Result` value where `f` is a closure that returns t
+    //~^ result_map_unit_fn
+
         do_nothing(value);
         do_nothing(value)
     });
     x.field.map(|value| { do_nothing(value); do_nothing(value); });
-    //~^ ERROR: called `map(f)` on an `Result` value where `f` is a closure that returns t
+    //~^ result_map_unit_fn
+
 
     // The following should suggest `if let Ok(_X) ...` as it's difficult to generate a proper let variable name for them
     let res: Result<!, usize> = Ok(42).map(diverge);
     "12".parse::<i32>().map(diverge);
-    //~^ ERROR: called `map(f)` on an `Result` value where `f` is a function that returns
+    //~^ result_map_unit_fn
+
 
     let res: Result<(), usize> = Ok(plus_one(1)).map(do_nothing);
 
     // Should suggest `if let Ok(_y) ...` to not override the existing foo variable
     let y: Result<usize, usize> = Ok(42);
     y.map(do_nothing);
-    //~^ ERROR: called `map(f)` on an `Result` value where `f` is a function that returns
+    //~^ result_map_unit_fn
+
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.stderr b/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.stderr
index d69c86c70e29..a6e38d808afa 100644
--- a/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/result_map_unit_fn_unfixable.stderr
@@ -10,7 +10,7 @@ LL |     x.field.map(|value| { do_nothing(value); do_nothing(value) });
    = help: to override `-D warnings` add `#[allow(clippy::result_map_unit_fn)]`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:27:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:28:5
    |
 LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value) });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -18,10 +18,11 @@ LL |     x.field.map(|value| if value > 0 { do_nothing(value); do_nothing(value)
    |     help: try: `if let Ok(value) = x.field { ... }`
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:32:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:34:5
    |
 LL | //     x.field.map(|value| {
 LL | ||
+LL | ||
 LL | ||         do_nothing(value);
 LL | ||         do_nothing(value)
 LL | ||     });
@@ -30,7 +31,7 @@ LL | ||     });
    |
 
 error: called `map(f)` on an `Result` value where `f` is a closure that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:37:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:40:5
    |
 LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -38,7 +39,7 @@ LL |     x.field.map(|value| { do_nothing(value); do_nothing(value); });
    |     help: try: `if let Ok(value) = x.field { ... }`
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:42:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:46:5
    |
 LL |     "12".parse::<i32>().map(diverge);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-
@@ -46,7 +47,7 @@ LL |     "12".parse::<i32>().map(diverge);
    |     help: try: `if let Ok(a) = "12".parse::<i32>() { diverge(a) }`
 
 error: called `map(f)` on an `Result` value where `f` is a function that returns the unit type `()`
-  --> tests/ui/result_map_unit_fn_unfixable.rs:49:5
+  --> tests/ui/result_map_unit_fn_unfixable.rs:54:5
    |
 LL |     y.map(do_nothing);
    |     ^^^^^^^^^^^^^^^^^-
diff --git a/src/tools/clippy/tests/ui/result_unit_error.rs b/src/tools/clippy/tests/ui/result_unit_error.rs
index f3159f2e9515..ddbe0eb556c8 100644
--- a/src/tools/clippy/tests/ui/result_unit_error.rs
+++ b/src/tools/clippy/tests/ui/result_unit_error.rs
@@ -1,7 +1,8 @@
 #![warn(clippy::result_unit_err)]
 
 pub fn returns_unit_error() -> Result<u32, ()> {
-    //~^ ERROR: this returns a `Result<_, ()>`
+    //~^ result_unit_err
+
     Err(())
 }
 
@@ -11,10 +12,11 @@ fn private_unit_errors() -> Result<String, ()> {
 
 pub trait HasUnitError {
     fn get_that_error(&self) -> Result<bool, ()>;
-    //~^ ERROR: this returns a `Result<_, ()>`
+    //~^ result_unit_err
 
     fn get_this_one_too(&self) -> Result<bool, ()> {
-        //~^ ERROR: this returns a `Result<_, ()>`
+        //~^ result_unit_err
+
         Err(())
     }
 }
@@ -33,7 +35,8 @@ pub struct UnitErrorHolder;
 
 impl UnitErrorHolder {
     pub fn unit_error(&self) -> Result<usize, ()> {
-        //~^ ERROR: this returns a `Result<_, ()>`
+        //~^ result_unit_err
+
         Ok(0)
     }
 }
@@ -43,7 +46,8 @@ pub mod issue_6546 {
     type ResInv<A, B> = Result<B, A>;
 
     pub fn should_lint() -> ResInv<(), usize> {
-        //~^ ERROR: this returns a `Result<_, ()>`
+        //~^ result_unit_err
+
         Ok(0)
     }
 
diff --git a/src/tools/clippy/tests/ui/result_unit_error.stderr b/src/tools/clippy/tests/ui/result_unit_error.stderr
index e869a3159775..d6c0924d8868 100644
--- a/src/tools/clippy/tests/ui/result_unit_error.stderr
+++ b/src/tools/clippy/tests/ui/result_unit_error.stderr
@@ -9,7 +9,7 @@ LL | pub fn returns_unit_error() -> Result<u32, ()> {
    = help: to override `-D warnings` add `#[allow(clippy::result_unit_err)]`
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/result_unit_error.rs:13:5
+  --> tests/ui/result_unit_error.rs:14:5
    |
 LL |     fn get_that_error(&self) -> Result<bool, ()>;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     fn get_that_error(&self) -> Result<bool, ()>;
    = help: use a custom `Error` type instead
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/result_unit_error.rs:16:5
+  --> tests/ui/result_unit_error.rs:17:5
    |
 LL |     fn get_this_one_too(&self) -> Result<bool, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     fn get_this_one_too(&self) -> Result<bool, ()> {
    = help: use a custom `Error` type instead
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/result_unit_error.rs:35:5
+  --> tests/ui/result_unit_error.rs:37:5
    |
 LL |     pub fn unit_error(&self) -> Result<usize, ()> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     pub fn unit_error(&self) -> Result<usize, ()> {
    = help: use a custom `Error` type instead
 
 error: this returns a `Result<_, ()>`
-  --> tests/ui/result_unit_error.rs:45:5
+  --> tests/ui/result_unit_error.rs:48:5
    |
 LL |     pub fn should_lint() -> ResInv<(), usize> {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/result_unit_error_no_std.rs b/src/tools/clippy/tests/ui/result_unit_error_no_std.rs
index c9f4996c3689..8a1849b8490a 100644
--- a/src/tools/clippy/tests/ui/result_unit_error_no_std.rs
+++ b/src/tools/clippy/tests/ui/result_unit_error_no_std.rs
@@ -10,6 +10,7 @@ pub fn returns_unit_error_no_lint() -> Result<u32, ()> {
 
 #[clippy::msrv = "1.81"]
 pub fn returns_unit_error_lint() -> Result<u32, ()> {
+    //~^ result_unit_err
     Err(())
 }
 
diff --git a/src/tools/clippy/tests/ui/return_and_then.fixed b/src/tools/clippy/tests/ui/return_and_then.fixed
index 9736a51ac868..74efa14eeec8 100644
--- a/src/tools/clippy/tests/ui/return_and_then.fixed
+++ b/src/tools/clippy/tests/ui/return_and_then.fixed
@@ -3,6 +3,7 @@
 fn main() {
     fn test_opt_block(opt: Option<i32>) -> Option<i32> {
         let n = opt?;
+        //~^ return_and_then
         let mut ret = n + 1;
         ret += n;
         if n > 1 { Some(ret) } else { None }
@@ -11,32 +12,38 @@ fn main() {
     fn test_opt_func(opt: Option<i32>) -> Option<i32> {
         let n = opt?;
         test_opt_block(Some(n))
+        //~^ return_and_then
     }
 
     fn test_call_chain() -> Option<i32> {
         let n = gen_option(1)?;
         test_opt_block(Some(n))
+        //~^ return_and_then
     }
 
     fn test_res_block(opt: Result<i32, i32>) -> Result<i32, i32> {
         let n = opt?;
         if n > 1 { Ok(n + 1) } else { Err(n) }
+        //~^ return_and_then
     }
 
     fn test_res_func(opt: Result<i32, i32>) -> Result<i32, i32> {
         let n = opt?;
         test_res_block(Ok(n))
+        //~^ return_and_then
     }
 
     fn test_ref_only() -> Option<i32> {
         // ref: empty string
         let x = Some("")?;
         if x.len() > 2 { Some(3) } else { None }
+        //~^ return_and_then
     }
 
     fn test_tmp_only() -> Option<i32> {
         // unused temporary: vec![1, 2, 4]
         let x = Some(match (vec![1, 2, 3], vec![1, 2, 4]) {
+            //~^ return_and_then
             (a, _) if a.len() > 1 => a,
             (_, b) => b,
         })?;
diff --git a/src/tools/clippy/tests/ui/return_and_then.rs b/src/tools/clippy/tests/ui/return_and_then.rs
index 8bcbdfc3a632..188dc57e588c 100644
--- a/src/tools/clippy/tests/ui/return_and_then.rs
+++ b/src/tools/clippy/tests/ui/return_and_then.rs
@@ -3,6 +3,7 @@
 fn main() {
     fn test_opt_block(opt: Option<i32>) -> Option<i32> {
         opt.and_then(|n| {
+            //~^ return_and_then
             let mut ret = n + 1;
             ret += n;
             if n > 1 { Some(ret) } else { None }
@@ -11,28 +12,34 @@ fn main() {
 
     fn test_opt_func(opt: Option<i32>) -> Option<i32> {
         opt.and_then(|n| test_opt_block(Some(n)))
+        //~^ return_and_then
     }
 
     fn test_call_chain() -> Option<i32> {
         gen_option(1).and_then(|n| test_opt_block(Some(n)))
+        //~^ return_and_then
     }
 
     fn test_res_block(opt: Result<i32, i32>) -> Result<i32, i32> {
         opt.and_then(|n| if n > 1 { Ok(n + 1) } else { Err(n) })
+        //~^ return_and_then
     }
 
     fn test_res_func(opt: Result<i32, i32>) -> Result<i32, i32> {
         opt.and_then(|n| test_res_block(Ok(n)))
+        //~^ return_and_then
     }
 
     fn test_ref_only() -> Option<i32> {
         // ref: empty string
         Some("").and_then(|x| if x.len() > 2 { Some(3) } else { None })
+        //~^ return_and_then
     }
 
     fn test_tmp_only() -> Option<i32> {
         // unused temporary: vec![1, 2, 4]
         Some(match (vec![1, 2, 3], vec![1, 2, 4]) {
+            //~^ return_and_then
             (a, _) if a.len() > 1 => a,
             (_, b) => b,
         })
diff --git a/src/tools/clippy/tests/ui/return_and_then.stderr b/src/tools/clippy/tests/ui/return_and_then.stderr
index b2e8bf2ca45a..cc611c3dba67 100644
--- a/src/tools/clippy/tests/ui/return_and_then.stderr
+++ b/src/tools/clippy/tests/ui/return_and_then.stderr
@@ -2,6 +2,7 @@ error: use the question mark operator instead of an `and_then` call
   --> tests/ui/return_and_then.rs:5:9
    |
 LL | /         opt.and_then(|n| {
+LL | |
 LL | |             let mut ret = n + 1;
 LL | |             ret += n;
 LL | |             if n > 1 { Some(ret) } else { None }
@@ -13,13 +14,14 @@ LL | |         })
 help: try
    |
 LL ~         let n = opt?;
+LL +
 LL +         let mut ret = n + 1;
 LL +         ret += n;
 LL +         if n > 1 { Some(ret) } else { None }
    |
 
 error: use the question mark operator instead of an `and_then` call
-  --> tests/ui/return_and_then.rs:13:9
+  --> tests/ui/return_and_then.rs:14:9
    |
 LL |         opt.and_then(|n| test_opt_block(Some(n)))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -31,7 +33,7 @@ LL +         test_opt_block(Some(n))
    |
 
 error: use the question mark operator instead of an `and_then` call
-  --> tests/ui/return_and_then.rs:17:9
+  --> tests/ui/return_and_then.rs:19:9
    |
 LL |         gen_option(1).and_then(|n| test_opt_block(Some(n)))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -43,7 +45,7 @@ LL +         test_opt_block(Some(n))
    |
 
 error: use the question mark operator instead of an `and_then` call
-  --> tests/ui/return_and_then.rs:21:9
+  --> tests/ui/return_and_then.rs:24:9
    |
 LL |         opt.and_then(|n| if n > 1 { Ok(n + 1) } else { Err(n) })
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -55,7 +57,7 @@ LL +         if n > 1 { Ok(n + 1) } else { Err(n) }
    |
 
 error: use the question mark operator instead of an `and_then` call
-  --> tests/ui/return_and_then.rs:25:9
+  --> tests/ui/return_and_then.rs:29:9
    |
 LL |         opt.and_then(|n| test_res_block(Ok(n)))
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -67,7 +69,7 @@ LL +         test_res_block(Ok(n))
    |
 
 error: use the question mark operator instead of an `and_then` call
-  --> tests/ui/return_and_then.rs:30:9
+  --> tests/ui/return_and_then.rs:35:9
    |
 LL |         Some("").and_then(|x| if x.len() > 2 { Some(3) } else { None })
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -79,9 +81,10 @@ LL +         if x.len() > 2 { Some(3) } else { None }
    |
 
 error: use the question mark operator instead of an `and_then` call
-  --> tests/ui/return_and_then.rs:35:9
+  --> tests/ui/return_and_then.rs:41:9
    |
 LL | /         Some(match (vec![1, 2, 3], vec![1, 2, 4]) {
+LL | |
 LL | |             (a, _) if a.len() > 1 => a,
 LL | |             (_, b) => b,
 LL | |         })
@@ -91,6 +94,7 @@ LL | |         .and_then(|x| if x.len() > 2 { Some(3) } else { None })
 help: try
    |
 LL ~         let x = Some(match (vec![1, 2, 3], vec![1, 2, 4]) {
+LL +
 LL +             (a, _) if a.len() > 1 => a,
 LL +             (_, b) => b,
 LL +         })?;
diff --git a/src/tools/clippy/tests/ui/return_self_not_must_use.rs b/src/tools/clippy/tests/ui/return_self_not_must_use.rs
index ec6f0feb8e65..83965662d15e 100644
--- a/src/tools/clippy/tests/ui/return_self_not_must_use.rs
+++ b/src/tools/clippy/tests/ui/return_self_not_must_use.rs
@@ -6,7 +6,8 @@ pub struct Bar;
 
 pub trait Whatever {
     fn what(&self) -> Self;
-    //~^ ERROR: missing `#[must_use]` attribute on a method returning `Self`
+    //~^ return_self_not_must_use
+
     // There should be no warning here! (returns a reference)
     fn what2(&self) -> &Self;
 }
@@ -17,11 +18,13 @@ impl Bar {
         Self
     }
     pub fn foo(&self) -> Self {
-        //~^ ERROR: missing `#[must_use]` attribute on a method returning `Self`
+        //~^ return_self_not_must_use
+
         Self
     }
     pub fn bar(self) -> Self {
-        //~^ ERROR: missing `#[must_use]` attribute on a method returning `Self`
+        //~^ return_self_not_must_use
+
         self
     }
     // There should be no warning here! (private method)
diff --git a/src/tools/clippy/tests/ui/return_self_not_must_use.stderr b/src/tools/clippy/tests/ui/return_self_not_must_use.stderr
index 01f826b94a80..3e6a28f32920 100644
--- a/src/tools/clippy/tests/ui/return_self_not_must_use.stderr
+++ b/src/tools/clippy/tests/ui/return_self_not_must_use.stderr
@@ -9,10 +9,11 @@ LL |     fn what(&self) -> Self;
    = help: to override `-D warnings` add `#[allow(clippy::return_self_not_must_use)]`
 
 error: missing `#[must_use]` attribute on a method returning `Self`
-  --> tests/ui/return_self_not_must_use.rs:19:5
+  --> tests/ui/return_self_not_must_use.rs:20:5
    |
 LL | /     pub fn foo(&self) -> Self {
 LL | |
+LL | |
 LL | |         Self
 LL | |     }
    | |_____^
@@ -20,10 +21,11 @@ LL | |     }
    = help: consider adding the `#[must_use]` attribute to the method or directly to the `Self` type
 
 error: missing `#[must_use]` attribute on a method returning `Self`
-  --> tests/ui/return_self_not_must_use.rs:23:5
+  --> tests/ui/return_self_not_must_use.rs:25:5
    |
 LL | /     pub fn bar(self) -> Self {
 LL | |
+LL | |
 LL | |         self
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.fixed b/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.fixed
index c8bf1b35085d..ba5059bbaa37 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.fixed
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.fixed
@@ -7,10 +7,14 @@ fn main() {
     // These should be linted:
 
     (21..=42).rev().for_each(|x| println!("{}", x));
+    //~^ reversed_empty_ranges
     let _ = (21..ANSWER).rev().filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
+    //~^ reversed_empty_ranges
 
     for _ in (-42..=-21).rev() {}
+    //~^ reversed_empty_ranges
     for _ in (21u32..42u32).rev() {}
+    //~^ reversed_empty_ranges
 
     // These should be ignored as they are not empty ranges:
 
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.rs b/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.rs
index 6733c096420b..4068bc393066 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.rs
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.rs
@@ -7,10 +7,14 @@ fn main() {
     // These should be linted:
 
     (42..=21).for_each(|x| println!("{}", x));
+    //~^ reversed_empty_ranges
     let _ = (ANSWER..21).filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
+    //~^ reversed_empty_ranges
 
     for _ in -21..=-42 {}
+    //~^ reversed_empty_ranges
     for _ in 42u32..21u32 {}
+    //~^ reversed_empty_ranges
 
     // These should be ignored as they are not empty ranges:
 
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.stderr b/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.stderr
index 24cb959c96af..3fadc4c169f1 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.stderr
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_fixable.stderr
@@ -13,7 +13,7 @@ LL +     (21..=42).rev().for_each(|x| println!("{}", x));
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_fixable.rs:10:13
+  --> tests/ui/reversed_empty_ranges_fixable.rs:11:13
    |
 LL |     let _ = (ANSWER..21).filter(|x| x % 2 == 0).take(10).collect::<Vec<_>>();
    |             ^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     let _ = (21..ANSWER).rev().filter(|x| x % 2 == 0).take(10).collect::<Ve
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_fixable.rs:12:14
+  --> tests/ui/reversed_empty_ranges_fixable.rs:14:14
    |
 LL |     for _ in -21..=-42 {}
    |              ^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     for _ in (-42..=-21).rev() {}
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_fixable.rs:13:14
+  --> tests/ui/reversed_empty_ranges_fixable.rs:16:14
    |
 LL |     for _ in 42u32..21u32 {}
    |              ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.fixed b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.fixed
index df5f2c441f41..55080da8a137 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.fixed
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.fixed
@@ -5,14 +5,17 @@ fn main() {
     const MAX_LEN: usize = 42;
 
     for i in (0..10).rev() {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     for i in (0..=10).rev() {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     for i in (0..MAX_LEN).rev() {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
@@ -32,15 +35,18 @@ fn main() {
     }
 
     for i in (0..10).rev().map(|x| x * 2) {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     // testing that the empty range lint folds constants
     for i in (5 + 4..10).rev() {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     for i in ((3 - 1)..(5 + 2)).rev() {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.rs b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.rs
index 92481be6cfc9..e51557bc2796 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.rs
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.rs
@@ -5,14 +5,17 @@ fn main() {
     const MAX_LEN: usize = 42;
 
     for i in 10..0 {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     for i in 10..=0 {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     for i in MAX_LEN..0 {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
@@ -32,15 +35,18 @@ fn main() {
     }
 
     for i in (10..0).map(|x| x * 2) {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     // testing that the empty range lint folds constants
     for i in 10..5 + 4 {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
     for i in (5 + 2)..(3 - 1) {
+        //~^ reversed_empty_ranges
         println!("{}", i);
     }
 
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.stderr b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.stderr
index 3e9ccb653fe7..eadd9d3675e1 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.stderr
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_fixable.stderr
@@ -13,7 +13,7 @@ LL +     for i in (0..10).rev() {
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:11:14
+  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:12:14
    |
 LL |     for i in 10..=0 {
    |              ^^^^^^
@@ -25,7 +25,7 @@ LL +     for i in (0..=10).rev() {
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:15:14
+  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:17:14
    |
 LL |     for i in MAX_LEN..0 {
    |              ^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     for i in (0..MAX_LEN).rev() {
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:34:14
+  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:37:14
    |
 LL |     for i in (10..0).map(|x| x * 2) {
    |              ^^^^^^^
@@ -49,7 +49,7 @@ LL +     for i in (0..10).rev().map(|x| x * 2) {
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:39:14
+  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:43:14
    |
 LL |     for i in 10..5 + 4 {
    |              ^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     for i in (5 + 4..10).rev() {
    |
 
 error: this range is empty so it will yield no values
-  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:43:14
+  --> tests/ui/reversed_empty_ranges_loops_fixable.rs:48:14
    |
 LL |     for i in (5 + 2)..(3 - 1) {
    |              ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_unfixable.rs b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_unfixable.rs
index cd1701dd4bf2..00aa20d25bda 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_unfixable.rs
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_loops_unfixable.rs
@@ -3,13 +3,14 @@
 
 fn main() {
     for i in 5..5 {
-        //~^ ERROR: this range is empty so it will yield no values
-        //~| NOTE: `-D clippy::reversed-empty-ranges` implied by `-D warnings`
+        //~^ reversed_empty_ranges
+
         println!("{}", i);
     }
 
     for i in (5 + 2)..(8 - 1) {
-        //~^ ERROR: this range is empty so it will yield no values
+        //~^ reversed_empty_ranges
+
         println!("{}", i);
     }
 }
diff --git a/src/tools/clippy/tests/ui/reversed_empty_ranges_unfixable.rs b/src/tools/clippy/tests/ui/reversed_empty_ranges_unfixable.rs
index 16c1121ae069..7bf434544378 100644
--- a/src/tools/clippy/tests/ui/reversed_empty_ranges_unfixable.rs
+++ b/src/tools/clippy/tests/ui/reversed_empty_ranges_unfixable.rs
@@ -6,13 +6,13 @@ const SOME_NUM: usize = 3;
 fn main() {
     let arr = [1, 2, 3, 4, 5];
     let _ = &arr[3usize..=1usize];
-    //~^ ERROR: this range is reversed and using it to index a slice will panic at run-tim
-    //~| NOTE: `-D clippy::reversed-empty-ranges` implied by `-D warnings`
+    //~^ reversed_empty_ranges
+
     let _ = &arr[SOME_NUM..1];
-    //~^ ERROR: this range is reversed and using it to index a slice will panic at run-tim
+    //~^ reversed_empty_ranges
 
     for _ in ANSWER..ANSWER {}
-    //~^ ERROR: this range is empty so it will yield no values
+    //~^ reversed_empty_ranges
 
     // Should not be linted, see issue #5689
     let _ = (42 + 10..42 + 10).map(|x| x / 2).find(|&x| x == 21);
diff --git a/src/tools/clippy/tests/ui/same_functions_in_if_condition.rs b/src/tools/clippy/tests/ui/same_functions_in_if_condition.rs
index a207e4221355..b7ed3aab0043 100644
--- a/src/tools/clippy/tests/ui/same_functions_in_if_condition.rs
+++ b/src/tools/clippy/tests/ui/same_functions_in_if_condition.rs
@@ -37,33 +37,33 @@ fn ifs_same_cond_fn() {
 
     if function() {
     } else if function() {
-        //~^ ERROR: `if` has the same function call as a previous `if`
+        //~^ same_functions_in_if_condition
     }
 
     if fn_arg(a) {
     } else if fn_arg(a) {
-        //~^ ERROR: `if` has the same function call as a previous `if`
+        //~^ same_functions_in_if_condition
     }
 
     if obj.method() {
     } else if obj.method() {
-        //~^ ERROR: `if` has the same function call as a previous `if`
+        //~^ same_functions_in_if_condition
     }
 
     if obj.method_arg(a) {
     } else if obj.method_arg(a) {
-        //~^ ERROR: `if` has the same function call as a previous `if`
+        //~^ same_functions_in_if_condition
     }
 
     let mut v = vec![1];
     if v.pop().is_none() {
     } else if v.pop().is_none() {
-        //~^ ERROR: `if` has the same function call as a previous `if`
+        //~^ same_functions_in_if_condition
     }
 
     if v.len() == 42 {
     } else if v.len() == 42 {
-        //~^ ERROR: `if` has the same function call as a previous `if`
+        //~^ same_functions_in_if_condition
     }
 
     if v.len() == 1 {
diff --git a/src/tools/clippy/tests/ui/same_item_push.rs b/src/tools/clippy/tests/ui/same_item_push.rs
index 87fd59ad3179..a08e8872a932 100644
--- a/src/tools/clippy/tests/ui/same_item_push.rs
+++ b/src/tools/clippy/tests/ui/same_item_push.rs
@@ -21,33 +21,33 @@ fn main() {
     let item = 2;
     for _ in 5..=20 {
         vec.push(item);
-        //~^ ERROR: it looks like the same item is being pushed into this `Vec`
+        //~^ same_item_push
     }
 
     let mut vec: Vec<u8> = Vec::new();
     for _ in 0..15 {
         let item = 2;
         vec.push(item);
-        //~^ ERROR: it looks like the same item is being pushed into this `Vec`
+        //~^ same_item_push
     }
 
     let mut vec: Vec<u8> = Vec::new();
     for _ in 0..15 {
         vec.push(13);
-        //~^ ERROR: it looks like the same item is being pushed into this `Vec`
+        //~^ same_item_push
     }
 
     let mut vec = Vec::new();
     for _ in 0..20 {
         vec.push(VALUE);
-        //~^ ERROR: it looks like the same item is being pushed into this `Vec`
+        //~^ same_item_push
     }
 
     let mut vec = Vec::new();
     let item = VALUE;
     for _ in 0..20 {
         vec.push(item);
-        //~^ ERROR: it looks like the same item is being pushed into this `Vec`
+        //~^ same_item_push
     }
 
     #[clippy::msrv = "1.81"]
@@ -56,7 +56,7 @@ fn main() {
         let item = VALUE;
         for _ in 0..20 {
             vec.push(item);
-            //~^ ERROR: it looks like the same item is being pushed into this `Vec`
+            //~^ same_item_push
         }
     }
 
diff --git a/src/tools/clippy/tests/ui/same_name_method.rs b/src/tools/clippy/tests/ui/same_name_method.rs
index ba876c2b5a3f..43c664b1505f 100644
--- a/src/tools/clippy/tests/ui/same_name_method.rs
+++ b/src/tools/clippy/tests/ui/same_name_method.rs
@@ -18,7 +18,7 @@ mod should_lint {
 
         impl S {
             fn foo() {}
-            //~^ ERROR: method's name is the same as an existing method in a trait
+            //~^ same_name_method
         }
 
         impl T1 for S {
@@ -33,7 +33,7 @@ mod should_lint {
 
         impl S {
             fn clone() {}
-            //~^ ERROR: method's name is the same as an existing method in a trait
+            //~^ same_name_method
         }
     }
 
@@ -44,7 +44,7 @@ mod should_lint {
 
         impl<U> S<U> {
             fn foo() {}
-            //~^ ERROR: method's name is the same as an existing method in a trait
+            //~^ same_name_method
         }
 
         impl<U: Copy> T1 for S<U> {
@@ -59,7 +59,7 @@ mod should_lint {
 
         impl S {
             fn foo() {}
-            //~^ ERROR: method's name is the same as an existing method in a trait
+            //~^ same_name_method
         }
 
         impl T1 for S {}
@@ -72,8 +72,8 @@ mod should_lint {
 
         impl S {
             fn foo() {}
-            //~^ ERROR: method's name is the same as an existing method in a trait
-            //~| ERROR: method's name is the same as an existing method in a trait
+            //~^ same_name_method
+            //~| same_name_method
         }
 
         impl T1 for S {}
diff --git a/src/tools/clippy/tests/ui/search_is_some.rs b/src/tools/clippy/tests/ui/search_is_some.rs
index 9a9aaba56adc..4143b8bfba58 100644
--- a/src/tools/clippy/tests/ui/search_is_some.rs
+++ b/src/tools/clippy/tests/ui/search_is_some.rs
@@ -14,18 +14,21 @@ fn main() {
 
     // Check `find().is_some()`, multi-line case.
     let _ = v.iter().find(|&x| {
+    //~^ search_is_some
                               *x < 0
                           }
                    ).is_some();
 
     // Check `position().is_some()`, multi-line case.
     let _ = v.iter().position(|&x| {
+    //~^ search_is_some
                                   x < 0
                               }
                    ).is_some();
 
     // Check `rposition().is_some()`, multi-line case.
     let _ = v.iter().rposition(|&x| {
+    //~^ search_is_some
                                    x < 0
                                }
                    ).is_some();
@@ -41,6 +44,7 @@ fn main() {
 
     let some_closure = |x: &u32| *x == 0;
     let _ = (0..1).find(some_closure).is_some();
+    //~^ search_is_some
 }
 
 #[rustfmt::skip]
@@ -51,18 +55,21 @@ fn is_none() {
 
     // Check `find().is_none()`, multi-line case.
     let _ = v.iter().find(|&x| {
+    //~^ search_is_some
                               *x < 0
                           }
                    ).is_none();
 
     // Check `position().is_none()`, multi-line case.
     let _ = v.iter().position(|&x| {
+    //~^ search_is_some
                                   x < 0
                               }
                    ).is_none();
 
     // Check `rposition().is_none()`, multi-line case.
     let _ = v.iter().rposition(|&x| {
+    //~^ search_is_some
                                    x < 0
                                }
                    ).is_none();
@@ -78,4 +85,5 @@ fn is_none() {
 
     let some_closure = |x: &u32| *x == 0;
     let _ = (0..1).find(some_closure).is_none();
+    //~^ search_is_some
 }
diff --git a/src/tools/clippy/tests/ui/search_is_some.stderr b/src/tools/clippy/tests/ui/search_is_some.stderr
index b5ef55341770..d9a43c8915e8 100644
--- a/src/tools/clippy/tests/ui/search_is_some.stderr
+++ b/src/tools/clippy/tests/ui/search_is_some.stderr
@@ -3,6 +3,7 @@ error: called `is_some()` after searching an `Iterator` with `find`
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
+LL | |
 LL | |                               *x < 0
 LL | |                           }
 LL | |                    ).is_some();
@@ -13,10 +14,11 @@ LL | |                    ).is_some();
    = help: to override `-D warnings` add `#[allow(clippy::search_is_some)]`
 
 error: called `is_some()` after searching an `Iterator` with `position`
-  --> tests/ui/search_is_some.rs:22:13
+  --> tests/ui/search_is_some.rs:23:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
+LL | |
 LL | |                                   x < 0
 LL | |                               }
 LL | |                    ).is_some();
@@ -25,10 +27,11 @@ LL | |                    ).is_some();
    = help: this is more succinctly expressed by calling `any()`
 
 error: called `is_some()` after searching an `Iterator` with `rposition`
-  --> tests/ui/search_is_some.rs:28:13
+  --> tests/ui/search_is_some.rs:30:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
+LL | |
 LL | |                                    x < 0
 LL | |                                }
 LL | |                    ).is_some();
@@ -37,16 +40,17 @@ LL | |                    ).is_some();
    = help: this is more succinctly expressed by calling `any()`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some.rs:43:20
+  --> tests/ui/search_is_some.rs:46:20
    |
 LL |     let _ = (0..1).find(some_closure).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(some_closure)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some.rs:53:13
+  --> tests/ui/search_is_some.rs:57:13
    |
 LL |       let _ = v.iter().find(|&x| {
    |  _____________^
+LL | |
 LL | |                               *x < 0
 LL | |                           }
 LL | |                    ).is_none();
@@ -55,10 +59,11 @@ LL | |                    ).is_none();
    = help: this is more succinctly expressed by calling `any()` with negation
 
 error: called `is_none()` after searching an `Iterator` with `position`
-  --> tests/ui/search_is_some.rs:59:13
+  --> tests/ui/search_is_some.rs:64:13
    |
 LL |       let _ = v.iter().position(|&x| {
    |  _____________^
+LL | |
 LL | |                                   x < 0
 LL | |                               }
 LL | |                    ).is_none();
@@ -67,10 +72,11 @@ LL | |                    ).is_none();
    = help: this is more succinctly expressed by calling `any()` with negation
 
 error: called `is_none()` after searching an `Iterator` with `rposition`
-  --> tests/ui/search_is_some.rs:65:13
+  --> tests/ui/search_is_some.rs:71:13
    |
 LL |       let _ = v.iter().rposition(|&x| {
    |  _____________^
+LL | |
 LL | |                                    x < 0
 LL | |                                }
 LL | |                    ).is_none();
@@ -79,7 +85,7 @@ LL | |                    ).is_none();
    = help: this is more succinctly expressed by calling `any()` with negation
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some.rs:80:13
+  --> tests/ui/search_is_some.rs:87:13
    |
 LL |     let _ = (0..1).find(some_closure).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!(0..1).any(some_closure)`
diff --git a/src/tools/clippy/tests/ui/search_is_some_fixable_none.fixed b/src/tools/clippy/tests/ui/search_is_some_fixable_none.fixed
index 86a937b4dae1..847e5140d3e6 100644
--- a/src/tools/clippy/tests/ui/search_is_some_fixable_none.fixed
+++ b/src/tools/clippy/tests/ui/search_is_some_fixable_none.fixed
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec)]
+#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec, clippy::manual_contains)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
@@ -7,36 +7,56 @@ fn main() {
 
     // Check `find().is_none()`, single-line case.
     let _ = !v.iter().any(|x| *x < 0);
+    //~^ search_is_some
     let _ = !(0..1).any(|x| **y == x); // one dereference less
+    //
+    //~^^ search_is_some
     let _ = !(0..1).any(|x| x == 0);
+    //~^ search_is_some
     let _ = !v.iter().any(|x| *x == 0);
+    //~^ search_is_some
     let _ = !(4..5).any(|x| x == 1 || x == 3 || x == 5);
+    //~^ search_is_some
     let _ = !(1..3).any(|x| [1, 2, 3].contains(&x));
+    //~^ search_is_some
     let _ = !(1..3).any(|x| x == 0 || [1, 2, 3].contains(&x));
+    //~^ search_is_some
     let _ = !(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0);
+    //~^ search_is_some
     let _ = !(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1);
 
     // Check `position().is_none()`, single-line case.
     let _ = !v.iter().any(|&x| x < 0);
+    //~^ search_is_some
 
     // Check `rposition().is_none()`, single-line case.
     let _ = !v.iter().any(|&x| x < 0);
+    //~^ search_is_some
 
     let s1 = String::from("hello world");
     let s2 = String::from("world");
 
     // caller of `find()` is a `&`static str`
     let _ = !"hello world".contains("world");
+    //~^ search_is_some
     let _ = !"hello world".contains(&s2);
+    //~^ search_is_some
     let _ = !"hello world".contains(&s2[2..]);
+    //~^ search_is_some
     // caller of `find()` is a `String`
     let _ = !s1.contains("world");
+    //~^ search_is_some
     let _ = !s1.contains(&s2);
+    //~^ search_is_some
     let _ = !s1.contains(&s2[2..]);
+    //~^ search_is_some
     // caller of `find()` is slice of `String`
     let _ = !s1[2..].contains("world");
+    //~^ search_is_some
     let _ = !s1[2..].contains(&s2);
+    //~^ search_is_some
     let _ = !s1[2..].contains(&s2[2..]);
+    //~^ search_is_some
 }
 
 #[allow(clippy::clone_on_copy, clippy::map_clone)]
@@ -53,6 +73,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|c| !filter_hand.iter().any(|cc| c == &cc))
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -69,6 +90,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|(c, _)| !filter_hand.iter().any(|cc| c == cc))
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -80,21 +102,25 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { foo: 1, bar: 2 }];
         let _ = !vfoo.iter().any(|v| v.foo == 1 && v.bar == 2);
+        //~^ search_is_some
 
         let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
         let _ = !vfoo
+            //~^ search_is_some
             .iter().any(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2);
     }
 
     fn index_projection() {
         let vfoo = vec![[0, 1, 2, 3]];
         let _ = !vfoo.iter().any(|a| a[0] == 42);
+        //~^ search_is_some
     }
 
     #[allow(clippy::match_like_matches_macro)]
     fn slice_projection() {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = !vfoo.iter().any(|sub| sub[1..4].len() == 3);
+        //~^ search_is_some
     }
 
     fn please(x: &u32) -> bool {
@@ -113,16 +139,22 @@ mod issue7392 {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = ![ppx].iter().any(|ppp_x: &&u32| please(ppp_x));
+        //~^ search_is_some
         let _ = ![String::from("Hey hey")].iter().any(|s| s.len() == 2);
+        //~^ search_is_some
 
         let v = vec![3, 2, 1, 0];
         let _ = !v.iter().any(|x| deref_enough(*x));
+        //~^ search_is_some
         let _ = !v.iter().any(|x: &u32| deref_enough(*x));
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = !v.iter().any(|x| arg_no_deref(&x));
+        //~^ search_is_some
         #[allow(clippy::redundant_closure)]
         let _ = !v.iter().any(|x: &u32| arg_no_deref(&x));
+        //~^ search_is_some
     }
 
     fn field_index_projection() {
@@ -143,6 +175,7 @@ mod issue7392 {
             },
         }];
         let _ = !vfoo
+            //~^ search_is_some
             .iter().any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2);
     }
 
@@ -157,11 +190,13 @@ mod issue7392 {
             inner: vec![Foo { bar: 0 }],
         }];
         let _ = !vfoo.iter().any(|v| v.inner[0].bar == 2);
+        //~^ search_is_some
     }
 
     fn double_deref_index_projection() {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = !vfoo.iter().any(|x| (**x)[0] == 9);
+        //~^ search_is_some
     }
 
     fn method_call_by_ref() {
@@ -175,11 +210,14 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { bar: 1 }];
         let _ = !vfoo.iter().any(|v| v.by_ref(&v.bar));
+        //~^ search_is_some
     }
 
     fn ref_bindings() {
         let _ = ![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
+        //~^ search_is_some
         let _ = ![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
+        //~^ search_is_some
     }
 
     fn test_string_1(s: &str) -> bool {
@@ -199,7 +237,9 @@ mod issue7392 {
         let lst = &[String::from("Hello"), String::from("world")];
         let v: Vec<&[String]> = vec![lst];
         let _ = !v.iter().any(|s| s[0].is_empty());
+        //~^ search_is_some
         let _ = !v.iter().any(|s| test_string_1(&s[0]));
+        //~^ search_is_some
 
         // Field projections
         struct FieldProjection<'a> {
@@ -209,8 +249,11 @@ mod issue7392 {
         let instance = FieldProjection { field: &field };
         let v = vec![instance];
         let _ = !v.iter().any(|fp| fp.field.is_power_of_two());
+        //~^ search_is_some
         let _ = !v.iter().any(|fp| test_u32_1(fp.field));
+        //~^ search_is_some
         let _ = !v.iter().any(|fp| test_u32_2(*fp.field));
+        //~^ search_is_some
     }
 }
 
@@ -227,39 +270,51 @@ mod issue_11910 {
     fn test_normal_for_iter() {
         let v = vec![3, 2, 1, 0, -1, -2, -3];
         let _ = !v.iter().any(|x| *x == 42);
+        //~^ search_is_some
         Foo.bar(!v.iter().any(|x| *x == 42));
+        //~^ search_is_some
     }
 
     fn test_then_for_iter() {
         let v = vec![3, 2, 1, 0, -1, -2, -3];
         (!v.iter().any(|x| *x == 42)).then(computations);
+        //~^ search_is_some
     }
 
     fn test_then_some_for_iter() {
         let v = vec![3, 2, 1, 0, -1, -2, -3];
         (!v.iter().any(|x| *x == 42)).then_some(0);
+        //~^ search_is_some
     }
 
     fn test_normal_for_str() {
         let s = "hello";
         let _ = !s.contains("world");
+        //~^ search_is_some
         Foo.bar(!s.contains("world"));
+        //~^ search_is_some
         let s = String::from("hello");
         let _ = !s.contains("world");
+        //~^ search_is_some
         Foo.bar(!s.contains("world"));
+        //~^ search_is_some
     }
 
     fn test_then_for_str() {
         let s = "hello";
         let _ = (!s.contains("world")).then(computations);
+        //~^ search_is_some
         let s = String::from("hello");
         let _ = (!s.contains("world")).then(computations);
+        //~^ search_is_some
     }
 
     fn test_then_some_for_str() {
         let s = "hello";
         let _ = (!s.contains("world")).then_some(0);
+        //~^ search_is_some
         let s = String::from("hello");
         let _ = (!s.contains("world")).then_some(0);
+        //~^ search_is_some
     }
 }
diff --git a/src/tools/clippy/tests/ui/search_is_some_fixable_none.rs b/src/tools/clippy/tests/ui/search_is_some_fixable_none.rs
index c0103a015097..e976d12600cc 100644
--- a/src/tools/clippy/tests/ui/search_is_some_fixable_none.rs
+++ b/src/tools/clippy/tests/ui/search_is_some_fixable_none.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec)]
+#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec, clippy::manual_contains)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
@@ -7,38 +7,59 @@ fn main() {
 
     // Check `find().is_none()`, single-line case.
     let _ = v.iter().find(|&x| *x < 0).is_none();
+    //~^ search_is_some
     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
+    //
+    //~^^ search_is_some
     let _ = (0..1).find(|x| *x == 0).is_none();
+    //~^ search_is_some
     let _ = v.iter().find(|x| **x == 0).is_none();
+    //~^ search_is_some
     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_none();
+    //~^ search_is_some
     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_none();
+    //~^ search_is_some
     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_none();
+    //~^ search_is_some
     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_none();
+    //~^ search_is_some
     let _ = (1..3)
+        //~^ search_is_some
         .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
         .is_none();
 
     // Check `position().is_none()`, single-line case.
     let _ = v.iter().position(|&x| x < 0).is_none();
+    //~^ search_is_some
 
     // Check `rposition().is_none()`, single-line case.
     let _ = v.iter().rposition(|&x| x < 0).is_none();
+    //~^ search_is_some
 
     let s1 = String::from("hello world");
     let s2 = String::from("world");
 
     // caller of `find()` is a `&`static str`
     let _ = "hello world".find("world").is_none();
+    //~^ search_is_some
     let _ = "hello world".find(&s2).is_none();
+    //~^ search_is_some
     let _ = "hello world".find(&s2[2..]).is_none();
+    //~^ search_is_some
     // caller of `find()` is a `String`
     let _ = s1.find("world").is_none();
+    //~^ search_is_some
     let _ = s1.find(&s2).is_none();
+    //~^ search_is_some
     let _ = s1.find(&s2[2..]).is_none();
+    //~^ search_is_some
     // caller of `find()` is slice of `String`
     let _ = s1[2..].find("world").is_none();
+    //~^ search_is_some
     let _ = s1[2..].find(&s2).is_none();
+    //~^ search_is_some
     let _ = s1[2..].find(&s2[2..]).is_none();
+    //~^ search_is_some
 }
 
 #[allow(clippy::clone_on_copy, clippy::map_clone)]
@@ -55,6 +76,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -71,6 +93,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -82,9 +105,11 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { foo: 1, bar: 2 }];
         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_none();
+        //~^ search_is_some
 
         let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
         let _ = vfoo
+            //~^ search_is_some
             .iter()
             .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
             .is_none();
@@ -93,12 +118,14 @@ mod issue7392 {
     fn index_projection() {
         let vfoo = vec![[0, 1, 2, 3]];
         let _ = vfoo.iter().find(|a| a[0] == 42).is_none();
+        //~^ search_is_some
     }
 
     #[allow(clippy::match_like_matches_macro)]
     fn slice_projection() {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
+        //~^ search_is_some
     }
 
     fn please(x: &u32) -> bool {
@@ -117,16 +144,22 @@ mod issue7392 {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_none();
+        //~^ search_is_some
         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
+        //~^ search_is_some
 
         let v = vec![3, 2, 1, 0];
         let _ = v.iter().find(|x| deref_enough(**x)).is_none();
+        //~^ search_is_some
         let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_none();
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x| arg_no_deref(x)).is_none();
+        //~^ search_is_some
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_none();
+        //~^ search_is_some
     }
 
     fn field_index_projection() {
@@ -147,6 +180,7 @@ mod issue7392 {
             },
         }];
         let _ = vfoo
+            //~^ search_is_some
             .iter()
             .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
             .is_none();
@@ -163,11 +197,13 @@ mod issue7392 {
             inner: vec![Foo { bar: 0 }],
         }];
         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_none();
+        //~^ search_is_some
     }
 
     fn double_deref_index_projection() {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_none();
+        //~^ search_is_some
     }
 
     fn method_call_by_ref() {
@@ -181,11 +217,14 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { bar: 1 }];
         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_none();
+        //~^ search_is_some
     }
 
     fn ref_bindings() {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_none();
+        //~^ search_is_some
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_none();
+        //~^ search_is_some
     }
 
     fn test_string_1(s: &str) -> bool {
@@ -205,7 +244,9 @@ mod issue7392 {
         let lst = &[String::from("Hello"), String::from("world")];
         let v: Vec<&[String]> = vec![lst];
         let _ = v.iter().find(|s| s[0].is_empty()).is_none();
+        //~^ search_is_some
         let _ = v.iter().find(|s| test_string_1(&s[0])).is_none();
+        //~^ search_is_some
 
         // Field projections
         struct FieldProjection<'a> {
@@ -215,8 +256,11 @@ mod issue7392 {
         let instance = FieldProjection { field: &field };
         let v = vec![instance];
         let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_none();
+        //~^ search_is_some
         let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_none();
+        //~^ search_is_some
         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_none();
+        //~^ search_is_some
     }
 }
 
@@ -233,39 +277,51 @@ mod issue_11910 {
     fn test_normal_for_iter() {
         let v = vec![3, 2, 1, 0, -1, -2, -3];
         let _ = v.iter().find(|x| **x == 42).is_none();
+        //~^ search_is_some
         Foo.bar(v.iter().find(|x| **x == 42).is_none());
+        //~^ search_is_some
     }
 
     fn test_then_for_iter() {
         let v = vec![3, 2, 1, 0, -1, -2, -3];
         v.iter().find(|x| **x == 42).is_none().then(computations);
+        //~^ search_is_some
     }
 
     fn test_then_some_for_iter() {
         let v = vec![3, 2, 1, 0, -1, -2, -3];
         v.iter().find(|x| **x == 42).is_none().then_some(0);
+        //~^ search_is_some
     }
 
     fn test_normal_for_str() {
         let s = "hello";
         let _ = s.find("world").is_none();
+        //~^ search_is_some
         Foo.bar(s.find("world").is_none());
+        //~^ search_is_some
         let s = String::from("hello");
         let _ = s.find("world").is_none();
+        //~^ search_is_some
         Foo.bar(s.find("world").is_none());
+        //~^ search_is_some
     }
 
     fn test_then_for_str() {
         let s = "hello";
         let _ = s.find("world").is_none().then(computations);
+        //~^ search_is_some
         let s = String::from("hello");
         let _ = s.find("world").is_none().then(computations);
+        //~^ search_is_some
     }
 
     fn test_then_some_for_str() {
         let s = "hello";
         let _ = s.find("world").is_none().then_some(0);
+        //~^ search_is_some
         let s = String::from("hello");
         let _ = s.find("world").is_none().then_some(0);
+        //~^ search_is_some
     }
 }
diff --git a/src/tools/clippy/tests/ui/search_is_some_fixable_none.stderr b/src/tools/clippy/tests/ui/search_is_some_fixable_none.stderr
index 2c858b9fb10e..ccc17025222d 100644
--- a/src/tools/clippy/tests/ui/search_is_some_fixable_none.stderr
+++ b/src/tools/clippy/tests/ui/search_is_some_fixable_none.stderr
@@ -8,145 +8,147 @@ LL |     let _ = v.iter().find(|&x| *x < 0).is_none();
    = help: to override `-D warnings` add `#[allow(clippy::search_is_some)]`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:10:13
+  --> tests/ui/search_is_some_fixable_none.rs:11:13
    |
 LL |     let _ = (0..1).find(|x| **y == *x).is_none(); // one dereference less
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!(0..1).any(|x| **y == x)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:11:13
+  --> tests/ui/search_is_some_fixable_none.rs:14:13
    |
 LL |     let _ = (0..1).find(|x| *x == 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!(0..1).any(|x| x == 0)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:12:13
+  --> tests/ui/search_is_some_fixable_none.rs:16:13
    |
 LL |     let _ = v.iter().find(|x| **x == 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|x| *x == 0)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:13:13
+  --> tests/ui/search_is_some_fixable_none.rs:18:13
    |
 LL |     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!(4..5).any(|x| x == 1 || x == 3 || x == 5)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:14:13
+  --> tests/ui/search_is_some_fixable_none.rs:20:13
    |
 LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!(1..3).any(|x| [1, 2, 3].contains(&x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:15:13
+  --> tests/ui/search_is_some_fixable_none.rs:22:13
    |
 LL |     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!(1..3).any(|x| x == 0 || [1, 2, 3].contains(&x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:16:13
+  --> tests/ui/search_is_some_fixable_none.rs:24:13
    |
 LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:17:13
+  --> tests/ui/search_is_some_fixable_none.rs:26:13
    |
 LL |       let _ = (1..3)
    |  _____________^
+LL | |
 LL | |         .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
 LL | |         .is_none();
    | |__________________^ help: consider using: `!(1..3).any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1)`
 
 error: called `is_none()` after searching an `Iterator` with `position`
-  --> tests/ui/search_is_some_fixable_none.rs:22:13
+  --> tests/ui/search_is_some_fixable_none.rs:32:13
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|&x| x < 0)`
 
 error: called `is_none()` after searching an `Iterator` with `rposition`
-  --> tests/ui/search_is_some_fixable_none.rs:25:13
+  --> tests/ui/search_is_some_fixable_none.rs:36:13
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|&x| x < 0)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:31:13
+  --> tests/ui/search_is_some_fixable_none.rs:43:13
    |
 LL |     let _ = "hello world".find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!"hello world".contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:32:13
+  --> tests/ui/search_is_some_fixable_none.rs:45:13
    |
 LL |     let _ = "hello world".find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!"hello world".contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:33:13
+  --> tests/ui/search_is_some_fixable_none.rs:47:13
    |
 LL |     let _ = "hello world".find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!"hello world".contains(&s2[2..])`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:35:13
+  --> tests/ui/search_is_some_fixable_none.rs:50:13
    |
 LL |     let _ = s1.find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s1.contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:36:13
+  --> tests/ui/search_is_some_fixable_none.rs:52:13
    |
 LL |     let _ = s1.find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s1.contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:37:13
+  --> tests/ui/search_is_some_fixable_none.rs:54:13
    |
 LL |     let _ = s1.find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s1.contains(&s2[2..])`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:39:13
+  --> tests/ui/search_is_some_fixable_none.rs:57:13
    |
 LL |     let _ = s1[2..].find("world").is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s1[2..].contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:40:13
+  --> tests/ui/search_is_some_fixable_none.rs:59:13
    |
 LL |     let _ = s1[2..].find(&s2).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s1[2..].contains(&s2)`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:41:13
+  --> tests/ui/search_is_some_fixable_none.rs:61:13
    |
 LL |     let _ = s1[2..].find(&s2[2..]).is_none();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s1[2..].contains(&s2[2..])`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:57:25
+  --> tests/ui/search_is_some_fixable_none.rs:78:25
    |
 LL |             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_none())
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!filter_hand.iter().any(|cc| c == &cc)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:73:30
+  --> tests/ui/search_is_some_fixable_none.rs:95:30
    |
 LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_none())
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!filter_hand.iter().any(|cc| c == cc)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:84:17
+  --> tests/ui/search_is_some_fixable_none.rs:107:17
    |
 LL |         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!vfoo.iter().any(|v| v.foo == 1 && v.bar == 2)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:87:17
+  --> tests/ui/search_is_some_fixable_none.rs:111:17
    |
 LL |           let _ = vfoo
    |  _________________^
+LL | |
 LL | |             .iter()
 LL | |             .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
 LL | |             .is_none();
@@ -155,62 +157,64 @@ LL | |             .is_none();
 help: consider using
    |
 LL ~         let _ = !vfoo
+LL +
 LL ~             .iter().any(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2);
    |
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:95:17
+  --> tests/ui/search_is_some_fixable_none.rs:120:17
    |
 LL |         let _ = vfoo.iter().find(|a| a[0] == 42).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!vfoo.iter().any(|a| a[0] == 42)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:101:17
+  --> tests/ui/search_is_some_fixable_none.rs:127:17
    |
 LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!vfoo.iter().any(|sub| sub[1..4].len() == 3)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:119:17
+  --> tests/ui/search_is_some_fixable_none.rs:146:17
    |
 LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `![ppx].iter().any(|ppp_x: &&u32| please(ppp_x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:120:17
+  --> tests/ui/search_is_some_fixable_none.rs:148:17
    |
 LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `![String::from("Hey hey")].iter().any(|s| s.len() == 2)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:123:17
+  --> tests/ui/search_is_some_fixable_none.rs:152:17
    |
 LL |         let _ = v.iter().find(|x| deref_enough(**x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|x| deref_enough(*x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:124:17
+  --> tests/ui/search_is_some_fixable_none.rs:154:17
    |
 LL |         let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|x: &u32| deref_enough(*x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:127:17
+  --> tests/ui/search_is_some_fixable_none.rs:158:17
    |
 LL |         let _ = v.iter().find(|x| arg_no_deref(x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|x| arg_no_deref(&x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:129:17
+  --> tests/ui/search_is_some_fixable_none.rs:161:17
    |
 LL |         let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|x: &u32| arg_no_deref(&x))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:149:17
+  --> tests/ui/search_is_some_fixable_none.rs:182:17
    |
 LL |           let _ = vfoo
    |  _________________^
+LL | |
 LL | |             .iter()
 LL | |             .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
 LL | |             .is_none();
@@ -219,137 +223,138 @@ LL | |             .is_none();
 help: consider using
    |
 LL ~         let _ = !vfoo
+LL +
 LL ~             .iter().any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2);
    |
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:165:17
+  --> tests/ui/search_is_some_fixable_none.rs:199:17
    |
 LL |         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!vfoo.iter().any(|v| v.inner[0].bar == 2)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:170:17
+  --> tests/ui/search_is_some_fixable_none.rs:205:17
    |
 LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!vfoo.iter().any(|x| (**x)[0] == 9)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:183:17
+  --> tests/ui/search_is_some_fixable_none.rs:219:17
    |
 LL |         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!vfoo.iter().any(|v| v.by_ref(&v.bar))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:187:17
+  --> tests/ui/search_is_some_fixable_none.rs:224:17
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:188:17
+  --> tests/ui/search_is_some_fixable_none.rs:226:17
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `![&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:207:17
+  --> tests/ui/search_is_some_fixable_none.rs:246:17
    |
 LL |         let _ = v.iter().find(|s| s[0].is_empty()).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|s| s[0].is_empty())`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:208:17
+  --> tests/ui/search_is_some_fixable_none.rs:248:17
    |
 LL |         let _ = v.iter().find(|s| test_string_1(&s[0])).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|s| test_string_1(&s[0]))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:217:17
+  --> tests/ui/search_is_some_fixable_none.rs:258:17
    |
 LL |         let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|fp| fp.field.is_power_of_two())`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:218:17
+  --> tests/ui/search_is_some_fixable_none.rs:260:17
    |
 LL |         let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|fp| test_u32_1(fp.field))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:219:17
+  --> tests/ui/search_is_some_fixable_none.rs:262:17
    |
 LL |         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|fp| test_u32_2(*fp.field))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:235:17
+  --> tests/ui/search_is_some_fixable_none.rs:279:17
    |
 LL |         let _ = v.iter().find(|x| **x == 42).is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|x| *x == 42)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:236:17
+  --> tests/ui/search_is_some_fixable_none.rs:281:17
    |
 LL |         Foo.bar(v.iter().find(|x| **x == 42).is_none());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!v.iter().any(|x| *x == 42)`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:241:9
+  --> tests/ui/search_is_some_fixable_none.rs:287:9
    |
 LL |         v.iter().find(|x| **x == 42).is_none().then(computations);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(!v.iter().any(|x| *x == 42))`
 
 error: called `is_none()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_none.rs:246:9
+  --> tests/ui/search_is_some_fixable_none.rs:293:9
    |
 LL |         v.iter().find(|x| **x == 42).is_none().then_some(0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(!v.iter().any(|x| *x == 42))`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:251:17
+  --> tests/ui/search_is_some_fixable_none.rs:299:17
    |
 LL |         let _ = s.find("world").is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s.contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:252:17
+  --> tests/ui/search_is_some_fixable_none.rs:301:17
    |
 LL |         Foo.bar(s.find("world").is_none());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s.contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:254:17
+  --> tests/ui/search_is_some_fixable_none.rs:304:17
    |
 LL |         let _ = s.find("world").is_none();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s.contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:255:17
+  --> tests/ui/search_is_some_fixable_none.rs:306:17
    |
 LL |         Foo.bar(s.find("world").is_none());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `!s.contains("world")`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:260:17
+  --> tests/ui/search_is_some_fixable_none.rs:312:17
    |
 LL |         let _ = s.find("world").is_none().then(computations);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(!s.contains("world"))`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:262:17
+  --> tests/ui/search_is_some_fixable_none.rs:315:17
    |
 LL |         let _ = s.find("world").is_none().then(computations);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(!s.contains("world"))`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:267:17
+  --> tests/ui/search_is_some_fixable_none.rs:321:17
    |
 LL |         let _ = s.find("world").is_none().then_some(0);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(!s.contains("world"))`
 
 error: called `is_none()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_none.rs:269:17
+  --> tests/ui/search_is_some_fixable_none.rs:324:17
    |
 LL |         let _ = s.find("world").is_none().then_some(0);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(!s.contains("world"))`
diff --git a/src/tools/clippy/tests/ui/search_is_some_fixable_some.fixed b/src/tools/clippy/tests/ui/search_is_some_fixable_some.fixed
index ae3cbc3c4da2..05e88b8528f1 100644
--- a/src/tools/clippy/tests/ui/search_is_some_fixable_some.fixed
+++ b/src/tools/clippy/tests/ui/search_is_some_fixable_some.fixed
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec)]
+#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec, clippy::manual_contains)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
@@ -7,36 +7,56 @@ fn main() {
 
     // Check `find().is_some()`, single-line case.
     let _ = v.iter().any(|x| *x < 0);
+    //~^ search_is_some
     let _ = (0..1).any(|x| **y == x); // one dereference less
+    //
+    //~^^ search_is_some
     let _ = (0..1).any(|x| x == 0);
+    //~^ search_is_some
     let _ = v.iter().any(|x| *x == 0);
+    //~^ search_is_some
     let _ = (4..5).any(|x| x == 1 || x == 3 || x == 5);
+    //~^ search_is_some
     let _ = (1..3).any(|x| [1, 2, 3].contains(&x));
+    //~^ search_is_some
     let _ = (1..3).any(|x| x == 0 || [1, 2, 3].contains(&x));
+    //~^ search_is_some
     let _ = (1..3).any(|x| [1, 2, 3].contains(&x) || x == 0);
+    //~^ search_is_some
     let _ = (1..3)
         .any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1);
 
     // Check `position().is_some()`, single-line case.
     let _ = v.iter().any(|&x| x < 0);
+    //~^ search_is_some
 
     // Check `rposition().is_some()`, single-line case.
     let _ = v.iter().any(|&x| x < 0);
+    //~^ search_is_some
 
     let s1 = String::from("hello world");
     let s2 = String::from("world");
     // caller of `find()` is a `&`static str`
     let _ = "hello world".contains("world");
+    //~^ search_is_some
     let _ = "hello world".contains(&s2);
+    //~^ search_is_some
     let _ = "hello world".contains(&s2[2..]);
+    //~^ search_is_some
     // caller of `find()` is a `String`
     let _ = s1.contains("world");
+    //~^ search_is_some
     let _ = s1.contains(&s2);
+    //~^ search_is_some
     let _ = s1.contains(&s2[2..]);
+    //~^ search_is_some
     // caller of `find()` is slice of `String`
     let _ = s1[2..].contains("world");
+    //~^ search_is_some
     let _ = s1[2..].contains(&s2);
+    //~^ search_is_some
     let _ = s1[2..].contains(&s2[2..]);
+    //~^ search_is_some
 }
 
 #[allow(clippy::clone_on_copy, clippy::map_clone)]
@@ -53,6 +73,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|c| filter_hand.iter().any(|cc| c == &cc))
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -69,6 +90,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|(c, _)| filter_hand.iter().any(|cc| c == cc))
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -80,6 +102,7 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { foo: 1, bar: 2 }];
         let _ = vfoo.iter().any(|v| v.foo == 1 && v.bar == 2);
+        //~^ search_is_some
 
         let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
         let _ = vfoo
@@ -90,12 +113,14 @@ mod issue7392 {
     fn index_projection() {
         let vfoo = vec![[0, 1, 2, 3]];
         let _ = vfoo.iter().any(|a| a[0] == 42);
+        //~^ search_is_some
     }
 
     #[allow(clippy::match_like_matches_macro)]
     fn slice_projection() {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = vfoo.iter().any(|sub| sub[1..4].len() == 3);
+        //~^ search_is_some
     }
 
     fn please(x: &u32) -> bool {
@@ -114,16 +139,22 @@ mod issue7392 {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = [ppx].iter().any(|ppp_x: &&u32| please(ppp_x));
+        //~^ search_is_some
         let _ = [String::from("Hey hey")].iter().any(|s| s.len() == 2);
+        //~^ search_is_some
 
         let v = vec![3, 2, 1, 0];
         let _ = v.iter().any(|x| deref_enough(*x));
+        //~^ search_is_some
         let _ = v.iter().any(|x: &u32| deref_enough(*x));
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().any(|x| arg_no_deref(&x));
+        //~^ search_is_some
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().any(|x: &u32| arg_no_deref(&x));
+        //~^ search_is_some
     }
 
     fn field_index_projection() {
@@ -159,11 +190,13 @@ mod issue7392 {
             inner: vec![Foo { bar: 0 }],
         }];
         let _ = vfoo.iter().any(|v| v.inner[0].bar == 2);
+        //~^ search_is_some
     }
 
     fn double_deref_index_projection() {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = vfoo.iter().any(|x| (**x)[0] == 9);
+        //~^ search_is_some
     }
 
     fn method_call_by_ref() {
@@ -177,11 +210,14 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { bar: 1 }];
         let _ = vfoo.iter().any(|v| v.by_ref(&v.bar));
+        //~^ search_is_some
     }
 
     fn ref_bindings() {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
+        //~^ search_is_some
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().any(|(&x, y)| x == *y);
+        //~^ search_is_some
     }
 
     fn test_string_1(s: &str) -> bool {
@@ -201,7 +237,9 @@ mod issue7392 {
         let lst = &[String::from("Hello"), String::from("world")];
         let v: Vec<&[String]> = vec![lst];
         let _ = v.iter().any(|s| s[0].is_empty());
+        //~^ search_is_some
         let _ = v.iter().any(|s| test_string_1(&s[0]));
+        //~^ search_is_some
 
         // Field projections
         struct FieldProjection<'a> {
@@ -211,8 +249,11 @@ mod issue7392 {
         let instance = FieldProjection { field: &field };
         let v = vec![instance];
         let _ = v.iter().any(|fp| fp.field.is_power_of_two());
+        //~^ search_is_some
         let _ = v.iter().any(|fp| test_u32_1(fp.field));
+        //~^ search_is_some
         let _ = v.iter().any(|fp| test_u32_2(*fp.field));
+        //~^ search_is_some
     }
 }
 
@@ -228,6 +269,7 @@ mod issue9120 {
     fn wrapper<T: Fn(&&u32) -> bool>(v: Vec<u32>, func: T) -> bool {
         #[allow(clippy::redundant_closure)]
         v.iter().any(|x: &u32| func(&x))
+        //~^ search_is_some
     }
 
     fn do_tests() {
@@ -237,11 +279,14 @@ mod issue9120 {
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().any(|x: &u32| arg_no_deref_impl(&x));
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().any(|x: &u32| arg_no_deref_dyn(&x));
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().any(|x: &u32| (*arg_no_deref_dyn)(&x));
+        //~^ search_is_some
     }
 }
diff --git a/src/tools/clippy/tests/ui/search_is_some_fixable_some.rs b/src/tools/clippy/tests/ui/search_is_some_fixable_some.rs
index 19a44803fd54..caab816f2436 100644
--- a/src/tools/clippy/tests/ui/search_is_some_fixable_some.rs
+++ b/src/tools/clippy/tests/ui/search_is_some_fixable_some.rs
@@ -1,4 +1,4 @@
-#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec)]
+#![allow(dead_code, clippy::explicit_auto_deref, clippy::useless_vec, clippy::manual_contains)]
 #![warn(clippy::search_is_some)]
 
 fn main() {
@@ -7,37 +7,58 @@ fn main() {
 
     // Check `find().is_some()`, single-line case.
     let _ = v.iter().find(|&x| *x < 0).is_some();
+    //~^ search_is_some
     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
+    //
+    //~^^ search_is_some
     let _ = (0..1).find(|x| *x == 0).is_some();
+    //~^ search_is_some
     let _ = v.iter().find(|x| **x == 0).is_some();
+    //~^ search_is_some
     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_some();
+    //~^ search_is_some
     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_some();
+    //~^ search_is_some
     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_some();
+    //~^ search_is_some
     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_some();
+    //~^ search_is_some
     let _ = (1..3)
         .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
+        //~^ search_is_some
         .is_some();
 
     // Check `position().is_some()`, single-line case.
     let _ = v.iter().position(|&x| x < 0).is_some();
+    //~^ search_is_some
 
     // Check `rposition().is_some()`, single-line case.
     let _ = v.iter().rposition(|&x| x < 0).is_some();
+    //~^ search_is_some
 
     let s1 = String::from("hello world");
     let s2 = String::from("world");
     // caller of `find()` is a `&`static str`
     let _ = "hello world".find("world").is_some();
+    //~^ search_is_some
     let _ = "hello world".find(&s2).is_some();
+    //~^ search_is_some
     let _ = "hello world".find(&s2[2..]).is_some();
+    //~^ search_is_some
     // caller of `find()` is a `String`
     let _ = s1.find("world").is_some();
+    //~^ search_is_some
     let _ = s1.find(&s2).is_some();
+    //~^ search_is_some
     let _ = s1.find(&s2[2..]).is_some();
+    //~^ search_is_some
     // caller of `find()` is slice of `String`
     let _ = s1[2..].find("world").is_some();
+    //~^ search_is_some
     let _ = s1[2..].find(&s2).is_some();
+    //~^ search_is_some
     let _ = s1[2..].find(&s2[2..]).is_some();
+    //~^ search_is_some
 }
 
 #[allow(clippy::clone_on_copy, clippy::map_clone)]
@@ -54,6 +75,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_some())
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -70,6 +92,7 @@ mod issue7392 {
             .hand
             .iter()
             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_some())
+            //~^ search_is_some
             .map(|c| c.clone())
             .collect::<Vec<_>>();
     }
@@ -81,23 +104,27 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { foo: 1, bar: 2 }];
         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_some();
+        //~^ search_is_some
 
         let vfoo = vec![(42, Foo { foo: 1, bar: 2 })];
         let _ = vfoo
             .iter()
             .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
+            //~^ search_is_some
             .is_some();
     }
 
     fn index_projection() {
         let vfoo = vec![[0, 1, 2, 3]];
         let _ = vfoo.iter().find(|a| a[0] == 42).is_some();
+        //~^ search_is_some
     }
 
     #[allow(clippy::match_like_matches_macro)]
     fn slice_projection() {
         let vfoo = vec![[0, 1, 2, 3, 0, 1, 2, 3]];
         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
+        //~^ search_is_some
     }
 
     fn please(x: &u32) -> bool {
@@ -116,16 +143,22 @@ mod issue7392 {
         let x = 19;
         let ppx: &u32 = &x;
         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
+        //~^ search_is_some
         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
+        //~^ search_is_some
 
         let v = vec![3, 2, 1, 0];
         let _ = v.iter().find(|x| deref_enough(**x)).is_some();
+        //~^ search_is_some
         let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_some();
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
+        //~^ search_is_some
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_some();
+        //~^ search_is_some
     }
 
     fn field_index_projection() {
@@ -148,6 +181,7 @@ mod issue7392 {
         let _ = vfoo
             .iter()
             .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
+            //~^ search_is_some
             .is_some();
     }
 
@@ -162,11 +196,13 @@ mod issue7392 {
             inner: vec![Foo { bar: 0 }],
         }];
         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_some();
+        //~^ search_is_some
     }
 
     fn double_deref_index_projection() {
         let vfoo = vec![&&[0, 1, 2, 3]];
         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
+        //~^ search_is_some
     }
 
     fn method_call_by_ref() {
@@ -180,11 +216,14 @@ mod issue7392 {
         }
         let vfoo = vec![Foo { bar: 1 }];
         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_some();
+        //~^ search_is_some
     }
 
     fn ref_bindings() {
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_some();
+        //~^ search_is_some
         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
+        //~^ search_is_some
     }
 
     fn test_string_1(s: &str) -> bool {
@@ -204,7 +243,9 @@ mod issue7392 {
         let lst = &[String::from("Hello"), String::from("world")];
         let v: Vec<&[String]> = vec![lst];
         let _ = v.iter().find(|s| s[0].is_empty()).is_some();
+        //~^ search_is_some
         let _ = v.iter().find(|s| test_string_1(&s[0])).is_some();
+        //~^ search_is_some
 
         // Field projections
         struct FieldProjection<'a> {
@@ -214,8 +255,11 @@ mod issue7392 {
         let instance = FieldProjection { field: &field };
         let v = vec![instance];
         let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_some();
+        //~^ search_is_some
         let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_some();
+        //~^ search_is_some
         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_some();
+        //~^ search_is_some
     }
 }
 
@@ -231,6 +275,7 @@ mod issue9120 {
     fn wrapper<T: Fn(&&u32) -> bool>(v: Vec<u32>, func: T) -> bool {
         #[allow(clippy::redundant_closure)]
         v.iter().find(|x: &&u32| func(x)).is_some()
+        //~^ search_is_some
     }
 
     fn do_tests() {
@@ -240,11 +285,14 @@ mod issue9120 {
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x: &&u32| arg_no_deref_impl(x)).is_some();
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x: &&u32| arg_no_deref_dyn(x)).is_some();
+        //~^ search_is_some
 
         #[allow(clippy::redundant_closure)]
         let _ = v.iter().find(|x: &&u32| (*arg_no_deref_dyn)(x)).is_some();
+        //~^ search_is_some
     }
 }
diff --git a/src/tools/clippy/tests/ui/search_is_some_fixable_some.stderr b/src/tools/clippy/tests/ui/search_is_some_fixable_some.stderr
index af1de7f82f80..af719b78831a 100644
--- a/src/tools/clippy/tests/ui/search_is_some_fixable_some.stderr
+++ b/src/tools/clippy/tests/ui/search_is_some_fixable_some.stderr
@@ -8,283 +8,286 @@ LL |     let _ = v.iter().find(|&x| *x < 0).is_some();
    = help: to override `-D warnings` add `#[allow(clippy::search_is_some)]`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:10:20
+  --> tests/ui/search_is_some_fixable_some.rs:11:20
    |
 LL |     let _ = (0..1).find(|x| **y == *x).is_some(); // one dereference less
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| **y == x)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:11:20
+  --> tests/ui/search_is_some_fixable_some.rs:14:20
    |
 LL |     let _ = (0..1).find(|x| *x == 0).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:12:22
+  --> tests/ui/search_is_some_fixable_some.rs:16:22
    |
 LL |     let _ = v.iter().find(|x| **x == 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| *x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:13:20
+  --> tests/ui/search_is_some_fixable_some.rs:18:20
    |
 LL |     let _ = (4..5).find(|x| *x == 1 || *x == 3 || *x == 5).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| x == 1 || x == 3 || x == 5)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:14:20
+  --> tests/ui/search_is_some_fixable_some.rs:20:20
    |
 LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x)).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| [1, 2, 3].contains(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:15:20
+  --> tests/ui/search_is_some_fixable_some.rs:22:20
    |
 LL |     let _ = (1..3).find(|x| *x == 0 || [1, 2, 3].contains(x)).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| x == 0 || [1, 2, 3].contains(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:16:20
+  --> tests/ui/search_is_some_fixable_some.rs:24:20
    |
 LL |     let _ = (1..3).find(|x| [1, 2, 3].contains(x) || *x == 0).is_some();
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| [1, 2, 3].contains(&x) || x == 0)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:18:10
+  --> tests/ui/search_is_some_fixable_some.rs:27:10
    |
 LL |           .find(|x| [1, 2, 3].contains(x) || *x == 0 || [4, 5, 6].contains(x) || *x == -1)
    |  __________^
+LL | |
 LL | |         .is_some();
    | |__________________^ help: consider using: `any(|x| [1, 2, 3].contains(&x) || x == 0 || [4, 5, 6].contains(&x) || x == -1)`
 
 error: called `is_some()` after searching an `Iterator` with `position`
-  --> tests/ui/search_is_some_fixable_some.rs:22:22
+  --> tests/ui/search_is_some_fixable_some.rs:32:22
    |
 LL |     let _ = v.iter().position(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|&x| x < 0)`
 
 error: called `is_some()` after searching an `Iterator` with `rposition`
-  --> tests/ui/search_is_some_fixable_some.rs:25:22
+  --> tests/ui/search_is_some_fixable_some.rs:36:22
    |
 LL |     let _ = v.iter().rposition(|&x| x < 0).is_some();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|&x| x < 0)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:30:27
+  --> tests/ui/search_is_some_fixable_some.rs:42:27
    |
 LL |     let _ = "hello world".find("world").is_some();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:31:27
+  --> tests/ui/search_is_some_fixable_some.rs:44:27
    |
 LL |     let _ = "hello world".find(&s2).is_some();
    |                           ^^^^^^^^^^^^^^^^^^^ help: consider using: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:32:27
+  --> tests/ui/search_is_some_fixable_some.rs:46:27
    |
 LL |     let _ = "hello world".find(&s2[2..]).is_some();
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `contains(&s2[2..])`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:34:16
+  --> tests/ui/search_is_some_fixable_some.rs:49:16
    |
 LL |     let _ = s1.find("world").is_some();
    |                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:35:16
+  --> tests/ui/search_is_some_fixable_some.rs:51:16
    |
 LL |     let _ = s1.find(&s2).is_some();
    |                ^^^^^^^^^^^^^^^^^^^ help: consider using: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:36:16
+  --> tests/ui/search_is_some_fixable_some.rs:53:16
    |
 LL |     let _ = s1.find(&s2[2..]).is_some();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `contains(&s2[2..])`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:38:21
+  --> tests/ui/search_is_some_fixable_some.rs:56:21
    |
 LL |     let _ = s1[2..].find("world").is_some();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `contains("world")`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:39:21
+  --> tests/ui/search_is_some_fixable_some.rs:58:21
    |
 LL |     let _ = s1[2..].find(&s2).is_some();
    |                     ^^^^^^^^^^^^^^^^^^^ help: consider using: `contains(&s2)`
 
 error: called `is_some()` after calling `find()` on a string
-  --> tests/ui/search_is_some_fixable_some.rs:40:21
+  --> tests/ui/search_is_some_fixable_some.rs:60:21
    |
 LL |     let _ = s1[2..].find(&s2[2..]).is_some();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `contains(&s2[2..])`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:56:44
+  --> tests/ui/search_is_some_fixable_some.rs:77:44
    |
 LL |             .filter(|c| filter_hand.iter().find(|cc| c == cc).is_some())
    |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|cc| c == &cc)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:72:49
+  --> tests/ui/search_is_some_fixable_some.rs:94:49
    |
 LL |             .filter(|(c, _)| filter_hand.iter().find(|cc| c == *cc).is_some())
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|cc| c == cc)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:83:29
+  --> tests/ui/search_is_some_fixable_some.rs:106:29
    |
 LL |         let _ = vfoo.iter().find(|v| v.foo == 1 && v.bar == 2).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|v| v.foo == 1 && v.bar == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:88:14
+  --> tests/ui/search_is_some_fixable_some.rs:112:14
    |
 LL |               .find(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)
    |  ______________^
+LL | |
 LL | |             .is_some();
    | |______________________^ help: consider using: `any(|(i, v)| *i == 42 && v.foo == 1 && v.bar == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:94:29
+  --> tests/ui/search_is_some_fixable_some.rs:119:29
    |
 LL |         let _ = vfoo.iter().find(|a| a[0] == 42).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|a| a[0] == 42)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:100:29
+  --> tests/ui/search_is_some_fixable_some.rs:126:29
    |
 LL |         let _ = vfoo.iter().find(|sub| sub[1..4].len() == 3).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|sub| sub[1..4].len() == 3)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:118:30
+  --> tests/ui/search_is_some_fixable_some.rs:145:30
    |
 LL |         let _ = [ppx].iter().find(|ppp_x: &&&u32| please(**ppp_x)).is_some();
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|ppp_x: &&u32| please(ppp_x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:119:50
+  --> tests/ui/search_is_some_fixable_some.rs:147:50
    |
 LL |         let _ = [String::from("Hey hey")].iter().find(|s| s.len() == 2).is_some();
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|s| s.len() == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:122:26
+  --> tests/ui/search_is_some_fixable_some.rs:151:26
    |
 LL |         let _ = v.iter().find(|x| deref_enough(**x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| deref_enough(*x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:123:26
+  --> tests/ui/search_is_some_fixable_some.rs:153:26
    |
 LL |         let _ = v.iter().find(|x: &&u32| deref_enough(**x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x: &u32| deref_enough(*x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:126:26
+  --> tests/ui/search_is_some_fixable_some.rs:157:26
    |
 LL |         let _ = v.iter().find(|x| arg_no_deref(x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| arg_no_deref(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:128:26
+  --> tests/ui/search_is_some_fixable_some.rs:160:26
    |
 LL |         let _ = v.iter().find(|x: &&u32| arg_no_deref(x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x: &u32| arg_no_deref(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:150:14
+  --> tests/ui/search_is_some_fixable_some.rs:183:14
    |
 LL |               .find(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)
    |  ______________^
+LL | |
 LL | |             .is_some();
    | |______________________^ help: consider using: `any(|v| v.inner_double.bar[0][0] == 2 && v.inner.bar[0] == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:164:29
+  --> tests/ui/search_is_some_fixable_some.rs:198:29
    |
 LL |         let _ = vfoo.iter().find(|v| v.inner[0].bar == 2).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|v| v.inner[0].bar == 2)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:169:29
+  --> tests/ui/search_is_some_fixable_some.rs:204:29
    |
 LL |         let _ = vfoo.iter().find(|x| (**x)[0] == 9).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x| (**x)[0] == 9)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:182:29
+  --> tests/ui/search_is_some_fixable_some.rs:218:29
    |
 LL |         let _ = vfoo.iter().find(|v| v.by_ref(&v.bar)).is_some();
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|v| v.by_ref(&v.bar))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:186:55
+  --> tests/ui/search_is_some_fixable_some.rs:223:55
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|(&x, y)| x == *y).is_some();
    |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|(&x, y)| x == *y)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:187:55
+  --> tests/ui/search_is_some_fixable_some.rs:225:55
    |
 LL |         let _ = [&(&1, 2), &(&3, 4), &(&5, 4)].iter().find(|&(&x, y)| x == *y).is_some();
    |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|(&x, y)| x == *y)`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:206:26
+  --> tests/ui/search_is_some_fixable_some.rs:245:26
    |
 LL |         let _ = v.iter().find(|s| s[0].is_empty()).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|s| s[0].is_empty())`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:207:26
+  --> tests/ui/search_is_some_fixable_some.rs:247:26
    |
 LL |         let _ = v.iter().find(|s| test_string_1(&s[0])).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|s| test_string_1(&s[0]))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:216:26
+  --> tests/ui/search_is_some_fixable_some.rs:257:26
    |
 LL |         let _ = v.iter().find(|fp| fp.field.is_power_of_two()).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|fp| fp.field.is_power_of_two())`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:217:26
+  --> tests/ui/search_is_some_fixable_some.rs:259:26
    |
 LL |         let _ = v.iter().find(|fp| test_u32_1(fp.field)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|fp| test_u32_1(fp.field))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:218:26
+  --> tests/ui/search_is_some_fixable_some.rs:261:26
    |
 LL |         let _ = v.iter().find(|fp| test_u32_2(*fp.field)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|fp| test_u32_2(*fp.field))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:233:18
+  --> tests/ui/search_is_some_fixable_some.rs:277:18
    |
 LL |         v.iter().find(|x: &&u32| func(x)).is_some()
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x: &u32| func(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:242:26
+  --> tests/ui/search_is_some_fixable_some.rs:287:26
    |
 LL |         let _ = v.iter().find(|x: &&u32| arg_no_deref_impl(x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x: &u32| arg_no_deref_impl(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:245:26
+  --> tests/ui/search_is_some_fixable_some.rs:291:26
    |
 LL |         let _ = v.iter().find(|x: &&u32| arg_no_deref_dyn(x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x: &u32| arg_no_deref_dyn(&x))`
 
 error: called `is_some()` after searching an `Iterator` with `find`
-  --> tests/ui/search_is_some_fixable_some.rs:248:26
+  --> tests/ui/search_is_some_fixable_some.rs:295:26
    |
 LL |         let _ = v.iter().find(|x: &&u32| (*arg_no_deref_dyn)(x)).is_some();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `any(|x: &u32| (*arg_no_deref_dyn)(&x))`
diff --git a/src/tools/clippy/tests/ui/seek_from_current.fixed b/src/tools/clippy/tests/ui/seek_from_current.fixed
index 543f0c681393..08eb15fe4e78 100644
--- a/src/tools/clippy/tests/ui/seek_from_current.fixed
+++ b/src/tools/clippy/tests/ui/seek_from_current.fixed
@@ -17,6 +17,7 @@ fn _msrv_1_51() -> io::Result<()> {
     let mut f = File::create("foo.txt")?;
     f.write_all(b"Hi!")?;
     f.stream_position()?;
+    //~^ seek_from_current
     f.seek(SeekFrom::Current(1))?;
     Ok(())
 }
diff --git a/src/tools/clippy/tests/ui/seek_from_current.rs b/src/tools/clippy/tests/ui/seek_from_current.rs
index 4ed877f8ec21..1974fd60dec7 100644
--- a/src/tools/clippy/tests/ui/seek_from_current.rs
+++ b/src/tools/clippy/tests/ui/seek_from_current.rs
@@ -17,6 +17,7 @@ fn _msrv_1_51() -> io::Result<()> {
     let mut f = File::create("foo.txt")?;
     f.write_all(b"Hi!")?;
     f.seek(SeekFrom::Current(0))?;
+    //~^ seek_from_current
     f.seek(SeekFrom::Current(1))?;
     Ok(())
 }
diff --git a/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.fixed b/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.fixed
index 8859a68320f0..87747eafc443 100644
--- a/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.fixed
+++ b/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.fixed
@@ -50,11 +50,13 @@ fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
 // This should trigger clippy warning
 fn seek_to_start<T: Seek>(t: &mut T) {
     t.rewind();
+    //~^ seek_to_start_instead_of_rewind
 }
 
 // This should trigger clippy warning
 fn owned_seek_to_start<T: Seek>(mut t: T) {
     t.rewind();
+    //~^ seek_to_start_instead_of_rewind
 }
 
 // This should NOT trigger clippy warning because
@@ -134,6 +136,7 @@ fn msrv_1_55() {
     write!(f, "{hello}").unwrap();
 
     f.rewind();
+    //~^ seek_to_start_instead_of_rewind
 
     let mut buf = String::new();
     f.read_to_string(&mut buf).unwrap();
diff --git a/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.rs b/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.rs
index 7b72efb34ff8..e824a9b1ec31 100644
--- a/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.rs
+++ b/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.rs
@@ -50,11 +50,13 @@ fn seek_to_start_false_trait_bound<T: MySeekTrait>(t: &mut T) {
 // This should trigger clippy warning
 fn seek_to_start<T: Seek>(t: &mut T) {
     t.seek(SeekFrom::Start(0));
+    //~^ seek_to_start_instead_of_rewind
 }
 
 // This should trigger clippy warning
 fn owned_seek_to_start<T: Seek>(mut t: T) {
     t.seek(SeekFrom::Start(0));
+    //~^ seek_to_start_instead_of_rewind
 }
 
 // This should NOT trigger clippy warning because
@@ -134,6 +136,7 @@ fn msrv_1_55() {
     write!(f, "{hello}").unwrap();
 
     f.seek(SeekFrom::Start(0));
+    //~^ seek_to_start_instead_of_rewind
 
     let mut buf = String::new();
     f.read_to_string(&mut buf).unwrap();
diff --git a/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.stderr b/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.stderr
index 2c3c45820e10..6c6575cc02f5 100644
--- a/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.stderr
+++ b/src/tools/clippy/tests/ui/seek_to_start_instead_of_rewind.stderr
@@ -8,13 +8,13 @@ LL |     t.seek(SeekFrom::Start(0));
    = help: to override `-D warnings` add `#[allow(clippy::seek_to_start_instead_of_rewind)]`
 
 error: used `seek` to go to the start of the stream
-  --> tests/ui/seek_to_start_instead_of_rewind.rs:57:7
+  --> tests/ui/seek_to_start_instead_of_rewind.rs:58:7
    |
 LL |     t.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
 
 error: used `seek` to go to the start of the stream
-  --> tests/ui/seek_to_start_instead_of_rewind.rs:136:7
+  --> tests/ui/seek_to_start_instead_of_rewind.rs:138:7
    |
 LL |     f.seek(SeekFrom::Start(0));
    |       ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `rewind()`
diff --git a/src/tools/clippy/tests/ui/self_assignment.rs b/src/tools/clippy/tests/ui/self_assignment.rs
index 213bca6c4515..6e82b42cf6d7 100644
--- a/src/tools/clippy/tests/ui/self_assignment.rs
+++ b/src/tools/clippy/tests/ui/self_assignment.rs
@@ -11,30 +11,38 @@ pub struct S<'a> {
 
 pub fn positives(mut a: usize, b: &mut u32, mut s: S) {
     a = a;
-    //~^ ERROR: self-assignment of `a` to `a`
-    //~| NOTE: `-D clippy::self-assignment` implied by `-D warnings`
+    //~^ self_assignment
+
     *b = *b;
-    //~^ ERROR: self-assignment of `*b` to `*b`
+    //~^ self_assignment
+
     s = s;
-    //~^ ERROR: self-assignment of `s` to `s`
+    //~^ self_assignment
+
     s.a = s.a;
-    //~^ ERROR: self-assignment of `s.a` to `s.a`
+    //~^ self_assignment
+
     s.b[9] = s.b[5 + 4];
-    //~^ ERROR: self-assignment of `s.b[5 + 4]` to `s.b[9]`
+    //~^ self_assignment
+
     s.c[0][1] = s.c[0][1];
-    //~^ ERROR: self-assignment of `s.c[0][1]` to `s.c[0][1]`
+    //~^ self_assignment
+
     s.b[a] = s.b[a];
-    //~^ ERROR: self-assignment of `s.b[a]` to `s.b[a]`
+    //~^ self_assignment
+
     *s.e = *s.e;
-    //~^ ERROR: self-assignment of `*s.e` to `*s.e`
+    //~^ self_assignment
+
     s.b[a + 10] = s.b[10 + a];
-    //~^ ERROR: self-assignment of `s.b[10 + a]` to `s.b[a + 10]`
+    //~^ self_assignment
 
     let mut t = (0, 1);
     t.1 = t.1;
-    //~^ ERROR: self-assignment of `t.1` to `t.1`
+    //~^ self_assignment
+
     t.0 = (t.0);
-    //~^ ERROR: self-assignment of `(t.0)` to `t.0`
+    //~^ self_assignment
 }
 
 pub fn negatives_not_equal(mut a: usize, b: &mut usize, mut s: S) {
diff --git a/src/tools/clippy/tests/ui/self_assignment.stderr b/src/tools/clippy/tests/ui/self_assignment.stderr
index e92414163d4c..e9a2164187ce 100644
--- a/src/tools/clippy/tests/ui/self_assignment.stderr
+++ b/src/tools/clippy/tests/ui/self_assignment.stderr
@@ -14,55 +14,55 @@ LL |     *b = *b;
    |     ^^^^^^^
 
 error: self-assignment of `s` to `s`
-  --> tests/ui/self_assignment.rs:18:5
+  --> tests/ui/self_assignment.rs:19:5
    |
 LL |     s = s;
    |     ^^^^^
 
 error: self-assignment of `s.a` to `s.a`
-  --> tests/ui/self_assignment.rs:20:5
+  --> tests/ui/self_assignment.rs:22:5
    |
 LL |     s.a = s.a;
    |     ^^^^^^^^^
 
 error: self-assignment of `s.b[5 + 4]` to `s.b[9]`
-  --> tests/ui/self_assignment.rs:22:5
+  --> tests/ui/self_assignment.rs:25:5
    |
 LL |     s.b[9] = s.b[5 + 4];
    |     ^^^^^^^^^^^^^^^^^^^
 
 error: self-assignment of `s.c[0][1]` to `s.c[0][1]`
-  --> tests/ui/self_assignment.rs:24:5
+  --> tests/ui/self_assignment.rs:28:5
    |
 LL |     s.c[0][1] = s.c[0][1];
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: self-assignment of `s.b[a]` to `s.b[a]`
-  --> tests/ui/self_assignment.rs:26:5
+  --> tests/ui/self_assignment.rs:31:5
    |
 LL |     s.b[a] = s.b[a];
    |     ^^^^^^^^^^^^^^^
 
 error: self-assignment of `*s.e` to `*s.e`
-  --> tests/ui/self_assignment.rs:28:5
+  --> tests/ui/self_assignment.rs:34:5
    |
 LL |     *s.e = *s.e;
    |     ^^^^^^^^^^^
 
 error: self-assignment of `s.b[10 + a]` to `s.b[a + 10]`
-  --> tests/ui/self_assignment.rs:30:5
+  --> tests/ui/self_assignment.rs:37:5
    |
 LL |     s.b[a + 10] = s.b[10 + a];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: self-assignment of `t.1` to `t.1`
-  --> tests/ui/self_assignment.rs:34:5
+  --> tests/ui/self_assignment.rs:41:5
    |
 LL |     t.1 = t.1;
    |     ^^^^^^^^^
 
 error: self-assignment of `(t.0)` to `t.0`
-  --> tests/ui/self_assignment.rs:36:5
+  --> tests/ui/self_assignment.rs:44:5
    |
 LL |     t.0 = (t.0);
    |     ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/self_named_constructors.rs b/src/tools/clippy/tests/ui/self_named_constructors.rs
index dc326b399481..8b6453e0d1d7 100644
--- a/src/tools/clippy/tests/ui/self_named_constructors.rs
+++ b/src/tools/clippy/tests/ui/self_named_constructors.rs
@@ -5,8 +5,8 @@ struct ShouldNotSpawn;
 
 impl ShouldSpawn {
     pub fn should_spawn() -> ShouldSpawn {
-        //~^ ERROR: constructor `should_spawn` has the same name as the type
-        //~| NOTE: `-D clippy::self-named-constructors` implied by `-D warnings`
+        //~^ self_named_constructors
+
         ShouldSpawn
     }
 
diff --git a/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.fixed b/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.fixed
index 6c8c835d0e0e..3de14e9d2595 100644
--- a/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.fixed
+++ b/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.fixed
@@ -16,21 +16,25 @@ fn get_unit() {}
 // the functions below trigger the lint
 fn main() {
     println!("Hello");
+    //~^ semicolon_if_nothing_returned
 }
 
 fn hello() {
     get_unit();
+    //~^ semicolon_if_nothing_returned
 }
 
 fn basic101(x: i32) {
     let y: i32;
     y = x + 1;
+    //~^ semicolon_if_nothing_returned
 }
 
 #[rustfmt::skip]
 fn closure_error() {
     let _d = || {
         hello();
+        //~^ semicolon_if_nothing_returned
     };
 }
 
@@ -42,6 +46,7 @@ fn unsafe_checks_error() {
     let mut s = MaybeUninit::<String>::uninit();
     let _d = || unsafe {
         ptr::drop_in_place(s.as_mut_ptr());
+        //~^ semicolon_if_nothing_returned
     };
 }
 
diff --git a/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.rs b/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.rs
index 2c2e4c024190..304f43fb457c 100644
--- a/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.rs
+++ b/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.rs
@@ -16,21 +16,25 @@ fn get_unit() {}
 // the functions below trigger the lint
 fn main() {
     println!("Hello")
+    //~^ semicolon_if_nothing_returned
 }
 
 fn hello() {
     get_unit()
+    //~^ semicolon_if_nothing_returned
 }
 
 fn basic101(x: i32) {
     let y: i32;
     y = x + 1
+    //~^ semicolon_if_nothing_returned
 }
 
 #[rustfmt::skip]
 fn closure_error() {
     let _d = || {
         hello()
+        //~^ semicolon_if_nothing_returned
     };
 }
 
@@ -42,6 +46,7 @@ fn unsafe_checks_error() {
     let mut s = MaybeUninit::<String>::uninit();
     let _d = || unsafe {
         ptr::drop_in_place(s.as_mut_ptr())
+        //~^ semicolon_if_nothing_returned
     };
 }
 
diff --git a/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.stderr b/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.stderr
index 69e434b142cf..d7d117e05bdf 100644
--- a/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.stderr
+++ b/src/tools/clippy/tests/ui/semicolon_if_nothing_returned.stderr
@@ -8,25 +8,25 @@ LL |     println!("Hello")
    = help: to override `-D warnings` add `#[allow(clippy::semicolon_if_nothing_returned)]`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> tests/ui/semicolon_if_nothing_returned.rs:22:5
+  --> tests/ui/semicolon_if_nothing_returned.rs:23:5
    |
 LL |     get_unit()
    |     ^^^^^^^^^^ help: add a `;` here: `get_unit();`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> tests/ui/semicolon_if_nothing_returned.rs:27:5
+  --> tests/ui/semicolon_if_nothing_returned.rs:29:5
    |
 LL |     y = x + 1
    |     ^^^^^^^^^ help: add a `;` here: `y = x + 1;`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> tests/ui/semicolon_if_nothing_returned.rs:33:9
+  --> tests/ui/semicolon_if_nothing_returned.rs:36:9
    |
 LL |         hello()
    |         ^^^^^^^ help: add a `;` here: `hello();`
 
 error: consider adding a `;` to the last statement for consistent formatting
-  --> tests/ui/semicolon_if_nothing_returned.rs:44:9
+  --> tests/ui/semicolon_if_nothing_returned.rs:48:9
    |
 LL |         ptr::drop_in_place(s.as_mut_ptr())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: add a `;` here: `ptr::drop_in_place(s.as_mut_ptr());`
diff --git a/src/tools/clippy/tests/ui/semicolon_inside_block.fixed b/src/tools/clippy/tests/ui/semicolon_inside_block.fixed
index 21681e71589e..7eb53e733ad5 100644
--- a/src/tools/clippy/tests/ui/semicolon_inside_block.fixed
+++ b/src/tools/clippy/tests/ui/semicolon_inside_block.fixed
@@ -36,7 +36,9 @@ fn main() {
     }
 
     { unit_fn_block(); }
+    //~^ semicolon_inside_block
     unsafe { unit_fn_block(); }
+    //~^ semicolon_inside_block
 
     { unit_fn_block(); }
     unsafe { unit_fn_block(); }
@@ -45,6 +47,7 @@ fn main() {
     unsafe { unit_fn_block(); };
 
     {
+    //~^ semicolon_inside_block
         unit_fn_block();
         unit_fn_block();
     }
@@ -58,6 +61,7 @@ fn main() {
     };
 
     { m!(()); }
+    //~^ semicolon_inside_block
     { m!(()); }
     { m!(()); };
     m!(0);
diff --git a/src/tools/clippy/tests/ui/semicolon_inside_block.rs b/src/tools/clippy/tests/ui/semicolon_inside_block.rs
index 3a81661cd16f..9fa5b117194d 100644
--- a/src/tools/clippy/tests/ui/semicolon_inside_block.rs
+++ b/src/tools/clippy/tests/ui/semicolon_inside_block.rs
@@ -36,7 +36,9 @@ fn main() {
     }
 
     { unit_fn_block() };
+    //~^ semicolon_inside_block
     unsafe { unit_fn_block() };
+    //~^ semicolon_inside_block
 
     { unit_fn_block(); }
     unsafe { unit_fn_block(); }
@@ -45,6 +47,7 @@ fn main() {
     unsafe { unit_fn_block(); };
 
     {
+    //~^ semicolon_inside_block
         unit_fn_block();
         unit_fn_block()
     };
@@ -58,6 +61,7 @@ fn main() {
     };
 
     { m!(()) };
+    //~^ semicolon_inside_block
     { m!(()); }
     { m!(()); };
     m!(0);
diff --git a/src/tools/clippy/tests/ui/semicolon_inside_block.stderr b/src/tools/clippy/tests/ui/semicolon_inside_block.stderr
index d32fb681d3b9..23433f4e7ef9 100644
--- a/src/tools/clippy/tests/ui/semicolon_inside_block.stderr
+++ b/src/tools/clippy/tests/ui/semicolon_inside_block.stderr
@@ -13,7 +13,7 @@ LL +     { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:39:5
+  --> tests/ui/semicolon_inside_block.rs:40:5
    |
 LL |     unsafe { unit_fn_block() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,9 +25,10 @@ LL +     unsafe { unit_fn_block(); }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:47:5
+  --> tests/ui/semicolon_inside_block.rs:49:5
    |
 LL | /     {
+LL | |
 LL | |         unit_fn_block();
 LL | |         unit_fn_block()
 LL | |     };
@@ -40,7 +41,7 @@ LL ~     }
    |
 
 error: consider moving the `;` inside the block for consistent formatting
-  --> tests/ui/semicolon_inside_block.rs:60:5
+  --> tests/ui/semicolon_inside_block.rs:63:5
    |
 LL |     { m!(()) };
    |     ^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/semicolon_outside_block.fixed b/src/tools/clippy/tests/ui/semicolon_outside_block.fixed
index ac7e86631cae..52fae9a3aff1 100644
--- a/src/tools/clippy/tests/ui/semicolon_outside_block.fixed
+++ b/src/tools/clippy/tests/ui/semicolon_outside_block.fixed
@@ -39,7 +39,9 @@ fn main() {
     unsafe { unit_fn_block() };
 
     { unit_fn_block() };
+    //~^ semicolon_outside_block
     unsafe { unit_fn_block() };
+    //~^ semicolon_outside_block
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
@@ -49,6 +51,7 @@ fn main() {
         unit_fn_block()
     };
     {
+    //~^ semicolon_outside_block
         unit_fn_block();
         unit_fn_block()
     };
@@ -59,6 +62,7 @@ fn main() {
 
     { m!(()) };
     { m!(()) };
+    //~^ semicolon_outside_block
     { m!(()); };
     m!(0);
     m!(1);
@@ -81,10 +85,12 @@ fn main() {
     { unit_fn_block(); };
 
     unsafe {
+    //~^ semicolon_outside_block
         std::arch::asm!("")
     };
 
     {
+    //~^ semicolon_outside_block
         line!()
     };
 
diff --git a/src/tools/clippy/tests/ui/semicolon_outside_block.rs b/src/tools/clippy/tests/ui/semicolon_outside_block.rs
index 68f25339e322..5975e66fbb81 100644
--- a/src/tools/clippy/tests/ui/semicolon_outside_block.rs
+++ b/src/tools/clippy/tests/ui/semicolon_outside_block.rs
@@ -39,7 +39,9 @@ fn main() {
     unsafe { unit_fn_block() };
 
     { unit_fn_block(); }
+    //~^ semicolon_outside_block
     unsafe { unit_fn_block(); }
+    //~^ semicolon_outside_block
 
     { unit_fn_block(); };
     unsafe { unit_fn_block(); };
@@ -49,6 +51,7 @@ fn main() {
         unit_fn_block()
     };
     {
+    //~^ semicolon_outside_block
         unit_fn_block();
         unit_fn_block();
     }
@@ -59,6 +62,7 @@ fn main() {
 
     { m!(()) };
     { m!(()); }
+    //~^ semicolon_outside_block
     { m!(()); };
     m!(0);
     m!(1);
@@ -81,10 +85,12 @@ fn main() {
     { unit_fn_block(); };
 
     unsafe {
+    //~^ semicolon_outside_block
         std::arch::asm!("");
     }
 
     {
+    //~^ semicolon_outside_block
         line!();
     }
 
diff --git a/src/tools/clippy/tests/ui/semicolon_outside_block.stderr b/src/tools/clippy/tests/ui/semicolon_outside_block.stderr
index ff8c00048f63..18d6dc697f2e 100644
--- a/src/tools/clippy/tests/ui/semicolon_outside_block.stderr
+++ b/src/tools/clippy/tests/ui/semicolon_outside_block.stderr
@@ -13,7 +13,7 @@ LL +     { unit_fn_block() };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui/semicolon_outside_block.rs:42:5
+  --> tests/ui/semicolon_outside_block.rs:43:5
    |
 LL |     unsafe { unit_fn_block(); }
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,9 +25,10 @@ LL +     unsafe { unit_fn_block() };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui/semicolon_outside_block.rs:51:5
+  --> tests/ui/semicolon_outside_block.rs:53:5
    |
 LL | /     {
+LL | |
 LL | |         unit_fn_block();
 LL | |         unit_fn_block();
 LL | |     }
@@ -40,7 +41,7 @@ LL ~     };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui/semicolon_outside_block.rs:61:5
+  --> tests/ui/semicolon_outside_block.rs:64:5
    |
 LL |     { m!(()); }
    |     ^^^^^^^^^^^
@@ -52,9 +53,10 @@ LL +     { m!(()) };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui/semicolon_outside_block.rs:83:5
+  --> tests/ui/semicolon_outside_block.rs:87:5
    |
 LL | /     unsafe {
+LL | |
 LL | |         std::arch::asm!("");
 LL | |     }
    | |_____^
@@ -66,9 +68,10 @@ LL ~     };
    |
 
 error: consider moving the `;` outside the block for consistent formatting
-  --> tests/ui/semicolon_outside_block.rs:87:5
+  --> tests/ui/semicolon_outside_block.rs:92:5
    |
 LL | /     {
+LL | |
 LL | |         line!();
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/serde.rs b/src/tools/clippy/tests/ui/serde.rs
index af8b10f3e6ae..8ab1144e5700 100644
--- a/src/tools/clippy/tests/ui/serde.rs
+++ b/src/tools/clippy/tests/ui/serde.rs
@@ -37,8 +37,7 @@ impl<'de> serde::de::Visitor<'de> for B {
     }
 
     fn visit_string<E>(self, _v: String) -> Result<Self::Value, E>
-    //~^ ERROR: you should not implement `visit_string` without also implementing `visit_s
-    //~| NOTE: `-D clippy::serde-api-misuse` implied by `-D warnings`
+    //~^ serde_api_misuse
     where
         E: serde::de::Error,
     {
diff --git a/src/tools/clippy/tests/ui/serde.stderr b/src/tools/clippy/tests/ui/serde.stderr
index f71d41d58aae..eb6b7c6b0c36 100644
--- a/src/tools/clippy/tests/ui/serde.stderr
+++ b/src/tools/clippy/tests/ui/serde.stderr
@@ -3,9 +3,9 @@ error: you should not implement `visit_string` without also implementing `visit_
    |
 LL | /     fn visit_string<E>(self, _v: String) -> Result<Self::Value, E>
 LL | |
-LL | |
 LL | |     where
-...  |
+LL | |         E: serde::de::Error,
+LL | |     {
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/set_contains_or_insert.rs b/src/tools/clippy/tests/ui/set_contains_or_insert.rs
index d3a3e1c878b3..575cfda139a4 100644
--- a/src/tools/clippy/tests/ui/set_contains_or_insert.rs
+++ b/src/tools/clippy/tests/ui/set_contains_or_insert.rs
@@ -10,35 +10,42 @@ fn should_warn_hashset() {
     let value = 5;
 
     if !set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
         println!("Just a comment");
     }
 
     if set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
         println!("Just a comment");
     }
 
     if !set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
     }
 
     if !!set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
         println!("Just a comment");
     }
 
     if (&set).contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
     }
 
     let borrow_value = &6;
     if !set.contains(borrow_value) {
+        //~^ set_contains_or_insert
         set.insert(*borrow_value);
     }
 
     let borrow_set = &mut set;
     if !borrow_set.contains(&value) {
+        //~^ set_contains_or_insert
         borrow_set.insert(value);
     }
 }
@@ -77,35 +84,42 @@ fn should_warn_btreeset() {
     let value = 5;
 
     if !set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
         println!("Just a comment");
     }
 
     if set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
         println!("Just a comment");
     }
 
     if !set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
     }
 
     if !!set.contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
         println!("Just a comment");
     }
 
     if (&set).contains(&value) {
+        //~^ set_contains_or_insert
         set.insert(value);
     }
 
     let borrow_value = &6;
     if !set.contains(borrow_value) {
+        //~^ set_contains_or_insert
         set.insert(*borrow_value);
     }
 
     let borrow_set = &mut set;
     if !borrow_set.contains(&value) {
+        //~^ set_contains_or_insert
         borrow_set.insert(value);
     }
 }
diff --git a/src/tools/clippy/tests/ui/set_contains_or_insert.stderr b/src/tools/clippy/tests/ui/set_contains_or_insert.stderr
index 14ad63005448..3152b1136458 100644
--- a/src/tools/clippy/tests/ui/set_contains_or_insert.stderr
+++ b/src/tools/clippy/tests/ui/set_contains_or_insert.stderr
@@ -3,6 +3,7 @@ error: usage of `HashSet::insert` after `HashSet::contains`
    |
 LL |     if !set.contains(&value) {
    |             ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
    |
@@ -10,106 +11,119 @@ LL |         set.insert(value);
    = help: to override `-D warnings` add `#[allow(clippy::set_contains_or_insert)]`
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:17:12
+  --> tests/ui/set_contains_or_insert.rs:18:12
    |
 LL |     if set.contains(&value) {
    |            ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:22:13
+  --> tests/ui/set_contains_or_insert.rs:24:13
    |
 LL |     if !set.contains(&value) {
    |             ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:26:14
+  --> tests/ui/set_contains_or_insert.rs:29:14
    |
 LL |     if !!set.contains(&value) {
    |              ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:31:15
+  --> tests/ui/set_contains_or_insert.rs:35:15
    |
 LL |     if (&set).contains(&value) {
    |               ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:36:13
+  --> tests/ui/set_contains_or_insert.rs:41:13
    |
 LL |     if !set.contains(borrow_value) {
    |             ^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(*borrow_value);
    |             ^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of `HashSet::insert` after `HashSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:41:20
+  --> tests/ui/set_contains_or_insert.rs:47:20
    |
 LL |     if !borrow_set.contains(&value) {
    |                    ^^^^^^^^^^^^^^^^
+LL |
 LL |         borrow_set.insert(value);
    |                    ^^^^^^^^^^^^^
 
 error: usage of `BTreeSet::insert` after `BTreeSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:79:13
+  --> tests/ui/set_contains_or_insert.rs:86:13
    |
 LL |     if !set.contains(&value) {
    |             ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `BTreeSet::insert` after `BTreeSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:84:12
+  --> tests/ui/set_contains_or_insert.rs:92:12
    |
 LL |     if set.contains(&value) {
    |            ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `BTreeSet::insert` after `BTreeSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:89:13
+  --> tests/ui/set_contains_or_insert.rs:98:13
    |
 LL |     if !set.contains(&value) {
    |             ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `BTreeSet::insert` after `BTreeSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:93:14
+  --> tests/ui/set_contains_or_insert.rs:103:14
    |
 LL |     if !!set.contains(&value) {
    |              ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `BTreeSet::insert` after `BTreeSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:98:15
+  --> tests/ui/set_contains_or_insert.rs:109:15
    |
 LL |     if (&set).contains(&value) {
    |               ^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(value);
    |             ^^^^^^^^^^^^^
 
 error: usage of `BTreeSet::insert` after `BTreeSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:103:13
+  --> tests/ui/set_contains_or_insert.rs:115:13
    |
 LL |     if !set.contains(borrow_value) {
    |             ^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |         set.insert(*borrow_value);
    |             ^^^^^^^^^^^^^^^^^^^^^
 
 error: usage of `BTreeSet::insert` after `BTreeSet::contains`
-  --> tests/ui/set_contains_or_insert.rs:108:20
+  --> tests/ui/set_contains_or_insert.rs:121:20
    |
 LL |     if !borrow_set.contains(&value) {
    |                    ^^^^^^^^^^^^^^^^
+LL |
 LL |         borrow_set.insert(value);
    |                    ^^^^^^^^^^^^^
 
diff --git a/src/tools/clippy/tests/ui/shadow.rs b/src/tools/clippy/tests/ui/shadow.rs
index 31944f5ef1b1..7d503a1cf6c1 100644
--- a/src/tools/clippy/tests/ui/shadow.rs
+++ b/src/tools/clippy/tests/ui/shadow.rs
@@ -22,22 +22,34 @@ macro_rules! reuse {
 fn shadow_same() {
     let x = 1;
     let x = x;
+    //~^ shadow_same
     let mut x = &x;
+    //~^ shadow_same
     let x = &mut x;
+    //~^ shadow_same
     let x = *x;
+    //~^ shadow_same
 }
 
 fn shadow_reuse() -> Option<()> {
     let x = ([[0]], ());
     let x = x.0;
+    //~^ shadow_reuse
     let x = x[0];
+    //~^ shadow_reuse
     let [x] = x;
+    //~^ shadow_reuse
     let x = Some(x);
+    //~^ shadow_reuse
     let x = foo(x);
+    //~^ shadow_reuse
     let x = || x;
+    //~^ shadow_reuse
     let x = Some(1).map(|_| x)?;
+    //~^ shadow_reuse
     let y = 1;
     let y = match y {
+        //~^ shadow_reuse
         1 => 2,
         _ => 3,
     };
@@ -53,27 +65,36 @@ fn shadow_reuse_macro() {
 fn shadow_unrelated() {
     let x = 1;
     let x = 2;
+    //~^ shadow_unrelated
 }
 
 fn syntax() {
     fn f(x: u32) {
         let x = 1;
+        //~^ shadow_unrelated
     }
     let x = 1;
     match Some(1) {
         Some(1) => {},
         Some(x) => {
+            //~^ shadow_unrelated
             let x = 1;
+            //~^ shadow_unrelated
         },
         _ => {},
     }
     if let Some(x) = Some(1) {}
+    //~^ shadow_unrelated
     while let Some(x) = Some(1) {}
+    //~^ shadow_unrelated
     let _ = |[x]: [u32; 1]| {
+        //~^ shadow_unrelated
         let x = 1;
+        //~^ shadow_unrelated
     };
     let y = Some(1);
     if let Some(y) = y {}
+    //~^ shadow_reuse
 }
 
 fn negative() {
@@ -110,12 +131,14 @@ pub async fn foo1(_a: i32) {}
 
 pub async fn foo2(_a: i32, _b: i64) {
     let _b = _a;
+    //~^ shadow_unrelated
 }
 
 fn ice_8748() {
     let _ = [0; {
         let x = 1;
         if let Some(x) = Some(1) { x } else { 1 }
+        //~^ shadow_unrelated
     }];
 }
 
@@ -126,10 +149,12 @@ fn shadow_closure() {
     #[allow(clippy::shadow_reuse)]
     let y = x.map(|x| x + 1);
     let z = x.map(|x| x + 1);
+    //~^ shadow_reuse
     let a: Vec<Option<u8>> = [100u8, 120, 140]
         .iter()
         .map(|i| i.checked_mul(2))
         .map(|i| i.map(|i| i - 10))
+        //~^ shadow_reuse
         .collect();
 }
 
@@ -139,6 +164,7 @@ struct Issue13795 {
 
 fn issue13795(value: Issue13795) {
     let Issue13795 { value, .. } = value;
+    //~^ shadow_same
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/shadow.stderr b/src/tools/clippy/tests/ui/shadow.stderr
index c8c524b3a2f5..649f843575a7 100644
--- a/src/tools/clippy/tests/ui/shadow.stderr
+++ b/src/tools/clippy/tests/ui/shadow.stderr
@@ -13,7 +13,7 @@ LL |     let x = 1;
    = help: to override `-D warnings` add `#[allow(clippy::shadow_same)]`
 
 error: `mut x` is shadowed by itself in `&x`
-  --> tests/ui/shadow.rs:25:13
+  --> tests/ui/shadow.rs:26:13
    |
 LL |     let mut x = &x;
    |             ^
@@ -25,37 +25,37 @@ LL |     let x = x;
    |         ^
 
 error: `x` is shadowed by itself in `&mut x`
-  --> tests/ui/shadow.rs:26:9
+  --> tests/ui/shadow.rs:28:9
    |
 LL |     let x = &mut x;
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:25:9
+  --> tests/ui/shadow.rs:26:9
    |
 LL |     let mut x = &x;
    |         ^^^^^
 
 error: `x` is shadowed by itself in `*x`
-  --> tests/ui/shadow.rs:27:9
+  --> tests/ui/shadow.rs:30:9
    |
 LL |     let x = *x;
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:26:9
+  --> tests/ui/shadow.rs:28:9
    |
 LL |     let x = &mut x;
    |         ^
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:32:9
+  --> tests/ui/shadow.rs:36:9
    |
 LL |     let x = x.0;
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:31:9
+  --> tests/ui/shadow.rs:35:9
    |
 LL |     let x = ([[0]], ());
    |         ^
@@ -63,175 +63,103 @@ LL |     let x = ([[0]], ());
    = help: to override `-D warnings` add `#[allow(clippy::shadow_reuse)]`
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:33:9
+  --> tests/ui/shadow.rs:38:9
    |
 LL |     let x = x[0];
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:32:9
+  --> tests/ui/shadow.rs:36:9
    |
 LL |     let x = x.0;
    |         ^
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:34:10
+  --> tests/ui/shadow.rs:40:10
    |
 LL |     let [x] = x;
    |          ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:33:9
+  --> tests/ui/shadow.rs:38:9
    |
 LL |     let x = x[0];
    |         ^
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:35:9
+  --> tests/ui/shadow.rs:42:9
    |
 LL |     let x = Some(x);
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:34:10
+  --> tests/ui/shadow.rs:40:10
    |
 LL |     let [x] = x;
    |          ^
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:36:9
+  --> tests/ui/shadow.rs:44:9
    |
 LL |     let x = foo(x);
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:35:9
+  --> tests/ui/shadow.rs:42:9
    |
 LL |     let x = Some(x);
    |         ^
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:37:9
+  --> tests/ui/shadow.rs:46:9
    |
 LL |     let x = || x;
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:36:9
+  --> tests/ui/shadow.rs:44:9
    |
 LL |     let x = foo(x);
    |         ^
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:38:9
+  --> tests/ui/shadow.rs:48:9
    |
 LL |     let x = Some(1).map(|_| x)?;
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:37:9
+  --> tests/ui/shadow.rs:46:9
    |
 LL |     let x = || x;
    |         ^
 
 error: `y` is shadowed
-  --> tests/ui/shadow.rs:40:9
+  --> tests/ui/shadow.rs:51:9
    |
 LL |     let y = match y {
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:39:9
+  --> tests/ui/shadow.rs:50:9
    |
 LL |     let y = 1;
    |         ^
 
 error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:55:9
+  --> tests/ui/shadow.rs:67:9
    |
 LL |     let x = 2;
    |         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:54:9
+  --> tests/ui/shadow.rs:66:9
    |
 LL |     let x = 1;
    |         ^
    = note: `-D clippy::shadow-unrelated` implied by `-D warnings`
    = help: to override `-D warnings` add `#[allow(clippy::shadow_unrelated)]`
 
-error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:60:13
-   |
-LL |         let x = 1;
-   |             ^
-   |
-note: previous binding is here
-  --> tests/ui/shadow.rs:59:10
-   |
-LL |     fn f(x: u32) {
-   |          ^
-
-error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:65:14
-   |
-LL |         Some(x) => {
-   |              ^
-   |
-note: previous binding is here
-  --> tests/ui/shadow.rs:62:9
-   |
-LL |     let x = 1;
-   |         ^
-
-error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:66:17
-   |
-LL |             let x = 1;
-   |                 ^
-   |
-note: previous binding is here
-  --> tests/ui/shadow.rs:65:14
-   |
-LL |         Some(x) => {
-   |              ^
-
-error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:70:17
-   |
-LL |     if let Some(x) = Some(1) {}
-   |                 ^
-   |
-note: previous binding is here
-  --> tests/ui/shadow.rs:62:9
-   |
-LL |     let x = 1;
-   |         ^
-
-error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:71:20
-   |
-LL |     while let Some(x) = Some(1) {}
-   |                    ^
-   |
-note: previous binding is here
-  --> tests/ui/shadow.rs:62:9
-   |
-LL |     let x = 1;
-   |         ^
-
-error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:72:15
-   |
-LL |     let _ = |[x]: [u32; 1]| {
-   |               ^
-   |
-note: previous binding is here
-  --> tests/ui/shadow.rs:62:9
-   |
-LL |     let x = 1;
-   |         ^
-
 error: `x` shadows a previous, unrelated binding
   --> tests/ui/shadow.rs:73:13
    |
@@ -239,79 +167,151 @@ LL |         let x = 1;
    |             ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:72:15
+  --> tests/ui/shadow.rs:72:10
+   |
+LL |     fn f(x: u32) {
+   |          ^
+
+error: `x` shadows a previous, unrelated binding
+  --> tests/ui/shadow.rs:79:14
+   |
+LL |         Some(x) => {
+   |              ^
+   |
+note: previous binding is here
+  --> tests/ui/shadow.rs:76:9
+   |
+LL |     let x = 1;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> tests/ui/shadow.rs:81:17
+   |
+LL |             let x = 1;
+   |                 ^
+   |
+note: previous binding is here
+  --> tests/ui/shadow.rs:79:14
+   |
+LL |         Some(x) => {
+   |              ^
+
+error: `x` shadows a previous, unrelated binding
+  --> tests/ui/shadow.rs:86:17
+   |
+LL |     if let Some(x) = Some(1) {}
+   |                 ^
+   |
+note: previous binding is here
+  --> tests/ui/shadow.rs:76:9
+   |
+LL |     let x = 1;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> tests/ui/shadow.rs:88:20
+   |
+LL |     while let Some(x) = Some(1) {}
+   |                    ^
+   |
+note: previous binding is here
+  --> tests/ui/shadow.rs:76:9
+   |
+LL |     let x = 1;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> tests/ui/shadow.rs:90:15
+   |
+LL |     let _ = |[x]: [u32; 1]| {
+   |               ^
+   |
+note: previous binding is here
+  --> tests/ui/shadow.rs:76:9
+   |
+LL |     let x = 1;
+   |         ^
+
+error: `x` shadows a previous, unrelated binding
+  --> tests/ui/shadow.rs:92:13
+   |
+LL |         let x = 1;
+   |             ^
+   |
+note: previous binding is here
+  --> tests/ui/shadow.rs:90:15
    |
 LL |     let _ = |[x]: [u32; 1]| {
    |               ^
 
 error: `y` is shadowed
-  --> tests/ui/shadow.rs:76:17
+  --> tests/ui/shadow.rs:96:17
    |
 LL |     if let Some(y) = y {}
    |                 ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:75:9
+  --> tests/ui/shadow.rs:95:9
    |
 LL |     let y = Some(1);
    |         ^
 
 error: `_b` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:112:9
+  --> tests/ui/shadow.rs:133:9
    |
 LL |     let _b = _a;
    |         ^^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:111:28
+  --> tests/ui/shadow.rs:132:28
    |
 LL | pub async fn foo2(_a: i32, _b: i64) {
    |                            ^^
 
 error: `x` shadows a previous, unrelated binding
-  --> tests/ui/shadow.rs:118:21
+  --> tests/ui/shadow.rs:140:21
    |
 LL |         if let Some(x) = Some(1) { x } else { 1 }
    |                     ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:117:13
+  --> tests/ui/shadow.rs:139:13
    |
 LL |         let x = 1;
    |             ^
 
 error: `x` is shadowed
-  --> tests/ui/shadow.rs:128:20
+  --> tests/ui/shadow.rs:151:20
    |
 LL |     let z = x.map(|x| x + 1);
    |                    ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:125:9
+  --> tests/ui/shadow.rs:148:9
    |
 LL |     let x = Some(1);
    |         ^
 
 error: `i` is shadowed
-  --> tests/ui/shadow.rs:132:25
+  --> tests/ui/shadow.rs:156:25
    |
 LL |         .map(|i| i.map(|i| i - 10))
    |                         ^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:132:15
+  --> tests/ui/shadow.rs:156:15
    |
 LL |         .map(|i| i.map(|i| i - 10))
    |               ^
 
 error: `value` is shadowed by itself in `value`
-  --> tests/ui/shadow.rs:141:22
+  --> tests/ui/shadow.rs:166:22
    |
 LL |     let Issue13795 { value, .. } = value;
    |                      ^^^^^
    |
 note: previous binding is here
-  --> tests/ui/shadow.rs:140:15
+  --> tests/ui/shadow.rs:165:15
    |
 LL | fn issue13795(value: Issue13795) {
    |               ^^^^^
diff --git a/src/tools/clippy/tests/ui/short_circuit_statement.fixed b/src/tools/clippy/tests/ui/short_circuit_statement.fixed
index a2bf07ac6052..133d296e259c 100644
--- a/src/tools/clippy/tests/ui/short_circuit_statement.fixed
+++ b/src/tools/clippy/tests/ui/short_circuit_statement.fixed
@@ -3,15 +3,19 @@
 
 fn main() {
     if f() { g(); }
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     if !f() { g(); }
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     if 1 != 2 { g(); }
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     if f() || g() { H * 2; }
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     if !(f() || g()) { H * 2; }
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
 
     macro_rules! mac {
         ($f:ident or $g:ident) => {
@@ -26,9 +30,10 @@ fn main() {
     }
 
     if mac!() { mac!(); }
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     if !mac!() { mac!(); }
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
 
     // Do not lint if the expression comes from a macro
     mac!();
diff --git a/src/tools/clippy/tests/ui/short_circuit_statement.rs b/src/tools/clippy/tests/ui/short_circuit_statement.rs
index bdba546ad8f6..4275ae64fdd6 100644
--- a/src/tools/clippy/tests/ui/short_circuit_statement.rs
+++ b/src/tools/clippy/tests/ui/short_circuit_statement.rs
@@ -3,15 +3,19 @@
 
 fn main() {
     f() && g();
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     f() || g();
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     1 == 2 || g();
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     (f() || g()) && (H * 2);
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     (f() || g()) || (H * 2);
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
 
     macro_rules! mac {
         ($f:ident or $g:ident) => {
@@ -26,9 +30,10 @@ fn main() {
     }
 
     mac!() && mac!();
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
+
     mac!() || mac!();
-    //~^ ERROR: boolean short circuit operator in statement
+    //~^ short_circuit_statement
 
     // Do not lint if the expression comes from a macro
     mac!();
diff --git a/src/tools/clippy/tests/ui/short_circuit_statement.stderr b/src/tools/clippy/tests/ui/short_circuit_statement.stderr
index ecf6676405b4..acd28d41a33a 100644
--- a/src/tools/clippy/tests/ui/short_circuit_statement.stderr
+++ b/src/tools/clippy/tests/ui/short_circuit_statement.stderr
@@ -8,37 +8,37 @@ LL |     f() && g();
    = help: to override `-D warnings` add `#[allow(clippy::short_circuit_statement)]`
 
 error: boolean short circuit operator in statement may be clearer using an explicit test
-  --> tests/ui/short_circuit_statement.rs:7:5
+  --> tests/ui/short_circuit_statement.rs:8:5
    |
 LL |     f() || g();
    |     ^^^^^^^^^^^ help: replace it with: `if !f() { g(); }`
 
 error: boolean short circuit operator in statement may be clearer using an explicit test
-  --> tests/ui/short_circuit_statement.rs:9:5
+  --> tests/ui/short_circuit_statement.rs:11:5
    |
 LL |     1 == 2 || g();
    |     ^^^^^^^^^^^^^^ help: replace it with: `if 1 != 2 { g(); }`
 
 error: boolean short circuit operator in statement may be clearer using an explicit test
-  --> tests/ui/short_circuit_statement.rs:11:5
+  --> tests/ui/short_circuit_statement.rs:14:5
    |
 LL |     (f() || g()) && (H * 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `if f() || g() { H * 2; }`
 
 error: boolean short circuit operator in statement may be clearer using an explicit test
-  --> tests/ui/short_circuit_statement.rs:13:5
+  --> tests/ui/short_circuit_statement.rs:17:5
    |
 LL |     (f() || g()) || (H * 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `if !(f() || g()) { H * 2; }`
 
 error: boolean short circuit operator in statement may be clearer using an explicit test
-  --> tests/ui/short_circuit_statement.rs:28:5
+  --> tests/ui/short_circuit_statement.rs:32:5
    |
 LL |     mac!() && mac!();
    |     ^^^^^^^^^^^^^^^^^ help: replace it with: `if mac!() { mac!(); }`
 
 error: boolean short circuit operator in statement may be clearer using an explicit test
-  --> tests/ui/short_circuit_statement.rs:30:5
+  --> tests/ui/short_circuit_statement.rs:35:5
    |
 LL |     mac!() || mac!();
    |     ^^^^^^^^^^^^^^^^^ help: replace it with: `if !mac!() { mac!(); }`
diff --git a/src/tools/clippy/tests/ui/should_impl_trait/corner_cases.rs b/src/tools/clippy/tests/ui/should_impl_trait/corner_cases.rs
index 50999c6f2198..4ec0f02d6645 100644
--- a/src/tools/clippy/tests/ui/should_impl_trait/corner_cases.rs
+++ b/src/tools/clippy/tests/ui/should_impl_trait/corner_cases.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::all, clippy::pedantic)]
 #![allow(
     clippy::missing_errors_doc,
diff --git a/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.rs b/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.rs
index 85eed3f06f64..87b3a7d2fa0c 100644
--- a/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.rs
+++ b/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.rs
@@ -23,77 +23,92 @@ impl T {
     // trait method list part 1, should lint all
     // *****************************************
     pub fn add(self, other: T) -> T {
-        //~^ ERROR: method `add` can be confused for the standard trait method `std::ops::Add:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn as_mut(&mut self) -> &mut T {
-        //~^ ERROR: method `as_mut` can be confused for the standard trait method `std::conver
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn as_ref(&self) -> &T {
-        //~^ ERROR: method `as_ref` can be confused for the standard trait method `std::conver
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn bitand(self, rhs: T) -> T {
-        //~^ ERROR: method `bitand` can be confused for the standard trait method `std::ops::B
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn bitor(self, rhs: Self) -> Self {
-        //~^ ERROR: method `bitor` can be confused for the standard trait method `std::ops::Bi
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn bitxor(self, rhs: Self) -> Self {
-        //~^ ERROR: method `bitxor` can be confused for the standard trait method `std::ops::B
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn borrow(&self) -> &str {
-        //~^ ERROR: method `borrow` can be confused for the standard trait method `std::borrow
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn borrow_mut(&mut self) -> &mut str {
-        //~^ ERROR: method `borrow_mut` can be confused for the standard trait method `std::bo
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn clone(&self) -> Self {
-        //~^ ERROR: method `clone` can be confused for the standard trait method `std::clone::
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn cmp(&self, other: &Self) -> Self {
-        //~^ ERROR: method `cmp` can be confused for the standard trait method `std::cmp::Ord:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn default() -> Self {
-        //~^ ERROR: method `default` can be confused for the standard trait method `std::defau
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn deref(&self) -> &Self {
-        //~^ ERROR: method `deref` can be confused for the standard trait method `std::ops::De
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn deref_mut(&mut self) -> &mut Self {
-        //~^ ERROR: method `deref_mut` can be confused for the standard trait method `std::ops
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn div(self, rhs: Self) -> Self {
-        //~^ ERROR: method `div` can be confused for the standard trait method `std::ops::Div:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn drop(&mut self) {
-        //~^ ERROR: method `drop` can be confused for the standard trait method `std::ops::Dro
+        //~^ should_implement_trait
+
         unimplemented!()
     }
     // **********
diff --git a/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.stderr b/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.stderr
index dfa55ace40f0..8738b61192a3 100644
--- a/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.stderr
+++ b/src/tools/clippy/tests/ui/should_impl_trait/method_list_1.stderr
@@ -3,6 +3,7 @@ error: method `add` can be confused for the standard trait method `std::ops::Add
    |
 LL | /     pub fn add(self, other: T) -> T {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -12,10 +13,11 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::should_implement_trait)]`
 
 error: method `as_mut` can be confused for the standard trait method `std::convert::AsMut::as_mut`
-  --> tests/ui/should_impl_trait/method_list_1.rs:30:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:31:5
    |
 LL | /     pub fn as_mut(&mut self) -> &mut T {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -23,10 +25,11 @@ LL | |     }
    = help: consider implementing the trait `std::convert::AsMut` or choosing a less ambiguous method name
 
 error: method `as_ref` can be confused for the standard trait method `std::convert::AsRef::as_ref`
-  --> tests/ui/should_impl_trait/method_list_1.rs:35:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:37:5
    |
 LL | /     pub fn as_ref(&self) -> &T {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -34,10 +37,11 @@ LL | |     }
    = help: consider implementing the trait `std::convert::AsRef` or choosing a less ambiguous method name
 
 error: method `bitand` can be confused for the standard trait method `std::ops::BitAnd::bitand`
-  --> tests/ui/should_impl_trait/method_list_1.rs:40:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:43:5
    |
 LL | /     pub fn bitand(self, rhs: T) -> T {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -45,10 +49,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitAnd` or choosing a less ambiguous method name
 
 error: method `bitor` can be confused for the standard trait method `std::ops::BitOr::bitor`
-  --> tests/ui/should_impl_trait/method_list_1.rs:45:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:49:5
    |
 LL | /     pub fn bitor(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -56,10 +61,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitOr` or choosing a less ambiguous method name
 
 error: method `bitxor` can be confused for the standard trait method `std::ops::BitXor::bitxor`
-  --> tests/ui/should_impl_trait/method_list_1.rs:50:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:55:5
    |
 LL | /     pub fn bitxor(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -67,10 +73,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::BitXor` or choosing a less ambiguous method name
 
 error: method `borrow` can be confused for the standard trait method `std::borrow::Borrow::borrow`
-  --> tests/ui/should_impl_trait/method_list_1.rs:55:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:61:5
    |
 LL | /     pub fn borrow(&self) -> &str {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -78,10 +85,11 @@ LL | |     }
    = help: consider implementing the trait `std::borrow::Borrow` or choosing a less ambiguous method name
 
 error: method `borrow_mut` can be confused for the standard trait method `std::borrow::BorrowMut::borrow_mut`
-  --> tests/ui/should_impl_trait/method_list_1.rs:60:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:67:5
    |
 LL | /     pub fn borrow_mut(&mut self) -> &mut str {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -89,10 +97,11 @@ LL | |     }
    = help: consider implementing the trait `std::borrow::BorrowMut` or choosing a less ambiguous method name
 
 error: method `clone` can be confused for the standard trait method `std::clone::Clone::clone`
-  --> tests/ui/should_impl_trait/method_list_1.rs:65:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:73:5
    |
 LL | /     pub fn clone(&self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -100,10 +109,11 @@ LL | |     }
    = help: consider implementing the trait `std::clone::Clone` or choosing a less ambiguous method name
 
 error: method `cmp` can be confused for the standard trait method `std::cmp::Ord::cmp`
-  --> tests/ui/should_impl_trait/method_list_1.rs:70:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:79:5
    |
 LL | /     pub fn cmp(&self, other: &Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -111,10 +121,11 @@ LL | |     }
    = help: consider implementing the trait `std::cmp::Ord` or choosing a less ambiguous method name
 
 error: method `default` can be confused for the standard trait method `std::default::Default::default`
-  --> tests/ui/should_impl_trait/method_list_1.rs:75:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:85:5
    |
 LL | /     pub fn default() -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -122,10 +133,11 @@ LL | |     }
    = help: consider implementing the trait `std::default::Default` or choosing a less ambiguous method name
 
 error: method `deref` can be confused for the standard trait method `std::ops::Deref::deref`
-  --> tests/ui/should_impl_trait/method_list_1.rs:80:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:91:5
    |
 LL | /     pub fn deref(&self) -> &Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -133,10 +145,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Deref` or choosing a less ambiguous method name
 
 error: method `deref_mut` can be confused for the standard trait method `std::ops::DerefMut::deref_mut`
-  --> tests/ui/should_impl_trait/method_list_1.rs:85:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:97:5
    |
 LL | /     pub fn deref_mut(&mut self) -> &mut Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -144,10 +157,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::DerefMut` or choosing a less ambiguous method name
 
 error: method `div` can be confused for the standard trait method `std::ops::Div::div`
-  --> tests/ui/should_impl_trait/method_list_1.rs:90:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:103:5
    |
 LL | /     pub fn div(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -155,10 +169,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Div` or choosing a less ambiguous method name
 
 error: method `drop` can be confused for the standard trait method `std::ops::Drop::drop`
-  --> tests/ui/should_impl_trait/method_list_1.rs:95:5
+  --> tests/ui/should_impl_trait/method_list_1.rs:109:5
    |
 LL | /     pub fn drop(&mut self) {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.rs b/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.rs
index 33211b32d74b..f0c4d4f15cb6 100644
--- a/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.rs
+++ b/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.rs
@@ -24,77 +24,92 @@ impl T {
     // *****************************************
 
     pub fn eq(&self, other: &Self) -> bool {
-        //~^ ERROR: method `eq` can be confused for the standard trait method `std::cmp::Parti
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn from_iter<T>(iter: T) -> Self {
-        //~^ ERROR: method `from_iter` can be confused for the standard trait method `std::ite
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn from_str(s: &str) -> Result<Self, Self> {
-        //~^ ERROR: method `from_str` can be confused for the standard trait method `std::str:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn hash(&self, state: &mut T) {
-        //~^ ERROR: method `hash` can be confused for the standard trait method `std::hash::Ha
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn index(&self, index: usize) -> &Self {
-        //~^ ERROR: method `index` can be confused for the standard trait method `std::ops::In
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn index_mut(&mut self, index: usize) -> &mut Self {
-        //~^ ERROR: method `index_mut` can be confused for the standard trait method `std::ops
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn into_iter(self) -> Self {
-        //~^ ERROR: method `into_iter` can be confused for the standard trait method `std::ite
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn mul(self, rhs: Self) -> Self {
-        //~^ ERROR: method `mul` can be confused for the standard trait method `std::ops::Mul:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn neg(self) -> Self {
-        //~^ ERROR: method `neg` can be confused for the standard trait method `std::ops::Neg:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn next(&mut self) -> Option<Self> {
-        //~^ ERROR: method `next` can be confused for the standard trait method `std::iter::It
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn not(self) -> Self {
-        //~^ ERROR: method `not` can be confused for the standard trait method `std::ops::Not:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn rem(self, rhs: Self) -> Self {
-        //~^ ERROR: method `rem` can be confused for the standard trait method `std::ops::Rem:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn shl(self, rhs: Self) -> Self {
-        //~^ ERROR: method `shl` can be confused for the standard trait method `std::ops::Shl:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn shr(self, rhs: Self) -> Self {
-        //~^ ERROR: method `shr` can be confused for the standard trait method `std::ops::Shr:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
 
     pub fn sub(self, rhs: Self) -> Self {
-        //~^ ERROR: method `sub` can be confused for the standard trait method `std::ops::Sub:
+        //~^ should_implement_trait
+
         unimplemented!()
     }
     // **********
diff --git a/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.stderr b/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.stderr
index b1e5bbbfa4c5..85de74337020 100644
--- a/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.stderr
+++ b/src/tools/clippy/tests/ui/should_impl_trait/method_list_2.stderr
@@ -3,6 +3,7 @@ error: method `eq` can be confused for the standard trait method `std::cmp::Part
    |
 LL | /     pub fn eq(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -12,10 +13,11 @@ LL | |     }
    = help: to override `-D warnings` add `#[allow(clippy::should_implement_trait)]`
 
 error: method `from_iter` can be confused for the standard trait method `std::iter::FromIterator::from_iter`
-  --> tests/ui/should_impl_trait/method_list_2.rs:31:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:32:5
    |
 LL | /     pub fn from_iter<T>(iter: T) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -23,10 +25,11 @@ LL | |     }
    = help: consider implementing the trait `std::iter::FromIterator` or choosing a less ambiguous method name
 
 error: method `from_str` can be confused for the standard trait method `std::str::FromStr::from_str`
-  --> tests/ui/should_impl_trait/method_list_2.rs:36:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:38:5
    |
 LL | /     pub fn from_str(s: &str) -> Result<Self, Self> {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -34,10 +37,11 @@ LL | |     }
    = help: consider implementing the trait `std::str::FromStr` or choosing a less ambiguous method name
 
 error: method `hash` can be confused for the standard trait method `std::hash::Hash::hash`
-  --> tests/ui/should_impl_trait/method_list_2.rs:41:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:44:5
    |
 LL | /     pub fn hash(&self, state: &mut T) {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -45,10 +49,11 @@ LL | |     }
    = help: consider implementing the trait `std::hash::Hash` or choosing a less ambiguous method name
 
 error: method `index` can be confused for the standard trait method `std::ops::Index::index`
-  --> tests/ui/should_impl_trait/method_list_2.rs:46:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:50:5
    |
 LL | /     pub fn index(&self, index: usize) -> &Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -56,10 +61,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Index` or choosing a less ambiguous method name
 
 error: method `index_mut` can be confused for the standard trait method `std::ops::IndexMut::index_mut`
-  --> tests/ui/should_impl_trait/method_list_2.rs:51:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:56:5
    |
 LL | /     pub fn index_mut(&mut self, index: usize) -> &mut Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -67,10 +73,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::IndexMut` or choosing a less ambiguous method name
 
 error: method `into_iter` can be confused for the standard trait method `std::iter::IntoIterator::into_iter`
-  --> tests/ui/should_impl_trait/method_list_2.rs:56:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:62:5
    |
 LL | /     pub fn into_iter(self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -78,10 +85,11 @@ LL | |     }
    = help: consider implementing the trait `std::iter::IntoIterator` or choosing a less ambiguous method name
 
 error: method `mul` can be confused for the standard trait method `std::ops::Mul::mul`
-  --> tests/ui/should_impl_trait/method_list_2.rs:61:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:68:5
    |
 LL | /     pub fn mul(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -89,10 +97,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Mul` or choosing a less ambiguous method name
 
 error: method `neg` can be confused for the standard trait method `std::ops::Neg::neg`
-  --> tests/ui/should_impl_trait/method_list_2.rs:66:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:74:5
    |
 LL | /     pub fn neg(self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -100,10 +109,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Neg` or choosing a less ambiguous method name
 
 error: method `next` can be confused for the standard trait method `std::iter::Iterator::next`
-  --> tests/ui/should_impl_trait/method_list_2.rs:71:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:80:5
    |
 LL | /     pub fn next(&mut self) -> Option<Self> {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -111,10 +121,11 @@ LL | |     }
    = help: consider implementing the trait `std::iter::Iterator` or choosing a less ambiguous method name
 
 error: method `not` can be confused for the standard trait method `std::ops::Not::not`
-  --> tests/ui/should_impl_trait/method_list_2.rs:76:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:86:5
    |
 LL | /     pub fn not(self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -122,10 +133,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Not` or choosing a less ambiguous method name
 
 error: method `rem` can be confused for the standard trait method `std::ops::Rem::rem`
-  --> tests/ui/should_impl_trait/method_list_2.rs:81:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:92:5
    |
 LL | /     pub fn rem(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -133,10 +145,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Rem` or choosing a less ambiguous method name
 
 error: method `shl` can be confused for the standard trait method `std::ops::Shl::shl`
-  --> tests/ui/should_impl_trait/method_list_2.rs:86:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:98:5
    |
 LL | /     pub fn shl(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -144,10 +157,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Shl` or choosing a less ambiguous method name
 
 error: method `shr` can be confused for the standard trait method `std::ops::Shr::shr`
-  --> tests/ui/should_impl_trait/method_list_2.rs:91:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:104:5
    |
 LL | /     pub fn shr(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
@@ -155,10 +169,11 @@ LL | |     }
    = help: consider implementing the trait `std::ops::Shr` or choosing a less ambiguous method name
 
 error: method `sub` can be confused for the standard trait method `std::ops::Sub::sub`
-  --> tests/ui/should_impl_trait/method_list_2.rs:96:5
+  --> tests/ui/should_impl_trait/method_list_2.rs:110:5
    |
 LL | /     pub fn sub(self, rhs: Self) -> Self {
 LL | |
+LL | |
 LL | |         unimplemented!()
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/should_panic_without_expect.rs b/src/tools/clippy/tests/ui/should_panic_without_expect.rs
index b554fdaf2249..a209f794b105 100644
--- a/src/tools/clippy/tests/ui/should_panic_without_expect.rs
+++ b/src/tools/clippy/tests/ui/should_panic_without_expect.rs
@@ -3,6 +3,7 @@
 
 #[test]
 #[should_panic]
+//~^ should_panic_without_expect
 fn no_message() {}
 
 #[test]
diff --git a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs
index 39d550398d70..4f65a06680d6 100644
--- a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs
+++ b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.rs
@@ -58,8 +58,7 @@ fn should_trigger_lint_with_mutex_guard_in_match_scrutinee() {
     // is preserved until the end of the match, but there is no clear indication that this is the
     // case.
     match mutex.lock().unwrap().foo() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         true => {
             mutex.lock().unwrap().bar();
         },
@@ -146,8 +145,7 @@ fn should_trigger_lint_with_wrapped_mutex() {
     // lifetime is not obvious. Additionally, it is not obvious from looking at the scrutinee that
     // the temporary contains such a type, making it potentially even more surprising.
     match s.lock_m().get_the_value() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         1 => {
             println!("Got 1. Is it still 1?");
             println!("{}", s.lock_m().get_the_value());
@@ -169,8 +167,7 @@ fn should_trigger_lint_with_double_wrapped_mutex() {
     // looking at the scrutinee that the temporary contains such a type, making it potentially even
     // more surprising.
     match s.lock_m_m().get_the_value() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         1 => {
             println!("Got 1. Is it still 1?");
             println!("{}", s.lock_m().get_the_value());
@@ -219,8 +216,7 @@ fn should_trigger_lint_for_vec() {
     // which have significant drops. The types with significant drops are also non-obvious when
     // reading the expression in the scrutinee.
     match counter.temp_increment().len() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         2 => {
             let current_count = counter.i.load(Ordering::Relaxed);
             println!("Current count {}", current_count);
@@ -244,8 +240,7 @@ fn should_trigger_lint_for_tuple_in_scrutinee() {
 
     {
         match (mutex1.lock().unwrap().s.len(), true) {
-            //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until
-            //~| NOTE: this might lead to deadlocks or other unexpected behavior
+            //~^ significant_drop_in_scrutinee
             (3, _) => {
                 println!("started");
                 mutex1.lock().unwrap().s.len();
@@ -255,8 +250,7 @@ fn should_trigger_lint_for_tuple_in_scrutinee() {
         };
 
         match (true, mutex1.lock().unwrap().s.len(), true) {
-            //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until
-            //~| NOTE: this might lead to deadlocks or other unexpected behavior
+            //~^ significant_drop_in_scrutinee
             (_, 3, _) => {
                 println!("started");
                 mutex1.lock().unwrap().s.len();
@@ -267,10 +261,8 @@ fn should_trigger_lint_for_tuple_in_scrutinee() {
 
         let mutex2 = Mutex::new(StateWithField { s: "two".to_owned() });
         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
-            //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until
-            //~| NOTE: this might lead to deadlocks or other unexpected behavior
-            //~| ERROR: temporary with significant `Drop` in `match` scrutinee will live until
-            //~| NOTE: this might lead to deadlocks or other unexpected behavior
+            //~^ significant_drop_in_scrutinee
+            //~| significant_drop_in_scrutinee
             (3, _, 3) => {
                 println!("started");
                 mutex1.lock().unwrap().s.len();
@@ -322,8 +314,7 @@ fn should_trigger_lint_for_accessing_field_in_mutex_in_one_side_of_binary_op() {
     let mutex = Mutex::new(StateWithField { s: "state".to_owned() });
 
     match mutex.lock().unwrap().s.len() > 1 {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         true => {
             mutex.lock().unwrap().s.len();
         },
@@ -331,8 +322,7 @@ fn should_trigger_lint_for_accessing_field_in_mutex_in_one_side_of_binary_op() {
     };
 
     match 1 < mutex.lock().unwrap().s.len() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         true => {
             mutex.lock().unwrap().s.len();
         },
@@ -351,8 +341,8 @@ fn should_trigger_lint_for_accessing_fields_in_mutex_in_both_sides_of_binary_op(
     });
 
     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
+        //~| significant_drop_in_scrutinee
         true => {
             println!(
                 "{} < {}",
@@ -364,8 +354,8 @@ fn should_trigger_lint_for_accessing_fields_in_mutex_in_both_sides_of_binary_op(
     };
 
     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
+        //~| significant_drop_in_scrutinee
         true => {
             println!(
                 "{} >= {}",
@@ -401,8 +391,7 @@ fn should_trigger_lint_for_return_from_closure_in_scrutinee() {
     // Should trigger lint because the temporary with a significant drop is returned from the
     // closure but not used directly in any match arms, so it has a potentially surprising lifetime.
     match get_mutex_guard().s.len() > 1 {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         true => {
             mutex1.lock().unwrap().s.len();
         },
@@ -420,8 +409,7 @@ fn should_trigger_lint_for_return_from_match_in_scrutinee() {
     // significant drop is but not used directly in any match arms, so it has a potentially
     // surprising lifetime.
     match match i {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         100 => mutex1.lock().unwrap(),
         _ => mutex2.lock().unwrap(),
     }
@@ -448,8 +436,7 @@ fn should_trigger_lint_for_return_from_if_in_scrutinee() {
     // with a significant drop is but not used directly in any match arms, so it has a potentially
     // surprising lifetime.
     match if i > 1 {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         mutex1.lock().unwrap()
     } else {
         mutex2.lock().unwrap()
@@ -504,8 +491,7 @@ fn should_trigger_lint_for_boxed_mutex_guard() {
     // Should trigger lint because a temporary Box holding a type with a significant drop in a match
     // scrutinee may have a potentially surprising lifetime.
     match s.lock().deref().deref() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         0 | 1 => println!("Value was less than 2"),
         _ => println!("Value is {}", s.lock().deref()),
     };
@@ -554,32 +540,28 @@ fn should_trigger_lint_in_assign_expr() {
     let mut i = 100;
 
     match mutex.lock().unwrap().i = i {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         _ => {
             println!("{}", mutex.lock().unwrap().i);
         },
     };
 
     match i = mutex.lock().unwrap().i {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         _ => {
             println!("{}", mutex.lock().unwrap().i);
         },
     };
 
     match mutex.lock().unwrap().i += 1 {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         _ => {
             println!("{}", mutex.lock().unwrap().i);
         },
     };
 
     match i += mutex.lock().unwrap().i {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         _ => {
             println!("{}", mutex.lock().unwrap().i);
         },
@@ -643,8 +625,7 @@ impl ResultReturner {
 fn should_trigger_lint_for_non_ref_move_and_clone_suggestion() {
     let rwlock = RwLock::<ResultReturner>::new(ResultReturner { s: "1".to_string() });
     match rwlock.read().unwrap().to_number() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         Ok(n) => println!("Converted to number: {}", n),
         Err(e) => println!("Could not convert {} to number", e),
     };
@@ -671,8 +652,7 @@ fn should_trigger_lint_without_significant_drop_in_arm() {
     // is preserved until the end of the match, but there is no clear indication that this is the
     // case.
     match mutex.lock().unwrap().foo() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         true => do_bar(&mutex),
         false => {},
     };
@@ -734,8 +714,7 @@ fn should_not_trigger_for_significant_drop_ref() {
     }
 
     match guard.take().len() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         0 => println!("empty"),
         _ => println!("not empty"),
     };
@@ -760,8 +739,7 @@ fn should_trigger_lint_if_and_only_if_lifetime_is_irrelevant() {
     // Should trigger lint even if `copy_old_lifetime()` has a lifetime, as the lifetime of
     // `&vec` is unrelated to the temporary with significant drop (i.e., the `MutexGuard`).
     for val in mutex.lock().unwrap().copy_old_lifetime() {
-        //~^ ERROR: temporary with significant `Drop` in `for` loop condition will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         println!("{}", val);
     }
 
@@ -800,8 +778,7 @@ fn should_not_trigger_lint_with_explicit_drop() {
 
     // Should trigger lint if there is no explicit drop.
     for val in [mutex.lock().unwrap()[0], 2] {
-        //~^ ERROR: temporary with significant `Drop` in `for` loop condition will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         println!("{:?}", val);
     }
 }
@@ -810,8 +787,7 @@ fn should_trigger_lint_in_if_let() {
     let mutex = Mutex::new(vec![1]);
 
     if let Some(val) = mutex.lock().unwrap().first().copied() {
-        //~^ ERROR: temporary with significant `Drop` in `if let` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         println!("{}", val);
     }
 
@@ -826,8 +802,7 @@ fn should_trigger_lint_in_while_let() {
     let mutex = Mutex::new(vec![1]);
 
     while let Some(val) = mutex.lock().unwrap().pop() {
-        //~^ ERROR: temporary with significant `Drop` in `while let` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         println!("{}", val);
     }
 }
@@ -838,6 +813,7 @@ async fn foo_async(mutex: &Mutex<i32>) -> Option<MutexGuard<'_, i32>> {
 
 async fn should_trigger_lint_for_async(mutex: Mutex<i32>) -> i32 {
     match *foo_async(&mutex).await.unwrap() {
+        //~^ significant_drop_in_scrutinee
         n if n < 10 => n,
         _ => 10,
     }
@@ -857,8 +833,7 @@ fn should_trigger_lint_in_match_expr() {
     // is preserved until the end of the match, but there is no clear indication that this is the
     // case.
     let _ = match mutex.lock().unwrap().foo() {
-        //~^ ERROR: temporary with significant `Drop` in `match` scrutinee will live until the
-        //~| NOTE: this might lead to deadlocks or other unexpected behavior
+        //~^ significant_drop_in_scrutinee
         true => 0,
         false => 1,
     };
diff --git a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr
index f99d862aa6b2..b32b249fd429 100644
--- a/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr
+++ b/src/tools/clippy/tests/ui/significant_drop_in_scrutinee.stderr
@@ -20,7 +20,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:148:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:147:11
    |
 LL |     match s.lock_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -42,7 +42,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:171:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:169:11
    |
 LL |     match s.lock_m_m().get_the_value() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -64,7 +64,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:221:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:218:11
    |
 LL |     match counter.temp_increment().len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -80,7 +80,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:246:16
+  --> tests/ui/significant_drop_in_scrutinee.rs:242:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -99,7 +99,7 @@ LL ~         match (value, true) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:257:22
+  --> tests/ui/significant_drop_in_scrutinee.rs:252:22
    |
 LL |         match (true, mutex1.lock().unwrap().s.len(), true) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -118,7 +118,7 @@ LL ~         match (true, value, true) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:269:16
+  --> tests/ui/significant_drop_in_scrutinee.rs:263:16
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -139,7 +139,7 @@ LL ~         match (value, true, mutex2.lock().unwrap().s.len()) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:269:54
+  --> tests/ui/significant_drop_in_scrutinee.rs:263:54
    |
 LL |         match (mutex1.lock().unwrap().s.len(), true, mutex2.lock().unwrap().s.len()) {
    |                                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -160,7 +160,7 @@ LL ~         match (mutex1.lock().unwrap().s.len(), true, value) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:324:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:316:11
    |
 LL |     match mutex.lock().unwrap().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -179,7 +179,7 @@ LL ~     match value > 1 {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:333:15
+  --> tests/ui/significant_drop_in_scrutinee.rs:324:15
    |
 LL |     match 1 < mutex.lock().unwrap().s.len() {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -198,7 +198,7 @@ LL ~     match 1 < value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:353:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:343:11
    |
 LL |     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ LL ~     match value < mutex2.lock().unwrap().s.len() {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:353:44
+  --> tests/ui/significant_drop_in_scrutinee.rs:343:44
    |
 LL |     match mutex1.lock().unwrap().s.len() < mutex2.lock().unwrap().s.len() {
    |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -240,7 +240,7 @@ LL ~     match mutex1.lock().unwrap().s.len() < value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:366:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:356:11
    |
 LL |     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -261,7 +261,7 @@ LL ~     match value >= mutex2.lock().unwrap().s.len() {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:366:45
+  --> tests/ui/significant_drop_in_scrutinee.rs:356:45
    |
 LL |     match mutex1.lock().unwrap().s.len() >= mutex2.lock().unwrap().s.len() {
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -282,7 +282,7 @@ LL ~     match mutex1.lock().unwrap().s.len() >= value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:403:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:393:11
    |
 LL |     match get_mutex_guard().s.len() > 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -301,14 +301,14 @@ LL ~     match value > 1 {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:422:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:411:11
    |
 LL |       match match i {
    |  ___________^
 LL | |
-LL | |
 LL | |         100 => mutex1.lock().unwrap(),
-...  |
+LL | |         _ => mutex2.lock().unwrap(),
+LL | |     }
 LL | |     .s
 LL | |     .len()
    | |__________^
@@ -324,7 +324,6 @@ help: try moving the temporary above the match
    |
 LL ~     let value = match i {
 LL +
-LL +
 LL +         100 => mutex1.lock().unwrap(),
 LL +         _ => mutex2.lock().unwrap(),
 LL +     }
@@ -334,13 +333,13 @@ LL ~     match value
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:450:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:438:11
    |
 LL |       match if i > 1 {
    |  ___________^
 LL | |
-LL | |
 LL | |         mutex1.lock().unwrap()
+LL | |     } else {
 ...  |
 LL | |     .s
 LL | |     .len()
@@ -357,7 +356,6 @@ help: try moving the temporary above the match
    |
 LL ~     let value = if i > 1 {
 LL +
-LL +
 LL +         mutex1.lock().unwrap()
 LL +     } else {
 LL +         mutex2.lock().unwrap()
@@ -368,7 +366,7 @@ LL ~     match value
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:506:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:493:11
    |
 LL |     match s.lock().deref().deref() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -386,7 +384,7 @@ LL ~     match (&value) {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:556:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:542:11
    |
 LL |     match mutex.lock().unwrap().i = i {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -405,7 +403,7 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:564:15
+  --> tests/ui/significant_drop_in_scrutinee.rs:549:15
    |
 LL |     match i = mutex.lock().unwrap().i {
    |               ^^^^^^^^^^^^^^^^^^^^^^^
@@ -424,7 +422,7 @@ LL ~     match i = value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:572:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:556:11
    |
 LL |     match mutex.lock().unwrap().i += 1 {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -443,7 +441,7 @@ LL ~     match () {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:580:16
+  --> tests/ui/significant_drop_in_scrutinee.rs:563:16
    |
 LL |     match i += mutex.lock().unwrap().i {
    |                ^^^^^^^^^^^^^^^^^^^^^^^
@@ -462,7 +460,7 @@ LL ~     match i += value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:645:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:627:11
    |
 LL |     match rwlock.read().unwrap().to_number() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -478,7 +476,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:673:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:654:11
    |
 LL |     match mutex.lock().unwrap().foo() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -494,7 +492,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:736:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:716:11
    |
 LL |     match guard.take().len() {
    |           ^^^^^^^^^^^^^^^^^^
@@ -510,7 +508,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `for` loop condition will live until the end of the `for` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:762:16
+  --> tests/ui/significant_drop_in_scrutinee.rs:741:16
    |
 LL |     for val in mutex.lock().unwrap().copy_old_lifetime() {
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -526,7 +524,7 @@ LL ~     for val in value {
    |
 
 error: temporary with significant `Drop` in `for` loop condition will live until the end of the `for` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:802:17
+  --> tests/ui/significant_drop_in_scrutinee.rs:780:17
    |
 LL |     for val in [mutex.lock().unwrap()[0], 2] {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -542,7 +540,7 @@ LL ~     for val in [value, 2] {
    |
 
 error: temporary with significant `Drop` in `if let` scrutinee will live until the end of the `if let` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:812:24
+  --> tests/ui/significant_drop_in_scrutinee.rs:789:24
    |
 LL |     if let Some(val) = mutex.lock().unwrap().first().copied() {
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -558,7 +556,7 @@ LL ~     if let Some(val) = value {
    |
 
 error: temporary with significant `Drop` in `while let` scrutinee will live until the end of the `while let` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:828:27
+  --> tests/ui/significant_drop_in_scrutinee.rs:804:27
    |
 LL |     while let Some(val) = mutex.lock().unwrap().pop() {
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -569,7 +567,7 @@ LL |     }
    = note: this might lead to deadlocks or other unexpected behavior
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:840:11
+  --> tests/ui/significant_drop_in_scrutinee.rs:815:11
    |
 LL |     match *foo_async(&mutex).await.unwrap() {
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -585,7 +583,7 @@ LL ~     match value {
    |
 
 error: temporary with significant `Drop` in `match` scrutinee will live until the end of the `match` expression
-  --> tests/ui/significant_drop_in_scrutinee.rs:859:19
+  --> tests/ui/significant_drop_in_scrutinee.rs:835:19
    |
 LL |     let _ = match mutex.lock().unwrap().foo() {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/significant_drop_tightening.fixed b/src/tools/clippy/tests/ui/significant_drop_tightening.fixed
index ed05f6e0c8d3..3d416056226c 100644
--- a/src/tools/clippy/tests/ui/significant_drop_tightening.fixed
+++ b/src/tools/clippy/tests/ui/significant_drop_tightening.fixed
@@ -8,6 +8,7 @@ pub fn complex_return_triggers_the_lint() -> i32 {
     }
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
+    //~^ significant_drop_tightening
     let _ = *lock;
     let _ = *lock;
     drop(lock);
@@ -103,6 +104,7 @@ pub fn unnecessary_contention_with_multiple_owned_results() {
     {
         let mutex = Mutex::new(1i32);
         let lock = mutex.lock().unwrap();
+        //~^ significant_drop_tightening
         let rslt0 = lock.abs();
         let rslt1 = lock.is_positive();
         drop(lock);
@@ -126,6 +128,7 @@ pub fn unnecessary_contention_with_single_owned_results() {
         let mutex = Mutex::new(1i32);
         
         let rslt0 = mutex.lock().unwrap().abs();
+        //~^ significant_drop_tightening
         
         do_heavy_computation_that_takes_time(rslt0);
     }
@@ -133,6 +136,7 @@ pub fn unnecessary_contention_with_single_owned_results() {
         let mutex = Mutex::new(vec![1i32]);
         
         mutex.lock().unwrap().clear();
+        //~^ significant_drop_tightening
         
         do_heavy_computation_that_takes_time(());
     }
diff --git a/src/tools/clippy/tests/ui/significant_drop_tightening.rs b/src/tools/clippy/tests/ui/significant_drop_tightening.rs
index e5f17278f0f6..d9c4ad543593 100644
--- a/src/tools/clippy/tests/ui/significant_drop_tightening.rs
+++ b/src/tools/clippy/tests/ui/significant_drop_tightening.rs
@@ -8,6 +8,7 @@ pub fn complex_return_triggers_the_lint() -> i32 {
     }
     let mutex = Mutex::new(1);
     let lock = mutex.lock().unwrap();
+    //~^ significant_drop_tightening
     let _ = *lock;
     let _ = *lock;
     foo()
@@ -102,6 +103,7 @@ pub fn unnecessary_contention_with_multiple_owned_results() {
     {
         let mutex = Mutex::new(1i32);
         let lock = mutex.lock().unwrap();
+        //~^ significant_drop_tightening
         let rslt0 = lock.abs();
         let rslt1 = lock.is_positive();
         do_heavy_computation_that_takes_time((rslt0, rslt1));
@@ -123,12 +125,14 @@ pub fn unnecessary_contention_with_single_owned_results() {
     {
         let mutex = Mutex::new(1i32);
         let lock = mutex.lock().unwrap();
+        //~^ significant_drop_tightening
         let rslt0 = lock.abs();
         do_heavy_computation_that_takes_time(rslt0);
     }
     {
         let mutex = Mutex::new(vec![1i32]);
         let mut lock = mutex.lock().unwrap();
+        //~^ significant_drop_tightening
         lock.clear();
         do_heavy_computation_that_takes_time(());
     }
diff --git a/src/tools/clippy/tests/ui/significant_drop_tightening.stderr b/src/tools/clippy/tests/ui/significant_drop_tightening.stderr
index aef774a3d360..25cd9da73a10 100644
--- a/src/tools/clippy/tests/ui/significant_drop_tightening.stderr
+++ b/src/tools/clippy/tests/ui/significant_drop_tightening.stderr
@@ -23,14 +23,13 @@ LL +     drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> tests/ui/significant_drop_tightening.rs:104:13
+  --> tests/ui/significant_drop_tightening.rs:105:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
 LL | |         let lock = mutex.lock().unwrap();
    | |             ^^^^
-LL | |         let rslt0 = lock.abs();
-LL | |         let rslt1 = lock.is_positive();
+...  |
 LL | |         do_heavy_computation_that_takes_time((rslt0, rslt1));
 LL | |     }
    | |_____- temporary `lock` is currently being dropped at the end of its contained scope
@@ -43,13 +42,13 @@ LL +         drop(lock);
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> tests/ui/significant_drop_tightening.rs:125:13
+  --> tests/ui/significant_drop_tightening.rs:127:13
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(1i32);
 LL | |         let lock = mutex.lock().unwrap();
    | |             ^^^^
-LL | |         let rslt0 = lock.abs();
+...  |
 LL | |         do_heavy_computation_that_takes_time(rslt0);
 LL | |     }
    | |_____- temporary `lock` is currently being dropped at the end of its contained scope
@@ -59,17 +58,18 @@ help: merge the temporary construction with its single usage
    |
 LL ~         
 LL +         let rslt0 = mutex.lock().unwrap().abs();
+LL |
 LL ~         
    |
 
 error: temporary with significant `Drop` can be early dropped
-  --> tests/ui/significant_drop_tightening.rs:131:17
+  --> tests/ui/significant_drop_tightening.rs:134:17
    |
 LL | /     {
 LL | |         let mutex = Mutex::new(vec![1i32]);
 LL | |         let mut lock = mutex.lock().unwrap();
    | |                 ^^^^
-LL | |         lock.clear();
+...  |
 LL | |         do_heavy_computation_that_takes_time(());
 LL | |     }
    | |_____- temporary `lock` is currently being dropped at the end of its contained scope
@@ -79,6 +79,7 @@ help: merge the temporary construction with its single usage
    |
 LL ~         
 LL +         mutex.lock().unwrap().clear();
+LL |
 LL ~         
    |
 
diff --git a/src/tools/clippy/tests/ui/similar_names.rs b/src/tools/clippy/tests/ui/similar_names.rs
index f09693344915..69b6ab6220bf 100644
--- a/src/tools/clippy/tests/ui/similar_names.rs
+++ b/src/tools/clippy/tests/ui/similar_names.rs
@@ -45,12 +45,12 @@ fn main() {
 
     let blubx: i32;
     let bluby: i32;
-    //~^ ERROR: binding's name is too similar to existing binding
+    //~^ similar_names
 
     let cake: i32;
     let cakes: i32;
     let coke: i32;
-    //~^ ERROR: binding's name is too similar to existing binding
+    //~^ similar_names
 
     match 5 {
         cheese @ 1 => {},
@@ -69,12 +69,12 @@ fn main() {
     let xyz1abc: i32;
     let xyz2abc: i32;
     let xyzeabc: i32;
-    //~^ ERROR: binding's name is too similar to existing binding
+    //~^ similar_names
 
     let parser: i32;
     let parsed: i32;
     let parsee: i32;
-    //~^ ERROR: binding's name is too similar to existing binding
+    //~^ similar_names
 
     let setter: i32;
     let getter: i32;
@@ -96,7 +96,7 @@ fn foo() {
     let Foo {
         apple: spring,
         bpple: sprang,
-        //~^ ERROR: binding's name is too similar to existing binding
+        //~^ similar_names
     } = unimplemented!();
 }
 
diff --git a/src/tools/clippy/tests/ui/single_call_fn.rs b/src/tools/clippy/tests/ui/single_call_fn.rs
index a0597664da55..c1cc4032bec9 100644
--- a/src/tools/clippy/tests/ui/single_call_fn.rs
+++ b/src/tools/clippy/tests/ui/single_call_fn.rs
@@ -11,7 +11,9 @@ extern crate proc_macros;
 pub fn f() {}
 
 fn i() {}
+//~^ single_call_fn
 fn j() {}
+//~^ single_call_fn
 
 fn h() {
     // Linted
@@ -32,6 +34,7 @@ fn g() {
 }
 
 fn c() {
+    //~^ single_call_fn
     println!("really");
     println!("long");
     println!("function...");
@@ -42,6 +45,7 @@ fn d() {
 }
 
 fn a() {}
+//~^ single_call_fn
 
 fn b() {
     a();
@@ -87,6 +91,7 @@ fn l() {
 
 trait Trait {
     fn default() {}
+    //~^ single_call_fn
     fn foo(&self);
 }
 extern "C" {
@@ -100,6 +105,7 @@ fn m<T: Trait>(v: T) {
     struct S;
     impl S {
         fn foo() {}
+        //~^ single_call_fn
     }
     T::default();
     S::foo();
diff --git a/src/tools/clippy/tests/ui/single_call_fn.stderr b/src/tools/clippy/tests/ui/single_call_fn.stderr
index 14529beac616..8dd90a123852 100644
--- a/src/tools/clippy/tests/ui/single_call_fn.stderr
+++ b/src/tools/clippy/tests/ui/single_call_fn.stderr
@@ -5,7 +5,7 @@ LL | fn i() {}
    | ^^^^^^^^^
    |
 note: used here
-  --> tests/ui/single_call_fn.rs:18:13
+  --> tests/ui/single_call_fn.rs:20:13
    |
 LL |     let a = i;
    |             ^
@@ -13,21 +13,22 @@ LL |     let a = i;
    = help: to override `-D warnings` add `#[allow(clippy::single_call_fn)]`
 
 error: this function is only used once
-  --> tests/ui/single_call_fn.rs:14:1
+  --> tests/ui/single_call_fn.rs:15:1
    |
 LL | fn j() {}
    | ^^^^^^^^^
    |
 note: used here
-  --> tests/ui/single_call_fn.rs:25:9
+  --> tests/ui/single_call_fn.rs:27:9
    |
 LL |         j();
    |         ^
 
 error: this function is only used once
-  --> tests/ui/single_call_fn.rs:34:1
+  --> tests/ui/single_call_fn.rs:36:1
    |
 LL | / fn c() {
+LL | |
 LL | |     println!("really");
 LL | |     println!("long");
 LL | |     println!("function...");
@@ -35,43 +36,43 @@ LL | | }
    | |_^
    |
 note: used here
-  --> tests/ui/single_call_fn.rs:41:5
+  --> tests/ui/single_call_fn.rs:44:5
    |
 LL |     c();
    |     ^
 
 error: this function is only used once
-  --> tests/ui/single_call_fn.rs:44:1
+  --> tests/ui/single_call_fn.rs:47:1
    |
 LL | fn a() {}
    | ^^^^^^^^^
    |
 note: used here
-  --> tests/ui/single_call_fn.rs:47:5
+  --> tests/ui/single_call_fn.rs:51:5
    |
 LL |     a();
    |     ^
 
 error: this function is only used once
-  --> tests/ui/single_call_fn.rs:89:5
+  --> tests/ui/single_call_fn.rs:93:5
    |
 LL |     fn default() {}
    |     ^^^^^^^^^^^^^^^
    |
 note: used here
-  --> tests/ui/single_call_fn.rs:104:5
+  --> tests/ui/single_call_fn.rs:110:5
    |
 LL |     T::default();
    |     ^^^^^^^^^^
 
 error: this function is only used once
-  --> tests/ui/single_call_fn.rs:102:9
+  --> tests/ui/single_call_fn.rs:107:9
    |
 LL |         fn foo() {}
    |         ^^^^^^^^^^^
    |
 note: used here
-  --> tests/ui/single_call_fn.rs:105:5
+  --> tests/ui/single_call_fn.rs:111:5
    |
 LL |     S::foo();
    |     ^^^^^^
diff --git a/src/tools/clippy/tests/ui/single_char_add_str.fixed b/src/tools/clippy/tests/ui/single_char_add_str.fixed
index aef15252b1bc..b729cf8b2ca1 100644
--- a/src/tools/clippy/tests/ui/single_char_add_str.fixed
+++ b/src/tools/clippy/tests/ui/single_char_add_str.fixed
@@ -12,44 +12,65 @@ fn main() {
 
     let mut string = String::new();
     string.push('R');
+    //~^ single_char_add_str
     string.push('\'');
+    //~^ single_char_add_str
 
     string.push('u');
     string.push_str("st");
     string.push_str("");
     string.push('\x52');
+    //~^ single_char_add_str
     string.push('\u{0052}');
+    //~^ single_char_add_str
     string.push('a');
+    //~^ single_char_add_str
 
     let c_ref = &'a';
     string.push(*c_ref);
+    //~^ single_char_add_str
     let c = 'a';
     string.push(c);
+    //~^ single_char_add_str
     string.push('a');
+    //~^ single_char_add_str
 
     get_string!().push('ö');
+    //~^ single_char_add_str
 
     // `insert_str` tests
 
     let mut string = String::new();
     string.insert(0, 'R');
+    //~^ single_char_add_str
     string.insert(1, '\'');
+    //~^ single_char_add_str
 
     string.insert(0, 'u');
     string.insert_str(2, "st");
     string.insert_str(0, "");
     string.insert(0, '\x52');
+    //~^ single_char_add_str
     string.insert(0, '\u{0052}');
+    //~^ single_char_add_str
     let x: usize = 2;
     string.insert(x, 'a');
+    //~^ single_char_add_str
     const Y: usize = 1;
     string.insert(Y, 'a');
+    //~^ single_char_add_str
     string.insert(Y, '"');
+    //~^ single_char_add_str
     string.insert(Y, '\'');
+    //~^ single_char_add_str
 
     string.insert(0, *c_ref);
+    //~^ single_char_add_str
     string.insert(0, c);
+    //~^ single_char_add_str
     string.insert(0, 'a');
+    //~^ single_char_add_str
 
     get_string!().insert(1, '?');
+    //~^ single_char_add_str
 }
diff --git a/src/tools/clippy/tests/ui/single_char_add_str.rs b/src/tools/clippy/tests/ui/single_char_add_str.rs
index 7f97250dacd4..a768c47db391 100644
--- a/src/tools/clippy/tests/ui/single_char_add_str.rs
+++ b/src/tools/clippy/tests/ui/single_char_add_str.rs
@@ -12,44 +12,65 @@ fn main() {
 
     let mut string = String::new();
     string.push_str("R");
+    //~^ single_char_add_str
     string.push_str("'");
+    //~^ single_char_add_str
 
     string.push('u');
     string.push_str("st");
     string.push_str("");
     string.push_str("\x52");
+    //~^ single_char_add_str
     string.push_str("\u{0052}");
+    //~^ single_char_add_str
     string.push_str(r##"a"##);
+    //~^ single_char_add_str
 
     let c_ref = &'a';
     string.push_str(&c_ref.to_string());
+    //~^ single_char_add_str
     let c = 'a';
     string.push_str(&c.to_string());
+    //~^ single_char_add_str
     string.push_str(&'a'.to_string());
+    //~^ single_char_add_str
 
     get_string!().push_str("ö");
+    //~^ single_char_add_str
 
     // `insert_str` tests
 
     let mut string = String::new();
     string.insert_str(0, "R");
+    //~^ single_char_add_str
     string.insert_str(1, "'");
+    //~^ single_char_add_str
 
     string.insert(0, 'u');
     string.insert_str(2, "st");
     string.insert_str(0, "");
     string.insert_str(0, "\x52");
+    //~^ single_char_add_str
     string.insert_str(0, "\u{0052}");
+    //~^ single_char_add_str
     let x: usize = 2;
     string.insert_str(x, r##"a"##);
+    //~^ single_char_add_str
     const Y: usize = 1;
     string.insert_str(Y, r##"a"##);
+    //~^ single_char_add_str
     string.insert_str(Y, r##"""##);
+    //~^ single_char_add_str
     string.insert_str(Y, r##"'"##);
+    //~^ single_char_add_str
 
     string.insert_str(0, &c_ref.to_string());
+    //~^ single_char_add_str
     string.insert_str(0, &c.to_string());
+    //~^ single_char_add_str
     string.insert_str(0, &'a'.to_string());
+    //~^ single_char_add_str
 
     get_string!().insert_str(1, "?");
+    //~^ single_char_add_str
 }
diff --git a/src/tools/clippy/tests/ui/single_char_add_str.stderr b/src/tools/clippy/tests/ui/single_char_add_str.stderr
index 7791c67578aa..a1fae93462c9 100644
--- a/src/tools/clippy/tests/ui/single_char_add_str.stderr
+++ b/src/tools/clippy/tests/ui/single_char_add_str.stderr
@@ -8,121 +8,121 @@ LL |     string.push_str("R");
    = help: to override `-D warnings` add `#[allow(clippy::single_char_add_str)]`
 
 error: calling `push_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:15:5
+  --> tests/ui/single_char_add_str.rs:16:5
    |
 LL |     string.push_str("'");
    |     ^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('\'')`
 
 error: calling `push_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:20:5
+  --> tests/ui/single_char_add_str.rs:22:5
    |
 LL |     string.push_str("\x52");
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('\x52')`
 
 error: calling `push_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:21:5
+  --> tests/ui/single_char_add_str.rs:24:5
    |
 LL |     string.push_str("\u{0052}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('\u{0052}')`
 
 error: calling `push_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:22:5
+  --> tests/ui/single_char_add_str.rs:26:5
    |
 LL |     string.push_str(r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `string.push('a')`
 
 error: calling `push_str()` using a single-character converted to string
-  --> tests/ui/single_char_add_str.rs:25:5
+  --> tests/ui/single_char_add_str.rs:30:5
    |
 LL |     string.push_str(&c_ref.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` without `to_string()`: `string.push(*c_ref)`
 
 error: calling `push_str()` using a single-character converted to string
-  --> tests/ui/single_char_add_str.rs:27:5
+  --> tests/ui/single_char_add_str.rs:33:5
    |
 LL |     string.push_str(&c.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` without `to_string()`: `string.push(c)`
 
 error: calling `push_str()` using a single-character converted to string
-  --> tests/ui/single_char_add_str.rs:28:5
+  --> tests/ui/single_char_add_str.rs:35:5
    |
 LL |     string.push_str(&'a'.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` without `to_string()`: `string.push('a')`
 
 error: calling `push_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:30:5
+  --> tests/ui/single_char_add_str.rs:38:5
    |
 LL |     get_string!().push_str("ö");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `push` with a character literal: `get_string!().push('ö')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:35:5
+  --> tests/ui/single_char_add_str.rs:44:5
    |
 LL |     string.insert_str(0, "R");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, 'R')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:36:5
+  --> tests/ui/single_char_add_str.rs:46:5
    |
 LL |     string.insert_str(1, "'");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(1, '\'')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:41:5
+  --> tests/ui/single_char_add_str.rs:52:5
    |
 LL |     string.insert_str(0, "\x52");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '\x52')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:42:5
+  --> tests/ui/single_char_add_str.rs:54:5
    |
 LL |     string.insert_str(0, "\u{0052}");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(0, '\u{0052}')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:44:5
+  --> tests/ui/single_char_add_str.rs:57:5
    |
 LL |     string.insert_str(x, r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(x, 'a')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:46:5
+  --> tests/ui/single_char_add_str.rs:60:5
    |
 LL |     string.insert_str(Y, r##"a"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, 'a')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:47:5
+  --> tests/ui/single_char_add_str.rs:62:5
    |
 LL |     string.insert_str(Y, r##"""##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, '"')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:48:5
+  --> tests/ui/single_char_add_str.rs:64:5
    |
 LL |     string.insert_str(Y, r##"'"##);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `string.insert(Y, '\'')`
 
 error: calling `insert_str()` using a single-character converted to string
-  --> tests/ui/single_char_add_str.rs:50:5
+  --> tests/ui/single_char_add_str.rs:67:5
    |
 LL |     string.insert_str(0, &c_ref.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` without `to_string()`: `string.insert(0, *c_ref)`
 
 error: calling `insert_str()` using a single-character converted to string
-  --> tests/ui/single_char_add_str.rs:51:5
+  --> tests/ui/single_char_add_str.rs:69:5
    |
 LL |     string.insert_str(0, &c.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` without `to_string()`: `string.insert(0, c)`
 
 error: calling `insert_str()` using a single-character converted to string
-  --> tests/ui/single_char_add_str.rs:52:5
+  --> tests/ui/single_char_add_str.rs:71:5
    |
 LL |     string.insert_str(0, &'a'.to_string());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` without `to_string()`: `string.insert(0, 'a')`
 
 error: calling `insert_str()` using a single-character string literal
-  --> tests/ui/single_char_add_str.rs:54:5
+  --> tests/ui/single_char_add_str.rs:74:5
    |
 LL |     get_string!().insert_str(1, "?");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `insert` with a character literal: `get_string!().insert(1, '?')`
diff --git a/src/tools/clippy/tests/ui/single_char_lifetime_names.rs b/src/tools/clippy/tests/ui/single_char_lifetime_names.rs
index 6731b5b13564..f4dcf46b0e2d 100644
--- a/src/tools/clippy/tests/ui/single_char_lifetime_names.rs
+++ b/src/tools/clippy/tests/ui/single_char_lifetime_names.rs
@@ -3,8 +3,8 @@
 
 // Lifetimes should only be linted when they're introduced
 struct DiagnosticCtx<'a, 'b>
-//~^ ERROR: single-character lifetime names are likely uninformative
-//~| ERROR: single-character lifetime names are likely uninformative
+//~^ single_char_lifetime_names
+//~| single_char_lifetime_names
 where
     'a: 'b,
 {
@@ -14,8 +14,9 @@ where
 
 // Only the lifetimes on the `impl`'s generics should be linted
 impl<'a, 'b> DiagnosticCtx<'a, 'b> {
-    //~^ ERROR: single-character lifetime names are likely uninformative
-    //~| ERROR: single-character lifetime names are likely uninformative
+    //~^ single_char_lifetime_names
+    //~| single_char_lifetime_names
+
     fn new(source: &'a str, unit: &'b ()) -> DiagnosticCtx<'a, 'b> {
         Self {
             _source: source,
@@ -36,7 +37,8 @@ impl<'src, 'unit> DiagnosticCtx<'src, 'unit> {
 
 // Only 'a should be linted here
 fn split_once<'a>(base: &'a str, other: &'_ str) -> (&'a str, Option<&'a str>) {
-    //~^ ERROR: single-character lifetime names are likely uninformative
+    //~^ single_char_lifetime_names
+
     base.split_once(other)
         .map(|(left, right)| (left, Some(right)))
         .unwrap_or((base, None))
diff --git a/src/tools/clippy/tests/ui/single_char_lifetime_names.stderr b/src/tools/clippy/tests/ui/single_char_lifetime_names.stderr
index 005c897b19ba..834b654baa57 100644
--- a/src/tools/clippy/tests/ui/single_char_lifetime_names.stderr
+++ b/src/tools/clippy/tests/ui/single_char_lifetime_names.stderr
@@ -33,7 +33,7 @@ LL | impl<'a, 'b> DiagnosticCtx<'a, 'b> {
    = help: use a more informative name
 
 error: single-character lifetime names are likely uninformative
-  --> tests/ui/single_char_lifetime_names.rs:38:15
+  --> tests/ui/single_char_lifetime_names.rs:39:15
    |
 LL | fn split_once<'a>(base: &'a str, other: &'_ str) -> (&'a str, Option<&'a str>) {
    |               ^^
diff --git a/src/tools/clippy/tests/ui/single_char_pattern.fixed b/src/tools/clippy/tests/ui/single_char_pattern.fixed
index a18d6319f89d..9bf9d6630441 100644
--- a/src/tools/clippy/tests/ui/single_char_pattern.fixed
+++ b/src/tools/clippy/tests/ui/single_char_pattern.fixed
@@ -5,6 +5,7 @@ use std::collections::HashSet;
 fn main() {
     let x = "foo";
     x.split('x');
+    //~^ single_char_pattern
     x.split("xx");
     x.split('x');
 
@@ -16,38 +17,67 @@ fn main() {
     // Can't use this lint for unicode code points which don't fit in a char
     x.split("❤️");
     x.split_inclusive('x');
+    //~^ single_char_pattern
     x.contains('x');
+    //~^ single_char_pattern
     x.starts_with('x');
+    //~^ single_char_pattern
     x.ends_with('x');
+    //~^ single_char_pattern
     x.find('x');
+    //~^ single_char_pattern
     x.rfind('x');
+    //~^ single_char_pattern
     x.rsplit('x');
+    //~^ single_char_pattern
     x.split_terminator('x');
+    //~^ single_char_pattern
     x.rsplit_terminator('x');
+    //~^ single_char_pattern
     x.splitn(2, 'x');
+    //~^ single_char_pattern
     x.rsplitn(2, 'x');
+    //~^ single_char_pattern
     x.split_once('x');
+    //~^ single_char_pattern
     x.rsplit_once('x');
+    //~^ single_char_pattern
     x.matches('x');
+    //~^ single_char_pattern
     x.rmatches('x');
+    //~^ single_char_pattern
     x.match_indices('x');
+    //~^ single_char_pattern
     x.rmatch_indices('x');
+    //~^ single_char_pattern
     x.trim_start_matches('x');
+    //~^ single_char_pattern
     x.trim_end_matches('x');
+    //~^ single_char_pattern
     x.replace('x', "y");
+    //~^ single_char_pattern
     x.replacen('x', "y", 3);
+    //~^ single_char_pattern
     // Make sure we escape characters correctly.
     x.split('\n');
+    //~^ single_char_pattern
     x.split('\'');
+    //~^ single_char_pattern
     x.split('\'');
+    //~^ single_char_pattern
     // Issue #11973: Don't escape `"` in `'"'`
     x.split('"');
+    //~^ single_char_pattern
 
     let h = HashSet::<String>::new();
     h.contains("X"); // should not warn
 
     x.replace(';', ",").split(','); // issue #2978
+    //
+    //~^^ single_char_pattern
     x.starts_with('\x03'); // issue #2996
+    //
+    //~^^ single_char_pattern
 
     // Issue #3204
     const S: &str = "#";
@@ -55,13 +85,20 @@ fn main() {
 
     // Raw string
     x.split('a');
+    //~^ single_char_pattern
     x.split('a');
+    //~^ single_char_pattern
     x.split('a');
+    //~^ single_char_pattern
     x.split('\'');
+    //~^ single_char_pattern
     x.split('#');
+    //~^ single_char_pattern
     // Must escape backslash in raw strings when converting to char #8060
     x.split('\\');
+    //~^ single_char_pattern
     x.split('\\');
+    //~^ single_char_pattern
 
     // should not warn, the char versions are actually slower in some cases
     x.strip_prefix("x");
diff --git a/src/tools/clippy/tests/ui/single_char_pattern.rs b/src/tools/clippy/tests/ui/single_char_pattern.rs
index b52e6fb2fdfb..0560a848fe9d 100644
--- a/src/tools/clippy/tests/ui/single_char_pattern.rs
+++ b/src/tools/clippy/tests/ui/single_char_pattern.rs
@@ -5,6 +5,7 @@ use std::collections::HashSet;
 fn main() {
     let x = "foo";
     x.split("x");
+    //~^ single_char_pattern
     x.split("xx");
     x.split('x');
 
@@ -16,38 +17,67 @@ fn main() {
     // Can't use this lint for unicode code points which don't fit in a char
     x.split("❤️");
     x.split_inclusive("x");
+    //~^ single_char_pattern
     x.contains("x");
+    //~^ single_char_pattern
     x.starts_with("x");
+    //~^ single_char_pattern
     x.ends_with("x");
+    //~^ single_char_pattern
     x.find("x");
+    //~^ single_char_pattern
     x.rfind("x");
+    //~^ single_char_pattern
     x.rsplit("x");
+    //~^ single_char_pattern
     x.split_terminator("x");
+    //~^ single_char_pattern
     x.rsplit_terminator("x");
+    //~^ single_char_pattern
     x.splitn(2, "x");
+    //~^ single_char_pattern
     x.rsplitn(2, "x");
+    //~^ single_char_pattern
     x.split_once("x");
+    //~^ single_char_pattern
     x.rsplit_once("x");
+    //~^ single_char_pattern
     x.matches("x");
+    //~^ single_char_pattern
     x.rmatches("x");
+    //~^ single_char_pattern
     x.match_indices("x");
+    //~^ single_char_pattern
     x.rmatch_indices("x");
+    //~^ single_char_pattern
     x.trim_start_matches("x");
+    //~^ single_char_pattern
     x.trim_end_matches("x");
+    //~^ single_char_pattern
     x.replace("x", "y");
+    //~^ single_char_pattern
     x.replacen("x", "y", 3);
+    //~^ single_char_pattern
     // Make sure we escape characters correctly.
     x.split("\n");
+    //~^ single_char_pattern
     x.split("'");
+    //~^ single_char_pattern
     x.split("\'");
+    //~^ single_char_pattern
     // Issue #11973: Don't escape `"` in `'"'`
     x.split("\"");
+    //~^ single_char_pattern
 
     let h = HashSet::<String>::new();
     h.contains("X"); // should not warn
 
     x.replace(';', ",").split(","); // issue #2978
+    //
+    //~^^ single_char_pattern
     x.starts_with("\x03"); // issue #2996
+    //
+    //~^^ single_char_pattern
 
     // Issue #3204
     const S: &str = "#";
@@ -55,13 +85,20 @@ fn main() {
 
     // Raw string
     x.split(r"a");
+    //~^ single_char_pattern
     x.split(r#"a"#);
+    //~^ single_char_pattern
     x.split(r###"a"###);
+    //~^ single_char_pattern
     x.split(r###"'"###);
+    //~^ single_char_pattern
     x.split(r###"#"###);
+    //~^ single_char_pattern
     // Must escape backslash in raw strings when converting to char #8060
     x.split(r#"\"#);
+    //~^ single_char_pattern
     x.split(r"\");
+    //~^ single_char_pattern
 
     // should not warn, the char versions are actually slower in some cases
     x.strip_prefix("x");
diff --git a/src/tools/clippy/tests/ui/single_char_pattern.stderr b/src/tools/clippy/tests/ui/single_char_pattern.stderr
index b2deed23cbd5..aa4ba28884a8 100644
--- a/src/tools/clippy/tests/ui/single_char_pattern.stderr
+++ b/src/tools/clippy/tests/ui/single_char_pattern.stderr
@@ -8,205 +8,205 @@ LL |     x.split("x");
    = help: to override `-D warnings` add `#[allow(clippy::single_char_pattern)]`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:18:23
+  --> tests/ui/single_char_pattern.rs:19:23
    |
 LL |     x.split_inclusive("x");
    |                       ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:19:16
+  --> tests/ui/single_char_pattern.rs:21:16
    |
 LL |     x.contains("x");
    |                ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:20:19
+  --> tests/ui/single_char_pattern.rs:23:19
    |
 LL |     x.starts_with("x");
    |                   ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:21:17
+  --> tests/ui/single_char_pattern.rs:25:17
    |
 LL |     x.ends_with("x");
    |                 ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:22:12
+  --> tests/ui/single_char_pattern.rs:27:12
    |
 LL |     x.find("x");
    |            ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:23:13
+  --> tests/ui/single_char_pattern.rs:29:13
    |
 LL |     x.rfind("x");
    |             ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:24:14
+  --> tests/ui/single_char_pattern.rs:31:14
    |
 LL |     x.rsplit("x");
    |              ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:25:24
+  --> tests/ui/single_char_pattern.rs:33:24
    |
 LL |     x.split_terminator("x");
    |                        ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:26:25
+  --> tests/ui/single_char_pattern.rs:35:25
    |
 LL |     x.rsplit_terminator("x");
    |                         ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:27:17
+  --> tests/ui/single_char_pattern.rs:37:17
    |
 LL |     x.splitn(2, "x");
    |                 ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:28:18
+  --> tests/ui/single_char_pattern.rs:39:18
    |
 LL |     x.rsplitn(2, "x");
    |                  ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:29:18
+  --> tests/ui/single_char_pattern.rs:41:18
    |
 LL |     x.split_once("x");
    |                  ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:30:19
+  --> tests/ui/single_char_pattern.rs:43:19
    |
 LL |     x.rsplit_once("x");
    |                   ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:31:15
+  --> tests/ui/single_char_pattern.rs:45:15
    |
 LL |     x.matches("x");
    |               ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:32:16
+  --> tests/ui/single_char_pattern.rs:47:16
    |
 LL |     x.rmatches("x");
    |                ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:33:21
+  --> tests/ui/single_char_pattern.rs:49:21
    |
 LL |     x.match_indices("x");
    |                     ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:34:22
+  --> tests/ui/single_char_pattern.rs:51:22
    |
 LL |     x.rmatch_indices("x");
    |                      ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:35:26
+  --> tests/ui/single_char_pattern.rs:53:26
    |
 LL |     x.trim_start_matches("x");
    |                          ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:36:24
+  --> tests/ui/single_char_pattern.rs:55:24
    |
 LL |     x.trim_end_matches("x");
    |                        ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:37:15
+  --> tests/ui/single_char_pattern.rs:57:15
    |
 LL |     x.replace("x", "y");
    |               ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:38:16
+  --> tests/ui/single_char_pattern.rs:59:16
    |
 LL |     x.replacen("x", "y", 3);
    |                ^^^ help: consider using a `char`: `'x'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:40:13
+  --> tests/ui/single_char_pattern.rs:62:13
    |
 LL |     x.split("\n");
    |             ^^^^ help: consider using a `char`: `'\n'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:41:13
+  --> tests/ui/single_char_pattern.rs:64:13
    |
 LL |     x.split("'");
    |             ^^^ help: consider using a `char`: `'\''`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:42:13
+  --> tests/ui/single_char_pattern.rs:66:13
    |
 LL |     x.split("\'");
    |             ^^^^ help: consider using a `char`: `'\''`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:44:13
+  --> tests/ui/single_char_pattern.rs:69:13
    |
 LL |     x.split("\"");
    |             ^^^^ help: consider using a `char`: `'"'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:49:31
+  --> tests/ui/single_char_pattern.rs:75:31
    |
 LL |     x.replace(';', ",").split(","); // issue #2978
    |                               ^^^ help: consider using a `char`: `','`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:50:19
+  --> tests/ui/single_char_pattern.rs:78:19
    |
 LL |     x.starts_with("\x03"); // issue #2996
    |                   ^^^^^^ help: consider using a `char`: `'\x03'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:57:13
+  --> tests/ui/single_char_pattern.rs:87:13
    |
 LL |     x.split(r"a");
    |             ^^^^ help: consider using a `char`: `'a'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:58:13
+  --> tests/ui/single_char_pattern.rs:89:13
    |
 LL |     x.split(r#"a"#);
    |             ^^^^^^ help: consider using a `char`: `'a'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:59:13
+  --> tests/ui/single_char_pattern.rs:91:13
    |
 LL |     x.split(r###"a"###);
    |             ^^^^^^^^^^ help: consider using a `char`: `'a'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:60:13
+  --> tests/ui/single_char_pattern.rs:93:13
    |
 LL |     x.split(r###"'"###);
    |             ^^^^^^^^^^ help: consider using a `char`: `'\''`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:61:13
+  --> tests/ui/single_char_pattern.rs:95:13
    |
 LL |     x.split(r###"#"###);
    |             ^^^^^^^^^^ help: consider using a `char`: `'#'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:63:13
+  --> tests/ui/single_char_pattern.rs:98:13
    |
 LL |     x.split(r#"\"#);
    |             ^^^^^^ help: consider using a `char`: `'\\'`
 
 error: single-character string constant used as pattern
-  --> tests/ui/single_char_pattern.rs:64:13
+  --> tests/ui/single_char_pattern.rs:100:13
    |
 LL |     x.split(r"\");
    |             ^^^^ help: consider using a `char`: `'\\'`
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports.fixed b/src/tools/clippy/tests/ui/single_component_path_imports.fixed
index 3e81bcd5e487..180a55813b19 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports.fixed
+++ b/src/tools/clippy/tests/ui/single_component_path_imports.fixed
@@ -3,6 +3,7 @@
 
 use core;
 
+//~^ single_component_path_imports
 
 use serde as edres;
 
@@ -29,6 +30,7 @@ fn main() {
 
 mod hello_mod {
     
+    //~^ single_component_path_imports
     #[allow(dead_code)]
     fn hello_mod() {}
 }
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports.rs b/src/tools/clippy/tests/ui/single_component_path_imports.rs
index 2d72f122adf2..888c533c534c 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports.rs
+++ b/src/tools/clippy/tests/ui/single_component_path_imports.rs
@@ -4,6 +4,7 @@
 use core;
 
 use regex;
+//~^ single_component_path_imports
 
 use serde as edres;
 
@@ -30,6 +31,7 @@ fn main() {
 
 mod hello_mod {
     use regex;
+    //~^ single_component_path_imports
     #[allow(dead_code)]
     fn hello_mod() {}
 }
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports.stderr b/src/tools/clippy/tests/ui/single_component_path_imports.stderr
index 95d7e4d85b7c..f1c56b14358f 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports.stderr
+++ b/src/tools/clippy/tests/ui/single_component_path_imports.stderr
@@ -8,7 +8,7 @@ LL | use regex;
    = help: to override `-D warnings` add `#[allow(clippy::single_component_path_imports)]`
 
 error: this import is redundant
-  --> tests/ui/single_component_path_imports.rs:32:5
+  --> tests/ui/single_component_path_imports.rs:33:5
    |
 LL |     use regex;
    |     ^^^^^^^^^^ help: remove it entirely
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports_macro.rs b/src/tools/clippy/tests/ui/single_component_path_imports_macro.rs
index fda294a61546..f655ea482d1c 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports_macro.rs
+++ b/src/tools/clippy/tests/ui/single_component_path_imports_macro.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.rs b/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.rs
index b4a1ce1d6aec..acfda8b3a9c8 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.rs
+++ b/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.rs
@@ -2,8 +2,7 @@
 #![allow(unused_imports)]
 //@no-rustfix
 use regex;
-//~^ ERROR: this import is redundant
-//~| NOTE: `-D clippy::single-component-path-imports` implied by `-D warnings`
+//~^ single_component_path_imports
 
 use serde as edres;
 
@@ -15,8 +14,9 @@ fn main() {
 
 mod root_nested_use_mod {
     use {regex, serde};
-    //~^ ERROR: this import is redundant
-    //~| ERROR: this import is redundant
+    //~^ single_component_path_imports
+    //~| single_component_path_imports
+
     #[allow(dead_code)]
     fn root_nested_use_mod() {}
 }
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.stderr b/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.stderr
index 8eec877860e7..6dbfd2711b4a 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.stderr
+++ b/src/tools/clippy/tests/ui/single_component_path_imports_nested_first.stderr
@@ -8,7 +8,7 @@ LL | use regex;
    = help: to override `-D warnings` add `#[allow(clippy::single_component_path_imports)]`
 
 error: this import is redundant
-  --> tests/ui/single_component_path_imports_nested_first.rs:17:10
+  --> tests/ui/single_component_path_imports_nested_first.rs:16:10
    |
 LL |     use {regex, serde};
    |          ^^^^^
@@ -16,7 +16,7 @@ LL |     use {regex, serde};
    = help: remove this import
 
 error: this import is redundant
-  --> tests/ui/single_component_path_imports_nested_first.rs:17:17
+  --> tests/ui/single_component_path_imports_nested_first.rs:16:17
    |
 LL |     use {regex, serde};
    |                 ^^^^^
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports_self_after.rs b/src/tools/clippy/tests/ui/single_component_path_imports_self_after.rs
index 5723d480a2e1..a0f2cf690809 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports_self_after.rs
+++ b/src/tools/clippy/tests/ui/single_component_path_imports_self_after.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
diff --git a/src/tools/clippy/tests/ui/single_component_path_imports_self_before.rs b/src/tools/clippy/tests/ui/single_component_path_imports_self_before.rs
index 8a4fbf0dc5b6..b80580da10c3 100644
--- a/src/tools/clippy/tests/ui/single_component_path_imports_self_before.rs
+++ b/src/tools/clippy/tests/ui/single_component_path_imports_self_before.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![warn(clippy::single_component_path_imports)]
 #![allow(unused_imports)]
 
diff --git a/src/tools/clippy/tests/ui/single_element_loop.fixed b/src/tools/clippy/tests/ui/single_element_loop.fixed
index 64cbd5e9c905..76c3cf56c11e 100644
--- a/src/tools/clippy/tests/ui/single_element_loop.fixed
+++ b/src/tools/clippy/tests/ui/single_element_loop.fixed
@@ -7,27 +7,33 @@ fn main() {
     let item1 = 2;
     {
         let item = &item1;
+        //~^ single_element_loop
         dbg!(item);
     }
 
     {
         let item = &item1;
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in 0..5 {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in 0..5 {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in 0..5 {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in 0..5 {
+        //~^ single_element_loop
         dbg!(item);
     }
 
@@ -48,6 +54,7 @@ fn main() {
     // should lint (issue #10018)
     {
         let _ = 42;
+        //~^ single_element_loop
         let _f = |n: u32| {
             for i in 0..n {
                 if i > 10 {
@@ -63,6 +70,7 @@ fn main() {
 
     {
         let (Ok(mut _x) | Err(mut _x)) = res_void;
+        //~^ single_element_loop
         let ptr: *const bool = std::ptr::null();
     }
 }
diff --git a/src/tools/clippy/tests/ui/single_element_loop.rs b/src/tools/clippy/tests/ui/single_element_loop.rs
index 92406f1c1cac..2eb928397b0a 100644
--- a/src/tools/clippy/tests/ui/single_element_loop.rs
+++ b/src/tools/clippy/tests/ui/single_element_loop.rs
@@ -6,26 +6,32 @@
 fn main() {
     let item1 = 2;
     for item in &[item1] {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in [item1].iter() {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in &[0..5] {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in [0..5].iter_mut() {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in [0..5] {
+        //~^ single_element_loop
         dbg!(item);
     }
 
     for item in [0..5].into_iter() {
+        //~^ single_element_loop
         dbg!(item);
     }
 
@@ -45,6 +51,7 @@ fn main() {
 
     // should lint (issue #10018)
     for _ in [42] {
+        //~^ single_element_loop
         let _f = |n: u32| {
             for i in 0..n {
                 if i > 10 {
@@ -59,6 +66,7 @@ fn main() {
     let res_void: Result<bool, bool> = Ok(true);
 
     for (Ok(mut _x) | Err(mut _x)) in [res_void] {
+        //~^ single_element_loop
         let ptr: *const bool = std::ptr::null();
     }
 }
diff --git a/src/tools/clippy/tests/ui/single_element_loop.stderr b/src/tools/clippy/tests/ui/single_element_loop.stderr
index 73453dd2dfd8..639f8d2d1b98 100644
--- a/src/tools/clippy/tests/ui/single_element_loop.stderr
+++ b/src/tools/clippy/tests/ui/single_element_loop.stderr
@@ -2,6 +2,7 @@ error: for loop over a single element
   --> tests/ui/single_element_loop.rs:8:5
    |
 LL | /     for item in &[item1] {
+LL | |
 LL | |         dbg!(item);
 LL | |     }
    | |_____^
@@ -12,14 +13,16 @@ help: try
    |
 LL ~     {
 LL +         let item = &item1;
+LL +
 LL +         dbg!(item);
 LL +     }
    |
 
 error: for loop over a single element
-  --> tests/ui/single_element_loop.rs:12:5
+  --> tests/ui/single_element_loop.rs:13:5
    |
 LL | /     for item in [item1].iter() {
+LL | |
 LL | |         dbg!(item);
 LL | |     }
    | |_____^
@@ -28,41 +31,42 @@ help: try
    |
 LL ~     {
 LL +         let item = &item1;
+LL +
 LL +         dbg!(item);
 LL +     }
    |
 
 error: this loops only once with `item` being `0..5`
-  --> tests/ui/single_element_loop.rs:16:17
+  --> tests/ui/single_element_loop.rs:18:17
    |
 LL |     for item in &[0..5] {
    |                 ^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
 error: this loops only once with `item` being `0..5`
-  --> tests/ui/single_element_loop.rs:20:17
+  --> tests/ui/single_element_loop.rs:23:17
    |
 LL |     for item in [0..5].iter_mut() {
    |                 ^^^^^^^^^^^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
 error: this loops only once with `item` being `0..5`
-  --> tests/ui/single_element_loop.rs:24:17
+  --> tests/ui/single_element_loop.rs:28:17
    |
 LL |     for item in [0..5] {
    |                 ^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
 error: this loops only once with `item` being `0..5`
-  --> tests/ui/single_element_loop.rs:28:17
+  --> tests/ui/single_element_loop.rs:33:17
    |
 LL |     for item in [0..5].into_iter() {
    |                 ^^^^^^^^^^^^^^^^^^ help: did you mean to iterate over the range instead?: `0..5`
 
 error: for loop over a single element
-  --> tests/ui/single_element_loop.rs:47:5
+  --> tests/ui/single_element_loop.rs:53:5
    |
 LL | /     for _ in [42] {
+LL | |
 LL | |         let _f = |n: u32| {
 LL | |             for i in 0..n {
-LL | |                 if i > 10 {
 ...  |
 LL | |         };
 LL | |     }
@@ -72,6 +76,7 @@ help: try
    |
 LL ~     {
 LL +         let _ = 42;
+LL +
 LL +         let _f = |n: u32| {
 LL +             for i in 0..n {
 LL +                 if i > 10 {
@@ -84,9 +89,10 @@ LL +     }
    |
 
 error: for loop over a single element
-  --> tests/ui/single_element_loop.rs:61:5
+  --> tests/ui/single_element_loop.rs:68:5
    |
 LL | /     for (Ok(mut _x) | Err(mut _x)) in [res_void] {
+LL | |
 LL | |         let ptr: *const bool = std::ptr::null();
 LL | |     }
    | |_____^
@@ -95,6 +101,7 @@ help: try
    |
 LL ~     {
 LL +         let (Ok(mut _x) | Err(mut _x)) = res_void;
+LL +
 LL +         let ptr: *const bool = std::ptr::null();
 LL +     }
    |
diff --git a/src/tools/clippy/tests/ui/single_match.fixed b/src/tools/clippy/tests/ui/single_match.fixed
index d3d5fd8b35c8..c6ffe93eb7ab 100644
--- a/src/tools/clippy/tests/ui/single_match.fixed
+++ b/src/tools/clippy/tests/ui/single_match.fixed
@@ -15,6 +15,7 @@ fn single_match() {
     if let Some(y) = x {
         println!("{:?}", y);
     };
+    //~^^^^^^ single_match
 
     let x = Some(1u8);
     match x {
@@ -27,6 +28,7 @@ fn single_match() {
 
     let z = (1u8, 1u8);
     if let (2..=3, 7..=9) = z { dummy() };
+    //~^^^^ single_match
 
     // Not linted (pattern guards used)
     match x {
@@ -53,12 +55,15 @@ fn single_match_know_enum() {
     let y: Result<_, i8> = Ok(1i8);
 
     if let Some(y) = x { dummy() };
+    //~^^^^ single_match
 
     if let Ok(y) = y { dummy() };
+    //~^^^^ single_match
 
     let c = Cow::Borrowed("");
 
     if let Cow::Borrowed(..) = c { dummy() };
+    //~^^^^ single_match
 
     let z = Foo::Bar;
     // no warning
@@ -77,6 +82,7 @@ fn single_match_know_enum() {
 fn if_suggestion() {
     let x = "test";
     if x == "test" { println!() }
+    //~^^^^ single_match
 
     #[derive(PartialEq, Eq)]
     enum Foo {
@@ -87,14 +93,18 @@ fn if_suggestion() {
 
     let x = Foo::A;
     if x == Foo::A { println!() }
+    //~^^^^ single_match
 
     const FOO_C: Foo = Foo::C(0);
     if x == FOO_C { println!() }
+    //~^^^^ single_match
 
     if x == Foo::A { println!() }
+    //~^^^^ single_match
 
     let x = &x;
     if x == &Foo::A { println!() }
+    //~^^^^ single_match
 
     enum Bar {
         A,
@@ -109,11 +119,13 @@ fn if_suggestion() {
 
     let x = Bar::A;
     if let Bar::A = x { println!() }
+    //~^^^^ single_match
 
     // issue #7038
     struct X;
     let x = Some(X);
     if let None = x { println!() };
+    //~^^^^ single_match
 }
 
 // See: issue #8282
@@ -133,12 +145,15 @@ fn ranges() {
 
     // lint
     if let (Some(_), _) = x {}
+    //~^^^^ single_match
 
     // lint
     if let (Some(E::V), _) = x { todo!() }
+    //~^^^^ single_match
 
     // lint
     if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}
+    //~^^^^ single_match
 
     // Don't lint, see above.
     match (Some(E::V), Some(E::V), Some(E::V)) {
@@ -211,6 +226,7 @@ fn issue_10808(bar: Option<i32>) {
         let r = &v as *const i32;
         println!("{}", *r);
     } }
+    //~^^^^^^^ single_match
 
     if let Some(v) = bar {
         unsafe {
@@ -218,6 +234,7 @@ fn issue_10808(bar: Option<i32>) {
             println!("{}", *r);
         }
     }
+    //~^^^^^^^^^^ single_match
 }
 
 mod issue8634 {
@@ -289,6 +306,7 @@ fn issue11365() {
     }
 
     if let Ok(Some(A)) = Ok::<_, u32>(Some(A)) { println!() }
+    //~^^^^ single_match
 
     match &Some(A) {
         Some(A | B | C) => println!(),
@@ -301,10 +319,12 @@ fn issue11365() {
     }
 
     if let Some(A | B) = &Some(A) { println!() }
+    //~^^^^ single_match
 }
 
 fn issue12758(s: &[u8]) {
     if &s[0..3] == b"foo" { println!() }
+    //~^^^^ single_match
 }
 
 #[derive(Eq, PartialEq)]
@@ -315,20 +335,26 @@ const CONST_I32: i32 = 1;
 
 fn irrefutable_match() {
     println!();
+    //~^^^^ single_match
 
     println!();
+    //~^^^^ single_match
 
     let i = 0;
     {
         let a = 1;
         let b = 2;
     }
+    //~^^^^^^^ single_match
 
     
+    //~^^^^ single_match
 
     
+    //~^^^^ single_match
 
     println!();
+    //~^^^^ single_match
 
     let mut x = vec![1i8];
 
diff --git a/src/tools/clippy/tests/ui/single_match.rs b/src/tools/clippy/tests/ui/single_match.rs
index 2f3547c50639..dc758fa4281c 100644
--- a/src/tools/clippy/tests/ui/single_match.rs
+++ b/src/tools/clippy/tests/ui/single_match.rs
@@ -18,6 +18,7 @@ fn single_match() {
         },
         _ => (),
     };
+    //~^^^^^^ single_match
 
     let x = Some(1u8);
     match x {
@@ -33,6 +34,7 @@ fn single_match() {
         (2..=3, 7..=9) => dummy(),
         _ => {},
     };
+    //~^^^^ single_match
 
     // Not linted (pattern guards used)
     match x {
@@ -62,11 +64,13 @@ fn single_match_know_enum() {
         Some(y) => dummy(),
         None => (),
     };
+    //~^^^^ single_match
 
     match y {
         Ok(y) => dummy(),
         Err(..) => (),
     };
+    //~^^^^ single_match
 
     let c = Cow::Borrowed("");
 
@@ -74,6 +78,7 @@ fn single_match_know_enum() {
         Cow::Borrowed(..) => dummy(),
         Cow::Owned(..) => (),
     };
+    //~^^^^ single_match
 
     let z = Foo::Bar;
     // no warning
@@ -95,6 +100,7 @@ fn if_suggestion() {
         "test" => println!(),
         _ => (),
     }
+    //~^^^^ single_match
 
     #[derive(PartialEq, Eq)]
     enum Foo {
@@ -108,23 +114,27 @@ fn if_suggestion() {
         Foo::A => println!(),
         _ => (),
     }
+    //~^^^^ single_match
 
     const FOO_C: Foo = Foo::C(0);
     match x {
         FOO_C => println!(),
         _ => (),
     }
+    //~^^^^ single_match
 
     match &&x {
         Foo::A => println!(),
         _ => (),
     }
+    //~^^^^ single_match
 
     let x = &x;
     match &x {
         Foo::A => println!(),
         _ => (),
     }
+    //~^^^^ single_match
 
     enum Bar {
         A,
@@ -142,6 +152,7 @@ fn if_suggestion() {
         Bar::A => println!(),
         _ => (),
     }
+    //~^^^^ single_match
 
     // issue #7038
     struct X;
@@ -150,6 +161,7 @@ fn if_suggestion() {
         None => println!(),
         _ => (),
     };
+    //~^^^^ single_match
 }
 
 // See: issue #8282
@@ -172,18 +184,21 @@ fn ranges() {
         (Some(_), _) => {},
         (None, _) => {},
     }
+    //~^^^^ single_match
 
     // lint
     match x {
         (Some(E::V), _) => todo!(),
         (_, _) => {},
     }
+    //~^^^^ single_match
 
     // lint
     match (Some(42), Some(E::V), Some(42)) {
         (.., Some(E::V), _) => {},
         (..) => {},
     }
+    //~^^^^ single_match
 
     // Don't lint, see above.
     match (Some(E::V), Some(E::V), Some(E::V)) {
@@ -259,6 +274,7 @@ fn issue_10808(bar: Option<i32>) {
         },
         _ => {},
     }
+    //~^^^^^^^ single_match
 
     match bar {
         #[rustfmt::skip]
@@ -270,6 +286,7 @@ fn issue_10808(bar: Option<i32>) {
         },
         _ => {},
     }
+    //~^^^^^^^^^^ single_match
 }
 
 mod issue8634 {
@@ -344,6 +361,7 @@ fn issue11365() {
         Ok(Some(A)) => println!(),
         Err(_) | Ok(None | Some(_)) => {},
     }
+    //~^^^^ single_match
 
     match &Some(A) {
         Some(A | B | C) => println!(),
@@ -359,6 +377,7 @@ fn issue11365() {
         Some(A | B) => println!(),
         None | Some(_) => {},
     }
+    //~^^^^ single_match
 }
 
 fn issue12758(s: &[u8]) {
@@ -366,6 +385,7 @@ fn issue12758(s: &[u8]) {
         b"foo" => println!(),
         _ => {},
     }
+    //~^^^^ single_match
 }
 
 #[derive(Eq, PartialEq)]
@@ -379,11 +399,13 @@ fn irrefutable_match() {
         DATA => println!(),
         _ => {},
     }
+    //~^^^^ single_match
 
     match CONST_I32 {
         CONST_I32 => println!(),
         _ => {},
     }
+    //~^^^^ single_match
 
     let i = 0;
     match i {
@@ -393,21 +415,25 @@ fn irrefutable_match() {
         },
         _ => {},
     }
+    //~^^^^^^^ single_match
 
     match i {
         i => {},
         _ => {},
     }
+    //~^^^^ single_match
 
     match i {
         i => (),
         _ => (),
     }
+    //~^^^^ single_match
 
     match CONST_I32 {
         CONST_I32 => println!(),
         _ => {},
     }
+    //~^^^^ single_match
 
     let mut x = vec![1i8];
 
diff --git a/src/tools/clippy/tests/ui/single_match.stderr b/src/tools/clippy/tests/ui/single_match.stderr
index 54bbfbac093c..c88296959489 100644
--- a/src/tools/clippy/tests/ui/single_match.stderr
+++ b/src/tools/clippy/tests/ui/single_match.stderr
@@ -19,7 +19,7 @@ LL ~     };
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:32:5
+  --> tests/ui/single_match.rs:33:5
    |
 LL | /     match z {
 LL | |         (2..=3, 7..=9) => dummy(),
@@ -28,7 +28,7 @@ LL | |     };
    | |_____^ help: try: `if let (2..=3, 7..=9) = z { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:61:5
+  --> tests/ui/single_match.rs:63:5
    |
 LL | /     match x {
 LL | |         Some(y) => dummy(),
@@ -37,7 +37,7 @@ LL | |     };
    | |_____^ help: try: `if let Some(y) = x { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:66:5
+  --> tests/ui/single_match.rs:69:5
    |
 LL | /     match y {
 LL | |         Ok(y) => dummy(),
@@ -46,7 +46,7 @@ LL | |     };
    | |_____^ help: try: `if let Ok(y) = y { dummy() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:73:5
+  --> tests/ui/single_match.rs:77:5
    |
 LL | /     match c {
 LL | |         Cow::Borrowed(..) => dummy(),
@@ -55,7 +55,7 @@ LL | |     };
    | |_____^ help: try: `if let Cow::Borrowed(..) = c { dummy() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> tests/ui/single_match.rs:94:5
+  --> tests/ui/single_match.rs:99:5
    |
 LL | /     match x {
 LL | |         "test" => println!(),
@@ -64,7 +64,7 @@ LL | |     }
    | |_____^ help: try: `if x == "test" { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> tests/ui/single_match.rs:107:5
+  --> tests/ui/single_match.rs:113:5
    |
 LL | /     match x {
 LL | |         Foo::A => println!(),
@@ -73,7 +73,7 @@ LL | |     }
    | |_____^ help: try: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> tests/ui/single_match.rs:113:5
+  --> tests/ui/single_match.rs:120:5
    |
 LL | /     match x {
 LL | |         FOO_C => println!(),
@@ -82,7 +82,7 @@ LL | |     }
    | |_____^ help: try: `if x == FOO_C { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> tests/ui/single_match.rs:118:5
+  --> tests/ui/single_match.rs:126:5
    |
 LL | /     match &&x {
 LL | |         Foo::A => println!(),
@@ -91,7 +91,7 @@ LL | |     }
    | |_____^ help: try: `if x == Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> tests/ui/single_match.rs:124:5
+  --> tests/ui/single_match.rs:133:5
    |
 LL | /     match &x {
 LL | |         Foo::A => println!(),
@@ -100,7 +100,7 @@ LL | |     }
    | |_____^ help: try: `if x == &Foo::A { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:141:5
+  --> tests/ui/single_match.rs:151:5
    |
 LL | /     match x {
 LL | |         Bar::A => println!(),
@@ -109,7 +109,7 @@ LL | |     }
    | |_____^ help: try: `if let Bar::A = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:149:5
+  --> tests/ui/single_match.rs:160:5
    |
 LL | /     match x {
 LL | |         None => println!(),
@@ -118,7 +118,7 @@ LL | |     };
    | |_____^ help: try: `if let None = x { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:171:5
+  --> tests/ui/single_match.rs:183:5
    |
 LL | /     match x {
 LL | |         (Some(_), _) => {},
@@ -127,7 +127,7 @@ LL | |     }
    | |_____^ help: try: `if let (Some(_), _) = x {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:177:5
+  --> tests/ui/single_match.rs:190:5
    |
 LL | /     match x {
 LL | |         (Some(E::V), _) => todo!(),
@@ -136,7 +136,7 @@ LL | |     }
    | |_____^ help: try: `if let (Some(E::V), _) = x { todo!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:183:5
+  --> tests/ui/single_match.rs:197:5
    |
 LL | /     match (Some(42), Some(E::V), Some(42)) {
 LL | |         (.., Some(E::V), _) => {},
@@ -145,7 +145,7 @@ LL | |     }
    | |_____^ help: try: `if let (.., Some(E::V), _) = (Some(42), Some(E::V), Some(42)) {}`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:255:5
+  --> tests/ui/single_match.rs:270:5
    |
 LL | /     match bar {
 LL | |         Some(v) => unsafe {
@@ -165,7 +165,7 @@ LL +     } }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:263:5
+  --> tests/ui/single_match.rs:279:5
    |
 LL | /     match bar {
 LL | |         #[rustfmt::skip]
@@ -187,7 +187,7 @@ LL +     }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:343:5
+  --> tests/ui/single_match.rs:360:5
    |
 LL | /     match Ok::<_, u32>(Some(A)) {
 LL | |         Ok(Some(A)) => println!(),
@@ -196,7 +196,7 @@ LL | |     }
    | |_____^ help: try: `if let Ok(Some(A)) = Ok::<_, u32>(Some(A)) { println!() }`
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match.rs:358:5
+  --> tests/ui/single_match.rs:376:5
    |
 LL | /     match &Some(A) {
 LL | |         Some(A | B) => println!(),
@@ -205,7 +205,7 @@ LL | |     }
    | |_____^ help: try: `if let Some(A | B) = &Some(A) { println!() }`
 
 error: you seem to be trying to use `match` for an equality check. Consider using `if`
-  --> tests/ui/single_match.rs:365:5
+  --> tests/ui/single_match.rs:384:5
    |
 LL | /     match &s[0..3] {
 LL | |         b"foo" => println!(),
@@ -214,7 +214,7 @@ LL | |     }
    | |_____^ help: try: `if &s[0..3] == b"foo" { println!() }`
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:378:5
+  --> tests/ui/single_match.rs:398:5
    |
 LL | /     match DATA {
 LL | |         DATA => println!(),
@@ -223,7 +223,7 @@ LL | |     }
    | |_____^ help: try: `println!();`
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:383:5
+  --> tests/ui/single_match.rs:404:5
    |
 LL | /     match CONST_I32 {
 LL | |         CONST_I32 => println!(),
@@ -232,7 +232,7 @@ LL | |     }
    | |_____^ help: try: `println!();`
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:389:5
+  --> tests/ui/single_match.rs:411:5
    |
 LL | /     match i {
 LL | |         i => {
@@ -252,7 +252,7 @@ LL +     }
    |
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:397:5
+  --> tests/ui/single_match.rs:420:5
    |
 LL | /     match i {
 LL | |         i => {},
@@ -261,7 +261,7 @@ LL | |     }
    | |_____^ help: `match` expression can be removed
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:402:5
+  --> tests/ui/single_match.rs:426:5
    |
 LL | /     match i {
 LL | |         i => (),
@@ -270,7 +270,7 @@ LL | |     }
    | |_____^ help: `match` expression can be removed
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match.rs:407:5
+  --> tests/ui/single_match.rs:432:5
    |
 LL | /     match CONST_I32 {
 LL | |         CONST_I32 => println!(),
diff --git a/src/tools/clippy/tests/ui/single_match_else.fixed b/src/tools/clippy/tests/ui/single_match_else.fixed
index c2ca746976bd..64782bf62a78 100644
--- a/src/tools/clippy/tests/ui/single_match_else.fixed
+++ b/src/tools/clippy/tests/ui/single_match_else.fixed
@@ -18,6 +18,7 @@ fn unwrap_addr() -> Option<&'static ExprNode> {
         let x = 5;
         None
     };
+    //~^^^^^^^ single_match_else
 
     // Don't lint
     with_span!(span match ExprNode::Butterflies {
@@ -80,12 +81,14 @@ fn main() {
         println!("else block");
         return
     }
+    //~^^^^^^^ single_match_else
 
     // lint here
     if let Some(a) = Some(1) { println!("${:?}", a) } else {
         println!("else block");
         return;
     }
+    //~^^^^^^^ single_match_else
 
     // lint here
     use std::convert::Infallible;
@@ -93,12 +96,14 @@ fn main() {
         println!("else block");
         return;
     }
+    //~^^^^^^^ single_match_else
 
     use std::borrow::Cow;
     if let Cow::Owned(a) = Cow::from("moo") { println!("${:?}", a) } else {
         println!("else block");
         return;
     }
+    //~^^^^^^^ single_match_else
 }
 
 fn issue_10808(bar: Option<i32>) {
@@ -109,6 +114,7 @@ fn issue_10808(bar: Option<i32>) {
         println!("None1");
         println!("None2");
     }
+    //~^^^^^^^^^^ single_match_else
 
     if let Some(v) = bar {
         println!("Some");
@@ -118,6 +124,7 @@ fn issue_10808(bar: Option<i32>) {
         let r = &v as *const i32;
         println!("{}", *r);
     } }
+    //~^^^^^^^^^^^ single_match_else
 
     if let Some(v) = bar { unsafe {
         let r = &v as *const i32;
@@ -127,6 +134,7 @@ fn issue_10808(bar: Option<i32>) {
         let r = &v as *const i32;
         println!("{}", *r);
     } }
+    //~^^^^^^^^^^^ single_match_else
 
     if let Some(v) = bar {
         unsafe {
@@ -137,6 +145,7 @@ fn issue_10808(bar: Option<i32>) {
         println!("None");
         println!("None");
     }
+    //~^^^^^^^^^^^^^ single_match_else
 
     match bar {
         Some(v) => {
@@ -174,4 +183,5 @@ fn issue_10808(bar: Option<i32>) {
 
 fn irrefutable_match() -> Option<&'static ExprNode> {
     Some(&NODE)
+    //~^^^^^^^ single_match_else
 }
diff --git a/src/tools/clippy/tests/ui/single_match_else.rs b/src/tools/clippy/tests/ui/single_match_else.rs
index 2d9e877ee0fe..3f86f4d51803 100644
--- a/src/tools/clippy/tests/ui/single_match_else.rs
+++ b/src/tools/clippy/tests/ui/single_match_else.rs
@@ -21,6 +21,7 @@ fn unwrap_addr() -> Option<&'static ExprNode> {
             None
         },
     };
+    //~^^^^^^^ single_match_else
 
     // Don't lint
     with_span!(span match ExprNode::Butterflies {
@@ -86,6 +87,7 @@ fn main() {
             return
         },
     }
+    //~^^^^^^^ single_match_else
 
     // lint here
     match Some(1) {
@@ -95,6 +97,7 @@ fn main() {
             return;
         },
     }
+    //~^^^^^^^ single_match_else
 
     // lint here
     use std::convert::Infallible;
@@ -105,6 +108,7 @@ fn main() {
             return;
         }
     }
+    //~^^^^^^^ single_match_else
 
     use std::borrow::Cow;
     match Cow::from("moo") {
@@ -114,6 +118,7 @@ fn main() {
             return;
         }
     }
+    //~^^^^^^^ single_match_else
 }
 
 fn issue_10808(bar: Option<i32>) {
@@ -127,6 +132,7 @@ fn issue_10808(bar: Option<i32>) {
             println!("None2");
         },
     }
+    //~^^^^^^^^^^ single_match_else
 
     match bar {
         Some(v) => {
@@ -139,6 +145,7 @@ fn issue_10808(bar: Option<i32>) {
             println!("{}", *r);
         },
     }
+    //~^^^^^^^^^^^ single_match_else
 
     match bar {
         Some(v) => unsafe {
@@ -151,6 +158,7 @@ fn issue_10808(bar: Option<i32>) {
             println!("{}", *r);
         },
     }
+    //~^^^^^^^^^^^ single_match_else
 
     match bar {
         #[rustfmt::skip]
@@ -165,6 +173,7 @@ fn issue_10808(bar: Option<i32>) {
             println!("None");
         },
     }
+    //~^^^^^^^^^^^^^ single_match_else
 
     match bar {
         Some(v) => {
@@ -208,4 +217,5 @@ fn irrefutable_match() -> Option<&'static ExprNode> {
             None
         },
     }
+    //~^^^^^^^ single_match_else
 }
diff --git a/src/tools/clippy/tests/ui/single_match_else.stderr b/src/tools/clippy/tests/ui/single_match_else.stderr
index aa494520b841..7d4ba5fb75ef 100644
--- a/src/tools/clippy/tests/ui/single_match_else.stderr
+++ b/src/tools/clippy/tests/ui/single_match_else.stderr
@@ -22,7 +22,7 @@ LL ~     };
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:82:5
+  --> tests/ui/single_match_else.rs:83:5
    |
 LL | /     match Some(1) {
 LL | |         Some(a) => println!("${:?}", a),
@@ -42,7 +42,7 @@ LL +     }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:91:5
+  --> tests/ui/single_match_else.rs:93:5
    |
 LL | /     match Some(1) {
 LL | |         Some(a) => println!("${:?}", a),
@@ -62,7 +62,7 @@ LL +     }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:101:5
+  --> tests/ui/single_match_else.rs:104:5
    |
 LL | /     match Result::<i32, &Infallible>::Ok(1) {
 LL | |         Ok(a) => println!("${:?}", a),
@@ -81,7 +81,7 @@ LL +     }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:110:5
+  --> tests/ui/single_match_else.rs:114:5
    |
 LL | /     match Cow::from("moo") {
 LL | |         Cow::Owned(a) => println!("${:?}", a),
@@ -100,7 +100,7 @@ LL +     }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:120:5
+  --> tests/ui/single_match_else.rs:125:5
    |
 LL | /     match bar {
 LL | |         Some(v) => unsafe {
@@ -123,7 +123,7 @@ LL +     }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:131:5
+  --> tests/ui/single_match_else.rs:137:5
    |
 LL | /     match bar {
 LL | |         Some(v) => {
@@ -147,7 +147,7 @@ LL +     } }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:143:5
+  --> tests/ui/single_match_else.rs:150:5
    |
 LL | /     match bar {
 LL | |         Some(v) => unsafe {
@@ -171,7 +171,7 @@ LL +     } }
    |
 
 error: you seem to be trying to use `match` for destructuring a single pattern. Consider using `if let`
-  --> tests/ui/single_match_else.rs:155:5
+  --> tests/ui/single_match_else.rs:163:5
    |
 LL | /     match bar {
 LL | |         #[rustfmt::skip]
@@ -196,7 +196,7 @@ LL +     }
    |
 
 error: this pattern is irrefutable, `match` is useless
-  --> tests/ui/single_match_else.rs:204:5
+  --> tests/ui/single_match_else.rs:213:5
    |
 LL | /     match ExprNode::Butterflies {
 LL | |         ExprNode::Butterflies => Some(&NODE),
diff --git a/src/tools/clippy/tests/ui/single_option_map.rs b/src/tools/clippy/tests/ui/single_option_map.rs
new file mode 100644
index 000000000000..6126582f4635
--- /dev/null
+++ b/src/tools/clippy/tests/ui/single_option_map.rs
@@ -0,0 +1,72 @@
+#![warn(clippy::single_option_map)]
+
+use std::sync::atomic::{AtomicUsize, Ordering};
+
+static ATOM: AtomicUsize = AtomicUsize::new(42);
+static MAYBE_ATOMIC: Option<&AtomicUsize> = Some(&ATOM);
+
+fn h(arg: Option<u32>) -> Option<u32> {
+    //~^ single_option_map
+
+    arg.map(|x| x * 2)
+}
+
+fn j(arg: Option<u64>) -> Option<u64> {
+    //~^ single_option_map
+
+    arg.map(|x| x * 2)
+}
+
+fn mul_args(a: String, b: u64) -> String {
+    a
+}
+
+fn mul_args_opt(a: Option<String>, b: u64) -> Option<String> {
+    //~^ single_option_map
+
+    a.map(|val| mul_args(val, b + 1))
+}
+
+// No lint: no `Option` argument argument
+fn maps_static_option() -> Option<usize> {
+    MAYBE_ATOMIC.map(|a| a.load(Ordering::Relaxed))
+}
+
+// No lint: wrapped by another function
+fn manipulate(i: i32) -> i32 {
+    i + 1
+}
+// No lint: wraps another function to do the optional thing
+fn manipulate_opt(opt_i: Option<i32>) -> Option<i32> {
+    opt_i.map(manipulate)
+}
+
+// No lint: maps other than the receiver
+fn map_not_arg(arg: Option<u32>) -> Option<u32> {
+    maps_static_option().map(|_| arg.unwrap())
+}
+
+// No lint: wrapper function with η-expanded form
+#[allow(clippy::redundant_closure)]
+fn manipulate_opt_explicit(opt_i: Option<i32>) -> Option<i32> {
+    opt_i.map(|x| manipulate(x))
+}
+
+// No lint
+fn multi_args(a: String, b: bool, c: u64) -> String {
+    a
+}
+
+// No lint: contains only map of a closure that binds other arguments
+fn multi_args_opt(a: Option<String>, b: bool, c: u64) -> Option<String> {
+    a.map(|a| multi_args(a, b, c))
+}
+
+fn main() {
+    let answer = Some(42u32);
+    let h_result = h(answer);
+
+    let answer = Some(42u64);
+    let j_result = j(answer);
+    maps_static_option();
+}
diff --git a/src/tools/clippy/tests/ui/single_option_map.stderr b/src/tools/clippy/tests/ui/single_option_map.stderr
new file mode 100644
index 000000000000..11865c5b569f
--- /dev/null
+++ b/src/tools/clippy/tests/ui/single_option_map.stderr
@@ -0,0 +1,40 @@
+error: `fn` that only maps over argument
+  --> tests/ui/single_option_map.rs:8:1
+   |
+LL | / fn h(arg: Option<u32>) -> Option<u32> {
+LL | |
+LL | |
+LL | |     arg.map(|x| x * 2)
+LL | | }
+   | |_^
+   |
+   = help: move the `.map` to the caller or to an `_opt` function
+   = note: `-D clippy::single-option-map` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::single_option_map)]`
+
+error: `fn` that only maps over argument
+  --> tests/ui/single_option_map.rs:14:1
+   |
+LL | / fn j(arg: Option<u64>) -> Option<u64> {
+LL | |
+LL | |
+LL | |     arg.map(|x| x * 2)
+LL | | }
+   | |_^
+   |
+   = help: move the `.map` to the caller or to an `_opt` function
+
+error: `fn` that only maps over argument
+  --> tests/ui/single_option_map.rs:24:1
+   |
+LL | / fn mul_args_opt(a: Option<String>, b: u64) -> Option<String> {
+LL | |
+LL | |
+LL | |     a.map(|val| mul_args(val, b + 1))
+LL | | }
+   | |_^
+   |
+   = help: move the `.map` to the caller or to an `_opt` function
+
+error: aborting due to 3 previous errors
+
diff --git a/src/tools/clippy/tests/ui/single_range_in_vec_init.rs b/src/tools/clippy/tests/ui/single_range_in_vec_init.rs
index 7887cfc61750..c6c0cb347dc6 100644
--- a/src/tools/clippy/tests/ui/single_range_in_vec_init.rs
+++ b/src/tools/clippy/tests/ui/single_range_in_vec_init.rs
@@ -24,16 +24,26 @@ fn awa_vec<T: PartialOrd>(start: T, end: T) {
 fn main() {
     // Lint
     [0..200];
+    //~^ single_range_in_vec_init
     vec![0..200];
+    //~^ single_range_in_vec_init
     [0u8..200];
+    //~^ single_range_in_vec_init
     [0usize..200];
+    //~^ single_range_in_vec_init
     [0..200usize];
+    //~^ single_range_in_vec_init
     vec![0u8..200];
+    //~^ single_range_in_vec_init
     vec![0usize..200];
+    //~^ single_range_in_vec_init
     vec![0..200usize];
+    //~^ single_range_in_vec_init
     // Only suggest collect
     [0..200isize];
+    //~^ single_range_in_vec_init
     vec![0..200isize];
+    //~^ single_range_in_vec_init
     // Do not lint
     [0..200, 0..100];
     vec![0..200, 0..100];
diff --git a/src/tools/clippy/tests/ui/single_range_in_vec_init.stderr b/src/tools/clippy/tests/ui/single_range_in_vec_init.stderr
index b3bc8dd4aca1..a99127a7606f 100644
--- a/src/tools/clippy/tests/ui/single_range_in_vec_init.stderr
+++ b/src/tools/clippy/tests/ui/single_range_in_vec_init.stderr
@@ -18,7 +18,7 @@ LL +     [0; 200];
    |
 
 error: a `Vec` of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:27:5
+  --> tests/ui/single_range_in_vec_init.rs:28:5
    |
 LL |     vec![0..200];
    |     ^^^^^^^^^^^^
@@ -35,7 +35,7 @@ LL +     vec![0; 200];
    |
 
 error: an array of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:28:5
+  --> tests/ui/single_range_in_vec_init.rs:30:5
    |
 LL |     [0u8..200];
    |     ^^^^^^^^^^
@@ -52,7 +52,7 @@ LL +     [0u8; 200];
    |
 
 error: an array of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:29:5
+  --> tests/ui/single_range_in_vec_init.rs:32:5
    |
 LL |     [0usize..200];
    |     ^^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL +     [0usize; 200];
    |
 
 error: an array of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:30:5
+  --> tests/ui/single_range_in_vec_init.rs:34:5
    |
 LL |     [0..200usize];
    |     ^^^^^^^^^^^^^
@@ -86,7 +86,7 @@ LL +     [0; 200usize];
    |
 
 error: a `Vec` of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:31:5
+  --> tests/ui/single_range_in_vec_init.rs:36:5
    |
 LL |     vec![0u8..200];
    |     ^^^^^^^^^^^^^^
@@ -103,7 +103,7 @@ LL +     vec![0u8; 200];
    |
 
 error: a `Vec` of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:32:5
+  --> tests/ui/single_range_in_vec_init.rs:38:5
    |
 LL |     vec![0usize..200];
    |     ^^^^^^^^^^^^^^^^^
@@ -120,7 +120,7 @@ LL +     vec![0usize; 200];
    |
 
 error: a `Vec` of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:33:5
+  --> tests/ui/single_range_in_vec_init.rs:40:5
    |
 LL |     vec![0..200usize];
    |     ^^^^^^^^^^^^^^^^^
@@ -137,7 +137,7 @@ LL +     vec![0; 200usize];
    |
 
 error: an array of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:35:5
+  --> tests/ui/single_range_in_vec_init.rs:43:5
    |
 LL |     [0..200isize];
    |     ^^^^^^^^^^^^^
@@ -149,7 +149,7 @@ LL +     (0..200isize).collect::<std::vec::Vec<isize>>();
    |
 
 error: a `Vec` of `Range` that is only one element
-  --> tests/ui/single_range_in_vec_init.rs:36:5
+  --> tests/ui/single_range_in_vec_init.rs:45:5
    |
 LL |     vec![0..200isize];
    |     ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/size_of_in_element_count/expressions.rs b/src/tools/clippy/tests/ui/size_of_in_element_count/expressions.rs
index f405ba200acd..3fe4d923441d 100644
--- a/src/tools/clippy/tests/ui/size_of_in_element_count/expressions.rs
+++ b/src/tools/clippy/tests/ui/size_of_in_element_count/expressions.rs
@@ -13,15 +13,15 @@ fn main() {
 
     // Count expression involving multiplication of size_of (Should trigger the lint)
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of::<u16>() * SIZE) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     // Count expression involving nested multiplications of size_of (Should trigger the lint)
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), HALF_SIZE * size_of_val(&x[0]) * 2) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     // Count expression involving divisions of size_of (Should trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE * size_of::<u16>() / 2) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     // Count expression involving divisions by size_of (Should not trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / size_of::<u16>()) };
@@ -31,7 +31,7 @@ fn main() {
 
     // Count expression involving recursive divisions by size_of (Should trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), DOUBLE_SIZE / (2 / size_of::<u16>())) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     // No size_of calls (Should not trigger the lint)
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), SIZE) };
diff --git a/src/tools/clippy/tests/ui/size_of_in_element_count/functions.rs b/src/tools/clippy/tests/ui/size_of_in_element_count/functions.rs
index af18136a1dbe..afd12edec1ed 100644
--- a/src/tools/clippy/tests/ui/size_of_in_element_count/functions.rs
+++ b/src/tools/clippy/tests/ui/size_of_in_element_count/functions.rs
@@ -16,47 +16,59 @@ fn main() {
 
     // Count is size_of (Should trigger the lint)
     unsafe { copy_nonoverlapping::<u16>(x.as_ptr(), y.as_mut_ptr(), size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u16>() * SIZE) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u16>() * SIZE);
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     slice_from_raw_parts(y.as_ptr(), size_of::<u16>() * SIZE);
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u16>() * SIZE) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { from_raw_parts(y.as_ptr(), size_of::<u16>() * SIZE) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 
     unsafe { y.as_mut_ptr().sub(size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     y.as_ptr().wrapping_sub(size_of::<u16>());
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { y.as_ptr().add(size_of::<u16>()) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     y.as_mut_ptr().wrapping_add(size_of::<u16>());
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     unsafe { y.as_ptr().offset(size_of::<u16>() as isize) };
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
+
     y.as_mut_ptr().wrapping_offset(size_of::<u16>() as isize);
-    //~^ ERROR: found a count of bytes instead of a count of elements of `T`
+    //~^ size_of_in_element_count
 }
diff --git a/src/tools/clippy/tests/ui/size_of_in_element_count/functions.stderr b/src/tools/clippy/tests/ui/size_of_in_element_count/functions.stderr
index de54789b2251..f11c33167669 100644
--- a/src/tools/clippy/tests/ui/size_of_in_element_count/functions.stderr
+++ b/src/tools/clippy/tests/ui/size_of_in_element_count/functions.stderr
@@ -9,7 +9,7 @@ LL |     unsafe { copy_nonoverlapping::<u16>(x.as_ptr(), y.as_mut_ptr(), size_of
    = help: to override `-D warnings` add `#[allow(clippy::size_of_in_element_count)]`
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:20:62
+  --> tests/ui/size_of_in_element_count/functions.rs:21:62
    |
 LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                                              ^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     unsafe { copy_nonoverlapping(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:23:49
+  --> tests/ui/size_of_in_element_count/functions.rs:24:49
    |
 LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u16>()) };
    |                                                 ^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     unsafe { x.as_ptr().copy_to(y.as_mut_ptr(), size_of::<u16>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:25:64
+  --> tests/ui/size_of_in_element_count/functions.rs:27:64
    |
 LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u16>()) };
    |                                                                ^^^^^^^^^^^^^^^^
@@ -33,7 +33,7 @@ LL |     unsafe { x.as_ptr().copy_to_nonoverlapping(y.as_mut_ptr(), size_of::<u1
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:27:51
+  --> tests/ui/size_of_in_element_count/functions.rs:30:51
    |
 LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u16>()) };
    |                                                   ^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from(x.as_ptr(), size_of::<u16>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:29:66
+  --> tests/ui/size_of_in_element_count/functions.rs:33:66
    |
 LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<u16>()) };
    |                                                                  ^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     unsafe { y.as_mut_ptr().copy_from_nonoverlapping(x.as_ptr(), size_of::<
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:32:47
+  --> tests/ui/size_of_in_element_count/functions.rs:36:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u16>()) };
    |                                               ^^^^^^^^^^^^^^^^
@@ -57,7 +57,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of::<u16>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:34:47
+  --> tests/ui/size_of_in_element_count/functions.rs:39:47
    |
 LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    |                                               ^^^^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     unsafe { copy(x.as_ptr(), y.as_mut_ptr(), size_of_val(&x[0])) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:37:66
+  --> tests/ui/size_of_in_element_count/functions.rs:42:66
    |
 LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<u16>() * SIZE) };
    |                                                                  ^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     unsafe { swap_nonoverlapping(y.as_mut_ptr(), x.as_mut_ptr(), size_of::<
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:40:46
+  --> tests/ui/size_of_in_element_count/functions.rs:45:46
    |
 LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u16>() * SIZE);
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL |     slice_from_raw_parts_mut(y.as_mut_ptr(), size_of::<u16>() * SIZE);
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:42:38
+  --> tests/ui/size_of_in_element_count/functions.rs:48:38
    |
 LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u16>() * SIZE);
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     slice_from_raw_parts(y.as_ptr(), size_of::<u16>() * SIZE);
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:45:49
+  --> tests/ui/size_of_in_element_count/functions.rs:51:49
    |
 LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u16>() * SIZE) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     unsafe { from_raw_parts_mut(y.as_mut_ptr(), size_of::<u16>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:47:41
+  --> tests/ui/size_of_in_element_count/functions.rs:54:41
    |
 LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u16>() * SIZE) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^
@@ -105,7 +105,7 @@ LL |     unsafe { from_raw_parts(y.as_ptr(), size_of::<u16>() * SIZE) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:50:33
+  --> tests/ui/size_of_in_element_count/functions.rs:57:33
    |
 LL |     unsafe { y.as_mut_ptr().sub(size_of::<u16>()) };
    |                                 ^^^^^^^^^^^^^^^^
@@ -113,7 +113,7 @@ LL |     unsafe { y.as_mut_ptr().sub(size_of::<u16>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:52:29
+  --> tests/ui/size_of_in_element_count/functions.rs:60:29
    |
 LL |     y.as_ptr().wrapping_sub(size_of::<u16>());
    |                             ^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     y.as_ptr().wrapping_sub(size_of::<u16>());
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:54:29
+  --> tests/ui/size_of_in_element_count/functions.rs:63:29
    |
 LL |     unsafe { y.as_ptr().add(size_of::<u16>()) };
    |                             ^^^^^^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL |     unsafe { y.as_ptr().add(size_of::<u16>()) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:56:33
+  --> tests/ui/size_of_in_element_count/functions.rs:66:33
    |
 LL |     y.as_mut_ptr().wrapping_add(size_of::<u16>());
    |                                 ^^^^^^^^^^^^^^^^
@@ -137,7 +137,7 @@ LL |     y.as_mut_ptr().wrapping_add(size_of::<u16>());
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:58:32
+  --> tests/ui/size_of_in_element_count/functions.rs:69:32
    |
 LL |     unsafe { y.as_ptr().offset(size_of::<u16>() as isize) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL |     unsafe { y.as_ptr().offset(size_of::<u16>() as isize) };
    = help: use a count of elements instead of a count of bytes, it already gets multiplied by the size of the type
 
 error: found a count of bytes instead of a count of elements of `T`
-  --> tests/ui/size_of_in_element_count/functions.rs:60:36
+  --> tests/ui/size_of_in_element_count/functions.rs:72:36
    |
 LL |     y.as_mut_ptr().wrapping_offset(size_of::<u16>() as isize);
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/size_of_ref.rs b/src/tools/clippy/tests/ui/size_of_ref.rs
index 670c6c080eca..9a6a9419f681 100644
--- a/src/tools/clippy/tests/ui/size_of_ref.rs
+++ b/src/tools/clippy/tests/ui/size_of_ref.rs
@@ -11,9 +11,10 @@ fn main() {
     size_of_val(y); // no lint
 
     size_of_val(&&x);
-    //~^ ERROR: argument to `std::mem::size_of_val()` is a reference to a reference
+    //~^ size_of_ref
+
     size_of_val(&y);
-    //~^ ERROR: argument to `std::mem::size_of_val()` is a reference to a reference
+    //~^ size_of_ref
 }
 
 struct S {
@@ -25,6 +26,6 @@ impl S {
     /// Get size of object including `self`, in bytes.
     pub fn size(&self) -> usize {
         std::mem::size_of_val(&self) + (std::mem::size_of::<u8>() * self.data.capacity())
-        //~^ ERROR: argument to `std::mem::size_of_val()` is a reference to a reference
+        //~^ size_of_ref
     }
 }
diff --git a/src/tools/clippy/tests/ui/size_of_ref.stderr b/src/tools/clippy/tests/ui/size_of_ref.stderr
index bb8f08de531c..6ac0b0dd2f06 100644
--- a/src/tools/clippy/tests/ui/size_of_ref.stderr
+++ b/src/tools/clippy/tests/ui/size_of_ref.stderr
@@ -9,7 +9,7 @@ LL |     size_of_val(&&x);
    = help: to override `-D warnings` add `#[allow(clippy::size_of_ref)]`
 
 error: argument to `std::mem::size_of_val()` is a reference to a reference
-  --> tests/ui/size_of_ref.rs:15:5
+  --> tests/ui/size_of_ref.rs:16:5
    |
 LL |     size_of_val(&y);
    |     ^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     size_of_val(&y);
    = help: dereference the argument to `std::mem::size_of_val()` to get the size of the value instead of the size of the reference-type
 
 error: argument to `std::mem::size_of_val()` is a reference to a reference
-  --> tests/ui/size_of_ref.rs:27:9
+  --> tests/ui/size_of_ref.rs:28:9
    |
 LL |         std::mem::size_of_val(&self) + (std::mem::size_of::<u8>() * self.data.capacity())
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/skip_while_next.rs b/src/tools/clippy/tests/ui/skip_while_next.rs
index 8e4cd82cec30..96f4604ad42d 100644
--- a/src/tools/clippy/tests/ui/skip_while_next.rs
+++ b/src/tools/clippy/tests/ui/skip_while_next.rs
@@ -12,9 +12,11 @@ fn skip_while_next() {
 
     // Single-line case.
     let _ = v.iter().skip_while(|&x| *x < 0).next();
+    //~^ skip_while_next
 
     // Multi-line case.
     let _ = v.iter().skip_while(|&x| {
+    //~^ skip_while_next
                                 *x < 0
                             }
                    ).next();
diff --git a/src/tools/clippy/tests/ui/skip_while_next.stderr b/src/tools/clippy/tests/ui/skip_while_next.stderr
index 2c1b9eeba3b6..5db8b4bcb522 100644
--- a/src/tools/clippy/tests/ui/skip_while_next.stderr
+++ b/src/tools/clippy/tests/ui/skip_while_next.stderr
@@ -9,10 +9,11 @@ LL |     let _ = v.iter().skip_while(|&x| *x < 0).next();
    = help: to override `-D warnings` add `#[allow(clippy::skip_while_next)]`
 
 error: called `skip_while(<p>).next()` on an `Iterator`
-  --> tests/ui/skip_while_next.rs:17:13
+  --> tests/ui/skip_while_next.rs:18:13
    |
 LL |       let _ = v.iter().skip_while(|&x| {
    |  _____________^
+LL | |
 LL | |                                 *x < 0
 LL | |                             }
 LL | |                    ).next();
diff --git a/src/tools/clippy/tests/ui/sliced_string_as_bytes.fixed b/src/tools/clippy/tests/ui/sliced_string_as_bytes.fixed
index 469ad27a99b9..16c0daff78fd 100644
--- a/src/tools/clippy/tests/ui/sliced_string_as_bytes.fixed
+++ b/src/tools/clippy/tests/ui/sliced_string_as_bytes.fixed
@@ -26,8 +26,11 @@ fn main() {
     let string: String = "dolor sit amet".to_owned();
 
     let bytes = &s.as_bytes()[1..5];
+    //~^ sliced_string_as_bytes
     let bytes = &string.as_bytes()[1..];
+    //~^ sliced_string_as_bytes
     let bytes = &"consectetur adipiscing".as_bytes()[..=5];
+    //~^ sliced_string_as_bytes
 
     let f = Foo;
     let bytes = f[0..4].as_bytes();
diff --git a/src/tools/clippy/tests/ui/sliced_string_as_bytes.rs b/src/tools/clippy/tests/ui/sliced_string_as_bytes.rs
index 4a4605e5a1ae..67985ae5b984 100644
--- a/src/tools/clippy/tests/ui/sliced_string_as_bytes.rs
+++ b/src/tools/clippy/tests/ui/sliced_string_as_bytes.rs
@@ -26,8 +26,11 @@ fn main() {
     let string: String = "dolor sit amet".to_owned();
 
     let bytes = s[1..5].as_bytes();
+    //~^ sliced_string_as_bytes
     let bytes = string[1..].as_bytes();
+    //~^ sliced_string_as_bytes
     let bytes = "consectetur adipiscing"[..=5].as_bytes();
+    //~^ sliced_string_as_bytes
 
     let f = Foo;
     let bytes = f[0..4].as_bytes();
diff --git a/src/tools/clippy/tests/ui/sliced_string_as_bytes.stderr b/src/tools/clippy/tests/ui/sliced_string_as_bytes.stderr
index 1342f4c01a48..ae7f02781f4b 100644
--- a/src/tools/clippy/tests/ui/sliced_string_as_bytes.stderr
+++ b/src/tools/clippy/tests/ui/sliced_string_as_bytes.stderr
@@ -8,13 +8,13 @@ LL |     let bytes = s[1..5].as_bytes();
    = help: to override `-D warnings` add `#[allow(clippy::sliced_string_as_bytes)]`
 
 error: calling `as_bytes` after slicing a string
-  --> tests/ui/sliced_string_as_bytes.rs:29:17
+  --> tests/ui/sliced_string_as_bytes.rs:30:17
    |
 LL |     let bytes = string[1..].as_bytes();
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&string.as_bytes()[1..]`
 
 error: calling `as_bytes` after slicing a string
-  --> tests/ui/sliced_string_as_bytes.rs:30:17
+  --> tests/ui/sliced_string_as_bytes.rs:32:17
    |
 LL |     let bytes = "consectetur adipiscing"[..=5].as_bytes();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&"consectetur adipiscing".as_bytes()[..=5]`
diff --git a/src/tools/clippy/tests/ui/slow_vector_initialization.rs b/src/tools/clippy/tests/ui/slow_vector_initialization.rs
index 4b30fad409e3..52f2a52fbbb8 100644
--- a/src/tools/clippy/tests/ui/slow_vector_initialization.rs
+++ b/src/tools/clippy/tests/ui/slow_vector_initialization.rs
@@ -12,13 +12,14 @@ fn extend_vector() {
     // Extend with constant expression
     let len = 300;
     let mut vec1 = Vec::with_capacity(len);
-    //~^ ERROR: slow zero-filling initialization
-    //~| NOTE: `-D clippy::slow-vector-initialization` implied by `-D warnings`
+    //~^ slow_vector_initialization
+
     vec1.extend(repeat(0).take(len));
 
     // Extend with len expression
     let mut vec2 = Vec::with_capacity(len - 10);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec2.extend(repeat(0).take(len - 10));
 
     // Extend with mismatching expression should not be warned
@@ -26,7 +27,8 @@ fn extend_vector() {
     vec3.extend(repeat(0).take(2));
 
     let mut vec4 = Vec::with_capacity(len);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec4.extend(repeat(0).take(vec4.capacity()));
 }
 
@@ -37,11 +39,13 @@ fn mixed_extend_resize_vector() {
 
     // Slow initialization
     let mut resized_vec = Vec::with_capacity(30);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     resized_vec.resize(30, 0);
 
     let mut extend_vec = Vec::with_capacity(30);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     extend_vec.extend(repeat(0).take(30));
 }
 
@@ -49,7 +53,8 @@ fn resize_vector() {
     // Resize with constant expression
     let len = 300;
     let mut vec1 = Vec::with_capacity(len);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec1.resize(len, 0);
 
     // Resize mismatch len
@@ -58,16 +63,19 @@ fn resize_vector() {
 
     // Resize with len expression
     let mut vec3 = Vec::with_capacity(len - 10);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec3.resize(len - 10, 0);
 
     let mut vec4 = Vec::with_capacity(len);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec4.resize(vec4.capacity(), 0);
 
     // Reinitialization should be warned
     vec1 = Vec::with_capacity(10);
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec1.resize(10, 0);
 }
 
@@ -75,21 +83,25 @@ fn from_empty_vec() {
     // Resize with constant expression
     let len = 300;
     let mut vec1 = Vec::new();
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec1.resize(len, 0);
 
     // Resize with len expression
     let mut vec3 = Vec::new();
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec3.resize(len - 10, 0);
 
     // Reinitialization should be warned
     vec1 = Vec::new();
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec1.resize(10, 0);
 
     vec1 = vec![];
-    //~^ ERROR: slow zero-filling initialization
+    //~^ slow_vector_initialization
+
     vec1.resize(10, 0);
 
     macro_rules! x {
diff --git a/src/tools/clippy/tests/ui/slow_vector_initialization.stderr b/src/tools/clippy/tests/ui/slow_vector_initialization.stderr
index 4a25cafcddf2..e83eef826472 100644
--- a/src/tools/clippy/tests/ui/slow_vector_initialization.stderr
+++ b/src/tools/clippy/tests/ui/slow_vector_initialization.stderr
@@ -15,106 +15,106 @@ error: slow zero-filling initialization
    |
 LL |       let mut vec2 = Vec::with_capacity(len - 10);
    |  ____________________^
-LL | |
+...  |
 LL | |     vec2.extend(repeat(0).take(len - 10));
    | |_________________________________________^ help: consider replacing this with: `vec![0; len - 10]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:28:20
+  --> tests/ui/slow_vector_initialization.rs:29:20
    |
 LL |       let mut vec4 = Vec::with_capacity(len);
    |  ____________________^
-LL | |
+...  |
 LL | |     vec4.extend(repeat(0).take(vec4.capacity()));
    | |________________________________________________^ help: consider replacing this with: `vec![0; len]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:39:27
+  --> tests/ui/slow_vector_initialization.rs:41:27
    |
 LL |       let mut resized_vec = Vec::with_capacity(30);
    |  ___________________________^
-LL | |
+...  |
 LL | |     resized_vec.resize(30, 0);
    | |_____________________________^ help: consider replacing this with: `vec![0; 30]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:43:26
+  --> tests/ui/slow_vector_initialization.rs:46:26
    |
 LL |       let mut extend_vec = Vec::with_capacity(30);
    |  __________________________^
-LL | |
+...  |
 LL | |     extend_vec.extend(repeat(0).take(30));
    | |_________________________________________^ help: consider replacing this with: `vec![0; 30]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:51:20
+  --> tests/ui/slow_vector_initialization.rs:55:20
    |
 LL |       let mut vec1 = Vec::with_capacity(len);
    |  ____________________^
-LL | |
+...  |
 LL | |     vec1.resize(len, 0);
    | |_______________________^ help: consider replacing this with: `vec![0; len]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:60:20
+  --> tests/ui/slow_vector_initialization.rs:65:20
    |
 LL |       let mut vec3 = Vec::with_capacity(len - 10);
    |  ____________________^
-LL | |
+...  |
 LL | |     vec3.resize(len - 10, 0);
    | |____________________________^ help: consider replacing this with: `vec![0; len - 10]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:64:20
+  --> tests/ui/slow_vector_initialization.rs:70:20
    |
 LL |       let mut vec4 = Vec::with_capacity(len);
    |  ____________________^
-LL | |
+...  |
 LL | |     vec4.resize(vec4.capacity(), 0);
    | |___________________________________^ help: consider replacing this with: `vec![0; len]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:69:12
+  --> tests/ui/slow_vector_initialization.rs:76:12
    |
 LL |       vec1 = Vec::with_capacity(10);
    |  ____________^
-LL | |
+...  |
 LL | |     vec1.resize(10, 0);
    | |______________________^ help: consider replacing this with: `vec![0; 10]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:77:20
+  --> tests/ui/slow_vector_initialization.rs:85:20
    |
 LL |       let mut vec1 = Vec::new();
    |  ____________________^
-LL | |
+...  |
 LL | |     vec1.resize(len, 0);
    | |_______________________^ help: consider replacing this with: `vec![0; len]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:82:20
+  --> tests/ui/slow_vector_initialization.rs:91:20
    |
 LL |       let mut vec3 = Vec::new();
    |  ____________________^
-LL | |
+...  |
 LL | |     vec3.resize(len - 10, 0);
    | |____________________________^ help: consider replacing this with: `vec![0; len - 10]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:87:12
+  --> tests/ui/slow_vector_initialization.rs:97:12
    |
 LL |       vec1 = Vec::new();
    |  ____________^
-LL | |
+...  |
 LL | |     vec1.resize(10, 0);
    | |______________________^ help: consider replacing this with: `vec![0; 10]`
 
 error: slow zero-filling initialization
-  --> tests/ui/slow_vector_initialization.rs:91:12
+  --> tests/ui/slow_vector_initialization.rs:102:12
    |
 LL |       vec1 = vec![];
    |  ____________^
-LL | |
+...  |
 LL | |     vec1.resize(10, 0);
    | |______________________^ help: consider replacing this with: `vec![0; 10]`
 
diff --git a/src/tools/clippy/tests/ui/stable_sort_primitive.fixed b/src/tools/clippy/tests/ui/stable_sort_primitive.fixed
index 97f3a92238d2..b4870ebad2b3 100644
--- a/src/tools/clippy/tests/ui/stable_sort_primitive.fixed
+++ b/src/tools/clippy/tests/ui/stable_sort_primitive.fixed
@@ -5,18 +5,25 @@ fn main() {
     // positive examples
     let mut vec = vec![1, 3, 2];
     vec.sort_unstable();
+    //~^ stable_sort_primitive
     let mut vec = vec![false, false, true];
     vec.sort_unstable();
+    //~^ stable_sort_primitive
     let mut vec = vec!['a', 'A', 'c'];
     vec.sort_unstable();
+    //~^ stable_sort_primitive
     let mut vec = vec!["ab", "cd", "ab", "bc"];
     vec.sort_unstable();
+    //~^ stable_sort_primitive
     let mut vec = vec![(2, 1), (1, 2), (2, 5)];
     vec.sort_unstable();
+    //~^ stable_sort_primitive
     let mut vec = vec![[2, 1], [1, 2], [2, 5]];
     vec.sort_unstable();
+    //~^ stable_sort_primitive
     let mut arr = [1, 3, 2];
     arr.sort_unstable();
+    //~^ stable_sort_primitive
     // Negative examples: behavior changes if made unstable
     let mut vec = vec![1, 3, 2];
     vec.sort_by_key(|i| i / 2);
diff --git a/src/tools/clippy/tests/ui/stable_sort_primitive.rs b/src/tools/clippy/tests/ui/stable_sort_primitive.rs
index 26e3d8e74f71..b3fe64efd620 100644
--- a/src/tools/clippy/tests/ui/stable_sort_primitive.rs
+++ b/src/tools/clippy/tests/ui/stable_sort_primitive.rs
@@ -5,18 +5,25 @@ fn main() {
     // positive examples
     let mut vec = vec![1, 3, 2];
     vec.sort();
+    //~^ stable_sort_primitive
     let mut vec = vec![false, false, true];
     vec.sort();
+    //~^ stable_sort_primitive
     let mut vec = vec!['a', 'A', 'c'];
     vec.sort();
+    //~^ stable_sort_primitive
     let mut vec = vec!["ab", "cd", "ab", "bc"];
     vec.sort();
+    //~^ stable_sort_primitive
     let mut vec = vec![(2, 1), (1, 2), (2, 5)];
     vec.sort();
+    //~^ stable_sort_primitive
     let mut vec = vec![[2, 1], [1, 2], [2, 5]];
     vec.sort();
+    //~^ stable_sort_primitive
     let mut arr = [1, 3, 2];
     arr.sort();
+    //~^ stable_sort_primitive
     // Negative examples: behavior changes if made unstable
     let mut vec = vec![1, 3, 2];
     vec.sort_by_key(|i| i / 2);
diff --git a/src/tools/clippy/tests/ui/stable_sort_primitive.stderr b/src/tools/clippy/tests/ui/stable_sort_primitive.stderr
index 66bd4c79bb28..00b45030139a 100644
--- a/src/tools/clippy/tests/ui/stable_sort_primitive.stderr
+++ b/src/tools/clippy/tests/ui/stable_sort_primitive.stderr
@@ -9,7 +9,7 @@ LL |     vec.sort();
    = help: to override `-D warnings` add `#[allow(clippy::stable_sort_primitive)]`
 
 error: used `sort` on primitive type `bool`
-  --> tests/ui/stable_sort_primitive.rs:9:5
+  --> tests/ui/stable_sort_primitive.rs:10:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
@@ -17,14 +17,6 @@ LL |     vec.sort();
    = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `char`
-  --> tests/ui/stable_sort_primitive.rs:11:5
-   |
-LL |     vec.sort();
-   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
-   |
-   = note: an unstable sort typically performs faster without any observable difference for this data type
-
-error: used `sort` on primitive type `str`
   --> tests/ui/stable_sort_primitive.rs:13:5
    |
 LL |     vec.sort();
@@ -32,8 +24,16 @@ LL |     vec.sort();
    |
    = note: an unstable sort typically performs faster without any observable difference for this data type
 
+error: used `sort` on primitive type `str`
+  --> tests/ui/stable_sort_primitive.rs:16:5
+   |
+LL |     vec.sort();
+   |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
+   |
+   = note: an unstable sort typically performs faster without any observable difference for this data type
+
 error: used `sort` on primitive type `tuple`
-  --> tests/ui/stable_sort_primitive.rs:15:5
+  --> tests/ui/stable_sort_primitive.rs:19:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
@@ -41,7 +41,7 @@ LL |     vec.sort();
    = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `array`
-  --> tests/ui/stable_sort_primitive.rs:17:5
+  --> tests/ui/stable_sort_primitive.rs:22:5
    |
 LL |     vec.sort();
    |     ^^^^^^^^^^ help: try: `vec.sort_unstable()`
@@ -49,7 +49,7 @@ LL |     vec.sort();
    = note: an unstable sort typically performs faster without any observable difference for this data type
 
 error: used `sort` on primitive type `i32`
-  --> tests/ui/stable_sort_primitive.rs:19:5
+  --> tests/ui/stable_sort_primitive.rs:25:5
    |
 LL |     arr.sort();
    |     ^^^^^^^^^^ help: try: `arr.sort_unstable()`
diff --git a/src/tools/clippy/tests/ui/starts_ends_with.fixed b/src/tools/clippy/tests/ui/starts_ends_with.fixed
index 252b6e5a98c0..b4f9d5867703 100644
--- a/src/tools/clippy/tests/ui/starts_ends_with.fixed
+++ b/src/tools/clippy/tests/ui/starts_ends_with.fixed
@@ -5,36 +5,46 @@ fn main() {}
 #[allow(clippy::unnecessary_operation)]
 fn starts_with() {
     "".starts_with(' ');
+    //~^ chars_next_cmp
     !"".starts_with(' ');
+    //~^ chars_next_cmp
 
     // Ensure that suggestion is escaped correctly
     "".starts_with('\n');
+    //~^ chars_next_cmp
     !"".starts_with('\n');
+    //~^ chars_next_cmp
 }
 
 fn chars_cmp_with_unwrap() {
     let s = String::from("foo");
     if s.starts_with('f') {
+        //~^ chars_next_cmp
         // s.starts_with('f')
         // Nothing here
     }
     if s.ends_with('o') {
+        //~^ chars_last_cmp
         // s.ends_with('o')
         // Nothing here
     }
     if s.ends_with('o') {
+        //~^ chars_last_cmp
         // s.ends_with('o')
         // Nothing here
     }
     if !s.starts_with('f') {
+        //~^ chars_next_cmp
         // !s.starts_with('f')
         // Nothing here
     }
     if !s.ends_with('o') {
+        //~^ chars_last_cmp
         // !s.ends_with('o')
         // Nothing here
     }
     if !s.ends_with('\n') {
+        //~^ chars_last_cmp
         // !s.ends_with('o')
         // Nothing here
     }
@@ -43,11 +53,17 @@ fn chars_cmp_with_unwrap() {
 #[allow(clippy::unnecessary_operation)]
 fn ends_with() {
     "".ends_with(' ');
+    //~^ chars_last_cmp
     !"".ends_with(' ');
+    //~^ chars_last_cmp
     "".ends_with(' ');
+    //~^ chars_last_cmp
     !"".ends_with(' ');
+    //~^ chars_last_cmp
 
     // Ensure that suggestion is escaped correctly
     "".ends_with('\n');
+    //~^ chars_last_cmp
     !"".ends_with('\n');
+    //~^ chars_last_cmp
 }
diff --git a/src/tools/clippy/tests/ui/starts_ends_with.rs b/src/tools/clippy/tests/ui/starts_ends_with.rs
index 6c5655f31782..dae04ac4a62d 100644
--- a/src/tools/clippy/tests/ui/starts_ends_with.rs
+++ b/src/tools/clippy/tests/ui/starts_ends_with.rs
@@ -5,36 +5,46 @@ fn main() {}
 #[allow(clippy::unnecessary_operation)]
 fn starts_with() {
     "".chars().next() == Some(' ');
+    //~^ chars_next_cmp
     Some(' ') != "".chars().next();
+    //~^ chars_next_cmp
 
     // Ensure that suggestion is escaped correctly
     "".chars().next() == Some('\n');
+    //~^ chars_next_cmp
     Some('\n') != "".chars().next();
+    //~^ chars_next_cmp
 }
 
 fn chars_cmp_with_unwrap() {
     let s = String::from("foo");
     if s.chars().next().unwrap() == 'f' {
+        //~^ chars_next_cmp
         // s.starts_with('f')
         // Nothing here
     }
     if s.chars().next_back().unwrap() == 'o' {
+        //~^ chars_last_cmp
         // s.ends_with('o')
         // Nothing here
     }
     if s.chars().last().unwrap() == 'o' {
+        //~^ chars_last_cmp
         // s.ends_with('o')
         // Nothing here
     }
     if s.chars().next().unwrap() != 'f' {
+        //~^ chars_next_cmp
         // !s.starts_with('f')
         // Nothing here
     }
     if s.chars().next_back().unwrap() != 'o' {
+        //~^ chars_last_cmp
         // !s.ends_with('o')
         // Nothing here
     }
     if s.chars().last().unwrap() != '\n' {
+        //~^ chars_last_cmp
         // !s.ends_with('o')
         // Nothing here
     }
@@ -43,11 +53,17 @@ fn chars_cmp_with_unwrap() {
 #[allow(clippy::unnecessary_operation)]
 fn ends_with() {
     "".chars().last() == Some(' ');
+    //~^ chars_last_cmp
     Some(' ') != "".chars().last();
+    //~^ chars_last_cmp
     "".chars().next_back() == Some(' ');
+    //~^ chars_last_cmp
     Some(' ') != "".chars().next_back();
+    //~^ chars_last_cmp
 
     // Ensure that suggestion is escaped correctly
     "".chars().last() == Some('\n');
+    //~^ chars_last_cmp
     Some('\n') != "".chars().last();
+    //~^ chars_last_cmp
 }
diff --git a/src/tools/clippy/tests/ui/starts_ends_with.stderr b/src/tools/clippy/tests/ui/starts_ends_with.stderr
index cee31f1e4cdd..bcb38f2beb7b 100644
--- a/src/tools/clippy/tests/ui/starts_ends_with.stderr
+++ b/src/tools/clippy/tests/ui/starts_ends_with.stderr
@@ -8,31 +8,31 @@ LL |     "".chars().next() == Some(' ');
    = help: to override `-D warnings` add `#[allow(clippy::chars_next_cmp)]`
 
 error: you should use the `starts_with` method
-  --> tests/ui/starts_ends_with.rs:8:5
+  --> tests/ui/starts_ends_with.rs:9:5
    |
 LL |     Some(' ') != "".chars().next();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".starts_with(' ')`
 
 error: you should use the `starts_with` method
-  --> tests/ui/starts_ends_with.rs:11:5
+  --> tests/ui/starts_ends_with.rs:13:5
    |
 LL |     "".chars().next() == Some('\n');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".starts_with('\n')`
 
 error: you should use the `starts_with` method
-  --> tests/ui/starts_ends_with.rs:12:5
+  --> tests/ui/starts_ends_with.rs:15:5
    |
 LL |     Some('\n') != "".chars().next();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".starts_with('\n')`
 
 error: you should use the `starts_with` method
-  --> tests/ui/starts_ends_with.rs:17:8
+  --> tests/ui/starts_ends_with.rs:21:8
    |
 LL |     if s.chars().next().unwrap() == 'f' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.starts_with('f')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:21:8
+  --> tests/ui/starts_ends_with.rs:26:8
    |
 LL |     if s.chars().next_back().unwrap() == 'o' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.ends_with('o')`
@@ -41,61 +41,61 @@ LL |     if s.chars().next_back().unwrap() == 'o' {
    = help: to override `-D warnings` add `#[allow(clippy::chars_last_cmp)]`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:25:8
+  --> tests/ui/starts_ends_with.rs:31:8
    |
 LL |     if s.chars().last().unwrap() == 'o' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `s.ends_with('o')`
 
 error: you should use the `starts_with` method
-  --> tests/ui/starts_ends_with.rs:29:8
+  --> tests/ui/starts_ends_with.rs:36:8
    |
 LL |     if s.chars().next().unwrap() != 'f' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.starts_with('f')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:33:8
+  --> tests/ui/starts_ends_with.rs:41:8
    |
 LL |     if s.chars().next_back().unwrap() != 'o' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('o')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:37:8
+  --> tests/ui/starts_ends_with.rs:46:8
    |
 LL |     if s.chars().last().unwrap() != '\n' {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!s.ends_with('\n')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:45:5
+  --> tests/ui/starts_ends_with.rs:55:5
    |
 LL |     "".chars().last() == Some(' ');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with(' ')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:46:5
+  --> tests/ui/starts_ends_with.rs:57:5
    |
 LL |     Some(' ') != "".chars().last();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with(' ')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:47:5
+  --> tests/ui/starts_ends_with.rs:59:5
    |
 LL |     "".chars().next_back() == Some(' ');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with(' ')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:48:5
+  --> tests/ui/starts_ends_with.rs:61:5
    |
 LL |     Some(' ') != "".chars().next_back();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with(' ')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:51:5
+  --> tests/ui/starts_ends_with.rs:65:5
    |
 LL |     "".chars().last() == Some('\n');
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `"".ends_with('\n')`
 
 error: you should use the `ends_with` method
-  --> tests/ui/starts_ends_with.rs:52:5
+  --> tests/ui/starts_ends_with.rs:67:5
    |
 LL |     Some('\n') != "".chars().last();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: like this: `!"".ends_with('\n')`
diff --git a/src/tools/clippy/tests/ui/std_instead_of_core.fixed b/src/tools/clippy/tests/ui/std_instead_of_core.fixed
index ec158ee02de8..ab2e801eee25 100644
--- a/src/tools/clippy/tests/ui/std_instead_of_core.fixed
+++ b/src/tools/clippy/tests/ui/std_instead_of_core.fixed
@@ -89,3 +89,4 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: core::net::IpAddr) {}
+//~^ std_instead_of_core
diff --git a/src/tools/clippy/tests/ui/std_instead_of_core.rs b/src/tools/clippy/tests/ui/std_instead_of_core.rs
index 9c3c1658d8fe..f760b3561aed 100644
--- a/src/tools/clippy/tests/ui/std_instead_of_core.rs
+++ b/src/tools/clippy/tests/ui/std_instead_of_core.rs
@@ -89,3 +89,4 @@ fn msrv_1_76(_: std::net::IpAddr) {}
 
 #[clippy::msrv = "1.77"]
 fn msrv_1_77(_: std::net::IpAddr) {}
+//~^ std_instead_of_core
diff --git a/src/tools/clippy/tests/ui/str_split.fixed b/src/tools/clippy/tests/ui/str_split.fixed
index 57a3c315a877..6aca5051c570 100644
--- a/src/tools/clippy/tests/ui/str_split.fixed
+++ b/src/tools/clippy/tests/ui/str_split.fixed
@@ -58,25 +58,35 @@ fn main() {
 
     // Splitting a `str` variable at "\n" or "\r\n" after trimming should warn
     let _ = s1.lines();
+    //~^ str_split_at_newline
     #[allow(clippy::single_char_pattern)]
     let _ = s1.lines();
+    //~^ str_split_at_newline
     let _ = s1.lines();
+    //~^ str_split_at_newline
 
     // Splitting a `String` variable at "\n" or "\r\n" after trimming should warn
     let _ = s2.lines();
+    //~^ str_split_at_newline
     #[allow(clippy::single_char_pattern)]
     let _ = s2.lines();
+    //~^ str_split_at_newline
     let _ = s2.lines();
+    //~^ str_split_at_newline
 
     // Splitting a variable that derefs into `str` at "\n" or "\r\n" after trimming should warn.
     let s3 = DerefsIntoStr { s: s1 };
     let _ = s3.lines();
+    //~^ str_split_at_newline
     #[allow(clippy::single_char_pattern)]
     let _ = s3.lines();
+    //~^ str_split_at_newline
     let _ = s3.lines();
+    //~^ str_split_at_newline
 
     // If the `&str` is generated by a macro then the macro should not be expanded in the suggested fix.
     let _ = make_str!(s1).lines();
+    //~^ str_split_at_newline
 
     // CASES THAT SHOULD NOT EMIT A LINT
 
diff --git a/src/tools/clippy/tests/ui/str_split.rs b/src/tools/clippy/tests/ui/str_split.rs
index fcff036f2649..11e9862da14b 100644
--- a/src/tools/clippy/tests/ui/str_split.rs
+++ b/src/tools/clippy/tests/ui/str_split.rs
@@ -58,25 +58,35 @@ fn main() {
 
     // Splitting a `str` variable at "\n" or "\r\n" after trimming should warn
     let _ = s1.trim().split('\n');
+    //~^ str_split_at_newline
     #[allow(clippy::single_char_pattern)]
     let _ = s1.trim().split("\n");
+    //~^ str_split_at_newline
     let _ = s1.trim().split("\r\n");
+    //~^ str_split_at_newline
 
     // Splitting a `String` variable at "\n" or "\r\n" after trimming should warn
     let _ = s2.trim().split('\n');
+    //~^ str_split_at_newline
     #[allow(clippy::single_char_pattern)]
     let _ = s2.trim().split("\n");
+    //~^ str_split_at_newline
     let _ = s2.trim().split("\r\n");
+    //~^ str_split_at_newline
 
     // Splitting a variable that derefs into `str` at "\n" or "\r\n" after trimming should warn.
     let s3 = DerefsIntoStr { s: s1 };
     let _ = s3.trim().split('\n');
+    //~^ str_split_at_newline
     #[allow(clippy::single_char_pattern)]
     let _ = s3.trim().split("\n");
+    //~^ str_split_at_newline
     let _ = s3.trim().split("\r\n");
+    //~^ str_split_at_newline
 
     // If the `&str` is generated by a macro then the macro should not be expanded in the suggested fix.
     let _ = make_str!(s1).trim().split('\n');
+    //~^ str_split_at_newline
 
     // CASES THAT SHOULD NOT EMIT A LINT
 
diff --git a/src/tools/clippy/tests/ui/str_split.stderr b/src/tools/clippy/tests/ui/str_split.stderr
index 7b560468f126..c4eca81004c5 100644
--- a/src/tools/clippy/tests/ui/str_split.stderr
+++ b/src/tools/clippy/tests/ui/str_split.stderr
@@ -8,55 +8,55 @@ LL |     let _ = s1.trim().split('\n');
    = help: to override `-D warnings` add `#[allow(clippy::str_split_at_newline)]`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:62:13
+  --> tests/ui/str_split.rs:63:13
    |
 LL |     let _ = s1.trim().split("\n");
    |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s1.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:63:13
+  --> tests/ui/str_split.rs:65:13
    |
 LL |     let _ = s1.trim().split("\r\n");
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s1.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:66:13
+  --> tests/ui/str_split.rs:69:13
    |
 LL |     let _ = s2.trim().split('\n');
    |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s2.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:68:13
+  --> tests/ui/str_split.rs:72:13
    |
 LL |     let _ = s2.trim().split("\n");
    |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s2.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:69:13
+  --> tests/ui/str_split.rs:74:13
    |
 LL |     let _ = s2.trim().split("\r\n");
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s2.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:73:13
+  --> tests/ui/str_split.rs:79:13
    |
 LL |     let _ = s3.trim().split('\n');
    |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s3.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:75:13
+  --> tests/ui/str_split.rs:82:13
    |
 LL |     let _ = s3.trim().split("\n");
    |             ^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s3.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:76:13
+  --> tests/ui/str_split.rs:84:13
    |
 LL |     let _ = s3.trim().split("\r\n");
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `s3.lines()`
 
 error: using `str.trim().split()` with hard-coded newlines
-  --> tests/ui/str_split.rs:79:13
+  --> tests/ui/str_split.rs:88:13
    |
 LL |     let _ = make_str!(s1).trim().split('\n');
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use `str.lines()` instead: `make_str!(s1).lines()`
diff --git a/src/tools/clippy/tests/ui/str_to_string.fixed b/src/tools/clippy/tests/ui/str_to_string.fixed
index 52e40b45a8bd..2941c4dbd33d 100644
--- a/src/tools/clippy/tests/ui/str_to_string.fixed
+++ b/src/tools/clippy/tests/ui/str_to_string.fixed
@@ -2,8 +2,9 @@
 
 fn main() {
     let hello = "hello world".to_owned();
-    //~^ ERROR: `to_string()` called on a `&str`
+    //~^ str_to_string
+
     let msg = &hello[..];
     msg.to_owned();
-    //~^ ERROR: `to_string()` called on a `&str`
+    //~^ str_to_string
 }
diff --git a/src/tools/clippy/tests/ui/str_to_string.rs b/src/tools/clippy/tests/ui/str_to_string.rs
index f93b289c29ab..4c4d2bb18062 100644
--- a/src/tools/clippy/tests/ui/str_to_string.rs
+++ b/src/tools/clippy/tests/ui/str_to_string.rs
@@ -2,8 +2,9 @@
 
 fn main() {
     let hello = "hello world".to_string();
-    //~^ ERROR: `to_string()` called on a `&str`
+    //~^ str_to_string
+
     let msg = &hello[..];
     msg.to_string();
-    //~^ ERROR: `to_string()` called on a `&str`
+    //~^ str_to_string
 }
diff --git a/src/tools/clippy/tests/ui/str_to_string.stderr b/src/tools/clippy/tests/ui/str_to_string.stderr
index a761d96cd6b1..cb7b6b48843a 100644
--- a/src/tools/clippy/tests/ui/str_to_string.stderr
+++ b/src/tools/clippy/tests/ui/str_to_string.stderr
@@ -8,7 +8,7 @@ LL |     let hello = "hello world".to_string();
    = help: to override `-D warnings` add `#[allow(clippy::str_to_string)]`
 
 error: `to_string()` called on a `&str`
-  --> tests/ui/str_to_string.rs:7:5
+  --> tests/ui/str_to_string.rs:8:5
    |
 LL |     msg.to_string();
    |     ^^^^^^^^^^^^^^^ help: try: `msg.to_owned()`
diff --git a/src/tools/clippy/tests/ui/string_add.rs b/src/tools/clippy/tests/ui/string_add.rs
index c535f2ebbfcb..5c7d13ebcd58 100644
--- a/src/tools/clippy/tests/ui/string_add.rs
+++ b/src/tools/clippy/tests/ui/string_add.rs
@@ -4,17 +4,19 @@ extern crate proc_macros;
 use proc_macros::external;
 
 #[warn(clippy::string_add)]
-#[allow(clippy::string_add_assign, unused)]
+#[allow(clippy::assign_op_pattern, clippy::string_add_assign, unused)]
 fn main() {
     // ignores assignment distinction
     let mut x = String::new();
 
     for _ in 1..3 {
         x = x + ".";
+        //~^ string_add
     }
 
     let y = String::new();
     let z = y + "...";
+    //~^ string_add
 
     assert_eq!(&x, &z);
 
diff --git a/src/tools/clippy/tests/ui/string_add.stderr b/src/tools/clippy/tests/ui/string_add.stderr
index fe6849b894b5..084a439410f8 100644
--- a/src/tools/clippy/tests/ui/string_add.stderr
+++ b/src/tools/clippy/tests/ui/string_add.stderr
@@ -1,12 +1,3 @@
-error: manual implementation of an assign operation
-  --> tests/ui/string_add.rs:13:9
-   |
-LL |         x = x + ".";
-   |         ^^^^^^^^^^^ help: replace it with: `x += "."`
-   |
-   = note: `-D clippy::assign-op-pattern` implied by `-D warnings`
-   = help: to override `-D warnings` add `#[allow(clippy::assign_op_pattern)]`
-
 error: you added something to a string. Consider using `String::push_str()` instead
   --> tests/ui/string_add.rs:13:13
    |
@@ -17,16 +8,10 @@ LL |         x = x + ".";
    = help: to override `-D warnings` add `#[allow(clippy::string_add)]`
 
 error: you added something to a string. Consider using `String::push_str()` instead
-  --> tests/ui/string_add.rs:17:13
+  --> tests/ui/string_add.rs:18:13
    |
 LL |     let z = y + "...";
    |             ^^^^^^^^^
 
-error: manual implementation of an assign operation
-  --> tests/ui/string_add.rs:22:5
-   |
-LL |     x = x + 1;
-   |     ^^^^^^^^^ help: replace it with: `x += 1`
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
diff --git a/src/tools/clippy/tests/ui/string_add_assign.fixed b/src/tools/clippy/tests/ui/string_add_assign.fixed
index 31d84831d09a..a86a304684f2 100644
--- a/src/tools/clippy/tests/ui/string_add_assign.fixed
+++ b/src/tools/clippy/tests/ui/string_add_assign.fixed
@@ -6,6 +6,8 @@ fn main() {
 
     for _ in 1..3 {
         x += ".";
+        //~^ string_add_assign
+        //~| assign_op_pattern
     }
 
     let y = String::new();
@@ -15,5 +17,6 @@ fn main() {
 
     let mut x = 1;
     x += 1;
+    //~^ assign_op_pattern
     assert_eq!(2, x);
 }
diff --git a/src/tools/clippy/tests/ui/string_add_assign.rs b/src/tools/clippy/tests/ui/string_add_assign.rs
index cdea91573cc7..042e33cf8413 100644
--- a/src/tools/clippy/tests/ui/string_add_assign.rs
+++ b/src/tools/clippy/tests/ui/string_add_assign.rs
@@ -6,6 +6,8 @@ fn main() {
 
     for _ in 1..3 {
         x = x + ".";
+        //~^ string_add_assign
+        //~| assign_op_pattern
     }
 
     let y = String::new();
@@ -15,5 +17,6 @@ fn main() {
 
     let mut x = 1;
     x = x + 1;
+    //~^ assign_op_pattern
     assert_eq!(2, x);
 }
diff --git a/src/tools/clippy/tests/ui/string_add_assign.stderr b/src/tools/clippy/tests/ui/string_add_assign.stderr
index 50f970084e6b..198772747927 100644
--- a/src/tools/clippy/tests/ui/string_add_assign.stderr
+++ b/src/tools/clippy/tests/ui/string_add_assign.stderr
@@ -17,7 +17,7 @@ LL |         x = x + ".";
    = help: to override `-D warnings` add `#[allow(clippy::assign_op_pattern)]`
 
 error: manual implementation of an assign operation
-  --> tests/ui/string_add_assign.rs:17:5
+  --> tests/ui/string_add_assign.rs:19:5
    |
 LL |     x = x + 1;
    |     ^^^^^^^^^ help: replace it with: `x += 1`
diff --git a/src/tools/clippy/tests/ui/string_extend.fixed b/src/tools/clippy/tests/ui/string_extend.fixed
index 142cb6a34980..17d3d927830f 100644
--- a/src/tools/clippy/tests/ui/string_extend.fixed
+++ b/src/tools/clippy/tests/ui/string_extend.fixed
@@ -14,12 +14,15 @@ fn main() {
 
     s.push_str(abc);
     s.push_str(abc);
+    //~^ string_extend_chars
 
     s.push_str("abc");
     s.push_str("abc");
+    //~^ string_extend_chars
 
     s.push_str(&def);
     s.push_str(&def);
+    //~^ string_extend_chars
 
     s.extend(abc.chars().skip(1));
     s.extend("abc".chars().skip(1));
@@ -30,4 +33,5 @@ fn main() {
 
     // issue #9735
     s.push_str(&abc[0..2]);
+    //~^ string_extend_chars
 }
diff --git a/src/tools/clippy/tests/ui/string_extend.rs b/src/tools/clippy/tests/ui/string_extend.rs
index 41c0d29fae9c..e2d54f479439 100644
--- a/src/tools/clippy/tests/ui/string_extend.rs
+++ b/src/tools/clippy/tests/ui/string_extend.rs
@@ -14,12 +14,15 @@ fn main() {
 
     s.push_str(abc);
     s.extend(abc.chars());
+    //~^ string_extend_chars
 
     s.push_str("abc");
     s.extend("abc".chars());
+    //~^ string_extend_chars
 
     s.push_str(&def);
     s.extend(def.chars());
+    //~^ string_extend_chars
 
     s.extend(abc.chars().skip(1));
     s.extend("abc".chars().skip(1));
@@ -30,4 +33,5 @@ fn main() {
 
     // issue #9735
     s.extend(abc[0..2].chars());
+    //~^ string_extend_chars
 }
diff --git a/src/tools/clippy/tests/ui/string_extend.stderr b/src/tools/clippy/tests/ui/string_extend.stderr
index fadda786aacb..52aad5a02f6d 100644
--- a/src/tools/clippy/tests/ui/string_extend.stderr
+++ b/src/tools/clippy/tests/ui/string_extend.stderr
@@ -8,19 +8,19 @@ LL |     s.extend(abc.chars());
    = help: to override `-D warnings` add `#[allow(clippy::string_extend_chars)]`
 
 error: calling `.extend(_.chars())`
-  --> tests/ui/string_extend.rs:19:5
+  --> tests/ui/string_extend.rs:20:5
    |
 LL |     s.extend("abc".chars());
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.push_str("abc")`
 
 error: calling `.extend(_.chars())`
-  --> tests/ui/string_extend.rs:22:5
+  --> tests/ui/string_extend.rs:24:5
    |
 LL |     s.extend(def.chars());
    |     ^^^^^^^^^^^^^^^^^^^^^ help: try: `s.push_str(&def)`
 
 error: calling `.extend(_.chars())`
-  --> tests/ui/string_extend.rs:32:5
+  --> tests/ui/string_extend.rs:35:5
    |
 LL |     s.extend(abc[0..2].chars());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `s.push_str(&abc[0..2])`
diff --git a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed
index 6aa5a95c6f40..193217114d88 100644
--- a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed
+++ b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.fixed
@@ -2,4 +2,5 @@
 
 fn main() {
     let _ = Some(&"Hello World!"[6..11]);
+    //~^ string_from_utf8_as_bytes
 }
diff --git a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs
index c8717f7950bd..49beb19ee40f 100644
--- a/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs
+++ b/src/tools/clippy/tests/ui/string_from_utf8_as_bytes.rs
@@ -2,4 +2,5 @@
 
 fn main() {
     let _ = std::str::from_utf8(&"Hello World!".as_bytes()[6..11]);
+    //~^ string_from_utf8_as_bytes
 }
diff --git a/src/tools/clippy/tests/ui/string_lit_as_bytes.fixed b/src/tools/clippy/tests/ui/string_lit_as_bytes.fixed
index 225d4e90c4e2..2a86dffbc762 100644
--- a/src/tools/clippy/tests/ui/string_lit_as_bytes.fixed
+++ b/src/tools/clippy/tests/ui/string_lit_as_bytes.fixed
@@ -9,16 +9,21 @@ extern crate macro_rules;
 macro_rules! b {
     ($b:literal) => {
         const B: &[u8] = b"warning";
+        //~^ string_lit_as_bytes
     };
 }
 
 fn str_lit_as_bytes() {
     let bs = b"hello there";
+    //~^ string_lit_as_bytes
 
     let bs = br###"raw string with 3# plus " ""###;
+    //~^ string_lit_as_bytes
 
     let bs = b"lit to string".to_vec();
+    //~^ string_lit_as_bytes
     let bs = b"lit to owned".to_vec();
+    //~^ string_lit_as_bytes
 
     b!("warning");
 
@@ -36,8 +41,10 @@ fn str_lit_as_bytes() {
     let current_version = env!("CARGO_PKG_VERSION").as_bytes();
 
     let includestr = include_bytes!("string_lit_as_bytes.rs");
+    //~^ string_lit_as_bytes
 
     let _ = b"string with newline\t\n";
+    //~^ string_lit_as_bytes
 
     let _ = match "x".as_bytes() {
         b"xx" => 0,
diff --git a/src/tools/clippy/tests/ui/string_lit_as_bytes.rs b/src/tools/clippy/tests/ui/string_lit_as_bytes.rs
index 3d116214ca42..785d8f1e0f6b 100644
--- a/src/tools/clippy/tests/ui/string_lit_as_bytes.rs
+++ b/src/tools/clippy/tests/ui/string_lit_as_bytes.rs
@@ -9,16 +9,21 @@ extern crate macro_rules;
 macro_rules! b {
     ($b:literal) => {
         const B: &[u8] = $b.as_bytes();
+        //~^ string_lit_as_bytes
     };
 }
 
 fn str_lit_as_bytes() {
     let bs = "hello there".as_bytes();
+    //~^ string_lit_as_bytes
 
     let bs = r###"raw string with 3# plus " ""###.as_bytes();
+    //~^ string_lit_as_bytes
 
     let bs = "lit to string".to_string().into_bytes();
+    //~^ string_lit_as_bytes
     let bs = "lit to owned".to_owned().into_bytes();
+    //~^ string_lit_as_bytes
 
     b!("warning");
 
@@ -36,8 +41,10 @@ fn str_lit_as_bytes() {
     let current_version = env!("CARGO_PKG_VERSION").as_bytes();
 
     let includestr = include_str!("string_lit_as_bytes.rs").as_bytes();
+    //~^ string_lit_as_bytes
 
     let _ = "string with newline\t\n".as_bytes();
+    //~^ string_lit_as_bytes
 
     let _ = match "x".as_bytes() {
         b"xx" => 0,
diff --git a/src/tools/clippy/tests/ui/string_lit_as_bytes.stderr b/src/tools/clippy/tests/ui/string_lit_as_bytes.stderr
index 66b3e6f9462d..9388fbdc775d 100644
--- a/src/tools/clippy/tests/ui/string_lit_as_bytes.stderr
+++ b/src/tools/clippy/tests/ui/string_lit_as_bytes.stderr
@@ -1,5 +1,5 @@
 error: calling `as_bytes()` on a string literal
-  --> tests/ui/string_lit_as_bytes.rs:16:14
+  --> tests/ui/string_lit_as_bytes.rs:17:14
    |
 LL |     let bs = "hello there".as_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"hello there"`
@@ -8,19 +8,19 @@ LL |     let bs = "hello there".as_bytes();
    = help: to override `-D warnings` add `#[allow(clippy::string_lit_as_bytes)]`
 
 error: calling `as_bytes()` on a string literal
-  --> tests/ui/string_lit_as_bytes.rs:18:14
+  --> tests/ui/string_lit_as_bytes.rs:20:14
    |
 LL |     let bs = r###"raw string with 3# plus " ""###.as_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `br###"raw string with 3# plus " ""###`
 
 error: calling `into_bytes()` on a string literal
-  --> tests/ui/string_lit_as_bytes.rs:20:14
+  --> tests/ui/string_lit_as_bytes.rs:23:14
    |
 LL |     let bs = "lit to string".to_string().into_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to string".to_vec()`
 
 error: calling `into_bytes()` on a string literal
-  --> tests/ui/string_lit_as_bytes.rs:21:14
+  --> tests/ui/string_lit_as_bytes.rs:25:14
    |
 LL |     let bs = "lit to owned".to_owned().into_bytes();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"lit to owned".to_vec()`
@@ -37,13 +37,13 @@ LL |     b!("warning");
    = note: this error originates in the macro `b` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: calling `as_bytes()` on `include_str!(..)`
-  --> tests/ui/string_lit_as_bytes.rs:38:22
+  --> tests/ui/string_lit_as_bytes.rs:43:22
    |
 LL |     let includestr = include_str!("string_lit_as_bytes.rs").as_bytes();
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `include_bytes!(..)` instead: `include_bytes!("string_lit_as_bytes.rs")`
 
 error: calling `as_bytes()` on a string literal
-  --> tests/ui/string_lit_as_bytes.rs:40:13
+  --> tests/ui/string_lit_as_bytes.rs:46:13
    |
 LL |     let _ = "string with newline\t\n".as_bytes();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using a byte string literal instead: `b"string with newline\t\n"`
diff --git a/src/tools/clippy/tests/ui/string_lit_chars_any.fixed b/src/tools/clippy/tests/ui/string_lit_chars_any.fixed
index 03e20c16ee63..cf05a2c2e835 100644
--- a/src/tools/clippy/tests/ui/string_lit_chars_any.fixed
+++ b/src/tools/clippy/tests/ui/string_lit_chars_any.fixed
@@ -16,11 +16,16 @@ impl NotStringLit {
 fn main() {
     let c = 'c';
     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    //~^ string_lit_chars_any
     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    //~^ string_lit_chars_any
     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    //~^ string_lit_chars_any
     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    //~^ string_lit_chars_any
     #[rustfmt::skip]
     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']' | '{' | '}' | '^' | '$' | '#' | '&' | '-' | '~');
+    //~^ string_lit_chars_any
     // Do not lint
     NotStringLit.chars().any(|x| x == c);
     "\\.+*?()|[]{}^$#&-~".chars().any(|x| {
diff --git a/src/tools/clippy/tests/ui/string_lit_chars_any.rs b/src/tools/clippy/tests/ui/string_lit_chars_any.rs
index 12e6ffb6a9c4..22cfb784ed7d 100644
--- a/src/tools/clippy/tests/ui/string_lit_chars_any.rs
+++ b/src/tools/clippy/tests/ui/string_lit_chars_any.rs
@@ -16,11 +16,16 @@ impl NotStringLit {
 fn main() {
     let c = 'c';
     "\\.+*?()|[]{}^$#&-~".chars().any(|x| x == c);
+    //~^ string_lit_chars_any
     r#"\.+*?()|[]{}^$#&-~"#.chars().any(|x| x == c);
+    //~^ string_lit_chars_any
     "\\.+*?()|[]{}^$#&-~".chars().any(|x| c == x);
+    //~^ string_lit_chars_any
     r#"\.+*?()|[]{}^$#&-~"#.chars().any(|x| c == x);
+    //~^ string_lit_chars_any
     #[rustfmt::skip]
     "\\.+*?()|[]{}^$#&-~".chars().any(|x| { x == c });
+    //~^ string_lit_chars_any
     // Do not lint
     NotStringLit.chars().any(|x| x == c);
     "\\.+*?()|[]{}^$#&-~".chars().any(|x| {
diff --git a/src/tools/clippy/tests/ui/string_lit_chars_any.stderr b/src/tools/clippy/tests/ui/string_lit_chars_any.stderr
index 1e28ae7b163e..3ba447b3c36b 100644
--- a/src/tools/clippy/tests/ui/string_lit_chars_any.stderr
+++ b/src/tools/clippy/tests/ui/string_lit_chars_any.stderr
@@ -13,7 +13,7 @@ LL +     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']'
    |
 
 error: usage of `.chars().any(...)` to check if a char matches any from a string literal
-  --> tests/ui/string_lit_chars_any.rs:19:5
+  --> tests/ui/string_lit_chars_any.rs:20:5
    |
 LL |     r#"\.+*?()|[]{}^$#&-~"#.chars().any(|x| x == c);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']'
    |
 
 error: usage of `.chars().any(...)` to check if a char matches any from a string literal
-  --> tests/ui/string_lit_chars_any.rs:20:5
+  --> tests/ui/string_lit_chars_any.rs:22:5
    |
 LL |     "\\.+*?()|[]{}^$#&-~".chars().any(|x| c == x);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']'
    |
 
 error: usage of `.chars().any(...)` to check if a char matches any from a string literal
-  --> tests/ui/string_lit_chars_any.rs:21:5
+  --> tests/ui/string_lit_chars_any.rs:24:5
    |
 LL |     r#"\.+*?()|[]{}^$#&-~"#.chars().any(|x| c == x);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     matches!(c, '\\' | '.' | '+' | '*' | '?' | '(' | ')' | '|' | '[' | ']'
    |
 
 error: usage of `.chars().any(...)` to check if a char matches any from a string literal
-  --> tests/ui/string_lit_chars_any.rs:23:5
+  --> tests/ui/string_lit_chars_any.rs:27:5
    |
 LL |     "\\.+*?()|[]{}^$#&-~".chars().any(|x| { x == c });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/string_slice.rs b/src/tools/clippy/tests/ui/string_slice.rs
index dc519493a4dd..0acc48c1f412 100644
--- a/src/tools/clippy/tests/ui/string_slice.rs
+++ b/src/tools/clippy/tests/ui/string_slice.rs
@@ -5,15 +5,17 @@ use std::borrow::Cow;
 
 fn main() {
     &"Ölkanne"[1..];
-    //~^ ERROR: indexing into a string may panic if the index is within a UTF-8 character
-    //~| NOTE: `-D clippy::string-slice` implied by `-D warnings`
+    //~^ string_slice
+
     let m = "Mötörhead";
     &m[2..5];
-    //~^ ERROR: indexing into a string may panic if the index is within a UTF-8 character
+    //~^ string_slice
+
     let s = String::from(m);
     &s[0..2];
-    //~^ ERROR: indexing into a string may panic if the index is within a UTF-8 character
+    //~^ string_slice
+
     let a = Cow::Borrowed("foo");
     &a[0..3];
-    //~^ ERROR: indexing into a string may panic if the index is within a UTF-8 character
+    //~^ string_slice
 }
diff --git a/src/tools/clippy/tests/ui/string_slice.stderr b/src/tools/clippy/tests/ui/string_slice.stderr
index bc0fcde34b82..f99413c6dfc6 100644
--- a/src/tools/clippy/tests/ui/string_slice.stderr
+++ b/src/tools/clippy/tests/ui/string_slice.stderr
@@ -14,13 +14,13 @@ LL |     &m[2..5];
    |      ^^^^^^^
 
 error: indexing into a string may panic if the index is within a UTF-8 character
-  --> tests/ui/string_slice.rs:14:6
+  --> tests/ui/string_slice.rs:15:6
    |
 LL |     &s[0..2];
    |      ^^^^^^^
 
 error: indexing into a string may panic if the index is within a UTF-8 character
-  --> tests/ui/string_slice.rs:17:6
+  --> tests/ui/string_slice.rs:19:6
    |
 LL |     &a[0..3];
    |      ^^^^^^^
diff --git a/src/tools/clippy/tests/ui/string_to_string.rs b/src/tools/clippy/tests/ui/string_to_string.rs
index 007685b60179..94174e1253b8 100644
--- a/src/tools/clippy/tests/ui/string_to_string.rs
+++ b/src/tools/clippy/tests/ui/string_to_string.rs
@@ -4,5 +4,5 @@
 fn main() {
     let mut message = String::from("Hello");
     let mut v = message.to_string();
-    //~^ ERROR: `to_string()` called on a `String`
+    //~^ string_to_string
 }
diff --git a/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed b/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed
index 1e7d04ffb9df..31ed1cf03a2d 100644
--- a/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed
+++ b/src/tools/clippy/tests/ui/strlen_on_c_strings.fixed
@@ -11,22 +11,29 @@ fn main() {
     // CString
     let cstring = CString::new("foo").expect("CString::new failed");
     let _ = cstring.as_bytes().len();
+    //~^ strlen_on_c_strings
 
     // CStr
     let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
     let _ = cstr.to_bytes().len();
+    //~^ strlen_on_c_strings
 
     let _ = cstr.to_bytes().len();
+    //~^ strlen_on_c_strings
 
     let pcstr: *const &CStr = &cstr;
     let _ = unsafe { (*pcstr).to_bytes().len() };
+    //~^ strlen_on_c_strings
 
     unsafe fn unsafe_identity<T>(x: T) -> T {
         x
     }
     let _ = unsafe { unsafe_identity(cstr).to_bytes().len() };
+    //~^ strlen_on_c_strings
     let _ = unsafe { unsafe_identity(cstr) }.to_bytes().len();
+    //~^ strlen_on_c_strings
 
     let f: unsafe fn(_) -> _ = unsafe_identity;
     let _ = unsafe { f(cstr).to_bytes().len() };
+    //~^ strlen_on_c_strings
 }
diff --git a/src/tools/clippy/tests/ui/strlen_on_c_strings.rs b/src/tools/clippy/tests/ui/strlen_on_c_strings.rs
index c3ad03591d4e..0f3798c9fd8a 100644
--- a/src/tools/clippy/tests/ui/strlen_on_c_strings.rs
+++ b/src/tools/clippy/tests/ui/strlen_on_c_strings.rs
@@ -11,22 +11,29 @@ fn main() {
     // CString
     let cstring = CString::new("foo").expect("CString::new failed");
     let _ = unsafe { libc::strlen(cstring.as_ptr()) };
+    //~^ strlen_on_c_strings
 
     // CStr
     let cstr = CStr::from_bytes_with_nul(b"foo\0").expect("CStr::from_bytes_with_nul failed");
     let _ = unsafe { libc::strlen(cstr.as_ptr()) };
+    //~^ strlen_on_c_strings
 
     let _ = unsafe { strlen(cstr.as_ptr()) };
+    //~^ strlen_on_c_strings
 
     let pcstr: *const &CStr = &cstr;
     let _ = unsafe { strlen((*pcstr).as_ptr()) };
+    //~^ strlen_on_c_strings
 
     unsafe fn unsafe_identity<T>(x: T) -> T {
         x
     }
     let _ = unsafe { strlen(unsafe_identity(cstr).as_ptr()) };
+    //~^ strlen_on_c_strings
     let _ = unsafe { strlen(unsafe { unsafe_identity(cstr) }.as_ptr()) };
+    //~^ strlen_on_c_strings
 
     let f: unsafe fn(_) -> _ = unsafe_identity;
     let _ = unsafe { strlen(f(cstr).as_ptr()) };
+    //~^ strlen_on_c_strings
 }
diff --git a/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr b/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr
index 8c2a7692659c..b8619fa2df30 100644
--- a/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr
+++ b/src/tools/clippy/tests/ui/strlen_on_c_strings.stderr
@@ -8,37 +8,37 @@ LL |     let _ = unsafe { libc::strlen(cstring.as_ptr()) };
    = help: to override `-D warnings` add `#[allow(clippy::strlen_on_c_strings)]`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:17:13
+  --> tests/ui/strlen_on_c_strings.rs:18:13
    |
 LL |     let _ = unsafe { libc::strlen(cstr.as_ptr()) };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstr.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:19:13
+  --> tests/ui/strlen_on_c_strings.rs:21:13
    |
 LL |     let _ = unsafe { strlen(cstr.as_ptr()) };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `cstr.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:22:22
+  --> tests/ui/strlen_on_c_strings.rs:25:22
    |
 LL |     let _ = unsafe { strlen((*pcstr).as_ptr()) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(*pcstr).to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:27:22
+  --> tests/ui/strlen_on_c_strings.rs:31:22
    |
 LL |     let _ = unsafe { strlen(unsafe_identity(cstr).as_ptr()) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe_identity(cstr).to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:28:13
+  --> tests/ui/strlen_on_c_strings.rs:33:13
    |
 LL |     let _ = unsafe { strlen(unsafe { unsafe_identity(cstr) }.as_ptr()) };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unsafe { unsafe_identity(cstr) }.to_bytes().len()`
 
 error: using `libc::strlen` on a `CString` or `CStr` value
-  --> tests/ui/strlen_on_c_strings.rs:31:22
+  --> tests/ui/strlen_on_c_strings.rs:37:22
    |
 LL |     let _ = unsafe { strlen(f(cstr).as_ptr()) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `f(cstr).to_bytes().len()`
diff --git a/src/tools/clippy/tests/ui/struct_excessive_bools.rs b/src/tools/clippy/tests/ui/struct_excessive_bools.rs
index 8137ce7a81c5..36cbc6278030 100644
--- a/src/tools/clippy/tests/ui/struct_excessive_bools.rs
+++ b/src/tools/clippy/tests/ui/struct_excessive_bools.rs
@@ -20,7 +20,7 @@ struct Foo {
 }
 
 struct BadFoo {
-    //~^ ERROR: more than 3 bools in a struct
+    //~^ struct_excessive_bools
     a: bool,
     b: bool,
     c: bool,
@@ -37,7 +37,7 @@ struct Bar {
 
 fn main() {
     struct FooFoo {
-        //~^ ERROR: more than 3 bools in a struct
+        //~^ struct_excessive_bools
         a: bool,
         b: bool,
         c: bool,
diff --git a/src/tools/clippy/tests/ui/struct_fields.rs b/src/tools/clippy/tests/ui/struct_fields.rs
index 7c8867bd0fa3..3dce530efffa 100644
--- a/src/tools/clippy/tests/ui/struct_fields.rs
+++ b/src/tools/clippy/tests/ui/struct_fields.rs
@@ -339,7 +339,9 @@ struct Use {
     use_foo: bool,
     //~^ ERROR: field name starts with the struct's name
     use_bar: bool,
+    //~^ struct_field_names
     use_baz: bool,
+    //~^ struct_field_names
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/struct_fields.stderr b/src/tools/clippy/tests/ui/struct_fields.stderr
index cfda18c708c0..79186cc1cfd8 100644
--- a/src/tools/clippy/tests/ui/struct_fields.stderr
+++ b/src/tools/clippy/tests/ui/struct_fields.stderr
@@ -276,7 +276,7 @@ LL |     use_bar: bool,
    |     ^^^^^^^^^^^^^
 
 error: field name starts with the struct's name
-  --> tests/ui/struct_fields.rs:342:5
+  --> tests/ui/struct_fields.rs:343:5
    |
 LL |     use_baz: bool,
    |     ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.rs b/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.rs
index 07280351e76c..9798d2049c62 100644
--- a/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.rs
+++ b/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.rs
@@ -12,16 +12,14 @@ impl Add for Foo {
 
     fn add(self, other: Self) -> Self {
         Foo(self.0 - other.0)
-        //~^ ERROR: suspicious use of `-` in `Add` impl
-        //~| NOTE: `-D clippy::suspicious-arithmetic-impl` implied by `-D warnings`
+        //~^ suspicious_arithmetic_impl
     }
 }
 
 impl AddAssign for Foo {
     fn add_assign(&mut self, other: Foo) {
         *self = *self - other;
-        //~^ ERROR: suspicious use of `-` in `AddAssign` impl
-        //~| NOTE: `-D clippy::suspicious-op-assign-impl` implied by `-D warnings`
+        //~^ suspicious_op_assign_impl
     }
 }
 
@@ -35,7 +33,7 @@ impl BitOrAssign for Foo {
 impl MulAssign for Foo {
     fn mul_assign(&mut self, other: Foo) {
         self.0 /= other.0;
-        //~^ ERROR: suspicious use of `/` in `MulAssign` impl
+        //~^ suspicious_op_assign_impl
     }
 }
 
@@ -74,7 +72,7 @@ impl Rem for Foo {
 
     fn rem(self, other: Self) -> Self {
         Foo(self.0 / other.0)
-        //~^ ERROR: suspicious use of `/` in `Rem` impl
+        //~^ suspicious_arithmetic_impl
     }
 }
 
@@ -83,7 +81,7 @@ impl BitAnd for Foo {
 
     fn bitand(self, other: Self) -> Self {
         Foo(self.0 | other.0)
-        //~^ ERROR: suspicious use of `|` in `BitAnd` impl
+        //~^ suspicious_arithmetic_impl
     }
 }
 
@@ -92,7 +90,7 @@ impl BitOr for Foo {
 
     fn bitor(self, other: Self) -> Self {
         Foo(self.0 ^ other.0)
-        //~^ ERROR: suspicious use of `^` in `BitOr` impl
+        //~^ suspicious_arithmetic_impl
     }
 }
 
@@ -101,7 +99,7 @@ impl BitXor for Foo {
 
     fn bitxor(self, other: Self) -> Self {
         Foo(self.0 & other.0)
-        //~^ ERROR: suspicious use of `&` in `BitXor` impl
+        //~^ suspicious_arithmetic_impl
     }
 }
 
@@ -110,7 +108,7 @@ impl Shl for Foo {
 
     fn shl(self, other: Self) -> Self {
         Foo(self.0 >> other.0)
-        //~^ ERROR: suspicious use of `>>` in `Shl` impl
+        //~^ suspicious_arithmetic_impl
     }
 }
 
@@ -119,7 +117,7 @@ impl Shr for Foo {
 
     fn shr(self, other: Self) -> Self {
         Foo(self.0 << other.0)
-        //~^ ERROR: suspicious use of `<<` in `Shr` impl
+        //~^ suspicious_arithmetic_impl
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.stderr b/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.stderr
index 1bfca49a635d..2d8aac4db2a7 100644
--- a/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_arithmetic_impl.stderr
@@ -8,7 +8,7 @@ LL |         Foo(self.0 - other.0)
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_arithmetic_impl)]`
 
 error: suspicious use of `-` in `AddAssign` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:22:23
+  --> tests/ui/suspicious_arithmetic_impl.rs:21:23
    |
 LL |         *self = *self - other;
    |                       ^
@@ -17,43 +17,43 @@ LL |         *self = *self - other;
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_op_assign_impl)]`
 
 error: suspicious use of `/` in `MulAssign` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:37:16
+  --> tests/ui/suspicious_arithmetic_impl.rs:35:16
    |
 LL |         self.0 /= other.0;
    |                ^^
 
 error: suspicious use of `/` in `Rem` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:76:20
+  --> tests/ui/suspicious_arithmetic_impl.rs:74:20
    |
 LL |         Foo(self.0 / other.0)
    |                    ^
 
 error: suspicious use of `|` in `BitAnd` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:85:20
+  --> tests/ui/suspicious_arithmetic_impl.rs:83:20
    |
 LL |         Foo(self.0 | other.0)
    |                    ^
 
 error: suspicious use of `^` in `BitOr` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:94:20
+  --> tests/ui/suspicious_arithmetic_impl.rs:92:20
    |
 LL |         Foo(self.0 ^ other.0)
    |                    ^
 
 error: suspicious use of `&` in `BitXor` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:103:20
+  --> tests/ui/suspicious_arithmetic_impl.rs:101:20
    |
 LL |         Foo(self.0 & other.0)
    |                    ^
 
 error: suspicious use of `>>` in `Shl` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:112:20
+  --> tests/ui/suspicious_arithmetic_impl.rs:110:20
    |
 LL |         Foo(self.0 >> other.0)
    |                    ^^
 
 error: suspicious use of `<<` in `Shr` impl
-  --> tests/ui/suspicious_arithmetic_impl.rs:121:20
+  --> tests/ui/suspicious_arithmetic_impl.rs:119:20
    |
 LL |         Foo(self.0 << other.0)
    |                    ^^
diff --git a/src/tools/clippy/tests/ui/suspicious_command_arg_space.fixed b/src/tools/clippy/tests/ui/suspicious_command_arg_space.fixed
index 704d6ea1bb83..0a0d90f75e57 100644
--- a/src/tools/clippy/tests/ui/suspicious_command_arg_space.fixed
+++ b/src/tools/clippy/tests/ui/suspicious_command_arg_space.fixed
@@ -2,10 +2,10 @@
 fn main() {
     // Things it should warn about:
     std::process::Command::new("echo").args(["-n", "hello"]).spawn().unwrap();
-    //~^ ERROR: single argument that looks like it should be multiple arguments
-    //~| NOTE: `-D clippy::suspicious-command-arg-space` implied by `-D warnings`
+    //~^ suspicious_command_arg_space
+
     std::process::Command::new("cat").args(["--number", "file"]).spawn().unwrap();
-    //~^ ERROR: single argument that looks like it should be multiple arguments
+    //~^ suspicious_command_arg_space
 
     // Things it should not warn about:
     std::process::Command::new("echo").arg("hello world").spawn().unwrap();
diff --git a/src/tools/clippy/tests/ui/suspicious_command_arg_space.rs b/src/tools/clippy/tests/ui/suspicious_command_arg_space.rs
index 2a2a7557381c..78bdfbdf0cb6 100644
--- a/src/tools/clippy/tests/ui/suspicious_command_arg_space.rs
+++ b/src/tools/clippy/tests/ui/suspicious_command_arg_space.rs
@@ -2,10 +2,10 @@
 fn main() {
     // Things it should warn about:
     std::process::Command::new("echo").arg("-n hello").spawn().unwrap();
-    //~^ ERROR: single argument that looks like it should be multiple arguments
-    //~| NOTE: `-D clippy::suspicious-command-arg-space` implied by `-D warnings`
+    //~^ suspicious_command_arg_space
+
     std::process::Command::new("cat").arg("--number file").spawn().unwrap();
-    //~^ ERROR: single argument that looks like it should be multiple arguments
+    //~^ suspicious_command_arg_space
 
     // Things it should not warn about:
     std::process::Command::new("echo").arg("hello world").spawn().unwrap();
diff --git a/src/tools/clippy/tests/ui/suspicious_doc_comments.fixed b/src/tools/clippy/tests/ui/suspicious_doc_comments.fixed
index d3df6a41cb12..3696b0e066d2 100644
--- a/src/tools/clippy/tests/ui/suspicious_doc_comments.fixed
+++ b/src/tools/clippy/tests/ui/suspicious_doc_comments.fixed
@@ -4,10 +4,12 @@
 
 //! Real module documentation.
 //! Fake module documentation.
+//~^ suspicious_doc_comments
 fn baz() {}
 
 pub mod singleline_outer_doc {
     //! This module contains useful functions.
+    //~^ suspicious_doc_comments
 
     pub fn bar() {}
 }
@@ -21,6 +23,7 @@ pub mod singleline_inner_doc {
 pub mod multiline_outer_doc {
     /*! This module contains useful functions.
      */
+    //~^^ suspicious_doc_comments
 
     pub fn bar() {}
 }
@@ -34,6 +37,7 @@ pub mod multiline_inner_doc {
 
 pub mod multiline_outer_doc2 {
     //! This module
+    //~^ suspicious_doc_comments
     //! contains
     //! useful functions.
 
@@ -42,6 +46,7 @@ pub mod multiline_outer_doc2 {
 
 pub mod multiline_outer_doc3 {
     //! a
+    //~^ suspicious_doc_comments
     //! b
 
     /// c
@@ -50,12 +55,14 @@ pub mod multiline_outer_doc3 {
 
 pub mod multiline_outer_doc4 {
     //! a
+    //~^ suspicious_doc_comments
     /// b
     pub fn bar() {}
 }
 
 pub mod multiline_outer_doc_gap {
     //! a
+    //~^ suspicious_doc_comments
 
     //! b
     pub fn bar() {}
@@ -68,6 +75,7 @@ pub mod multiline_outer_doc_commented {
 
 pub mod outer_doc_macro {
     //! Very cool macro
+    //~^ suspicious_doc_comments
     macro_rules! x {
         () => {};
     }
@@ -75,6 +83,7 @@ pub mod outer_doc_macro {
 
 pub mod useless_outer_doc {
     //! Huh.
+    //~^ suspicious_doc_comments
     use std::mem;
 }
 
diff --git a/src/tools/clippy/tests/ui/suspicious_doc_comments.rs b/src/tools/clippy/tests/ui/suspicious_doc_comments.rs
index 04db2b199c09..4107f5526d13 100644
--- a/src/tools/clippy/tests/ui/suspicious_doc_comments.rs
+++ b/src/tools/clippy/tests/ui/suspicious_doc_comments.rs
@@ -4,10 +4,12 @@
 
 //! Real module documentation.
 ///! Fake module documentation.
+//~^ suspicious_doc_comments
 fn baz() {}
 
 pub mod singleline_outer_doc {
     ///! This module contains useful functions.
+    //~^ suspicious_doc_comments
 
     pub fn bar() {}
 }
@@ -21,6 +23,7 @@ pub mod singleline_inner_doc {
 pub mod multiline_outer_doc {
     /**! This module contains useful functions.
      */
+    //~^^ suspicious_doc_comments
 
     pub fn bar() {}
 }
@@ -34,6 +37,7 @@ pub mod multiline_inner_doc {
 
 pub mod multiline_outer_doc2 {
     ///! This module
+    //~^ suspicious_doc_comments
     ///! contains
     ///! useful functions.
 
@@ -42,6 +46,7 @@ pub mod multiline_outer_doc2 {
 
 pub mod multiline_outer_doc3 {
     ///! a
+    //~^ suspicious_doc_comments
     ///! b
 
     /// c
@@ -50,12 +55,14 @@ pub mod multiline_outer_doc3 {
 
 pub mod multiline_outer_doc4 {
     ///! a
+    //~^ suspicious_doc_comments
     /// b
     pub fn bar() {}
 }
 
 pub mod multiline_outer_doc_gap {
     ///! a
+    //~^ suspicious_doc_comments
 
     ///! b
     pub fn bar() {}
@@ -68,6 +75,7 @@ pub mod multiline_outer_doc_commented {
 
 pub mod outer_doc_macro {
     ///! Very cool macro
+    //~^ suspicious_doc_comments
     macro_rules! x {
         () => {};
     }
@@ -75,6 +83,7 @@ pub mod outer_doc_macro {
 
 pub mod useless_outer_doc {
     ///! Huh.
+    //~^ suspicious_doc_comments
     use std::mem;
 }
 
diff --git a/src/tools/clippy/tests/ui/suspicious_doc_comments.stderr b/src/tools/clippy/tests/ui/suspicious_doc_comments.stderr
index 7e5933df2376..df04d08537c9 100644
--- a/src/tools/clippy/tests/ui/suspicious_doc_comments.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_doc_comments.stderr
@@ -13,7 +13,7 @@ LL + //! Fake module documentation.
    |
 
 error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:10:5
+  --> tests/ui/suspicious_doc_comments.rs:11:5
    |
 LL |     ///! This module contains useful functions.
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     //! This module contains useful functions.
    |
 
 error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:22:5
+  --> tests/ui/suspicious_doc_comments.rs:24:5
    |
 LL | /     /**! This module contains useful functions.
 LL | |      */
@@ -38,9 +38,10 @@ LL +      */
    |
 
 error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:36:5
+  --> tests/ui/suspicious_doc_comments.rs:39:5
    |
 LL | /     ///! This module
+LL | |
 LL | |     ///! contains
 LL | |     ///! useful functions.
    | |__________________________^
@@ -48,37 +49,13 @@ LL | |     ///! useful functions.
 help: use an inner doc comment to document the parent module or crate
    |
 LL ~     //! This module
+LL |
 LL ~     //! contains
 LL ~     //! useful functions.
    |
 
 error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:44:5
-   |
-LL | /     ///! a
-LL | |     ///! b
-   | |__________^
-   |
-help: use an inner doc comment to document the parent module or crate
-   |
-LL ~     //! a
-LL ~     //! b
-   |
-
-error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:52:5
-   |
-LL |     ///! a
-   |     ^^^^^^
-   |
-help: use an inner doc comment to document the parent module or crate
-   |
-LL -     ///! a
-LL +     //! a
-   |
-
-error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:58:5
+  --> tests/ui/suspicious_doc_comments.rs:48:5
    |
 LL | /     ///! a
 LL | |
@@ -93,7 +70,35 @@ LL ~     //! b
    |
 
 error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:70:5
+  --> tests/ui/suspicious_doc_comments.rs:57:5
+   |
+LL |     ///! a
+   |     ^^^^^^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL -     ///! a
+LL +     //! a
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> tests/ui/suspicious_doc_comments.rs:64:5
+   |
+LL | /     ///! a
+...  |
+LL | |     ///! b
+   | |__________^
+   |
+help: use an inner doc comment to document the parent module or crate
+   |
+LL ~     //! a
+LL |
+LL |
+LL ~     //! b
+   |
+
+error: this is an outer doc comment and does not apply to the parent module or crate
+  --> tests/ui/suspicious_doc_comments.rs:77:5
    |
 LL |     ///! Very cool macro
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -105,7 +110,7 @@ LL +     //! Very cool macro
    |
 
 error: this is an outer doc comment and does not apply to the parent module or crate
-  --> tests/ui/suspicious_doc_comments.rs:77:5
+  --> tests/ui/suspicious_doc_comments.rs:85:5
    |
 LL |     ///! Huh.
    |     ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.rs b/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.rs
index 9e9c4775748c..17c7cc15b170 100644
--- a/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.rs
+++ b/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.rs
@@ -1,16 +1,17 @@
-#![allow(unused)]
+#![allow(unused, clippy::empty_line_after_doc_comments)]
 #![warn(clippy::suspicious_doc_comments)]
 //@no-rustfix
 ///! a
-//~^ ERROR: this is an outer doc comment and does not apply to the parent module or crate
-//~| NOTE: `-D clippy::suspicious-doc-comments` implied by `-D warnings`
+//~^ suspicious_doc_comments
+
 ///! b
 /// c
 ///! d
 pub fn foo() {}
 
 ///! a
-//~^ ERROR: this is an outer doc comment and does not apply to the parent module or crate
+//~^ suspicious_doc_comments
+
 ///! b
 /// c
 ///! d
diff --git a/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.stderr b/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.stderr
index d15f16f7c503..234a22021df3 100644
--- a/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_doc_comments_unfixable.stderr
@@ -26,6 +26,7 @@ error: this is an outer doc comment and does not apply to the parent module or c
    |
 LL | / ///! a
 LL | |
+LL | |
 LL | | ///! b
 LL | | /// c
 LL | | ///! d
@@ -35,6 +36,7 @@ help: use an inner doc comment to document the parent module or crate
    |
 LL + //! a
 LL |
+LL |
 LL + //! b
 LL | /// c
 LL + //! d
diff --git a/src/tools/clippy/tests/ui/suspicious_else_formatting.rs b/src/tools/clippy/tests/ui/suspicious_else_formatting.rs
index 3d5c892eb606..28a3b551116d 100644
--- a/src/tools/clippy/tests/ui/suspicious_else_formatting.rs
+++ b/src/tools/clippy/tests/ui/suspicious_else_formatting.rs
@@ -20,10 +20,12 @@ fn main() {
     // weird `else` formatting:
     if foo() {
     } {
+    //~^ suspicious_else_formatting
     }
 
     if foo() {
     } if foo() {
+    //~^ suspicious_else_formatting
     }
 
     let _ = { // if as the last expression
@@ -31,6 +33,7 @@ fn main() {
 
         if foo() {
         } if foo() {
+        //~^ suspicious_else_formatting
         }
         else {
         }
@@ -39,6 +42,7 @@ fn main() {
     let _ = { // if in the middle of a block
         if foo() {
         } if foo() {
+        //~^ suspicious_else_formatting
         }
         else {
         }
@@ -50,6 +54,7 @@ fn main() {
     } else
     {
     }
+    //~^^^ suspicious_else_formatting
 
     // This is fine, though weird. Allman style braces on the else.
     if foo() {
@@ -62,12 +67,14 @@ fn main() {
     } else
     if foo() { // the span of the above error should continue here
     }
+    //~^^^ suspicious_else_formatting
 
     if foo() {
     }
     else
     if foo() { // the span of the above error should continue here
     }
+    //~^^^^ suspicious_else_formatting
 
     // those are ok:
     if foo() {
@@ -95,8 +102,8 @@ fn main() {
 
     else
     {
-
     }
+    //~^^^^^ suspicious_else_formatting
 
     if foo() {
     }
@@ -105,6 +112,7 @@ fn main() {
     {
 
     }
+    //~^^^^^^ suspicious_else_formatting
 
     // #3864 - Allman style braces
     if foo()
diff --git a/src/tools/clippy/tests/ui/suspicious_else_formatting.stderr b/src/tools/clippy/tests/ui/suspicious_else_formatting.stderr
index 28c5a2d904ce..affd20b22d9c 100644
--- a/src/tools/clippy/tests/ui/suspicious_else_formatting.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_else_formatting.stderr
@@ -9,7 +9,7 @@ LL |     } {
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_else_formatting)]`
 
 error: this looks like an `else if` but the `else` is missing
-  --> tests/ui/suspicious_else_formatting.rs:26:6
+  --> tests/ui/suspicious_else_formatting.rs:27:6
    |
 LL |     } if foo() {
    |      ^
@@ -17,7 +17,7 @@ LL |     } if foo() {
    = note: to remove this lint, add the missing `else` or add a new line before the second `if`
 
 error: this looks like an `else if` but the `else` is missing
-  --> tests/ui/suspicious_else_formatting.rs:33:10
+  --> tests/ui/suspicious_else_formatting.rs:35:10
    |
 LL |         } if foo() {
    |          ^
@@ -25,7 +25,7 @@ LL |         } if foo() {
    = note: to remove this lint, add the missing `else` or add a new line before the second `if`
 
 error: this looks like an `else if` but the `else` is missing
-  --> tests/ui/suspicious_else_formatting.rs:41:10
+  --> tests/ui/suspicious_else_formatting.rs:44:10
    |
 LL |         } if foo() {
    |          ^
@@ -33,7 +33,7 @@ LL |         } if foo() {
    = note: to remove this lint, add the missing `else` or add a new line before the second `if`
 
 error: this is an `else {..}` but the formatting might hide it
-  --> tests/ui/suspicious_else_formatting.rs:50:6
+  --> tests/ui/suspicious_else_formatting.rs:54:6
    |
 LL |       } else
    |  ______^
@@ -43,7 +43,7 @@ LL | |     {
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
 
 error: this is an `else if` but the formatting might hide it
-  --> tests/ui/suspicious_else_formatting.rs:62:6
+  --> tests/ui/suspicious_else_formatting.rs:67:6
    |
 LL |       } else
    |  ______^
@@ -53,7 +53,7 @@ LL | |     if foo() { // the span of the above error should continue here
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `if`
 
 error: this is an `else if` but the formatting might hide it
-  --> tests/ui/suspicious_else_formatting.rs:67:6
+  --> tests/ui/suspicious_else_formatting.rs:73:6
    |
 LL |       }
    |  ______^
@@ -64,7 +64,7 @@ LL | |     if foo() { // the span of the above error should continue here
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `if`
 
 error: this is an `else {..}` but the formatting might hide it
-  --> tests/ui/suspicious_else_formatting.rs:94:6
+  --> tests/ui/suspicious_else_formatting.rs:101:6
    |
 LL |       }
    |  ______^
@@ -76,7 +76,7 @@ LL | |     {
    = note: to remove this lint, remove the `else` or remove the new line between `else` and `{..}`
 
 error: this is an `else {..}` but the formatting might hide it
-  --> tests/ui/suspicious_else_formatting.rs:102:6
+  --> tests/ui/suspicious_else_formatting.rs:109:6
    |
 LL |       }
    |  ______^
diff --git a/src/tools/clippy/tests/ui/suspicious_map.rs b/src/tools/clippy/tests/ui/suspicious_map.rs
index d4a52cb110fb..86e48e29bb9e 100644
--- a/src/tools/clippy/tests/ui/suspicious_map.rs
+++ b/src/tools/clippy/tests/ui/suspicious_map.rs
@@ -3,11 +3,11 @@
 
 fn main() {
     let _ = (0..3).map(|x| x + 2).count();
-    //~^ ERROR: this call to `map()` won't have an effect on the call to `count()`
+    //~^ suspicious_map
 
     let f = |x| x + 1;
     let _ = (0..3).map(f).count();
-    //~^ ERROR: this call to `map()` won't have an effect on the call to `count()`
+    //~^ suspicious_map
 }
 
 fn negative() {
diff --git a/src/tools/clippy/tests/ui/suspicious_operation_groupings.fixed b/src/tools/clippy/tests/ui/suspicious_operation_groupings.fixed
index 60fde6e22cb6..fa680e537d30 100644
--- a/src/tools/clippy/tests/ui/suspicious_operation_groupings.fixed
+++ b/src/tools/clippy/tests/ui/suspicious_operation_groupings.fixed
@@ -1,7 +1,7 @@
 //@compile-flags: -Zdeduplicate-diagnostics=yes
 
 #![warn(clippy::suspicious_operation_groupings)]
-#![allow(dead_code, unused_parens, clippy::eq_op)]
+#![allow(dead_code, unused_parens, clippy::eq_op, clippy::manual_midpoint)]
 
 struct Vec3 {
     x: f64,
@@ -15,6 +15,7 @@ impl PartialEq for Vec3 {
     fn eq(&self, other: &Self) -> bool {
         // This should trigger the lint because `self.x` is compared to `other.y`
         self.x == other.x && self.y == other.y && self.z == other.z
+        //~^ suspicious_operation_groupings
     }
 }
 
@@ -28,6 +29,7 @@ struct S {
 fn buggy_ab_cmp(s1: &S, s2: &S) -> bool {
     // There's no `s1.b`
     s1.a < s2.a && s1.b < s2.b
+    //~^ suspicious_operation_groupings
 }
 
 struct SaOnly {
@@ -76,31 +78,38 @@ fn permissable(s1: &S, s2: &S) -> bool {
 fn non_boolean_operators(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     s1.a * s2.a + s1.b * s2.b + s1.c * s2.c + s1.d * s2.d
+    //~^ suspicious_operation_groupings
 }
 
 fn odd_number_of_pairs(s1: &S, s2: &S) -> i32 {
     // There's no `s2.b`
     s1.a * s2.a + s1.b * s2.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
+    //~| suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_middle_change_left(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     s1.a * s2.a + s1.b * s2.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_middle_change_right(s1: &S, s2: &S) -> i32 {
     // There's no `s2.b`
     s1.a * s2.a + s1.b * s2.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_start(s1: &S, s2: &S) -> i32 {
     // There's no `s2.a`
     s1.a * s2.a + s1.b * s2.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_end(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     s1.a * s2.a + s1.b * s2.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
 }
 
 fn the_cross_product_should_not_lint(s1: &S, s2: &S) -> (i32, i32, i32) {
@@ -114,56 +123,68 @@ fn the_cross_product_should_not_lint(s1: &S, s2: &S) -> (i32, i32, i32) {
 fn outer_parens_simple(s1: &S, s2: &S) -> i32 {
     // There's no `s2.b`
     (s1.a * s2.a + s1.b * s2.b)
+    //~^ suspicious_operation_groupings
 }
 
 fn outer_parens(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (s1.a * s2.a + s1.b * s2.b + s1.c * s2.c + s1.d * s2.d)
+    //~^ suspicious_operation_groupings
 }
 
 fn inner_parens(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.c) + (s1.d * s2.d)
+    //~^ suspicious_operation_groupings
 }
 
 fn outer_and_some_inner_parens(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     ((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.c) + (s1.d * s2.d))
+    //~^ suspicious_operation_groupings
 }
 
 fn all_parens_balanced_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.c) + (s1.d * s2.d)))
+    //~^ suspicious_operation_groupings
+    //~| suspicious_operation_groupings
 }
 
 fn all_parens_left_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.c)) + (s1.d * s2.d))
+    //~^ suspicious_operation_groupings
 }
 
 fn all_parens_right_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     ((s1.a * s2.a) + ((s1.b * s2.b) + (s1.c * s2.c) + (s1.d * s2.d)))
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_other_binop_expression(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     (s1.a * s2.a + s1.b * s2.b) / 2
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_function_call(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     i32::swap_bytes(s1.a * s2.a + s1.b * s2.b)
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_larger_boolean_expression(s1: &S, s2: &S) -> bool {
     // There's no `s1.c`
     s1.a > 0 && s1.b > 0 && s1.c == s2.c && s1.d == s2.d
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_larger_boolean_expression_with_unsorted_ops(s1: &S, s2: &S) -> bool {
     // There's no `s1.c`
     s1.a > 0 && s1.c == s2.c && s1.b > 0 && s1.d == s2.d
+    //~^ suspicious_operation_groupings
 }
 
 struct Nested {
@@ -173,6 +194,7 @@ struct Nested {
 fn changed_middle_ident(n1: &Nested, n2: &Nested) -> bool {
     // There's no `n2.inner.2.0`
     (n1.inner.0).0 == (n2.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.2).0
+    //~^ suspicious_operation_groupings
 }
 
 // `eq_op` should catch this one.
@@ -187,12 +209,14 @@ fn inside_fn_with_similar_expression(s1: &S, s2: &S, strict: bool) -> bool {
     } else {
         // There's no `s1.b` in this subexpression
         s1.a <= s2.a && s1.b <= s2.b
+        //~^ suspicious_operation_groupings
     }
 }
 
 fn inside_an_if_statement(s1: &mut S, s2: &S) {
     // There's no `s1.b`
     if s1.a < s2.a && s1.b < s2.b {
+        //~^ suspicious_operation_groupings
         s1.c = s2.c;
     }
 }
@@ -200,11 +224,13 @@ fn inside_an_if_statement(s1: &mut S, s2: &S) {
 fn maximum_unary_minus_right_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     -(-(-s1.a * -s2.a) + (-(-s1.b * -s2.b) + -(-s1.c * -s2.c) + -(-s1.d * -s2.d)))
+    //~^ suspicious_operation_groupings
 }
 
 fn unary_minus_and_an_if_expression(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     -(if -s1.a < -s2.a && -s1.b < -s2.b { s1.c } else { s2.a })
+    //~^ suspicious_operation_groupings
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/suspicious_operation_groupings.rs b/src/tools/clippy/tests/ui/suspicious_operation_groupings.rs
index ce37148a853b..4ffee640e8bd 100644
--- a/src/tools/clippy/tests/ui/suspicious_operation_groupings.rs
+++ b/src/tools/clippy/tests/ui/suspicious_operation_groupings.rs
@@ -1,7 +1,7 @@
 //@compile-flags: -Zdeduplicate-diagnostics=yes
 
 #![warn(clippy::suspicious_operation_groupings)]
-#![allow(dead_code, unused_parens, clippy::eq_op)]
+#![allow(dead_code, unused_parens, clippy::eq_op, clippy::manual_midpoint)]
 
 struct Vec3 {
     x: f64,
@@ -15,6 +15,7 @@ impl PartialEq for Vec3 {
     fn eq(&self, other: &Self) -> bool {
         // This should trigger the lint because `self.x` is compared to `other.y`
         self.x == other.y && self.y == other.y && self.z == other.z
+        //~^ suspicious_operation_groupings
     }
 }
 
@@ -28,6 +29,7 @@ struct S {
 fn buggy_ab_cmp(s1: &S, s2: &S) -> bool {
     // There's no `s1.b`
     s1.a < s2.a && s1.a < s2.b
+    //~^ suspicious_operation_groupings
 }
 
 struct SaOnly {
@@ -76,31 +78,38 @@ fn permissable(s1: &S, s2: &S) -> bool {
 fn non_boolean_operators(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d
+    //~^ suspicious_operation_groupings
 }
 
 fn odd_number_of_pairs(s1: &S, s2: &S) -> i32 {
     // There's no `s2.b`
     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
+    //~^ suspicious_operation_groupings
+    //~| suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_middle_change_left(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     s1.a * s2.a + s2.b * s2.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_middle_change_right(s1: &S, s2: &S) -> i32 {
     // There's no `s2.b`
     s1.a * s2.a + s1.b * s1.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_start(s1: &S, s2: &S) -> i32 {
     // There's no `s2.a`
     s1.a * s1.a + s1.b * s2.b + s1.c * s2.c
+    //~^ suspicious_operation_groupings
 }
 
 fn not_caught_by_eq_op_end(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     s1.a * s2.a + s1.b * s2.b + s1.c * s1.c
+    //~^ suspicious_operation_groupings
 }
 
 fn the_cross_product_should_not_lint(s1: &S, s2: &S) -> (i32, i32, i32) {
@@ -114,56 +123,68 @@ fn the_cross_product_should_not_lint(s1: &S, s2: &S) -> (i32, i32, i32) {
 fn outer_parens_simple(s1: &S, s2: &S) -> i32 {
     // There's no `s2.b`
     (s1.a * s2.a + s1.b * s1.b)
+    //~^ suspicious_operation_groupings
 }
 
 fn outer_parens(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d)
+    //~^ suspicious_operation_groupings
 }
 
 fn inner_parens(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)
+    //~^ suspicious_operation_groupings
 }
 
 fn outer_and_some_inner_parens(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     ((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d))
+    //~^ suspicious_operation_groupings
 }
 
 fn all_parens_balanced_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
+    //~^ suspicious_operation_groupings
+    //~| suspicious_operation_groupings
 }
 
 fn all_parens_left_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     (((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b)) + (s1.d * s2.d))
+    //~^ suspicious_operation_groupings
 }
 
 fn all_parens_right_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     ((s1.a * s2.a) + ((s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)))
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_other_binop_expression(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     (s1.a * s2.a + s2.b * s2.b) / 2
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_function_call(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     i32::swap_bytes(s1.a * s2.a + s2.b * s2.b)
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_larger_boolean_expression(s1: &S, s2: &S) -> bool {
     // There's no `s1.c`
     s1.a > 0 && s1.b > 0 && s1.d == s2.c && s1.d == s2.d
+    //~^ suspicious_operation_groupings
 }
 
 fn inside_larger_boolean_expression_with_unsorted_ops(s1: &S, s2: &S) -> bool {
     // There's no `s1.c`
     s1.a > 0 && s1.d == s2.c && s1.b > 0 && s1.d == s2.d
+    //~^ suspicious_operation_groupings
 }
 
 struct Nested {
@@ -173,6 +194,7 @@ struct Nested {
 fn changed_middle_ident(n1: &Nested, n2: &Nested) -> bool {
     // There's no `n2.inner.2.0`
     (n1.inner.0).0 == (n2.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.1).0
+    //~^ suspicious_operation_groupings
 }
 
 // `eq_op` should catch this one.
@@ -187,12 +209,14 @@ fn inside_fn_with_similar_expression(s1: &S, s2: &S, strict: bool) -> bool {
     } else {
         // There's no `s1.b` in this subexpression
         s1.a <= s2.a && s1.a <= s2.b
+        //~^ suspicious_operation_groupings
     }
 }
 
 fn inside_an_if_statement(s1: &mut S, s2: &S) {
     // There's no `s1.b`
     if s1.a < s2.a && s1.a < s2.b {
+        //~^ suspicious_operation_groupings
         s1.c = s2.c;
     }
 }
@@ -200,11 +224,13 @@ fn inside_an_if_statement(s1: &mut S, s2: &S) {
 fn maximum_unary_minus_right_tree(s1: &S, s2: &S) -> i32 {
     // There's no `s2.c`
     -(-(-s1.a * -s2.a) + (-(-s1.b * -s2.b) + -(-s1.c * -s2.b) + -(-s1.d * -s2.d)))
+    //~^ suspicious_operation_groupings
 }
 
 fn unary_minus_and_an_if_expression(s1: &S, s2: &S) -> i32 {
     // There's no `s1.b`
     -(if -s1.a < -s2.a && -s1.a < -s2.b { s1.c } else { s2.a })
+    //~^ suspicious_operation_groupings
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/suspicious_operation_groupings.stderr b/src/tools/clippy/tests/ui/suspicious_operation_groupings.stderr
index 7cb066d57e75..b640b2041cd3 100644
--- a/src/tools/clippy/tests/ui/suspicious_operation_groupings.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_operation_groupings.stderr
@@ -8,151 +8,151 @@ LL |         self.x == other.y && self.y == other.y && self.z == other.z
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_operation_groupings)]`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:30:20
+  --> tests/ui/suspicious_operation_groupings.rs:31:20
    |
 LL |     s1.a < s2.a && s1.a < s2.b
    |                    ^^^^^^^^^^^ help: did you mean: `s1.b < s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:78:33
+  --> tests/ui/suspicious_operation_groupings.rs:80:33
    |
 LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d
    |                                 ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:83:19
+  --> tests/ui/suspicious_operation_groupings.rs:86:19
    |
 LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
    |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:83:19
+  --> tests/ui/suspicious_operation_groupings.rs:86:19
    |
 LL |     s1.a * s2.a + s1.b * s2.c + s1.c * s2.c
    |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
-error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:88:19
-   |
-LL |     s1.a * s2.a + s2.b * s2.b + s1.c * s2.c
-   |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
-
 error: this sequence of operators looks suspiciously like a bug
   --> tests/ui/suspicious_operation_groupings.rs:93:19
    |
+LL |     s1.a * s2.a + s2.b * s2.b + s1.c * s2.c
+   |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
+
+error: this sequence of operators looks suspiciously like a bug
+  --> tests/ui/suspicious_operation_groupings.rs:99:19
+   |
 LL |     s1.a * s2.a + s1.b * s1.b + s1.c * s2.c
    |                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:98:5
+  --> tests/ui/suspicious_operation_groupings.rs:105:5
    |
 LL |     s1.a * s1.a + s1.b * s2.b + s1.c * s2.c
    |     ^^^^^^^^^^^ help: did you mean: `s1.a * s2.a`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:103:33
+  --> tests/ui/suspicious_operation_groupings.rs:111:33
    |
 LL |     s1.a * s2.a + s1.b * s2.b + s1.c * s1.c
    |                                 ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:116:20
+  --> tests/ui/suspicious_operation_groupings.rs:125:20
    |
 LL |     (s1.a * s2.a + s1.b * s1.b)
    |                    ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:121:34
+  --> tests/ui/suspicious_operation_groupings.rs:131:34
    |
 LL |     (s1.a * s2.a + s1.b * s2.b + s1.c * s2.b + s1.d * s2.d)
    |                                  ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:126:38
+  --> tests/ui/suspicious_operation_groupings.rs:137:38
    |
 LL |     (s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)
    |                                      ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:131:39
+  --> tests/ui/suspicious_operation_groupings.rs:143:39
    |
 LL |     ((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d))
    |                                       ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:136:42
+  --> tests/ui/suspicious_operation_groupings.rs:149:42
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
    |                                          ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:136:42
+  --> tests/ui/suspicious_operation_groupings.rs:149:42
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b)) + ((s1.c * s2.b) + (s1.d * s2.d)))
    |                                          ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:141:40
+  --> tests/ui/suspicious_operation_groupings.rs:156:40
    |
 LL |     (((s1.a * s2.a) + (s1.b * s2.b) + (s1.c * s2.b)) + (s1.d * s2.d))
    |                                        ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:146:40
+  --> tests/ui/suspicious_operation_groupings.rs:162:40
    |
 LL |     ((s1.a * s2.a) + ((s1.b * s2.b) + (s1.c * s2.b) + (s1.d * s2.d)))
    |                                        ^^^^^^^^^^^ help: did you mean: `s1.c * s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:151:20
+  --> tests/ui/suspicious_operation_groupings.rs:168:20
    |
 LL |     (s1.a * s2.a + s2.b * s2.b) / 2
    |                    ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:156:35
+  --> tests/ui/suspicious_operation_groupings.rs:174:35
    |
 LL |     i32::swap_bytes(s1.a * s2.a + s2.b * s2.b)
    |                                   ^^^^^^^^^^^ help: did you mean: `s1.b * s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:161:29
+  --> tests/ui/suspicious_operation_groupings.rs:180:29
    |
 LL |     s1.a > 0 && s1.b > 0 && s1.d == s2.c && s1.d == s2.d
    |                             ^^^^^^^^^^^^ help: did you mean: `s1.c == s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:166:17
+  --> tests/ui/suspicious_operation_groupings.rs:186:17
    |
 LL |     s1.a > 0 && s1.d == s2.c && s1.b > 0 && s1.d == s2.d
    |                 ^^^^^^^^^^^^ help: did you mean: `s1.c == s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:175:77
+  --> tests/ui/suspicious_operation_groupings.rs:196:77
    |
 LL |     (n1.inner.0).0 == (n2.inner.0).0 && (n1.inner.1).0 == (n2.inner.1).0 && (n1.inner.2).0 == (n2.inner.1).0
    |                                                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `(n1.inner.2).0 == (n2.inner.2).0`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:189:25
+  --> tests/ui/suspicious_operation_groupings.rs:211:25
    |
 LL |         s1.a <= s2.a && s1.a <= s2.b
    |                         ^^^^^^^^^^^^ help: did you mean: `s1.b <= s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:195:23
+  --> tests/ui/suspicious_operation_groupings.rs:218:23
    |
 LL |     if s1.a < s2.a && s1.a < s2.b {
    |                       ^^^^^^^^^^^ help: did you mean: `s1.b < s2.b`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:202:48
+  --> tests/ui/suspicious_operation_groupings.rs:226:48
    |
 LL |     -(-(-s1.a * -s2.a) + (-(-s1.b * -s2.b) + -(-s1.c * -s2.b) + -(-s1.d * -s2.d)))
    |                                                ^^^^^^^^^^^^^ help: did you mean: `-s1.c * -s2.c`
 
 error: this sequence of operators looks suspiciously like a bug
-  --> tests/ui/suspicious_operation_groupings.rs:207:27
+  --> tests/ui/suspicious_operation_groupings.rs:232:27
    |
 LL |     -(if -s1.a < -s2.a && -s1.a < -s2.b { s1.c } else { s2.a })
    |                           ^^^^^^^^^^^^^ help: did you mean: `-s1.b < -s2.b`
diff --git a/src/tools/clippy/tests/ui/suspicious_splitn.rs b/src/tools/clippy/tests/ui/suspicious_splitn.rs
index 7aa609706220..535f62c6bede 100644
--- a/src/tools/clippy/tests/ui/suspicious_splitn.rs
+++ b/src/tools/clippy/tests/ui/suspicious_splitn.rs
@@ -8,32 +8,30 @@ fn main() {
     let _ = [].splitn(0, |&x: &u32| x == 1);
 
     let _ = "a,b".splitn(0, ',');
-    //~^ ERROR: `splitn` called with `0` splits
-    //~| NOTE: the resulting iterator will always return `None`
+    //~^ suspicious_splitn
+
     let _ = "a,b".rsplitn(0, ',');
-    //~^ ERROR: `rsplitn` called with `0` splits
-    //~| NOTE: the resulting iterator will always return `None`
+    //~^ suspicious_splitn
+
     let _ = "a,b".splitn(1, ',');
-    //~^ ERROR: `splitn` called with `1` split
-    //~| NOTE: the resulting iterator will always return the entire string followed by `No
+    //~^ suspicious_splitn
+
     let _ = [0, 1, 2].splitn(0, |&x| x == 1);
-    //~^ ERROR: `splitn` called with `0` splits
-    //~| NOTE: the resulting iterator will always return `None`
+    //~^ suspicious_splitn
+
     let _ = [0, 1, 2].splitn_mut(0, |&x| x == 1);
-    //~^ ERROR: `splitn_mut` called with `0` splits
-    //~| NOTE: the resulting iterator will always return `None`
+    //~^ suspicious_splitn
+
     let _ = [0, 1, 2].splitn(1, |&x| x == 1);
-    //~^ ERROR: `splitn` called with `1` split
-    //~| NOTE: the resulting iterator will always return the entire slice followed by `Non
+    //~^ suspicious_splitn
+
     let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
-    //~^ ERROR: `rsplitn_mut` called with `1` split
-    //~| NOTE: the resulting iterator will always return the entire slice followed by `Non
+    //~^ suspicious_splitn
 
     const X: usize = 0;
     let _ = "a,b".splitn(X + 1, ',');
-    //~^ ERROR: `splitn` called with `1` split
-    //~| NOTE: the resulting iterator will always return the entire string followed by `No
+    //~^ suspicious_splitn
+
     let _ = "a,b".splitn(X, ',');
-    //~^ ERROR: `splitn` called with `0` splits
-    //~| NOTE: the resulting iterator will always return `None`
+    //~^ suspicious_splitn
 }
diff --git a/src/tools/clippy/tests/ui/suspicious_splitn.stderr b/src/tools/clippy/tests/ui/suspicious_splitn.stderr
index 6e05bc28d130..910c905bc990 100644
--- a/src/tools/clippy/tests/ui/suspicious_splitn.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_splitn.stderr
@@ -57,7 +57,7 @@ LL |     let _ = [0, 1, 2].rsplitn_mut(1, |&x| x == 1);
    = note: the resulting iterator will always return the entire slice followed by `None`
 
 error: `splitn` called with `1` split
-  --> tests/ui/suspicious_splitn.rs:33:13
+  --> tests/ui/suspicious_splitn.rs:32:13
    |
 LL |     let _ = "a,b".splitn(X + 1, ',');
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     let _ = "a,b".splitn(X + 1, ',');
    = note: the resulting iterator will always return the entire string followed by `None`
 
 error: `splitn` called with `0` splits
-  --> tests/ui/suspicious_splitn.rs:36:13
+  --> tests/ui/suspicious_splitn.rs:35:13
    |
 LL |     let _ = "a,b".splitn(X, ',');
    |             ^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/suspicious_to_owned.rs b/src/tools/clippy/tests/ui/suspicious_to_owned.rs
index 794c2e7174af..2eec05ccaf4c 100644
--- a/src/tools/clippy/tests/ui/suspicious_to_owned.rs
+++ b/src/tools/clippy/tests/ui/suspicious_to_owned.rs
@@ -15,8 +15,8 @@ fn main() {
     // we expect this to be linted
     let cow = Cow::Borrowed(moo);
     let _ = cow.to_owned();
-    //~^ ERROR: this `to_owned` call clones the Cow<'_, str> itself and does not cause the
-    //~| NOTE: `-D clippy::suspicious-to-owned` implied by `-D warnings`
+    //~^ suspicious_to_owned
+
     // we expect no lints for this
     let cow = Cow::Borrowed(moo);
     let _ = cow.into_owned();
@@ -27,7 +27,8 @@ fn main() {
     // we expect this to be linted
     let cow = Cow::Borrowed(&moos);
     let _ = cow.to_owned();
-    //~^ ERROR: this `to_owned` call clones the Cow<'_, [char; 3]> itself and does not cau
+    //~^ suspicious_to_owned
+
     // we expect no lints for this
     let cow = Cow::Borrowed(&moos);
     let _ = cow.into_owned();
@@ -38,7 +39,8 @@ fn main() {
     // we expect this to be linted
     let cow = Cow::Borrowed(&moos_vec);
     let _ = cow.to_owned();
-    //~^ ERROR: this `to_owned` call clones the Cow<'_, Vec<char>> itself and does not cau
+    //~^ suspicious_to_owned
+
     // we expect no lints for this
     let cow = Cow::Borrowed(&moos_vec);
     let _ = cow.into_owned();
@@ -49,7 +51,8 @@ fn main() {
     // we expect this to be linted
     let cow = unsafe { CStr::from_ptr(c_moo_ptr) }.to_string_lossy();
     let _ = cow.to_owned();
-    //~^ ERROR: this `to_owned` call clones the Cow<'_, str> itself and does not cause the
+    //~^ suspicious_to_owned
+
     // we expect no lints for this
     let cow = unsafe { CStr::from_ptr(c_moo_ptr) }.to_string_lossy();
     let _ = cow.into_owned();
@@ -64,8 +67,8 @@ fn main() {
 
     // we expect implicit_clone lints for these
     let _ = String::from(moo).to_owned();
-    //~^ ERROR: implicitly cloning a `String` by calling `to_owned` on its dereferenced ty
-    //~| NOTE: `-D clippy::implicit-clone` implied by `-D warnings`
+    //~^ implicit_clone
+
     let _ = moos_vec.to_owned();
-    //~^ ERROR: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
+    //~^ implicit_clone
 }
diff --git a/src/tools/clippy/tests/ui/suspicious_to_owned.stderr b/src/tools/clippy/tests/ui/suspicious_to_owned.stderr
index 2c26565d5ef1..f90bea5fb8ff 100644
--- a/src/tools/clippy/tests/ui/suspicious_to_owned.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_to_owned.stderr
@@ -33,7 +33,7 @@ LL +     let _ = cow.clone();
    |
 
 error: this `to_owned` call clones the Cow<'_, Vec<char>> itself and does not cause the Cow<'_, Vec<char>> contents to become owned
-  --> tests/ui/suspicious_to_owned.rs:40:13
+  --> tests/ui/suspicious_to_owned.rs:41:13
    |
 LL |     let _ = cow.to_owned();
    |             ^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     let _ = cow.clone();
    |
 
 error: this `to_owned` call clones the Cow<'_, str> itself and does not cause the Cow<'_, str> contents to become owned
-  --> tests/ui/suspicious_to_owned.rs:51:13
+  --> tests/ui/suspicious_to_owned.rs:53:13
    |
 LL |     let _ = cow.to_owned();
    |             ^^^^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL +     let _ = cow.clone();
    |
 
 error: implicitly cloning a `String` by calling `to_owned` on its dereferenced type
-  --> tests/ui/suspicious_to_owned.rs:66:13
+  --> tests/ui/suspicious_to_owned.rs:69:13
    |
 LL |     let _ = String::from(moo).to_owned();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `String::from(moo).clone()`
@@ -74,7 +74,7 @@ LL |     let _ = String::from(moo).to_owned();
    = help: to override `-D warnings` add `#[allow(clippy::implicit_clone)]`
 
 error: implicitly cloning a `Vec` by calling `to_owned` on its dereferenced type
-  --> tests/ui/suspicious_to_owned.rs:69:13
+  --> tests/ui/suspicious_to_owned.rs:72:13
    |
 LL |     let _ = moos_vec.to_owned();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider using: `moos_vec.clone()`
diff --git a/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.rs b/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.rs
index a7a62154ee0f..ab9bdde6cf90 100644
--- a/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.rs
+++ b/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.rs
@@ -7,18 +7,22 @@ fn main() {
     let a = 42;
 
     if a >- 30 {}
-    //~^ ERROR: by not having a space between `>` and `-` it looks like `>-` is a single o
+    //~^ suspicious_unary_op_formatting
+
     if a >=- 30 {}
-    //~^ ERROR: by not having a space between `>=` and `-` it looks like `>=-` is a single
+    //~^ suspicious_unary_op_formatting
+
 
     let b = true;
     let c = false;
 
     if b &&! c {}
-    //~^ ERROR: by not having a space between `&&` and `!` it looks like `&&!` is a single
+    //~^ suspicious_unary_op_formatting
+
 
     if a >-   30 {}
-    //~^ ERROR: by not having a space between `>` and `-` it looks like `>-` is a single o
+    //~^ suspicious_unary_op_formatting
+
 
     // those are ok:
     if a >-30 {}
diff --git a/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.stderr b/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.stderr
index 379fb17266a9..5fe18aa82435 100644
--- a/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_unary_op_formatting.stderr
@@ -9,7 +9,7 @@ LL |     if a >- 30 {}
    = help: to override `-D warnings` add `#[allow(clippy::suspicious_unary_op_formatting)]`
 
 error: by not having a space between `>=` and `-` it looks like `>=-` is a single operator
-  --> tests/ui/suspicious_unary_op_formatting.rs:11:9
+  --> tests/ui/suspicious_unary_op_formatting.rs:12:9
    |
 LL |     if a >=- 30 {}
    |         ^^^^^
@@ -17,7 +17,7 @@ LL |     if a >=- 30 {}
    = help: put a space between `>=` and `-` and remove the space after `-`
 
 error: by not having a space between `&&` and `!` it looks like `&&!` is a single operator
-  --> tests/ui/suspicious_unary_op_formatting.rs:17:9
+  --> tests/ui/suspicious_unary_op_formatting.rs:19:9
    |
 LL |     if b &&! c {}
    |         ^^^^^
@@ -25,7 +25,7 @@ LL |     if b &&! c {}
    = help: put a space between `&&` and `!` and remove the space after `!`
 
 error: by not having a space between `>` and `-` it looks like `>-` is a single operator
-  --> tests/ui/suspicious_unary_op_formatting.rs:20:9
+  --> tests/ui/suspicious_unary_op_formatting.rs:23:9
    |
 LL |     if a >-   30 {}
    |         ^^^^^^
diff --git a/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.rs b/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.rs
index a5319e1b2308..40a8d8c366ba 100644
--- a/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.rs
+++ b/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.rs
@@ -11,24 +11,31 @@ macro_rules! macro_test {
 macro_rules! macro_test_inside {
     () => {
         1 ^ 2 // should warn even if inside macro
+        //
+        //~^^ suspicious_xor_used_as_pow
     };
 }
 
 fn main() {
     // Should warn:
     let _ = 2 ^ 5;
-    //~^ ERROR: `^` is not the exponentiation operator
-    //~| NOTE: `-D clippy::suspicious-xor-used-as-pow` implied by `-D warnings`
+    //~^ suspicious_xor_used_as_pow
+
     let _ = 2i32 ^ 9i32;
-    //~^ ERROR: `^` is not the exponentiation operator
+    //~^ suspicious_xor_used_as_pow
+
     let _ = 2i32 ^ 2i32;
-    //~^ ERROR: `^` is not the exponentiation operator
+    //~^ suspicious_xor_used_as_pow
+
     let _ = 50i32 ^ 3i32;
-    //~^ ERROR: `^` is not the exponentiation operator
+    //~^ suspicious_xor_used_as_pow
+
     let _ = 5i32 ^ 8i32;
-    //~^ ERROR: `^` is not the exponentiation operator
+    //~^ suspicious_xor_used_as_pow
+
     let _ = 2i32 ^ 32i32;
-    //~^ ERROR: `^` is not the exponentiation operator
+    //~^ suspicious_xor_used_as_pow
+
     macro_test_inside!();
 
     // Should not warn:
diff --git a/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr b/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr
index 2a153169bd34..efeafdb94acb 100644
--- a/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr
+++ b/src/tools/clippy/tests/ui/suspicious_xor_used_as_pow.stderr
@@ -1,5 +1,5 @@
 error: `^` is not the exponentiation operator
-  --> tests/ui/suspicious_xor_used_as_pow.rs:19:13
+  --> tests/ui/suspicious_xor_used_as_pow.rs:21:13
    |
 LL |     let _ = 2 ^ 5;
    |             ^^^^^
@@ -13,7 +13,7 @@ LL +     let _ = 2.pow(5);
    |
 
 error: `^` is not the exponentiation operator
-  --> tests/ui/suspicious_xor_used_as_pow.rs:22:13
+  --> tests/ui/suspicious_xor_used_as_pow.rs:24:13
    |
 LL |     let _ = 2i32 ^ 9i32;
    |             ^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     let _ = 2i32.pow(9i32);
    |
 
 error: `^` is not the exponentiation operator
-  --> tests/ui/suspicious_xor_used_as_pow.rs:24:13
+  --> tests/ui/suspicious_xor_used_as_pow.rs:27:13
    |
 LL |     let _ = 2i32 ^ 2i32;
    |             ^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     let _ = 2i32.pow(2i32);
    |
 
 error: `^` is not the exponentiation operator
-  --> tests/ui/suspicious_xor_used_as_pow.rs:26:13
+  --> tests/ui/suspicious_xor_used_as_pow.rs:30:13
    |
 LL |     let _ = 50i32 ^ 3i32;
    |             ^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     let _ = 50i32.pow(3i32);
    |
 
 error: `^` is not the exponentiation operator
-  --> tests/ui/suspicious_xor_used_as_pow.rs:28:13
+  --> tests/ui/suspicious_xor_used_as_pow.rs:33:13
    |
 LL |     let _ = 5i32 ^ 8i32;
    |             ^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     let _ = 5i32.pow(8i32);
    |
 
 error: `^` is not the exponentiation operator
-  --> tests/ui/suspicious_xor_used_as_pow.rs:30:13
+  --> tests/ui/suspicious_xor_used_as_pow.rs:36:13
    |
 LL |     let _ = 2i32 ^ 32i32;
    |             ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/swap.rs b/src/tools/clippy/tests/ui/swap.rs
index c9ad77629290..51af55ecd27c 100644
--- a/src/tools/clippy/tests/ui/swap.rs
+++ b/src/tools/clippy/tests/ui/swap.rs
@@ -26,6 +26,7 @@ fn field() {
     let mut bar = Bar { a: 1, b: 2 };
 
     let temp = bar.a;
+    //~^ manual_swap
     bar.a = bar.b;
     bar.b = temp;
 
@@ -38,6 +39,7 @@ fn field() {
 fn array() {
     let mut foo = [1, 2];
     let temp = foo[0];
+    //~^ manual_swap
     foo[0] = foo[1];
     foo[1] = temp;
 
@@ -47,6 +49,7 @@ fn array() {
 fn slice() {
     let foo = &mut [1, 2];
     let temp = foo[0];
+    //~^ manual_swap
     foo[0] = foo[1];
     foo[1] = temp;
 
@@ -66,6 +69,7 @@ fn unswappable_slice() {
 fn vec() {
     let mut foo = vec![1, 2];
     let temp = foo[0];
+    //~^ manual_swap
     foo[0] = foo[1];
     foo[1] = temp;
 
@@ -77,6 +81,7 @@ fn xor_swap_locals() {
     let mut a = 0;
     let mut b = 1;
     a ^= b;
+    //~^ manual_swap
     b ^= a;
     a ^= b;
 }
@@ -85,6 +90,7 @@ fn xor_field_swap() {
     // This is an xor-based swap of fields in a struct.
     let mut bar = Bar { a: 0, b: 1 };
     bar.a ^= bar.b;
+    //~^ manual_swap
     bar.b ^= bar.a;
     bar.a ^= bar.b;
 }
@@ -93,6 +99,7 @@ fn xor_slice_swap() {
     // This is an xor-based swap of a slice
     let foo = &mut [1, 2];
     foo[0] ^= foo[1];
+    //~^ manual_swap
     foo[1] ^= foo[0];
     foo[0] ^= foo[1];
 }
@@ -122,6 +129,7 @@ fn distinct_slice() {
     let foo = &mut [vec![1, 2], vec![3, 4]];
     let bar = &mut [vec![1, 2], vec![3, 4]];
     let temp = foo[0][1];
+    //~^ manual_swap
     foo[0][1] = bar[1][0];
     bar[1][0] = temp;
 }
@@ -133,31 +141,38 @@ fn main() {
     let mut b = 1337;
 
     a = b;
+    //~^ almost_swapped
     b = a;
 
     ; let t = a;
+    //~^ manual_swap
     a = b;
     b = t;
 
     let mut c = Foo(42);
 
     c.0 = a;
+    //~^ almost_swapped
     a = c.0;
 
     ; let t = c.0;
+    //~^ manual_swap
     c.0 = a;
     a = t;
 
     let a = b;
+    //~^ almost_swapped
     let b = a;
 
     let mut c = 1;
     let mut d = 2;
     d = c;
+    //~^ almost_swapped
     c = d;
 
     let mut b = 1;
     let a = b;
+    //~^ almost_swapped
     b = a;
 
     let b = 1;
@@ -171,6 +186,7 @@ fn main() {
     let mut a = 2;
 
     let t = b;
+    //~^ manual_swap
     b = a;
     a = t;
 }
@@ -206,6 +222,7 @@ fn issue_8154() {
     let mut s = &mut s;
     let s = S3(&mut s);
     let t = s.0.x;
+    //~^ manual_swap
     s.0.x = s.0.y;
     s.0.y = t;
 }
diff --git a/src/tools/clippy/tests/ui/swap.stderr b/src/tools/clippy/tests/ui/swap.stderr
index fad356782479..15f7566d5896 100644
--- a/src/tools/clippy/tests/ui/swap.stderr
+++ b/src/tools/clippy/tests/ui/swap.stderr
@@ -2,6 +2,7 @@ error: this looks like you are swapping `bar.a` and `bar.b` manually
   --> tests/ui/swap.rs:28:5
    |
 LL | /     let temp = bar.a;
+LL | |
 LL | |     bar.a = bar.b;
 LL | |     bar.b = temp;
    | |_________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b);`
@@ -11,57 +12,64 @@ LL | |     bar.b = temp;
    = help: to override `-D warnings` add `#[allow(clippy::manual_swap)]`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> tests/ui/swap.rs:40:5
+  --> tests/ui/swap.rs:41:5
    |
 LL | /     let temp = foo[0];
+LL | |
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> tests/ui/swap.rs:49:5
+  --> tests/ui/swap.rs:51:5
    |
 LL | /     let temp = foo[0];
+LL | |
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> tests/ui/swap.rs:68:5
+  --> tests/ui/swap.rs:71:5
    |
 LL | /     let temp = foo[0];
+LL | |
 LL | |     foo[0] = foo[1];
 LL | |     foo[1] = temp;
    | |__________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `a` and `b` manually
-  --> tests/ui/swap.rs:79:5
+  --> tests/ui/swap.rs:83:5
    |
 LL | /     a ^= b;
+LL | |
 LL | |     b ^= a;
 LL | |     a ^= b;
    | |___________^ help: try: `std::mem::swap(&mut a, &mut b);`
 
 error: this looks like you are swapping `bar.a` and `bar.b` manually
-  --> tests/ui/swap.rs:87:5
+  --> tests/ui/swap.rs:92:5
    |
 LL | /     bar.a ^= bar.b;
+LL | |
 LL | |     bar.b ^= bar.a;
 LL | |     bar.a ^= bar.b;
    | |___________________^ help: try: `std::mem::swap(&mut bar.a, &mut bar.b);`
 
 error: this looks like you are swapping elements of `foo` manually
-  --> tests/ui/swap.rs:95:5
+  --> tests/ui/swap.rs:101:5
    |
 LL | /     foo[0] ^= foo[1];
+LL | |
 LL | |     foo[1] ^= foo[0];
 LL | |     foo[0] ^= foo[1];
    | |_____________________^ help: try: `foo.swap(0, 1);`
 
 error: this looks like you are swapping `foo[0][1]` and `bar[1][0]` manually
-  --> tests/ui/swap.rs:124:5
+  --> tests/ui/swap.rs:131:5
    |
 LL | /     let temp = foo[0][1];
+LL | |
 LL | |     foo[0][1] = bar[1][0];
 LL | |     bar[1][0] = temp;
    | |_____________________^ help: try: `std::mem::swap(&mut foo[0][1], &mut bar[1][0]);`
@@ -69,10 +77,11 @@ LL | |     bar[1][0] = temp;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `a` and `b` manually
-  --> tests/ui/swap.rs:138:7
+  --> tests/ui/swap.rs:147:7
    |
 LL |       ; let t = a;
    |  _______^
+LL | |
 LL | |     a = b;
 LL | |     b = t;
    | |__________^ help: try: `std::mem::swap(&mut a, &mut b);`
@@ -80,10 +89,11 @@ LL | |     b = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `c.0` and `a` manually
-  --> tests/ui/swap.rs:147:7
+  --> tests/ui/swap.rs:158:7
    |
 LL |       ; let t = c.0;
    |  _______^
+LL | |
 LL | |     c.0 = a;
 LL | |     a = t;
    | |__________^ help: try: `std::mem::swap(&mut c.0, &mut a);`
@@ -91,9 +101,10 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `b` and `a` manually
-  --> tests/ui/swap.rs:173:5
+  --> tests/ui/swap.rs:188:5
    |
 LL | /     let t = b;
+LL | |
 LL | |     b = a;
 LL | |     a = t;
    | |__________^ help: try: `std::mem::swap(&mut b, &mut a);`
@@ -101,9 +112,10 @@ LL | |     a = t;
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> tests/ui/swap.rs:135:5
+  --> tests/ui/swap.rs:143:5
    |
 LL | /     a = b;
+LL | |
 LL | |     b = a;
    | |_________^ help: try: `std::mem::swap(&mut a, &mut b)`
    |
@@ -112,45 +124,50 @@ LL | |     b = a;
    = help: to override `-D warnings` add `#[allow(clippy::almost_swapped)]`
 
 error: this looks like you are trying to swap `c.0` and `a`
-  --> tests/ui/swap.rs:144:5
+  --> tests/ui/swap.rs:154:5
    |
 LL | /     c.0 = a;
+LL | |
 LL | |     a = c.0;
    | |___________^ help: try: `std::mem::swap(&mut c.0, &mut a)`
    |
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> tests/ui/swap.rs:151:5
+  --> tests/ui/swap.rs:163:5
    |
 LL | /     let a = b;
+LL | |
 LL | |     let b = a;
    | |_____________^ help: try: `std::mem::swap(&mut a, &mut b)`
    |
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `d` and `c`
-  --> tests/ui/swap.rs:156:5
+  --> tests/ui/swap.rs:169:5
    |
 LL | /     d = c;
+LL | |
 LL | |     c = d;
    | |_________^ help: try: `std::mem::swap(&mut d, &mut c)`
    |
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are trying to swap `a` and `b`
-  --> tests/ui/swap.rs:160:5
+  --> tests/ui/swap.rs:174:5
    |
 LL | /     let a = b;
+LL | |
 LL | |     b = a;
    | |_________^ help: try: `std::mem::swap(&mut a, &mut b)`
    |
    = note: or maybe you should use `std::mem::replace`?
 
 error: this looks like you are swapping `s.0.x` and `s.0.y` manually
-  --> tests/ui/swap.rs:208:5
+  --> tests/ui/swap.rs:224:5
    |
 LL | /     let t = s.0.x;
+LL | |
 LL | |     s.0.x = s.0.y;
 LL | |     s.0.y = t;
    | |______________^ help: try: `std::mem::swap(&mut s.0.x, &mut s.0.y);`
diff --git a/src/tools/clippy/tests/ui/swap_ptr_to_ref.fixed b/src/tools/clippy/tests/ui/swap_ptr_to_ref.fixed
index 599bb0e80443..ec46368a95ae 100644
--- a/src/tools/clippy/tests/ui/swap_ptr_to_ref.fixed
+++ b/src/tools/clippy/tests/ui/swap_ptr_to_ref.fixed
@@ -9,9 +9,13 @@ fn main() {
 
     unsafe {
         core::ptr::swap(y, z);
+        //~^ swap_ptr_to_ref
         core::ptr::swap(y, &mut x);
+        //~^ swap_ptr_to_ref
         core::ptr::swap(&mut x, y);
+        //~^ swap_ptr_to_ref
         core::ptr::swap(addr_of_mut!(x), addr_of_mut!(x));
+        //~^ swap_ptr_to_ref
     }
 
     let y = &mut x;
diff --git a/src/tools/clippy/tests/ui/swap_ptr_to_ref.rs b/src/tools/clippy/tests/ui/swap_ptr_to_ref.rs
index 3a8a8daefddc..6a903ddb006d 100644
--- a/src/tools/clippy/tests/ui/swap_ptr_to_ref.rs
+++ b/src/tools/clippy/tests/ui/swap_ptr_to_ref.rs
@@ -9,9 +9,13 @@ fn main() {
 
     unsafe {
         core::mem::swap(&mut *y, &mut *z);
+        //~^ swap_ptr_to_ref
         core::mem::swap(&mut *y, &mut x);
+        //~^ swap_ptr_to_ref
         core::mem::swap(&mut x, &mut *y);
+        //~^ swap_ptr_to_ref
         core::mem::swap(&mut *addr_of_mut!(x), &mut *addr_of_mut!(x));
+        //~^ swap_ptr_to_ref
     }
 
     let y = &mut x;
diff --git a/src/tools/clippy/tests/ui/swap_ptr_to_ref.stderr b/src/tools/clippy/tests/ui/swap_ptr_to_ref.stderr
index 019c2f91f0e9..6b851901f82e 100644
--- a/src/tools/clippy/tests/ui/swap_ptr_to_ref.stderr
+++ b/src/tools/clippy/tests/ui/swap_ptr_to_ref.stderr
@@ -8,19 +8,19 @@ LL |         core::mem::swap(&mut *y, &mut *z);
    = help: to override `-D warnings` add `#[allow(clippy::swap_ptr_to_ref)]`
 
 error: call to `core::mem::swap` with a parameter derived from a raw pointer
-  --> tests/ui/swap_ptr_to_ref.rs:12:9
+  --> tests/ui/swap_ptr_to_ref.rs:13:9
    |
 LL |         core::mem::swap(&mut *y, &mut x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use ptr::swap: `core::ptr::swap(y, &mut x)`
 
 error: call to `core::mem::swap` with a parameter derived from a raw pointer
-  --> tests/ui/swap_ptr_to_ref.rs:13:9
+  --> tests/ui/swap_ptr_to_ref.rs:15:9
    |
 LL |         core::mem::swap(&mut x, &mut *y);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use ptr::swap: `core::ptr::swap(&mut x, y)`
 
 error: call to `core::mem::swap` with a parameter derived from a raw pointer
-  --> tests/ui/swap_ptr_to_ref.rs:14:9
+  --> tests/ui/swap_ptr_to_ref.rs:17:9
    |
 LL |         core::mem::swap(&mut *addr_of_mut!(x), &mut *addr_of_mut!(x));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use ptr::swap: `core::ptr::swap(addr_of_mut!(x), addr_of_mut!(x))`
diff --git a/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.rs b/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.rs
index 08e56a5d01b2..9c7cf27096cc 100644
--- a/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.rs
+++ b/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.rs
@@ -12,11 +12,12 @@ fn main() {
 
     unsafe {
         core::mem::swap(addr_of_mut_to_ref!(x), &mut *y);
-        //~^ ERROR: call to `core::mem::swap` with a parameter derived from a raw pointer
-        //~| NOTE: `-D clippy::swap-ptr-to-ref` implied by `-D warnings`
+        //~^ swap_ptr_to_ref
+
         core::mem::swap(&mut *y, addr_of_mut_to_ref!(x));
-        //~^ ERROR: call to `core::mem::swap` with a parameter derived from a raw pointer
+        //~^ swap_ptr_to_ref
+
         core::mem::swap(addr_of_mut_to_ref!(x), addr_of_mut_to_ref!(x));
-        //~^ ERROR: call to `core::mem::swap` with a parameter derived from a raw pointer
+        //~^ swap_ptr_to_ref
     }
 }
diff --git a/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.stderr b/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.stderr
index 8a0352049483..3bb9d87b70a5 100644
--- a/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/swap_ptr_to_ref_unfixable.stderr
@@ -14,7 +14,7 @@ LL |         core::mem::swap(&mut *y, addr_of_mut_to_ref!(x));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: call to `core::mem::swap` with a parameter derived from a raw pointer
-  --> tests/ui/swap_ptr_to_ref_unfixable.rs:19:9
+  --> tests/ui/swap_ptr_to_ref_unfixable.rs:20:9
    |
 LL |         core::mem::swap(addr_of_mut_to_ref!(x), addr_of_mut_to_ref!(x));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.fixed b/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.fixed
new file mode 100644
index 000000000000..c96a53ba2cd1
--- /dev/null
+++ b/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.fixed
@@ -0,0 +1,9 @@
+// https://github.com/rust-lang/rust-clippy/issues/12302
+use std::marker::PhantomData;
+
+pub struct Aa<T>(PhantomData<T>);
+
+fn aa(a: Aa<String>) {
+//~^ ERROR: expected one of
+
+}
diff --git a/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.rs b/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.rs
new file mode 100644
index 000000000000..a3a35eb26d10
--- /dev/null
+++ b/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.rs
@@ -0,0 +1,9 @@
+// https://github.com/rust-lang/rust-clippy/issues/12302
+use std::marker::PhantomData;
+
+pub struct Aa<T>(PhantomData<T>);
+
+fn aa(a: Aa<String) {
+//~^ ERROR: expected one of
+
+}
diff --git a/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.stderr b/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.stderr
new file mode 100644
index 000000000000..e334ca5241eb
--- /dev/null
+++ b/src/tools/clippy/tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.stderr
@@ -0,0 +1,13 @@
+error: expected one of `!`, `(`, `+`, `,`, `::`, `<`, or `>`, found `)`
+  --> tests/ui/syntax-error-recovery/non_expressive_names_error_recovery.rs:6:19
+   |
+LL | fn aa(a: Aa<String) {
+   |                   ^ expected one of 7 possible tokens
+   |
+help: you might have meant to end the type parameters here
+   |
+LL | fn aa(a: Aa<String>) {
+   |                   +
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/clippy/tests/ui/tabs_in_doc_comments.fixed b/src/tools/clippy/tests/ui/tabs_in_doc_comments.fixed
index 3536c1746df3..ed96cbaa6d3c 100644
--- a/src/tools/clippy/tests/ui/tabs_in_doc_comments.fixed
+++ b/src/tools/clippy/tests/ui/tabs_in_doc_comments.fixed
@@ -3,15 +3,23 @@
 ///
 /// Struct to hold two strings:
 ///     - first        one
+//~^ tabs_in_doc_comments
+//~| tabs_in_doc_comments
 ///     - second    one
+//~^ tabs_in_doc_comments
+//~| tabs_in_doc_comments
 pub struct DoubleString {
     ///
     ///     - First String:
+    //~^ tabs_in_doc_comments
     ///         - needs to be inside here
+    //~^ tabs_in_doc_comments
     first_string: String,
     ///
     ///     - Second String:
+    //~^ tabs_in_doc_comments
     ///         - needs to be inside here
+    //~^ tabs_in_doc_comments
     second_string: String,
 }
 
diff --git a/src/tools/clippy/tests/ui/tabs_in_doc_comments.rs b/src/tools/clippy/tests/ui/tabs_in_doc_comments.rs
index 033a685066e1..73d4d92a862e 100644
--- a/src/tools/clippy/tests/ui/tabs_in_doc_comments.rs
+++ b/src/tools/clippy/tests/ui/tabs_in_doc_comments.rs
@@ -3,15 +3,23 @@
 ///
 /// Struct to hold two strings:
 /// 	- first		one
+//~^ tabs_in_doc_comments
+//~| tabs_in_doc_comments
 /// 	- second	one
+//~^ tabs_in_doc_comments
+//~| tabs_in_doc_comments
 pub struct DoubleString {
     ///
     /// 	- First String:
+    //~^ tabs_in_doc_comments
     /// 		- needs to be inside here
+    //~^ tabs_in_doc_comments
     first_string: String,
     ///
     /// 	- Second String:
+    //~^ tabs_in_doc_comments
     /// 		- needs to be inside here
+    //~^ tabs_in_doc_comments
     second_string: String,
 }
 
diff --git a/src/tools/clippy/tests/ui/tabs_in_doc_comments.stderr b/src/tools/clippy/tests/ui/tabs_in_doc_comments.stderr
index f8d30b728e58..331bccaca92d 100644
--- a/src/tools/clippy/tests/ui/tabs_in_doc_comments.stderr
+++ b/src/tools/clippy/tests/ui/tabs_in_doc_comments.stderr
@@ -14,37 +14,37 @@ LL | ///     - first        one
    |                ^^^^^^^^ help: consider using four spaces per tab
 
 error: using tabs in doc comments is not recommended
-  --> tests/ui/tabs_in_doc_comments.rs:6:5
+  --> tests/ui/tabs_in_doc_comments.rs:8:5
    |
 LL | ///     - second    one
    |     ^^^^ help: consider using four spaces per tab
 
 error: using tabs in doc comments is not recommended
-  --> tests/ui/tabs_in_doc_comments.rs:6:14
+  --> tests/ui/tabs_in_doc_comments.rs:8:14
    |
 LL | ///     - second    one
    |                 ^^^^ help: consider using four spaces per tab
 
 error: using tabs in doc comments is not recommended
-  --> tests/ui/tabs_in_doc_comments.rs:9:9
+  --> tests/ui/tabs_in_doc_comments.rs:13:9
    |
 LL |     ///     - First String:
    |         ^^^^ help: consider using four spaces per tab
 
 error: using tabs in doc comments is not recommended
-  --> tests/ui/tabs_in_doc_comments.rs:10:9
+  --> tests/ui/tabs_in_doc_comments.rs:15:9
    |
 LL |     ///         - needs to be inside here
    |         ^^^^^^^^ help: consider using four spaces per tab
 
 error: using tabs in doc comments is not recommended
-  --> tests/ui/tabs_in_doc_comments.rs:13:9
+  --> tests/ui/tabs_in_doc_comments.rs:19:9
    |
 LL |     ///     - Second String:
    |         ^^^^ help: consider using four spaces per tab
 
 error: using tabs in doc comments is not recommended
-  --> tests/ui/tabs_in_doc_comments.rs:14:9
+  --> tests/ui/tabs_in_doc_comments.rs:21:9
    |
 LL |     ///         - needs to be inside here
    |         ^^^^^^^^ help: consider using four spaces per tab
diff --git a/src/tools/clippy/tests/ui/temporary_assignment.rs b/src/tools/clippy/tests/ui/temporary_assignment.rs
index d269f91b9fa8..ac9ed5d05f8f 100644
--- a/src/tools/clippy/tests/ui/temporary_assignment.rs
+++ b/src/tools/clippy/tests/ui/temporary_assignment.rs
@@ -46,18 +46,19 @@ fn main() {
     let mut t = (0, 0);
 
     Struct { field: 0 }.field = 1;
-    //~^ ERROR: assignment to temporary
-    //~| NOTE: `-D clippy::temporary-assignment` implied by `-D warnings`
+    //~^ temporary_assignment
+
     MultiStruct {
-        //~^ ERROR: assignment to temporary
+        //~^ temporary_assignment
         structure: Struct { field: 0 },
     }
     .structure
     .field = 1;
     ArrayStruct { array: [0] }.array[0] = 1;
-    //~^ ERROR: assignment to temporary
+    //~^ temporary_assignment
+
     (0, 0).0 = 1;
-    //~^ ERROR: assignment to temporary
+    //~^ temporary_assignment
 
     // no error
     s.field = 1;
diff --git a/src/tools/clippy/tests/ui/temporary_assignment.stderr b/src/tools/clippy/tests/ui/temporary_assignment.stderr
index 7e6529cb2134..5f6a54003630 100644
--- a/src/tools/clippy/tests/ui/temporary_assignment.stderr
+++ b/src/tools/clippy/tests/ui/temporary_assignment.stderr
@@ -24,7 +24,7 @@ LL |     ArrayStruct { array: [0] }.array[0] = 1;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: assignment to temporary
-  --> tests/ui/temporary_assignment.rs:59:5
+  --> tests/ui/temporary_assignment.rs:60:5
    |
 LL |     (0, 0).0 = 1;
    |     ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/test_attr_in_doctest.rs b/src/tools/clippy/tests/ui/test_attr_in_doctest.rs
index 4c904f7a09ac..6cffd813b835 100644
--- a/src/tools/clippy/tests/ui/test_attr_in_doctest.rs
+++ b/src/tools/clippy/tests/ui/test_attr_in_doctest.rs
@@ -4,46 +4,44 @@
 ///
 /// ```
 /// #[test]
+//~^ test_attr_in_doctest
 /// fn should_be_linted() {
 ///     assert_eq!(1, 1);
 /// }
 /// ```
-///
+/// 
 /// Make sure we catch multiple tests in one example,
 /// and show that we really parse the attr:
-///
 /// ```
 /// #[test]
+//~^ test_attr_in_doctest
 /// fn should_also_be_linted() {
 ///     #[cfg(test)]
 ///     assert!(true);
 /// }
 ///
 /// #[test]
+//~^ test_attr_in_doctest
 /// fn should_be_linted_too() {
 ///     assert_eq!("#[test]", "
 ///     #[test]
 ///     ");
 /// }
 /// ```
-///
+/// 
 /// We don't catch examples that aren't run:
-///
 /// ```ignore
 /// #[test]
 /// fn ignored() { todo!() }
 /// ```
-///
 /// ```no_run
 /// #[test]
 /// fn ignored() { todo!() }
 /// ```
-///
 /// ```compile_fail
 /// #[test]
 /// fn ignored() { Err(()) }
 /// ```
-///
 /// ```txt
 /// #[test]
 /// fn not_even_rust() { panic!("Ouch") }
diff --git a/src/tools/clippy/tests/ui/test_attr_in_doctest.stderr b/src/tools/clippy/tests/ui/test_attr_in_doctest.stderr
index f950455f2908..166b9b417b62 100644
--- a/src/tools/clippy/tests/ui/test_attr_in_doctest.stderr
+++ b/src/tools/clippy/tests/ui/test_attr_in_doctest.stderr
@@ -3,6 +3,7 @@ error: unit tests in doctest are not executed
    |
 LL |   /// #[test]
    |  _____^
+LL | |
 LL | | /// fn should_be_linted() {
    | |_______________________^
    |
@@ -14,14 +15,16 @@ error: unit tests in doctest are not executed
    |
 LL |   /// #[test]
    |  _____^
+LL | |
 LL | | /// fn should_also_be_linted() {
    | |____________________________^
 
 error: unit tests in doctest are not executed
-  --> tests/ui/test_attr_in_doctest.rs:22:5
+  --> tests/ui/test_attr_in_doctest.rs:23:5
    |
 LL |   /// #[test]
    |  _____^
+LL | |
 LL | | /// fn should_be_linted_too() {
    | |___________________________^
 
diff --git a/src/tools/clippy/tests/ui/tests_outside_test_module.rs b/src/tools/clippy/tests/ui/tests_outside_test_module.rs
index 0abde4a57bf7..35126c46af08 100644
--- a/src/tools/clippy/tests/ui/tests_outside_test_module.rs
+++ b/src/tools/clippy/tests/ui/tests_outside_test_module.rs
@@ -1,3 +1,4 @@
+//@require-annotations-for-level: WARN
 #![allow(unused)]
 #![warn(clippy::tests_outside_test_module)]
 
diff --git a/src/tools/clippy/tests/ui/tests_outside_test_module.stderr b/src/tools/clippy/tests/ui/tests_outside_test_module.stderr
index 09feae6bf2aa..8602a63cc7a4 100644
--- a/src/tools/clippy/tests/ui/tests_outside_test_module.stderr
+++ b/src/tools/clippy/tests/ui/tests_outside_test_module.stderr
@@ -1,5 +1,5 @@
 error: this function marked with #[test] is outside a #[cfg(test)] module
-  --> tests/ui/tests_outside_test_module.rs:10:1
+  --> tests/ui/tests_outside_test_module.rs:11:1
    |
 LL | fn my_test() {}
    | ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/to_digit_is_some.fixed b/src/tools/clippy/tests/ui/to_digit_is_some.fixed
index 2ef4c05289fd..627d54c5f738 100644
--- a/src/tools/clippy/tests/ui/to_digit_is_some.fixed
+++ b/src/tools/clippy/tests/ui/to_digit_is_some.fixed
@@ -5,5 +5,7 @@ fn main() {
     let d = &c;
 
     let _ = d.is_digit(8);
+    //~^ to_digit_is_some
     let _ = char::is_digit(c, 8);
+    //~^ to_digit_is_some
 }
diff --git a/src/tools/clippy/tests/ui/to_digit_is_some.rs b/src/tools/clippy/tests/ui/to_digit_is_some.rs
index 54d9545809c5..d4eccc9931f1 100644
--- a/src/tools/clippy/tests/ui/to_digit_is_some.rs
+++ b/src/tools/clippy/tests/ui/to_digit_is_some.rs
@@ -5,5 +5,7 @@ fn main() {
     let d = &c;
 
     let _ = d.to_digit(8).is_some();
+    //~^ to_digit_is_some
     let _ = char::to_digit(c, 8).is_some();
+    //~^ to_digit_is_some
 }
diff --git a/src/tools/clippy/tests/ui/to_digit_is_some.stderr b/src/tools/clippy/tests/ui/to_digit_is_some.stderr
index e44106b2e188..f41382a60d53 100644
--- a/src/tools/clippy/tests/ui/to_digit_is_some.stderr
+++ b/src/tools/clippy/tests/ui/to_digit_is_some.stderr
@@ -8,7 +8,7 @@ LL |     let _ = d.to_digit(8).is_some();
    = help: to override `-D warnings` add `#[allow(clippy::to_digit_is_some)]`
 
 error: use of `.to_digit(..).is_some()`
-  --> tests/ui/to_digit_is_some.rs:8:13
+  --> tests/ui/to_digit_is_some.rs:9:13
    |
 LL |     let _ = char::to_digit(c, 8).is_some();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `char::is_digit(c, 8)`
diff --git a/src/tools/clippy/tests/ui/to_string_trait_impl.rs b/src/tools/clippy/tests/ui/to_string_trait_impl.rs
index 7be9f7994f08..646ec4db1f11 100644
--- a/src/tools/clippy/tests/ui/to_string_trait_impl.rs
+++ b/src/tools/clippy/tests/ui/to_string_trait_impl.rs
@@ -9,6 +9,7 @@ struct Point {
 }
 
 impl ToString for Point {
+    //~^ to_string_trait_impl
     fn to_string(&self) -> String {
         format!("({}, {})", self.x, self.y)
     }
diff --git a/src/tools/clippy/tests/ui/to_string_trait_impl.stderr b/src/tools/clippy/tests/ui/to_string_trait_impl.stderr
index fe8afc215f0c..b24dfa39e011 100644
--- a/src/tools/clippy/tests/ui/to_string_trait_impl.stderr
+++ b/src/tools/clippy/tests/ui/to_string_trait_impl.stderr
@@ -2,6 +2,7 @@ error: direct implementation of `ToString`
   --> tests/ui/to_string_trait_impl.rs:11:1
    |
 LL | / impl ToString for Point {
+LL | |
 LL | |     fn to_string(&self) -> String {
 LL | |         format!("({}, {})", self.x, self.y)
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.fixed b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.fixed
index d4a0cdf3447f..7075aefd50b6 100644
--- a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.fixed
+++ b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.fixed
@@ -1,7 +1,9 @@
 #![warn(clippy::too_long_first_doc_paragraph)]
 
 /// A very short summary.
+//~^ too_long_first_doc_paragraph
 ///
+//~^ too_long_first_doc_paragraph
 /// 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. Blablabla, it needs to be over
diff --git a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.rs b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.rs
index 5a3b6c42a328..844417d741ef 100644
--- a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.rs
+++ b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.rs
@@ -1,6 +1,7 @@
 #![warn(clippy::too_long_first_doc_paragraph)]
 
 /// A very short summary.
+//~^ too_long_first_doc_paragraph
 /// 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. Blablabla, it needs to be over
diff --git a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.stderr b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.stderr
index 84a574017a9b..bc2fbc2d14df 100644
--- a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.stderr
+++ b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph-fix.stderr
@@ -2,6 +2,7 @@ error: first doc comment paragraph is too long
   --> tests/ui/too_long_first_doc_paragraph-fix.rs:3:1
    |
 LL | / /// A very short summary.
+LL | |
 LL | | /// A much longer explanation that goes into a lot more detail about
 LL | | /// how the thing works, possibly with doclinks and so one,
 LL | | /// and probably spanning a many rows. Blablabla, it needs to be over
@@ -13,7 +14,9 @@ LL | | /// 200 characters so I needed to write something longeeeeeeer.
 help: add an empty line
    |
 LL | /// A very short summary.
+LL |
 LL + ///
+LL +
    |
 
 error: aborting due to 1 previous error
diff --git a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.rs b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.rs
index 7d0a37cde46d..49420841c88c 100644
--- a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.rs
+++ b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.rs
@@ -6,6 +6,7 @@ pub mod foo {
 
     // in foo.rs
     //! A very short summary.
+    //~^ too_long_first_doc_paragraph
     //! 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. Blablabla, it needs to be over
@@ -13,6 +14,7 @@ pub mod foo {
 }
 
 /// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+//~^ too_long_first_doc_paragraph
 /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
 /// gravida non lacinia at, rhoncus eu lacus.
 pub struct Bar;
@@ -34,6 +36,7 @@ pub enum Enum {
 }
 
 /// Lorem
+//~^ too_long_first_doc_paragraph
 /// ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
 /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
 /// gravida non lacinia at, rhoncus eu lacus.
@@ -58,6 +61,13 @@ pub union Union2 {
 /// gravida non lacinia at, rhoncus eu lacus.
 fn f() {}
 
+#[rustfmt::skip]
+/// Some function. This doc-string paragraph is too long. Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software like Aldus PageMaker including versions of Lorem Ipsum.
+//~^ too_long_first_doc_paragraph
+///
+/// Here's a second paragraph. It would be preferable to put the details here.
+pub fn issue_14274() {}
+
 fn main() {
     // test code goes here
 }
diff --git a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr
index 8bc853132ec0..f3f182aa5422 100644
--- a/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr
+++ b/src/tools/clippy/tests/ui/too_long_first_doc_paragraph.stderr
@@ -2,6 +2,7 @@ error: first doc comment paragraph is too long
   --> tests/ui/too_long_first_doc_paragraph.rs:8:5
    |
 LL | /     //! A very short summary.
+LL | |
 LL | |     //! A much longer explanation that goes into a lot more detail about
 LL | |     //! how the thing works, possibly with doclinks and so one,
 LL | |     //! and probably spanning a many rows. Blablabla, it needs to be over
@@ -13,26 +14,39 @@ LL | |     //! 200 characters so I needed to write something longeeeeeeer.
 help: add an empty line
    |
 LL |     //! A very short summary.
+LL |
 LL ~     //!
+LL +
 LL ~     //! A much longer explanation that goes into a lot more detail about
    |
 
 error: first doc comment paragraph is too long
-  --> tests/ui/too_long_first_doc_paragraph.rs:15:1
+  --> tests/ui/too_long_first_doc_paragraph.rs:16:1
    |
 LL | / /// Lorem ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
+LL | |
 LL | | /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
 LL | | /// gravida non lacinia at, rhoncus eu lacus.
    | |_^
 
 error: first doc comment paragraph is too long
-  --> tests/ui/too_long_first_doc_paragraph.rs:36:1
+  --> tests/ui/too_long_first_doc_paragraph.rs:38:1
    |
 LL | / /// Lorem
+LL | |
 LL | | /// ipsum dolor sit amet, consectetur adipiscing elit. Nunc turpis nunc, lacinia
 LL | | /// a dolor in, pellentesque aliquet enim. Cras nec maximus sem. Mauris arcu libero,
 LL | | /// gravida non lacinia at, rhoncus eu lacus.
    | |_^
 
-error: aborting due to 3 previous errors
+error: first doc comment paragraph is too long
+  --> tests/ui/too_long_first_doc_paragraph.rs:65:1
+   |
+LL | / /// Some function. This doc-string paragraph is too long. Lorem Ipsum is simply dummy text of the printing and typesetting industry. Lore...
+LL | |
+LL | | ///
+LL | | /// Here's a second paragraph. It would be preferable to put the details here.
+   | |_^
+
+error: aborting due to 4 previous errors
 
diff --git a/src/tools/clippy/tests/ui/toplevel_ref_arg.fixed b/src/tools/clippy/tests/ui/toplevel_ref_arg.fixed
index 3eb47a5b5fd6..11d4eaaefda0 100644
--- a/src/tools/clippy/tests/ui/toplevel_ref_arg.fixed
+++ b/src/tools/clippy/tests/ui/toplevel_ref_arg.fixed
@@ -12,17 +12,22 @@ fn main() {
     y(1u8);
 
     let _x = &1;
+    //~^ toplevel_ref_arg
 
     let _y: &(&_, u8) = &(&1, 2);
+    //~^ toplevel_ref_arg
 
     let _z = &(1 + 2);
+    //~^ toplevel_ref_arg
 
     let _z = &mut (1 + 2);
+    //~^ toplevel_ref_arg
 
     let (ref x, _) = (1, 2); // ok, not top level
     println!("The answer is {}.", x);
 
     let _x = &vec![1, 2, 3];
+    //~^ toplevel_ref_arg
 
     // Make sure that allowing the lint works
     #[allow(clippy::toplevel_ref_arg)]
@@ -33,6 +38,7 @@ fn main() {
 
     // lint in macro
     inline!(let _y = &42;);
+    //~^ toplevel_ref_arg
 
     // do not lint in external macro
     external!(let ref _y = 42;);
diff --git a/src/tools/clippy/tests/ui/toplevel_ref_arg.rs b/src/tools/clippy/tests/ui/toplevel_ref_arg.rs
index cd731387de97..957dd542f5a9 100644
--- a/src/tools/clippy/tests/ui/toplevel_ref_arg.rs
+++ b/src/tools/clippy/tests/ui/toplevel_ref_arg.rs
@@ -12,17 +12,22 @@ fn main() {
     y(1u8);
 
     let ref _x = 1;
+    //~^ toplevel_ref_arg
 
     let ref _y: (&_, u8) = (&1, 2);
+    //~^ toplevel_ref_arg
 
     let ref _z = 1 + 2;
+    //~^ toplevel_ref_arg
 
     let ref mut _z = 1 + 2;
+    //~^ toplevel_ref_arg
 
     let (ref x, _) = (1, 2); // ok, not top level
     println!("The answer is {}.", x);
 
     let ref _x = vec![1, 2, 3];
+    //~^ toplevel_ref_arg
 
     // Make sure that allowing the lint works
     #[allow(clippy::toplevel_ref_arg)]
@@ -33,6 +38,7 @@ fn main() {
 
     // lint in macro
     inline!(let ref _y = 42;);
+    //~^ toplevel_ref_arg
 
     // do not lint in external macro
     external!(let ref _y = 42;);
diff --git a/src/tools/clippy/tests/ui/toplevel_ref_arg.stderr b/src/tools/clippy/tests/ui/toplevel_ref_arg.stderr
index 61f0fd4a6cd2..42e77f01495b 100644
--- a/src/tools/clippy/tests/ui/toplevel_ref_arg.stderr
+++ b/src/tools/clippy/tests/ui/toplevel_ref_arg.stderr
@@ -8,31 +8,31 @@ LL |     let ref _x = 1;
    = help: to override `-D warnings` add `#[allow(clippy::toplevel_ref_arg)]`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> tests/ui/toplevel_ref_arg.rs:16:9
+  --> tests/ui/toplevel_ref_arg.rs:17:9
    |
 LL |     let ref _y: (&_, u8) = (&1, 2);
    |     ----^^^^^^--------------------- help: try: `let _y: &(&_, u8) = &(&1, 2);`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> tests/ui/toplevel_ref_arg.rs:18:9
+  --> tests/ui/toplevel_ref_arg.rs:20:9
    |
 LL |     let ref _z = 1 + 2;
    |     ----^^^^^^--------- help: try: `let _z = &(1 + 2);`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> tests/ui/toplevel_ref_arg.rs:20:9
+  --> tests/ui/toplevel_ref_arg.rs:23:9
    |
 LL |     let ref mut _z = 1 + 2;
    |     ----^^^^^^^^^^--------- help: try: `let _z = &mut (1 + 2);`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> tests/ui/toplevel_ref_arg.rs:25:9
+  --> tests/ui/toplevel_ref_arg.rs:29:9
    |
 LL |     let ref _x = vec![1, 2, 3];
    |     ----^^^^^^----------------- help: try: `let _x = &vec![1, 2, 3];`
 
 error: `ref` on an entire `let` pattern is discouraged, take a reference with `&` instead
-  --> tests/ui/toplevel_ref_arg.rs:35:17
+  --> tests/ui/toplevel_ref_arg.rs:40:17
    |
 LL |     inline!(let ref _y = 42;);
    |             ----^^^^^^------ help: try: `let _y = &42;`
diff --git a/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.rs b/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.rs
index 8aaf47b1bd0c..87c84a7ee14a 100644
--- a/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.rs
+++ b/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.rs
@@ -7,6 +7,7 @@ extern crate proc_macros;
 use proc_macros::{external, inline_macros};
 
 fn the_answer(ref mut x: u8) {
+    //~^ toplevel_ref_arg
     *x = 42;
 }
 
@@ -18,6 +19,7 @@ fn main() {
     // lint in macro
     inline! {
         fn fun_example(ref _x: usize) {}
+        //~^ toplevel_ref_arg
     }
 
     // do not lint in external macro
diff --git a/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.stderr b/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.stderr
index 26166e2fc8da..e17b2536874e 100644
--- a/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.stderr
+++ b/src/tools/clippy/tests/ui/toplevel_ref_arg_non_rustfix.stderr
@@ -8,7 +8,7 @@ LL | fn the_answer(ref mut x: u8) {
    = help: to override `-D warnings` add `#[allow(clippy::toplevel_ref_arg)]`
 
 error: `ref` directly on a function parameter does not prevent taking ownership of the passed argument. Consider using a reference type instead
-  --> tests/ui/toplevel_ref_arg_non_rustfix.rs:20:24
+  --> tests/ui/toplevel_ref_arg_non_rustfix.rs:21:24
    |
 LL |         fn fun_example(ref _x: usize) {}
    |                        ^^^^^^
diff --git a/src/tools/clippy/tests/ui/track-diagnostics.rs b/src/tools/clippy/tests/ui/track-diagnostics.rs
index 6ab0bce770e2..723ea23e9a63 100644
--- a/src/tools/clippy/tests/ui/track-diagnostics.rs
+++ b/src/tools/clippy/tests/ui/track-diagnostics.rs
@@ -7,5 +7,6 @@
 struct A;
 struct B;
 const S: A = B;
+//~^ ERROR: mismatched types
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/trailing_empty_array.rs b/src/tools/clippy/tests/ui/trailing_empty_array.rs
index ea3b8ff01afa..a8c3ffdb0dab 100644
--- a/src/tools/clippy/tests/ui/trailing_empty_array.rs
+++ b/src/tools/clippy/tests/ui/trailing_empty_array.rs
@@ -4,39 +4,39 @@
 // Do lint:
 
 struct RarelyUseful {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     field: i32,
     last: [usize; 0],
 }
 
 struct OnlyField {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     first_and_last: [usize; 0],
 }
 
 struct GenericArrayType<T> {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     field: i32,
     last: [T; 0],
 }
 
 #[must_use]
 struct OnlyAnotherAttribute {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     field: i32,
     last: [usize; 0],
 }
 
 #[derive(Debug)]
 struct OnlyADeriveAttribute {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     field: i32,
     last: [usize; 0],
 }
 
 const ZERO: usize = 0;
 struct ZeroSizedWithConst {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     field: i32,
     last: [usize; ZERO],
 }
@@ -46,7 +46,7 @@ const fn compute_zero() -> usize {
     (4 + 6) - (2 * 5)
 }
 struct ZeroSizedWithConstFunction {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     field: i32,
     last: [usize; compute_zero()],
 }
@@ -55,19 +55,19 @@ const fn compute_zero_from_arg(x: usize) -> usize {
     x - 1
 }
 struct ZeroSizedWithConstFunction2 {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     field: i32,
     last: [usize; compute_zero_from_arg(1)],
 }
 
 struct ZeroSizedArrayWrapper([usize; 0]);
-//~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+//~^ trailing_empty_array
 
 struct TupleStruct(i32, [usize; 0]);
-//~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+//~^ trailing_empty_array
 
 struct LotsOfFields {
-    //~^ ERROR: trailing zero-sized array in a struct which is not marked with a `repr` attrib
+    //~^ trailing_empty_array
     f1: u32,
     f2: u32,
     f3: u32,
diff --git a/src/tools/clippy/tests/ui/trailing_zeros.fixed b/src/tools/clippy/tests/ui/trailing_zeros.fixed
index f7de976f1e00..8c30b062fb18 100644
--- a/src/tools/clippy/tests/ui/trailing_zeros.fixed
+++ b/src/tools/clippy/tests/ui/trailing_zeros.fixed
@@ -4,10 +4,11 @@
 fn main() {
     let x: i32 = 42;
     let _ = x.trailing_zeros() >= 4;
-    //~^ ERROR: bit mask could be simplified with a call to `trailing_zeros`
-    //~| NOTE: `-D clippy::verbose-bit-mask` implied by `-D warnings`
+    //~^ verbose_bit_mask
+
     let _ = x.trailing_zeros() >= 5;
-    //~^ ERROR: bit mask could be simplified with a call to `trailing_zeros`
+    //~^ verbose_bit_mask
+
     let _ = x & 0b1_1010 == 0; // do not lint
     let _ = x & 1 == 0; // do not lint
 }
diff --git a/src/tools/clippy/tests/ui/trailing_zeros.rs b/src/tools/clippy/tests/ui/trailing_zeros.rs
index a05b09233e21..369a31557392 100644
--- a/src/tools/clippy/tests/ui/trailing_zeros.rs
+++ b/src/tools/clippy/tests/ui/trailing_zeros.rs
@@ -4,10 +4,11 @@
 fn main() {
     let x: i32 = 42;
     let _ = (x & 0b1111 == 0);
-    //~^ ERROR: bit mask could be simplified with a call to `trailing_zeros`
-    //~| NOTE: `-D clippy::verbose-bit-mask` implied by `-D warnings`
+    //~^ verbose_bit_mask
+
     let _ = x & 0b1_1111 == 0;
-    //~^ ERROR: bit mask could be simplified with a call to `trailing_zeros`
+    //~^ verbose_bit_mask
+
     let _ = x & 0b1_1010 == 0; // do not lint
     let _ = x & 1 == 0; // do not lint
 }
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed
index 708512793d50..666ff78b2189 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.fixed
@@ -5,12 +5,14 @@
 use std::any::Any;
 
 fn bad_foo<T: Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
 fn bad_bar<T, U>(arg0: T, arg1: U)
 where
     T: Clone + Copy,
+    //~^ trait_duplication_in_bounds
     U: Clone + Copy,
 {
     unimplemented!();
@@ -39,6 +41,7 @@ trait GoodSelfWhereClause {
 }
 
 trait BadSelfTraitBound: Clone {
+    //~^ trait_duplication_in_bounds
     fn f();
 }
 
@@ -46,6 +49,7 @@ trait BadSelfWhereClause {
     fn f()
     where
         Self: Clone;
+    //~^ trait_duplication_in_bounds
 }
 
 trait GoodTraitBound<T: Clone + Copy, U: Clone + Copy> {
@@ -60,6 +64,7 @@ trait GoodWhereClause<T, U> {
 }
 
 trait BadTraitBound<T: Clone + Copy, U: Clone + Copy> {
+    //~^ trait_duplication_in_bounds
     fn f();
 }
 
@@ -67,6 +72,7 @@ trait BadWhereClause<T, U> {
     fn f()
     where
         T: Clone + Copy,
+        //~^ trait_duplication_in_bounds
         U: Clone + Copy;
 }
 
@@ -100,6 +106,7 @@ fn good_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
 }
 
 fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
@@ -108,6 +115,7 @@ mod foo {
 }
 
 fn qualified_path<T: std::clone::Clone + foo::Clone>(arg0: T) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
@@ -116,6 +124,7 @@ fn good_trait_object(arg0: &(dyn Any + Send)) {
 }
 
 fn bad_trait_object(arg0: &(dyn Any + Send)) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs
index 12db6b65a7ae..a1a86fe058e6 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.rs
@@ -5,12 +5,14 @@
 use std::any::Any;
 
 fn bad_foo<T: Clone + Clone + Clone + Copy, U: Clone + Copy>(arg0: T, argo1: U) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
 fn bad_bar<T, U>(arg0: T, arg1: U)
 where
     T: Clone + Clone + Clone + Copy,
+    //~^ trait_duplication_in_bounds
     U: Clone + Copy,
 {
     unimplemented!();
@@ -39,6 +41,7 @@ trait GoodSelfWhereClause {
 }
 
 trait BadSelfTraitBound: Clone + Clone + Clone {
+    //~^ trait_duplication_in_bounds
     fn f();
 }
 
@@ -46,6 +49,7 @@ trait BadSelfWhereClause {
     fn f()
     where
         Self: Clone + Clone + Clone;
+    //~^ trait_duplication_in_bounds
 }
 
 trait GoodTraitBound<T: Clone + Copy, U: Clone + Copy> {
@@ -60,6 +64,7 @@ trait GoodWhereClause<T, U> {
 }
 
 trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
+    //~^ trait_duplication_in_bounds
     fn f();
 }
 
@@ -67,6 +72,7 @@ trait BadWhereClause<T, U> {
     fn f()
     where
         T: Clone + Clone + Clone + Copy,
+        //~^ trait_duplication_in_bounds
         U: Clone + Copy;
 }
 
@@ -100,6 +106,7 @@ fn good_generic<T: GenericTrait<u64> + GenericTrait<u32>>(arg0: T) {
 }
 
 fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
@@ -108,6 +115,7 @@ mod foo {
 }
 
 fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
@@ -116,6 +124,7 @@ fn good_trait_object(arg0: &(dyn Any + Send)) {
 }
 
 fn bad_trait_object(arg0: &(dyn Any + Send + Send)) {
+    //~^ trait_duplication_in_bounds
     unimplemented!();
 }
 
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr
index 83c06eaccd4e..d76b4e458480 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds.stderr
@@ -11,67 +11,67 @@ LL | #![deny(clippy::trait_duplication_in_bounds)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: these where clauses contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:13:8
+  --> tests/ui/trait_duplication_in_bounds.rs:14:8
    |
 LL |     T: Clone + Clone + Clone + Copy,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:41:26
+  --> tests/ui/trait_duplication_in_bounds.rs:43:26
    |
 LL | trait BadSelfTraitBound: Clone + Clone + Clone {
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these where clauses contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:48:15
+  --> tests/ui/trait_duplication_in_bounds.rs:51:15
    |
 LL |         Self: Clone + Clone + Clone;
    |               ^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone`
 
 error: these bounds contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:62:24
+  --> tests/ui/trait_duplication_in_bounds.rs:66:24
    |
 LL | trait BadTraitBound<T: Clone + Clone + Clone + Copy, U: Clone + Copy> {
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these where clauses contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:69:12
+  --> tests/ui/trait_duplication_in_bounds.rs:74:12
    |
 LL |         T: Clone + Clone + Clone + Copy,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Clone + Copy`
 
 error: these bounds contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:102:19
+  --> tests/ui/trait_duplication_in_bounds.rs:108:19
    |
 LL | fn bad_generic<T: GenericTrait<u64> + GenericTrait<u32> + GenericTrait<u64>>(arg0: T) {
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `GenericTrait<u64> + GenericTrait<u32>`
 
 error: these bounds contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:110:22
+  --> tests/ui/trait_duplication_in_bounds.rs:117:22
    |
 LL | fn qualified_path<T: std::clone::Clone + Clone + foo::Clone>(arg0: T) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::clone::Clone + foo::Clone`
 
 error: this trait bound is already specified in trait declaration
-  --> tests/ui/trait_duplication_in_bounds.rs:118:33
+  --> tests/ui/trait_duplication_in_bounds.rs:126:33
    |
 LL | fn bad_trait_object(arg0: &(dyn Any + Send + Send)) {
    |                                 ^^^^^^^^^^^^^^^^^ help: try: `Any + Send`
 
 error: these bounds contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:165:36
+  --> tests/ui/trait_duplication_in_bounds.rs:174:36
    |
 LL | const fn const_trait_bounds_bad<T: ~const ConstTrait + ~const ConstTrait>() {}
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `~const ConstTrait`
 
 error: these where clauses contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:172:8
+  --> tests/ui/trait_duplication_in_bounds.rs:181:8
    |
 LL |     T: IntoIterator<Item = U::Owned> + IntoIterator<Item = U::Owned>,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `IntoIterator<Item = U::Owned>`
 
 error: these where clauses contain repeated elements
-  --> tests/ui/trait_duplication_in_bounds.rs:194:8
+  --> tests/ui/trait_duplication_in_bounds.rs:203:8
    |
 LL |     T: AssocConstTrait<ASSOC = 0> + AssocConstTrait<ASSOC = 0>,
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `AssocConstTrait<ASSOC = 0>`
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.rs b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.rs
index b0095bb77b5a..cf72ed844a78 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.rs
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.rs
@@ -5,8 +5,8 @@ use std::collections::BTreeMap;
 use std::ops::{Add, AddAssign, Div, DivAssign, Mul, MulAssign, Sub, SubAssign};
 
 fn bad_foo<T: Clone + Default, Z: Copy>(arg0: T, arg1: Z)
-//~^ ERROR: this trait bound is already specified in the where clause
-//~| ERROR: this trait bound is already specified in the where clause
+//~^ trait_duplication_in_bounds
+//~| trait_duplication_in_bounds
 where
     T: Clone,
     T: Default,
@@ -36,7 +36,7 @@ trait T: Default {
     fn f()
     where
         Self: Default;
-    //~^ ERROR: this trait bound is already specified in trait declaration
+    //~^ trait_duplication_in_bounds
 }
 
 trait U: Default {
@@ -51,19 +51,21 @@ trait ZZ: Default {
     fn f()
     where
         Self: Default + Clone;
-    //~^ ERROR: this trait bound is already specified in trait declaration
+    //~^ trait_duplication_in_bounds
 }
 
 trait BadTrait: Default + Clone {
     fn f()
     where
         Self: Default + Clone;
-    //~^ ERROR: this trait bound is already specified in trait declaration
-    //~| ERROR: this trait bound is already specified in trait declaration
+    //~^ trait_duplication_in_bounds
+    //~| trait_duplication_in_bounds
+
     fn g()
     where
         Self: Default;
-    //~^ ERROR: this trait bound is already specified in trait declaration
+    //~^ trait_duplication_in_bounds
+
     fn h()
     where
         Self: Copy;
@@ -99,7 +101,7 @@ trait FooIter: Iterator<Item = Foo> {
     fn bar()
     where
         Self: Iterator<Item = Foo>,
-        //~^ ERROR: this trait bound is already specified in trait declaration
+        //~^ trait_duplication_in_bounds
     {
     }
 }
diff --git a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.stderr b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.stderr
index 41029007a98e..546d39518e1f 100644
--- a/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/trait_duplication_in_bounds_unfixable.stderr
@@ -52,7 +52,7 @@ LL |         Self: Default + Clone;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> tests/ui/trait_duplication_in_bounds_unfixable.rs:65:15
+  --> tests/ui/trait_duplication_in_bounds_unfixable.rs:66:15
    |
 LL |         Self: Default;
    |               ^^^^^^^
@@ -60,7 +60,7 @@ LL |         Self: Default;
    = help: consider removing this trait bound
 
 error: this trait bound is already specified in trait declaration
-  --> tests/ui/trait_duplication_in_bounds_unfixable.rs:101:15
+  --> tests/ui/trait_duplication_in_bounds_unfixable.rs:103:15
    |
 LL |         Self: Iterator<Item = Foo>,
    |               ^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/transmute.rs b/src/tools/clippy/tests/ui/transmute.rs
index 7f5bdea4acf3..3aecde398dc3 100644
--- a/src/tools/clippy/tests/ui/transmute.rs
+++ b/src/tools/clippy/tests/ui/transmute.rs
@@ -29,41 +29,40 @@ unsafe fn _generic<'a, T, U: 'a>(t: &'a T) {
     let _: &'a U = core::mem::transmute(t);
 
     let _: *const T = core::mem::transmute(t);
-    //~^ ERROR: transmute from a reference to a pointer
-    //~| NOTE: `-D clippy::useless-transmute` implied by `-D warnings`
+    //~^ useless_transmute
 
     let _: *mut T = core::mem::transmute(t);
-    //~^ ERROR: transmute from a reference to a pointer
+    //~^ useless_transmute
 
     let _: *const U = core::mem::transmute(t);
-    //~^ ERROR: transmute from a reference to a pointer
+    //~^ useless_transmute
 }
 
 #[warn(clippy::useless_transmute)]
 fn useless() {
     unsafe {
         let _: Vec<i32> = core::mem::transmute(my_vec());
-        //~^ ERROR: transmute from a type (`std::vec::Vec<i32>`) to itself
+        //~^ useless_transmute
 
         let _: Vec<i32> = core::mem::transmute(my_vec());
-        //~^ ERROR: transmute from a type (`std::vec::Vec<i32>`) to itself
+        //~^ useless_transmute
 
         let _: Vec<i32> = std::mem::transmute(my_vec());
-        //~^ ERROR: transmute from a type (`std::vec::Vec<i32>`) to itself
+        //~^ useless_transmute
 
         let _: Vec<i32> = std::mem::transmute(my_vec());
-        //~^ ERROR: transmute from a type (`std::vec::Vec<i32>`) to itself
+        //~^ useless_transmute
 
         let _: Vec<i32> = my_transmute(my_vec());
-        //~^ ERROR: transmute from a type (`std::vec::Vec<i32>`) to itself
+        //~^ useless_transmute
 
         let _: *const usize = std::mem::transmute(5_isize);
-        //~^ ERROR: transmute from an integer to a pointer
+        //~^ useless_transmute
 
         let _ = 5_isize as *const usize;
 
         let _: *const usize = std::mem::transmute(1 + 1usize);
-        //~^ ERROR: transmute from an integer to a pointer
+        //~^ useless_transmute
 
         let _ = (1 + 1_usize) as *const usize;
     }
@@ -95,77 +94,84 @@ fn crosspointer() {
 
     unsafe {
         let _: Usize = core::mem::transmute(int_const_ptr);
-        //~^ ERROR: transmute from a type (`*const Usize`) to the type that it points to (
-        //~| NOTE: `-D clippy::crosspointer-transmute` implied by `-D warnings`
+        //~^ crosspointer_transmute
 
         let _: Usize = core::mem::transmute(int_mut_ptr);
-        //~^ ERROR: transmute from a type (`*mut Usize`) to the type that it points to (`U
+        //~^ crosspointer_transmute
 
         let _: *const Usize = core::mem::transmute(my_int());
-        //~^ ERROR: transmute from a type (`Usize`) to a pointer to that type (`*const Usi
+        //~^ crosspointer_transmute
 
         let _: *mut Usize = core::mem::transmute(my_int());
-        //~^ ERROR: transmute from a type (`Usize`) to a pointer to that type (`*mut Usize
+        //~^ crosspointer_transmute
     }
 }
 
 #[warn(clippy::transmute_int_to_bool)]
 fn int_to_bool() {
     let _: bool = unsafe { std::mem::transmute(0_u8) };
-    //~^ ERROR: transmute from a `u8` to a `bool`
-    //~| NOTE: `-D clippy::transmute-int-to-bool` implied by `-D warnings`
+    //~^ transmute_int_to_bool
 }
 
 #[warn(clippy::transmute_int_to_float)]
 mod int_to_float {
     fn test() {
         let _: f16 = unsafe { std::mem::transmute(0_u16) };
-        //~^ ERROR: transmute from a `u16` to a `f16`
-        //~| NOTE: `-D clippy::transmute-int-to-float` implied by `-D warnings`
+        //~^ transmute_int_to_float
+
         let _: f16 = unsafe { std::mem::transmute(0_i16) };
-        //~^ ERROR: transmute from a `i16` to a `f16`
+        //~^ transmute_int_to_float
+
         let _: f32 = unsafe { std::mem::transmute(0_u32) };
-        //~^ ERROR: transmute from a `u32` to a `f32`
+        //~^ transmute_int_to_float
+
         let _: f32 = unsafe { std::mem::transmute(0_i32) };
-        //~^ ERROR: transmute from a `i32` to a `f32`
+        //~^ transmute_int_to_float
+
         let _: f64 = unsafe { std::mem::transmute(0_u64) };
-        //~^ ERROR: transmute from a `u64` to a `f64`
+        //~^ transmute_int_to_float
+
         let _: f64 = unsafe { std::mem::transmute(0_i64) };
-        //~^ ERROR: transmute from a `i64` to a `f64`
+        //~^ transmute_int_to_float
+
         let _: f128 = unsafe { std::mem::transmute(0_u128) };
-        //~^ ERROR: transmute from a `u128` to a `f128`
+        //~^ transmute_int_to_float
+
         let _: f128 = unsafe { std::mem::transmute(0_i128) };
-        //~^ ERROR: transmute from a `i128` to a `f128`
+        //~^ transmute_int_to_float
     }
 
     mod issue_5747 {
         const VALUE16: f16 = unsafe { std::mem::transmute(0_u16) };
-        //~^ ERROR: transmute from a `u16` to a `f16`
+        //~^ transmute_int_to_float
+
         const VALUE32: f32 = unsafe { std::mem::transmute(0_u32) };
-        //~^ ERROR: transmute from a `u32` to a `f32`
+        //~^ transmute_int_to_float
+
         const VALUE64: f64 = unsafe { std::mem::transmute(0_i64) };
-        //~^ ERROR: transmute from a `i64` to a `f64`
+        //~^ transmute_int_to_float
+
         const VALUE128: f128 = unsafe { std::mem::transmute(0_i128) };
-        //~^ ERROR: transmute from a `i128` to a `f128`
+        //~^ transmute_int_to_float
 
         const fn from_bits_16(v: i16) -> f16 {
             unsafe { std::mem::transmute(v) }
-            //~^ ERROR: transmute from a `i16` to a `f16`
+            //~^ transmute_int_to_float
         }
 
         const fn from_bits_32(v: i32) -> f32 {
             unsafe { std::mem::transmute(v) }
-            //~^ ERROR: transmute from a `i32` to a `f32`
+            //~^ transmute_int_to_float
         }
 
         const fn from_bits_64(v: u64) -> f64 {
             unsafe { std::mem::transmute(v) }
-            //~^ ERROR: transmute from a `u64` to a `f64`
+            //~^ transmute_int_to_float
         }
 
         const fn from_bits_128(v: u128) -> f128 {
             unsafe { std::mem::transmute(v) }
-            //~^ ERROR: transmute from a `u128` to a `f128`
+            //~^ transmute_int_to_float
         }
     }
 }
@@ -174,52 +180,67 @@ mod num_to_bytes {
     fn test() {
         unsafe {
             let _: [u8; 1] = std::mem::transmute(0u8);
-            //~^ ERROR: transmute from a `u8` to a `[u8; 1]`
-            //~| NOTE: `-D clippy::transmute-num-to-bytes` implied by `-D warnings`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 4] = std::mem::transmute(0u32);
-            //~^ ERROR: transmute from a `u32` to a `[u8; 4]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 16] = std::mem::transmute(0u128);
-            //~^ ERROR: transmute from a `u128` to a `[u8; 16]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 1] = std::mem::transmute(0i8);
-            //~^ ERROR: transmute from a `i8` to a `[u8; 1]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 4] = std::mem::transmute(0i32);
-            //~^ ERROR: transmute from a `i32` to a `[u8; 4]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 16] = std::mem::transmute(0i128);
-            //~^ ERROR: transmute from a `i128` to a `[u8; 16]`
+            //~^ transmute_num_to_bytes
 
             let _: [u8; 2] = std::mem::transmute(0.0f16);
-            //~^ ERROR: transmute from a `f16` to a `[u8; 2]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 4] = std::mem::transmute(0.0f32);
-            //~^ ERROR: transmute from a `f32` to a `[u8; 4]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 8] = std::mem::transmute(0.0f64);
-            //~^ ERROR: transmute from a `f64` to a `[u8; 8]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 16] = std::mem::transmute(0.0f128);
-            //~^ ERROR: transmute from a `f128` to a `[u8; 16]`
+            //~^ transmute_num_to_bytes
         }
     }
     const fn test_const() {
         unsafe {
             let _: [u8; 1] = std::mem::transmute(0u8);
-            //~^ ERROR: transmute from a `u8` to a `[u8; 1]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 4] = std::mem::transmute(0u32);
-            //~^ ERROR: transmute from a `u32` to a `[u8; 4]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 16] = std::mem::transmute(0u128);
-            //~^ ERROR: transmute from a `u128` to a `[u8; 16]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 1] = std::mem::transmute(0i8);
-            //~^ ERROR: transmute from a `i8` to a `[u8; 1]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 4] = std::mem::transmute(0i32);
-            //~^ ERROR: transmute from a `i32` to a `[u8; 4]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 16] = std::mem::transmute(0i128);
-            //~^ ERROR: transmute from a `i128` to a `[u8; 16]`
+            //~^ transmute_num_to_bytes
 
             let _: [u8; 2] = std::mem::transmute(0.0f16);
-            //~^ ERROR: transmute from a `f16` to a `[u8; 2]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 4] = std::mem::transmute(0.0f32);
-            //~^ ERROR: transmute from a `f32` to a `[u8; 4]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 8] = std::mem::transmute(0.0f64);
-            //~^ ERROR: transmute from a `f64` to a `[u8; 8]`
+            //~^ transmute_num_to_bytes
+
             let _: [u8; 16] = std::mem::transmute(0.0f128);
-            //~^ ERROR: transmute from a `f128` to a `[u8; 16]`
+            //~^ transmute_num_to_bytes
         }
     }
 }
@@ -228,12 +249,13 @@ fn bytes_to_str(mb: &mut [u8]) {
     const B: &[u8] = b"";
 
     let _: &str = unsafe { std::mem::transmute(B) };
-    //~^ ERROR: transmute from a `&[u8]` to a `&str`
-    //~| NOTE: `-D clippy::transmute-bytes-to-str` implied by `-D warnings`
+    //~^ transmute_bytes_to_str
+
     let _: &mut str = unsafe { std::mem::transmute(mb) };
-    //~^ ERROR: transmute from a `&mut [u8]` to a `&mut str`
+    //~^ transmute_bytes_to_str
+
     const _: &str = unsafe { std::mem::transmute(B) };
-    //~^ ERROR: transmute from a `&[u8]` to a `&str`
+    //~^ transmute_bytes_to_str
 }
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/transmute.stderr b/src/tools/clippy/tests/ui/transmute.stderr
index b5032772856e..e0d28437aafc 100644
--- a/src/tools/clippy/tests/ui/transmute.stderr
+++ b/src/tools/clippy/tests/ui/transmute.stderr
@@ -8,61 +8,61 @@ LL |     let _: *const T = core::mem::transmute(t);
    = help: to override `-D warnings` add `#[allow(clippy::useless_transmute)]`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmute.rs:35:21
+  --> tests/ui/transmute.rs:34:21
    |
 LL |     let _: *mut T = core::mem::transmute(t);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *mut T`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmute.rs:38:23
+  --> tests/ui/transmute.rs:37:23
    |
 LL |     let _: *const U = core::mem::transmute(t);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `t as *const T as *const U`
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:45:27
+  --> tests/ui/transmute.rs:44:27
    |
 LL |         let _: Vec<i32> = core::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:48:27
+  --> tests/ui/transmute.rs:47:27
    |
 LL |         let _: Vec<i32> = core::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:51:27
+  --> tests/ui/transmute.rs:50:27
    |
 LL |         let _: Vec<i32> = std::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:54:27
+  --> tests/ui/transmute.rs:53:27
    |
 LL |         let _: Vec<i32> = std::mem::transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`std::vec::Vec<i32>`) to itself
-  --> tests/ui/transmute.rs:57:27
+  --> tests/ui/transmute.rs:56:27
    |
 LL |         let _: Vec<i32> = my_transmute(my_vec());
    |                           ^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from an integer to a pointer
-  --> tests/ui/transmute.rs:60:31
+  --> tests/ui/transmute.rs:59:31
    |
 LL |         let _: *const usize = std::mem::transmute(5_isize);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `5_isize as *const usize`
 
 error: transmute from an integer to a pointer
-  --> tests/ui/transmute.rs:65:31
+  --> tests/ui/transmute.rs:64:31
    |
 LL |         let _: *const usize = std::mem::transmute(1 + 1usize);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(1 + 1usize) as *const usize`
 
 error: transmute from a type (`*const Usize`) to the type that it points to (`Usize`)
-  --> tests/ui/transmute.rs:97:24
+  --> tests/ui/transmute.rs:96:24
    |
 LL |         let _: Usize = core::mem::transmute(int_const_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,25 +71,25 @@ LL |         let _: Usize = core::mem::transmute(int_const_ptr);
    = help: to override `-D warnings` add `#[allow(clippy::crosspointer_transmute)]`
 
 error: transmute from a type (`*mut Usize`) to the type that it points to (`Usize`)
-  --> tests/ui/transmute.rs:101:24
+  --> tests/ui/transmute.rs:99:24
    |
 LL |         let _: Usize = core::mem::transmute(int_mut_ptr);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*const Usize`)
-  --> tests/ui/transmute.rs:104:31
+  --> tests/ui/transmute.rs:102:31
    |
 LL |         let _: *const Usize = core::mem::transmute(my_int());
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a type (`Usize`) to a pointer to that type (`*mut Usize`)
-  --> tests/ui/transmute.rs:107:29
+  --> tests/ui/transmute.rs:105:29
    |
 LL |         let _: *mut Usize = core::mem::transmute(my_int());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a `u8` to a `bool`
-  --> tests/ui/transmute.rs:114:28
+  --> tests/ui/transmute.rs:112:28
    |
 LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `0_u8 != 0`
@@ -98,7 +98,7 @@ LL |     let _: bool = unsafe { std::mem::transmute(0_u8) };
    = help: to override `-D warnings` add `#[allow(clippy::transmute_int_to_bool)]`
 
 error: transmute from a `u16` to a `f16`
-  --> tests/ui/transmute.rs:122:31
+  --> tests/ui/transmute.rs:119:31
    |
 LL |         let _: f16 = unsafe { std::mem::transmute(0_u16) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f16::from_bits(0_u16)`
@@ -107,19 +107,19 @@ LL |         let _: f16 = unsafe { std::mem::transmute(0_u16) };
    = help: to override `-D warnings` add `#[allow(clippy::transmute_int_to_float)]`
 
 error: transmute from a `i16` to a `f16`
-  --> tests/ui/transmute.rs:125:31
+  --> tests/ui/transmute.rs:122:31
    |
 LL |         let _: f16 = unsafe { std::mem::transmute(0_i16) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f16::from_bits(0_i16 as u16)`
 
 error: transmute from a `u32` to a `f32`
-  --> tests/ui/transmute.rs:127:31
+  --> tests/ui/transmute.rs:125:31
    |
 LL |         let _: f32 = unsafe { std::mem::transmute(0_u32) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_u32)`
 
 error: transmute from a `i32` to a `f32`
-  --> tests/ui/transmute.rs:129:31
+  --> tests/ui/transmute.rs:128:31
    |
 LL |         let _: f32 = unsafe { std::mem::transmute(0_i32) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_i32 as u32)`
@@ -131,73 +131,73 @@ LL |         let _: f64 = unsafe { std::mem::transmute(0_u64) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_u64)`
 
 error: transmute from a `i64` to a `f64`
-  --> tests/ui/transmute.rs:133:31
+  --> tests/ui/transmute.rs:134:31
    |
 LL |         let _: f64 = unsafe { std::mem::transmute(0_i64) };
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_i64 as u64)`
 
 error: transmute from a `u128` to a `f128`
-  --> tests/ui/transmute.rs:135:32
+  --> tests/ui/transmute.rs:137:32
    |
 LL |         let _: f128 = unsafe { std::mem::transmute(0_u128) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(0_u128)`
 
 error: transmute from a `i128` to a `f128`
-  --> tests/ui/transmute.rs:137:32
+  --> tests/ui/transmute.rs:140:32
    |
 LL |         let _: f128 = unsafe { std::mem::transmute(0_i128) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(0_i128 as u128)`
 
 error: transmute from a `u16` to a `f16`
-  --> tests/ui/transmute.rs:142:39
+  --> tests/ui/transmute.rs:145:39
    |
 LL |         const VALUE16: f16 = unsafe { std::mem::transmute(0_u16) };
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f16::from_bits(0_u16)`
 
 error: transmute from a `u32` to a `f32`
-  --> tests/ui/transmute.rs:144:39
+  --> tests/ui/transmute.rs:148:39
    |
 LL |         const VALUE32: f32 = unsafe { std::mem::transmute(0_u32) };
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(0_u32)`
 
 error: transmute from a `i64` to a `f64`
-  --> tests/ui/transmute.rs:146:39
+  --> tests/ui/transmute.rs:151:39
    |
 LL |         const VALUE64: f64 = unsafe { std::mem::transmute(0_i64) };
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(0_i64 as u64)`
 
 error: transmute from a `i128` to a `f128`
-  --> tests/ui/transmute.rs:148:41
+  --> tests/ui/transmute.rs:154:41
    |
 LL |         const VALUE128: f128 = unsafe { std::mem::transmute(0_i128) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(0_i128 as u128)`
 
 error: transmute from a `i16` to a `f16`
-  --> tests/ui/transmute.rs:152:22
+  --> tests/ui/transmute.rs:158:22
    |
 LL |             unsafe { std::mem::transmute(v) }
    |                      ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f16::from_bits(v as u16)`
 
 error: transmute from a `i32` to a `f32`
-  --> tests/ui/transmute.rs:157:22
+  --> tests/ui/transmute.rs:163:22
    |
 LL |             unsafe { std::mem::transmute(v) }
    |                      ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f32::from_bits(v as u32)`
 
 error: transmute from a `u64` to a `f64`
-  --> tests/ui/transmute.rs:162:22
+  --> tests/ui/transmute.rs:168:22
    |
 LL |             unsafe { std::mem::transmute(v) }
    |                      ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f64::from_bits(v)`
 
 error: transmute from a `u128` to a `f128`
-  --> tests/ui/transmute.rs:167:22
+  --> tests/ui/transmute.rs:173:22
    |
 LL |             unsafe { std::mem::transmute(v) }
    |                      ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f128::from_bits(v)`
 
 error: transmute from a `u8` to a `[u8; 1]`
-  --> tests/ui/transmute.rs:176:30
+  --> tests/ui/transmute.rs:182:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
@@ -206,121 +206,121 @@ LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    = help: to override `-D warnings` add `#[allow(clippy::transmute_num_to_bytes)]`
 
 error: transmute from a `u32` to a `[u8; 4]`
-  --> tests/ui/transmute.rs:179:30
+  --> tests/ui/transmute.rs:185:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0u32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
 
 error: transmute from a `u128` to a `[u8; 16]`
-  --> tests/ui/transmute.rs:181:31
+  --> tests/ui/transmute.rs:188:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0u128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
 
 error: transmute from a `i8` to a `[u8; 1]`
-  --> tests/ui/transmute.rs:183:30
+  --> tests/ui/transmute.rs:191:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0i8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
 
 error: transmute from a `i32` to a `[u8; 4]`
-  --> tests/ui/transmute.rs:185:30
+  --> tests/ui/transmute.rs:194:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0i32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
 
 error: transmute from a `i128` to a `[u8; 16]`
-  --> tests/ui/transmute.rs:187:31
+  --> tests/ui/transmute.rs:197:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0i128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
 
 error: transmute from a `f16` to a `[u8; 2]`
-  --> tests/ui/transmute.rs:190:30
+  --> tests/ui/transmute.rs:200:30
    |
 LL |             let _: [u8; 2] = std::mem::transmute(0.0f16);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f16.to_ne_bytes()`
 
 error: transmute from a `f32` to a `[u8; 4]`
-  --> tests/ui/transmute.rs:192:30
+  --> tests/ui/transmute.rs:203:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0.0f32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()`
 
 error: transmute from a `f64` to a `[u8; 8]`
-  --> tests/ui/transmute.rs:194:30
+  --> tests/ui/transmute.rs:206:30
    |
 LL |             let _: [u8; 8] = std::mem::transmute(0.0f64);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()`
 
 error: transmute from a `f128` to a `[u8; 16]`
-  --> tests/ui/transmute.rs:196:31
+  --> tests/ui/transmute.rs:209:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0.0f128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f128.to_ne_bytes()`
 
 error: transmute from a `u8` to a `[u8; 1]`
-  --> tests/ui/transmute.rs:202:30
+  --> tests/ui/transmute.rs:215:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0u8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u8.to_ne_bytes()`
 
 error: transmute from a `u32` to a `[u8; 4]`
-  --> tests/ui/transmute.rs:204:30
+  --> tests/ui/transmute.rs:218:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0u32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u32.to_ne_bytes()`
 
 error: transmute from a `u128` to a `[u8; 16]`
-  --> tests/ui/transmute.rs:206:31
+  --> tests/ui/transmute.rs:221:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0u128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0u128.to_ne_bytes()`
 
 error: transmute from a `i8` to a `[u8; 1]`
-  --> tests/ui/transmute.rs:208:30
+  --> tests/ui/transmute.rs:224:30
    |
 LL |             let _: [u8; 1] = std::mem::transmute(0i8);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i8.to_ne_bytes()`
 
 error: transmute from a `i32` to a `[u8; 4]`
-  --> tests/ui/transmute.rs:210:30
+  --> tests/ui/transmute.rs:227:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0i32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i32.to_ne_bytes()`
 
 error: transmute from a `i128` to a `[u8; 16]`
-  --> tests/ui/transmute.rs:212:31
+  --> tests/ui/transmute.rs:230:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0i128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0i128.to_ne_bytes()`
 
 error: transmute from a `f16` to a `[u8; 2]`
-  --> tests/ui/transmute.rs:215:30
+  --> tests/ui/transmute.rs:233:30
    |
 LL |             let _: [u8; 2] = std::mem::transmute(0.0f16);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f16.to_ne_bytes()`
 
 error: transmute from a `f32` to a `[u8; 4]`
-  --> tests/ui/transmute.rs:217:30
+  --> tests/ui/transmute.rs:236:30
    |
 LL |             let _: [u8; 4] = std::mem::transmute(0.0f32);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f32.to_ne_bytes()`
 
 error: transmute from a `f64` to a `[u8; 8]`
-  --> tests/ui/transmute.rs:219:30
+  --> tests/ui/transmute.rs:239:30
    |
 LL |             let _: [u8; 8] = std::mem::transmute(0.0f64);
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f64.to_ne_bytes()`
 
 error: transmute from a `f128` to a `[u8; 16]`
-  --> tests/ui/transmute.rs:221:31
+  --> tests/ui/transmute.rs:242:31
    |
 LL |             let _: [u8; 16] = std::mem::transmute(0.0f128);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `to_ne_bytes()`: `0.0f128.to_ne_bytes()`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> tests/ui/transmute.rs:230:28
+  --> tests/ui/transmute.rs:251:28
    |
 LL |     let _: &str = unsafe { std::mem::transmute(B) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8(B).unwrap()`
@@ -329,13 +329,13 @@ LL |     let _: &str = unsafe { std::mem::transmute(B) };
    = help: to override `-D warnings` add `#[allow(clippy::transmute_bytes_to_str)]`
 
 error: transmute from a `&mut [u8]` to a `&mut str`
-  --> tests/ui/transmute.rs:233:32
+  --> tests/ui/transmute.rs:254:32
    |
 LL |     let _: &mut str = unsafe { std::mem::transmute(mb) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_mut(mb).unwrap()`
 
 error: transmute from a `&[u8]` to a `&str`
-  --> tests/ui/transmute.rs:235:30
+  --> tests/ui/transmute.rs:257:30
    |
 LL |     const _: &str = unsafe { std::mem::transmute(B) };
    |                              ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `std::str::from_utf8_unchecked(B)`
diff --git a/src/tools/clippy/tests/ui/transmute_32bit.rs b/src/tools/clippy/tests/ui/transmute_32bit.rs
index e162bbb2d929..997f43ab12b5 100644
--- a/src/tools/clippy/tests/ui/transmute_32bit.rs
+++ b/src/tools/clippy/tests/ui/transmute_32bit.rs
@@ -3,12 +3,12 @@
 #[warn(clippy::wrong_transmute)]
 fn main() {
     unsafe {
-        let _: *const usize = std::mem::transmute(6.0f32);
+        let _: *const usize = std::mem::transmute(6.0f32); //~ wrong_transmute
 
-        let _: *mut usize = std::mem::transmute(6.0f32);
+        let _: *mut usize = std::mem::transmute(6.0f32); //~ wrong_transmute
 
-        let _: *const usize = std::mem::transmute('x');
+        let _: *const usize = std::mem::transmute('x'); //~ wrong_transmute
 
-        let _: *mut usize = std::mem::transmute('x');
+        let _: *mut usize = std::mem::transmute('x'); //~ wrong_transmute
     }
 }
diff --git a/src/tools/clippy/tests/ui/transmute_64bit.rs b/src/tools/clippy/tests/ui/transmute_64bit.rs
index fd0ad74bcfa0..1a4bfffdc322 100644
--- a/src/tools/clippy/tests/ui/transmute_64bit.rs
+++ b/src/tools/clippy/tests/ui/transmute_64bit.rs
@@ -4,10 +4,9 @@
 fn main() {
     unsafe {
         let _: *const usize = std::mem::transmute(6.0f64);
-        //~^ ERROR: transmute from a `f64` to a pointer
-        //~| NOTE: `-D clippy::wrong-transmute` implied by `-D warnings`
+        //~^ wrong_transmute
 
         let _: *mut usize = std::mem::transmute(6.0f64);
-        //~^ ERROR: transmute from a `f64` to a pointer
+        //~^ wrong_transmute
     }
 }
diff --git a/src/tools/clippy/tests/ui/transmute_64bit.stderr b/src/tools/clippy/tests/ui/transmute_64bit.stderr
index 65fff17f59fa..e75b81671e09 100644
--- a/src/tools/clippy/tests/ui/transmute_64bit.stderr
+++ b/src/tools/clippy/tests/ui/transmute_64bit.stderr
@@ -8,7 +8,7 @@ LL |         let _: *const usize = std::mem::transmute(6.0f64);
    = help: to override `-D warnings` add `#[allow(clippy::wrong_transmute)]`
 
 error: transmute from a `f64` to a pointer
-  --> tests/ui/transmute_64bit.rs:10:29
+  --> tests/ui/transmute_64bit.rs:9:29
    |
 LL |         let _: *mut usize = std::mem::transmute(6.0f64);
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/transmute_collection.rs b/src/tools/clippy/tests/ui/transmute_collection.rs
index 6748b66e0eb6..74d7f5e38bf8 100644
--- a/src/tools/clippy/tests/ui/transmute_collection.rs
+++ b/src/tools/clippy/tests/ui/transmute_collection.rs
@@ -8,61 +8,71 @@ fn main() {
     unsafe {
         // wrong size
         let _ = transmute::<_, Vec<u32>>(vec![0u8]);
-        //~^ ERROR: transmute from `std::vec::Vec<u8>` to `std::vec::Vec<u32>` with mismat
-        //~| NOTE: `-D clippy::unsound-collection-transmute` implied by `-D warnings`
+        //~^ unsound_collection_transmute
+
         // wrong layout
         let _ = transmute::<_, Vec<[u8; 4]>>(vec![1234u32]);
-        //~^ ERROR: transmute from `std::vec::Vec<u32>` to `std::vec::Vec<[u8; 4]>` with m
+        //~^ unsound_collection_transmute
 
         // wrong size
         let _ = transmute::<_, VecDeque<u32>>(VecDeque::<u8>::new());
-        //~^ ERROR: transmute from `std::collections::VecDeque<u8>` to `std::collections::
+        //~^ unsound_collection_transmute
+
         // wrong layout
         let _ = transmute::<_, VecDeque<u32>>(VecDeque::<[u8; 4]>::new());
-        //~^ ERROR: transmute from `std::collections::VecDeque<[u8; 4]>` to `std::collecti
+        //~^ unsound_collection_transmute
 
         // wrong size
         let _ = transmute::<_, BinaryHeap<u32>>(BinaryHeap::<u8>::new());
-        //~^ ERROR: transmute from `std::collections::BinaryHeap<u8>` to `std::collections
+        //~^ unsound_collection_transmute
+
         // wrong layout
         let _ = transmute::<_, BinaryHeap<u32>>(BinaryHeap::<[u8; 4]>::new());
-        //~^ ERROR: transmute from `std::collections::BinaryHeap<[u8; 4]>` to `std::collec
+        //~^ unsound_collection_transmute
 
         // wrong size
         let _ = transmute::<_, BTreeSet<u32>>(BTreeSet::<u8>::new());
-        //~^ ERROR: transmute from `std::collections::BTreeSet<u8>` to `std::collections::
+        //~^ unsound_collection_transmute
+
         // wrong layout
         let _ = transmute::<_, BTreeSet<u32>>(BTreeSet::<[u8; 4]>::new());
-        //~^ ERROR: transmute from `std::collections::BTreeSet<[u8; 4]>` to `std::collecti
+        //~^ unsound_collection_transmute
 
         // wrong size
         let _ = transmute::<_, HashSet<u32>>(HashSet::<u8>::new());
-        //~^ ERROR: transmute from `std::collections::HashSet<u8>` to `std::collections::H
+        //~^ unsound_collection_transmute
+
         // wrong layout
         let _ = transmute::<_, HashSet<u32>>(HashSet::<[u8; 4]>::new());
-        //~^ ERROR: transmute from `std::collections::HashSet<[u8; 4]>` to `std::collectio
+        //~^ unsound_collection_transmute
 
         // wrong size
         let _ = transmute::<_, BTreeMap<u8, u32>>(BTreeMap::<u8, u8>::new());
-        //~^ ERROR: transmute from `std::collections::BTreeMap<u8, u8>` to `std::collectio
+        //~^ unsound_collection_transmute
+
         let _ = transmute::<_, BTreeMap<u8, u32>>(BTreeMap::<u32, u32>::new());
-        //~^ ERROR: transmute from `std::collections::BTreeMap<u32, u32>` to `std::collect
+        //~^ unsound_collection_transmute
+
         // wrong layout
         let _ = transmute::<_, BTreeMap<u8, u32>>(BTreeMap::<u8, [u8; 4]>::new());
-        //~^ ERROR: transmute from `std::collections::BTreeMap<u8, [u8; 4]>` to `std::coll
+        //~^ unsound_collection_transmute
+
         let _ = transmute::<_, BTreeMap<u32, u32>>(BTreeMap::<[u8; 4], u32>::new());
-        //~^ ERROR: transmute from `std::collections::BTreeMap<[u8; 4], u32>` to `std::col
+        //~^ unsound_collection_transmute
 
         // wrong size
         let _ = transmute::<_, HashMap<u8, u32>>(HashMap::<u8, u8>::new());
-        //~^ ERROR: transmute from `std::collections::HashMap<u8, u8>` to `std::collection
+        //~^ unsound_collection_transmute
+
         let _ = transmute::<_, HashMap<u8, u32>>(HashMap::<u32, u32>::new());
-        //~^ ERROR: transmute from `std::collections::HashMap<u32, u32>` to `std::collecti
+        //~^ unsound_collection_transmute
+
         // wrong layout
         let _ = transmute::<_, HashMap<u8, u32>>(HashMap::<u8, [u8; 4]>::new());
-        //~^ ERROR: transmute from `std::collections::HashMap<u8, [u8; 4]>` to `std::colle
+        //~^ unsound_collection_transmute
+
         let _ = transmute::<_, HashMap<u32, u32>>(HashMap::<[u8; 4], u32>::new());
-        //~^ ERROR: transmute from `std::collections::HashMap<[u8; 4], u32>` to `std::coll
+        //~^ unsound_collection_transmute
 
         let _ = transmute::<_, Vec<u8>>(Vec::<MaybeUninit<u8>>::new());
         let _ = transmute::<_, Vec<*mut u32>>(Vec::<Box<u32>>::new());
diff --git a/src/tools/clippy/tests/ui/transmute_collection.stderr b/src/tools/clippy/tests/ui/transmute_collection.stderr
index 06db9321064b..ac2de07f6bf2 100644
--- a/src/tools/clippy/tests/ui/transmute_collection.stderr
+++ b/src/tools/clippy/tests/ui/transmute_collection.stderr
@@ -20,91 +20,91 @@ LL |         let _ = transmute::<_, VecDeque<u32>>(VecDeque::<u8>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::VecDeque<[u8; 4]>` to `std::collections::VecDeque<u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:21:17
+  --> tests/ui/transmute_collection.rs:22:17
    |
 LL |         let _ = transmute::<_, VecDeque<u32>>(VecDeque::<[u8; 4]>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BinaryHeap<u8>` to `std::collections::BinaryHeap<u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:25:17
+  --> tests/ui/transmute_collection.rs:26:17
    |
 LL |         let _ = transmute::<_, BinaryHeap<u32>>(BinaryHeap::<u8>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BinaryHeap<[u8; 4]>` to `std::collections::BinaryHeap<u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:28:17
+  --> tests/ui/transmute_collection.rs:30:17
    |
 LL |         let _ = transmute::<_, BinaryHeap<u32>>(BinaryHeap::<[u8; 4]>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BTreeSet<u8>` to `std::collections::BTreeSet<u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:32:17
+  --> tests/ui/transmute_collection.rs:34:17
    |
 LL |         let _ = transmute::<_, BTreeSet<u32>>(BTreeSet::<u8>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BTreeSet<[u8; 4]>` to `std::collections::BTreeSet<u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:35:17
+  --> tests/ui/transmute_collection.rs:38:17
    |
 LL |         let _ = transmute::<_, BTreeSet<u32>>(BTreeSet::<[u8; 4]>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::HashSet<u8>` to `std::collections::HashSet<u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:39:17
+  --> tests/ui/transmute_collection.rs:42:17
    |
 LL |         let _ = transmute::<_, HashSet<u32>>(HashSet::<u8>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::HashSet<[u8; 4]>` to `std::collections::HashSet<u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:42:17
+  --> tests/ui/transmute_collection.rs:46:17
    |
 LL |         let _ = transmute::<_, HashSet<u32>>(HashSet::<[u8; 4]>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BTreeMap<u8, u8>` to `std::collections::BTreeMap<u8, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:46:17
+  --> tests/ui/transmute_collection.rs:50:17
    |
 LL |         let _ = transmute::<_, BTreeMap<u8, u32>>(BTreeMap::<u8, u8>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BTreeMap<u32, u32>` to `std::collections::BTreeMap<u8, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:48:17
+  --> tests/ui/transmute_collection.rs:53:17
    |
 LL |         let _ = transmute::<_, BTreeMap<u8, u32>>(BTreeMap::<u32, u32>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BTreeMap<u8, [u8; 4]>` to `std::collections::BTreeMap<u8, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:51:17
+  --> tests/ui/transmute_collection.rs:57:17
    |
 LL |         let _ = transmute::<_, BTreeMap<u8, u32>>(BTreeMap::<u8, [u8; 4]>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::BTreeMap<[u8; 4], u32>` to `std::collections::BTreeMap<u32, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:53:17
+  --> tests/ui/transmute_collection.rs:60:17
    |
 LL |         let _ = transmute::<_, BTreeMap<u32, u32>>(BTreeMap::<[u8; 4], u32>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::HashMap<u8, u8>` to `std::collections::HashMap<u8, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:57:17
+  --> tests/ui/transmute_collection.rs:64:17
    |
 LL |         let _ = transmute::<_, HashMap<u8, u32>>(HashMap::<u8, u8>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::HashMap<u32, u32>` to `std::collections::HashMap<u8, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:59:17
+  --> tests/ui/transmute_collection.rs:67:17
    |
 LL |         let _ = transmute::<_, HashMap<u8, u32>>(HashMap::<u32, u32>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::HashMap<u8, [u8; 4]>` to `std::collections::HashMap<u8, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:62:17
+  --> tests/ui/transmute_collection.rs:71:17
    |
 LL |         let _ = transmute::<_, HashMap<u8, u32>>(HashMap::<u8, [u8; 4]>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from `std::collections::HashMap<[u8; 4], u32>` to `std::collections::HashMap<u32, u32>` with mismatched layout is unsound
-  --> tests/ui/transmute_collection.rs:64:17
+  --> tests/ui/transmute_collection.rs:74:17
    |
 LL |         let _ = transmute::<_, HashMap<u32, u32>>(HashMap::<[u8; 4], u32>::new());
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/transmute_float_to_int.fixed b/src/tools/clippy/tests/ui/transmute_float_to_int.fixed
index 075a198918a0..1f97b997eaa0 100644
--- a/src/tools/clippy/tests/ui/transmute_float_to_int.fixed
+++ b/src/tools/clippy/tests/ui/transmute_float_to_int.fixed
@@ -5,48 +5,55 @@
 
 fn float_to_int() {
     let _: u32 = unsafe { 1f32.to_bits() };
-    //~^ ERROR: transmute from a `f32` to a `u32`
-    //~| NOTE: `-D clippy::transmute-float-to-int` implied by `-D warnings`
+    //~^ transmute_float_to_int
+
     let _: i32 = unsafe { 1f32.to_bits() as i32 };
-    //~^ ERROR: transmute from a `f32` to a `i32`
+    //~^ transmute_float_to_int
+
     let _: u64 = unsafe { 1f64.to_bits() };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
+
     let _: i64 = unsafe { 1f64.to_bits() as i64 };
-    //~^ ERROR: transmute from a `f64` to a `i64`
+    //~^ transmute_float_to_int
+
     let _: u64 = unsafe { 1.0f64.to_bits() };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
+
     let _: u64 = unsafe { (-1.0f64).to_bits() };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
 }
 
 mod issue_5747 {
     const VALUE16: i16 = unsafe { 1f16.to_bits() as i16 };
-    //~^ ERROR: transmute from a `f16` to a `i16`
+    //~^ transmute_float_to_int
+
     const VALUE32: i32 = unsafe { 1f32.to_bits() as i32 };
-    //~^ ERROR: transmute from a `f32` to a `i32`
+    //~^ transmute_float_to_int
+
     const VALUE64: u64 = unsafe { 1f64.to_bits() };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
+
     const VALUE128: u128 = unsafe { 1f128.to_bits() };
-    //~^ ERROR: transmute from a `f128` to a `u128`
+    //~^ transmute_float_to_int
 
     const fn to_bits_16(v: f16) -> u16 {
         unsafe { v.to_bits() }
-        //~^ ERROR: transmute from a `f16` to a `u16`
+        //~^ transmute_float_to_int
     }
 
     const fn to_bits_32(v: f32) -> u32 {
         unsafe { v.to_bits() }
-        //~^ ERROR: transmute from a `f32` to a `u32`
+        //~^ transmute_float_to_int
     }
 
     const fn to_bits_64(v: f64) -> i64 {
         unsafe { v.to_bits() as i64 }
-        //~^ ERROR: transmute from a `f64` to a `i64`
+        //~^ transmute_float_to_int
     }
 
     const fn to_bits_128(v: f128) -> i128 {
         unsafe { v.to_bits() as i128 }
-        //~^ ERROR: transmute from a `f128` to a `i128`
+        //~^ transmute_float_to_int
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/transmute_float_to_int.rs b/src/tools/clippy/tests/ui/transmute_float_to_int.rs
index 12541b2f7cf3..788a7e1026c6 100644
--- a/src/tools/clippy/tests/ui/transmute_float_to_int.rs
+++ b/src/tools/clippy/tests/ui/transmute_float_to_int.rs
@@ -5,48 +5,55 @@
 
 fn float_to_int() {
     let _: u32 = unsafe { std::mem::transmute(1f32) };
-    //~^ ERROR: transmute from a `f32` to a `u32`
-    //~| NOTE: `-D clippy::transmute-float-to-int` implied by `-D warnings`
+    //~^ transmute_float_to_int
+
     let _: i32 = unsafe { std::mem::transmute(1f32) };
-    //~^ ERROR: transmute from a `f32` to a `i32`
+    //~^ transmute_float_to_int
+
     let _: u64 = unsafe { std::mem::transmute(1f64) };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
+
     let _: i64 = unsafe { std::mem::transmute(1f64) };
-    //~^ ERROR: transmute from a `f64` to a `i64`
+    //~^ transmute_float_to_int
+
     let _: u64 = unsafe { std::mem::transmute(1.0) };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
+
     let _: u64 = unsafe { std::mem::transmute(-1.0) };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
 }
 
 mod issue_5747 {
     const VALUE16: i16 = unsafe { std::mem::transmute(1f16) };
-    //~^ ERROR: transmute from a `f16` to a `i16`
+    //~^ transmute_float_to_int
+
     const VALUE32: i32 = unsafe { std::mem::transmute(1f32) };
-    //~^ ERROR: transmute from a `f32` to a `i32`
+    //~^ transmute_float_to_int
+
     const VALUE64: u64 = unsafe { std::mem::transmute(1f64) };
-    //~^ ERROR: transmute from a `f64` to a `u64`
+    //~^ transmute_float_to_int
+
     const VALUE128: u128 = unsafe { std::mem::transmute(1f128) };
-    //~^ ERROR: transmute from a `f128` to a `u128`
+    //~^ transmute_float_to_int
 
     const fn to_bits_16(v: f16) -> u16 {
         unsafe { std::mem::transmute(v) }
-        //~^ ERROR: transmute from a `f16` to a `u16`
+        //~^ transmute_float_to_int
     }
 
     const fn to_bits_32(v: f32) -> u32 {
         unsafe { std::mem::transmute(v) }
-        //~^ ERROR: transmute from a `f32` to a `u32`
+        //~^ transmute_float_to_int
     }
 
     const fn to_bits_64(v: f64) -> i64 {
         unsafe { std::mem::transmute(v) }
-        //~^ ERROR: transmute from a `f64` to a `i64`
+        //~^ transmute_float_to_int
     }
 
     const fn to_bits_128(v: f128) -> i128 {
         unsafe { std::mem::transmute(v) }
-        //~^ ERROR: transmute from a `f128` to a `i128`
+        //~^ transmute_float_to_int
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/transmute_float_to_int.stderr b/src/tools/clippy/tests/ui/transmute_float_to_int.stderr
index 0cabab58ab08..223cbc4e90c0 100644
--- a/src/tools/clippy/tests/ui/transmute_float_to_int.stderr
+++ b/src/tools/clippy/tests/ui/transmute_float_to_int.stderr
@@ -14,73 +14,73 @@ LL |     let _: i32 = unsafe { std::mem::transmute(1f32) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f32.to_bits() as i32`
 
 error: transmute from a `f64` to a `u64`
-  --> tests/ui/transmute_float_to_int.rs:12:27
+  --> tests/ui/transmute_float_to_int.rs:13:27
    |
 LL |     let _: u64 = unsafe { std::mem::transmute(1f64) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f64.to_bits()`
 
 error: transmute from a `f64` to a `i64`
-  --> tests/ui/transmute_float_to_int.rs:14:27
+  --> tests/ui/transmute_float_to_int.rs:16:27
    |
 LL |     let _: i64 = unsafe { std::mem::transmute(1f64) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f64.to_bits() as i64`
 
 error: transmute from a `f64` to a `u64`
-  --> tests/ui/transmute_float_to_int.rs:16:27
+  --> tests/ui/transmute_float_to_int.rs:19:27
    |
 LL |     let _: u64 = unsafe { std::mem::transmute(1.0) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1.0f64.to_bits()`
 
 error: transmute from a `f64` to a `u64`
-  --> tests/ui/transmute_float_to_int.rs:18:27
+  --> tests/ui/transmute_float_to_int.rs:22:27
    |
 LL |     let _: u64 = unsafe { std::mem::transmute(-1.0) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `(-1.0f64).to_bits()`
 
 error: transmute from a `f16` to a `i16`
-  --> tests/ui/transmute_float_to_int.rs:23:35
+  --> tests/ui/transmute_float_to_int.rs:27:35
    |
 LL |     const VALUE16: i16 = unsafe { std::mem::transmute(1f16) };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f16.to_bits() as i16`
 
 error: transmute from a `f32` to a `i32`
-  --> tests/ui/transmute_float_to_int.rs:25:35
+  --> tests/ui/transmute_float_to_int.rs:30:35
    |
 LL |     const VALUE32: i32 = unsafe { std::mem::transmute(1f32) };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f32.to_bits() as i32`
 
 error: transmute from a `f64` to a `u64`
-  --> tests/ui/transmute_float_to_int.rs:27:35
+  --> tests/ui/transmute_float_to_int.rs:33:35
    |
 LL |     const VALUE64: u64 = unsafe { std::mem::transmute(1f64) };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f64.to_bits()`
 
 error: transmute from a `f128` to a `u128`
-  --> tests/ui/transmute_float_to_int.rs:29:37
+  --> tests/ui/transmute_float_to_int.rs:36:37
    |
 LL |     const VALUE128: u128 = unsafe { std::mem::transmute(1f128) };
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `1f128.to_bits()`
 
 error: transmute from a `f16` to a `u16`
-  --> tests/ui/transmute_float_to_int.rs:33:18
+  --> tests/ui/transmute_float_to_int.rs:40:18
    |
 LL |         unsafe { std::mem::transmute(v) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits()`
 
 error: transmute from a `f32` to a `u32`
-  --> tests/ui/transmute_float_to_int.rs:38:18
+  --> tests/ui/transmute_float_to_int.rs:45:18
    |
 LL |         unsafe { std::mem::transmute(v) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits()`
 
 error: transmute from a `f64` to a `i64`
-  --> tests/ui/transmute_float_to_int.rs:43:18
+  --> tests/ui/transmute_float_to_int.rs:50:18
    |
 LL |         unsafe { std::mem::transmute(v) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits() as i64`
 
 error: transmute from a `f128` to a `i128`
-  --> tests/ui/transmute_float_to_int.rs:48:18
+  --> tests/ui/transmute_float_to_int.rs:55:18
    |
 LL |         unsafe { std::mem::transmute(v) }
    |                  ^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `v.to_bits() as i128`
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_char.fixed b/src/tools/clippy/tests/ui/transmute_int_to_char.fixed
index d3277d1b8c73..b5425a2e9e85 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_char.fixed
+++ b/src/tools/clippy/tests/ui/transmute_int_to_char.fixed
@@ -3,10 +3,10 @@
 
 fn int_to_char() {
     let _: char = unsafe { std::char::from_u32(0_u32).unwrap() };
-    //~^ ERROR: transmute from a `u32` to a `char`
-    //~| NOTE: `-D clippy::transmute-int-to-char` implied by `-D warnings`
+    //~^ transmute_int_to_char
+
     let _: char = unsafe { std::char::from_u32(0_i32 as u32).unwrap() };
-    //~^ ERROR: transmute from a `i32` to a `char`
+    //~^ transmute_int_to_char
 
     // These shouldn't warn
     const _: char = unsafe { std::mem::transmute(0_u32) };
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_char.rs b/src/tools/clippy/tests/ui/transmute_int_to_char.rs
index d21c4fd6fea3..b24bb177c9fc 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_char.rs
+++ b/src/tools/clippy/tests/ui/transmute_int_to_char.rs
@@ -3,10 +3,10 @@
 
 fn int_to_char() {
     let _: char = unsafe { std::mem::transmute(0_u32) };
-    //~^ ERROR: transmute from a `u32` to a `char`
-    //~| NOTE: `-D clippy::transmute-int-to-char` implied by `-D warnings`
+    //~^ transmute_int_to_char
+
     let _: char = unsafe { std::mem::transmute(0_i32) };
-    //~^ ERROR: transmute from a `i32` to a `char`
+    //~^ transmute_int_to_char
 
     // These shouldn't warn
     const _: char = unsafe { std::mem::transmute(0_u32) };
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.fixed b/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.fixed
index 32a57645b46f..e525751e306e 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.fixed
+++ b/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.fixed
@@ -15,10 +15,10 @@ fn panic(info: &PanicInfo) -> ! {
 
 fn int_to_char() {
     let _: char = unsafe { core::char::from_u32(0_u32).unwrap() };
-    //~^ ERROR: transmute from a `u32` to a `char`
-    //~| NOTE: `-D clippy::transmute-int-to-char` implied by `-D warnings`
+    //~^ transmute_int_to_char
+
     let _: char = unsafe { core::char::from_u32(0_i32 as u32).unwrap() };
-    //~^ ERROR: transmute from a `i32` to a `char`
+    //~^ transmute_int_to_char
 
     // These shouldn't warn
     const _: char = unsafe { core::mem::transmute(0_u32) };
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.rs b/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.rs
index 942794c32f81..7cb508ceaf3b 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.rs
+++ b/src/tools/clippy/tests/ui/transmute_int_to_char_no_std.rs
@@ -15,10 +15,10 @@ fn panic(info: &PanicInfo) -> ! {
 
 fn int_to_char() {
     let _: char = unsafe { core::mem::transmute(0_u32) };
-    //~^ ERROR: transmute from a `u32` to a `char`
-    //~| NOTE: `-D clippy::transmute-int-to-char` implied by `-D warnings`
+    //~^ transmute_int_to_char
+
     let _: char = unsafe { core::mem::transmute(0_i32) };
-    //~^ ERROR: transmute from a `i32` to a `char`
+    //~^ transmute_int_to_char
 
     // These shouldn't warn
     const _: char = unsafe { core::mem::transmute(0_u32) };
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.fixed b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.fixed
index 1a48051ec8c4..273090fef387 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.fixed
+++ b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.fixed
@@ -17,27 +17,34 @@ fn main() {
     let int_i128: i128 = 1;
 
     let _: NonZero<u8> = unsafe { NonZero::new_unchecked(int_u8) };
-    //~^ ERROR: transmute from a `u8` to a `NonZero<u8>`
-    //~| NOTE: `-D clippy::transmute-int-to-non-zero` implied by `-D warnings`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u16> = unsafe { NonZero::new_unchecked(int_u16) };
-    //~^ ERROR: transmute from a `u16` to a `NonZero<u16>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u32> = unsafe { NonZero::new_unchecked(int_u32) };
-    //~^ ERROR: transmute from a `u32` to a `NonZero<u32>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u64> = unsafe { NonZero::new_unchecked(int_u64) };
-    //~^ ERROR: transmute from a `u64` to a `NonZero<u64>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u128> = unsafe { NonZero::new_unchecked(int_u128) };
-    //~^ ERROR: transmute from a `u128` to a `NonZero<u128>`
+    //~^ transmute_int_to_non_zero
 
     let _: NonZero<i8> = unsafe { NonZero::new_unchecked(int_i8) };
-    //~^ ERROR: transmute from a `i8` to a `NonZero<i8>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i16> = unsafe { NonZero::new_unchecked(int_i16) };
-    //~^ ERROR: transmute from a `i16` to a `NonZero<i16>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i32> = unsafe { NonZero::new_unchecked(int_i32) };
-    //~^ ERROR: transmute from a `i32` to a `NonZero<i32>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i64> = unsafe { NonZero::new_unchecked(int_i64) };
-    //~^ ERROR: transmute from a `i64` to a `NonZero<i64>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i128> = unsafe { NonZero::new_unchecked(int_i128) };
-    //~^ ERROR: transmute from a `i128` to a `NonZero<i128>`
+    //~^ transmute_int_to_non_zero
 
     let _: NonZero<u8> = unsafe { NonZero::new_unchecked(int_u8) };
     let _: NonZero<u16> = unsafe { NonZero::new_unchecked(int_u16) };
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.rs b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.rs
index d8e842fb99ce..f27bc9b42d42 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.rs
+++ b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.rs
@@ -17,27 +17,34 @@ fn main() {
     let int_i128: i128 = 1;
 
     let _: NonZero<u8> = unsafe { std::mem::transmute(int_u8) };
-    //~^ ERROR: transmute from a `u8` to a `NonZero<u8>`
-    //~| NOTE: `-D clippy::transmute-int-to-non-zero` implied by `-D warnings`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u16> = unsafe { std::mem::transmute(int_u16) };
-    //~^ ERROR: transmute from a `u16` to a `NonZero<u16>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u32> = unsafe { std::mem::transmute(int_u32) };
-    //~^ ERROR: transmute from a `u32` to a `NonZero<u32>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u64> = unsafe { std::mem::transmute(int_u64) };
-    //~^ ERROR: transmute from a `u64` to a `NonZero<u64>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<u128> = unsafe { std::mem::transmute(int_u128) };
-    //~^ ERROR: transmute from a `u128` to a `NonZero<u128>`
+    //~^ transmute_int_to_non_zero
 
     let _: NonZero<i8> = unsafe { std::mem::transmute(int_i8) };
-    //~^ ERROR: transmute from a `i8` to a `NonZero<i8>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i16> = unsafe { std::mem::transmute(int_i16) };
-    //~^ ERROR: transmute from a `i16` to a `NonZero<i16>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i32> = unsafe { std::mem::transmute(int_i32) };
-    //~^ ERROR: transmute from a `i32` to a `NonZero<i32>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i64> = unsafe { std::mem::transmute(int_i64) };
-    //~^ ERROR: transmute from a `i64` to a `NonZero<i64>`
+    //~^ transmute_int_to_non_zero
+
     let _: NonZero<i128> = unsafe { std::mem::transmute(int_i128) };
-    //~^ ERROR: transmute from a `i128` to a `NonZero<i128>`
+    //~^ transmute_int_to_non_zero
 
     let _: NonZero<u8> = unsafe { NonZero::new_unchecked(int_u8) };
     let _: NonZero<u16> = unsafe { NonZero::new_unchecked(int_u16) };
diff --git a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr
index 199b8ec59d09..995ab11a5bc9 100644
--- a/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr
+++ b/src/tools/clippy/tests/ui/transmute_int_to_non_zero.stderr
@@ -14,49 +14,49 @@ LL |     let _: NonZero<u16> = unsafe { std::mem::transmute(int_u16) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u16)`
 
 error: transmute from a `u32` to a `NonZero<u32>`
-  --> tests/ui/transmute_int_to_non_zero.rs:24:36
+  --> tests/ui/transmute_int_to_non_zero.rs:25:36
    |
 LL |     let _: NonZero<u32> = unsafe { std::mem::transmute(int_u32) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u32)`
 
 error: transmute from a `u64` to a `NonZero<u64>`
-  --> tests/ui/transmute_int_to_non_zero.rs:26:36
+  --> tests/ui/transmute_int_to_non_zero.rs:28:36
    |
 LL |     let _: NonZero<u64> = unsafe { std::mem::transmute(int_u64) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u64)`
 
 error: transmute from a `u128` to a `NonZero<u128>`
-  --> tests/ui/transmute_int_to_non_zero.rs:28:37
+  --> tests/ui/transmute_int_to_non_zero.rs:31:37
    |
 LL |     let _: NonZero<u128> = unsafe { std::mem::transmute(int_u128) };
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_u128)`
 
 error: transmute from a `i8` to a `NonZero<i8>`
-  --> tests/ui/transmute_int_to_non_zero.rs:31:35
+  --> tests/ui/transmute_int_to_non_zero.rs:34:35
    |
 LL |     let _: NonZero<i8> = unsafe { std::mem::transmute(int_i8) };
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i8)`
 
 error: transmute from a `i16` to a `NonZero<i16>`
-  --> tests/ui/transmute_int_to_non_zero.rs:33:36
+  --> tests/ui/transmute_int_to_non_zero.rs:37:36
    |
 LL |     let _: NonZero<i16> = unsafe { std::mem::transmute(int_i16) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i16)`
 
 error: transmute from a `i32` to a `NonZero<i32>`
-  --> tests/ui/transmute_int_to_non_zero.rs:35:36
+  --> tests/ui/transmute_int_to_non_zero.rs:40:36
    |
 LL |     let _: NonZero<i32> = unsafe { std::mem::transmute(int_i32) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i32)`
 
 error: transmute from a `i64` to a `NonZero<i64>`
-  --> tests/ui/transmute_int_to_non_zero.rs:37:36
+  --> tests/ui/transmute_int_to_non_zero.rs:43:36
    |
 LL |     let _: NonZero<i64> = unsafe { std::mem::transmute(int_i64) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i64)`
 
 error: transmute from a `i128` to a `NonZero<i128>`
-  --> tests/ui/transmute_int_to_non_zero.rs:39:37
+  --> tests/ui/transmute_int_to_non_zero.rs:46:37
    |
 LL |     let _: NonZero<i128> = unsafe { std::mem::transmute(int_i128) };
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `NonZero::new_unchecked(int_i128)`
diff --git a/src/tools/clippy/tests/ui/transmute_null_to_fn.rs b/src/tools/clippy/tests/ui/transmute_null_to_fn.rs
index c0196ad52d43..e88f05bb662e 100644
--- a/src/tools/clippy/tests/ui/transmute_null_to_fn.rs
+++ b/src/tools/clippy/tests/ui/transmute_null_to_fn.rs
@@ -6,9 +6,10 @@
 fn one_liners() {
     unsafe {
         let _: fn() = std::mem::transmute(0 as *const ());
-        //~^ ERROR: transmuting a known null pointer into a function pointer
+        //~^ transmute_null_to_fn
+
         let _: fn() = std::mem::transmute(std::ptr::null::<()>());
-        //~^ ERROR: transmuting a known null pointer into a function pointer
+        //~^ transmute_null_to_fn
     }
 }
 
@@ -19,7 +20,8 @@ fn transmute_const() {
     unsafe {
         // Should raise a lint.
         let _: fn() = std::mem::transmute(ZPTR);
-        //~^ ERROR: transmuting a known null pointer into a function pointer
+        //~^ transmute_null_to_fn
+
         // Should NOT raise a lint.
         let _: fn() = std::mem::transmute(NOT_ZPTR);
     }
@@ -28,11 +30,13 @@ fn transmute_const() {
 fn issue_11485() {
     unsafe {
         let _: fn() = std::mem::transmute(0 as *const u8 as *const ());
-        //~^ ERROR: transmuting a known null pointer into a function pointer
+        //~^ transmute_null_to_fn
+
         let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const u8);
-        //~^ ERROR: transmuting a known null pointer into a function pointer
+        //~^ transmute_null_to_fn
+
         let _: fn() = std::mem::transmute(ZPTR as *const u8);
-        //~^ ERROR: transmuting a known null pointer into a function pointer
+        //~^ transmute_null_to_fn
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/transmute_null_to_fn.stderr b/src/tools/clippy/tests/ui/transmute_null_to_fn.stderr
index cea7b42cb801..f7d80147445d 100644
--- a/src/tools/clippy/tests/ui/transmute_null_to_fn.stderr
+++ b/src/tools/clippy/tests/ui/transmute_null_to_fn.stderr
@@ -9,7 +9,7 @@ LL |         let _: fn() = std::mem::transmute(0 as *const ());
    = help: to override `-D warnings` add `#[allow(clippy::transmute_null_to_fn)]`
 
 error: transmuting a known null pointer into a function pointer
-  --> tests/ui/transmute_null_to_fn.rs:10:23
+  --> tests/ui/transmute_null_to_fn.rs:11:23
    |
 LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
@@ -17,7 +17,7 @@ LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>());
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
 
 error: transmuting a known null pointer into a function pointer
-  --> tests/ui/transmute_null_to_fn.rs:21:23
+  --> tests/ui/transmute_null_to_fn.rs:22:23
    |
 LL |         let _: fn() = std::mem::transmute(ZPTR);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
@@ -25,7 +25,7 @@ LL |         let _: fn() = std::mem::transmute(ZPTR);
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
 
 error: transmuting a known null pointer into a function pointer
-  --> tests/ui/transmute_null_to_fn.rs:30:23
+  --> tests/ui/transmute_null_to_fn.rs:32:23
    |
 LL |         let _: fn() = std::mem::transmute(0 as *const u8 as *const ());
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
@@ -33,7 +33,7 @@ LL |         let _: fn() = std::mem::transmute(0 as *const u8 as *const ());
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
 
 error: transmuting a known null pointer into a function pointer
-  --> tests/ui/transmute_null_to_fn.rs:32:23
+  --> tests/ui/transmute_null_to_fn.rs:35:23
    |
 LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const u8);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
@@ -41,7 +41,7 @@ LL |         let _: fn() = std::mem::transmute(std::ptr::null::<()>() as *const
    = help: try wrapping your function pointer type in `Option<T>` instead, and using `None` as a null pointer value
 
 error: transmuting a known null pointer into a function pointer
-  --> tests/ui/transmute_null_to_fn.rs:34:23
+  --> tests/ui/transmute_null_to_fn.rs:38:23
    |
 LL |         let _: fn() = std::mem::transmute(ZPTR as *const u8);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ this transmute results in undefined behavior
diff --git a/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.fixed b/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.fixed
index 39e67b250526..3a67be5f45d0 100644
--- a/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.fixed
+++ b/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.fixed
@@ -31,24 +31,32 @@ fn transmute_ptr_to_ptr() {
         // pointer-to-pointer transmutes; bad
         let _: *const f32 = ptr.cast::<f32>();
         //~^ transmute_ptr_to_ptr
+
         let _: *mut f32 = mut_ptr.cast::<f32>();
         //~^ transmute_ptr_to_ptr
+
         // ref-ref transmutes; bad
         let _: &f32 = &*(&1u32 as *const u32 as *const f32);
         //~^ transmute_ptr_to_ptr
+
         let _: &f32 = &*(&1f64 as *const f64 as *const f32);
         //~^ transmute_ptr_to_ptr
+
         //:^ this test is here because both f32 and f64 are the same TypeVariant, but they are not
         // the same type
         let _: &mut f32 = &mut *(&mut 1u32 as *mut u32 as *mut f32);
         //~^ transmute_ptr_to_ptr
+
         let _: &GenericParam<f32> = &*(&GenericParam { t: 1u32 } as *const GenericParam<u32> as *const GenericParam<f32>);
         //~^ transmute_ptr_to_ptr
+
         let u64_ref: &u64 = &0u64;
         let u8_ref: &u8 = &*(u64_ref as *const u64 as *const u8);
         //~^ transmute_ptr_to_ptr
+
         let _: *const u32 = mut_ptr.cast_const();
         //~^ transmute_ptr_to_ptr
+
         let _: *mut u32 = ptr.cast_mut();
         //~^ transmute_ptr_to_ptr
     }
@@ -77,6 +85,7 @@ const _: &() = {
 fn msrv_1_37(ptr: *const u8) {
     unsafe {
         let _: *const i8 = ptr as *const i8;
+        //~^ transmute_ptr_to_ptr
     }
 }
 
@@ -84,6 +93,7 @@ fn msrv_1_37(ptr: *const u8) {
 fn msrv_1_38(ptr: *const u8) {
     unsafe {
         let _: *const i8 = ptr.cast::<i8>();
+        //~^ transmute_ptr_to_ptr
     }
 }
 
@@ -91,7 +101,9 @@ fn msrv_1_38(ptr: *const u8) {
 fn msrv_1_64(ptr: *const u8, mut_ptr: *mut u8) {
     unsafe {
         let _: *mut u8 = ptr as *mut u8;
+        //~^ transmute_ptr_to_ptr
         let _: *const u8 = mut_ptr as *const u8;
+        //~^ transmute_ptr_to_ptr
     }
 }
 
@@ -99,7 +111,9 @@ fn msrv_1_64(ptr: *const u8, mut_ptr: *mut u8) {
 fn msrv_1_65(ptr: *const u8, mut_ptr: *mut u8) {
     unsafe {
         let _: *mut u8 = ptr.cast_mut();
+        //~^ transmute_ptr_to_ptr
         let _: *const u8 = mut_ptr.cast_const();
+        //~^ transmute_ptr_to_ptr
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.rs b/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.rs
index 580b28551734..01ad3a3296b1 100644
--- a/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.rs
+++ b/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.rs
@@ -31,24 +31,32 @@ fn transmute_ptr_to_ptr() {
         // pointer-to-pointer transmutes; bad
         let _: *const f32 = transmute(ptr);
         //~^ transmute_ptr_to_ptr
+
         let _: *mut f32 = transmute(mut_ptr);
         //~^ transmute_ptr_to_ptr
+
         // ref-ref transmutes; bad
         let _: &f32 = transmute(&1u32);
         //~^ transmute_ptr_to_ptr
+
         let _: &f32 = transmute(&1f64);
         //~^ transmute_ptr_to_ptr
+
         //:^ this test is here because both f32 and f64 are the same TypeVariant, but they are not
         // the same type
         let _: &mut f32 = transmute(&mut 1u32);
         //~^ transmute_ptr_to_ptr
+
         let _: &GenericParam<f32> = transmute(&GenericParam { t: 1u32 });
         //~^ transmute_ptr_to_ptr
+
         let u64_ref: &u64 = &0u64;
         let u8_ref: &u8 = transmute(u64_ref);
         //~^ transmute_ptr_to_ptr
+
         let _: *const u32 = transmute(mut_ptr);
         //~^ transmute_ptr_to_ptr
+
         let _: *mut u32 = transmute(ptr);
         //~^ transmute_ptr_to_ptr
     }
@@ -77,6 +85,7 @@ const _: &() = {
 fn msrv_1_37(ptr: *const u8) {
     unsafe {
         let _: *const i8 = transmute(ptr);
+        //~^ transmute_ptr_to_ptr
     }
 }
 
@@ -84,6 +93,7 @@ fn msrv_1_37(ptr: *const u8) {
 fn msrv_1_38(ptr: *const u8) {
     unsafe {
         let _: *const i8 = transmute(ptr);
+        //~^ transmute_ptr_to_ptr
     }
 }
 
@@ -91,7 +101,9 @@ fn msrv_1_38(ptr: *const u8) {
 fn msrv_1_64(ptr: *const u8, mut_ptr: *mut u8) {
     unsafe {
         let _: *mut u8 = transmute(ptr);
+        //~^ transmute_ptr_to_ptr
         let _: *const u8 = transmute(mut_ptr);
+        //~^ transmute_ptr_to_ptr
     }
 }
 
@@ -99,7 +111,9 @@ fn msrv_1_64(ptr: *const u8, mut_ptr: *mut u8) {
 fn msrv_1_65(ptr: *const u8, mut_ptr: *mut u8) {
     unsafe {
         let _: *mut u8 = transmute(ptr);
+        //~^ transmute_ptr_to_ptr
         let _: *const u8 = transmute(mut_ptr);
+        //~^ transmute_ptr_to_ptr
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.stderr b/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.stderr
index f4f83cd7ac6a..c8db4fe214fd 100644
--- a/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.stderr
+++ b/src/tools/clippy/tests/ui/transmute_ptr_to_ptr.stderr
@@ -13,7 +13,7 @@ LL +         let _: *const f32 = ptr.cast::<f32>();
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:34:27
+  --> tests/ui/transmute_ptr_to_ptr.rs:35:27
    |
 LL |         let _: *mut f32 = transmute(mut_ptr);
    |                           ^^^^^^^^^^^^^^^^^^
@@ -25,37 +25,37 @@ LL +         let _: *mut f32 = mut_ptr.cast::<f32>();
    |
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ptr_to_ptr.rs:37:23
+  --> tests/ui/transmute_ptr_to_ptr.rs:39:23
    |
 LL |         let _: &f32 = transmute(&1u32);
    |                       ^^^^^^^^^^^^^^^^ help: try: `&*(&1u32 as *const u32 as *const f32)`
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ptr_to_ptr.rs:39:23
+  --> tests/ui/transmute_ptr_to_ptr.rs:42:23
    |
 LL |         let _: &f32 = transmute(&1f64);
    |                       ^^^^^^^^^^^^^^^^ help: try: `&*(&1f64 as *const f64 as *const f32)`
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ptr_to_ptr.rs:43:27
+  --> tests/ui/transmute_ptr_to_ptr.rs:47:27
    |
 LL |         let _: &mut f32 = transmute(&mut 1u32);
    |                           ^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *(&mut 1u32 as *mut u32 as *mut f32)`
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ptr_to_ptr.rs:45:37
+  --> tests/ui/transmute_ptr_to_ptr.rs:50:37
    |
 LL |         let _: &GenericParam<f32> = transmute(&GenericParam { t: 1u32 });
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(&GenericParam { t: 1u32 } as *const GenericParam<u32> as *const GenericParam<f32>)`
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ptr_to_ptr.rs:48:27
+  --> tests/ui/transmute_ptr_to_ptr.rs:54:27
    |
 LL |         let u8_ref: &u8 = transmute(u64_ref);
    |                           ^^^^^^^^^^^^^^^^^^ help: try: `&*(u64_ref as *const u64 as *const u8)`
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:50:29
+  --> tests/ui/transmute_ptr_to_ptr.rs:57:29
    |
 LL |         let _: *const u32 = transmute(mut_ptr);
    |                             ^^^^^^^^^^^^^^^^^^
@@ -67,7 +67,7 @@ LL +         let _: *const u32 = mut_ptr.cast_const();
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:52:27
+  --> tests/ui/transmute_ptr_to_ptr.rs:60:27
    |
 LL |         let _: *mut u32 = transmute(ptr);
    |                           ^^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ LL +         let _: *mut u32 = ptr.cast_mut();
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:64:14
+  --> tests/ui/transmute_ptr_to_ptr.rs:72:14
    |
 LL |     unsafe { transmute(v) }
    |              ^^^^^^^^^^^^
@@ -91,7 +91,7 @@ LL +     unsafe { v as *const &() }
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:79:28
+  --> tests/ui/transmute_ptr_to_ptr.rs:87:28
    |
 LL |         let _: *const i8 = transmute(ptr);
    |                            ^^^^^^^^^^^^^^
@@ -103,7 +103,7 @@ LL +         let _: *const i8 = ptr as *const i8;
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:86:28
+  --> tests/ui/transmute_ptr_to_ptr.rs:95:28
    |
 LL |         let _: *const i8 = transmute(ptr);
    |                            ^^^^^^^^^^^^^^
@@ -115,7 +115,7 @@ LL +         let _: *const i8 = ptr.cast::<i8>();
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:93:26
+  --> tests/ui/transmute_ptr_to_ptr.rs:103:26
    |
 LL |         let _: *mut u8 = transmute(ptr);
    |                          ^^^^^^^^^^^^^^
@@ -127,7 +127,7 @@ LL +         let _: *mut u8 = ptr as *mut u8;
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:94:28
+  --> tests/ui/transmute_ptr_to_ptr.rs:105:28
    |
 LL |         let _: *const u8 = transmute(mut_ptr);
    |                            ^^^^^^^^^^^^^^^^^^
@@ -139,7 +139,7 @@ LL +         let _: *const u8 = mut_ptr as *const u8;
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:101:26
+  --> tests/ui/transmute_ptr_to_ptr.rs:113:26
    |
 LL |         let _: *mut u8 = transmute(ptr);
    |                          ^^^^^^^^^^^^^^
@@ -151,7 +151,7 @@ LL +         let _: *mut u8 = ptr.cast_mut();
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmute_ptr_to_ptr.rs:102:28
+  --> tests/ui/transmute_ptr_to_ptr.rs:115:28
    |
 LL |         let _: *const u8 = transmute(mut_ptr);
    |                            ^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/transmute_ptr_to_ref.fixed b/src/tools/clippy/tests/ui/transmute_ptr_to_ref.fixed
index 56330d719389..1bd45bc10a39 100644
--- a/src/tools/clippy/tests/ui/transmute_ptr_to_ref.fixed
+++ b/src/tools/clippy/tests/ui/transmute_ptr_to_ref.fixed
@@ -7,24 +7,31 @@
 
 unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     let _: &T = &*p;
+    //~^ transmute_ptr_to_ref
     let _: &T = &*p;
 
     let _: &mut T = &mut *m;
+    //~^ transmute_ptr_to_ref
     let _: &mut T = &mut *m;
 
     let _: &T = &*m;
+    //~^ transmute_ptr_to_ref
     let _: &T = &*m;
 
     let _: &mut T = &mut *(p as *mut T);
+    //~^ transmute_ptr_to_ref
     let _ = &mut *(p as *mut T);
 
     let _: &T = &*(o as *const T);
+    //~^ transmute_ptr_to_ref
     let _: &T = &*(o as *const T);
 
     let _: &mut T = &mut *(om as *mut T);
+    //~^ transmute_ptr_to_ref
     let _: &mut T = &mut *(om as *mut T);
 
     let _: &T = &*(om as *const T);
+    //~^ transmute_ptr_to_ref
     let _: &T = &*(om as *const T);
 }
 
@@ -35,20 +42,27 @@ fn _issue1231() {
 
     let raw = 42 as *const i32;
     let _: &Foo<u8> = unsafe { &*raw.cast::<Foo<_>>() };
+    //~^ transmute_ptr_to_ref
 
     let _: &Foo<&u8> = unsafe { &*raw.cast::<Foo<&_>>() };
+    //~^ transmute_ptr_to_ref
 
     type Bar<'a> = &'a u8;
     let raw = 42 as *const i32;
     unsafe { &*(raw as *const u8) };
+    //~^ transmute_ptr_to_ref
 }
 
 unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     match 0 {
         0 => &*x.cast::<&u32>(),
+        //~^ transmute_ptr_to_ref
         1 => &*y.cast::<&u32>(),
+        //~^ transmute_ptr_to_ref
         2 => &*x.cast::<&'b u32>(),
+        //~^ transmute_ptr_to_ref
         _ => &*y.cast::<&'b u32>(),
+        //~^ transmute_ptr_to_ref
     }
 }
 
@@ -57,10 +71,14 @@ unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     let a = 0u32;
     let a = &a as *const u32;
     let _: &u32 = &*a;
+    //~^ transmute_ptr_to_ref
     let _: &u32 = &*a.cast::<u32>();
+    //~^ transmute_ptr_to_ref
     match 0 {
         0 => &*x.cast::<&u32>(),
+        //~^ transmute_ptr_to_ref
         _ => &*x.cast::<&'b u32>(),
+        //~^ transmute_ptr_to_ref
     }
 }
 
@@ -69,10 +87,14 @@ unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     let a = 0u32;
     let a = &a as *const u32;
     let _: &u32 = &*a;
+    //~^ transmute_ptr_to_ref
     let _: &u32 = &*(a as *const u32);
+    //~^ transmute_ptr_to_ref
     match 0 {
         0 => &*(x as *const () as *const &u32),
+        //~^ transmute_ptr_to_ref
         _ => &*(x as *const () as *const &'b u32),
+        //~^ transmute_ptr_to_ref
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/transmute_ptr_to_ref.rs b/src/tools/clippy/tests/ui/transmute_ptr_to_ref.rs
index ce1ee8bfbfae..cbe64bf1ea6b 100644
--- a/src/tools/clippy/tests/ui/transmute_ptr_to_ref.rs
+++ b/src/tools/clippy/tests/ui/transmute_ptr_to_ref.rs
@@ -7,24 +7,31 @@
 
 unsafe fn _ptr_to_ref<T, U>(p: *const T, m: *mut T, o: *const U, om: *mut U) {
     let _: &T = std::mem::transmute(p);
+    //~^ transmute_ptr_to_ref
     let _: &T = &*p;
 
     let _: &mut T = std::mem::transmute(m);
+    //~^ transmute_ptr_to_ref
     let _: &mut T = &mut *m;
 
     let _: &T = std::mem::transmute(m);
+    //~^ transmute_ptr_to_ref
     let _: &T = &*m;
 
     let _: &mut T = std::mem::transmute(p as *mut T);
+    //~^ transmute_ptr_to_ref
     let _ = &mut *(p as *mut T);
 
     let _: &T = std::mem::transmute(o);
+    //~^ transmute_ptr_to_ref
     let _: &T = &*(o as *const T);
 
     let _: &mut T = std::mem::transmute(om);
+    //~^ transmute_ptr_to_ref
     let _: &mut T = &mut *(om as *mut T);
 
     let _: &T = std::mem::transmute(om);
+    //~^ transmute_ptr_to_ref
     let _: &T = &*(om as *const T);
 }
 
@@ -35,20 +42,27 @@ fn _issue1231() {
 
     let raw = 42 as *const i32;
     let _: &Foo<u8> = unsafe { std::mem::transmute::<_, &Foo<_>>(raw) };
+    //~^ transmute_ptr_to_ref
 
     let _: &Foo<&u8> = unsafe { std::mem::transmute::<_, &Foo<&_>>(raw) };
+    //~^ transmute_ptr_to_ref
 
     type Bar<'a> = &'a u8;
     let raw = 42 as *const i32;
     unsafe { std::mem::transmute::<_, Bar>(raw) };
+    //~^ transmute_ptr_to_ref
 }
 
 unsafe fn _issue8924<'a, 'b, 'c>(x: *const &'a u32, y: *const &'b u32) -> &'c &'b u32 {
     match 0 {
         0 => std::mem::transmute(x),
+        //~^ transmute_ptr_to_ref
         1 => std::mem::transmute(y),
+        //~^ transmute_ptr_to_ref
         2 => std::mem::transmute::<_, &&'b u32>(x),
+        //~^ transmute_ptr_to_ref
         _ => std::mem::transmute::<_, &&'b u32>(y),
+        //~^ transmute_ptr_to_ref
     }
 }
 
@@ -57,10 +71,14 @@ unsafe fn _meets_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     let a = 0u32;
     let a = &a as *const u32;
     let _: &u32 = std::mem::transmute(a);
+    //~^ transmute_ptr_to_ref
     let _: &u32 = std::mem::transmute::<_, &u32>(a);
+    //~^ transmute_ptr_to_ref
     match 0 {
         0 => std::mem::transmute(x),
+        //~^ transmute_ptr_to_ref
         _ => std::mem::transmute::<_, &&'b u32>(x),
+        //~^ transmute_ptr_to_ref
     }
 }
 
@@ -69,10 +87,14 @@ unsafe fn _under_msrv<'a, 'b, 'c>(x: *const &'a u32) -> &'c &'b u32 {
     let a = 0u32;
     let a = &a as *const u32;
     let _: &u32 = std::mem::transmute(a);
+    //~^ transmute_ptr_to_ref
     let _: &u32 = std::mem::transmute::<_, &u32>(a);
+    //~^ transmute_ptr_to_ref
     match 0 {
         0 => std::mem::transmute(x),
+        //~^ transmute_ptr_to_ref
         _ => std::mem::transmute::<_, &&'b u32>(x),
+        //~^ transmute_ptr_to_ref
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/transmute_ptr_to_ref.stderr b/src/tools/clippy/tests/ui/transmute_ptr_to_ref.stderr
index 44cda254c3f7..7fad9b4065a5 100644
--- a/src/tools/clippy/tests/ui/transmute_ptr_to_ref.stderr
+++ b/src/tools/clippy/tests/ui/transmute_ptr_to_ref.stderr
@@ -8,127 +8,127 @@ LL |     let _: &T = std::mem::transmute(p);
    = help: to override `-D warnings` add `#[allow(clippy::transmute_ptr_to_ref)]`
 
 error: transmute from a pointer type (`*mut T`) to a reference type (`&mut T`)
-  --> tests/ui/transmute_ptr_to_ref.rs:12:21
+  --> tests/ui/transmute_ptr_to_ref.rs:13:21
    |
 LL |     let _: &mut T = std::mem::transmute(m);
    |                     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *m`
 
 error: transmute from a pointer type (`*mut T`) to a reference type (`&T`)
-  --> tests/ui/transmute_ptr_to_ref.rs:15:17
+  --> tests/ui/transmute_ptr_to_ref.rs:17:17
    |
 LL |     let _: &T = std::mem::transmute(m);
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*m`
 
 error: transmute from a pointer type (`*mut T`) to a reference type (`&mut T`)
-  --> tests/ui/transmute_ptr_to_ref.rs:18:21
+  --> tests/ui/transmute_ptr_to_ref.rs:21:21
    |
 LL |     let _: &mut T = std::mem::transmute(p as *mut T);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *(p as *mut T)`
 
 error: transmute from a pointer type (`*const U`) to a reference type (`&T`)
-  --> tests/ui/transmute_ptr_to_ref.rs:21:17
+  --> tests/ui/transmute_ptr_to_ref.rs:25:17
    |
 LL |     let _: &T = std::mem::transmute(o);
    |                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(o as *const T)`
 
 error: transmute from a pointer type (`*mut U`) to a reference type (`&mut T`)
-  --> tests/ui/transmute_ptr_to_ref.rs:24:21
+  --> tests/ui/transmute_ptr_to_ref.rs:29:21
    |
 LL |     let _: &mut T = std::mem::transmute(om);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&mut *(om as *mut T)`
 
 error: transmute from a pointer type (`*mut U`) to a reference type (`&T`)
-  --> tests/ui/transmute_ptr_to_ref.rs:27:17
+  --> tests/ui/transmute_ptr_to_ref.rs:33:17
    |
 LL |     let _: &T = std::mem::transmute(om);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(om as *const T)`
 
 error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<'_, u8>`)
-  --> tests/ui/transmute_ptr_to_ref.rs:37:32
+  --> tests/ui/transmute_ptr_to_ref.rs:44:32
    |
 LL |     let _: &Foo<u8> = unsafe { std::mem::transmute::<_, &Foo<_>>(raw) };
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*raw.cast::<Foo<_>>()`
 
 error: transmute from a pointer type (`*const i32`) to a reference type (`&_issue1231::Foo<'_, &u8>`)
-  --> tests/ui/transmute_ptr_to_ref.rs:39:33
+  --> tests/ui/transmute_ptr_to_ref.rs:47:33
    |
 LL |     let _: &Foo<&u8> = unsafe { std::mem::transmute::<_, &Foo<&_>>(raw) };
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*raw.cast::<Foo<&_>>()`
 
 error: transmute from a pointer type (`*const i32`) to a reference type (`&u8`)
-  --> tests/ui/transmute_ptr_to_ref.rs:43:14
+  --> tests/ui/transmute_ptr_to_ref.rs:52:14
    |
 LL |     unsafe { std::mem::transmute::<_, Bar>(raw) };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(raw as *const u8)`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:48:14
+  --> tests/ui/transmute_ptr_to_ref.rs:58:14
    |
 LL |         0 => std::mem::transmute(x),
    |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&u32>()`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:49:14
+  --> tests/ui/transmute_ptr_to_ref.rs:60:14
    |
 LL |         1 => std::mem::transmute(y),
    |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*y.cast::<&u32>()`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:50:14
+  --> tests/ui/transmute_ptr_to_ref.rs:62:14
    |
 LL |         2 => std::mem::transmute::<_, &&'b u32>(x),
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&'b u32>()`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:51:14
+  --> tests/ui/transmute_ptr_to_ref.rs:64:14
    |
 LL |         _ => std::mem::transmute::<_, &&'b u32>(y),
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*y.cast::<&'b u32>()`
 
 error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:59:19
+  --> tests/ui/transmute_ptr_to_ref.rs:73:19
    |
 LL |     let _: &u32 = std::mem::transmute(a);
    |                   ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*a`
 
 error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:60:19
+  --> tests/ui/transmute_ptr_to_ref.rs:75:19
    |
 LL |     let _: &u32 = std::mem::transmute::<_, &u32>(a);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*a.cast::<u32>()`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:62:14
+  --> tests/ui/transmute_ptr_to_ref.rs:78:14
    |
 LL |         0 => std::mem::transmute(x),
    |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&u32>()`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:63:14
+  --> tests/ui/transmute_ptr_to_ref.rs:80:14
    |
 LL |         _ => std::mem::transmute::<_, &&'b u32>(x),
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*x.cast::<&'b u32>()`
 
 error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:71:19
+  --> tests/ui/transmute_ptr_to_ref.rs:89:19
    |
 LL |     let _: &u32 = std::mem::transmute(a);
    |                   ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*a`
 
 error: transmute from a pointer type (`*const u32`) to a reference type (`&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:72:19
+  --> tests/ui/transmute_ptr_to_ref.rs:91:19
    |
 LL |     let _: &u32 = std::mem::transmute::<_, &u32>(a);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a as *const u32)`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:74:14
+  --> tests/ui/transmute_ptr_to_ref.rs:94:14
    |
 LL |         0 => std::mem::transmute(x),
    |              ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(x as *const () as *const &u32)`
 
 error: transmute from a pointer type (`*const &u32`) to a reference type (`&&u32`)
-  --> tests/ui/transmute_ptr_to_ref.rs:75:14
+  --> tests/ui/transmute_ptr_to_ref.rs:96:14
    |
 LL |         _ => std::mem::transmute::<_, &&'b u32>(x),
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(x as *const () as *const &'b u32)`
diff --git a/src/tools/clippy/tests/ui/transmute_ref_to_ref.rs b/src/tools/clippy/tests/ui/transmute_ref_to_ref.rs
index 44d7af44a805..8bdf07b4a428 100644
--- a/src/tools/clippy/tests/ui/transmute_ref_to_ref.rs
+++ b/src/tools/clippy/tests/ui/transmute_ref_to_ref.rs
@@ -7,12 +7,14 @@ fn main() {
     unsafe {
         let single_u64: &[u64] = &[0xDEAD_BEEF_DEAD_BEEF];
         let bools: &[bool] = unsafe { std::mem::transmute(single_u64) };
-        //~^ ERROR: transmute from a reference to a reference
+        //~^ transmute_ptr_to_ptr
+
         let a: &[u32] = &[0x12345678, 0x90ABCDEF, 0xFEDCBA09, 0x87654321];
         let b: &[u8] = unsafe { std::mem::transmute(a) };
-        //~^ ERROR: transmute from a reference to a reference
+        //~^ transmute_ptr_to_ptr
+
         let bytes = &[1u8, 2u8, 3u8, 4u8] as &[u8];
         let alt_slice: &[u32] = unsafe { std::mem::transmute(bytes) };
-        //~^ ERROR: transmute from a reference to a reference
+        //~^ transmute_ptr_to_ptr
     }
 }
diff --git a/src/tools/clippy/tests/ui/transmute_ref_to_ref.stderr b/src/tools/clippy/tests/ui/transmute_ref_to_ref.stderr
index e2d04cea8959..e8d659f9c5d8 100644
--- a/src/tools/clippy/tests/ui/transmute_ref_to_ref.stderr
+++ b/src/tools/clippy/tests/ui/transmute_ref_to_ref.stderr
@@ -11,13 +11,13 @@ LL | #![deny(clippy::transmute_ptr_to_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ref_to_ref.rs:12:33
+  --> tests/ui/transmute_ref_to_ref.rs:13:33
    |
 LL |         let b: &[u8] = unsafe { std::mem::transmute(a) };
    |                                 ^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a as *const [u32] as *const [u8])`
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ref_to_ref.rs:15:42
+  --> tests/ui/transmute_ref_to_ref.rs:17:42
    |
 LL |         let alt_slice: &[u32] = unsafe { std::mem::transmute(bytes) };
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(bytes as *const [u8] as *const [u32])`
diff --git a/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.rs b/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.rs
index 591770587549..faa776f2afce 100644
--- a/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.rs
+++ b/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.rs
@@ -19,12 +19,14 @@ fn main() {
     unsafe {
         let single_u64: &[u64] = &[0xDEAD_BEEF_DEAD_BEEF];
         let bools: &[bool] = unsafe { core::mem::transmute(single_u64) };
-        //~^ ERROR: transmute from a reference to a reference
+        //~^ transmute_ptr_to_ptr
+
         let a: &[u32] = &[0x12345678, 0x90ABCDEF, 0xFEDCBA09, 0x87654321];
         let b: &[u8] = unsafe { core::mem::transmute(a) };
-        //~^ ERROR: transmute from a reference to a reference
+        //~^ transmute_ptr_to_ptr
+
         let bytes = &[1u8, 2u8, 3u8, 4u8] as &[u8];
         let alt_slice: &[u32] = unsafe { core::mem::transmute(bytes) };
-        //~^ ERROR: transmute from a reference to a reference
+        //~^ transmute_ptr_to_ptr
     }
 }
diff --git a/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.stderr b/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.stderr
index 6a76d6729d05..9aa9ed928a4d 100644
--- a/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.stderr
+++ b/src/tools/clippy/tests/ui/transmute_ref_to_ref_no_std.stderr
@@ -11,13 +11,13 @@ LL | #![deny(clippy::transmute_ptr_to_ptr)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ref_to_ref_no_std.rs:24:33
+  --> tests/ui/transmute_ref_to_ref_no_std.rs:25:33
    |
 LL |         let b: &[u8] = unsafe { core::mem::transmute(a) };
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(a as *const [u32] as *const [u8])`
 
 error: transmute from a reference to a reference
-  --> tests/ui/transmute_ref_to_ref_no_std.rs:27:42
+  --> tests/ui/transmute_ref_to_ref_no_std.rs:29:42
    |
 LL |         let alt_slice: &[u32] = unsafe { core::mem::transmute(bytes) };
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&*(bytes as *const [u8] as *const [u32])`
diff --git a/src/tools/clippy/tests/ui/transmute_undefined_repr.rs b/src/tools/clippy/tests/ui/transmute_undefined_repr.rs
index 5b16d71f1142..a449d6a4302f 100644
--- a/src/tools/clippy/tests/ui/transmute_undefined_repr.rs
+++ b/src/tools/clippy/tests/ui/transmute_undefined_repr.rs
@@ -32,11 +32,11 @@ fn main() {
 
         // Lint, Ty2 is unordered
         let _: Ty2C<u32, i32> = transmute(value::<Ty2<u32, i32>>());
-        //~^ ERROR: transmute from `Ty2<u32, i32>` which has an undefined layout
-        //~| NOTE: `-D clippy::transmute-undefined-repr` implied by `-D warnings`
+        //~^ transmute_undefined_repr
+
         // Lint, Ty2 is unordered
         let _: Ty2<u32, i32> = transmute(value::<Ty2C<u32, i32>>());
-        //~^ ERROR: transmute into `Ty2<u32, i32>` which has an undefined layout
+        //~^ transmute_undefined_repr
 
         // Ok, Ty2 types are the same
         let _: Ty2<u32, i32> = transmute(value::<Ty<Ty2<u32, i32>>>());
@@ -45,24 +45,22 @@ fn main() {
 
         // Lint, different Ty2 instances
         let _: Ty2<u32, f32> = transmute(value::<Ty<Ty2<u32, i32>>>());
-        //~^ ERROR: transmute from `Ty<Ty2<u32, i32>>` to `Ty2<u32, f32>`, both of which h
-        //~| NOTE: two instances of the same generic type (`Ty2`) may have different layou
+        //~^ transmute_undefined_repr
+
         // Lint, different Ty2 instances
         let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>());
-        //~^ ERROR: transmute from `Ty2<u32, f32>` to `Ty<Ty2<u32, i32>>`, both of which h
-        //~| NOTE: two instances of the same generic type (`Ty2`) may have different layou
+        //~^ transmute_undefined_repr
 
         let _: Ty<&()> = transmute(value::<&()>());
         let _: &() = transmute(value::<Ty<&()>>());
 
         // Lint, different Ty2 instances
         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>());
-        //~^ ERROR: transmute from `Ty<&Ty2<u32, i32>>` to `&Ty2<u32, f32>`, both of which
-        //~| NOTE: two instances of the same generic type (`Ty2`) may have different layou
+        //~^ transmute_undefined_repr
+
         // Lint, different Ty2 instances
         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>());
-        //~^ ERROR: transmute from `&Ty2<u32, f32>` to `Ty<&Ty2<u32, i32>>`, both of which
-        //~| NOTE: two instances of the same generic type (`Ty2`) may have different layou
+        //~^ transmute_undefined_repr
 
         // Ok, pointer to usize conversion
         let _: Ty<usize> = transmute(value::<&Ty2<u32, i32>>());
@@ -91,12 +89,11 @@ fn main() {
 
         // Lint, different Ty2 instances
         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32, u32>>>());
-        //~^ ERROR: transmute from `std::boxed::Box<Ty2<u32, u32>>` to `&mut Ty2<u32, f32>
-        //~| NOTE: two instances of the same generic type (`Ty2`) may have different layou
+        //~^ transmute_undefined_repr
+
         // Lint, different Ty2 instances
         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32, f32>>());
-        //~^ ERROR: transmute from `&mut Ty2<u32, f32>` to `std::boxed::Box<Ty2<u32, u32>>
-        //~| NOTE: two instances of the same generic type (`Ty2`) may have different layou
+        //~^ transmute_undefined_repr
 
         // Ok, type erasure
         let _: *const () = transmute(value::<Ty<&Ty2<u32, f32>>>());
@@ -192,12 +189,11 @@ fn main() {
 
         // Err
         let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty2<u32, u32>>>());
-        //~^ ERROR: transmute into `*const Ty2<u32, u32>` which has an undefined layout
-        //~| NOTE: the contained type `Ty2<u32, u32>` has an undefined layout
+        //~^ transmute_undefined_repr
+
         // Err
         let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const Ty2<u32, u32>>());
-        //~^ ERROR: transmute from `*const Ty2<u32, u32>` which has an undefined layout
-        //~| NOTE: the contained type `Ty2<u32, u32>` has an undefined layout
+        //~^ transmute_undefined_repr
 
         // Ok
         let _: NonNull<u8> = transmute(value::<NonNull<(String, String)>>());
@@ -243,12 +239,11 @@ fn _with_generics<T: 'static, U: 'static>() {
 
         // Err
         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>());
-        //~^ ERROR: transmute from `std::vec::Vec<Ty2<U, i32>>` to `std::vec::Vec<Ty2<T, u
-        //~| NOTE: two instances of the same generic type (`Vec`) may have different layou
+        //~^ transmute_undefined_repr
+
         // Err
         let _: Vec<Ty2<U, i32>> = transmute(value::<Vec<Ty2<T, u32>>>());
-        //~^ ERROR: transmute from `std::vec::Vec<Ty2<T, u32>>` to `std::vec::Vec<Ty2<U, i
-        //~| NOTE: two instances of the same generic type (`Vec`) may have different layou
+        //~^ transmute_undefined_repr
 
         // Ok
         let _: *const u32 = transmute(value::<Box<T>>());
diff --git a/src/tools/clippy/tests/ui/transmute_undefined_repr.stderr b/src/tools/clippy/tests/ui/transmute_undefined_repr.stderr
index b41d37a5cd13..a259ef784c78 100644
--- a/src/tools/clippy/tests/ui/transmute_undefined_repr.stderr
+++ b/src/tools/clippy/tests/ui/transmute_undefined_repr.stderr
@@ -30,7 +30,7 @@ LL |         let _: Ty<Ty2<u32, i32>> = transmute(value::<Ty2<u32, f32>>());
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `Ty<&Ty2<u32, i32>>` to `&Ty2<u32, f32>`, both of which have an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:59:33
+  --> tests/ui/transmute_undefined_repr.rs:58:33
    |
 LL |         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>());
    |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -38,7 +38,7 @@ LL |         let _: &Ty2<u32, f32> = transmute(value::<Ty<&Ty2<u32, i32>>>());
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&Ty2<u32, f32>` to `Ty<&Ty2<u32, i32>>`, both of which have an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:63:37
+  --> tests/ui/transmute_undefined_repr.rs:62:37
    |
 LL |         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>());
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -46,7 +46,7 @@ LL |         let _: Ty<&Ty2<u32, i32>> = transmute(value::<&Ty2<u32, f32>>());
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `std::boxed::Box<Ty2<u32, u32>>` to `&mut Ty2<u32, f32>`, both of which have an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:93:45
+  --> tests/ui/transmute_undefined_repr.rs:91:45
    |
 LL |         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32, u32>>>());
    |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,7 +54,7 @@ LL |         let _: &'static mut Ty2<u32, f32> = transmute(value::<Box<Ty2<u32,
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute from `&mut Ty2<u32, f32>` to `std::boxed::Box<Ty2<u32, u32>>`, both of which have an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:97:37
+  --> tests/ui/transmute_undefined_repr.rs:95:37
    |
 LL |         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32, f32>>());
    |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -62,7 +62,7 @@ LL |         let _: Box<Ty2<u32, u32>> = transmute(value::<&'static mut Ty2<u32,
    = note: two instances of the same generic type (`Ty2`) may have different layouts
 
 error: transmute into `*const Ty2<u32, u32>` which has an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:194:39
+  --> tests/ui/transmute_undefined_repr.rs:191:39
    |
 LL |         let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty2<u32, u32>>>());
    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -70,7 +70,7 @@ LL |         let _: *const Ty2<u32, u32> = transmute(value::<*const Ty2C<u32, Ty
    = note: the contained type `Ty2<u32, u32>` has an undefined layout
 
 error: transmute from `*const Ty2<u32, u32>` which has an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:198:50
+  --> tests/ui/transmute_undefined_repr.rs:195:50
    |
 LL |         let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const Ty2<u32, u32>>());
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -78,7 +78,7 @@ LL |         let _: *const Ty2C<u32, Ty2<u32, u32>> = transmute(value::<*const T
    = note: the contained type `Ty2<u32, u32>` has an undefined layout
 
 error: transmute from `std::vec::Vec<Ty2<U, i32>>` to `std::vec::Vec<Ty2<T, u32>>`, both of which have an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:245:35
+  --> tests/ui/transmute_undefined_repr.rs:241:35
    |
 LL |         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -86,7 +86,7 @@ LL |         let _: Vec<Ty2<T, u32>> = transmute(value::<Vec<Ty2<U, i32>>>());
    = note: two instances of the same generic type (`Vec`) may have different layouts
 
 error: transmute from `std::vec::Vec<Ty2<T, u32>>` to `std::vec::Vec<Ty2<U, i32>>`, both of which have an undefined layout
-  --> tests/ui/transmute_undefined_repr.rs:249:35
+  --> tests/ui/transmute_undefined_repr.rs:245:35
    |
 LL |         let _: Vec<Ty2<U, i32>> = transmute(value::<Vec<Ty2<T, u32>>>());
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.fixed b/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.fixed
index a4a3ca82e76c..e7ad2a1cbbcb 100644
--- a/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.fixed
+++ b/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.fixed
@@ -15,28 +15,33 @@ fn main() {
 
     // e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
     let _ptr_i32_transmute = unsafe { usize::MAX as *const i32 };
+    //~^ useless_transmute
     let ptr_i32 = usize::MAX as *const i32;
 
     // e has type *T, U is *U_0, and either U_0: Sized ...
     let _ptr_i8_transmute = unsafe { ptr_i32.cast::<i8>() };
+    //~^ transmute_ptr_to_ptr
     let _ptr_i8 = ptr_i32 as *const i8;
 
     let slice_ptr = &[0, 1, 2, 3] as *const [i32];
 
     // ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
     let _ptr_to_unsized_transmute = unsafe { slice_ptr as *const [u32] };
+    //~^ transmute_ptr_to_ptr
     let _ptr_to_unsized = slice_ptr as *const [u32];
     // TODO: We could try testing vtable casts here too, but maybe
     // we should wait until std::raw::TraitObject is stabilized?
 
     // e has type *T and U is a numeric type, while T: Sized; ptr-addr-cast
     let _usize_from_int_ptr_transmute = unsafe { ptr_i32 as usize };
+    //~^ transmutes_expressible_as_ptr_casts
     let _usize_from_int_ptr = ptr_i32 as usize;
 
     let array_ref: &[i32; 4] = &[1, 2, 3, 4];
 
     // e has type &[T; n] and U is *const T; array-ptr-cast
     let _array_ptr_transmute = unsafe { array_ref as *const [i32; 4] };
+    //~^ useless_transmute
     let _array_ptr = array_ref as *const [i32; 4];
 
     fn foo(_: usize) -> u8 {
@@ -45,13 +50,16 @@ fn main() {
 
     // e is a function pointer type and U has type *T, while T: Sized; fptr-ptr-cast
     let _usize_ptr_transmute = unsafe { foo as *const usize };
+    //~^ transmutes_expressible_as_ptr_casts
     let _usize_ptr_transmute = foo as *const usize;
 
     // e is a function pointer type and U is an integer; fptr-addr-cast
     let _usize_from_fn_ptr_transmute = unsafe { foo as usize };
+    //~^ transmutes_expressible_as_ptr_casts
     let _usize_from_fn_ptr = foo as *const usize;
 
     let _usize_from_ref = unsafe { &1u32 as *const u32 as usize };
+    //~^ transmutes_expressible_as_ptr_casts
 }
 
 // If a ref-to-ptr cast of this form where the pointer type points to a type other
@@ -63,6 +71,7 @@ fn main() {
 // fall through into `do_check`.
 fn trigger_do_check_to_emit_error(in_param: &[i32; 1]) -> *const u8 {
     unsafe { in_param as *const [i32; 1] as *const u8 }
+    //~^ useless_transmute
 }
 
 #[repr(C)]
@@ -81,6 +90,7 @@ fn issue_10449() {
     fn f() {}
 
     let _x: u8 = unsafe { *(f as *const u8) };
+    //~^ transmutes_expressible_as_ptr_casts
 }
 
 // Pointers cannot be cast to integers in const contexts
diff --git a/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.rs b/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.rs
index 6aa8e384e268..42a81777a826 100644
--- a/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.rs
+++ b/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.rs
@@ -15,28 +15,33 @@ fn main() {
 
     // e is an integer and U is *U_0, while U_0: Sized; addr-ptr-cast
     let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize::MAX) };
+    //~^ useless_transmute
     let ptr_i32 = usize::MAX as *const i32;
 
     // e has type *T, U is *U_0, and either U_0: Sized ...
     let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr_i32) };
+    //~^ transmute_ptr_to_ptr
     let _ptr_i8 = ptr_i32 as *const i8;
 
     let slice_ptr = &[0, 1, 2, 3] as *const [i32];
 
     // ... or pointer_kind(T) = pointer_kind(U_0); ptr-ptr-cast
     let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u32]>(slice_ptr) };
+    //~^ transmute_ptr_to_ptr
     let _ptr_to_unsized = slice_ptr as *const [u32];
     // TODO: We could try testing vtable casts here too, but maybe
     // we should wait until std::raw::TraitObject is stabilized?
 
     // e has type *T and U is a numeric type, while T: Sized; ptr-addr-cast
     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, usize>(ptr_i32) };
+    //~^ transmutes_expressible_as_ptr_casts
     let _usize_from_int_ptr = ptr_i32 as usize;
 
     let array_ref: &[i32; 4] = &[1, 2, 3, 4];
 
     // e has type &[T; n] and U is *const T; array-ptr-cast
     let _array_ptr_transmute = unsafe { transmute::<&[i32; 4], *const [i32; 4]>(array_ref) };
+    //~^ useless_transmute
     let _array_ptr = array_ref as *const [i32; 4];
 
     fn foo(_: usize) -> u8 {
@@ -45,13 +50,16 @@ fn main() {
 
     // e is a function pointer type and U has type *T, while T: Sized; fptr-ptr-cast
     let _usize_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, *const usize>(foo) };
+    //~^ transmutes_expressible_as_ptr_casts
     let _usize_ptr_transmute = foo as *const usize;
 
     // e is a function pointer type and U is an integer; fptr-addr-cast
     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
+    //~^ transmutes_expressible_as_ptr_casts
     let _usize_from_fn_ptr = foo as *const usize;
 
     let _usize_from_ref = unsafe { transmute::<*const u32, usize>(&1u32) };
+    //~^ transmutes_expressible_as_ptr_casts
 }
 
 // If a ref-to-ptr cast of this form where the pointer type points to a type other
@@ -63,6 +71,7 @@ fn main() {
 // fall through into `do_check`.
 fn trigger_do_check_to_emit_error(in_param: &[i32; 1]) -> *const u8 {
     unsafe { transmute::<&[i32; 1], *const u8>(in_param) }
+    //~^ useless_transmute
 }
 
 #[repr(C)]
@@ -81,6 +90,7 @@ fn issue_10449() {
     fn f() {}
 
     let _x: u8 = unsafe { *std::mem::transmute::<fn(), *const u8>(f) };
+    //~^ transmutes_expressible_as_ptr_casts
 }
 
 // Pointers cannot be cast to integers in const contexts
diff --git a/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.stderr b/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.stderr
index 21edd39e7ad6..7746f087cc71 100644
--- a/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.stderr
+++ b/src/tools/clippy/tests/ui/transmutes_expressible_as_ptr_casts.stderr
@@ -8,7 +8,7 @@ LL |     let _ptr_i32_transmute = unsafe { transmute::<usize, *const i32>(usize:
    = help: to override `-D warnings` add `#[allow(clippy::useless_transmute)]`
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:21:38
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:22:38
    |
 LL |     let _ptr_i8_transmute = unsafe { transmute::<*const i32, *const i8>(ptr_i32) };
    |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +22,7 @@ LL +     let _ptr_i8_transmute = unsafe { ptr_i32.cast::<i8>() };
    |
 
 error: transmute from a pointer to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:27:46
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:29:46
    |
 LL |     let _ptr_to_unsized_transmute = unsafe { transmute::<*const [i32], *const [u32]>(slice_ptr) };
    |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -34,7 +34,7 @@ LL +     let _ptr_to_unsized_transmute = unsafe { slice_ptr as *const [u32] };
    |
 
 error: transmute from `*const i32` to `usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:33:50
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:36:50
    |
 LL |     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, usize>(ptr_i32) };
    |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `ptr_i32 as usize`
@@ -43,37 +43,37 @@ LL |     let _usize_from_int_ptr_transmute = unsafe { transmute::<*const i32, us
    = help: to override `-D warnings` add `#[allow(clippy::transmutes_expressible_as_ptr_casts)]`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:39:41
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:43:41
    |
 LL |     let _array_ptr_transmute = unsafe { transmute::<&[i32; 4], *const [i32; 4]>(array_ref) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `array_ref as *const [i32; 4]`
 
 error: transmute from `fn(usize) -> u8` to `*const usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:47:41
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:52:41
    |
 LL |     let _usize_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, *const usize>(foo) };
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as *const usize`
 
 error: transmute from `fn(usize) -> u8` to `usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:51:49
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:57:49
    |
 LL |     let _usize_from_fn_ptr_transmute = unsafe { transmute::<fn(usize) -> u8, usize>(foo) };
    |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `foo as usize`
 
 error: transmute from `*const u32` to `usize` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:54:36
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:61:36
    |
 LL |     let _usize_from_ref = unsafe { transmute::<*const u32, usize>(&1u32) };
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `&1u32 as *const u32 as usize`
 
 error: transmute from a reference to a pointer
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:65:14
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:73:14
    |
 LL |     unsafe { transmute::<&[i32; 1], *const u8>(in_param) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `in_param as *const [i32; 1] as *const u8`
 
 error: transmute from `fn()` to `*const u8` which could be expressed as a pointer cast instead
-  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:83:28
+  --> tests/ui/transmutes_expressible_as_ptr_casts.rs:92:28
    |
 LL |     let _x: u8 = unsafe { *std::mem::transmute::<fn(), *const u8>(f) };
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `(f as *const u8)`
diff --git a/src/tools/clippy/tests/ui/transmuting_null.rs b/src/tools/clippy/tests/ui/transmuting_null.rs
index c2deb6b6c460..bcd35bbd4e72 100644
--- a/src/tools/clippy/tests/ui/transmuting_null.rs
+++ b/src/tools/clippy/tests/ui/transmuting_null.rs
@@ -8,10 +8,10 @@
 fn one_liners() {
     unsafe {
         let _: &u64 = std::mem::transmute(0 as *const u64);
-        //~^ ERROR: transmuting a known null pointer into a reference
-        //~| NOTE: `-D clippy::transmuting-null` implied by `-D warnings`
+        //~^ transmuting_null
+
         let _: &u64 = std::mem::transmute(std::ptr::null::<u64>());
-        //~^ ERROR: transmuting a known null pointer into a reference
+        //~^ transmuting_null
     }
 }
 
@@ -22,7 +22,8 @@ fn transmute_const() {
     unsafe {
         // Should raise a lint.
         let _: &u64 = std::mem::transmute(ZPTR);
-        //~^ ERROR: transmuting a known null pointer into a reference
+        //~^ transmuting_null
+
         // Should NOT raise a lint.
         let _: &u64 = std::mem::transmute(NOT_ZPTR);
     }
diff --git a/src/tools/clippy/tests/ui/trim_split_whitespace.fixed b/src/tools/clippy/tests/ui/trim_split_whitespace.fixed
index 6d3daf798a67..434e91b7d953 100644
--- a/src/tools/clippy/tests/ui/trim_split_whitespace.fixed
+++ b/src/tools/clippy/tests/ui/trim_split_whitespace.fixed
@@ -59,13 +59,25 @@ impl DerefStrAndCustomTrim {
 fn main() {
     // &str
     let _ = " A B C ".split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = " A B C ".split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = " A B C ".split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
 
     // String
     let _ = (" A B C ").to_string().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = (" A B C ").to_string().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = (" A B C ").to_string().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
 
     // Custom
     let _ = Custom.trim().split_whitespace(); // should not trigger lint
@@ -73,6 +85,8 @@ fn main() {
     // Deref<Target=str>
     let s = DerefStr(" A B C ");
     let _ = s.split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
 
     // Deref<Target=str> + custom impl
     let s = DerefStrAndCustom(" A B C ");
@@ -81,6 +95,8 @@ fn main() {
     // Deref<Target=str> + only custom split_ws() impl
     let s = DerefStrAndCustomSplit(" A B C ");
     let _ = s.split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     // Expl: trim() is called on str (deref) and returns &str.
     //       Thus split_ws() is called on str as well and the custom impl on S is unused
 
diff --git a/src/tools/clippy/tests/ui/trim_split_whitespace.rs b/src/tools/clippy/tests/ui/trim_split_whitespace.rs
index b49d9e8b3fab..b939ecdfba85 100644
--- a/src/tools/clippy/tests/ui/trim_split_whitespace.rs
+++ b/src/tools/clippy/tests/ui/trim_split_whitespace.rs
@@ -59,13 +59,25 @@ impl DerefStrAndCustomTrim {
 fn main() {
     // &str
     let _ = " A B C ".trim().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = " A B C ".trim_start().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = " A B C ".trim_end().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
 
     // String
     let _ = (" A B C ").to_string().trim().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = (" A B C ").to_string().trim_start().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     let _ = (" A B C ").to_string().trim_end().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
 
     // Custom
     let _ = Custom.trim().split_whitespace(); // should not trigger lint
@@ -73,6 +85,8 @@ fn main() {
     // Deref<Target=str>
     let s = DerefStr(" A B C ");
     let _ = s.trim().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
 
     // Deref<Target=str> + custom impl
     let s = DerefStrAndCustom(" A B C ");
@@ -81,6 +95,8 @@ fn main() {
     // Deref<Target=str> + only custom split_ws() impl
     let s = DerefStrAndCustomSplit(" A B C ");
     let _ = s.trim().split_whitespace(); // should trigger lint
+    //
+    //~^^ trim_split_whitespace
     // Expl: trim() is called on str (deref) and returns &str.
     //       Thus split_ws() is called on str as well and the custom impl on S is unused
 
diff --git a/src/tools/clippy/tests/ui/trim_split_whitespace.stderr b/src/tools/clippy/tests/ui/trim_split_whitespace.stderr
index 6119d21a8e9a..f242dd802115 100644
--- a/src/tools/clippy/tests/ui/trim_split_whitespace.stderr
+++ b/src/tools/clippy/tests/ui/trim_split_whitespace.stderr
@@ -8,43 +8,43 @@ LL |     let _ = " A B C ".trim().split_whitespace(); // should trigger lint
    = help: to override `-D warnings` add `#[allow(clippy::trim_split_whitespace)]`
 
 error: found call to `str::trim_start` before `str::split_whitespace`
-  --> tests/ui/trim_split_whitespace.rs:62:23
+  --> tests/ui/trim_split_whitespace.rs:64:23
    |
 LL |     let _ = " A B C ".trim_start().split_whitespace(); // should trigger lint
    |                       ^^^^^^^^^^^^^ help: remove `trim_start()`
 
 error: found call to `str::trim_end` before `str::split_whitespace`
-  --> tests/ui/trim_split_whitespace.rs:63:23
+  --> tests/ui/trim_split_whitespace.rs:67:23
    |
 LL |     let _ = " A B C ".trim_end().split_whitespace(); // should trigger lint
    |                       ^^^^^^^^^^^ help: remove `trim_end()`
 
 error: found call to `str::trim` before `str::split_whitespace`
-  --> tests/ui/trim_split_whitespace.rs:66:37
+  --> tests/ui/trim_split_whitespace.rs:72:37
    |
 LL |     let _ = (" A B C ").to_string().trim().split_whitespace(); // should trigger lint
    |                                     ^^^^^^^ help: remove `trim()`
 
 error: found call to `str::trim_start` before `str::split_whitespace`
-  --> tests/ui/trim_split_whitespace.rs:67:37
+  --> tests/ui/trim_split_whitespace.rs:75:37
    |
 LL |     let _ = (" A B C ").to_string().trim_start().split_whitespace(); // should trigger lint
    |                                     ^^^^^^^^^^^^^ help: remove `trim_start()`
 
 error: found call to `str::trim_end` before `str::split_whitespace`
-  --> tests/ui/trim_split_whitespace.rs:68:37
+  --> tests/ui/trim_split_whitespace.rs:78:37
    |
 LL |     let _ = (" A B C ").to_string().trim_end().split_whitespace(); // should trigger lint
    |                                     ^^^^^^^^^^^ help: remove `trim_end()`
 
 error: found call to `str::trim` before `str::split_whitespace`
-  --> tests/ui/trim_split_whitespace.rs:75:15
+  --> tests/ui/trim_split_whitespace.rs:87:15
    |
 LL |     let _ = s.trim().split_whitespace(); // should trigger lint
    |               ^^^^^^^ help: remove `trim()`
 
 error: found call to `str::trim` before `str::split_whitespace`
-  --> tests/ui/trim_split_whitespace.rs:83:15
+  --> tests/ui/trim_split_whitespace.rs:97:15
    |
 LL |     let _ = s.trim().split_whitespace(); // should trigger lint
    |               ^^^^^^^ help: remove `trim()`
diff --git a/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.rs b/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.rs
index 043a7b63af3c..37bc6f89a20a 100644
--- a/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.rs
+++ b/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.rs
@@ -52,6 +52,7 @@ fn good_return_explicit_lt_struct<'a>(foo: &'a Foo) -> FooRef<'a> {
 fn bad(x: &u32, y: &Foo, z: &Baz) {}
 //~^ ERROR: this argument (4 byte) is passed by reference, but would be more efficient if passed by
 //~| ERROR: this argument (4 byte) is passed by reference, but would be more efficient if passed by
+//~| ERROR: this argument (4 byte) is passed by reference, but would be more efficient if passed by
 
 impl Foo {
     fn good(self, a: &mut u32, b: u32, c: &Bar) {}
diff --git a/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.stderr b/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.stderr
index 4887fb00e742..e813fecf653a 100644
--- a/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.stderr
+++ b/src/tools/clippy/tests/ui/trivially_copy_pass_by_ref.stderr
@@ -23,91 +23,91 @@ LL | fn bad(x: &u32, y: &Foo, z: &Baz) {}
    |                             ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:61:12
+  --> tests/ui/trivially_copy_pass_by_ref.rs:62:12
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |            ^^^^^ help: consider passing by value instead: `self`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:61:22
+  --> tests/ui/trivially_copy_pass_by_ref.rs:62:22
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                      ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:61:31
+  --> tests/ui/trivially_copy_pass_by_ref.rs:62:31
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                               ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:61:40
+  --> tests/ui/trivially_copy_pass_by_ref.rs:62:40
    |
 LL |     fn bad(&self, x: &u32, y: &Foo, z: &Baz) {}
    |                                        ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:67:16
+  --> tests/ui/trivially_copy_pass_by_ref.rs:68:16
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:67:25
+  --> tests/ui/trivially_copy_pass_by_ref.rs:68:25
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                         ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:67:34
+  --> tests/ui/trivially_copy_pass_by_ref.rs:68:34
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:72:35
+  --> tests/ui/trivially_copy_pass_by_ref.rs:73:35
    |
 LL |     fn bad_issue7518(self, other: &Self) {}
    |                                   ^^^^^ help: consider passing by value instead: `Self`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:85:16
+  --> tests/ui/trivially_copy_pass_by_ref.rs:86:16
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                ^^^^ help: consider passing by value instead: `u32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:85:25
+  --> tests/ui/trivially_copy_pass_by_ref.rs:86:25
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                         ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:85:34
+  --> tests/ui/trivially_copy_pass_by_ref.rs:86:34
    |
 LL |     fn bad2(x: &u32, y: &Foo, z: &Baz) {}
    |                                  ^^^^ help: consider passing by value instead: `Baz`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:92:34
+  --> tests/ui/trivially_copy_pass_by_ref.rs:93:34
    |
 LL |     fn trait_method(&self, _foo: &Foo);
    |                                  ^^^^ help: consider passing by value instead: `Foo`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:125:21
+  --> tests/ui/trivially_copy_pass_by_ref.rs:126:21
    |
 LL |     fn foo_never(x: &i32) {
    |                     ^^^^ help: consider passing by value instead: `i32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:131:15
+  --> tests/ui/trivially_copy_pass_by_ref.rs:132:15
    |
 LL |     fn foo(x: &i32) {
    |               ^^^^ help: consider passing by value instead: `i32`
 
 error: this argument (N byte) is passed by reference, but would be more efficient if passed by value (limit: 8 byte)
-  --> tests/ui/trivially_copy_pass_by_ref.rs:159:37
+  --> tests/ui/trivially_copy_pass_by_ref.rs:160:37
    |
 LL | fn _unrelated_lifetimes<'a, 'b>(_x: &'a u32, y: &'b u32) -> &'b u32 {
    |                                     ^^^^^^^ help: consider passing by value instead: `u32`
diff --git a/src/tools/clippy/tests/ui/try_err.fixed b/src/tools/clippy/tests/ui/try_err.fixed
index f149bfb77740..ea509f9a2da8 100644
--- a/src/tools/clippy/tests/ui/try_err.fixed
+++ b/src/tools/clippy/tests/ui/try_err.fixed
@@ -20,6 +20,7 @@ pub fn basic_test() -> Result<i32, i32> {
     // To avoid warnings during rustfix
     if true {
         return Err(err);
+        //~^ try_err
     }
     Ok(0)
 }
@@ -30,6 +31,7 @@ pub fn into_test() -> Result<i32, i32> {
     // To avoid warnings during rustfix
     if true {
         return Err(err.into());
+        //~^ try_err
     }
     Ok(0)
 }
@@ -50,6 +52,7 @@ pub fn closure_matches_test() -> Result<i32, i32> {
             // To avoid warnings during rustfix
             if true {
                 return Err(err);
+                //~^ try_err
             }
             Ok(i)
         })
@@ -69,6 +72,7 @@ pub fn closure_into_test() -> Result<i32, i32> {
             // To avoid warnings during rustfix
             if true {
                 return Err(err.into());
+                //~^ try_err
             }
             Ok(i)
         })
@@ -89,6 +93,7 @@ fn calling_macro() -> Result<i32, i32> {
         match $(Ok::<_, i32>(5)) {
             Ok(_) => 0,
             Err(_) => return Err(1),
+            //~^ try_err
         }
     );
     // `Err` arg is another macro
@@ -96,6 +101,7 @@ fn calling_macro() -> Result<i32, i32> {
         match $(Ok::<_, i32>(5)) {
             Ok(_) => 0,
             Err(_) => return Err(inline!(1)),
+            //~^ try_err
         }
     );
     Ok(5)
@@ -123,6 +129,7 @@ fn main() {
 pub fn macro_inside(fail: bool) -> Result<i32, String> {
     if fail {
         return Err(inline!(inline!(String::from("aasdfasdfasdfa"))));
+        //~^ try_err
     }
     Ok(0)
 }
@@ -130,8 +137,10 @@ pub fn macro_inside(fail: bool) -> Result<i32, String> {
 pub fn poll_write(n: usize) -> Poll<io::Result<usize>> {
     if n == 0 {
         return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))
+        //~^ try_err
     } else if n == 1 {
         return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))
+        //~^ try_err
     };
 
     Poll::Ready(Ok(n))
@@ -140,6 +149,7 @@ pub fn poll_write(n: usize) -> Poll<io::Result<usize>> {
 pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
     if !ready {
         return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))
+        //~^ try_err
     }
 
     Poll::Ready(None)
@@ -149,6 +159,7 @@ pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
 pub fn try_return(x: bool) -> Result<i32, i32> {
     if x {
         return Err(42);
+        //~^ try_err
     }
     Ok(0)
 }
diff --git a/src/tools/clippy/tests/ui/try_err.rs b/src/tools/clippy/tests/ui/try_err.rs
index 841ec6b5d5c7..295f7bd7089b 100644
--- a/src/tools/clippy/tests/ui/try_err.rs
+++ b/src/tools/clippy/tests/ui/try_err.rs
@@ -20,6 +20,7 @@ pub fn basic_test() -> Result<i32, i32> {
     // To avoid warnings during rustfix
     if true {
         Err(err)?;
+        //~^ try_err
     }
     Ok(0)
 }
@@ -30,6 +31,7 @@ pub fn into_test() -> Result<i32, i32> {
     // To avoid warnings during rustfix
     if true {
         Err(err)?;
+        //~^ try_err
     }
     Ok(0)
 }
@@ -50,6 +52,7 @@ pub fn closure_matches_test() -> Result<i32, i32> {
             // To avoid warnings during rustfix
             if true {
                 Err(err)?;
+                //~^ try_err
             }
             Ok(i)
         })
@@ -69,6 +72,7 @@ pub fn closure_into_test() -> Result<i32, i32> {
             // To avoid warnings during rustfix
             if true {
                 Err(err)?;
+                //~^ try_err
             }
             Ok(i)
         })
@@ -89,6 +93,7 @@ fn calling_macro() -> Result<i32, i32> {
         match $(Ok::<_, i32>(5)) {
             Ok(_) => 0,
             Err(_) => Err(1)?,
+            //~^ try_err
         }
     );
     // `Err` arg is another macro
@@ -96,6 +101,7 @@ fn calling_macro() -> Result<i32, i32> {
         match $(Ok::<_, i32>(5)) {
             Ok(_) => 0,
             Err(_) => Err(inline!(1))?,
+            //~^ try_err
         }
     );
     Ok(5)
@@ -123,6 +129,7 @@ fn main() {
 pub fn macro_inside(fail: bool) -> Result<i32, String> {
     if fail {
         Err(inline!(inline!(String::from("aasdfasdfasdfa"))))?;
+        //~^ try_err
     }
     Ok(0)
 }
@@ -130,8 +137,10 @@ pub fn macro_inside(fail: bool) -> Result<i32, String> {
 pub fn poll_write(n: usize) -> Poll<io::Result<usize>> {
     if n == 0 {
         Err(io::ErrorKind::WriteZero)?
+        //~^ try_err
     } else if n == 1 {
         Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
+        //~^ try_err
     };
 
     Poll::Ready(Ok(n))
@@ -140,6 +149,7 @@ pub fn poll_write(n: usize) -> Poll<io::Result<usize>> {
 pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
     if !ready {
         Err(io::ErrorKind::NotFound)?
+        //~^ try_err
     }
 
     Poll::Ready(None)
@@ -149,6 +159,7 @@ pub fn poll_next(ready: bool) -> Poll<Option<io::Result<()>>> {
 pub fn try_return(x: bool) -> Result<i32, i32> {
     if x {
         return Err(42)?;
+        //~^ try_err
     }
     Ok(0)
 }
diff --git a/src/tools/clippy/tests/ui/try_err.stderr b/src/tools/clippy/tests/ui/try_err.stderr
index fb563d407866..50c2b092d6c8 100644
--- a/src/tools/clippy/tests/ui/try_err.stderr
+++ b/src/tools/clippy/tests/ui/try_err.stderr
@@ -11,25 +11,25 @@ LL | #![deny(clippy::try_err)]
    |         ^^^^^^^^^^^^^^^
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:32:9
+  --> tests/ui/try_err.rs:33:9
    |
 LL |         Err(err)?;
    |         ^^^^^^^^^ help: try: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:52:17
+  --> tests/ui/try_err.rs:54:17
    |
 LL |                 Err(err)?;
    |                 ^^^^^^^^^ help: try: `return Err(err)`
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:71:17
+  --> tests/ui/try_err.rs:74:17
    |
 LL |                 Err(err)?;
    |                 ^^^^^^^^^ help: try: `return Err(err.into())`
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:91:23
+  --> tests/ui/try_err.rs:95:23
    |
 LL |             Err(_) => Err(1)?,
    |                       ^^^^^^^ help: try: `return Err(1)`
@@ -37,7 +37,7 @@ LL |             Err(_) => Err(1)?,
    = note: this error originates in the macro `__inline_mac_fn_calling_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:98:23
+  --> tests/ui/try_err.rs:103:23
    |
 LL |             Err(_) => Err(inline!(1))?,
    |                       ^^^^^^^^^^^^^^^^ help: try: `return Err(inline!(1))`
@@ -45,31 +45,31 @@ LL |             Err(_) => Err(inline!(1))?,
    = note: this error originates in the macro `__inline_mac_fn_calling_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:125:9
+  --> tests/ui/try_err.rs:131:9
    |
 LL |         Err(inline!(inline!(String::from("aasdfasdfasdfa"))))?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Err(inline!(inline!(String::from("aasdfasdfasdfa"))))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:132:9
+  --> tests/ui/try_err.rs:139:9
    |
 LL |         Err(io::ErrorKind::WriteZero)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Err(io::ErrorKind::WriteZero.into()))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:134:9
+  --> tests/ui/try_err.rs:142:9
    |
 LL |         Err(io::Error::new(io::ErrorKind::InvalidInput, "error"))?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Err(io::Error::new(io::ErrorKind::InvalidInput, "error")))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:142:9
+  --> tests/ui/try_err.rs:151:9
    |
 LL |         Err(io::ErrorKind::NotFound)?
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `return Poll::Ready(Some(Err(io::ErrorKind::NotFound.into())))`
 
 error: returning an `Err(_)` with the `?` operator
-  --> tests/ui/try_err.rs:151:16
+  --> tests/ui/try_err.rs:161:16
    |
 LL |         return Err(42)?;
    |                ^^^^^^^^ help: try: `Err(42)`
diff --git a/src/tools/clippy/tests/ui/tuple_array_conversions.rs b/src/tools/clippy/tests/ui/tuple_array_conversions.rs
index ca79cc104f22..772c41df090e 100644
--- a/src/tools/clippy/tests/ui/tuple_array_conversions.rs
+++ b/src/tools/clippy/tests/ui/tuple_array_conversions.rs
@@ -8,15 +8,21 @@ extern crate proc_macros;
 fn main() {
     let x = [1, 2];
     let x = (x[0], x[1]);
+    //~^ tuple_array_conversions
     let x = [x.0, x.1];
+    //~^ tuple_array_conversions
     let x = &[1, 2];
     let x = (x[0], x[1]);
 
     let t1: &[(u32, u32)] = &[(1, 2), (3, 4)];
     let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
+    //~^ tuple_array_conversions
     t1.iter().for_each(|&(a, b)| _ = [a, b]);
+    //~^ tuple_array_conversions
     let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
+    //~^ tuple_array_conversions
     t1.iter().for_each(|&(a, b)| _ = [a, b]);
+    //~^ tuple_array_conversions
     // Do not lint
     let v2: Vec<[u32; 2]> = t1.iter().map(|&t| t.into()).collect();
     let t3: Vec<(u32, u32)> = v2.iter().map(|&v| v.into()).collect();
@@ -55,9 +61,11 @@ fn main() {
     // FP #11082; needs discussion
     let (a, b) = (1.0f64, 2.0f64);
     let _: &[f64] = &[a, b];
+    //~^ tuple_array_conversions
     // FP #11085; impossible to fix
     let [src, dest]: [_; 2] = [1, 2];
     (src, dest);
+    //~^ tuple_array_conversions
     // FP #11100
     fn issue_11100_array_to_tuple(this: [&mut i32; 2]) -> (&i32, &mut i32) {
         let [input, output] = this;
@@ -102,7 +110,9 @@ fn msrv_too_low() {
 fn msrv_juust_right() {
     let x = [1, 2];
     let x = (x[0], x[1]);
+    //~^ tuple_array_conversions
     let x = [x.0, x.1];
+    //~^ tuple_array_conversions
     let x = &[1, 2];
     let x = (x[0], x[1]);
 }
diff --git a/src/tools/clippy/tests/ui/tuple_array_conversions.stderr b/src/tools/clippy/tests/ui/tuple_array_conversions.stderr
index 9e022b3cfb25..6dafb8d285d4 100644
--- a/src/tools/clippy/tests/ui/tuple_array_conversions.stderr
+++ b/src/tools/clippy/tests/ui/tuple_array_conversions.stderr
@@ -9,7 +9,7 @@ LL |     let x = (x[0], x[1]);
    = help: to override `-D warnings` add `#[allow(clippy::tuple_array_conversions)]`
 
 error: it looks like you're trying to convert a tuple to an array
-  --> tests/ui/tuple_array_conversions.rs:11:13
+  --> tests/ui/tuple_array_conversions.rs:12:13
    |
 LL |     let x = [x.0, x.1];
    |             ^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     let x = [x.0, x.1];
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
-  --> tests/ui/tuple_array_conversions.rs:16:53
+  --> tests/ui/tuple_array_conversions.rs:18:53
    |
 LL |     let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
    |                                                     ^^^^^^
@@ -25,7 +25,7 @@ LL |     let v1: Vec<[u32; 2]> = t1.iter().map(|&(a, b)| [a, b]).collect();
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
-  --> tests/ui/tuple_array_conversions.rs:17:38
+  --> tests/ui/tuple_array_conversions.rs:20:38
    |
 LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    |                                      ^^^^^^
@@ -33,7 +33,7 @@ LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert an array to a tuple
-  --> tests/ui/tuple_array_conversions.rs:18:55
+  --> tests/ui/tuple_array_conversions.rs:22:55
    |
 LL |     let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
    |                                                       ^^^^^^
@@ -41,7 +41,7 @@ LL |     let t2: Vec<(u32, u32)> = v1.iter().map(|&[a, b]| (a, b)).collect();
    = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
-  --> tests/ui/tuple_array_conversions.rs:19:38
+  --> tests/ui/tuple_array_conversions.rs:24:38
    |
 LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    |                                      ^^^^^^
@@ -49,7 +49,7 @@ LL |     t1.iter().for_each(|&(a, b)| _ = [a, b]);
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
-  --> tests/ui/tuple_array_conversions.rs:57:22
+  --> tests/ui/tuple_array_conversions.rs:63:22
    |
 LL |     let _: &[f64] = &[a, b];
    |                      ^^^^^^
@@ -57,7 +57,7 @@ LL |     let _: &[f64] = &[a, b];
    = help: use `.into()` instead, or `<[T; N]>::from` if type annotations are needed
 
 error: it looks like you're trying to convert an array to a tuple
-  --> tests/ui/tuple_array_conversions.rs:60:5
+  --> tests/ui/tuple_array_conversions.rs:67:5
    |
 LL |     (src, dest);
    |     ^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     (src, dest);
    = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
 error: it looks like you're trying to convert an array to a tuple
-  --> tests/ui/tuple_array_conversions.rs:104:13
+  --> tests/ui/tuple_array_conversions.rs:112:13
    |
 LL |     let x = (x[0], x[1]);
    |             ^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL |     let x = (x[0], x[1]);
    = help: use `.into()` instead, or `<(T0, T1, ..., Tn)>::from` if type annotations are needed
 
 error: it looks like you're trying to convert a tuple to an array
-  --> tests/ui/tuple_array_conversions.rs:105:13
+  --> tests/ui/tuple_array_conversions.rs:114:13
    |
 LL |     let x = [x.0, x.1];
    |             ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/ty_fn_sig.rs b/src/tools/clippy/tests/ui/ty_fn_sig.rs
index 9e2753dcb18d..60767bfad135 100644
--- a/src/tools/clippy/tests/ui/ty_fn_sig.rs
+++ b/src/tools/clippy/tests/ui/ty_fn_sig.rs
@@ -1,3 +1,4 @@
+//@ check-pass
 // Regression test
 
 pub fn retry<F: Fn()>(f: F) {
diff --git a/src/tools/clippy/tests/ui/type_complexity.rs b/src/tools/clippy/tests/ui/type_complexity.rs
index be28ee2da0cd..89c4955c9f6f 100644
--- a/src/tools/clippy/tests/ui/type_complexity.rs
+++ b/src/tools/clippy/tests/ui/type_complexity.rs
@@ -5,42 +5,46 @@
 type Alias = Vec<Vec<Box<(u32, u32, u32, u32)>>>; // no warning here
 
 const CST: (u32, (u32, (u32, (u32, u32)))) = (0, (0, (0, (0, 0))));
-//~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
-//~| NOTE: `-D clippy::type-complexity` implied by `-D warnings`
+//~^ type_complexity
+
 static ST: (u32, (u32, (u32, (u32, u32)))) = (0, (0, (0, (0, 0))));
-//~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+//~^ type_complexity
 
 struct S {
     f: Vec<Vec<Box<(u32, u32, u32, u32)>>>,
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
 }
 
 struct Ts(Vec<Vec<Box<(u32, u32, u32, u32)>>>);
-//~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+//~^ type_complexity
 
 enum E {
     Tuple(Vec<Vec<Box<(u32, u32, u32, u32)>>>),
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
     Struct { f: Vec<Vec<Box<(u32, u32, u32, u32)>>> },
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
 }
 
 impl S {
     const A: (u32, (u32, (u32, (u32, u32)))) = (0, (0, (0, (0, 0))));
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
+
     fn impl_method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
 }
 
 trait T {
     const A: Vec<Vec<Box<(u32, u32, u32, u32)>>>;
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
+
     type B = Vec<Vec<Box<(u32, u32, u32, u32)>>>;
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
+
     fn method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>);
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
+
     fn def_method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
 }
 
 // Should not warn since there is likely no way to simplify this (#1013)
@@ -53,16 +57,17 @@ impl T for () {
 }
 
 fn test1() -> Vec<Vec<Box<(u32, u32, u32, u32)>>> {
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
+
     vec![]
 }
 
 fn test2(_x: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
-//~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+//~^ type_complexity
 
 fn test3() {
     let _y: Vec<Vec<Box<(u32, u32, u32, u32)>>> = vec![];
-    //~^ ERROR: very complex type used. Consider factoring parts into `type` definitions
+    //~^ type_complexity
 }
 
 #[repr(C)]
diff --git a/src/tools/clippy/tests/ui/type_complexity.stderr b/src/tools/clippy/tests/ui/type_complexity.stderr
index 9e27899e4f90..181e04d38e9a 100644
--- a/src/tools/clippy/tests/ui/type_complexity.stderr
+++ b/src/tools/clippy/tests/ui/type_complexity.stderr
@@ -44,49 +44,49 @@ LL |     const A: (u32, (u32, (u32, (u32, u32)))) = (0, (0, (0, (0, 0))));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:31:30
+  --> tests/ui/type_complexity.rs:32:30
    |
 LL |     fn impl_method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
    |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:36:14
+  --> tests/ui/type_complexity.rs:37:14
    |
 LL |     const A: Vec<Vec<Box<(u32, u32, u32, u32)>>>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:38:14
+  --> tests/ui/type_complexity.rs:40:14
    |
 LL |     type B = Vec<Vec<Box<(u32, u32, u32, u32)>>>;
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:40:25
+  --> tests/ui/type_complexity.rs:43:25
    |
 LL |     fn method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:42:29
+  --> tests/ui/type_complexity.rs:46:29
    |
 LL |     fn def_method(&self, p: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:55:15
+  --> tests/ui/type_complexity.rs:59:15
    |
 LL | fn test1() -> Vec<Vec<Box<(u32, u32, u32, u32)>>> {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:60:14
+  --> tests/ui/type_complexity.rs:65:14
    |
 LL | fn test2(_x: Vec<Vec<Box<(u32, u32, u32, u32)>>>) {}
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: very complex type used. Consider factoring parts into `type` definitions
-  --> tests/ui/type_complexity.rs:64:13
+  --> tests/ui/type_complexity.rs:69:13
    |
 LL |     let _y: Vec<Vec<Box<(u32, u32, u32, u32)>>> = vec![];
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/type_id_on_box.fixed b/src/tools/clippy/tests/ui/type_id_on_box.fixed
index 3656043700fa..2e241c36b34a 100644
--- a/src/tools/clippy/tests/ui/type_id_on_box.fixed
+++ b/src/tools/clippy/tests/ui/type_id_on_box.fixed
@@ -29,7 +29,7 @@ fn main() {
 
     let any_box: Box<dyn Any> = Box::new(0usize);
     let _ = (*any_box).type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     // Don't lint. We explicitly say "do this instead" if this is intentional
     let _ = TypeId::of::<Box<dyn Any>>();
@@ -38,18 +38,18 @@ fn main() {
     // 2 derefs are needed here to get to the `dyn Any`
     let any_box: &Box<dyn Any> = &(Box::new(0usize) as Box<dyn Any>);
     let _ = (**any_box).type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     let b = existential();
     let _ = b.type_id(); // Don't
 
     let b: Box<dyn AnySubTrait> = Box::new(1);
     let _ = (*b).type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     let b: SomeBox = Box::new(0usize);
     let _ = (*b).type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     let b = BadBox(Box::new(0usize));
     let _ = b.type_id(); // Don't lint. This is a call to `<BadBox as Any>::type_id`. Not `std::boxed::Box`!
diff --git a/src/tools/clippy/tests/ui/type_id_on_box.rs b/src/tools/clippy/tests/ui/type_id_on_box.rs
index 4bd9e73f2da0..46fac632894c 100644
--- a/src/tools/clippy/tests/ui/type_id_on_box.rs
+++ b/src/tools/clippy/tests/ui/type_id_on_box.rs
@@ -29,7 +29,7 @@ fn main() {
 
     let any_box: Box<dyn Any> = Box::new(0usize);
     let _ = any_box.type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     // Don't lint. We explicitly say "do this instead" if this is intentional
     let _ = TypeId::of::<Box<dyn Any>>();
@@ -38,18 +38,18 @@ fn main() {
     // 2 derefs are needed here to get to the `dyn Any`
     let any_box: &Box<dyn Any> = &(Box::new(0usize) as Box<dyn Any>);
     let _ = any_box.type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     let b = existential();
     let _ = b.type_id(); // Don't
 
     let b: Box<dyn AnySubTrait> = Box::new(1);
     let _ = b.type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     let b: SomeBox = Box::new(0usize);
     let _ = b.type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     let b = BadBox(Box::new(0usize));
     let _ = b.type_id(); // Don't lint. This is a call to `<BadBox as Any>::type_id`. Not `std::boxed::Box`!
diff --git a/src/tools/clippy/tests/ui/type_id_on_box_unfixable.rs b/src/tools/clippy/tests/ui/type_id_on_box_unfixable.rs
index 67e398e604b4..58d245d56aa5 100644
--- a/src/tools/clippy/tests/ui/type_id_on_box_unfixable.rs
+++ b/src/tools/clippy/tests/ui/type_id_on_box_unfixable.rs
@@ -23,9 +23,9 @@ fn main() {
     // could)
     let b: Box<dyn AnySubSubTrait> = Box::new(1);
     let _ = b.type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 
     let b: Box<dyn NormalTrait> = Box::new(1);
     let _ = b.type_id();
-    //~^ ERROR: calling `.type_id()` on
+    //~^ type_id_on_box
 }
diff --git a/src/tools/clippy/tests/ui/unbuffered_bytes.rs b/src/tools/clippy/tests/ui/unbuffered_bytes.rs
new file mode 100644
index 000000000000..87199c7e335d
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unbuffered_bytes.rs
@@ -0,0 +1,41 @@
+#![warn(clippy::unbuffered_bytes)]
+
+use std::fs::File;
+use std::io::{BufReader, Cursor, Read, Stdin, stdin};
+use std::net::TcpStream;
+
+fn main() {
+    // File is not buffered, should complain
+    let file = File::open("./bytes.txt").unwrap();
+    file.bytes();
+    //~^ unbuffered_bytes
+
+    // TcpStream is not buffered, should complain
+    let tcp_stream: TcpStream = TcpStream::connect("127.0.0.1:80").unwrap();
+    tcp_stream.bytes();
+    //~^ unbuffered_bytes
+
+    // BufReader<File> is buffered, should not complain
+    let file = BufReader::new(File::open("./bytes.txt").unwrap());
+    file.bytes();
+
+    // Cursor is buffered, should not complain
+    let cursor = Cursor::new(Vec::new());
+    cursor.bytes();
+
+    // Stdio would acquire the lock for every byte, should complain
+    let s: Stdin = stdin();
+    s.bytes();
+    //~^ unbuffered_bytes
+
+    // But when locking stdin, this is fine so should not complain
+    let s: Stdin = stdin();
+    let s = s.lock();
+    s.bytes();
+}
+
+fn use_read<R: Read>(r: R) {
+    // Callers of `use_read` may choose a `R` that is not buffered
+    r.bytes();
+    //~^ unbuffered_bytes
+}
diff --git a/src/tools/clippy/tests/ui/unbuffered_bytes.stderr b/src/tools/clippy/tests/ui/unbuffered_bytes.stderr
new file mode 100644
index 000000000000..7505eb9e363a
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unbuffered_bytes.stderr
@@ -0,0 +1,36 @@
+error: calling .bytes() is very inefficient when data is not in memory
+  --> tests/ui/unbuffered_bytes.rs:10:5
+   |
+LL |     file.bytes();
+   |     ^^^^^^^^^^^^
+   |
+   = help: consider using `BufReader`
+   = note: `-D clippy::unbuffered-bytes` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unbuffered_bytes)]`
+
+error: calling .bytes() is very inefficient when data is not in memory
+  --> tests/ui/unbuffered_bytes.rs:15:5
+   |
+LL |     tcp_stream.bytes();
+   |     ^^^^^^^^^^^^^^^^^^
+   |
+   = help: consider using `BufReader`
+
+error: calling .bytes() is very inefficient when data is not in memory
+  --> tests/ui/unbuffered_bytes.rs:28:5
+   |
+LL |     s.bytes();
+   |     ^^^^^^^^^
+   |
+   = help: consider using `BufReader`
+
+error: calling .bytes() is very inefficient when data is not in memory
+  --> tests/ui/unbuffered_bytes.rs:39:5
+   |
+LL |     r.bytes();
+   |     ^^^^^^^^^
+   |
+   = help: consider using `BufReader`
+
+error: aborting due to 4 previous errors
+
diff --git a/src/tools/clippy/tests/ui/unchecked_duration_subtraction.fixed b/src/tools/clippy/tests/ui/unchecked_duration_subtraction.fixed
index a0c3330d1777..bddffe44ac4d 100644
--- a/src/tools/clippy/tests/ui/unchecked_duration_subtraction.fixed
+++ b/src/tools/clippy/tests/ui/unchecked_duration_subtraction.fixed
@@ -7,10 +7,14 @@ fn main() {
     let second = Duration::from_secs(3);
 
     let _ = _first.checked_sub(second).unwrap();
+    //~^ unchecked_duration_subtraction
 
     let _ = Instant::now().checked_sub(Duration::from_secs(5)).unwrap();
+    //~^ unchecked_duration_subtraction
 
     let _ = _first.checked_sub(Duration::from_secs(5)).unwrap();
+    //~^ unchecked_duration_subtraction
 
     let _ = Instant::now().checked_sub(second).unwrap();
+    //~^ unchecked_duration_subtraction
 }
diff --git a/src/tools/clippy/tests/ui/unchecked_duration_subtraction.rs b/src/tools/clippy/tests/ui/unchecked_duration_subtraction.rs
index fff1d13720d9..bb0f71239642 100644
--- a/src/tools/clippy/tests/ui/unchecked_duration_subtraction.rs
+++ b/src/tools/clippy/tests/ui/unchecked_duration_subtraction.rs
@@ -7,10 +7,14 @@ fn main() {
     let second = Duration::from_secs(3);
 
     let _ = _first - second;
+    //~^ unchecked_duration_subtraction
 
     let _ = Instant::now() - Duration::from_secs(5);
+    //~^ unchecked_duration_subtraction
 
     let _ = _first - Duration::from_secs(5);
+    //~^ unchecked_duration_subtraction
 
     let _ = Instant::now() - second;
+    //~^ unchecked_duration_subtraction
 }
diff --git a/src/tools/clippy/tests/ui/unchecked_duration_subtraction.stderr b/src/tools/clippy/tests/ui/unchecked_duration_subtraction.stderr
index b5e9bab86b47..be291c320e68 100644
--- a/src/tools/clippy/tests/ui/unchecked_duration_subtraction.stderr
+++ b/src/tools/clippy/tests/ui/unchecked_duration_subtraction.stderr
@@ -8,19 +8,19 @@ LL |     let _ = _first - second;
    = help: to override `-D warnings` add `#[allow(clippy::unchecked_duration_subtraction)]`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
-  --> tests/ui/unchecked_duration_subtraction.rs:11:13
+  --> tests/ui/unchecked_duration_subtraction.rs:12:13
    |
 LL |     let _ = Instant::now() - Duration::from_secs(5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(Duration::from_secs(5)).unwrap()`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
-  --> tests/ui/unchecked_duration_subtraction.rs:13:13
+  --> tests/ui/unchecked_duration_subtraction.rs:15:13
    |
 LL |     let _ = _first - Duration::from_secs(5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `_first.checked_sub(Duration::from_secs(5)).unwrap()`
 
 error: unchecked subtraction of a 'Duration' from an 'Instant'
-  --> tests/ui/unchecked_duration_subtraction.rs:15:13
+  --> tests/ui/unchecked_duration_subtraction.rs:18:13
    |
 LL |     let _ = Instant::now() - second;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Instant::now().checked_sub(second).unwrap()`
diff --git a/src/tools/clippy/tests/ui/unconditional_recursion.rs b/src/tools/clippy/tests/ui/unconditional_recursion.rs
index b8476a7088a1..d9f4c07dc902 100644
--- a/src/tools/clippy/tests/ui/unconditional_recursion.rs
+++ b/src/tools/clippy/tests/ui/unconditional_recursion.rs
@@ -15,11 +15,13 @@ enum Foo {
 
 impl PartialEq for Foo {
     fn ne(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         self != other
     }
     fn eq(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         self == other
     }
 }
@@ -31,9 +33,11 @@ enum Foo2 {
 
 impl PartialEq for Foo2 {
     fn ne(&self, other: &Self) -> bool {
+        //~^ unconditional_recursion
         self != &Foo2::B // no error here
     }
     fn eq(&self, other: &Self) -> bool {
+        //~^ unconditional_recursion
         self == &Foo2::B // no error here
     }
 }
@@ -45,11 +49,14 @@ enum Foo3 {
 
 impl PartialEq for Foo3 {
     fn ne(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+        //~| ERROR: function cannot return without recursing
         self.ne(other)
     }
     fn eq(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+        //~| ERROR: function cannot return without recursing
+
         self.eq(other)
     }
 }
@@ -93,11 +100,13 @@ struct S;
 // Check the order doesn't matter.
 impl PartialEq for S {
     fn ne(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         other != self
     }
     fn eq(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         other == self
     }
 }
@@ -107,12 +116,16 @@ struct S2;
 // Check that if the same element is compared, it's also triggering the lint.
 impl PartialEq for S2 {
     fn ne(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         other != other
+        //~^ eq_op
     }
     fn eq(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         other == other
+        //~^ eq_op
     }
 }
 
@@ -120,12 +133,16 @@ struct S3;
 
 impl PartialEq for S3 {
     fn ne(&self, _other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         self != self
+        //~^ eq_op
     }
     fn eq(&self, _other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         self == self
+        //~^ eq_op
     }
 }
 
@@ -152,7 +169,8 @@ macro_rules! impl_partial_eq {
     ($ty:ident) => {
         impl PartialEq for $ty {
             fn eq(&self, other: &Self) -> bool {
-                //~^ ERROR: function cannot return without recursing
+                //~^ unconditional_recursion
+
                 self == other
             }
         }
@@ -181,7 +199,8 @@ struct S7<'a> {
 
 impl<'a> PartialEq for S7<'a> {
     fn eq(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         let mine = &self.field;
         let theirs = &other.field;
         mine == theirs
@@ -250,7 +269,8 @@ impl std::default::Default for S12 {
 
 impl S12 {
     fn new() -> Self {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         Self::default()
     }
 
@@ -289,7 +309,8 @@ struct S15<'a> {
 
 impl PartialEq for S15<'_> {
     fn eq(&self, other: &Self) -> bool {
-        //~^ ERROR: function cannot return without recursing
+        //~^ unconditional_recursion
+
         let mine = &self.field;
         let theirs = &other.field;
         mine.eq(theirs)
@@ -360,6 +381,7 @@ struct BadFromTy1<'a>(&'a ());
 struct BadIntoTy1<'b>(&'b ());
 impl<'a> From<BadFromTy1<'a>> for BadIntoTy1<'static> {
     fn from(f: BadFromTy1<'a>) -> Self {
+        //~^ unconditional_recursion
         f.into()
     }
 }
@@ -369,6 +391,7 @@ struct BadFromTy2<'a>(&'a ());
 struct BadIntoTy2<'b>(&'b ());
 impl<'a> From<BadFromTy2<'a>> for BadIntoTy2<'static> {
     fn from(f: BadFromTy2<'a>) -> Self {
+        //~^ unconditional_recursion
         Into::into(f)
     }
 }
diff --git a/src/tools/clippy/tests/ui/unconditional_recursion.stderr b/src/tools/clippy/tests/ui/unconditional_recursion.stderr
index 6a0078ee0906..c6eaa6a0775c 100644
--- a/src/tools/clippy/tests/ui/unconditional_recursion.stderr
+++ b/src/tools/clippy/tests/ui/unconditional_recursion.stderr
@@ -1,9 +1,9 @@
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:47:5
+  --> tests/ui/unconditional_recursion.rs:51:5
    |
 LL |     fn ne(&self, other: &Self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
-LL |
+...
 LL |         self.ne(other)
    |         -------------- recursive call site
    |
@@ -12,18 +12,18 @@ LL |         self.ne(other)
    = help: to override `-D warnings` add `#[allow(unconditional_recursion)]`
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:51:5
+  --> tests/ui/unconditional_recursion.rs:56:5
    |
 LL |     fn eq(&self, other: &Self) -> bool {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
-LL |
+...
 LL |         self.eq(other)
    |         -------------- recursive call site
    |
    = help: a `loop` may express intention better if this is on purpose
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:216:5
+  --> tests/ui/unconditional_recursion.rs:235:5
    |
 LL |     fn to_string(&self) -> String {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -34,7 +34,7 @@ LL |         self.to_string()
    = help: a `loop` may express intention better if this is on purpose
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:226:5
+  --> tests/ui/unconditional_recursion.rs:245:5
    |
 LL |     fn to_string(&self) -> String {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -45,7 +45,7 @@ LL |         x.to_string()
    = help: a `loop` may express intention better if this is on purpose
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:237:5
+  --> tests/ui/unconditional_recursion.rs:256:5
    |
 LL |     fn to_string(&self) -> String {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ cannot return without recursing
@@ -60,12 +60,13 @@ error: function cannot return without recursing
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         self != other
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:19:9
+  --> tests/ui/unconditional_recursion.rs:20:9
    |
 LL |         self != other
    |         ^^^^^^^^^^^^^
@@ -73,125 +74,132 @@ LL |         self != other
    = help: to override `-D warnings` add `#[allow(clippy::unconditional_recursion)]`
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:21:5
+  --> tests/ui/unconditional_recursion.rs:22:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         self == other
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:23:9
+  --> tests/ui/unconditional_recursion.rs:25:9
    |
 LL |         self == other
    |         ^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:33:5
+  --> tests/ui/unconditional_recursion.rs:35:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
+LL | |
 LL | |         self != &Foo2::B // no error here
-LL | |     }
-   | |_____^
-   |
-note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:34:9
-   |
-LL |         self != &Foo2::B // no error here
-   |         ^^^^^^^^^^^^^^^^
-
-error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:36:5
-   |
-LL | /     fn eq(&self, other: &Self) -> bool {
-LL | |         self == &Foo2::B // no error here
 LL | |     }
    | |_____^
    |
 note: recursive call site
   --> tests/ui/unconditional_recursion.rs:37:9
    |
+LL |         self != &Foo2::B // no error here
+   |         ^^^^^^^^^^^^^^^^
+
+error: function cannot return without recursing
+  --> tests/ui/unconditional_recursion.rs:39:5
+   |
+LL | /     fn eq(&self, other: &Self) -> bool {
+LL | |
+LL | |         self == &Foo2::B // no error here
+LL | |     }
+   | |_____^
+   |
+note: recursive call site
+  --> tests/ui/unconditional_recursion.rs:41:9
+   |
 LL |         self == &Foo2::B // no error here
    |         ^^^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:47:5
+  --> tests/ui/unconditional_recursion.rs:51:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         self.ne(other)
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:49:9
+  --> tests/ui/unconditional_recursion.rs:54:9
    |
 LL |         self.ne(other)
    |         ^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:51:5
+  --> tests/ui/unconditional_recursion.rs:56:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
-LL | |
-LL | |         self.eq(other)
+...  |
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:53:9
+  --> tests/ui/unconditional_recursion.rs:60:9
    |
 LL |         self.eq(other)
    |         ^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:95:5
+  --> tests/ui/unconditional_recursion.rs:102:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         other != self
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:97:9
+  --> tests/ui/unconditional_recursion.rs:105:9
    |
 LL |         other != self
    |         ^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:99:5
+  --> tests/ui/unconditional_recursion.rs:107:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         other == self
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:101:9
+  --> tests/ui/unconditional_recursion.rs:110:9
    |
 LL |         other == self
    |         ^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:109:5
+  --> tests/ui/unconditional_recursion.rs:118:5
    |
 LL | /     fn ne(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         other != other
+LL | |
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:111:9
+  --> tests/ui/unconditional_recursion.rs:121:9
    |
 LL |         other != other
    |         ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> tests/ui/unconditional_recursion.rs:111:9
+  --> tests/ui/unconditional_recursion.rs:121:9
    |
 LL |         other != other
    |         ^^^^^^^^^^^^^^
@@ -199,73 +207,80 @@ LL |         other != other
    = note: `#[deny(clippy::eq_op)]` on by default
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:113:5
+  --> tests/ui/unconditional_recursion.rs:124:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         other == other
+LL | |
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:115:9
+  --> tests/ui/unconditional_recursion.rs:127:9
    |
 LL |         other == other
    |         ^^^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/unconditional_recursion.rs:115:9
+  --> tests/ui/unconditional_recursion.rs:127:9
    |
 LL |         other == other
    |         ^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:122:5
+  --> tests/ui/unconditional_recursion.rs:135:5
    |
 LL | /     fn ne(&self, _other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         self != self
+LL | |
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:124:9
+  --> tests/ui/unconditional_recursion.rs:138:9
    |
 LL |         self != self
    |         ^^^^^^^^^^^^
 
 error: equal expressions as operands to `!=`
-  --> tests/ui/unconditional_recursion.rs:124:9
+  --> tests/ui/unconditional_recursion.rs:138:9
    |
 LL |         self != self
    |         ^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:126:5
+  --> tests/ui/unconditional_recursion.rs:141:5
    |
 LL | /     fn eq(&self, _other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         self == self
+LL | |
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:128:9
+  --> tests/ui/unconditional_recursion.rs:144:9
    |
 LL |         self == self
    |         ^^^^^^^^^^^^
 
 error: equal expressions as operands to `==`
-  --> tests/ui/unconditional_recursion.rs:128:9
+  --> tests/ui/unconditional_recursion.rs:144:9
    |
 LL |         self == self
    |         ^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:154:13
+  --> tests/ui/unconditional_recursion.rs:171:13
    |
 LL | /             fn eq(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |                 self == other
 LL | |             }
    | |_____________^
@@ -274,7 +289,7 @@ LL |   impl_partial_eq!(S5);
    |   -------------------- in this macro invocation
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:156:17
+  --> tests/ui/unconditional_recursion.rs:174:17
    |
 LL |                 self == other
    |                 ^^^^^^^^^^^^^
@@ -284,10 +299,11 @@ LL | impl_partial_eq!(S5);
    = note: this error originates in the macro `impl_partial_eq` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:183:5
+  --> tests/ui/unconditional_recursion.rs:201:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         let mine = &self.field;
 LL | |         let theirs = &other.field;
 LL | |         mine == theirs
@@ -295,31 +311,33 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:187:9
+  --> tests/ui/unconditional_recursion.rs:206:9
    |
 LL |         mine == theirs
    |         ^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:252:5
+  --> tests/ui/unconditional_recursion.rs:271:5
    |
 LL | /     fn new() -> Self {
 LL | |
+LL | |
 LL | |         Self::default()
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:254:9
+  --> tests/ui/unconditional_recursion.rs:274:9
    |
 LL |         Self::default()
    |         ^^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:291:5
+  --> tests/ui/unconditional_recursion.rs:311:5
    |
 LL | /     fn eq(&self, other: &Self) -> bool {
 LL | |
+LL | |
 LL | |         let mine = &self.field;
 LL | |         let theirs = &other.field;
 LL | |         mine.eq(theirs)
@@ -327,35 +345,37 @@ LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:295:9
+  --> tests/ui/unconditional_recursion.rs:316:9
    |
 LL |         mine.eq(theirs)
    |         ^^^^^^^^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:362:5
+  --> tests/ui/unconditional_recursion.rs:383:5
    |
 LL | /     fn from(f: BadFromTy1<'a>) -> Self {
+LL | |
 LL | |         f.into()
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:363:9
+  --> tests/ui/unconditional_recursion.rs:385:9
    |
 LL |         f.into()
    |         ^^^^^^^^
 
 error: function cannot return without recursing
-  --> tests/ui/unconditional_recursion.rs:371:5
+  --> tests/ui/unconditional_recursion.rs:393:5
    |
 LL | /     fn from(f: BadFromTy2<'a>) -> Self {
+LL | |
 LL | |         Into::into(f)
 LL | |     }
    | |_____^
    |
 note: recursive call site
-  --> tests/ui/unconditional_recursion.rs:372:9
+  --> tests/ui/unconditional_recursion.rs:395:9
    |
 LL |         Into::into(f)
    |         ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unicode.fixed b/src/tools/clippy/tests/ui/unicode.fixed
index f9efb4ec34c6..9234b440d964 100644
--- a/src/tools/clippy/tests/ui/unicode.fixed
+++ b/src/tools/clippy/tests/ui/unicode.fixed
@@ -3,16 +3,20 @@
 #[warn(clippy::invisible_characters)]
 fn zero() {
     print!("Here >\u{200B}< is a ZWS, and \u{200B}another");
+    //~^ invisible_characters
     print!("This\u{200B}is\u{200B}fine");
     print!("Here >\u{AD}< is a SHY, and \u{AD}another");
+    //~^ invisible_characters
     print!("This\u{ad}is\u{ad}fine");
     print!("Here >\u{2060}< is a WJ, and \u{2060}another");
+    //~^ invisible_characters
     print!("This\u{2060}is\u{2060}fine");
 }
 
 #[warn(clippy::unicode_not_nfc)]
 fn canon() {
     print!("̀àh?");
+    //~^ unicode_not_nfc
     print!("a\u{0300}h?"); // also ok
 }
 
@@ -21,13 +25,16 @@ mod non_ascii_literal {
 
     fn uni() {
         print!("\u{dc}ben!");
+        //~^ non_ascii_literal
         print!("\u{DC}ben!"); // this is ok
     }
 
     // issue 8013
     fn single_quote() {
         const _EMPTY_BLOCK: char = '\u{25b1}';
+        //~^ non_ascii_literal
         const _FULL_BLOCK: char = '\u{25b0}';
+        //~^ non_ascii_literal
     }
 
     #[test]
@@ -48,6 +55,7 @@ mod non_ascii_literal {
         #[test]
         fn denied() {
             let _ = "\u{60b2}\u{3057}\u{3044}\u{304b}\u{306a}\u{3001}\u{3053}\u{3053}\u{306b}\u{65e5}\u{672c}\u{8a9e}\u{3092}\u{66f8}\u{304f}\u{3053}\u{3068}\u{306f}\u{3067}\u{304d}\u{306a}\u{3044}\u{3002}";
+            //~^ non_ascii_literal
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/unicode.rs b/src/tools/clippy/tests/ui/unicode.rs
index bba613e228ed..ada8bac8e049 100644
--- a/src/tools/clippy/tests/ui/unicode.rs
+++ b/src/tools/clippy/tests/ui/unicode.rs
@@ -3,16 +3,20 @@
 #[warn(clippy::invisible_characters)]
 fn zero() {
     print!("Here >​< is a ZWS, and ​another");
+    //~^ invisible_characters
     print!("This\u{200B}is\u{200B}fine");
     print!("Here >­< is a SHY, and ­another");
+    //~^ invisible_characters
     print!("This\u{ad}is\u{ad}fine");
     print!("Here >⁠< is a WJ, and ⁠another");
+    //~^ invisible_characters
     print!("This\u{2060}is\u{2060}fine");
 }
 
 #[warn(clippy::unicode_not_nfc)]
 fn canon() {
     print!("̀àh?");
+    //~^ unicode_not_nfc
     print!("a\u{0300}h?"); // also ok
 }
 
@@ -21,13 +25,16 @@ mod non_ascii_literal {
 
     fn uni() {
         print!("Üben!");
+        //~^ non_ascii_literal
         print!("\u{DC}ben!"); // this is ok
     }
 
     // issue 8013
     fn single_quote() {
         const _EMPTY_BLOCK: char = '▱';
+        //~^ non_ascii_literal
         const _FULL_BLOCK: char = '▰';
+        //~^ non_ascii_literal
     }
 
     #[test]
@@ -48,6 +55,7 @@ mod non_ascii_literal {
         #[test]
         fn denied() {
             let _ = "悲しいかな、ここに日本語を書くことはできない。";
+            //~^ non_ascii_literal
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/unicode.stderr b/src/tools/clippy/tests/ui/unicode.stderr
index b004493300ee..c761ec89602f 100644
--- a/src/tools/clippy/tests/ui/unicode.stderr
+++ b/src/tools/clippy/tests/ui/unicode.stderr
@@ -8,19 +8,19 @@ LL |     print!("Here >​< is a ZWS, and ​another");
    = help: to override `-D warnings` add `#[allow(clippy::invisible_characters)]`
 
 error: invisible character detected
-  --> tests/ui/unicode.rs:7:12
+  --> tests/ui/unicode.rs:8:12
    |
 LL |     print!("Here >­< is a SHY, and ­another");
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >\u{AD}< is a SHY, and \u{AD}another"`
 
 error: invisible character detected
-  --> tests/ui/unicode.rs:9:12
+  --> tests/ui/unicode.rs:11:12
    |
 LL |     print!("Here >⁠< is a WJ, and ⁠another");
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"Here >\u{2060}< is a WJ, and \u{2060}another"`
 
 error: non-NFC Unicode sequence detected
-  --> tests/ui/unicode.rs:15:12
+  --> tests/ui/unicode.rs:18:12
    |
 LL |     print!("̀àh?");
    |            ^^^^^ help: consider replacing the string with: `"̀àh?"`
@@ -29,37 +29,37 @@ LL |     print!("̀àh?");
    = help: to override `-D warnings` add `#[allow(clippy::unicode_not_nfc)]`
 
 error: literal non-ASCII character detected
-  --> tests/ui/unicode.rs:23:16
+  --> tests/ui/unicode.rs:27:16
    |
 LL |         print!("Üben!");
    |                ^^^^^^^ help: consider replacing the string with: `"\u{dc}ben!"`
    |
 note: the lint level is defined here
-  --> tests/ui/unicode.rs:20:13
+  --> tests/ui/unicode.rs:24:13
    |
 LL |     #![deny(clippy::non_ascii_literal)]
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: literal non-ASCII character detected
-  --> tests/ui/unicode.rs:29:36
+  --> tests/ui/unicode.rs:34:36
    |
 LL |         const _EMPTY_BLOCK: char = '▱';
    |                                    ^^^ help: consider replacing the string with: `'\u{25b1}'`
 
 error: literal non-ASCII character detected
-  --> tests/ui/unicode.rs:30:35
+  --> tests/ui/unicode.rs:36:35
    |
 LL |         const _FULL_BLOCK: char = '▰';
    |                                   ^^^ help: consider replacing the string with: `'\u{25b0}'`
 
 error: literal non-ASCII character detected
-  --> tests/ui/unicode.rs:50:21
+  --> tests/ui/unicode.rs:57:21
    |
 LL |             let _ = "悲しいかな、ここに日本語を書くことはできない。";
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider replacing the string with: `"\u{60b2}\u{3057}\u{3044}\u{304b}\u{306a}\u{3001}\u{3053}\u{3053}\u{306b}\u{65e5}\u{672c}\u{8a9e}\u{3092}\u{66f8}\u{304f}\u{3053}\u{3068}\u{306f}\u{3067}\u{304d}\u{306a}\u{3044}\u{3002}"`
    |
 note: the lint level is defined here
-  --> tests/ui/unicode.rs:39:17
+  --> tests/ui/unicode.rs:46:17
    |
 LL |         #![deny(clippy::non_ascii_literal)]
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/uninhabited_references.rs b/src/tools/clippy/tests/ui/uninhabited_references.rs
index 3569366ed056..9b3616ad5187 100644
--- a/src/tools/clippy/tests/ui/uninhabited_references.rs
+++ b/src/tools/clippy/tests/ui/uninhabited_references.rs
@@ -3,13 +3,16 @@
 #![feature(never_type)]
 
 fn ret_uninh_ref() -> &'static std::convert::Infallible {
+    //~^ uninhabited_references
     unsafe { std::mem::transmute(&()) }
 }
 
 macro_rules! ret_something {
     ($name:ident, $ty:ty) => {
         fn $name(x: &$ty) -> &$ty {
+            //~^ uninhabited_references
             &*x
+            //~^ uninhabited_references
         }
     };
 }
@@ -20,4 +23,5 @@ ret_something!(id_never, !);
 fn main() {
     let x = ret_uninh_ref();
     let _ = *x;
+    //~^ uninhabited_references
 }
diff --git a/src/tools/clippy/tests/ui/uninhabited_references.stderr b/src/tools/clippy/tests/ui/uninhabited_references.stderr
index 8c9b206f4296..ac05ab5bb4d4 100644
--- a/src/tools/clippy/tests/ui/uninhabited_references.stderr
+++ b/src/tools/clippy/tests/ui/uninhabited_references.stderr
@@ -8,7 +8,7 @@ LL | fn ret_uninh_ref() -> &'static std::convert::Infallible {
    = help: to override `-D warnings` add `#[allow(clippy::uninhabited_references)]`
 
 error: dereferencing a reference to an uninhabited type would be undefined behavior
-  --> tests/ui/uninhabited_references.rs:11:30
+  --> tests/ui/uninhabited_references.rs:12:30
    |
 LL |         fn $name(x: &$ty) -> &$ty {
    |                              ^^^^
@@ -19,7 +19,7 @@ LL | ret_something!(id_never, !);
    = note: this error originates in the macro `ret_something` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: dereferencing a reference to an uninhabited type is undefined behavior
-  --> tests/ui/uninhabited_references.rs:12:14
+  --> tests/ui/uninhabited_references.rs:14:14
    |
 LL |             &*x
    |              ^^
@@ -30,7 +30,7 @@ LL | ret_something!(id_never, !);
    = note: this error originates in the macro `ret_something` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: dereferencing a reference to an uninhabited type is undefined behavior
-  --> tests/ui/uninhabited_references.rs:22:13
+  --> tests/ui/uninhabited_references.rs:25:13
    |
 LL |     let _ = *x;
    |             ^^
diff --git a/src/tools/clippy/tests/ui/uninit.rs b/src/tools/clippy/tests/ui/uninit.rs
index 10a4c22b5b91..f74248c8aea8 100644
--- a/src/tools/clippy/tests/ui/uninit.rs
+++ b/src/tools/clippy/tests/ui/uninit.rs
@@ -10,8 +10,7 @@ union MyOwnMaybeUninit {
 
 fn main() {
     let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
-    //~^ ERROR: this call for this type may be undefined behavior
-    //~| NOTE: `#[deny(clippy::uninit_assumed_init)]` on by default
+    //~^ uninit_assumed_init
 
     // This is OK, because ZSTs do not contain data.
     let _: () = unsafe { MaybeUninit::uninit().assume_init() };
@@ -33,7 +32,7 @@ fn main() {
 
     // Was a false negative.
     let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
-    //~^ ERROR: this call for this type may be undefined behavior
+    //~^ uninit_assumed_init
 
     polymorphic::<()>();
     polymorphic_maybe_uninit_array::<10>();
@@ -42,7 +41,7 @@ fn main() {
     fn polymorphic<T>() {
         // We are conservative around polymorphic types.
         let _: T = unsafe { MaybeUninit::uninit().assume_init() };
-        //~^ ERROR: this call for this type may be undefined behavior
+        //~^ uninit_assumed_init
     }
 
     fn polymorphic_maybe_uninit_array<const N: usize>() {
diff --git a/src/tools/clippy/tests/ui/uninit.stderr b/src/tools/clippy/tests/ui/uninit.stderr
index 81577fe3fd47..d6f54dd61ca0 100644
--- a/src/tools/clippy/tests/ui/uninit.stderr
+++ b/src/tools/clippy/tests/ui/uninit.stderr
@@ -7,13 +7,13 @@ LL |     let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
    = note: `#[deny(clippy::uninit_assumed_init)]` on by default
 
 error: this call for this type may be undefined behavior
-  --> tests/ui/uninit.rs:35:29
+  --> tests/ui/uninit.rs:34:29
    |
 LL |     let _: usize = unsafe { MaybeUninit::uninit().assume_init() };
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this call for this type may be undefined behavior
-  --> tests/ui/uninit.rs:44:29
+  --> tests/ui/uninit.rs:43:29
    |
 LL |         let _: T = unsafe { MaybeUninit::uninit().assume_init() };
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/uninit_vec.rs b/src/tools/clippy/tests/ui/uninit_vec.rs
index 464f88140bdb..a48397137992 100644
--- a/src/tools/clippy/tests/ui/uninit_vec.rs
+++ b/src/tools/clippy/tests/ui/uninit_vec.rs
@@ -16,40 +16,46 @@ union MyOwnMaybeUninit {
 // https://github.com/rust-lang/rust/issues/119620
 unsafe fn requires_paramenv<S>() {
     let mut vec = Vec::<UnsafeCell<*mut S>>::with_capacity(1);
+    //~^ uninit_vec
     vec.set_len(1);
 }
 
 fn main() {
     // with_capacity() -> set_len() should be detected
     let mut vec: Vec<u8> = Vec::with_capacity(1000);
-    //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates uninitial
+    //~^ uninit_vec
+
     unsafe {
         vec.set_len(200);
     }
 
     // reserve() -> set_len() should be detected
     vec.reserve(1000);
-    //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates uninitial
+    //~^ uninit_vec
+
     unsafe {
         vec.set_len(200);
     }
 
     // new() -> set_len() should be detected
     let mut vec: Vec<u8> = Vec::new();
-    //~^ ERROR: calling `set_len()` on empty `Vec` creates out-of-bound values
+    //~^ uninit_vec
+
     unsafe {
         vec.set_len(200);
     }
 
     // default() -> set_len() should be detected
     let mut vec: Vec<u8> = Default::default();
-    //~^ ERROR: calling `set_len()` on empty `Vec` creates out-of-bound values
+    //~^ uninit_vec
+
     unsafe {
         vec.set_len(200);
     }
 
     let mut vec: Vec<u8> = Vec::default();
-    //~^ ERROR: calling `set_len()` on empty `Vec` creates out-of-bound values
+    //~^ uninit_vec
+
     unsafe {
         vec.set_len(200);
     }
@@ -57,16 +63,19 @@ fn main() {
     // test when both calls are enclosed in the same unsafe block
     unsafe {
         let mut vec: Vec<u8> = Vec::with_capacity(1000);
-        //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates unini
+        //~^ uninit_vec
+
         vec.set_len(200);
 
         vec.reserve(1000);
-        //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates unini
+        //~^ uninit_vec
+
         vec.set_len(200);
     }
 
     let mut vec: Vec<u8> = Vec::with_capacity(1000);
-    //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates uninitial
+    //~^ uninit_vec
+
     unsafe {
         // test the case where there are other statements in the following unsafe block
         vec.set_len(200);
@@ -76,13 +85,15 @@ fn main() {
     // handle vec stored in the field of a struct
     let mut my_vec = MyVec::default();
     my_vec.vec.reserve(1000);
-    //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates uninitial
+    //~^ uninit_vec
+
     unsafe {
         my_vec.vec.set_len(200);
     }
 
     my_vec.vec = Vec::with_capacity(1000);
-    //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates uninitial
+    //~^ uninit_vec
+
     unsafe {
         my_vec.vec.set_len(200);
     }
@@ -137,7 +148,8 @@ fn main() {
     fn polymorphic<T>() {
         // We are conservative around polymorphic types.
         let mut vec: Vec<T> = Vec::with_capacity(1000);
-        //~^ ERROR: calling `set_len()` immediately after reserving a buffer creates unini
+        //~^ uninit_vec
+
         unsafe {
             vec.set_len(10);
         }
@@ -165,6 +177,7 @@ fn main() {
 
         let mut vec: Vec<Recursive<T>> = Vec::with_capacity(1);
         //~^ uninit_vec
+
         unsafe {
             vec.set_len(1);
         }
@@ -178,6 +191,7 @@ fn main() {
         // Enums can have a discriminant that can't be uninit, so this should still warn
         let mut vec: Vec<Enum<T>> = Vec::with_capacity(1);
         //~^ uninit_vec
+
         unsafe {
             vec.set_len(1);
         }
diff --git a/src/tools/clippy/tests/ui/uninit_vec.stderr b/src/tools/clippy/tests/ui/uninit_vec.stderr
index e7c81cf792f2..7ff6140a2c3e 100644
--- a/src/tools/clippy/tests/ui/uninit_vec.stderr
+++ b/src/tools/clippy/tests/ui/uninit_vec.stderr
@@ -3,6 +3,7 @@ error: calling `set_len()` immediately after reserving a buffer creates uninitia
    |
 LL |     let mut vec = Vec::<UnsafeCell<*mut S>>::with_capacity(1);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |
 LL |     vec.set_len(1);
    |     ^^^^^^^^^^^^^^
    |
@@ -11,7 +12,7 @@ LL |     vec.set_len(1);
    = help: to override `-D warnings` add `#[allow(clippy::uninit_vec)]`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:24:5
+  --> tests/ui/uninit_vec.rs:25:5
    |
 LL |     let mut vec: Vec<u8> = Vec::with_capacity(1000);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -22,7 +23,7 @@ LL |         vec.set_len(200);
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:31:5
+  --> tests/ui/uninit_vec.rs:33:5
    |
 LL |     vec.reserve(1000);
    |     ^^^^^^^^^^^^^^^^^^
@@ -33,7 +34,7 @@ LL |         vec.set_len(200);
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` on empty `Vec` creates out-of-bound values
-  --> tests/ui/uninit_vec.rs:38:5
+  --> tests/ui/uninit_vec.rs:41:5
    |
 LL |     let mut vec: Vec<u8> = Vec::new();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -42,7 +43,7 @@ LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
 
 error: calling `set_len()` on empty `Vec` creates out-of-bound values
-  --> tests/ui/uninit_vec.rs:45:5
+  --> tests/ui/uninit_vec.rs:49:5
    |
 LL |     let mut vec: Vec<u8> = Default::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -51,7 +52,7 @@ LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
 
 error: calling `set_len()` on empty `Vec` creates out-of-bound values
-  --> tests/ui/uninit_vec.rs:51:5
+  --> tests/ui/uninit_vec.rs:56:5
    |
 LL |     let mut vec: Vec<u8> = Vec::default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +61,7 @@ LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:68:5
+  --> tests/ui/uninit_vec.rs:76:5
    |
 LL |     let mut vec: Vec<u8> = Vec::with_capacity(1000);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -71,7 +72,7 @@ LL |         vec.set_len(200);
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:78:5
+  --> tests/ui/uninit_vec.rs:87:5
    |
 LL |     my_vec.vec.reserve(1000);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -82,7 +83,7 @@ LL |         my_vec.vec.set_len(200);
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:84:5
+  --> tests/ui/uninit_vec.rs:94:5
    |
 LL |     my_vec.vec = Vec::with_capacity(1000);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -93,29 +94,29 @@ LL |         my_vec.vec.set_len(200);
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:59:9
+  --> tests/ui/uninit_vec.rs:65:9
    |
 LL |         let mut vec: Vec<u8> = Vec::with_capacity(1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-LL |
+...
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
    |
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:63:9
+  --> tests/ui/uninit_vec.rs:70:9
    |
 LL |         vec.reserve(1000);
    |         ^^^^^^^^^^^^^^^^^^
-LL |
+...
 LL |         vec.set_len(200);
    |         ^^^^^^^^^^^^^^^^
    |
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:139:9
+  --> tests/ui/uninit_vec.rs:150:9
    |
 LL |         let mut vec: Vec<T> = Vec::with_capacity(1000);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -126,7 +127,7 @@ LL |             vec.set_len(10);
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:166:9
+  --> tests/ui/uninit_vec.rs:178:9
    |
 LL |         let mut vec: Vec<Recursive<T>> = Vec::with_capacity(1);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -137,7 +138,7 @@ LL |             vec.set_len(1);
    = help: initialize the buffer or wrap the content in `MaybeUninit`
 
 error: calling `set_len()` immediately after reserving a buffer creates uninitialized values
-  --> tests/ui/uninit_vec.rs:179:9
+  --> tests/ui/uninit_vec.rs:192:9
    |
 LL |         let mut vec: Vec<Enum<T>> = Vec::with_capacity(1);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args.fixed b/src/tools/clippy/tests/ui/uninlined_format_args.fixed
index 111a2e1987c8..7b609d9163a9 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args.fixed
+++ b/src/tools/clippy/tests/ui/uninlined_format_args.fixed
@@ -43,75 +43,141 @@ fn tester(fn_arg: i32) {
     let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
 
     println!("val='{local_i32}'");
+    //~^ uninlined_format_args
     println!("val='{local_i32}'"); // 3 spaces
+    //
+    //~^^ uninlined_format_args
     println!("val='{local_i32}'"); // tab
+    //
+    //~^^ uninlined_format_args
     println!("val='{local_i32}'"); // space+tab
+    //
+    //~^^ uninlined_format_args
     println!("val='{local_i32}'"); // tab+space
+    //
+    //~^^ uninlined_format_args
     println!(
+        //~^ uninlined_format_args
         "val='{local_i32}'"
     );
     println!("{local_i32}");
+    //~^ uninlined_format_args
     println!("{fn_arg}");
+    //~^ uninlined_format_args
     println!("{local_i32:?}");
+    //~^ uninlined_format_args
     println!("{local_i32:#?}");
+    //~^ uninlined_format_args
     println!("{local_i32:4}");
+    //~^ uninlined_format_args
     println!("{local_i32:04}");
+    //~^ uninlined_format_args
     println!("{local_i32:<3}");
+    //~^ uninlined_format_args
     println!("{local_i32:#010x}");
+    //~^ uninlined_format_args
     println!("{local_f64:.1}");
+    //~^ uninlined_format_args
     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
     println!("{local_i32} {local_f64}");
+    //~^ uninlined_format_args
     println!("{}, {}", local_i32, local_opt.unwrap());
     println!("{val}");
+    //~^ uninlined_format_args
     println!("{val}");
+    //~^ uninlined_format_args
     println!("{} {1}", local_i32, 42);
     println!("val='{local_i32}'");
+    //~^ uninlined_format_args
     println!("val='{local_i32}'");
+    //~^ uninlined_format_args
     println!("val='{local_i32}'");
+    //~^ uninlined_format_args
     println!("val='{fn_arg}'");
+    //~^ uninlined_format_args
     println!("{local_i32}");
+    //~^ uninlined_format_args
     println!("{local_i32:?}");
+    //~^ uninlined_format_args
     println!("{local_i32:#?}");
+    //~^ uninlined_format_args
     println!("{local_i32:04}");
+    //~^ uninlined_format_args
     println!("{local_i32:<3}");
+    //~^ uninlined_format_args
     println!("{local_i32:#010x}");
+    //~^ uninlined_format_args
     println!("{local_f64:.1}");
+    //~^ uninlined_format_args
     println!("{local_i32} {local_i32}");
+    //~^ uninlined_format_args
     println!("{local_f64} {local_i32} {local_i32} {local_f64}");
+    //~^ uninlined_format_args
     println!("{local_i32} {local_f64}");
+    //~^ uninlined_format_args
     println!("{local_f64} {local_i32}");
+    //~^ uninlined_format_args
     println!("{local_f64} {local_i32} {local_f64} {local_i32}");
+    //~^ uninlined_format_args
     println!("{1} {0}", "str", local_i32);
     println!("{local_i32}");
+    //~^ uninlined_format_args
     println!("{local_i32:width$}");
+    //~^ uninlined_format_args
     println!("{local_i32:width$}");
+    //~^ uninlined_format_args
     println!("{local_i32:.prec$}");
+    //~^ uninlined_format_args
     println!("{local_i32:.prec$}");
+    //~^ uninlined_format_args
     println!("{val:val$}");
+    //~^ uninlined_format_args
     println!("{val:val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{val:val$.val$}");
+    //~^ uninlined_format_args
     println!("{width:width$}");
+    //~^ uninlined_format_args
     println!("{local_i32:width$}");
+    //~^ uninlined_format_args
     println!("{width:width$}");
+    //~^ uninlined_format_args
     println!("{local_i32:width$}");
+    //~^ uninlined_format_args
     println!("{prec:.prec$}");
+    //~^ uninlined_format_args
     println!("{local_i32:.prec$}");
+    //~^ uninlined_format_args
     println!("{prec:.prec$}");
+    //~^ uninlined_format_args
     println!("{local_i32:.prec$}");
+    //~^ uninlined_format_args
     println!("{width:width$.prec$}");
+    //~^ uninlined_format_args
     println!("{width:width$.prec$}");
+    //~^ uninlined_format_args
     println!("{local_f64:width$.prec$}");
+    //~^ uninlined_format_args
     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
+    //~^ uninlined_format_args
     println!(
+        //~^ uninlined_format_args
         "{local_i32:width$.prec$} {local_i32:prec$.width$} {width:local_i32$.prec$} {width:prec$.local_i32$} {prec:local_i32$.width$} {prec:width$.local_i32$}",
     );
     println!(
@@ -122,8 +188,11 @@ fn tester(fn_arg: i32) {
         1 + 2
     );
     println!("Width = {local_i32}, value with width = {local_f64:local_i32$}");
+    //~^ uninlined_format_args
     println!("{local_i32:width$.prec$}");
+    //~^ uninlined_format_args
     println!("{width:width$.prec$}");
+    //~^ uninlined_format_args
     println!("{}", format!("{}", local_i32));
     my_println!("{}", local_i32);
     my_println_args!("{}", local_i32);
@@ -143,21 +212,26 @@ fn tester(fn_arg: i32) {
     println!(no_param_str!(), local_i32);
 
     println!(
+        //~^ uninlined_format_args
         "{val}",
     );
     println!("{val}");
+    //~^ uninlined_format_args
 
     println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
     println!("{}", with_span!(span val));
 
     if local_i32 > 0 {
         panic!("p1 {local_i32}");
+        //~^ uninlined_format_args
     }
     if local_i32 > 0 {
         panic!("p2 {local_i32}");
+        //~^ uninlined_format_args
     }
     if local_i32 > 0 {
         panic!("p3 {local_i32}");
+        //~^ uninlined_format_args
     }
     if local_i32 > 0 {
         panic!("p4 {local_i32}");
@@ -178,6 +252,7 @@ fn _under_msrv() {
 fn _meets_msrv() {
     let local_i32 = 1;
     println!("expand='{local_i32}'");
+    //~^ uninlined_format_args
 }
 
 fn _do_not_fire() {
@@ -280,7 +355,11 @@ fn user_format() {
     let local_f64 = 2.0;
 
     usr_println!(true, "val='{local_i32}'");
+    //~^ uninlined_format_args
     usr_println!(true, "{local_i32}");
+    //~^ uninlined_format_args
     usr_println!(true, "{local_i32:#010x}");
+    //~^ uninlined_format_args
     usr_println!(true, "{local_f64:.1}");
+    //~^ uninlined_format_args
 }
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args.rs b/src/tools/clippy/tests/ui/uninlined_format_args.rs
index 81fe24765674..14e0b6caabc0 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args.rs
+++ b/src/tools/clippy/tests/ui/uninlined_format_args.rs
@@ -43,77 +43,143 @@ fn tester(fn_arg: i32) {
     let _: &[u8; 3] = b"	 	"; // <- <tab><space><tab>
 
     println!("val='{}'", local_i32);
+    //~^ uninlined_format_args
     println!("val='{   }'", local_i32); // 3 spaces
+    //
+    //~^^ uninlined_format_args
     println!("val='{	}'", local_i32); // tab
+    //
+    //~^^ uninlined_format_args
     println!("val='{ 	}'", local_i32); // space+tab
+    //
+    //~^^ uninlined_format_args
     println!("val='{	 }'", local_i32); // tab+space
+    //
+    //~^^ uninlined_format_args
     println!(
+        //~^ uninlined_format_args
         "val='{
     }'",
         local_i32
     );
     println!("{}", local_i32);
+    //~^ uninlined_format_args
     println!("{}", fn_arg);
+    //~^ uninlined_format_args
     println!("{:?}", local_i32);
+    //~^ uninlined_format_args
     println!("{:#?}", local_i32);
+    //~^ uninlined_format_args
     println!("{:4}", local_i32);
+    //~^ uninlined_format_args
     println!("{:04}", local_i32);
+    //~^ uninlined_format_args
     println!("{:<3}", local_i32);
+    //~^ uninlined_format_args
     println!("{:#010x}", local_i32);
+    //~^ uninlined_format_args
     println!("{:.1}", local_f64);
+    //~^ uninlined_format_args
     println!("Hello {} is {:.*}", "x", local_i32, local_f64);
     println!("Hello {} is {:.*}", local_i32, 5, local_f64);
     println!("Hello {} is {2:.*}", local_i32, 5, local_f64);
     println!("{} {}", local_i32, local_f64);
+    //~^ uninlined_format_args
     println!("{}, {}", local_i32, local_opt.unwrap());
     println!("{}", val);
+    //~^ uninlined_format_args
     println!("{}", v = val);
+    //~^ uninlined_format_args
     println!("{} {1}", local_i32, 42);
     println!("val='{\t }'", local_i32);
+    //~^ uninlined_format_args
     println!("val='{\n }'", local_i32);
+    //~^ uninlined_format_args
     println!("val='{local_i32}'", local_i32 = local_i32);
+    //~^ uninlined_format_args
     println!("val='{local_i32}'", local_i32 = fn_arg);
+    //~^ uninlined_format_args
     println!("{0}", local_i32);
+    //~^ uninlined_format_args
     println!("{0:?}", local_i32);
+    //~^ uninlined_format_args
     println!("{0:#?}", local_i32);
+    //~^ uninlined_format_args
     println!("{0:04}", local_i32);
+    //~^ uninlined_format_args
     println!("{0:<3}", local_i32);
+    //~^ uninlined_format_args
     println!("{0:#010x}", local_i32);
+    //~^ uninlined_format_args
     println!("{0:.1}", local_f64);
+    //~^ uninlined_format_args
     println!("{0} {0}", local_i32);
+    //~^ uninlined_format_args
     println!("{1} {} {0} {}", local_i32, local_f64);
+    //~^ uninlined_format_args
     println!("{0} {1}", local_i32, local_f64);
+    //~^ uninlined_format_args
     println!("{1} {0}", local_i32, local_f64);
+    //~^ uninlined_format_args
     println!("{1} {0} {1} {0}", local_i32, local_f64);
+    //~^ uninlined_format_args
     println!("{1} {0}", "str", local_i32);
     println!("{v}", v = local_i32);
+    //~^ uninlined_format_args
     println!("{local_i32:0$}", width);
+    //~^ uninlined_format_args
     println!("{local_i32:w$}", w = width);
+    //~^ uninlined_format_args
     println!("{local_i32:.0$}", prec);
+    //~^ uninlined_format_args
     println!("{local_i32:.p$}", p = prec);
+    //~^ uninlined_format_args
     println!("{:0$}", v = val);
+    //~^ uninlined_format_args
     println!("{0:0$}", v = val);
+    //~^ uninlined_format_args
     println!("{:0$.0$}", v = val);
+    //~^ uninlined_format_args
     println!("{0:0$.0$}", v = val);
+    //~^ uninlined_format_args
     println!("{0:0$.v$}", v = val);
+    //~^ uninlined_format_args
     println!("{0:v$.0$}", v = val);
+    //~^ uninlined_format_args
     println!("{v:0$.0$}", v = val);
+    //~^ uninlined_format_args
     println!("{v:v$.0$}", v = val);
+    //~^ uninlined_format_args
     println!("{v:0$.v$}", v = val);
+    //~^ uninlined_format_args
     println!("{v:v$.v$}", v = val);
+    //~^ uninlined_format_args
     println!("{:0$}", width);
+    //~^ uninlined_format_args
     println!("{:1$}", local_i32, width);
+    //~^ uninlined_format_args
     println!("{:w$}", w = width);
+    //~^ uninlined_format_args
     println!("{:w$}", local_i32, w = width);
+    //~^ uninlined_format_args
     println!("{:.0$}", prec);
+    //~^ uninlined_format_args
     println!("{:.1$}", local_i32, prec);
+    //~^ uninlined_format_args
     println!("{:.p$}", p = prec);
+    //~^ uninlined_format_args
     println!("{:.p$}", local_i32, p = prec);
+    //~^ uninlined_format_args
     println!("{:0$.1$}", width, prec);
+    //~^ uninlined_format_args
     println!("{:0$.w$}", width, w = prec);
+    //~^ uninlined_format_args
     println!("{:1$.2$}", local_f64, width, prec);
+    //~^ uninlined_format_args
     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
+    //~^ uninlined_format_args
     println!(
+        //~^ uninlined_format_args
         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
         local_i32, width, prec,
     );
@@ -125,8 +191,11 @@ fn tester(fn_arg: i32) {
         1 + 2
     );
     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
+    //~^ uninlined_format_args
     println!("{:w$.p$}", local_i32, w = width, p = prec);
+    //~^ uninlined_format_args
     println!("{:w$.p$}", w = width, p = prec);
+    //~^ uninlined_format_args
     println!("{}", format!("{}", local_i32));
     my_println!("{}", local_i32);
     my_println_args!("{}", local_i32);
@@ -146,23 +215,28 @@ fn tester(fn_arg: i32) {
     println!(no_param_str!(), local_i32);
 
     println!(
+        //~^ uninlined_format_args
         "{}",
         // comment with a comma , in it
         val,
     );
     println!("{}", /* comment with a comma , in it */ val);
+    //~^ uninlined_format_args
 
     println!(with_span!("{0} {1}" "{1} {0}"), local_i32, local_f64);
     println!("{}", with_span!(span val));
 
     if local_i32 > 0 {
         panic!("p1 {}", local_i32);
+        //~^ uninlined_format_args
     }
     if local_i32 > 0 {
         panic!("p2 {0}", local_i32);
+        //~^ uninlined_format_args
     }
     if local_i32 > 0 {
         panic!("p3 {local_i32}", local_i32 = local_i32);
+        //~^ uninlined_format_args
     }
     if local_i32 > 0 {
         panic!("p4 {local_i32}");
@@ -183,6 +257,7 @@ fn _under_msrv() {
 fn _meets_msrv() {
     let local_i32 = 1;
     println!("expand='{}'", local_i32);
+    //~^ uninlined_format_args
 }
 
 fn _do_not_fire() {
@@ -285,7 +360,11 @@ fn user_format() {
     let local_f64 = 2.0;
 
     usr_println!(true, "val='{}'", local_i32);
+    //~^ uninlined_format_args
     usr_println!(true, "{}", local_i32);
+    //~^ uninlined_format_args
     usr_println!(true, "{:#010x}", local_i32);
+    //~^ uninlined_format_args
     usr_println!(true, "{:.1}", local_f64);
+    //~^ uninlined_format_args
 }
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args.stderr b/src/tools/clippy/tests/ui/uninlined_format_args.stderr
index 77961fea2c53..7e62a095eadf 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args.stderr
+++ b/src/tools/clippy/tests/ui/uninlined_format_args.stderr
@@ -13,7 +13,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:46:5
+  --> tests/ui/uninlined_format_args.rs:47:5
    |
 LL |     println!("val='{   }'", local_i32); // 3 spaces
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     println!("val='{local_i32}'"); // 3 spaces
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:47:5
+  --> tests/ui/uninlined_format_args.rs:50:5
    |
 LL |     println!("val='{    }'", local_i32); // tab
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     println!("val='{local_i32}'"); // tab
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:48:5
+  --> tests/ui/uninlined_format_args.rs:53:5
    |
 LL |     println!("val='{     }'", local_i32); // space+tab
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     println!("val='{local_i32}'"); // space+tab
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:49:5
+  --> tests/ui/uninlined_format_args.rs:56:5
    |
 LL |     println!("val='{     }'", local_i32); // tab+space
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,9 +61,10 @@ LL +     println!("val='{local_i32}'"); // tab+space
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:50:5
+  --> tests/ui/uninlined_format_args.rs:59:5
    |
 LL | /     println!(
+LL | |
 LL | |         "val='{
 LL | |     }'",
 LL | |         local_i32
@@ -71,7 +72,7 @@ LL | |     );
    | |_____^
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:55:5
+  --> tests/ui/uninlined_format_args.rs:65:5
    |
 LL |     println!("{}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -83,7 +84,7 @@ LL +     println!("{local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:56:5
+  --> tests/ui/uninlined_format_args.rs:67:5
    |
 LL |     println!("{}", fn_arg);
    |     ^^^^^^^^^^^^^^^^^^^^^^
@@ -95,7 +96,7 @@ LL +     println!("{fn_arg}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:57:5
+  --> tests/ui/uninlined_format_args.rs:69:5
    |
 LL |     println!("{:?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -107,7 +108,7 @@ LL +     println!("{local_i32:?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:58:5
+  --> tests/ui/uninlined_format_args.rs:71:5
    |
 LL |     println!("{:#?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -119,7 +120,7 @@ LL +     println!("{local_i32:#?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:59:5
+  --> tests/ui/uninlined_format_args.rs:73:5
    |
 LL |     println!("{:4}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -131,7 +132,7 @@ LL +     println!("{local_i32:4}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:60:5
+  --> tests/ui/uninlined_format_args.rs:75:5
    |
 LL |     println!("{:04}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -143,7 +144,7 @@ LL +     println!("{local_i32:04}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:61:5
+  --> tests/ui/uninlined_format_args.rs:77:5
    |
 LL |     println!("{:<3}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -155,7 +156,7 @@ LL +     println!("{local_i32:<3}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:62:5
+  --> tests/ui/uninlined_format_args.rs:79:5
    |
 LL |     println!("{:#010x}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -167,7 +168,7 @@ LL +     println!("{local_i32:#010x}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:63:5
+  --> tests/ui/uninlined_format_args.rs:81:5
    |
 LL |     println!("{:.1}", local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -179,7 +180,7 @@ LL +     println!("{local_f64:.1}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:67:5
+  --> tests/ui/uninlined_format_args.rs:86:5
    |
 LL |     println!("{} {}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -191,7 +192,7 @@ LL +     println!("{local_i32} {local_f64}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:69:5
+  --> tests/ui/uninlined_format_args.rs:89:5
    |
 LL |     println!("{}", val);
    |     ^^^^^^^^^^^^^^^^^^^
@@ -203,7 +204,7 @@ LL +     println!("{val}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:70:5
+  --> tests/ui/uninlined_format_args.rs:91:5
    |
 LL |     println!("{}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -215,7 +216,7 @@ LL +     println!("{val}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:72:5
+  --> tests/ui/uninlined_format_args.rs:94:5
    |
 LL |     println!("val='{\t }'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -227,7 +228,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:73:5
+  --> tests/ui/uninlined_format_args.rs:96:5
    |
 LL |     println!("val='{\n }'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -239,7 +240,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:74:5
+  --> tests/ui/uninlined_format_args.rs:98:5
    |
 LL |     println!("val='{local_i32}'", local_i32 = local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -251,7 +252,7 @@ LL +     println!("val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:75:5
+  --> tests/ui/uninlined_format_args.rs:100:5
    |
 LL |     println!("val='{local_i32}'", local_i32 = fn_arg);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -263,7 +264,7 @@ LL +     println!("val='{fn_arg}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:76:5
+  --> tests/ui/uninlined_format_args.rs:102:5
    |
 LL |     println!("{0}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -275,7 +276,7 @@ LL +     println!("{local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:77:5
+  --> tests/ui/uninlined_format_args.rs:104:5
    |
 LL |     println!("{0:?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -287,7 +288,7 @@ LL +     println!("{local_i32:?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:78:5
+  --> tests/ui/uninlined_format_args.rs:106:5
    |
 LL |     println!("{0:#?}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -299,7 +300,7 @@ LL +     println!("{local_i32:#?}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:79:5
+  --> tests/ui/uninlined_format_args.rs:108:5
    |
 LL |     println!("{0:04}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -311,7 +312,7 @@ LL +     println!("{local_i32:04}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:80:5
+  --> tests/ui/uninlined_format_args.rs:110:5
    |
 LL |     println!("{0:<3}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -323,7 +324,7 @@ LL +     println!("{local_i32:<3}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:81:5
+  --> tests/ui/uninlined_format_args.rs:112:5
    |
 LL |     println!("{0:#010x}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -335,7 +336,7 @@ LL +     println!("{local_i32:#010x}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:82:5
+  --> tests/ui/uninlined_format_args.rs:114:5
    |
 LL |     println!("{0:.1}", local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -347,7 +348,7 @@ LL +     println!("{local_f64:.1}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:83:5
+  --> tests/ui/uninlined_format_args.rs:116:5
    |
 LL |     println!("{0} {0}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -359,7 +360,7 @@ LL +     println!("{local_i32} {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:84:5
+  --> tests/ui/uninlined_format_args.rs:118:5
    |
 LL |     println!("{1} {} {0} {}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -371,7 +372,7 @@ LL +     println!("{local_f64} {local_i32} {local_i32} {local_f64}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:85:5
+  --> tests/ui/uninlined_format_args.rs:120:5
    |
 LL |     println!("{0} {1}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -383,7 +384,7 @@ LL +     println!("{local_i32} {local_f64}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:86:5
+  --> tests/ui/uninlined_format_args.rs:122:5
    |
 LL |     println!("{1} {0}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -395,7 +396,7 @@ LL +     println!("{local_f64} {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:87:5
+  --> tests/ui/uninlined_format_args.rs:124:5
    |
 LL |     println!("{1} {0} {1} {0}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -407,7 +408,7 @@ LL +     println!("{local_f64} {local_i32} {local_f64} {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:89:5
+  --> tests/ui/uninlined_format_args.rs:127:5
    |
 LL |     println!("{v}", v = local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -419,7 +420,7 @@ LL +     println!("{local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:90:5
+  --> tests/ui/uninlined_format_args.rs:129:5
    |
 LL |     println!("{local_i32:0$}", width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -431,7 +432,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:91:5
+  --> tests/ui/uninlined_format_args.rs:131:5
    |
 LL |     println!("{local_i32:w$}", w = width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -443,7 +444,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:92:5
+  --> tests/ui/uninlined_format_args.rs:133:5
    |
 LL |     println!("{local_i32:.0$}", prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -455,7 +456,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:93:5
+  --> tests/ui/uninlined_format_args.rs:135:5
    |
 LL |     println!("{local_i32:.p$}", p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -467,7 +468,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:94:5
+  --> tests/ui/uninlined_format_args.rs:137:5
    |
 LL |     println!("{:0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -479,7 +480,7 @@ LL +     println!("{val:val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:95:5
+  --> tests/ui/uninlined_format_args.rs:139:5
    |
 LL |     println!("{0:0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -491,7 +492,7 @@ LL +     println!("{val:val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:96:5
+  --> tests/ui/uninlined_format_args.rs:141:5
    |
 LL |     println!("{:0$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -503,7 +504,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:97:5
+  --> tests/ui/uninlined_format_args.rs:143:5
    |
 LL |     println!("{0:0$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -515,7 +516,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:98:5
+  --> tests/ui/uninlined_format_args.rs:145:5
    |
 LL |     println!("{0:0$.v$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -527,7 +528,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:99:5
+  --> tests/ui/uninlined_format_args.rs:147:5
    |
 LL |     println!("{0:v$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -539,7 +540,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:100:5
+  --> tests/ui/uninlined_format_args.rs:149:5
    |
 LL |     println!("{v:0$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -551,7 +552,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:101:5
+  --> tests/ui/uninlined_format_args.rs:151:5
    |
 LL |     println!("{v:v$.0$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -563,7 +564,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:102:5
+  --> tests/ui/uninlined_format_args.rs:153:5
    |
 LL |     println!("{v:0$.v$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -575,7 +576,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:103:5
+  --> tests/ui/uninlined_format_args.rs:155:5
    |
 LL |     println!("{v:v$.v$}", v = val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -587,7 +588,7 @@ LL +     println!("{val:val$.val$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:104:5
+  --> tests/ui/uninlined_format_args.rs:157:5
    |
 LL |     println!("{:0$}", width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -599,7 +600,7 @@ LL +     println!("{width:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:105:5
+  --> tests/ui/uninlined_format_args.rs:159:5
    |
 LL |     println!("{:1$}", local_i32, width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -611,7 +612,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:106:5
+  --> tests/ui/uninlined_format_args.rs:161:5
    |
 LL |     println!("{:w$}", w = width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -623,7 +624,7 @@ LL +     println!("{width:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:107:5
+  --> tests/ui/uninlined_format_args.rs:163:5
    |
 LL |     println!("{:w$}", local_i32, w = width);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -635,7 +636,7 @@ LL +     println!("{local_i32:width$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:108:5
+  --> tests/ui/uninlined_format_args.rs:165:5
    |
 LL |     println!("{:.0$}", prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -647,7 +648,7 @@ LL +     println!("{prec:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:109:5
+  --> tests/ui/uninlined_format_args.rs:167:5
    |
 LL |     println!("{:.1$}", local_i32, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -659,7 +660,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:110:5
+  --> tests/ui/uninlined_format_args.rs:169:5
    |
 LL |     println!("{:.p$}", p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -671,7 +672,7 @@ LL +     println!("{prec:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:111:5
+  --> tests/ui/uninlined_format_args.rs:171:5
    |
 LL |     println!("{:.p$}", local_i32, p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -683,7 +684,7 @@ LL +     println!("{local_i32:.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:112:5
+  --> tests/ui/uninlined_format_args.rs:173:5
    |
 LL |     println!("{:0$.1$}", width, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -695,7 +696,7 @@ LL +     println!("{width:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:113:5
+  --> tests/ui/uninlined_format_args.rs:175:5
    |
 LL |     println!("{:0$.w$}", width, w = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -707,7 +708,7 @@ LL +     println!("{width:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:114:5
+  --> tests/ui/uninlined_format_args.rs:177:5
    |
 LL |     println!("{:1$.2$}", local_f64, width, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -719,7 +720,7 @@ LL +     println!("{local_f64:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:115:5
+  --> tests/ui/uninlined_format_args.rs:179:5
    |
 LL |     println!("{:1$.2$} {0} {1} {2}", local_f64, width, prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -731,16 +732,17 @@ LL +     println!("{local_f64:width$.prec$} {local_f64} {width} {prec}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:116:5
+  --> tests/ui/uninlined_format_args.rs:181:5
    |
 LL | /     println!(
+LL | |
 LL | |         "{0:1$.2$} {0:2$.1$} {1:0$.2$} {1:2$.0$} {2:0$.1$} {2:1$.0$}",
 LL | |         local_i32, width, prec,
 LL | |     );
    | |_____^
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:127:5
+  --> tests/ui/uninlined_format_args.rs:193:5
    |
 LL |     println!("Width = {}, value with width = {:0$}", local_i32, local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -752,7 +754,7 @@ LL +     println!("Width = {local_i32}, value with width = {local_f64:local_i32$
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:128:5
+  --> tests/ui/uninlined_format_args.rs:195:5
    |
 LL |     println!("{:w$.p$}", local_i32, w = width, p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -764,7 +766,7 @@ LL +     println!("{local_i32:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:129:5
+  --> tests/ui/uninlined_format_args.rs:197:5
    |
 LL |     println!("{:w$.p$}", w = width, p = prec);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -776,17 +778,17 @@ LL +     println!("{width:width$.prec$}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:148:5
+  --> tests/ui/uninlined_format_args.rs:217:5
    |
 LL | /     println!(
+LL | |
 LL | |         "{}",
-LL | |         // comment with a comma , in it
-LL | |         val,
+...  |
 LL | |     );
    | |_____^
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:153:5
+  --> tests/ui/uninlined_format_args.rs:223:5
    |
 LL |     println!("{}", /* comment with a comma , in it */ val);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -798,7 +800,7 @@ LL +     println!("{val}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:159:9
+  --> tests/ui/uninlined_format_args.rs:230:9
    |
 LL |         panic!("p1 {}", local_i32);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -810,7 +812,7 @@ LL +         panic!("p1 {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:162:9
+  --> tests/ui/uninlined_format_args.rs:234:9
    |
 LL |         panic!("p2 {0}", local_i32);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -822,7 +824,7 @@ LL +         panic!("p2 {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:165:9
+  --> tests/ui/uninlined_format_args.rs:238:9
    |
 LL |         panic!("p3 {local_i32}", local_i32 = local_i32);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -834,7 +836,7 @@ LL +         panic!("p3 {local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:185:5
+  --> tests/ui/uninlined_format_args.rs:259:5
    |
 LL |     println!("expand='{}'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -846,7 +848,7 @@ LL +     println!("expand='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:287:5
+  --> tests/ui/uninlined_format_args.rs:362:5
    |
 LL |     usr_println!(true, "val='{}'", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -858,7 +860,7 @@ LL +     usr_println!(true, "val='{local_i32}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:288:5
+  --> tests/ui/uninlined_format_args.rs:364:5
    |
 LL |     usr_println!(true, "{}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -870,7 +872,7 @@ LL +     usr_println!(true, "{local_i32}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:289:5
+  --> tests/ui/uninlined_format_args.rs:366:5
    |
 LL |     usr_println!(true, "{:#010x}", local_i32);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -882,7 +884,7 @@ LL +     usr_println!(true, "{local_i32:#010x}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args.rs:290:5
+  --> tests/ui/uninlined_format_args.rs:368:5
    |
 LL |     usr_println!(true, "{:.1}", local_f64);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.fixed b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.fixed
index 9911d1317070..3710036c0589 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.fixed
+++ b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2018.fixed
@@ -9,15 +9,19 @@ fn main() {
     let var = 1;
 
     println!("val='{var}'");
+    //~^ uninlined_format_args
 
     if var > 0 {
         panic!("p1 {}", var);
+        //~[edition2021]^ uninlined_format_args
     }
     if var > 0 {
         panic!("p2 {0}", var);
+        //~[edition2021]^ uninlined_format_args
     }
     if var > 0 {
         panic!("p3 {var}", var = var);
+        //~[edition2021]^ uninlined_format_args
     }
 
     #[allow(non_fmt_panics)]
@@ -28,5 +32,7 @@ fn main() {
     }
 
     assert!(var == 1, "p5 {}", var);
+    //~[edition2021]^ uninlined_format_args
     debug_assert!(var == 1, "p6 {}", var);
+    //~[edition2021]^ uninlined_format_args
 }
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.fixed b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.fixed
index 87b74670565f..8a754d313806 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.fixed
+++ b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.fixed
@@ -9,15 +9,19 @@ fn main() {
     let var = 1;
 
     println!("val='{var}'");
+    //~^ uninlined_format_args
 
     if var > 0 {
         panic!("p1 {var}");
+        //~[edition2021]^ uninlined_format_args
     }
     if var > 0 {
         panic!("p2 {var}");
+        //~[edition2021]^ uninlined_format_args
     }
     if var > 0 {
         panic!("p3 {var}");
+        //~[edition2021]^ uninlined_format_args
     }
 
     #[allow(non_fmt_panics)]
@@ -28,5 +32,7 @@ fn main() {
     }
 
     assert!(var == 1, "p5 {var}");
+    //~[edition2021]^ uninlined_format_args
     debug_assert!(var == 1, "p6 {var}");
+    //~[edition2021]^ uninlined_format_args
 }
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.stderr b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.stderr
index 7638d3f8bbad..4db6e6a99312 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.stderr
+++ b/src/tools/clippy/tests/ui/uninlined_format_args_panic.edition2021.stderr
@@ -13,7 +13,7 @@ LL +     println!("val='{var}'");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:14:9
+  --> tests/ui/uninlined_format_args_panic.rs:15:9
    |
 LL |         panic!("p1 {}", var);
    |         ^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +         panic!("p1 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:17:9
+  --> tests/ui/uninlined_format_args_panic.rs:19:9
    |
 LL |         panic!("p2 {0}", var);
    |         ^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +         panic!("p2 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:20:9
+  --> tests/ui/uninlined_format_args_panic.rs:23:9
    |
 LL |         panic!("p3 {var}", var = var);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +         panic!("p3 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:30:5
+  --> tests/ui/uninlined_format_args_panic.rs:34:5
    |
 LL |     assert!(var == 1, "p5 {}", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     assert!(var == 1, "p5 {var}");
    |
 
 error: variables can be used directly in the `format!` string
-  --> tests/ui/uninlined_format_args_panic.rs:31:5
+  --> tests/ui/uninlined_format_args_panic.rs:36:5
    |
 LL |     debug_assert!(var == 1, "p6 {}", var);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/uninlined_format_args_panic.rs b/src/tools/clippy/tests/ui/uninlined_format_args_panic.rs
index 647c69bc5c41..94de4f057e99 100644
--- a/src/tools/clippy/tests/ui/uninlined_format_args_panic.rs
+++ b/src/tools/clippy/tests/ui/uninlined_format_args_panic.rs
@@ -9,15 +9,19 @@ fn main() {
     let var = 1;
 
     println!("val='{}'", var);
+    //~^ uninlined_format_args
 
     if var > 0 {
         panic!("p1 {}", var);
+        //~[edition2021]^ uninlined_format_args
     }
     if var > 0 {
         panic!("p2 {0}", var);
+        //~[edition2021]^ uninlined_format_args
     }
     if var > 0 {
         panic!("p3 {var}", var = var);
+        //~[edition2021]^ uninlined_format_args
     }
 
     #[allow(non_fmt_panics)]
@@ -28,5 +32,7 @@ fn main() {
     }
 
     assert!(var == 1, "p5 {}", var);
+    //~[edition2021]^ uninlined_format_args
     debug_assert!(var == 1, "p6 {}", var);
+    //~[edition2021]^ uninlined_format_args
 }
diff --git a/src/tools/clippy/tests/ui/unit_arg.rs b/src/tools/clippy/tests/ui/unit_arg.rs
index 2e1390621a6c..22a6a26dab62 100644
--- a/src/tools/clippy/tests/ui/unit_arg.rs
+++ b/src/tools/clippy/tests/ui/unit_arg.rs
@@ -61,23 +61,30 @@ impl Tr for B {
 
 fn bad() {
     foo({
+        //~^ unit_arg
         1;
     });
     foo(foo(1));
+    //~^ unit_arg
     foo({
+        //~^ unit_arg
         foo(1);
         foo(2);
     });
     let b = Bar;
     b.bar({
+        //~^ unit_arg
         1;
     });
     taking_multiple_units(foo(0), foo(1));
+    //~^ unit_arg
     taking_multiple_units(foo(0), {
+        //~^ unit_arg
         foo(1);
         foo(2);
     });
     taking_multiple_units(
+        //~^ unit_arg
         {
             foo(0);
             foo(1);
@@ -89,9 +96,11 @@ fn bad() {
     );
     // here Some(foo(2)) isn't the top level statement expression, wrap the suggestion in a block
     None.or(Some(foo(2)));
+    //~^ unit_arg
     // in this case, the suggestion can be inlined, no need for a surrounding block
     // foo(()); foo(()) instead of { foo(()); foo(()) }
     foo(foo(()));
+    //~^ unit_arg
 }
 
 fn ok() {
@@ -129,6 +138,7 @@ mod issue_2945 {
 #[allow(dead_code)]
 fn returning_expr() -> Option<()> {
     Some(foo(1))
+    //~^ unit_arg
 }
 
 fn taking_multiple_units(a: (), b: ()) {}
diff --git a/src/tools/clippy/tests/ui/unit_arg.stderr b/src/tools/clippy/tests/ui/unit_arg.stderr
index bf79e93e4440..6c333d9792d4 100644
--- a/src/tools/clippy/tests/ui/unit_arg.stderr
+++ b/src/tools/clippy/tests/ui/unit_arg.stderr
@@ -2,6 +2,7 @@ error: passing a unit value to a function
   --> tests/ui/unit_arg.rs:63:5
    |
 LL | /     foo({
+LL | |
 LL | |         1;
 LL | |     });
    | |______^
@@ -16,13 +17,14 @@ LL +         1
 help: or move the expression in front of the call and replace it with the unit literal `()`
    |
 LL ~     {
+LL +
 LL +         1;
 LL +     };
 LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> tests/ui/unit_arg.rs:66:5
+  --> tests/ui/unit_arg.rs:67:5
    |
 LL |     foo(foo(1));
    |     ^^^^^^^^^^^
@@ -34,9 +36,10 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> tests/ui/unit_arg.rs:67:5
+  --> tests/ui/unit_arg.rs:69:5
    |
 LL | /     foo({
+LL | |
 LL | |         foo(1);
 LL | |         foo(2);
 LL | |     });
@@ -50,6 +53,7 @@ LL +         foo(2)
 help: or move the expression in front of the call and replace it with the unit literal `()`
    |
 LL ~     {
+LL +
 LL +         foo(1);
 LL +         foo(2);
 LL +     };
@@ -57,9 +61,10 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> tests/ui/unit_arg.rs:72:5
+  --> tests/ui/unit_arg.rs:75:5
    |
 LL | /     b.bar({
+LL | |
 LL | |         1;
 LL | |     });
    | |______^
@@ -72,13 +77,14 @@ LL +         1
 help: or move the expression in front of the call and replace it with the unit literal `()`
    |
 LL ~     {
+LL +
 LL +         1;
 LL +     };
 LL ~     b.bar(());
    |
 
 error: passing unit values to a function
-  --> tests/ui/unit_arg.rs:75:5
+  --> tests/ui/unit_arg.rs:79:5
    |
 LL |     taking_multiple_units(foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -91,9 +97,10 @@ LL ~     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> tests/ui/unit_arg.rs:76:5
+  --> tests/ui/unit_arg.rs:81:5
    |
 LL | /     taking_multiple_units(foo(0), {
+LL | |
 LL | |         foo(1);
 LL | |         foo(2);
 LL | |     });
@@ -108,6 +115,7 @@ help: or move the expressions in front of the call and replace them with the uni
    |
 LL ~     foo(0);
 LL +     {
+LL +
 LL +         foo(1);
 LL +         foo(2);
 LL +     };
@@ -115,12 +123,12 @@ LL ~     taking_multiple_units((), ());
    |
 
 error: passing unit values to a function
-  --> tests/ui/unit_arg.rs:80:5
+  --> tests/ui/unit_arg.rs:86:5
    |
 LL | /     taking_multiple_units(
+LL | |
 LL | |         {
 LL | |             foo(0);
-LL | |             foo(1);
 ...  |
 LL | |         },
 LL | |     );
@@ -147,13 +155,14 @@ LL +         foo(2);
 LL +         foo(3);
 LL +     };
 LL +     taking_multiple_units(
+LL +
 LL +         (),
 LL +         (),
 LL ~     );
    |
 
 error: passing a unit value to a function
-  --> tests/ui/unit_arg.rs:91:13
+  --> tests/ui/unit_arg.rs:98:13
    |
 LL |     None.or(Some(foo(2)));
    |             ^^^^^^^^^^^^
@@ -167,7 +176,7 @@ LL ~     });
    |
 
 error: passing a unit value to a function
-  --> tests/ui/unit_arg.rs:94:5
+  --> tests/ui/unit_arg.rs:102:5
    |
 LL |     foo(foo(()));
    |     ^^^^^^^^^^^^
@@ -179,7 +188,7 @@ LL ~     foo(());
    |
 
 error: passing a unit value to a function
-  --> tests/ui/unit_arg.rs:131:5
+  --> tests/ui/unit_arg.rs:140:5
    |
 LL |     Some(foo(1))
    |     ^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unit_arg_empty_blocks.fixed b/src/tools/clippy/tests/ui/unit_arg_empty_blocks.fixed
index a947ded7b1e7..b045a33608d7 100644
--- a/src/tools/clippy/tests/ui/unit_arg_empty_blocks.fixed
+++ b/src/tools/clippy/tests/ui/unit_arg_empty_blocks.fixed
@@ -14,12 +14,16 @@ fn foo3<T1: Debug, T2: Debug, T3: Debug>(t1: T1, t2: T2, t3: T3) {
 
 fn bad() {
     foo(());
+    //~^ unit_arg
     foo3((), 2, 2);
+    //~^ unit_arg
     foo(0);
     taking_two_units((), ());
+    //~^ unit_arg
     foo(0);
     foo(1);
     taking_three_units((), (), ());
+    //~^ unit_arg
 }
 
 fn taking_two_units(a: (), b: ()) {}
diff --git a/src/tools/clippy/tests/ui/unit_arg_empty_blocks.rs b/src/tools/clippy/tests/ui/unit_arg_empty_blocks.rs
index 058c4f84a9e8..ab305913f3f6 100644
--- a/src/tools/clippy/tests/ui/unit_arg_empty_blocks.rs
+++ b/src/tools/clippy/tests/ui/unit_arg_empty_blocks.rs
@@ -14,9 +14,13 @@ fn foo3<T1: Debug, T2: Debug, T3: Debug>(t1: T1, t2: T2, t3: T3) {
 
 fn bad() {
     foo({});
+    //~^ unit_arg
     foo3({}, 2, 2);
+    //~^ unit_arg
     taking_two_units({}, foo(0));
+    //~^ unit_arg
     taking_three_units({}, foo(0), foo(1));
+    //~^ unit_arg
 }
 
 fn taking_two_units(a: (), b: ()) {}
diff --git a/src/tools/clippy/tests/ui/unit_arg_empty_blocks.stderr b/src/tools/clippy/tests/ui/unit_arg_empty_blocks.stderr
index d971195dda26..2c686d58ecc1 100644
--- a/src/tools/clippy/tests/ui/unit_arg_empty_blocks.stderr
+++ b/src/tools/clippy/tests/ui/unit_arg_empty_blocks.stderr
@@ -10,7 +10,7 @@ LL |     foo({});
    = help: to override `-D warnings` add `#[allow(clippy::unit_arg)]`
 
 error: passing a unit value to a function
-  --> tests/ui/unit_arg_empty_blocks.rs:17:5
+  --> tests/ui/unit_arg_empty_blocks.rs:18:5
    |
 LL |     foo3({}, 2, 2);
    |     ^^^^^--^^^^^^^
@@ -18,7 +18,7 @@ LL |     foo3({}, 2, 2);
    |          help: use a unit literal instead: `()`
 
 error: passing unit values to a function
-  --> tests/ui/unit_arg_empty_blocks.rs:18:5
+  --> tests/ui/unit_arg_empty_blocks.rs:20:5
    |
 LL |     taking_two_units({}, foo(0));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -30,7 +30,7 @@ LL ~     taking_two_units((), ());
    |
 
 error: passing unit values to a function
-  --> tests/ui/unit_arg_empty_blocks.rs:19:5
+  --> tests/ui/unit_arg_empty_blocks.rs:22:5
    |
 LL |     taking_three_units({}, foo(0), foo(1));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unit_cmp.rs b/src/tools/clippy/tests/ui/unit_cmp.rs
index cea89026da6f..93f5b87c3d2a 100644
--- a/src/tools/clippy/tests/ui/unit_cmp.rs
+++ b/src/tools/clippy/tests/ui/unit_cmp.rs
@@ -15,22 +15,23 @@ fn main() {
 
     // this warns
     if {
-        //~^ ERROR: ==-comparison of unit values detected. This will always be true
-        //~| NOTE: `-D clippy::unit-cmp` implied by `-D warnings`
+        //~^ unit_cmp
+
         true;
     } == {
         false;
     } {}
 
     if {
-        //~^ ERROR: >-comparison of unit values detected. This will always be false
+        //~^ unit_cmp
+
         true;
     } > {
         false;
     } {}
 
     assert_eq!(
-        //~^ ERROR: `assert_eq` of unit values detected. This will always succeed
+        //~^ unit_cmp
         {
             true;
         },
@@ -39,7 +40,7 @@ fn main() {
         }
     );
     debug_assert_eq!(
-        //~^ ERROR: `debug_assert_eq` of unit values detected. This will always succeed
+        //~^ unit_cmp
         {
             true;
         },
@@ -49,7 +50,7 @@ fn main() {
     );
 
     assert_ne!(
-        //~^ ERROR: `assert_ne` of unit values detected. This will always fail
+        //~^ unit_cmp
         {
             true;
         },
@@ -58,7 +59,7 @@ fn main() {
         }
     );
     debug_assert_ne!(
-        //~^ ERROR: `debug_assert_ne` of unit values detected. This will always fail
+        //~^ unit_cmp
         {
             true;
         },
diff --git a/src/tools/clippy/tests/ui/unit_cmp.stderr b/src/tools/clippy/tests/ui/unit_cmp.stderr
index 9e067edb8467..8f26749fd860 100644
--- a/src/tools/clippy/tests/ui/unit_cmp.stderr
+++ b/src/tools/clippy/tests/ui/unit_cmp.stderr
@@ -20,6 +20,7 @@ error: >-comparison of unit values detected. This will always be false
 LL |       if {
    |  ________^
 LL | |
+LL | |
 LL | |         true;
 LL | |     } > {
 LL | |         false;
@@ -27,7 +28,7 @@ LL | |     } {}
    | |_____^
 
 error: `assert_eq` of unit values detected. This will always succeed
-  --> tests/ui/unit_cmp.rs:32:5
+  --> tests/ui/unit_cmp.rs:33:5
    |
 LL | /     assert_eq!(
 LL | |
@@ -38,7 +39,7 @@ LL | |     );
    | |_____^
 
 error: `debug_assert_eq` of unit values detected. This will always succeed
-  --> tests/ui/unit_cmp.rs:41:5
+  --> tests/ui/unit_cmp.rs:42:5
    |
 LL | /     debug_assert_eq!(
 LL | |
@@ -49,7 +50,7 @@ LL | |     );
    | |_____^
 
 error: `assert_ne` of unit values detected. This will always fail
-  --> tests/ui/unit_cmp.rs:51:5
+  --> tests/ui/unit_cmp.rs:52:5
    |
 LL | /     assert_ne!(
 LL | |
@@ -60,7 +61,7 @@ LL | |     );
    | |_____^
 
 error: `debug_assert_ne` of unit values detected. This will always fail
-  --> tests/ui/unit_cmp.rs:60:5
+  --> tests/ui/unit_cmp.rs:61:5
    |
 LL | /     debug_assert_ne!(
 LL | |
diff --git a/src/tools/clippy/tests/ui/unit_hash.fixed b/src/tools/clippy/tests/ui/unit_hash.fixed
index ed0facf1b963..25c90e6ddc4c 100644
--- a/src/tools/clippy/tests/ui/unit_hash.fixed
+++ b/src/tools/clippy/tests/ui/unit_hash.fixed
@@ -17,18 +17,15 @@ fn main() {
 
     match my_enum {
         Foo::Empty => 0_u8.hash(&mut state),
-        //~^ ERROR: this call to `hash` on the unit type will do nothing
-        //~| NOTE: the implementation of `Hash` for `()` is a no-op
+        //~^ unit_hash
         Foo::WithValue(x) => x.hash(&mut state),
     }
 
     let res = ();
     0_u8.hash(&mut state);
-    //~^ ERROR: this call to `hash` on the unit type will do nothing
-    //~| NOTE: the implementation of `Hash` for `()` is a no-op
+    //~^ unit_hash
 
     #[allow(clippy::unit_arg)]
     0_u8.hash(&mut state);
-    //~^ ERROR: this call to `hash` on the unit type will do nothing
-    //~| NOTE: the implementation of `Hash` for `()` is a no-op
+    //~^ unit_hash
 }
diff --git a/src/tools/clippy/tests/ui/unit_hash.rs b/src/tools/clippy/tests/ui/unit_hash.rs
index f3636d1644da..b04cca6adf2a 100644
--- a/src/tools/clippy/tests/ui/unit_hash.rs
+++ b/src/tools/clippy/tests/ui/unit_hash.rs
@@ -17,18 +17,15 @@ fn main() {
 
     match my_enum {
         Foo::Empty => ().hash(&mut state),
-        //~^ ERROR: this call to `hash` on the unit type will do nothing
-        //~| NOTE: the implementation of `Hash` for `()` is a no-op
+        //~^ unit_hash
         Foo::WithValue(x) => x.hash(&mut state),
     }
 
     let res = ();
     res.hash(&mut state);
-    //~^ ERROR: this call to `hash` on the unit type will do nothing
-    //~| NOTE: the implementation of `Hash` for `()` is a no-op
+    //~^ unit_hash
 
     #[allow(clippy::unit_arg)]
     do_nothing().hash(&mut state);
-    //~^ ERROR: this call to `hash` on the unit type will do nothing
-    //~| NOTE: the implementation of `Hash` for `()` is a no-op
+    //~^ unit_hash
 }
diff --git a/src/tools/clippy/tests/ui/unit_hash.stderr b/src/tools/clippy/tests/ui/unit_hash.stderr
index b48f3a543b76..d1cabf89f8e7 100644
--- a/src/tools/clippy/tests/ui/unit_hash.stderr
+++ b/src/tools/clippy/tests/ui/unit_hash.stderr
@@ -9,7 +9,7 @@ LL |         Foo::Empty => ().hash(&mut state),
    = help: to override `-D warnings` add `#[allow(clippy::unit_hash)]`
 
 error: this call to `hash` on the unit type will do nothing
-  --> tests/ui/unit_hash.rs:26:5
+  --> tests/ui/unit_hash.rs:25:5
    |
 LL |     res.hash(&mut state);
    |     ^^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
@@ -17,7 +17,7 @@ LL |     res.hash(&mut state);
    = note: the implementation of `Hash` for `()` is a no-op
 
 error: this call to `hash` on the unit type will do nothing
-  --> tests/ui/unit_hash.rs:31:5
+  --> tests/ui/unit_hash.rs:29:5
    |
 LL |     do_nothing().hash(&mut state);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the call to `hash` or consider using: `0_u8.hash(&mut state)`
diff --git a/src/tools/clippy/tests/ui/unit_return_expecting_ord.rs b/src/tools/clippy/tests/ui/unit_return_expecting_ord.rs
index 5f62157dd6d5..74cd30472684 100644
--- a/src/tools/clippy/tests/ui/unit_return_expecting_ord.rs
+++ b/src/tools/clippy/tests/ui/unit_return_expecting_ord.rs
@@ -16,16 +16,19 @@ fn unit(_i: isize) {}
 fn main() {
     let mut structs = vec![Struct { field: 2 }, Struct { field: 1 }];
     structs.sort_by_key(|s| {
-        //~^ ERROR: this closure returns the unit type which also implements Ord
+        //~^ unit_return_expecting_ord
+
         double(s.field);
     });
     structs.sort_by_key(|s| double(s.field));
     structs.is_sorted_by_key(|s| {
-        //~^ ERROR: this closure returns the unit type which also implements PartialOrd
+        //~^ unit_return_expecting_ord
+
         double(s.field);
     });
     structs.is_sorted_by_key(|s| {
-        //~^ ERROR: this closure returns the unit type which also implements PartialOrd
+        //~^ unit_return_expecting_ord
+
         if s.field > 0 {
             ()
         } else {
@@ -36,5 +39,5 @@ fn main() {
         return double(s.field);
     });
     structs.sort_by_key(|s| unit(s.field));
-    //~^ ERROR: this closure returns the unit type which also implements Ord
+    //~^ unit_return_expecting_ord
 }
diff --git a/src/tools/clippy/tests/ui/unit_return_expecting_ord.stderr b/src/tools/clippy/tests/ui/unit_return_expecting_ord.stderr
index 329832048e88..d5ce2fb0b51d 100644
--- a/src/tools/clippy/tests/ui/unit_return_expecting_ord.stderr
+++ b/src/tools/clippy/tests/ui/unit_return_expecting_ord.stderr
@@ -5,7 +5,7 @@ LL |     structs.sort_by_key(|s| {
    |                         ^^^
    |
 help: probably caused by this trailing semicolon
-  --> tests/ui/unit_return_expecting_ord.rs:20:24
+  --> tests/ui/unit_return_expecting_ord.rs:21:24
    |
 LL |         double(s.field);
    |                        ^
@@ -13,25 +13,25 @@ LL |         double(s.field);
    = help: to override `-D warnings` add `#[allow(clippy::unit_return_expecting_ord)]`
 
 error: this closure returns the unit type which also implements PartialOrd
-  --> tests/ui/unit_return_expecting_ord.rs:23:30
+  --> tests/ui/unit_return_expecting_ord.rs:24:30
    |
 LL |     structs.is_sorted_by_key(|s| {
    |                              ^^^
    |
 help: probably caused by this trailing semicolon
-  --> tests/ui/unit_return_expecting_ord.rs:25:24
+  --> tests/ui/unit_return_expecting_ord.rs:27:24
    |
 LL |         double(s.field);
    |                        ^
 
 error: this closure returns the unit type which also implements PartialOrd
-  --> tests/ui/unit_return_expecting_ord.rs:27:30
+  --> tests/ui/unit_return_expecting_ord.rs:29:30
    |
 LL |     structs.is_sorted_by_key(|s| {
    |                              ^^^
 
 error: this closure returns the unit type which also implements Ord
-  --> tests/ui/unit_return_expecting_ord.rs:38:25
+  --> tests/ui/unit_return_expecting_ord.rs:41:25
    |
 LL |     structs.sort_by_key(|s| unit(s.field));
    |                         ^^^
diff --git a/src/tools/clippy/tests/ui/unknown_clippy_lints.fixed b/src/tools/clippy/tests/ui/unknown_clippy_lints.fixed
index c0ccd41c19ab..f97452c34eb5 100644
--- a/src/tools/clippy/tests/ui/unknown_clippy_lints.fixed
+++ b/src/tools/clippy/tests/ui/unknown_clippy_lints.fixed
@@ -1,18 +1,27 @@
 #![warn(clippy::pedantic)]
 // Should suggest lowercase
 #![allow(clippy::all)]
+//~^ ERROR: unknown lint
 #![warn(clippy::cmp_owned)]
+//~^ ERROR: unknown lint
 
 // Should suggest similar clippy lint name
 #[warn(clippy::if_not_else)]
+//~^ ERROR: unknown lint
 #[warn(clippy::unnecessary_cast)]
+//~^ ERROR: unknown lint
 #[warn(clippy::useless_transmute)]
+//~^ ERROR: unknown lint
 // Should suggest rustc lint name(`dead_code`)
 #[warn(dead_code)]
+//~^ ERROR: unknown lint
 // Shouldn't suggest removed/deprecated clippy lint name(`unused_collect`)
 #[warn(clippy::unused_self)]
+//~^ ERROR: unknown lint
 // Shouldn't suggest renamed clippy lint name(`const_static_lifetime`)
 #[warn(clippy::redundant_static_lifetimes)]
+//~^ ERROR: unknown lint
 // issue #118183, should report `missing_docs` from rustc lint
 #[warn(missing_docs)]
+//~^ ERROR: unknown lint
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/unknown_clippy_lints.rs b/src/tools/clippy/tests/ui/unknown_clippy_lints.rs
index 7a59ad364aa7..2ff4dd80bddc 100644
--- a/src/tools/clippy/tests/ui/unknown_clippy_lints.rs
+++ b/src/tools/clippy/tests/ui/unknown_clippy_lints.rs
@@ -1,18 +1,27 @@
 #![warn(clippy::pedantic)]
 // Should suggest lowercase
 #![allow(clippy::All)]
+//~^ ERROR: unknown lint
 #![warn(clippy::CMP_OWNED)]
+//~^ ERROR: unknown lint
 
 // Should suggest similar clippy lint name
 #[warn(clippy::if_not_els)]
+//~^ ERROR: unknown lint
 #[warn(clippy::UNNecsaRy_cAst)]
+//~^ ERROR: unknown lint
 #[warn(clippy::useles_transute)]
+//~^ ERROR: unknown lint
 // Should suggest rustc lint name(`dead_code`)
 #[warn(clippy::dead_cod)]
+//~^ ERROR: unknown lint
 // Shouldn't suggest removed/deprecated clippy lint name(`unused_collect`)
 #[warn(clippy::unused_colle)]
+//~^ ERROR: unknown lint
 // Shouldn't suggest renamed clippy lint name(`const_static_lifetime`)
 #[warn(clippy::const_static_lifetim)]
+//~^ ERROR: unknown lint
 // issue #118183, should report `missing_docs` from rustc lint
 #[warn(clippy::missing_docs)]
+//~^ ERROR: unknown lint
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/unknown_clippy_lints.stderr b/src/tools/clippy/tests/ui/unknown_clippy_lints.stderr
index ea925cd3a9fc..592fdfbebd43 100644
--- a/src/tools/clippy/tests/ui/unknown_clippy_lints.stderr
+++ b/src/tools/clippy/tests/ui/unknown_clippy_lints.stderr
@@ -8,31 +8,31 @@ LL | #![allow(clippy::All)]
    = help: to override `-D warnings` add `#[allow(unknown_lints)]`
 
 error: unknown lint: `clippy::CMP_OWNED`
-  --> tests/ui/unknown_clippy_lints.rs:4:9
+  --> tests/ui/unknown_clippy_lints.rs:5:9
    |
 LL | #![warn(clippy::CMP_OWNED)]
    |         ^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::cmp_owned`
 
 error: unknown lint: `clippy::if_not_els`
-  --> tests/ui/unknown_clippy_lints.rs:7:8
+  --> tests/ui/unknown_clippy_lints.rs:9:8
    |
 LL | #[warn(clippy::if_not_els)]
    |        ^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::if_not_else`
 
 error: unknown lint: `clippy::UNNecsaRy_cAst`
-  --> tests/ui/unknown_clippy_lints.rs:8:8
+  --> tests/ui/unknown_clippy_lints.rs:11:8
    |
 LL | #[warn(clippy::UNNecsaRy_cAst)]
    |        ^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::unnecessary_cast`
 
 error: unknown lint: `clippy::useles_transute`
-  --> tests/ui/unknown_clippy_lints.rs:9:8
+  --> tests/ui/unknown_clippy_lints.rs:13:8
    |
 LL | #[warn(clippy::useles_transute)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::useless_transmute`
 
 error: unknown lint: `clippy::dead_cod`
-  --> tests/ui/unknown_clippy_lints.rs:11:8
+  --> tests/ui/unknown_clippy_lints.rs:16:8
    |
 LL | #[warn(clippy::dead_cod)]
    |        ^^^^^^^^^^^^^^^^
@@ -44,19 +44,19 @@ LL + #[warn(dead_code)]
    |
 
 error: unknown lint: `clippy::unused_colle`
-  --> tests/ui/unknown_clippy_lints.rs:13:8
+  --> tests/ui/unknown_clippy_lints.rs:19:8
    |
 LL | #[warn(clippy::unused_colle)]
    |        ^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::unused_self`
 
 error: unknown lint: `clippy::const_static_lifetim`
-  --> tests/ui/unknown_clippy_lints.rs:15:8
+  --> tests/ui/unknown_clippy_lints.rs:22:8
    |
 LL | #[warn(clippy::const_static_lifetim)]
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: did you mean: `clippy::redundant_static_lifetimes`
 
 error: unknown lint: `clippy::missing_docs`
-  --> tests/ui/unknown_clippy_lints.rs:17:8
+  --> tests/ui/unknown_clippy_lints.rs:25:8
    |
 LL | #[warn(clippy::missing_docs)]
    |        ^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_box_returns.rs b/src/tools/clippy/tests/ui/unnecessary_box_returns.rs
index bcdaca33b644..a7ab7e90be06 100644
--- a/src/tools/clippy/tests/ui/unnecessary_box_returns.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_box_returns.rs
@@ -3,7 +3,7 @@
 trait Bar {
     // lint
     fn baz(&self) -> Box<usize>;
-    //~^ ERROR: boxed return of the sized type `usize`
+    //~^ unnecessary_box_returns
 }
 
 pub struct Foo {}
@@ -17,7 +17,8 @@ impl Bar for Foo {
 
 impl Foo {
     fn baz(&self) -> Box<usize> {
-        //~^ ERROR: boxed return of the sized type `usize`
+        //~^ unnecessary_box_returns
+
         // lint
         Box::new(13)
     }
@@ -25,13 +26,15 @@ impl Foo {
 
 // lint
 fn bxed_usize() -> Box<usize> {
-    //~^ ERROR: boxed return of the sized type `usize`
+    //~^ unnecessary_box_returns
+
     Box::new(5)
 }
 
 // lint
 fn _bxed_foo() -> Box<Foo> {
-    //~^ ERROR: boxed return of the sized type `Foo`
+    //~^ unnecessary_box_returns
+
     Box::new(Foo {})
 }
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_box_returns.stderr b/src/tools/clippy/tests/ui/unnecessary_box_returns.stderr
index cb88ba1b0016..ab1d90f13b92 100644
--- a/src/tools/clippy/tests/ui/unnecessary_box_returns.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_box_returns.stderr
@@ -17,7 +17,7 @@ LL |     fn baz(&self) -> Box<usize> {
    = help: changing this also requires a change to the return expressions in this function
 
 error: boxed return of the sized type `usize`
-  --> tests/ui/unnecessary_box_returns.rs:27:20
+  --> tests/ui/unnecessary_box_returns.rs:28:20
    |
 LL | fn bxed_usize() -> Box<usize> {
    |                    ^^^^^^^^^^ help: try: `usize`
@@ -25,7 +25,7 @@ LL | fn bxed_usize() -> Box<usize> {
    = help: changing this also requires a change to the return expressions in this function
 
 error: boxed return of the sized type `Foo`
-  --> tests/ui/unnecessary_box_returns.rs:33:19
+  --> tests/ui/unnecessary_box_returns.rs:35:19
    |
 LL | fn _bxed_foo() -> Box<Foo> {
    |                   ^^^^^^^^ help: try: `Foo`
diff --git a/src/tools/clippy/tests/ui/unnecessary_cast.fixed b/src/tools/clippy/tests/ui/unnecessary_cast.fixed
index c43e50761bd5..ba167e79a308 100644
--- a/src/tools/clippy/tests/ui/unnecessary_cast.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_cast.fixed
@@ -17,6 +17,7 @@ type PtrMutU8 = *mut u8;
 
 fn owo<T>(ptr: *const T) -> *const T {
     ptr
+    //~^ unnecessary_cast
 }
 
 fn uwu<T, U>(ptr: *const T) -> *const U {
@@ -52,21 +53,32 @@ fn bbb() -> UnsignedThirtyTwoBitInteger {
 fn main() {
     // Test cast_unnecessary
     1_i32;
+    //~^ unnecessary_cast
     1_f32;
+    //~^ unnecessary_cast
     false;
+    //~^ unnecessary_cast
     &1i32 as &i32;
 
     -1_i32;
+    //~^ unnecessary_cast
     - 1_i32;
+    //~^ unnecessary_cast
     -1_f32;
+    //~^ unnecessary_cast
     1_i32;
+    //~^ unnecessary_cast
     1_f32;
+    //~^ unnecessary_cast
 
     let _: *mut u8 = [1u8, 2].as_ptr() as *mut u8;
+    //~^ unnecessary_cast
 
     [1u8, 2].as_ptr();
+    //~^ unnecessary_cast
     [1u8, 2].as_ptr() as *mut u8;
     [1u8, 2].as_mut_ptr();
+    //~^ unnecessary_cast
     [1u8, 2].as_mut_ptr() as *const u8;
     [1u8, 2].as_ptr() as PtrConstU8;
     [1u8, 2].as_ptr() as PtrMutU8;
@@ -78,9 +90,12 @@ fn main() {
     let _: *mut u8 = [1u8, 2].as_mut_ptr() as *mut _;
 
     owo::<u32>([1u32].as_ptr());
+    //~^ unnecessary_cast
     uwu::<u32, u8>([1u32].as_ptr());
+    //~^ unnecessary_cast
     // this will not lint in the function body even though they have the same type, instead here
     uwu::<u32, u32>([1u32].as_ptr());
+    //~^ unnecessary_cast
 
     // macro version
     macro_rules! foo {
@@ -116,8 +131,10 @@ fn main() {
     let pid = unsafe { fake_libc::getpid() };
     pid as i32;
     aaa();
+    //~^ unnecessary_cast
     let x = aaa();
     aaa();
+    //~^ unnecessary_cast
     // Will not lint currently.
     bbb() as u32;
     let x = bbb();
@@ -154,13 +171,21 @@ mod fixable {
     fn main() {
         // casting integer literal to float is unnecessary
         100_f32;
+        //~^ unnecessary_cast
         100_f64;
+        //~^ unnecessary_cast
         100_f64;
+        //~^ unnecessary_cast
         let _ = -100_f32;
+        //~^ unnecessary_cast
         let _ = -100_f64;
+        //~^ unnecessary_cast
         let _ = -100_f64;
+        //~^ unnecessary_cast
         100_f32;
+        //~^ unnecessary_cast
         100_f64;
+        //~^ unnecessary_cast
         // Should not trigger
         #[rustfmt::skip]
         let v = vec!(1);
@@ -173,32 +198,44 @@ mod fixable {
         0b11 as f64;
 
         1_u32;
+        //~^ unnecessary_cast
         0x10_i32;
+        //~^ unnecessary_cast
         0b10_usize;
+        //~^ unnecessary_cast
         0o73_u16;
+        //~^ unnecessary_cast
         1_000_000_000_u32;
+        //~^ unnecessary_cast
 
         1.0_f64;
+        //~^ unnecessary_cast
         0.5_f32;
+        //~^ unnecessary_cast
 
         1.0 as u16;
 
         let _ = -1_i32;
+        //~^ unnecessary_cast
         let _ = -1.0_f32;
+        //~^ unnecessary_cast
 
         let _ = 1 as I32Alias;
         let _ = &1 as &I32Alias;
 
         let x = 1i32;
         let _ = &{ x };
+        //~^ unnecessary_cast
     }
 
     type I32Alias = i32;
 
     fn issue_9380() {
         let _: i32 = -1_i32;
+        //~^ unnecessary_cast
         let _: f32 = -(1) as f32;
         let _: i64 = -1_i64;
+        //~^ unnecessary_cast
         let _: i64 = -(1.0) as i64;
 
         let _ = -(1 + 1) as i64;
@@ -206,8 +243,11 @@ mod fixable {
 
     fn issue_9563() {
         let _: f64 = (-8.0_f64).exp();
+        //~^ unnecessary_cast
         #[allow(ambiguous_negative_literals)]
         let _: f64 = -8.0_f64.exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
+        //
+        //~^^ unnecessary_cast
     }
 
     fn issue_9562_non_literal() {
@@ -216,6 +256,7 @@ mod fixable {
         }
 
         let _num = foo();
+        //~^ unnecessary_cast
     }
 
     fn issue_9603() {
@@ -226,5 +267,6 @@ mod fixable {
     // `*x.pow(2)` which tries to dereference the return value rather than `x`.
     fn issue_11968(x: &usize) -> usize {
         { *x }.pow(2)
+        //~^ unnecessary_cast
     }
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_cast.rs b/src/tools/clippy/tests/ui/unnecessary_cast.rs
index 4a5ca231315e..0f90a8b05965 100644
--- a/src/tools/clippy/tests/ui/unnecessary_cast.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_cast.rs
@@ -17,6 +17,7 @@ type PtrMutU8 = *mut u8;
 
 fn owo<T>(ptr: *const T) -> *const T {
     ptr as *const T
+    //~^ unnecessary_cast
 }
 
 fn uwu<T, U>(ptr: *const T) -> *const U {
@@ -52,21 +53,32 @@ fn bbb() -> UnsignedThirtyTwoBitInteger {
 fn main() {
     // Test cast_unnecessary
     1i32 as i32;
+    //~^ unnecessary_cast
     1f32 as f32;
+    //~^ unnecessary_cast
     false as bool;
+    //~^ unnecessary_cast
     &1i32 as &i32;
 
     -1_i32 as i32;
+    //~^ unnecessary_cast
     - 1_i32 as i32;
+    //~^ unnecessary_cast
     -1f32 as f32;
+    //~^ unnecessary_cast
     1_i32 as i32;
+    //~^ unnecessary_cast
     1_f32 as f32;
+    //~^ unnecessary_cast
 
     let _: *mut u8 = [1u8, 2].as_ptr() as *const u8 as *mut u8;
+    //~^ unnecessary_cast
 
     [1u8, 2].as_ptr() as *const u8;
+    //~^ unnecessary_cast
     [1u8, 2].as_ptr() as *mut u8;
     [1u8, 2].as_mut_ptr() as *mut u8;
+    //~^ unnecessary_cast
     [1u8, 2].as_mut_ptr() as *const u8;
     [1u8, 2].as_ptr() as PtrConstU8;
     [1u8, 2].as_ptr() as PtrMutU8;
@@ -78,9 +90,12 @@ fn main() {
     let _: *mut u8 = [1u8, 2].as_mut_ptr() as *mut _;
 
     owo::<u32>([1u32].as_ptr()) as *const u32;
+    //~^ unnecessary_cast
     uwu::<u32, u8>([1u32].as_ptr()) as *const u8;
+    //~^ unnecessary_cast
     // this will not lint in the function body even though they have the same type, instead here
     uwu::<u32, u32>([1u32].as_ptr()) as *const u32;
+    //~^ unnecessary_cast
 
     // macro version
     macro_rules! foo {
@@ -116,8 +131,10 @@ fn main() {
     let pid = unsafe { fake_libc::getpid() };
     pid as i32;
     aaa() as u32;
+    //~^ unnecessary_cast
     let x = aaa();
     aaa() as u32;
+    //~^ unnecessary_cast
     // Will not lint currently.
     bbb() as u32;
     let x = bbb();
@@ -154,13 +171,21 @@ mod fixable {
     fn main() {
         // casting integer literal to float is unnecessary
         100 as f32;
+        //~^ unnecessary_cast
         100 as f64;
+        //~^ unnecessary_cast
         100_i32 as f64;
+        //~^ unnecessary_cast
         let _ = -100 as f32;
+        //~^ unnecessary_cast
         let _ = -100 as f64;
+        //~^ unnecessary_cast
         let _ = -100_i32 as f64;
+        //~^ unnecessary_cast
         100. as f32;
+        //~^ unnecessary_cast
         100. as f64;
+        //~^ unnecessary_cast
         // Should not trigger
         #[rustfmt::skip]
         let v = vec!(1);
@@ -173,32 +198,44 @@ mod fixable {
         0b11 as f64;
 
         1 as u32;
+        //~^ unnecessary_cast
         0x10 as i32;
+        //~^ unnecessary_cast
         0b10 as usize;
+        //~^ unnecessary_cast
         0o73 as u16;
+        //~^ unnecessary_cast
         1_000_000_000 as u32;
+        //~^ unnecessary_cast
 
         1.0 as f64;
+        //~^ unnecessary_cast
         0.5 as f32;
+        //~^ unnecessary_cast
 
         1.0 as u16;
 
         let _ = -1 as i32;
+        //~^ unnecessary_cast
         let _ = -1.0 as f32;
+        //~^ unnecessary_cast
 
         let _ = 1 as I32Alias;
         let _ = &1 as &I32Alias;
 
         let x = 1i32;
         let _ = &(x as i32);
+        //~^ unnecessary_cast
     }
 
     type I32Alias = i32;
 
     fn issue_9380() {
         let _: i32 = -(1) as i32;
+        //~^ unnecessary_cast
         let _: f32 = -(1) as f32;
         let _: i64 = -(1) as i64;
+        //~^ unnecessary_cast
         let _: i64 = -(1.0) as i64;
 
         let _ = -(1 + 1) as i64;
@@ -206,8 +243,11 @@ mod fixable {
 
     fn issue_9563() {
         let _: f64 = (-8.0 as f64).exp();
+        //~^ unnecessary_cast
         #[allow(ambiguous_negative_literals)]
         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
+        //
+        //~^^ unnecessary_cast
     }
 
     fn issue_9562_non_literal() {
@@ -216,6 +256,7 @@ mod fixable {
         }
 
         let _num = foo() as f32;
+        //~^ unnecessary_cast
     }
 
     fn issue_9603() {
@@ -226,5 +267,6 @@ mod fixable {
     // `*x.pow(2)` which tries to dereference the return value rather than `x`.
     fn issue_11968(x: &usize) -> usize {
         (*x as usize).pow(2)
+        //~^ unnecessary_cast
     }
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_cast.stderr b/src/tools/clippy/tests/ui/unnecessary_cast.stderr
index 80fd5c13d818..c83770c1a299 100644
--- a/src/tools/clippy/tests/ui/unnecessary_cast.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_cast.stderr
@@ -8,241 +8,241 @@ LL |     ptr as *const T
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_cast)]`
 
 error: casting integer literal to `i32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:54:5
+  --> tests/ui/unnecessary_cast.rs:55:5
    |
 LL |     1i32 as i32;
    |     ^^^^^^^^^^^ help: try: `1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:55:5
+  --> tests/ui/unnecessary_cast.rs:57:5
    |
 LL |     1f32 as f32;
    |     ^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting to the same type is unnecessary (`bool` -> `bool`)
-  --> tests/ui/unnecessary_cast.rs:56:5
+  --> tests/ui/unnecessary_cast.rs:59:5
    |
 LL |     false as bool;
    |     ^^^^^^^^^^^^^ help: try: `false`
 
 error: casting integer literal to `i32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:59:5
+  --> tests/ui/unnecessary_cast.rs:63:5
    |
 LL |     -1_i32 as i32;
    |     ^^^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:60:5
+  --> tests/ui/unnecessary_cast.rs:65:5
    |
 LL |     - 1_i32 as i32;
    |     ^^^^^^^^^^^^^^ help: try: `- 1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:61:5
+  --> tests/ui/unnecessary_cast.rs:67:5
    |
 LL |     -1f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `-1_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:62:5
+  --> tests/ui/unnecessary_cast.rs:69:5
    |
 LL |     1_i32 as i32;
    |     ^^^^^^^^^^^^ help: try: `1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:63:5
+  --> tests/ui/unnecessary_cast.rs:71:5
    |
 LL |     1_f32 as f32;
    |     ^^^^^^^^^^^^ help: try: `1_f32`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> tests/ui/unnecessary_cast.rs:65:22
+  --> tests/ui/unnecessary_cast.rs:74:22
    |
 LL |     let _: *mut u8 = [1u8, 2].as_ptr() as *const u8 as *mut u8;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> tests/ui/unnecessary_cast.rs:67:5
+  --> tests/ui/unnecessary_cast.rs:77:5
    |
 LL |     [1u8, 2].as_ptr() as *const u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*mut u8` -> `*mut u8`)
-  --> tests/ui/unnecessary_cast.rs:69:5
+  --> tests/ui/unnecessary_cast.rs:80:5
    |
 LL |     [1u8, 2].as_mut_ptr() as *mut u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `[1u8, 2].as_mut_ptr()`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> tests/ui/unnecessary_cast.rs:80:5
+  --> tests/ui/unnecessary_cast.rs:92:5
    |
 LL |     owo::<u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `owo::<u32>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u8` -> `*const u8`)
-  --> tests/ui/unnecessary_cast.rs:81:5
+  --> tests/ui/unnecessary_cast.rs:94:5
    |
 LL |     uwu::<u32, u8>([1u32].as_ptr()) as *const u8;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u8>([1u32].as_ptr())`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*const u32` -> `*const u32`)
-  --> tests/ui/unnecessary_cast.rs:83:5
+  --> tests/ui/unnecessary_cast.rs:97:5
    |
 LL |     uwu::<u32, u32>([1u32].as_ptr()) as *const u32;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `uwu::<u32, u32>([1u32].as_ptr())`
 
 error: casting to the same type is unnecessary (`u32` -> `u32`)
-  --> tests/ui/unnecessary_cast.rs:118:5
+  --> tests/ui/unnecessary_cast.rs:133:5
    |
 LL |     aaa() as u32;
    |     ^^^^^^^^^^^^ help: try: `aaa()`
 
 error: casting to the same type is unnecessary (`u32` -> `u32`)
-  --> tests/ui/unnecessary_cast.rs:120:5
+  --> tests/ui/unnecessary_cast.rs:136:5
    |
 LL |     aaa() as u32;
    |     ^^^^^^^^^^^^ help: try: `aaa()`
 
 error: casting integer literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:156:9
+  --> tests/ui/unnecessary_cast.rs:173:9
    |
 LL |         100 as f32;
    |         ^^^^^^^^^^ help: try: `100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:157:9
+  --> tests/ui/unnecessary_cast.rs:175:9
    |
 LL |         100 as f64;
    |         ^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:158:9
+  --> tests/ui/unnecessary_cast.rs:177:9
    |
 LL |         100_i32 as f64;
    |         ^^^^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:159:17
+  --> tests/ui/unnecessary_cast.rs:179:17
    |
 LL |         let _ = -100 as f32;
    |                 ^^^^^^^^^^^ help: try: `-100_f32`
 
 error: casting integer literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:160:17
+  --> tests/ui/unnecessary_cast.rs:181:17
    |
 LL |         let _ = -100 as f64;
    |                 ^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting integer literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:161:17
+  --> tests/ui/unnecessary_cast.rs:183:17
    |
 LL |         let _ = -100_i32 as f64;
    |                 ^^^^^^^^^^^^^^^ help: try: `-100_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:162:9
+  --> tests/ui/unnecessary_cast.rs:185:9
    |
 LL |         100. as f32;
    |         ^^^^^^^^^^^ help: try: `100_f32`
 
 error: casting float literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:163:9
+  --> tests/ui/unnecessary_cast.rs:187:9
    |
 LL |         100. as f64;
    |         ^^^^^^^^^^^ help: try: `100_f64`
 
 error: casting integer literal to `u32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:175:9
+  --> tests/ui/unnecessary_cast.rs:200:9
    |
 LL |         1 as u32;
    |         ^^^^^^^^ help: try: `1_u32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:176:9
+  --> tests/ui/unnecessary_cast.rs:202:9
    |
 LL |         0x10 as i32;
    |         ^^^^^^^^^^^ help: try: `0x10_i32`
 
 error: casting integer literal to `usize` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:177:9
+  --> tests/ui/unnecessary_cast.rs:204:9
    |
 LL |         0b10 as usize;
    |         ^^^^^^^^^^^^^ help: try: `0b10_usize`
 
 error: casting integer literal to `u16` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:178:9
+  --> tests/ui/unnecessary_cast.rs:206:9
    |
 LL |         0o73 as u16;
    |         ^^^^^^^^^^^ help: try: `0o73_u16`
 
 error: casting integer literal to `u32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:179:9
+  --> tests/ui/unnecessary_cast.rs:208:9
    |
 LL |         1_000_000_000 as u32;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `1_000_000_000_u32`
 
 error: casting float literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:181:9
+  --> tests/ui/unnecessary_cast.rs:211:9
    |
 LL |         1.0 as f64;
    |         ^^^^^^^^^^ help: try: `1.0_f64`
 
 error: casting float literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:182:9
+  --> tests/ui/unnecessary_cast.rs:213:9
    |
 LL |         0.5 as f32;
    |         ^^^^^^^^^^ help: try: `0.5_f32`
 
 error: casting integer literal to `i32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:186:17
+  --> tests/ui/unnecessary_cast.rs:218:17
    |
 LL |         let _ = -1 as i32;
    |                 ^^^^^^^^^ help: try: `-1_i32`
 
 error: casting float literal to `f32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:187:17
+  --> tests/ui/unnecessary_cast.rs:220:17
    |
 LL |         let _ = -1.0 as f32;
    |                 ^^^^^^^^^^^ help: try: `-1.0_f32`
 
 error: casting to the same type is unnecessary (`i32` -> `i32`)
-  --> tests/ui/unnecessary_cast.rs:193:18
+  --> tests/ui/unnecessary_cast.rs:227:18
    |
 LL |         let _ = &(x as i32);
    |                  ^^^^^^^^^^ help: try: `{ x }`
 
 error: casting integer literal to `i32` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:199:22
+  --> tests/ui/unnecessary_cast.rs:234:22
    |
 LL |         let _: i32 = -(1) as i32;
    |                      ^^^^^^^^^^^ help: try: `-1_i32`
 
 error: casting integer literal to `i64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:201:22
+  --> tests/ui/unnecessary_cast.rs:237:22
    |
 LL |         let _: i64 = -(1) as i64;
    |                      ^^^^^^^^^^^ help: try: `-1_i64`
 
 error: casting float literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:208:22
+  --> tests/ui/unnecessary_cast.rs:245:22
    |
 LL |         let _: f64 = (-8.0 as f64).exp();
    |                      ^^^^^^^^^^^^^ help: try: `(-8.0_f64)`
 
 error: casting float literal to `f64` is unnecessary
-  --> tests/ui/unnecessary_cast.rs:210:23
+  --> tests/ui/unnecessary_cast.rs:248:23
    |
 LL |         let _: f64 = -(8.0 as f64).exp(); // should suggest `-8.0_f64.exp()` here not to change code behavior
    |                       ^^^^^^^^^^^^ help: try: `8.0_f64`
 
 error: casting to the same type is unnecessary (`f32` -> `f32`)
-  --> tests/ui/unnecessary_cast.rs:218:20
+  --> tests/ui/unnecessary_cast.rs:258:20
    |
 LL |         let _num = foo() as f32;
    |                    ^^^^^^^^^^^^ help: try: `foo()`
 
 error: casting to the same type is unnecessary (`usize` -> `usize`)
-  --> tests/ui/unnecessary_cast.rs:228:9
+  --> tests/ui/unnecessary_cast.rs:269:9
    |
 LL |         (*x as usize).pow(2)
    |         ^^^^^^^^^^^^^ help: try: `{ *x }`
diff --git a/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.rs b/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.rs
index 36adf19c91ca..2bb64c3e80e3 100644
--- a/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.rs
@@ -2,8 +2,7 @@
 //@no-rustfix
 fn main() {
     let _ = std::ptr::null() as *const u8;
-    //~^ ERROR: casting raw pointers to the same type and constness is unnecessary (`*cons
-    //~| NOTE: `-D clippy::unnecessary-cast` implied by `-D warnings`
+    //~^ unnecessary_cast
 }
 
 mod issue11113 {
@@ -19,7 +18,7 @@ mod issue11113 {
     impl TearOff {
         unsafe fn query(&self) {
             ((*(*(self.object as *mut *mut _) as *mut Vtbl)).query)()
-            //~^ ERROR: casting raw pointers to the same type and constness is unnecessary
+            //~^ unnecessary_cast
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.stderr b/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.stderr
index cafaffeae6c3..6ba1c7873066 100644
--- a/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_cast_unfixable.stderr
@@ -8,7 +8,7 @@ LL |     let _ = std::ptr::null() as *const u8;
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_cast)]`
 
 error: casting raw pointers to the same type and constness is unnecessary (`*mut issue11113::Vtbl` -> `*mut issue11113::Vtbl`)
-  --> tests/ui/unnecessary_cast_unfixable.rs:21:16
+  --> tests/ui/unnecessary_cast_unfixable.rs:20:16
    |
 LL |             ((*(*(self.object as *mut *mut _) as *mut Vtbl)).query)()
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `*(self.object as *mut *mut _)`
diff --git a/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.rs b/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.rs
index 9915f8b843ef..e7e01248dfbe 100644
--- a/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.rs
@@ -2,22 +2,25 @@
 
 #![warn(clippy::unnecessary_clippy_cfg)]
 #![cfg_attr(clippy, deny(clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
 #![cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
 #![cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
+//~| duplicated_attributes
 #![cfg_attr(clippy, deny(clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
 
 #[cfg_attr(clippy, deny(clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
 #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
 #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
+//~| duplicated_attributes
 #[cfg_attr(clippy, deny(clippy::non_minimal_cfg))]
-//~^ ERROR: no need to put clippy lints behind a `clippy` cfg
+//~^ unnecessary_clippy_cfg
+
 pub struct Bar;
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.stderr b/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.stderr
index 01f842a657de..f66c68949548 100644
--- a/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_clippy_cfg.stderr
@@ -24,19 +24,19 @@ LL | #![cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    = note: write instead: `#![deny(clippy::non_minimal_cfg)]`
 
 error: no need to put clippy lints behind a `clippy` cfg
-  --> tests/ui/unnecessary_clippy_cfg.rs:10:1
+  --> tests/ui/unnecessary_clippy_cfg.rs:11:1
    |
 LL | #![cfg_attr(clippy, deny(clippy::non_minimal_cfg))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `#![deny(clippy::non_minimal_cfg)]`
 
 error: no need to put clippy lints behind a `clippy` cfg
-  --> tests/ui/unnecessary_clippy_cfg.rs:13:1
+  --> tests/ui/unnecessary_clippy_cfg.rs:14:1
    |
 LL | #[cfg_attr(clippy, deny(clippy::non_minimal_cfg))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `#[deny(clippy::non_minimal_cfg)]`
 
 error: no need to put clippy lints behind a `clippy` cfg
-  --> tests/ui/unnecessary_clippy_cfg.rs:15:36
+  --> tests/ui/unnecessary_clippy_cfg.rs:16:36
    |
 LL | #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL | #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    = note: write instead: `#[deny(clippy::non_minimal_cfg)]`
 
 error: no need to put clippy lints behind a `clippy` cfg
-  --> tests/ui/unnecessary_clippy_cfg.rs:17:36
+  --> tests/ui/unnecessary_clippy_cfg.rs:18:36
    |
 LL | #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL | #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    = note: write instead: `#[deny(clippy::non_minimal_cfg)]`
 
 error: no need to put clippy lints behind a `clippy` cfg
-  --> tests/ui/unnecessary_clippy_cfg.rs:19:1
+  --> tests/ui/unnecessary_clippy_cfg.rs:21:1
    |
 LL | #[cfg_attr(clippy, deny(clippy::non_minimal_cfg))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `#[deny(clippy::non_minimal_cfg)]`
@@ -77,18 +77,18 @@ LL | #![cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    = help: to override `-D warnings` add `#[allow(clippy::duplicated_attributes)]`
 
 error: duplicated attribute
-  --> tests/ui/unnecessary_clippy_cfg.rs:17:25
+  --> tests/ui/unnecessary_clippy_cfg.rs:18:25
    |
 LL | #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    |                         ^^^^^^^^^
    |
 note: first defined here
-  --> tests/ui/unnecessary_clippy_cfg.rs:15:25
+  --> tests/ui/unnecessary_clippy_cfg.rs:16:25
    |
 LL | #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    |                         ^^^^^^^^^
 help: remove this attribute
-  --> tests/ui/unnecessary_clippy_cfg.rs:17:25
+  --> tests/ui/unnecessary_clippy_cfg.rs:18:25
    |
 LL | #[cfg_attr(clippy, deny(dead_code, clippy::non_minimal_cfg))]
    |                         ^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_clone.rs b/src/tools/clippy/tests/ui/unnecessary_clone.rs
index 12ac96aa64ca..7335b6f9f039 100644
--- a/src/tools/clippy/tests/ui/unnecessary_clone.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_clone.rs
@@ -21,34 +21,36 @@ fn clone_on_ref_ptr() {
     let arc_weak = Arc::downgrade(&arc);
 
     rc.clone();
-    //~^ ERROR: using `.clone()` on a ref-counted pointer
-    //~| NOTE: `-D clippy::clone-on-ref-ptr` implied by `-D warnings`
+    //~^ clone_on_ref_ptr
+
     Rc::clone(&rc);
 
     arc.clone();
-    //~^ ERROR: using `.clone()` on a ref-counted pointer
+    //~^ clone_on_ref_ptr
+
     Arc::clone(&arc);
 
     rcweak.clone();
-    //~^ ERROR: using `.clone()` on a ref-counted pointer
+    //~^ clone_on_ref_ptr
+
     rc::Weak::clone(&rcweak);
 
     arc_weak.clone();
-    //~^ ERROR: using `.clone()` on a ref-counted pointer
+    //~^ clone_on_ref_ptr
+
     sync::Weak::clone(&arc_weak);
 
     let x = Arc::new(SomeImpl);
     let _: Arc<dyn SomeTrait> = x.clone();
-    //~^ ERROR: using `.clone()` on a ref-counted pointer
+    //~^ clone_on_ref_ptr
 }
 
 fn clone_on_copy_generic<T: Copy>(t: T) {
     t.clone();
-    //~^ ERROR: using `clone` on type `T` which implements the `Copy` trait
-    //~| NOTE: `-D clippy::clone-on-copy` implied by `-D warnings`
+    //~^ clone_on_copy
 
     Some(t).clone();
-    //~^ ERROR: using `clone` on type `Option<T>` which implements the `Copy` trait
+    //~^ clone_on_copy
 }
 
 mod many_derefs {
@@ -83,7 +85,8 @@ mod many_derefs {
     fn go1() {
         let a = A;
         let _: E = a.clone();
-        //~^ ERROR: using `clone` on type `E` which implements the `Copy` trait
+        //~^ clone_on_copy
+
         let _: E = *****a;
     }
 }
@@ -103,6 +106,6 @@ mod issue2076 {
     fn func() -> Option<Rc<u8>> {
         let rc = Rc::new(42);
         Some(try_opt!(Some(rc)).clone())
-        //~^ ERROR: using `.clone()` on a ref-counted pointer
+        //~^ clone_on_ref_ptr
     }
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_clone.stderr b/src/tools/clippy/tests/ui/unnecessary_clone.stderr
index e34a387c77e2..a4fdf09cd5dc 100644
--- a/src/tools/clippy/tests/ui/unnecessary_clone.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_clone.stderr
@@ -14,25 +14,25 @@ LL |     arc.clone();
    |     ^^^^^^^^^^^ help: try: `Arc::<bool>::clone(&arc)`
 
 error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:32:5
+  --> tests/ui/unnecessary_clone.rs:33:5
    |
 LL |     rcweak.clone();
    |     ^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&rcweak)`
 
 error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:36:5
+  --> tests/ui/unnecessary_clone.rs:38:5
    |
 LL |     arc_weak.clone();
    |     ^^^^^^^^^^^^^^^^ help: try: `Weak::<bool>::clone(&arc_weak)`
 
 error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:41:33
+  --> tests/ui/unnecessary_clone.rs:44:33
    |
 LL |     let _: Arc<dyn SomeTrait> = x.clone();
    |                                 ^^^^^^^^^ help: try: `Arc::<SomeImpl>::clone(&x)`
 
 error: using `clone` on type `T` which implements the `Copy` trait
-  --> tests/ui/unnecessary_clone.rs:46:5
+  --> tests/ui/unnecessary_clone.rs:49:5
    |
 LL |     t.clone();
    |     ^^^^^^^^^ help: try removing the `clone` call: `t`
@@ -41,19 +41,19 @@ LL |     t.clone();
    = help: to override `-D warnings` add `#[allow(clippy::clone_on_copy)]`
 
 error: using `clone` on type `Option<T>` which implements the `Copy` trait
-  --> tests/ui/unnecessary_clone.rs:50:5
+  --> tests/ui/unnecessary_clone.rs:52:5
    |
 LL |     Some(t).clone();
    |     ^^^^^^^^^^^^^^^ help: try removing the `clone` call: `Some(t)`
 
 error: using `clone` on type `E` which implements the `Copy` trait
-  --> tests/ui/unnecessary_clone.rs:85:20
+  --> tests/ui/unnecessary_clone.rs:87:20
    |
 LL |         let _: E = a.clone();
    |                    ^^^^^^^^^ help: try dereferencing it: `*****a`
 
 error: using `.clone()` on a ref-counted pointer
-  --> tests/ui/unnecessary_clone.rs:105:14
+  --> tests/ui/unnecessary_clone.rs:108:14
    |
 LL |         Some(try_opt!(Some(rc)).clone())
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Rc::<u8>::clone(&try_opt!(Some(rc)))`
diff --git a/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.fixed b/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.fixed
index b6dd1f267743..bae8f066cf12 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.fixed
@@ -4,40 +4,40 @@ fn main() {
     // --- TryFromMethod `T::try_from(u)` ---
 
     let _: i64 = 0i32.into();
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _: i64 = 0i32.into();
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryFromFunction `T::try_from(U)` ---
 
     let _ = i64::from(0i32);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _ = i64::from(0i32);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryIntoFunction `U::try_into(t)` ---
 
     let _: i64 = i32::into(0);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _: i64 = i32::into(0i32);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryFromFunction `<T as TryFrom<U>>::try_from(U)` ---
 
     let _ = <i64 as From<i32>>::from(0);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _ = <i64 as From<i32>>::from(0);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryIntoFunction `<U as TryInto<_>>::try_into(U)` ---
 
     let _: i64 = <i32 as Into<_>>::into(0);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _: i64 = <i32 as Into<_>>::into(0);
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.rs b/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.rs
index 6f8df7365e89..04c9826f3765 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_fallible_conversions.rs
@@ -4,40 +4,40 @@ fn main() {
     // --- TryFromMethod `T::try_from(u)` ---
 
     let _: i64 = 0i32.try_into().unwrap();
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _: i64 = 0i32.try_into().expect("can't happen");
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryFromFunction `T::try_from(U)` ---
 
     let _ = i64::try_from(0i32).unwrap();
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _ = i64::try_from(0i32).expect("can't happen");
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryIntoFunction `U::try_into(t)` ---
 
     let _: i64 = i32::try_into(0).unwrap();
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _: i64 = i32::try_into(0i32).expect("can't happen");
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryFromFunction `<T as TryFrom<U>>::try_from(U)` ---
 
     let _ = <i64 as TryFrom<i32>>::try_from(0).unwrap();
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _ = <i64 as TryFrom<i32>>::try_from(0).expect("can't happen");
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     // --- TryIntoFunction `<U as TryInto<_>>::try_into(U)` ---
 
     let _: i64 = <i32 as TryInto<_>>::try_into(0).unwrap();
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 
     let _: i64 = <i32 as TryInto<_>>::try_into(0).expect("can't happen");
-    //~^ ERROR: use of a fallible conversion when an infallible one could be used
+    //~^ unnecessary_fallible_conversions
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_filter_map.rs b/src/tools/clippy/tests/ui/unnecessary_filter_map.rs
index 8cf102ab0a55..c4f1b6bc7e3d 100644
--- a/src/tools/clippy/tests/ui/unnecessary_filter_map.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_filter_map.rs
@@ -3,29 +3,33 @@
 
 fn main() {
     let _ = (0..4).filter_map(|x| if x > 1 { Some(x) } else { None });
-    //~^ ERROR: this `.filter_map` can be written more simply
-    //~| NOTE: `-D clippy::unnecessary-filter-map` implied by `-D warnings`
+    //~^ unnecessary_filter_map
+
     let _ = (0..4).filter_map(|x| {
-        //~^ ERROR: this `.filter_map` can be written more simply
+        //~^ unnecessary_filter_map
+
         if x > 1 {
             return Some(x);
         };
         None
     });
     let _ = (0..4).filter_map(|x| match x {
-        //~^ ERROR: this `.filter_map` can be written more simply
+        //~^ unnecessary_filter_map
         0 | 1 => None,
         _ => Some(x),
     });
 
     let _ = (0..4).filter_map(|x| Some(x + 1));
-    //~^ ERROR: this `.filter_map` can be written more simply
+    //~^ unnecessary_filter_map
 
     let _ = (0..4).filter_map(i32::checked_abs);
 
     let _ = (0..4).filter_map(Some);
 
     let _ = vec![Some(10), None].into_iter().filter_map(|x| Some(x));
+    //~^ redundant_closure
+    //~| unnecessary_filter_map
+    //~| unnecessary_filter_map
 }
 
 fn filter_map_none_changes_item_type() -> impl Iterator<Item = bool> {
@@ -163,4 +167,5 @@ fn issue11260() {
     // #11260 is about unnecessary_find_map, but the fix also kind of applies to
     // unnecessary_filter_map
     let _x = std::iter::once(1).filter_map(|n| (n > 1).then_some(n));
+    //~^ unnecessary_filter_map
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_filter_map.stderr b/src/tools/clippy/tests/ui/unnecessary_filter_map.stderr
index b21589c5f844..6683444b7273 100644
--- a/src/tools/clippy/tests/ui/unnecessary_filter_map.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_filter_map.stderr
@@ -13,15 +13,15 @@ error: this `.filter_map` can be written more simply
 LL |       let _ = (0..4).filter_map(|x| {
    |  _____________^
 LL | |
+LL | |
 LL | |         if x > 1 {
-LL | |             return Some(x);
-LL | |         };
+...  |
 LL | |         None
 LL | |     });
    | |______^ help: try instead: `filter`
 
 error: this `.filter_map` can be written more simply
-  --> tests/ui/unnecessary_filter_map.rs:15:13
+  --> tests/ui/unnecessary_filter_map.rs:16:13
    |
 LL |       let _ = (0..4).filter_map(|x| match x {
    |  _____________^
@@ -32,13 +32,13 @@ LL | |     });
    | |______^ help: try instead: `filter`
 
 error: this `.filter_map` can be written more simply
-  --> tests/ui/unnecessary_filter_map.rs:21:13
+  --> tests/ui/unnecessary_filter_map.rs:22:13
    |
 LL |     let _ = (0..4).filter_map(|x| Some(x + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try instead: `map`
 
 error: redundant closure
-  --> tests/ui/unnecessary_filter_map.rs:28:57
+  --> tests/ui/unnecessary_filter_map.rs:29:57
    |
 LL |     let _ = vec![Some(10), None].into_iter().filter_map(|x| Some(x));
    |                                                         ^^^^^^^^^^^ help: replace the closure with the function itself: `Some`
@@ -47,19 +47,19 @@ LL |     let _ = vec![Some(10), None].into_iter().filter_map(|x| Some(x));
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
 
 error: filter_map is unnecessary
-  --> tests/ui/unnecessary_filter_map.rs:28:61
+  --> tests/ui/unnecessary_filter_map.rs:29:61
    |
 LL |     let _ = vec![Some(10), None].into_iter().filter_map(|x| Some(x));
    |                                                             ^^^^ help: try removing the filter_map
 
 error: this `.filter_map` can be written more simply
-  --> tests/ui/unnecessary_filter_map.rs:28:13
+  --> tests/ui/unnecessary_filter_map.rs:29:13
    |
 LL |     let _ = vec![Some(10), None].into_iter().filter_map(|x| Some(x));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try instead: `map`
 
 error: this `.filter_map` can be written more simply
-  --> tests/ui/unnecessary_filter_map.rs:165:14
+  --> tests/ui/unnecessary_filter_map.rs:169:14
    |
 LL |     let _x = std::iter::once(1).filter_map(|n| (n > 1).then_some(n));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try instead: `filter`
diff --git a/src/tools/clippy/tests/ui/unnecessary_find_map.rs b/src/tools/clippy/tests/ui/unnecessary_find_map.rs
index c357d8532481..8c8a3799f021 100644
--- a/src/tools/clippy/tests/ui/unnecessary_find_map.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_find_map.rs
@@ -3,23 +3,24 @@
 
 fn main() {
     let _ = (0..4).find_map(|x| if x > 1 { Some(x) } else { None });
-    //~^ ERROR: this `.find_map` can be written more simply
-    //~| NOTE: `-D clippy::unnecessary-find-map` implied by `-D warnings`
+    //~^ unnecessary_find_map
+
     let _ = (0..4).find_map(|x| {
-        //~^ ERROR: this `.find_map` can be written more simply
+        //~^ unnecessary_find_map
+
         if x > 1 {
             return Some(x);
         };
         None
     });
     let _ = (0..4).find_map(|x| match x {
-        //~^ ERROR: this `.find_map` can be written more simply
+        //~^ unnecessary_find_map
         0 | 1 => None,
         _ => Some(x),
     });
 
     let _ = (0..4).find_map(|x| Some(x + 1));
-    //~^ ERROR: this `.find_map` can be written more simply
+    //~^ unnecessary_find_map
 
     let _ = (0..4).find_map(i32::checked_abs);
 }
@@ -31,5 +32,6 @@ fn find_map_none_changes_item_type() -> Option<bool> {
 fn issue11260() {
     let y = Some(1);
     let _x = std::iter::once(1).find_map(|n| (n > 1).then_some(n));
+    //~^ unnecessary_find_map
     let _x = std::iter::once(1).find_map(|n| (n > 1).then_some(y)); // different option, so can't be just `.find()`
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_find_map.stderr b/src/tools/clippy/tests/ui/unnecessary_find_map.stderr
index 98a6c3d164a6..94e320773a6f 100644
--- a/src/tools/clippy/tests/ui/unnecessary_find_map.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_find_map.stderr
@@ -13,15 +13,15 @@ error: this `.find_map` can be written more simply
 LL |       let _ = (0..4).find_map(|x| {
    |  _____________^
 LL | |
+LL | |
 LL | |         if x > 1 {
-LL | |             return Some(x);
-LL | |         };
+...  |
 LL | |         None
 LL | |     });
    | |______^ help: try instead: `find`
 
 error: this `.find_map` can be written more simply
-  --> tests/ui/unnecessary_find_map.rs:15:13
+  --> tests/ui/unnecessary_find_map.rs:16:13
    |
 LL |       let _ = (0..4).find_map(|x| match x {
    |  _____________^
@@ -32,13 +32,13 @@ LL | |     });
    | |______^ help: try instead: `find`
 
 error: this `.find_map` can be written more simply
-  --> tests/ui/unnecessary_find_map.rs:21:13
+  --> tests/ui/unnecessary_find_map.rs:22:13
    |
 LL |     let _ = (0..4).find_map(|x| Some(x + 1));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try instead: `map(..).next()`
 
 error: this `.find_map` can be written more simply
-  --> tests/ui/unnecessary_find_map.rs:33:14
+  --> tests/ui/unnecessary_find_map.rs:34:14
    |
 LL |     let _x = std::iter::once(1).find_map(|n| (n > 1).then_some(n));
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try instead: `find`
diff --git a/src/tools/clippy/tests/ui/unnecessary_first_then_check.fixed b/src/tools/clippy/tests/ui/unnecessary_first_then_check.fixed
index 7202e1bbd179..aa049eb33751 100644
--- a/src/tools/clippy/tests/ui/unnecessary_first_then_check.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_first_then_check.fixed
@@ -4,19 +4,26 @@
 fn main() {
     let s = [1, 2, 3];
     let _: bool = !s.is_empty();
+    //~^ unnecessary_first_then_check
     let _: bool = s.is_empty();
+    //~^ unnecessary_first_then_check
 
     let v = vec![1, 2, 3];
     let _: bool = !v.is_empty();
+    //~^ unnecessary_first_then_check
 
     let n = [[1, 2, 3], [4, 5, 6]];
     let _: bool = !n[0].is_empty();
+    //~^ unnecessary_first_then_check
     let _: bool = n[0].is_empty();
+    //~^ unnecessary_first_then_check
 
     struct Foo {
         bar: &'static [i32],
     }
     let f = [Foo { bar: &[] }];
     let _: bool = !f[0].bar.is_empty();
+    //~^ unnecessary_first_then_check
     let _: bool = f[0].bar.is_empty();
+    //~^ unnecessary_first_then_check
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_first_then_check.rs b/src/tools/clippy/tests/ui/unnecessary_first_then_check.rs
index 762b95999288..4c2ac3ba40a2 100644
--- a/src/tools/clippy/tests/ui/unnecessary_first_then_check.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_first_then_check.rs
@@ -4,19 +4,26 @@
 fn main() {
     let s = [1, 2, 3];
     let _: bool = s.first().is_some();
+    //~^ unnecessary_first_then_check
     let _: bool = s.first().is_none();
+    //~^ unnecessary_first_then_check
 
     let v = vec![1, 2, 3];
     let _: bool = v.first().is_some();
+    //~^ unnecessary_first_then_check
 
     let n = [[1, 2, 3], [4, 5, 6]];
     let _: bool = n[0].first().is_some();
+    //~^ unnecessary_first_then_check
     let _: bool = n[0].first().is_none();
+    //~^ unnecessary_first_then_check
 
     struct Foo {
         bar: &'static [i32],
     }
     let f = [Foo { bar: &[] }];
     let _: bool = f[0].bar.first().is_some();
+    //~^ unnecessary_first_then_check
     let _: bool = f[0].bar.first().is_none();
+    //~^ unnecessary_first_then_check
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_first_then_check.stderr b/src/tools/clippy/tests/ui/unnecessary_first_then_check.stderr
index bbaf7e68edab..408b388ecf71 100644
--- a/src/tools/clippy/tests/ui/unnecessary_first_then_check.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_first_then_check.stderr
@@ -8,37 +8,37 @@ LL |     let _: bool = s.first().is_some();
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_first_then_check)]`
 
 error: unnecessary use of `first().is_none()` to check if slice is empty
-  --> tests/ui/unnecessary_first_then_check.rs:7:21
+  --> tests/ui/unnecessary_first_then_check.rs:8:21
    |
 LL |     let _: bool = s.first().is_none();
    |                     ^^^^^^^^^^^^^^^^^ help: replace this with: `is_empty()`
 
 error: unnecessary use of `first().is_some()` to check if slice is not empty
-  --> tests/ui/unnecessary_first_then_check.rs:10:19
+  --> tests/ui/unnecessary_first_then_check.rs:12:19
    |
 LL |     let _: bool = v.first().is_some();
    |                   ^^^^^^^^^^^^^^^^^^^ help: replace this with: `!v.is_empty()`
 
 error: unnecessary use of `first().is_some()` to check if slice is not empty
-  --> tests/ui/unnecessary_first_then_check.rs:13:19
+  --> tests/ui/unnecessary_first_then_check.rs:16:19
    |
 LL |     let _: bool = n[0].first().is_some();
    |                   ^^^^^^^^^^^^^^^^^^^^^^ help: replace this with: `!n[0].is_empty()`
 
 error: unnecessary use of `first().is_none()` to check if slice is empty
-  --> tests/ui/unnecessary_first_then_check.rs:14:24
+  --> tests/ui/unnecessary_first_then_check.rs:18:24
    |
 LL |     let _: bool = n[0].first().is_none();
    |                        ^^^^^^^^^^^^^^^^^ help: replace this with: `is_empty()`
 
 error: unnecessary use of `first().is_some()` to check if slice is not empty
-  --> tests/ui/unnecessary_first_then_check.rs:20:19
+  --> tests/ui/unnecessary_first_then_check.rs:25:19
    |
 LL |     let _: bool = f[0].bar.first().is_some();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace this with: `!f[0].bar.is_empty()`
 
 error: unnecessary use of `first().is_none()` to check if slice is empty
-  --> tests/ui/unnecessary_first_then_check.rs:21:28
+  --> tests/ui/unnecessary_first_then_check.rs:27:28
    |
 LL |     let _: bool = f[0].bar.first().is_none();
    |                            ^^^^^^^^^^^^^^^^^ help: replace this with: `is_empty()`
diff --git a/src/tools/clippy/tests/ui/unnecessary_fold.fixed b/src/tools/clippy/tests/ui/unnecessary_fold.fixed
index c5bc11b55ab5..1c331be75094 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fold.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_fold.fixed
@@ -8,19 +8,25 @@ fn is_any(acc: bool, x: usize) -> bool {
 fn unnecessary_fold() {
     // Can be replaced by .any
     let _ = (0..3).any(|x| x > 2);
+    //~^ unnecessary_fold
     // Can be replaced by .any (checking suggestion)
     let _ = (0..3).fold(false, is_any);
+    //~^ redundant_closure
     // Can be replaced by .all
     let _ = (0..3).all(|x| x > 2);
+    //~^ unnecessary_fold
     // Can be replaced by .sum
     let _: i32 = (0..3).sum();
+    //~^ unnecessary_fold
     // Can be replaced by .product
     let _: i32 = (0..3).product();
+    //~^ unnecessary_fold
 }
 
 /// Should trigger the `UNNECESSARY_FOLD` lint, with an error span including exactly `.fold(...)`
 fn unnecessary_fold_span_for_multi_element_chain() {
     let _: bool = (0..3).map(|x| 2 * x).any(|x| x > 2);
+    //~^ unnecessary_fold
 }
 
 /// Calls which should not trigger the `UNNECESSARY_FOLD` lint
@@ -51,6 +57,7 @@ fn unnecessary_fold_over_multiple_lines() {
         .map(|x| x + 1)
         .filter(|x| x % 2 == 0)
         .any(|x| x > 2);
+    //~^ unnecessary_fold
 }
 
 fn issue10000() {
@@ -62,16 +69,25 @@ fn issue10000() {
     fn smoketest_map<S: BuildHasher>(mut map: HashMap<i32, i32, S>) {
         map.insert(0, 0);
         assert_eq!(map.values().sum::<i32>(), 0);
+        //~^ unnecessary_fold
 
         // more cases:
         let _ = map.values().sum::<i32>();
+        //~^ unnecessary_fold
         let _ = map.values().product::<i32>();
+        //~^ unnecessary_fold
         let _: i32 = map.values().sum();
+        //~^ unnecessary_fold
         let _: i32 = map.values().product();
+        //~^ unnecessary_fold
         anything(map.values().sum::<i32>());
+        //~^ unnecessary_fold
         anything(map.values().product::<i32>());
+        //~^ unnecessary_fold
         num(map.values().sum());
+        //~^ unnecessary_fold
         num(map.values().product());
+        //~^ unnecessary_fold
     }
 
     smoketest_map(HashMap::new());
diff --git a/src/tools/clippy/tests/ui/unnecessary_fold.rs b/src/tools/clippy/tests/ui/unnecessary_fold.rs
index 3a5136eeeaeb..e2050e37e3b1 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fold.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_fold.rs
@@ -8,19 +8,25 @@ fn is_any(acc: bool, x: usize) -> bool {
 fn unnecessary_fold() {
     // Can be replaced by .any
     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
+    //~^ unnecessary_fold
     // Can be replaced by .any (checking suggestion)
     let _ = (0..3).fold(false, |acc, x| is_any(acc, x));
+    //~^ redundant_closure
     // Can be replaced by .all
     let _ = (0..3).fold(true, |acc, x| acc && x > 2);
+    //~^ unnecessary_fold
     // Can be replaced by .sum
     let _: i32 = (0..3).fold(0, |acc, x| acc + x);
+    //~^ unnecessary_fold
     // Can be replaced by .product
     let _: i32 = (0..3).fold(1, |acc, x| acc * x);
+    //~^ unnecessary_fold
 }
 
 /// Should trigger the `UNNECESSARY_FOLD` lint, with an error span including exactly `.fold(...)`
 fn unnecessary_fold_span_for_multi_element_chain() {
     let _: bool = (0..3).map(|x| 2 * x).fold(false, |acc, x| acc || x > 2);
+    //~^ unnecessary_fold
 }
 
 /// Calls which should not trigger the `UNNECESSARY_FOLD` lint
@@ -51,6 +57,7 @@ fn unnecessary_fold_over_multiple_lines() {
         .map(|x| x + 1)
         .filter(|x| x % 2 == 0)
         .fold(false, |acc, x| acc || x > 2);
+    //~^ unnecessary_fold
 }
 
 fn issue10000() {
@@ -62,16 +69,25 @@ fn issue10000() {
     fn smoketest_map<S: BuildHasher>(mut map: HashMap<i32, i32, S>) {
         map.insert(0, 0);
         assert_eq!(map.values().fold(0, |x, y| x + y), 0);
+        //~^ unnecessary_fold
 
         // more cases:
         let _ = map.values().fold(0, |x, y| x + y);
+        //~^ unnecessary_fold
         let _ = map.values().fold(1, |x, y| x * y);
+        //~^ unnecessary_fold
         let _: i32 = map.values().fold(0, |x, y| x + y);
+        //~^ unnecessary_fold
         let _: i32 = map.values().fold(1, |x, y| x * y);
+        //~^ unnecessary_fold
         anything(map.values().fold(0, |x, y| x + y));
+        //~^ unnecessary_fold
         anything(map.values().fold(1, |x, y| x * y));
+        //~^ unnecessary_fold
         num(map.values().fold(0, |x, y| x + y));
+        //~^ unnecessary_fold
         num(map.values().fold(1, |x, y| x * y));
+        //~^ unnecessary_fold
     }
 
     smoketest_map(HashMap::new());
diff --git a/src/tools/clippy/tests/ui/unnecessary_fold.stderr b/src/tools/clippy/tests/ui/unnecessary_fold.stderr
index 31abab62f4c6..d82b1f39b48b 100644
--- a/src/tools/clippy/tests/ui/unnecessary_fold.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_fold.stderr
@@ -8,7 +8,7 @@ LL |     let _ = (0..3).fold(false, |acc, x| acc || x > 2);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_fold)]`
 
 error: redundant closure
-  --> tests/ui/unnecessary_fold.rs:12:32
+  --> tests/ui/unnecessary_fold.rs:13:32
    |
 LL |     let _ = (0..3).fold(false, |acc, x| is_any(acc, x));
    |                                ^^^^^^^^^^^^^^^^^^^^^^^ help: replace the closure with the function itself: `is_any`
@@ -17,85 +17,85 @@ LL |     let _ = (0..3).fold(false, |acc, x| is_any(acc, x));
    = help: to override `-D warnings` add `#[allow(clippy::redundant_closure)]`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:14:20
+  --> tests/ui/unnecessary_fold.rs:16:20
    |
 LL |     let _ = (0..3).fold(true, |acc, x| acc && x > 2);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `all(|x| x > 2)`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:16:25
+  --> tests/ui/unnecessary_fold.rs:19:25
    |
 LL |     let _: i32 = (0..3).fold(0, |acc, x| acc + x);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:18:25
+  --> tests/ui/unnecessary_fold.rs:22:25
    |
 LL |     let _: i32 = (0..3).fold(1, |acc, x| acc * x);
    |                         ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:23:41
+  --> tests/ui/unnecessary_fold.rs:28:41
    |
 LL |     let _: bool = (0..3).map(|x| 2 * x).fold(false, |acc, x| acc || x > 2);
    |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:53:10
+  --> tests/ui/unnecessary_fold.rs:59:10
    |
 LL |         .fold(false, |acc, x| acc || x > 2);
    |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `any(|x| x > 2)`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:64:33
+  --> tests/ui/unnecessary_fold.rs:71:33
    |
 LL |         assert_eq!(map.values().fold(0, |x, y| x + y), 0);
    |                                 ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:67:30
+  --> tests/ui/unnecessary_fold.rs:75:30
    |
 LL |         let _ = map.values().fold(0, |x, y| x + y);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:68:30
+  --> tests/ui/unnecessary_fold.rs:77:30
    |
 LL |         let _ = map.values().fold(1, |x, y| x * y);
    |                              ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:69:35
+  --> tests/ui/unnecessary_fold.rs:79:35
    |
 LL |         let _: i32 = map.values().fold(0, |x, y| x + y);
    |                                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:70:35
+  --> tests/ui/unnecessary_fold.rs:81:35
    |
 LL |         let _: i32 = map.values().fold(1, |x, y| x * y);
    |                                   ^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:71:31
+  --> tests/ui/unnecessary_fold.rs:83:31
    |
 LL |         anything(map.values().fold(0, |x, y| x + y));
    |                               ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:72:31
+  --> tests/ui/unnecessary_fold.rs:85:31
    |
 LL |         anything(map.values().fold(1, |x, y| x * y));
    |                               ^^^^^^^^^^^^^^^^^^^^^ help: try: `product::<i32>()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:73:26
+  --> tests/ui/unnecessary_fold.rs:87:26
    |
 LL |         num(map.values().fold(0, |x, y| x + y));
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `sum()`
 
 error: this `.fold` can be written more succinctly using another method
-  --> tests/ui/unnecessary_fold.rs:74:26
+  --> tests/ui/unnecessary_fold.rs:89:26
    |
 LL |         num(map.values().fold(1, |x, y| x * y));
    |                          ^^^^^^^^^^^^^^^^^^^^^ help: try: `product()`
diff --git a/src/tools/clippy/tests/ui/unnecessary_get_then_check.fixed b/src/tools/clippy/tests/ui/unnecessary_get_then_check.fixed
index 178a3300c346..c6da769544e0 100644
--- a/src/tools/clippy/tests/ui/unnecessary_get_then_check.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_get_then_check.fixed
@@ -4,23 +4,33 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
 fn main() {
     let s: HashSet<String> = HashSet::new();
-    let _ = s.contains("a"); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = !s.contains("a"); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.contains("a");
+    //~^ unnecessary_get_then_check
+    let _ = !s.contains("a");
+    //~^ unnecessary_get_then_check
 
     let s: HashMap<String, ()> = HashMap::new();
-    let _ = s.contains_key("a"); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = !s.contains_key("a"); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.contains_key("a");
+    //~^ unnecessary_get_then_check
+    let _ = !s.contains_key("a");
+    //~^ unnecessary_get_then_check
 
     let s: BTreeSet<String> = BTreeSet::new();
-    let _ = s.contains("a"); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = !s.contains("a"); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.contains("a");
+    //~^ unnecessary_get_then_check
+    let _ = !s.contains("a");
+    //~^ unnecessary_get_then_check
 
     let s: BTreeMap<String, ()> = BTreeMap::new();
-    let _ = s.contains_key("a"); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = !s.contains_key("a"); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.contains_key("a");
+    //~^ unnecessary_get_then_check
+    let _ = !s.contains_key("a");
+    //~^ unnecessary_get_then_check
 
     // Import to check that the generic annotations are kept!
     let s: HashSet<String> = HashSet::new();
-    let _ = s.contains::<str>("a"); //~ ERROR: unnecessary use of `get::<str>("a").is_some()`
-    let _ = !s.contains::<str>("a"); //~ ERROR: unnecessary use of `get::<str>("a").is_none()`
+    let _ = s.contains::<str>("a");
+    //~^ unnecessary_get_then_check
+    let _ = !s.contains::<str>("a");
+    //~^ unnecessary_get_then_check
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_get_then_check.rs b/src/tools/clippy/tests/ui/unnecessary_get_then_check.rs
index c197bdef47ea..323ccc2136ce 100644
--- a/src/tools/clippy/tests/ui/unnecessary_get_then_check.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_get_then_check.rs
@@ -4,23 +4,33 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 
 fn main() {
     let s: HashSet<String> = HashSet::new();
-    let _ = s.get("a").is_some(); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = s.get("a").is_none(); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.get("a").is_some();
+    //~^ unnecessary_get_then_check
+    let _ = s.get("a").is_none();
+    //~^ unnecessary_get_then_check
 
     let s: HashMap<String, ()> = HashMap::new();
-    let _ = s.get("a").is_some(); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = s.get("a").is_none(); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.get("a").is_some();
+    //~^ unnecessary_get_then_check
+    let _ = s.get("a").is_none();
+    //~^ unnecessary_get_then_check
 
     let s: BTreeSet<String> = BTreeSet::new();
-    let _ = s.get("a").is_some(); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = s.get("a").is_none(); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.get("a").is_some();
+    //~^ unnecessary_get_then_check
+    let _ = s.get("a").is_none();
+    //~^ unnecessary_get_then_check
 
     let s: BTreeMap<String, ()> = BTreeMap::new();
-    let _ = s.get("a").is_some(); //~ ERROR: unnecessary use of `get("a").is_some()`
-    let _ = s.get("a").is_none(); //~ ERROR: unnecessary use of `get("a").is_none()`
+    let _ = s.get("a").is_some();
+    //~^ unnecessary_get_then_check
+    let _ = s.get("a").is_none();
+    //~^ unnecessary_get_then_check
 
     // Import to check that the generic annotations are kept!
     let s: HashSet<String> = HashSet::new();
-    let _ = s.get::<str>("a").is_some(); //~ ERROR: unnecessary use of `get::<str>("a").is_some()`
-    let _ = s.get::<str>("a").is_none(); //~ ERROR: unnecessary use of `get::<str>("a").is_none()`
+    let _ = s.get::<str>("a").is_some();
+    //~^ unnecessary_get_then_check
+    let _ = s.get::<str>("a").is_none();
+    //~^ unnecessary_get_then_check
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_get_then_check.stderr b/src/tools/clippy/tests/ui/unnecessary_get_then_check.stderr
index 0477c03d16dd..5ecb3d4e29dd 100644
--- a/src/tools/clippy/tests/ui/unnecessary_get_then_check.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_get_then_check.stderr
@@ -8,7 +8,7 @@ LL |     let _ = s.get("a").is_some();
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_get_then_check)]`
 
 error: unnecessary use of `get("a").is_none()`
-  --> tests/ui/unnecessary_get_then_check.rs:8:15
+  --> tests/ui/unnecessary_get_then_check.rs:9:15
    |
 LL |     let _ = s.get("a").is_none();
    |             --^^^^^^^^^^^^^^^^^^
@@ -16,13 +16,13 @@ LL |     let _ = s.get("a").is_none();
    |             help: replace it with: `!s.contains("a")`
 
 error: unnecessary use of `get("a").is_some()`
-  --> tests/ui/unnecessary_get_then_check.rs:11:15
+  --> tests/ui/unnecessary_get_then_check.rs:13:15
    |
 LL |     let _ = s.get("a").is_some();
    |               ^^^^^^^^^^^^^^^^^^ help: replace it with: `contains_key("a")`
 
 error: unnecessary use of `get("a").is_none()`
-  --> tests/ui/unnecessary_get_then_check.rs:12:15
+  --> tests/ui/unnecessary_get_then_check.rs:15:15
    |
 LL |     let _ = s.get("a").is_none();
    |             --^^^^^^^^^^^^^^^^^^
@@ -30,13 +30,13 @@ LL |     let _ = s.get("a").is_none();
    |             help: replace it with: `!s.contains_key("a")`
 
 error: unnecessary use of `get("a").is_some()`
-  --> tests/ui/unnecessary_get_then_check.rs:15:15
+  --> tests/ui/unnecessary_get_then_check.rs:19:15
    |
 LL |     let _ = s.get("a").is_some();
    |               ^^^^^^^^^^^^^^^^^^ help: replace it with: `contains("a")`
 
 error: unnecessary use of `get("a").is_none()`
-  --> tests/ui/unnecessary_get_then_check.rs:16:15
+  --> tests/ui/unnecessary_get_then_check.rs:21:15
    |
 LL |     let _ = s.get("a").is_none();
    |             --^^^^^^^^^^^^^^^^^^
@@ -44,13 +44,13 @@ LL |     let _ = s.get("a").is_none();
    |             help: replace it with: `!s.contains("a")`
 
 error: unnecessary use of `get("a").is_some()`
-  --> tests/ui/unnecessary_get_then_check.rs:19:15
+  --> tests/ui/unnecessary_get_then_check.rs:25:15
    |
 LL |     let _ = s.get("a").is_some();
    |               ^^^^^^^^^^^^^^^^^^ help: replace it with: `contains_key("a")`
 
 error: unnecessary use of `get("a").is_none()`
-  --> tests/ui/unnecessary_get_then_check.rs:20:15
+  --> tests/ui/unnecessary_get_then_check.rs:27:15
    |
 LL |     let _ = s.get("a").is_none();
    |             --^^^^^^^^^^^^^^^^^^
@@ -58,13 +58,13 @@ LL |     let _ = s.get("a").is_none();
    |             help: replace it with: `!s.contains_key("a")`
 
 error: unnecessary use of `get::<str>("a").is_some()`
-  --> tests/ui/unnecessary_get_then_check.rs:24:15
+  --> tests/ui/unnecessary_get_then_check.rs:32:15
    |
 LL |     let _ = s.get::<str>("a").is_some();
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^ help: replace it with: `contains::<str>("a")`
 
 error: unnecessary use of `get::<str>("a").is_none()`
-  --> tests/ui/unnecessary_get_then_check.rs:25:15
+  --> tests/ui/unnecessary_get_then_check.rs:34:15
    |
 LL |     let _ = s.get::<str>("a").is_none();
    |             --^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed
index dc5e163ff04e..aed2dbe1f1ce 100644
--- a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.fixed
@@ -29,6 +29,7 @@ fn main() {
 // https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
 fn check_files(files: &[(FileType, &std::path::Path)]) -> bool {
     for (t, path) in files {
+        //~^ unnecessary_to_owned
         let other = match get_file_path(t) {
             Ok(p) => p,
             Err(_) => {
@@ -44,6 +45,7 @@ fn check_files(files: &[(FileType, &std::path::Path)]) -> bool {
 
 fn check_files_vec(files: Vec<(FileType, &std::path::Path)>) -> bool {
     for (t, path) in files.iter() {
+        //~^ unnecessary_to_owned
         let other = match get_file_path(t) {
             Ok(p) => p,
             Err(_) => {
@@ -175,7 +177,8 @@ mod issue_12821 {
     fn foo() {
         let v: Vec<_> = "hello".chars().collect();
         for c in v.iter() {
-            //~^ ERROR: unnecessary use of `cloned`
+            //~^ unnecessary_to_owned
+
             println!("{c}"); // should not suggest to remove `&`
         }
     }
@@ -183,8 +186,9 @@ mod issue_12821 {
     fn bar() {
         let v: Vec<_> = "hello".chars().collect();
         for c in v.iter() {
-            //~^ ERROR: unnecessary use of `cloned`
-            let ref_c = c; //~ HELP: remove any references to the binding
+            //~^ unnecessary_to_owned
+
+            let ref_c = c;
             println!("{ref_c}");
         }
     }
@@ -192,8 +196,9 @@ mod issue_12821 {
     fn baz() {
         let v: Vec<_> = "hello".chars().enumerate().collect();
         for (i, c) in v.iter() {
-            //~^ ERROR: unnecessary use of `cloned`
-            let ref_c = c; //~ HELP: remove any references to the binding
+            //~^ unnecessary_to_owned
+
+            let ref_c = c;
             let ref_i = i;
             println!("{i} {ref_c}"); // should not suggest to remove `&` from `i`
         }
diff --git a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs
index 8f797ac717fb..12fdd150e423 100644
--- a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.rs
@@ -29,6 +29,7 @@ fn main() {
 // https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
 fn check_files(files: &[(FileType, &std::path::Path)]) -> bool {
     for (t, path) in files.iter().copied() {
+        //~^ unnecessary_to_owned
         let other = match get_file_path(&t) {
             Ok(p) => p,
             Err(_) => {
@@ -44,6 +45,7 @@ fn check_files(files: &[(FileType, &std::path::Path)]) -> bool {
 
 fn check_files_vec(files: Vec<(FileType, &std::path::Path)>) -> bool {
     for (t, path) in files.iter().copied() {
+        //~^ unnecessary_to_owned
         let other = match get_file_path(&t) {
             Ok(p) => p,
             Err(_) => {
@@ -175,7 +177,8 @@ mod issue_12821 {
     fn foo() {
         let v: Vec<_> = "hello".chars().collect();
         for c in v.iter().cloned() {
-            //~^ ERROR: unnecessary use of `cloned`
+            //~^ unnecessary_to_owned
+
             println!("{c}"); // should not suggest to remove `&`
         }
     }
@@ -183,8 +186,9 @@ mod issue_12821 {
     fn bar() {
         let v: Vec<_> = "hello".chars().collect();
         for c in v.iter().cloned() {
-            //~^ ERROR: unnecessary use of `cloned`
-            let ref_c = &c; //~ HELP: remove any references to the binding
+            //~^ unnecessary_to_owned
+
+            let ref_c = &c;
             println!("{ref_c}");
         }
     }
@@ -192,8 +196,9 @@ mod issue_12821 {
     fn baz() {
         let v: Vec<_> = "hello".chars().enumerate().collect();
         for (i, c) in v.iter().cloned() {
-            //~^ ERROR: unnecessary use of `cloned`
-            let ref_c = &c; //~ HELP: remove any references to the binding
+            //~^ unnecessary_to_owned
+
+            let ref_c = &c;
             let ref_i = &i;
             println!("{i} {ref_c}"); // should not suggest to remove `&` from `i`
         }
diff --git a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr
index 6f2ae0ab1f35..632c8f371106 100644
--- a/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_iter_cloned.stderr
@@ -9,11 +9,12 @@ LL |     for (t, path) in files.iter().copied() {
 help: remove any references to the binding
    |
 LL ~     for (t, path) in files {
+LL |
 LL ~         let other = match get_file_path(t) {
    |
 
 error: unnecessary use of `copied`
-  --> tests/ui/unnecessary_iter_cloned.rs:46:22
+  --> tests/ui/unnecessary_iter_cloned.rs:47:22
    |
 LL |     for (t, path) in files.iter().copied() {
    |                      ^^^^^^^^^^^^^^^^^^^^^
@@ -21,17 +22,18 @@ LL |     for (t, path) in files.iter().copied() {
 help: remove any references to the binding
    |
 LL ~     for (t, path) in files.iter() {
+LL |
 LL ~         let other = match get_file_path(t) {
    |
 
 error: unnecessary use of `cloned`
-  --> tests/ui/unnecessary_iter_cloned.rs:177:18
+  --> tests/ui/unnecessary_iter_cloned.rs:179:18
    |
 LL |         for c in v.iter().cloned() {
    |                  ^^^^^^^^^^^^^^^^^ help: remove any references to the binding: `v.iter()`
 
 error: unnecessary use of `cloned`
-  --> tests/ui/unnecessary_iter_cloned.rs:185:18
+  --> tests/ui/unnecessary_iter_cloned.rs:188:18
    |
 LL |         for c in v.iter().cloned() {
    |                  ^^^^^^^^^^^^^^^^^
@@ -40,11 +42,12 @@ help: remove any references to the binding
    |
 LL ~         for c in v.iter() {
 LL |
+LL |
 LL ~             let ref_c = c;
    |
 
 error: unnecessary use of `cloned`
-  --> tests/ui/unnecessary_iter_cloned.rs:194:23
+  --> tests/ui/unnecessary_iter_cloned.rs:198:23
    |
 LL |         for (i, c) in v.iter().cloned() {
    |                       ^^^^^^^^^^^^^^^^^
@@ -53,6 +56,7 @@ help: remove any references to the binding
    |
 LL ~         for (i, c) in v.iter() {
 LL |
+LL |
 LL ~             let ref_c = c;
 LL ~             let ref_i = i;
    |
diff --git a/src/tools/clippy/tests/ui/unnecessary_join.rs b/src/tools/clippy/tests/ui/unnecessary_join.rs
index d042d9e5c212..e58b2696645a 100644
--- a/src/tools/clippy/tests/ui/unnecessary_join.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_join.rs
@@ -8,6 +8,7 @@ fn main() {
         .iter()
         .map(|item| item.to_uppercase())
         .collect::<Vec<String>>()
+        //~^ unnecessary_join
         .join("");
     println!("{}", output);
 
@@ -17,6 +18,7 @@ fn main() {
         .iter()
         .map(|item| item.to_uppercase())
         .collect::<Vec<_>>()
+        //~^ unnecessary_join
         .join("");
     println!("{}", output);
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_join.stderr b/src/tools/clippy/tests/ui/unnecessary_join.stderr
index a06a1059033b..a7677fe2f9eb 100644
--- a/src/tools/clippy/tests/ui/unnecessary_join.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_join.stderr
@@ -3,6 +3,7 @@ error: called `.collect::<Vec<String>>().join("")` on an iterator
    |
 LL |           .collect::<Vec<String>>()
    |  __________^
+LL | |
 LL | |         .join("");
    | |_________________^ help: consider using: `collect::<String>()`
    |
@@ -10,10 +11,11 @@ LL | |         .join("");
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_join)]`
 
 error: called `.collect::<Vec<String>>().join("")` on an iterator
-  --> tests/ui/unnecessary_join.rs:19:10
+  --> tests/ui/unnecessary_join.rs:20:10
    |
 LL |           .collect::<Vec<_>>()
    |  __________^
+LL | |
 LL | |         .join("");
    | |_________________^ help: consider using: `collect::<String>()`
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_lazy_eval.fixed b/src/tools/clippy/tests/ui/unnecessary_lazy_eval.fixed
index d8031c484e5e..9a3290816389 100644
--- a/src/tools/clippy/tests/ui/unnecessary_lazy_eval.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_lazy_eval.fixed
@@ -81,42 +81,69 @@ fn main() {
 
     // Should lint - Option
     let _ = opt.unwrap_or(2);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.unwrap_or(astronomers_pi);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.unwrap_or(ext_str.some_field);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.unwrap_or_else(|| ext_arr[0]);
     let _ = opt.and(ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.or(ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.or(None);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.get_or_insert(2);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.ok_or(2);
+    //~^ unnecessary_lazy_evaluations
     let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
+    //~^ unnecessary_lazy_evaluations
     let _ = cond.then_some(astronomers_pi);
+    //~^ unnecessary_lazy_evaluations
     let _ = true.then_some({});
+    //~^ unnecessary_lazy_evaluations
     let _ = true.then_some({});
+    //~^ unnecessary_lazy_evaluations
 
     // Should lint - Builtin deref
     let r = &1;
     let _ = Some(1).unwrap_or(*r);
+    //~^ unnecessary_lazy_evaluations
     let b = Box::new(1);
     let _ = Some(1).unwrap_or(*b);
+    //~^ unnecessary_lazy_evaluations
     // Should lint - Builtin deref through autoderef
     let _ = Some(1).as_ref().unwrap_or(&r);
+    //~^ unnecessary_lazy_evaluations
     let _ = Some(1).as_ref().unwrap_or(&b);
+    //~^ unnecessary_lazy_evaluations
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or(2);
+    //~^ unnecessary_lazy_evaluations
     let _ = Some(10).and(ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _: Option<usize> = None.or(ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = None.get_or_insert(2);
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = None.ok_or(2);
+    //~^ unnecessary_lazy_evaluations
     let _: Option<usize> = None.or(None);
+    //~^ unnecessary_lazy_evaluations
 
     let mut deep = Deep(Some(42));
     let _ = deep.0.unwrap_or(2);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.and(ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.or(None);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.get_or_insert(2);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.ok_or(2);
+    //~^ unnecessary_lazy_evaluations
 
     // Should not lint - Option
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
@@ -148,16 +175,22 @@ fn main() {
 
     // should lint, bind_instead_of_map doesn't apply
     let _: Option<usize> = None.or(Some(3));
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.or(Some(3));
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.or(Some(3));
+    //~^ unnecessary_lazy_evaluations
 
     // Should lint - Result
     let res: Result<usize, usize> = Err(5);
     let res2: Result<usize, SomeStruct> = Err(SomeStruct { some_field: 5 });
 
     let _ = res2.unwrap_or(2);
+    //~^ unnecessary_lazy_evaluations
     let _ = res2.unwrap_or(astronomers_pi);
+    //~^ unnecessary_lazy_evaluations
     let _ = res2.unwrap_or(ext_str.some_field);
+    //~^ unnecessary_lazy_evaluations
 
     // Should not lint - Result
     let _ = res.unwrap_or_else(|err| err);
@@ -180,13 +213,20 @@ fn main() {
 
     // should lint, bind_instead_of_map doesn't apply
     let _: Result<usize, usize> = res.and(Err(2));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.and(Err(astronomers_pi));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.and(Err(ext_str.some_field));
+    //~^ unnecessary_lazy_evaluations
 
     let _: Result<usize, usize> = res.or(Ok(2));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.
+    //~^ unnecessary_lazy_evaluations
     // some lines
     // some lines
     // some lines
@@ -217,39 +257,39 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     // See comments in `eager_or_lazy.rs` for the rules that this is meant to follow
 
     let _x = false.then_some(i32::MAX + 1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(i32::MAX * 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(i32::MAX - 1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(i32::MIN - 1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some((1 + 2 * 3 - 2 / 3 + 9) << 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(255u8 << 7);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(255u8 << 8);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(255u8 >> 8);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 255u8 >> x);
     let _x = false.then_some(i32::MAX + -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(-i32::MAX);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(-i32::MIN);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| -y);
     let _x = false.then_some(255 >> -7);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(255 << -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(1 / 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(x << -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(x << 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| x + x);
     let _x = false.then(|| x * x);
     let _x = false.then(|| x - x);
@@ -259,19 +299,19 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     let _x = false.then(|| 1 + x);
 
     let _x = false.then_some(x / 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(x % 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| y / -1);
     let _x = false.then_some(1 / -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(i32::MIN / -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| i32::MIN / x as i32);
     let _x = false.then_some(i32::MIN / 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then_some(4 / 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 1 / x);
 
     // const eval doesn't read variables, but floating point math never panics, so we can still emit a
@@ -279,5 +319,5 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     let f1 = 1.0;
     let f2 = 2.0;
     let _x = false.then_some(f1 + f2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_lazy_eval.rs b/src/tools/clippy/tests/ui/unnecessary_lazy_eval.rs
index ea55b1d9a905..2d05ef5c2917 100644
--- a/src/tools/clippy/tests/ui/unnecessary_lazy_eval.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_lazy_eval.rs
@@ -81,42 +81,69 @@ fn main() {
 
     // Should lint - Option
     let _ = opt.unwrap_or_else(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.unwrap_or_else(|| astronomers_pi);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.unwrap_or_else(|| ext_str.some_field);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.unwrap_or_else(|| ext_arr[0]);
     let _ = opt.and_then(|_| ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.or_else(|| ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.or_else(|| None);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.get_or_insert_with(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.ok_or_else(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
+    //~^ unnecessary_lazy_evaluations
     let _ = cond.then(|| astronomers_pi);
+    //~^ unnecessary_lazy_evaluations
     let _ = true.then(|| -> _ {});
+    //~^ unnecessary_lazy_evaluations
     let _ = true.then(|| {});
+    //~^ unnecessary_lazy_evaluations
 
     // Should lint - Builtin deref
     let r = &1;
     let _ = Some(1).unwrap_or_else(|| *r);
+    //~^ unnecessary_lazy_evaluations
     let b = Box::new(1);
     let _ = Some(1).unwrap_or_else(|| *b);
+    //~^ unnecessary_lazy_evaluations
     // Should lint - Builtin deref through autoderef
     let _ = Some(1).as_ref().unwrap_or_else(|| &r);
+    //~^ unnecessary_lazy_evaluations
     let _ = Some(1).as_ref().unwrap_or_else(|| &b);
+    //~^ unnecessary_lazy_evaluations
 
     // Cases when unwrap is not called on a simple variable
     let _ = Some(10).unwrap_or_else(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _ = Some(10).and_then(|_| ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _: Option<usize> = None.or_else(|| ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = None.get_or_insert_with(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = None.ok_or_else(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _: Option<usize> = None.or_else(|| None);
+    //~^ unnecessary_lazy_evaluations
 
     let mut deep = Deep(Some(42));
     let _ = deep.0.unwrap_or_else(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.and_then(|_| ext_opt);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.or_else(|| None);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.get_or_insert_with(|| 2);
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.ok_or_else(|| 2);
+    //~^ unnecessary_lazy_evaluations
 
     // Should not lint - Option
     let _ = opt.unwrap_or_else(|| ext_str.return_some_field());
@@ -148,16 +175,22 @@ fn main() {
 
     // should lint, bind_instead_of_map doesn't apply
     let _: Option<usize> = None.or_else(|| Some(3));
+    //~^ unnecessary_lazy_evaluations
     let _ = deep.0.or_else(|| Some(3));
+    //~^ unnecessary_lazy_evaluations
     let _ = opt.or_else(|| Some(3));
+    //~^ unnecessary_lazy_evaluations
 
     // Should lint - Result
     let res: Result<usize, usize> = Err(5);
     let res2: Result<usize, SomeStruct> = Err(SomeStruct { some_field: 5 });
 
     let _ = res2.unwrap_or_else(|_| 2);
+    //~^ unnecessary_lazy_evaluations
     let _ = res2.unwrap_or_else(|_| astronomers_pi);
+    //~^ unnecessary_lazy_evaluations
     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
+    //~^ unnecessary_lazy_evaluations
 
     // Should not lint - Result
     let _ = res.unwrap_or_else(|err| err);
@@ -180,13 +213,20 @@ fn main() {
 
     // should lint, bind_instead_of_map doesn't apply
     let _: Result<usize, usize> = res.and_then(|_| Err(2));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
+    //~^ unnecessary_lazy_evaluations
 
     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
+    //~^ unnecessary_lazy_evaluations
     let _: Result<usize, usize> = res.
+    //~^ unnecessary_lazy_evaluations
     // some lines
     // some lines
     // some lines
@@ -217,39 +257,39 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     // See comments in `eager_or_lazy.rs` for the rules that this is meant to follow
 
     let _x = false.then(|| i32::MAX + 1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| i32::MAX * 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| i32::MAX - 1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| i32::MIN - 1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| (1 + 2 * 3 - 2 / 3 + 9) << 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 255u8 << 7);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 255u8 << 8);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 255u8 >> 8);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 255u8 >> x);
     let _x = false.then(|| i32::MAX + -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| -i32::MAX);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| -i32::MIN);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| -y);
     let _x = false.then(|| 255 >> -7);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 255 << -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 1 / 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| x << -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| x << 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| x + x);
     let _x = false.then(|| x * x);
     let _x = false.then(|| x - x);
@@ -259,19 +299,19 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     let _x = false.then(|| 1 + x);
 
     let _x = false.then(|| x / 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| x % 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| y / -1);
     let _x = false.then(|| 1 / -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| i32::MIN / -1);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| i32::MIN / x as i32);
     let _x = false.then(|| i32::MIN / 0);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 4 / 2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
     let _x = false.then(|| 1 / x);
 
     // const eval doesn't read variables, but floating point math never panics, so we can still emit a
@@ -279,5 +319,5 @@ fn panicky_arithmetic_ops(x: usize, y: isize) {
     let f1 = 1.0;
     let f2 = 2.0;
     let _x = false.then(|| f1 + f2);
-    //~^ ERROR: unnecessary closure used with `bool::then`
+    //~^ unnecessary_lazy_evaluations
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_lazy_eval.stderr b/src/tools/clippy/tests/ui/unnecessary_lazy_eval.stderr
index 9bb1b71f0ed5..75a06a419c71 100644
--- a/src/tools/clippy/tests/ui/unnecessary_lazy_eval.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_lazy_eval.stderr
@@ -13,7 +13,7 @@ LL +     let _ = opt.unwrap_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:84:13
+  --> tests/ui/unnecessary_lazy_eval.rs:85:13
    |
 LL |     let _ = opt.unwrap_or_else(|| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     let _ = opt.unwrap_or(astronomers_pi);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:85:13
+  --> tests/ui/unnecessary_lazy_eval.rs:87:13
    |
 LL |     let _ = opt.unwrap_or_else(|| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     let _ = opt.unwrap_or(ext_str.some_field);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:87:13
+  --> tests/ui/unnecessary_lazy_eval.rs:90:13
    |
 LL |     let _ = opt.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     let _ = opt.and(ext_opt);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:88:13
+  --> tests/ui/unnecessary_lazy_eval.rs:92:13
    |
 LL |     let _ = opt.or_else(|| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     let _ = opt.or(ext_opt);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:89:13
+  --> tests/ui/unnecessary_lazy_eval.rs:94:13
    |
 LL |     let _ = opt.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     let _ = opt.or(None);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:90:13
+  --> tests/ui/unnecessary_lazy_eval.rs:96:13
    |
 LL |     let _ = opt.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let _ = opt.get_or_insert(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:91:13
+  --> tests/ui/unnecessary_lazy_eval.rs:98:13
    |
 LL |     let _ = opt.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let _ = opt.ok_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:92:13
+  --> tests/ui/unnecessary_lazy_eval.rs:100:13
    |
 LL |     let _ = nested_tuple_opt.unwrap_or_else(|| Some((1, 2)));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let _ = nested_tuple_opt.unwrap_or(Some((1, 2)));
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:93:13
+  --> tests/ui/unnecessary_lazy_eval.rs:102:13
    |
 LL |     let _ = cond.then(|| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     let _ = cond.then_some(astronomers_pi);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:94:13
+  --> tests/ui/unnecessary_lazy_eval.rs:104:13
    |
 LL |     let _ = true.then(|| -> _ {});
    |             ^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     let _ = true.then_some({});
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:95:13
+  --> tests/ui/unnecessary_lazy_eval.rs:106:13
    |
 LL |     let _ = true.then(|| {});
    |             ^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     let _ = true.then_some({});
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:99:13
+  --> tests/ui/unnecessary_lazy_eval.rs:111:13
    |
 LL |     let _ = Some(1).unwrap_or_else(|| *r);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     let _ = Some(1).unwrap_or(*r);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:101:13
+  --> tests/ui/unnecessary_lazy_eval.rs:114:13
    |
 LL |     let _ = Some(1).unwrap_or_else(|| *b);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     let _ = Some(1).unwrap_or(*b);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:103:13
+  --> tests/ui/unnecessary_lazy_eval.rs:117:13
    |
 LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &r);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     let _ = Some(1).as_ref().unwrap_or(&r);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:104:13
+  --> tests/ui/unnecessary_lazy_eval.rs:119:13
    |
 LL |     let _ = Some(1).as_ref().unwrap_or_else(|| &b);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     let _ = Some(1).as_ref().unwrap_or(&b);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:107:13
+  --> tests/ui/unnecessary_lazy_eval.rs:123:13
    |
 LL |     let _ = Some(10).unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL +     let _ = Some(10).unwrap_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:108:13
+  --> tests/ui/unnecessary_lazy_eval.rs:125:13
    |
 LL |     let _ = Some(10).and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL +     let _ = Some(10).and(ext_opt);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:109:28
+  --> tests/ui/unnecessary_lazy_eval.rs:127:28
    |
 LL |     let _: Option<usize> = None.or_else(|| ext_opt);
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL +     let _: Option<usize> = None.or(ext_opt);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:110:13
+  --> tests/ui/unnecessary_lazy_eval.rs:129:13
    |
 LL |     let _ = None.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL +     let _ = None.get_or_insert(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:111:35
+  --> tests/ui/unnecessary_lazy_eval.rs:131:35
    |
 LL |     let _: Result<usize, usize> = None.ok_or_else(|| 2);
    |                                   ^^^^^^^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL +     let _: Result<usize, usize> = None.ok_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:112:28
+  --> tests/ui/unnecessary_lazy_eval.rs:133:28
    |
 LL |     let _: Option<usize> = None.or_else(|| None);
    |                            ^^^^^^^^^^^^^^^^^^^^^
@@ -265,7 +265,7 @@ LL +     let _: Option<usize> = None.or(None);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:115:13
+  --> tests/ui/unnecessary_lazy_eval.rs:137:13
    |
 LL |     let _ = deep.0.unwrap_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL +     let _ = deep.0.unwrap_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:116:13
+  --> tests/ui/unnecessary_lazy_eval.rs:139:13
    |
 LL |     let _ = deep.0.and_then(|_| ext_opt);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -289,7 +289,7 @@ LL +     let _ = deep.0.and(ext_opt);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:117:13
+  --> tests/ui/unnecessary_lazy_eval.rs:141:13
    |
 LL |     let _ = deep.0.or_else(|| None);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -301,7 +301,7 @@ LL +     let _ = deep.0.or(None);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:118:13
+  --> tests/ui/unnecessary_lazy_eval.rs:143:13
    |
 LL |     let _ = deep.0.get_or_insert_with(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL +     let _ = deep.0.get_or_insert(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:119:13
+  --> tests/ui/unnecessary_lazy_eval.rs:145:13
    |
 LL |     let _ = deep.0.ok_or_else(|| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL +     let _ = deep.0.ok_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:150:28
+  --> tests/ui/unnecessary_lazy_eval.rs:177:28
    |
 LL |     let _: Option<usize> = None.or_else(|| Some(3));
    |                            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL +     let _: Option<usize> = None.or(Some(3));
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:151:13
+  --> tests/ui/unnecessary_lazy_eval.rs:179:13
    |
 LL |     let _ = deep.0.or_else(|| Some(3));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -349,7 +349,7 @@ LL +     let _ = deep.0.or(Some(3));
    |
 
 error: unnecessary closure used to substitute value for `Option::None`
-  --> tests/ui/unnecessary_lazy_eval.rs:152:13
+  --> tests/ui/unnecessary_lazy_eval.rs:181:13
    |
 LL |     let _ = opt.or_else(|| Some(3));
    |             ^^^^^^^^^^^^^^^^^^^^^^^
@@ -361,7 +361,7 @@ LL +     let _ = opt.or(Some(3));
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:158:13
+  --> tests/ui/unnecessary_lazy_eval.rs:188:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -373,7 +373,7 @@ LL +     let _ = res2.unwrap_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:159:13
+  --> tests/ui/unnecessary_lazy_eval.rs:190:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| astronomers_pi);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -385,7 +385,7 @@ LL +     let _ = res2.unwrap_or(astronomers_pi);
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:160:13
+  --> tests/ui/unnecessary_lazy_eval.rs:192:13
    |
 LL |     let _ = res2.unwrap_or_else(|_| ext_str.some_field);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -397,7 +397,7 @@ LL +     let _ = res2.unwrap_or(ext_str.some_field);
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:182:35
+  --> tests/ui/unnecessary_lazy_eval.rs:215:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(2));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -409,7 +409,7 @@ LL +     let _: Result<usize, usize> = res.and(Err(2));
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:183:35
+  --> tests/ui/unnecessary_lazy_eval.rs:217:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(astronomers_pi));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -421,7 +421,7 @@ LL +     let _: Result<usize, usize> = res.and(Err(astronomers_pi));
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:184:35
+  --> tests/ui/unnecessary_lazy_eval.rs:219:35
    |
 LL |     let _: Result<usize, usize> = res.and_then(|_| Err(ext_str.some_field));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -433,7 +433,7 @@ LL +     let _: Result<usize, usize> = res.and(Err(ext_str.some_field));
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:186:35
+  --> tests/ui/unnecessary_lazy_eval.rs:222:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(2));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^
@@ -445,7 +445,7 @@ LL +     let _: Result<usize, usize> = res.or(Ok(2));
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:187:35
+  --> tests/ui/unnecessary_lazy_eval.rs:224:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(astronomers_pi));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -457,7 +457,7 @@ LL +     let _: Result<usize, usize> = res.or(Ok(astronomers_pi));
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:188:35
+  --> tests/ui/unnecessary_lazy_eval.rs:226:35
    |
 LL |     let _: Result<usize, usize> = res.or_else(|_| Ok(ext_str.some_field));
    |                                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -469,7 +469,7 @@ LL +     let _: Result<usize, usize> = res.or(Ok(ext_str.some_field));
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval.rs:189:35
+  --> tests/ui/unnecessary_lazy_eval.rs:228:35
    |
 LL |       let _: Result<usize, usize> = res.
    |  ___________________________________^
@@ -484,7 +484,7 @@ LL +     or(Ok(ext_str.some_field));
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:219:14
+  --> tests/ui/unnecessary_lazy_eval.rs:259:14
    |
 LL |     let _x = false.then(|| i32::MAX + 1);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -496,7 +496,7 @@ LL +     let _x = false.then_some(i32::MAX + 1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:221:14
+  --> tests/ui/unnecessary_lazy_eval.rs:261:14
    |
 LL |     let _x = false.then(|| i32::MAX * 2);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -508,7 +508,7 @@ LL +     let _x = false.then_some(i32::MAX * 2);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:223:14
+  --> tests/ui/unnecessary_lazy_eval.rs:263:14
    |
 LL |     let _x = false.then(|| i32::MAX - 1);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -520,7 +520,7 @@ LL +     let _x = false.then_some(i32::MAX - 1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:225:14
+  --> tests/ui/unnecessary_lazy_eval.rs:265:14
    |
 LL |     let _x = false.then(|| i32::MIN - 1);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -532,7 +532,7 @@ LL +     let _x = false.then_some(i32::MIN - 1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:227:14
+  --> tests/ui/unnecessary_lazy_eval.rs:267:14
    |
 LL |     let _x = false.then(|| (1 + 2 * 3 - 2 / 3 + 9) << 2);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -544,7 +544,7 @@ LL +     let _x = false.then_some((1 + 2 * 3 - 2 / 3 + 9) << 2);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:229:14
+  --> tests/ui/unnecessary_lazy_eval.rs:269:14
    |
 LL |     let _x = false.then(|| 255u8 << 7);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -556,7 +556,7 @@ LL +     let _x = false.then_some(255u8 << 7);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:231:14
+  --> tests/ui/unnecessary_lazy_eval.rs:271:14
    |
 LL |     let _x = false.then(|| 255u8 << 8);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -568,7 +568,7 @@ LL +     let _x = false.then_some(255u8 << 8);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:233:14
+  --> tests/ui/unnecessary_lazy_eval.rs:273:14
    |
 LL |     let _x = false.then(|| 255u8 >> 8);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -580,7 +580,7 @@ LL +     let _x = false.then_some(255u8 >> 8);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:236:14
+  --> tests/ui/unnecessary_lazy_eval.rs:276:14
    |
 LL |     let _x = false.then(|| i32::MAX + -1);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -592,7 +592,7 @@ LL +     let _x = false.then_some(i32::MAX + -1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:238:14
+  --> tests/ui/unnecessary_lazy_eval.rs:278:14
    |
 LL |     let _x = false.then(|| -i32::MAX);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -604,7 +604,7 @@ LL +     let _x = false.then_some(-i32::MAX);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:240:14
+  --> tests/ui/unnecessary_lazy_eval.rs:280:14
    |
 LL |     let _x = false.then(|| -i32::MIN);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -616,7 +616,7 @@ LL +     let _x = false.then_some(-i32::MIN);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:243:14
+  --> tests/ui/unnecessary_lazy_eval.rs:283:14
    |
 LL |     let _x = false.then(|| 255 >> -7);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -628,7 +628,7 @@ LL +     let _x = false.then_some(255 >> -7);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:245:14
+  --> tests/ui/unnecessary_lazy_eval.rs:285:14
    |
 LL |     let _x = false.then(|| 255 << -1);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -640,7 +640,7 @@ LL +     let _x = false.then_some(255 << -1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:247:14
+  --> tests/ui/unnecessary_lazy_eval.rs:287:14
    |
 LL |     let _x = false.then(|| 1 / 0);
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -652,7 +652,7 @@ LL +     let _x = false.then_some(1 / 0);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:249:14
+  --> tests/ui/unnecessary_lazy_eval.rs:289:14
    |
 LL |     let _x = false.then(|| x << -1);
    |              ^^^^^^^^^^^^^^^^^^^^^^
@@ -664,7 +664,7 @@ LL +     let _x = false.then_some(x << -1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:251:14
+  --> tests/ui/unnecessary_lazy_eval.rs:291:14
    |
 LL |     let _x = false.then(|| x << 2);
    |              ^^^^^^^^^^^^^^^^^^^^^
@@ -676,7 +676,7 @@ LL +     let _x = false.then_some(x << 2);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:261:14
+  --> tests/ui/unnecessary_lazy_eval.rs:301:14
    |
 LL |     let _x = false.then(|| x / 0);
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -688,7 +688,7 @@ LL +     let _x = false.then_some(x / 0);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:263:14
+  --> tests/ui/unnecessary_lazy_eval.rs:303:14
    |
 LL |     let _x = false.then(|| x % 0);
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -700,7 +700,7 @@ LL +     let _x = false.then_some(x % 0);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:266:14
+  --> tests/ui/unnecessary_lazy_eval.rs:306:14
    |
 LL |     let _x = false.then(|| 1 / -1);
    |              ^^^^^^^^^^^^^^^^^^^^^
@@ -712,7 +712,7 @@ LL +     let _x = false.then_some(1 / -1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:268:14
+  --> tests/ui/unnecessary_lazy_eval.rs:308:14
    |
 LL |     let _x = false.then(|| i32::MIN / -1);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -724,7 +724,7 @@ LL +     let _x = false.then_some(i32::MIN / -1);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:271:14
+  --> tests/ui/unnecessary_lazy_eval.rs:311:14
    |
 LL |     let _x = false.then(|| i32::MIN / 0);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -736,7 +736,7 @@ LL +     let _x = false.then_some(i32::MIN / 0);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:273:14
+  --> tests/ui/unnecessary_lazy_eval.rs:313:14
    |
 LL |     let _x = false.then(|| 4 / 2);
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -748,7 +748,7 @@ LL +     let _x = false.then_some(4 / 2);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval.rs:281:14
+  --> tests/ui/unnecessary_lazy_eval.rs:321:14
    |
 LL |     let _x = false.then(|| f1 + f2);
    |              ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.rs b/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.rs
index 412d4aaafb4a..6d28d544dfe0 100644
--- a/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.rs
@@ -11,15 +11,16 @@ struct SomeStruct {
 fn main() {
     // fix will break type inference
     let _ = Ok(1).unwrap_or_else(|()| 2);
-    //~^ ERROR: unnecessary closure used to substitute value for `Result::Err`
-    //~| NOTE: `-D clippy::unnecessary-lazy-evaluations` implied by `-D warnings`
+    //~^ unnecessary_lazy_evaluations
+
     mod e {
         pub struct E;
     }
     let _ = Ok(1).unwrap_or_else(|e::E| 2);
-    //~^ ERROR: unnecessary closure used to substitute value for `Result::Err`
+    //~^ unnecessary_lazy_evaluations
+
     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
-    //~^ ERROR: unnecessary closure used to substitute value for `Result::Err`
+    //~^ unnecessary_lazy_evaluations
 
     // Fix #6343
     let arr = [(Some(1),)];
@@ -29,4 +30,5 @@ fn main() {
 fn issue11672() {
     // Return type annotation helps type inference and removing it can break code
     let _ = true.then(|| -> &[u8] { &[] });
+    //~^ unnecessary_lazy_evaluations
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.stderr b/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.stderr
index 9688c44c9145..5174acc1e9f9 100644
--- a/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_lazy_eval_unfixable.stderr
@@ -25,7 +25,7 @@ LL +     let _ = Ok(1).unwrap_or(2);
    |
 
 error: unnecessary closure used to substitute value for `Result::Err`
-  --> tests/ui/unnecessary_lazy_eval_unfixable.rs:21:13
+  --> tests/ui/unnecessary_lazy_eval_unfixable.rs:22:13
    |
 LL |     let _ = Ok(1).unwrap_or_else(|SomeStruct { .. }| 2);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     let _ = Ok(1).unwrap_or(2);
    |
 
 error: unnecessary closure used with `bool::then`
-  --> tests/ui/unnecessary_lazy_eval_unfixable.rs:31:13
+  --> tests/ui/unnecessary_lazy_eval_unfixable.rs:32:13
    |
 LL |     let _ = true.then(|| -> &[u8] { &[] });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_bound.fixed b/src/tools/clippy/tests/ui/unnecessary_literal_bound.fixed
index 107e397466d0..ec0d2db154ce 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_bound.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_bound.fixed
@@ -7,6 +7,7 @@ struct Struct<'a> {
 impl Struct<'_> {
     // Should warn
     fn returns_lit(&self) -> &'static str {
+        //~^ unnecessary_literal_bound
         "Hello"
     }
 
@@ -27,6 +28,7 @@ impl Struct<'_> {
 
     // Should warn
     fn contionally_returns_literals_explicit(&self, cond: bool) -> &'static str {
+        //~^ unnecessary_literal_bound
         if cond {
             return "Literal";
         }
@@ -51,6 +53,7 @@ trait ReturnsStr {
 impl ReturnsStr for u8 {
     // Should warn, even though not useful without trait refinement
     fn trait_method(&self) -> &'static str {
+        //~^ unnecessary_literal_bound
         "Literal"
     }
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_bound.rs b/src/tools/clippy/tests/ui/unnecessary_literal_bound.rs
index b371ff9d3a2e..713dee4d30a6 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_bound.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_bound.rs
@@ -7,6 +7,7 @@ struct Struct<'a> {
 impl Struct<'_> {
     // Should warn
     fn returns_lit(&self) -> &str {
+        //~^ unnecessary_literal_bound
         "Hello"
     }
 
@@ -27,6 +28,7 @@ impl Struct<'_> {
 
     // Should warn
     fn contionally_returns_literals_explicit(&self, cond: bool) -> &str {
+        //~^ unnecessary_literal_bound
         if cond {
             return "Literal";
         }
@@ -51,6 +53,7 @@ trait ReturnsStr {
 impl ReturnsStr for u8 {
     // Should warn, even though not useful without trait refinement
     fn trait_method(&self) -> &str {
+        //~^ unnecessary_literal_bound
         "Literal"
     }
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_bound.stderr b/src/tools/clippy/tests/ui/unnecessary_literal_bound.stderr
index 512b2f9a0afa..e510d86622d6 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_bound.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_bound.stderr
@@ -8,13 +8,13 @@ LL |     fn returns_lit(&self) -> &str {
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_literal_bound)]`
 
 error: returning a `str` unnecessarily tied to the lifetime of arguments
-  --> tests/ui/unnecessary_literal_bound.rs:29:68
+  --> tests/ui/unnecessary_literal_bound.rs:30:68
    |
 LL |     fn contionally_returns_literals_explicit(&self, cond: bool) -> &str {
    |                                                                    ^^^^ help: try: `&'static str`
 
 error: returning a `str` unnecessarily tied to the lifetime of arguments
-  --> tests/ui/unnecessary_literal_bound.rs:53:31
+  --> tests/ui/unnecessary_literal_bound.rs:55:31
    |
 LL |     fn trait_method(&self) -> &str {
    |                               ^^^^ help: try: `&'static str`
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.fixed b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.fixed
index b17343aa9ba5..877f4ad41c7e 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.fixed
@@ -9,73 +9,119 @@
 
 fn unwrap_option_some() {
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
 
     1;
+    //~^ unnecessary_literal_unwrap
     1;
+    //~^ unnecessary_literal_unwrap
 }
 
 #[rustfmt::skip] // force rustfmt not to remove braces in `|| { 234 }`
 fn unwrap_option_none() {
     let _val = panic!();
+    //~^ unnecessary_literal_unwrap
     let _val = panic!("this always happens");
+    //~^ unnecessary_literal_unwrap
     let _val: String = String::default();
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = 234;
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = 234;
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = { 234 };
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = { 234 };
+    //~^ unnecessary_literal_unwrap
 
     panic!();
+    //~^ unnecessary_literal_unwrap
     panic!("this always happens");
+    //~^ unnecessary_literal_unwrap
     String::default();
+    //~^ unnecessary_literal_unwrap
     234;
+    //~^ unnecessary_literal_unwrap
     234;
+    //~^ unnecessary_literal_unwrap
     { 234 };
+    //~^ unnecessary_literal_unwrap
     { 234 };
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_ok() {
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = panic!("{:?}", 1);
+    //~^ unnecessary_literal_unwrap
     let _val = panic!("{1}: {:?}", 1, "this always happens");
+    //~^ unnecessary_literal_unwrap
 
     1;
+    //~^ unnecessary_literal_unwrap
     1;
+    //~^ unnecessary_literal_unwrap
     panic!("{:?}", 1);
+    //~^ unnecessary_literal_unwrap
     panic!("{1}: {:?}", 1, "this always happens");
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_err() {
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = panic!("{:?}", 1);
+    //~^ unnecessary_literal_unwrap
     let _val = panic!("{1}: {:?}", 1, "this always happens");
+    //~^ unnecessary_literal_unwrap
 
     1;
+    //~^ unnecessary_literal_unwrap
     1;
+    //~^ unnecessary_literal_unwrap
     panic!("{:?}", 1);
+    //~^ unnecessary_literal_unwrap
     panic!("{1}: {:?}", 1, "this always happens");
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_option() {
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
 
     1;
+    //~^ unnecessary_literal_unwrap
     1;
+    //~^ unnecessary_literal_unwrap
     1;
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_result() {
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
     let _val = 1;
+    //~^ unnecessary_literal_unwrap
 
     1;
+    //~^ unnecessary_literal_unwrap
     1;
+    //~^ unnecessary_literal_unwrap
     1;
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_from_binding() {
@@ -90,12 +136,20 @@ fn unwrap_from_binding() {
 
 fn unwrap_unchecked() {
     let _ = 1;
+    //~^ unnecessary_literal_unwrap
     let _ = unsafe { 1 + *(&1 as *const i32) }; // needs to keep the unsafe block
+    //
+    //~^^ unnecessary_literal_unwrap
     let _ = 1 + 1;
+    //~^ unnecessary_literal_unwrap
     let _ = 1;
+    //~^ unnecessary_literal_unwrap
     let _ = unsafe { 1 + *(&1 as *const i32) };
+    //~^ unnecessary_literal_unwrap
     let _ = 1 + 1;
+    //~^ unnecessary_literal_unwrap
     let _ = 123;
+    //~^ unnecessary_literal_unwrap
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.rs b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.rs
index 7bd8deea4d1b..c0a35ae78a71 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.rs
@@ -9,73 +9,119 @@
 
 fn unwrap_option_some() {
     let _val = Some(1).unwrap();
+    //~^ unnecessary_literal_unwrap
     let _val = Some(1).expect("this never happens");
+    //~^ unnecessary_literal_unwrap
 
     Some(1).unwrap();
+    //~^ unnecessary_literal_unwrap
     Some(1).expect("this never happens");
+    //~^ unnecessary_literal_unwrap
 }
 
 #[rustfmt::skip] // force rustfmt not to remove braces in `|| { 234 }`
 fn unwrap_option_none() {
     let _val = None::<()>.unwrap();
+    //~^ unnecessary_literal_unwrap
     let _val = None::<()>.expect("this always happens");
+    //~^ unnecessary_literal_unwrap
     let _val: String = None.unwrap_or_default();
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = None.unwrap_or(234);
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = None.unwrap_or_else(|| 234);
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = None.unwrap_or_else(|| { 234 });
+    //~^ unnecessary_literal_unwrap
     let _val: u16 = None.unwrap_or_else(|| -> u16 { 234 });
+    //~^ unnecessary_literal_unwrap
 
     None::<()>.unwrap();
+    //~^ unnecessary_literal_unwrap
     None::<()>.expect("this always happens");
+    //~^ unnecessary_literal_unwrap
     None::<String>.unwrap_or_default();
+    //~^ unnecessary_literal_unwrap
     None::<u16>.unwrap_or(234);
+    //~^ unnecessary_literal_unwrap
     None::<u16>.unwrap_or_else(|| 234);
+    //~^ unnecessary_literal_unwrap
     None::<u16>.unwrap_or_else(|| { 234 });
+    //~^ unnecessary_literal_unwrap
     None::<u16>.unwrap_or_else(|| -> u16 { 234 });
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_ok() {
     let _val = Ok::<_, ()>(1).unwrap();
+    //~^ unnecessary_literal_unwrap
     let _val = Ok::<_, ()>(1).expect("this never happens");
+    //~^ unnecessary_literal_unwrap
     let _val = Ok::<_, ()>(1).unwrap_err();
+    //~^ unnecessary_literal_unwrap
     let _val = Ok::<_, ()>(1).expect_err("this always happens");
+    //~^ unnecessary_literal_unwrap
 
     Ok::<_, ()>(1).unwrap();
+    //~^ unnecessary_literal_unwrap
     Ok::<_, ()>(1).expect("this never happens");
+    //~^ unnecessary_literal_unwrap
     Ok::<_, ()>(1).unwrap_err();
+    //~^ unnecessary_literal_unwrap
     Ok::<_, ()>(1).expect_err("this always happens");
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_err() {
     let _val = Err::<(), _>(1).unwrap_err();
+    //~^ unnecessary_literal_unwrap
     let _val = Err::<(), _>(1).expect_err("this never happens");
+    //~^ unnecessary_literal_unwrap
     let _val = Err::<(), _>(1).unwrap();
+    //~^ unnecessary_literal_unwrap
     let _val = Err::<(), _>(1).expect("this always happens");
+    //~^ unnecessary_literal_unwrap
 
     Err::<(), _>(1).unwrap_err();
+    //~^ unnecessary_literal_unwrap
     Err::<(), _>(1).expect_err("this never happens");
+    //~^ unnecessary_literal_unwrap
     Err::<(), _>(1).unwrap();
+    //~^ unnecessary_literal_unwrap
     Err::<(), _>(1).expect("this always happens");
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_option() {
     let _val = Some(1).unwrap_or(2);
+    //~^ unnecessary_literal_unwrap
     let _val = Some(1).unwrap_or_default();
+    //~^ unnecessary_literal_unwrap
     let _val = Some(1).unwrap_or_else(|| 2);
+    //~^ unnecessary_literal_unwrap
 
     Some(1).unwrap_or(2);
+    //~^ unnecessary_literal_unwrap
     Some(1).unwrap_or_default();
+    //~^ unnecessary_literal_unwrap
     Some(1).unwrap_or_else(|| 2);
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_result() {
     let _val = Ok::<_, ()>(1).unwrap_or(2);
+    //~^ unnecessary_literal_unwrap
     let _val = Ok::<_, ()>(1).unwrap_or_default();
+    //~^ unnecessary_literal_unwrap
     let _val = Ok::<_, ()>(1).unwrap_or_else(|_| 2);
+    //~^ unnecessary_literal_unwrap
 
     Ok::<_, ()>(1).unwrap_or(2);
+    //~^ unnecessary_literal_unwrap
     Ok::<_, ()>(1).unwrap_or_default();
+    //~^ unnecessary_literal_unwrap
     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_from_binding() {
@@ -90,12 +136,20 @@ fn unwrap_from_binding() {
 
 fn unwrap_unchecked() {
     let _ = unsafe { Some(1).unwrap_unchecked() };
+    //~^ unnecessary_literal_unwrap
     let _ = unsafe { Some(1).unwrap_unchecked() + *(&1 as *const i32) }; // needs to keep the unsafe block
+    //
+    //~^^ unnecessary_literal_unwrap
     let _ = unsafe { Some(1).unwrap_unchecked() } + 1;
+    //~^ unnecessary_literal_unwrap
     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
+    //~^ unnecessary_literal_unwrap
     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
+    //~^ unnecessary_literal_unwrap
     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
+    //~^ unnecessary_literal_unwrap
     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
+    //~^ unnecessary_literal_unwrap
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.stderr b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.stderr
index 631bf0837266..cd90763263e9 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap.stderr
@@ -13,7 +13,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:12:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:13:16
    |
 LL |     let _val = Some(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:14:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:16:5
    |
 LL |     Some(1).unwrap();
    |     ^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     1;
    |
 
 error: used `expect()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:15:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:18:5
    |
 LL |     Some(1).expect("this never happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,13 +49,13 @@ LL +     1;
    |
 
 error: used `unwrap()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:20:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:24:16
    |
 LL |     let _val = None::<()>.unwrap();
    |                ^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
 
 error: used `expect()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:21:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:26:16
    |
 LL |     let _val = None::<()>.expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -67,13 +67,13 @@ LL +     let _val = panic!("this always happens");
    |
 
 error: used `unwrap_or_default()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:22:24
+  --> tests/ui/unnecessary_literal_unwrap.rs:28:24
    |
 LL |     let _val: String = None.unwrap_or_default();
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `String::default()`
 
 error: used `unwrap_or()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:23:21
+  --> tests/ui/unnecessary_literal_unwrap.rs:30:21
    |
 LL |     let _val: u16 = None.unwrap_or(234);
    |                     ^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     let _val: u16 = 234;
    |
 
 error: used `unwrap_or_else()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:24:21
+  --> tests/ui/unnecessary_literal_unwrap.rs:32:21
    |
 LL |     let _val: u16 = None.unwrap_or_else(|| 234);
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     let _val: u16 = 234;
    |
 
 error: used `unwrap_or_else()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:25:21
+  --> tests/ui/unnecessary_literal_unwrap.rs:34:21
    |
 LL |     let _val: u16 = None.unwrap_or_else(|| { 234 });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     let _val: u16 = { 234 };
    |
 
 error: used `unwrap_or_else()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:26:21
+  --> tests/ui/unnecessary_literal_unwrap.rs:36:21
    |
 LL |     let _val: u16 = None.unwrap_or_else(|| -> u16 { 234 });
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -121,13 +121,13 @@ LL +     let _val: u16 = { 234 };
    |
 
 error: used `unwrap()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:28:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:39:5
    |
 LL |     None::<()>.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap()`: `panic!()`
 
 error: used `expect()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:29:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:41:5
    |
 LL |     None::<()>.expect("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -139,13 +139,13 @@ LL +     panic!("this always happens");
    |
 
 error: used `unwrap_or_default()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:30:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:43:5
    |
 LL |     None::<String>.unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `String::default()`
 
 error: used `unwrap_or()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:31:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:45:5
    |
 LL |     None::<u16>.unwrap_or(234);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     234;
    |
 
 error: used `unwrap_or_else()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:32:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:47:5
    |
 LL |     None::<u16>.unwrap_or_else(|| 234);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     234;
    |
 
 error: used `unwrap_or_else()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:33:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:49:5
    |
 LL |     None::<u16>.unwrap_or_else(|| { 234 });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     { 234 };
    |
 
 error: used `unwrap_or_else()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:34:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:51:5
    |
 LL |     None::<u16>.unwrap_or_else(|| -> u16 { 234 });
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     { 234 };
    |
 
 error: used `unwrap()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:38:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:56:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^
@@ -205,7 +205,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:39:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:58:16
    |
 LL |     let _val = Ok::<_, ()>(1).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -217,7 +217,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:40:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:60:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -229,7 +229,7 @@ LL +     let _val = panic!("{:?}", 1);
    |
 
 error: used `expect_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:41:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:62:16
    |
 LL |     let _val = Ok::<_, ()>(1).expect_err("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -241,7 +241,7 @@ LL +     let _val = panic!("{1}: {:?}", 1, "this always happens");
    |
 
 error: used `unwrap()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:43:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:65:5
    |
 LL |     Ok::<_, ()>(1).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -253,7 +253,7 @@ LL +     1;
    |
 
 error: used `expect()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:44:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:67:5
    |
 LL |     Ok::<_, ()>(1).expect("this never happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -265,7 +265,7 @@ LL +     1;
    |
 
 error: used `unwrap_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:45:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:69:5
    |
 LL |     Ok::<_, ()>(1).unwrap_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -277,7 +277,7 @@ LL +     panic!("{:?}", 1);
    |
 
 error: used `expect_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:46:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:71:5
    |
 LL |     Ok::<_, ()>(1).expect_err("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -289,7 +289,7 @@ LL +     panic!("{1}: {:?}", 1, "this always happens");
    |
 
 error: used `unwrap_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:50:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:76:16
    |
 LL |     let _val = Err::<(), _>(1).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -301,7 +301,7 @@ LL +     let _val = 1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:51:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:78:16
    |
 LL |     let _val = Err::<(), _>(1).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -313,7 +313,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:52:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:80:16
    |
 LL |     let _val = Err::<(), _>(1).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -325,7 +325,7 @@ LL +     let _val = panic!("{:?}", 1);
    |
 
 error: used `expect()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:53:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:82:16
    |
 LL |     let _val = Err::<(), _>(1).expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -337,7 +337,7 @@ LL +     let _val = panic!("{1}: {:?}", 1, "this always happens");
    |
 
 error: used `unwrap_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:55:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:85:5
    |
 LL |     Err::<(), _>(1).unwrap_err();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -349,7 +349,7 @@ LL +     1;
    |
 
 error: used `expect_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:56:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:87:5
    |
 LL |     Err::<(), _>(1).expect_err("this never happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -361,7 +361,7 @@ LL +     1;
    |
 
 error: used `unwrap()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:57:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:89:5
    |
 LL |     Err::<(), _>(1).unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -373,7 +373,7 @@ LL +     panic!("{:?}", 1);
    |
 
 error: used `expect()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:58:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:91:5
    |
 LL |     Err::<(), _>(1).expect("this always happens");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -385,7 +385,7 @@ LL +     panic!("{1}: {:?}", 1, "this always happens");
    |
 
 error: used `unwrap_or()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:62:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:96:16
    |
 LL |     let _val = Some(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^
@@ -397,7 +397,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:63:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:98:16
    |
 LL |     let _val = Some(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -409,7 +409,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:64:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:100:16
    |
 LL |     let _val = Some(1).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -421,7 +421,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:66:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:103:5
    |
 LL |     Some(1).unwrap_or(2);
    |     ^^^^^^^^^^^^^^^^^^^^
@@ -433,7 +433,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_default()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:67:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:105:5
    |
 LL |     Some(1).unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -445,7 +445,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_else()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:68:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:107:5
    |
 LL |     Some(1).unwrap_or_else(|| 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -457,7 +457,7 @@ LL +     1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:72:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:112:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -469,7 +469,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:73:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:114:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -481,7 +481,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:74:16
+  --> tests/ui/unnecessary_literal_unwrap.rs:116:16
    |
 LL |     let _val = Ok::<_, ()>(1).unwrap_or_else(|_| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -493,7 +493,7 @@ LL +     let _val = 1;
    |
 
 error: used `unwrap_or()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:76:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:119:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or(2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -505,7 +505,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:77:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:121:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -517,7 +517,7 @@ LL +     1;
    |
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:78:5
+  --> tests/ui/unnecessary_literal_unwrap.rs:123:5
    |
 LL |     Ok::<_, ()>(1).unwrap_or_else(|_| 2);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -529,7 +529,7 @@ LL +     1;
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:92:22
+  --> tests/ui/unnecessary_literal_unwrap.rs:138:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -541,7 +541,7 @@ LL +     let _ = 1;
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:93:22
+  --> tests/ui/unnecessary_literal_unwrap.rs:140:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() + *(&1 as *const i32) }; // needs to keep the unsafe block
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -553,7 +553,7 @@ LL +     let _ = unsafe { 1 + *(&1 as *const i32) }; // needs to keep the unsafe
    |
 
 error: used `unwrap_unchecked()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:94:22
+  --> tests/ui/unnecessary_literal_unwrap.rs:143:22
    |
 LL |     let _ = unsafe { Some(1).unwrap_unchecked() } + 1;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -565,7 +565,7 @@ LL +     let _ = 1 + 1;
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:95:22
+  --> tests/ui/unnecessary_literal_unwrap.rs:145:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -577,7 +577,7 @@ LL +     let _ = 1;
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:96:22
+  --> tests/ui/unnecessary_literal_unwrap.rs:147:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() + *(&1 as *const i32) };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -589,7 +589,7 @@ LL +     let _ = unsafe { 1 + *(&1 as *const i32) };
    |
 
 error: used `unwrap_unchecked()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:97:22
+  --> tests/ui/unnecessary_literal_unwrap.rs:149:22
    |
 LL |     let _ = unsafe { Ok::<_, ()>(1).unwrap_unchecked() } + 1;
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -601,7 +601,7 @@ LL +     let _ = 1 + 1;
    |
 
 error: used `unwrap_err_unchecked()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap.rs:98:22
+  --> tests/ui/unnecessary_literal_unwrap.rs:151:22
    |
 LL |     let _ = unsafe { Err::<(), i32>(123).unwrap_err_unchecked() };
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.rs b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.rs
index 61058b7988a2..b6cba4e6a568 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.rs
@@ -5,154 +5,190 @@
 fn unwrap_option_some() {
     let val = Some(1);
     let _val2 = val.unwrap();
-    //~^ ERROR: used `unwrap()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect("this never happens");
-    //~^ ERROR: used `expect()` on `Some` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_option_some_context() {
     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap();
-    //~^ ERROR: used `unwrap()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Some::<usize>([1, 2, 3].iter().sum()).expect("this never happens");
-    //~^ ERROR: used `expect()` on `Some` value
+    //~^ unnecessary_literal_unwrap
 
     let val = Some::<usize>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap();
-    //~^ ERROR: used `unwrap()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect("this never happens");
-    //~^ ERROR: used `expect()` on `Some` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_option_none() {
     let val = None::<()>;
     let _val2 = val.unwrap();
-    //~^ ERROR: used `unwrap()` on `None` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect("this always happens");
-    //~^ ERROR: used `expect()` on `None` value
+    //~^ unnecessary_literal_unwrap
+
     let _val3: u8 = None.unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `None` value
+    //~^ unnecessary_literal_unwrap
+
     None::<()>.unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `None` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_ok() {
     let val = Ok::<_, ()>(1);
     let _val2 = val.unwrap();
-    //~^ ERROR: used `unwrap()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect("this never happens");
-    //~^ ERROR: used `expect()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect_err("this always happens");
-    //~^ ERROR: used `expect_err()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_ok_context() {
     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
-    //~^ ERROR: used `unwrap()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
-    //~^ ERROR: used `expect()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
-    //~^ ERROR: used `expect_err()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
 
     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap();
-    //~^ ERROR: used `unwrap()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect("this never happens");
-    //~^ ERROR: used `expect()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect_err("this always happens");
-    //~^ ERROR: used `expect_err()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_err() {
     let val = Err::<(), _>(1);
     let _val2 = val.unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect_err("this never happens");
-    //~^ ERROR: used `expect_err()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap();
-    //~^ ERROR: used `unwrap()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect("this always happens");
-    //~^ ERROR: used `expect()` on `Err` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_result_err_context() {
     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
-    //~^ ERROR: used `expect_err()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
-    //~^ ERROR: used `unwrap()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
-    //~^ ERROR: used `expect()` on `Err` value
+    //~^ unnecessary_literal_unwrap
 
     let val = Err::<(), usize>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect_err("this never happens");
-    //~^ ERROR: used `expect_err()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap();
-    //~^ ERROR: used `unwrap()` on `Err` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.expect("this always happens");
-    //~^ ERROR: used `expect()` on `Err` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_option() {
     let val = Some(1);
     let _val2 = val.unwrap_or(2);
-    //~^ ERROR: used `unwrap_or()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_else(|| 2);
-    //~^ ERROR: used `unwrap_or_else()` on `Some` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_option_context() {
     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
-    //~^ ERROR: used `unwrap_or()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
-    //~^ ERROR: used `unwrap_or_else()` on `Some` value
+    //~^ unnecessary_literal_unwrap
 
     let val = Some::<usize>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap_or(2);
-    //~^ ERROR: used `unwrap_or()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `Some` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_else(|| 2);
-    //~^ ERROR: used `unwrap_or_else()` on `Some` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_result() {
     let val = Ok::<_, ()>(1);
     let _val2 = val.unwrap_or(2);
-    //~^ ERROR: used `unwrap_or()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_else(|_| 2);
-    //~^ ERROR: used `unwrap_or_else()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn unwrap_methods_result_context() {
     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
-    //~^ ERROR: used `unwrap_or()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
-    //~^ ERROR: used `unwrap_or_else()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
 
     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
     let _val2 = val.unwrap_or(2);
-    //~^ ERROR: used `unwrap_or()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_default();
-    //~^ ERROR: used `unwrap_or_default()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
+
     let _val2 = val.unwrap_or_else(|_| 2);
-    //~^ ERROR: used `unwrap_or_else()` on `Ok` value
+    //~^ unnecessary_literal_unwrap
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.stderr b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
index b7dd7ae729fd..4994eeded776 100644
--- a/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_literal_unwrap_unfixable.stderr
@@ -13,7 +13,7 @@ LL |     let val = Some(1);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_literal_unwrap)]`
 
 error: used `expect()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:9:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:10:17
    |
 LL |     let _val2 = val.expect("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,589 +25,589 @@ LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:14:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:15:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:14:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:15:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:16:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:18:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:16:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:18:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:20:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:22:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:19:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:21:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:22:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:25:17
    |
 LL |     let _val2 = val.expect("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:19:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:21:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:28:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:31:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `None` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:27:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:30:15
    |
 LL |     let val = None::<()>;
    |               ^^^^^^^^^^
 
 error: used `expect()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:30:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:34:17
    |
 LL |     let _val2 = val.expect("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `None` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:27:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:30:15
    |
 LL |     let val = None::<()>;
    |               ^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:32:21
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:37:21
    |
 LL |     let _val3: u8 = None.unwrap_or_default();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `Default::default()`
 
 error: used `unwrap_or_default()` on `None` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:34:5
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:40:5
    |
 LL |     None::<()>.unwrap_or_default();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove the `None` and `unwrap_or_default()`: `Default::default()`
 
 error: used `unwrap()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:40:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:46:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:39:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:45:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `expect()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:42:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:49:17
    |
 LL |     let _val2 = val.expect("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:39:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:45:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:44:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:52:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:39:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:45:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:46:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:55:17
    |
 LL |     let _val2 = val.expect_err("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:39:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:45:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:51:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:60:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:51:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:60:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:53:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:63:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:53:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:63:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:55:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:66:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:55:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:66:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:57:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:69:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:57:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:69:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).expect_err("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:61:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:73:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:60:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:63:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:76:17
    |
 LL |     let _val2 = val.expect("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:60:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:65:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:79:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:60:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:67:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:82:17
    |
 LL |     let _val2 = val.expect_err("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `expect_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:60:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:73:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:88:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:87:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:75:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:91:17
    |
 LL |     let _val2 = val.expect_err("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:87:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:77:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:94:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:87:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:79:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:97:17
    |
 LL |     let _val2 = val.expect("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:72:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:87:15
    |
 LL |     let val = Err::<(), _>(1);
    |               ^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:84:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:102:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:84:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:102:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap_err();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:86:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:105:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:86:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:105:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect_err("this never happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:88:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:108:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:88:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:108:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).unwrap();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:90:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:111:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:90:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:111:16
    |
 LL |     let _val = Err::<(), usize>([1, 2, 3].iter().sum()).expect("this always happens");
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:94:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:115:17
    |
 LL |     let _val2 = val.unwrap_err();
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:93:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:114:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect_err()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:96:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:118:17
    |
 LL |     let _val2 = val.expect_err("this never happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect_err()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:93:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:114:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:98:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:121:17
    |
 LL |     let _val2 = val.unwrap();
    |                 ^^^^^^^^^^^^
    |
 help: remove the `Err` and `unwrap()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:93:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:114:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `expect()` on `Err` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:100:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:124:17
    |
 LL |     let _val2 = val.expect("this always happens");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Err` and `expect()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:93:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:114:15
    |
 LL |     let val = Err::<(), usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:106:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:130:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:105:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:129:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or_default()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:108:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:133:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_default()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:105:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:129:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or_else()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:110:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:136:17
    |
 LL |     let _val2 = val.unwrap_or_else(|| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_else()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:105:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:129:15
    |
 LL |     let val = Some(1);
    |               ^^^^^^^
 
 error: used `unwrap_or()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:115:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:141:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:115:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:141:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:117:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:144:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_default()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:117:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:144:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:119:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:147:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_else()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:119:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:147:16
    |
 LL |     let _val = Some::<usize>([1, 2, 3].iter().sum()).unwrap_or_else(|| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:123:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:151:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:122:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:150:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:125:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:154:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_default()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:122:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:150:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Some` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:127:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:157:17
    |
 LL |     let _val2 = val.unwrap_or_else(|| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Some` and `unwrap_or_else()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:122:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:150:15
    |
 LL |     let val = Some::<usize>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:133:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:163:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:132:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:162:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:135:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:166:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:132:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:162:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:137:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:169:17
    |
 LL |     let _val2 = val.unwrap_or_else(|_| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:132:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:162:15
    |
 LL |     let val = Ok::<_, ()>(1);
    |               ^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:142:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:174:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:142:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:174:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or(2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:144:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:177:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:144:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:177:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_default();
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:146:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:180:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:146:16
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:180:16
    |
 LL |     let _val = Ok::<usize, ()>([1, 2, 3].iter().sum()).unwrap_or_else(|_| 2);
    |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:150:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:184:17
    |
 LL |     let _val2 = val.unwrap_or(2);
    |                 ^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:149:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:183:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_default()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:152:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:187:17
    |
 LL |     let _val2 = val.unwrap_or_default();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_default()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:149:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:183:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used `unwrap_or_else()` on `Ok` value
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:154:17
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:190:17
    |
 LL |     let _val2 = val.unwrap_or_else(|_| 2);
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: remove the `Ok` and `unwrap_or_else()`
-  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:149:15
+  --> tests/ui/unnecessary_literal_unwrap_unfixable.rs:183:15
    |
 LL |     let val = Ok::<usize, ()>([1, 2, 3].iter().sum());
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.fixed b/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.fixed
index d0ba7ed749e4..4452fda38c40 100644
--- a/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.fixed
@@ -30,14 +30,22 @@ fn main() {
     let c: SimpleResult = Err(err);
 
     let a = Some(fun(x));
+    //~^ unnecessary_map_on_constructor
     let b: SimpleResult = Ok(fun(x));
+    //~^ unnecessary_map_on_constructor
     let c: SimpleResult = Err(notfun(err));
+    //~^ unnecessary_map_on_constructor
 
     let a = Option::Some(fun(x));
+    //~^ unnecessary_map_on_constructor
     let b: SimpleResult = SimpleResult::Ok(fun(x));
+    //~^ unnecessary_map_on_constructor
     let c: SimpleResult = SimpleResult::Err(notfun(err));
+    //~^ unnecessary_map_on_constructor
     let b: std::result::Result<i32, SimpleError> = Ok(fun(x));
+    //~^ unnecessary_map_on_constructor
     let c: std::result::Result<i32, SimpleError> = Err(notfun(err));
+    //~^ unnecessary_map_on_constructor
 
     let a = Some(fun(x));
     let b: SimpleResult = Ok(fun(x));
diff --git a/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.rs b/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.rs
index e89e7aad4c40..0cd41f2b363a 100644
--- a/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.rs
@@ -30,14 +30,22 @@ fn main() {
     let c: SimpleResult = Err(err);
 
     let a = Some(x).map(fun);
+    //~^ unnecessary_map_on_constructor
     let b: SimpleResult = Ok(x).map(fun);
+    //~^ unnecessary_map_on_constructor
     let c: SimpleResult = Err(err).map_err(notfun);
+    //~^ unnecessary_map_on_constructor
 
     let a = Option::Some(x).map(fun);
+    //~^ unnecessary_map_on_constructor
     let b: SimpleResult = SimpleResult::Ok(x).map(fun);
+    //~^ unnecessary_map_on_constructor
     let c: SimpleResult = SimpleResult::Err(err).map_err(notfun);
+    //~^ unnecessary_map_on_constructor
     let b: std::result::Result<i32, SimpleError> = Ok(x).map(fun);
+    //~^ unnecessary_map_on_constructor
     let c: std::result::Result<i32, SimpleError> = Err(err).map_err(notfun);
+    //~^ unnecessary_map_on_constructor
 
     let a = Some(fun(x));
     let b: SimpleResult = Ok(fun(x));
diff --git a/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.stderr b/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.stderr
index ecbf65244154..f29bfec60f72 100644
--- a/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_map_on_constructor.stderr
@@ -8,43 +8,43 @@ LL |     let a = Some(x).map(fun);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_map_on_constructor)]`
 
 error: unnecessary map on constructor Ok(_)
-  --> tests/ui/unnecessary_map_on_constructor.rs:33:27
+  --> tests/ui/unnecessary_map_on_constructor.rs:34:27
    |
 LL |     let b: SimpleResult = Ok(x).map(fun);
    |                           ^^^^^^^^^^^^^^ help: try: `Ok(fun(x))`
 
 error: unnecessary map_err on constructor Err(_)
-  --> tests/ui/unnecessary_map_on_constructor.rs:34:27
+  --> tests/ui/unnecessary_map_on_constructor.rs:36:27
    |
 LL |     let c: SimpleResult = Err(err).map_err(notfun);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Err(notfun(err))`
 
 error: unnecessary map on constructor Option::Some(_)
-  --> tests/ui/unnecessary_map_on_constructor.rs:36:13
+  --> tests/ui/unnecessary_map_on_constructor.rs:39:13
    |
 LL |     let a = Option::Some(x).map(fun);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Option::Some(fun(x))`
 
 error: unnecessary map on constructor SimpleResult::Ok(_)
-  --> tests/ui/unnecessary_map_on_constructor.rs:37:27
+  --> tests/ui/unnecessary_map_on_constructor.rs:41:27
    |
 LL |     let b: SimpleResult = SimpleResult::Ok(x).map(fun);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `SimpleResult::Ok(fun(x))`
 
 error: unnecessary map_err on constructor SimpleResult::Err(_)
-  --> tests/ui/unnecessary_map_on_constructor.rs:38:27
+  --> tests/ui/unnecessary_map_on_constructor.rs:43:27
    |
 LL |     let c: SimpleResult = SimpleResult::Err(err).map_err(notfun);
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `SimpleResult::Err(notfun(err))`
 
 error: unnecessary map on constructor Ok(_)
-  --> tests/ui/unnecessary_map_on_constructor.rs:39:52
+  --> tests/ui/unnecessary_map_on_constructor.rs:45:52
    |
 LL |     let b: std::result::Result<i32, SimpleError> = Ok(x).map(fun);
    |                                                    ^^^^^^^^^^^^^^ help: try: `Ok(fun(x))`
 
 error: unnecessary map_err on constructor Err(_)
-  --> tests/ui/unnecessary_map_on_constructor.rs:40:52
+  --> tests/ui/unnecessary_map_on_constructor.rs:47:52
    |
 LL |     let c: std::result::Result<i32, SimpleError> = Err(err).map_err(notfun);
    |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Err(notfun(err))`
diff --git a/src/tools/clippy/tests/ui/unnecessary_map_or.fixed b/src/tools/clippy/tests/ui/unnecessary_map_or.fixed
index 5a6e77a06b8f..3c7243972845 100644
--- a/src/tools/clippy/tests/ui/unnecessary_map_or.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_map_or.fixed
@@ -11,24 +11,39 @@ extern crate proc_macros;
 fn main() {
     // should trigger
     let _ = Some(5) == Some(5);
+    //~^ unnecessary_map_or
     let _ = Some(5) != Some(5);
+    //~^ unnecessary_map_or
     let _ = Some(5) == Some(5);
     let _ = Some(5).is_some_and(|n| {
+        //~^ unnecessary_map_or
         let _ = n;
         6 >= 5
     });
     let _ = Some(vec![5]).is_some_and(|n| n == [5]);
+    //~^ unnecessary_map_or
     let _ = Some(vec![1]).is_some_and(|n| vec![2] == n);
+    //~^ unnecessary_map_or
     let _ = Some(5).is_some_and(|n| n == n);
+    //~^ unnecessary_map_or
     let _ = Some(5).is_some_and(|n| n == if 2 > 1 { n } else { 0 });
+    //~^ unnecessary_map_or
     let _ = Ok::<Vec<i32>, i32>(vec![5]).is_ok_and(|n| n == [5]);
+    //~^ unnecessary_map_or
     let _ = Ok::<i32, i32>(5) == Ok(5);
+    //~^ unnecessary_map_or
     let _ = (Some(5) == Some(5)).then(|| 1);
+    //~^ unnecessary_map_or
     let _ = Some(5).is_none_or(|n| n == 5);
+    //~^ unnecessary_map_or
     let _ = Some(5).is_none_or(|n| 5 == n);
+    //~^ unnecessary_map_or
     let _ = !(Some(5) == Some(5));
+    //~^ unnecessary_map_or
     let _ = (Some(5) == Some(5)) || false;
+    //~^ unnecessary_map_or
     let _ = (Some(5) == Some(5)) as usize;
+    //~^ unnecessary_map_or
 
     macro_rules! x {
         () => {
@@ -53,18 +68,23 @@ fn main() {
     struct S;
     let r: Result<i32, S> = Ok(3);
     let _ = r.is_ok_and(|x| x == 7);
+    //~^ unnecessary_map_or
 
     // lint constructs that are not comparaisons as well
     let func = |_x| true;
     let r: Result<i32, S> = Ok(3);
     let _ = r.is_ok_and(func);
+    //~^ unnecessary_map_or
     let _ = Some(5).is_some_and(func);
+    //~^ unnecessary_map_or
     let _ = Some(5).is_none_or(func);
+    //~^ unnecessary_map_or
 
     #[derive(PartialEq)]
     struct S2;
     let r: Result<i32, S2> = Ok(4);
     let _ = r == Ok(8);
+    //~^ unnecessary_map_or
 
     // do not lint `Result::map_or(true, …)`
     let r: Result<i32, S2> = Ok(4);
@@ -85,6 +105,8 @@ fn msrv_1_81() {
 
 fn with_refs(o: &mut Option<u32>) -> bool {
     o.is_none_or(|n| n > 5) || (o as &Option<u32>).is_none_or(|n| n < 5)
+    //~^ unnecessary_map_or
+    //~| unnecessary_map_or
 }
 
 struct S;
@@ -98,4 +120,13 @@ impl std::ops::Deref for S {
 
 fn with_deref(o: &S) -> bool {
     o.is_none_or(|n| n > 5)
+    //~^ unnecessary_map_or
+}
+
+fn issue14201(a: Option<String>, b: Option<String>, s: &String) -> bool {
+    let x = a.is_some_and(|a| a == *s);
+    //~^ unnecessary_map_or
+    let y = b.is_none_or(|b| b == *s);
+    //~^ unnecessary_map_or
+    x && y
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_map_or.rs b/src/tools/clippy/tests/ui/unnecessary_map_or.rs
index 5ba63121659f..e734a27badab 100644
--- a/src/tools/clippy/tests/ui/unnecessary_map_or.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_map_or.rs
@@ -11,27 +11,43 @@ extern crate proc_macros;
 fn main() {
     // should trigger
     let _ = Some(5).map_or(false, |n| n == 5);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(true, |n| n != 5);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(false, |n| {
+        //~^ unnecessary_map_or
         let _ = 1;
         n == 5
     });
     let _ = Some(5).map_or(false, |n| {
+        //~^ unnecessary_map_or
         let _ = n;
         6 >= 5
     });
     let _ = Some(vec![5]).map_or(false, |n| n == [5]);
+    //~^ unnecessary_map_or
     let _ = Some(vec![1]).map_or(false, |n| vec![2] == n);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(false, |n| n == n);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(false, |n| n == if 2 > 1 { n } else { 0 });
+    //~^ unnecessary_map_or
     let _ = Ok::<Vec<i32>, i32>(vec![5]).map_or(false, |n| n == [5]);
+    //~^ unnecessary_map_or
     let _ = Ok::<i32, i32>(5).map_or(false, |n| n == 5);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(false, |n| n == 5).then(|| 1);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(true, |n| n == 5);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(true, |n| 5 == n);
+    //~^ unnecessary_map_or
     let _ = !Some(5).map_or(false, |n| n == 5);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(false, |n| n == 5) || false;
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(false, |n| n == 5) as usize;
+    //~^ unnecessary_map_or
 
     macro_rules! x {
         () => {
@@ -56,18 +72,23 @@ fn main() {
     struct S;
     let r: Result<i32, S> = Ok(3);
     let _ = r.map_or(false, |x| x == 7);
+    //~^ unnecessary_map_or
 
     // lint constructs that are not comparaisons as well
     let func = |_x| true;
     let r: Result<i32, S> = Ok(3);
     let _ = r.map_or(false, func);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(false, func);
+    //~^ unnecessary_map_or
     let _ = Some(5).map_or(true, func);
+    //~^ unnecessary_map_or
 
     #[derive(PartialEq)]
     struct S2;
     let r: Result<i32, S2> = Ok(4);
     let _ = r.map_or(false, |x| x == 8);
+    //~^ unnecessary_map_or
 
     // do not lint `Result::map_or(true, …)`
     let r: Result<i32, S2> = Ok(4);
@@ -88,6 +109,8 @@ fn msrv_1_81() {
 
 fn with_refs(o: &mut Option<u32>) -> bool {
     o.map_or(true, |n| n > 5) || (o as &Option<u32>).map_or(true, |n| n < 5)
+    //~^ unnecessary_map_or
+    //~| unnecessary_map_or
 }
 
 struct S;
@@ -101,4 +124,13 @@ impl std::ops::Deref for S {
 
 fn with_deref(o: &S) -> bool {
     o.map_or(true, |n| n > 5)
+    //~^ unnecessary_map_or
+}
+
+fn issue14201(a: Option<String>, b: Option<String>, s: &String) -> bool {
+    let x = a.map_or(false, |a| a == *s);
+    //~^ unnecessary_map_or
+    let y = b.map_or(true, |b| b == *s);
+    //~^ unnecessary_map_or
+    x && y
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_map_or.stderr b/src/tools/clippy/tests/ui/unnecessary_map_or.stderr
index 9f38b8c8d93a..0f9466a6a6b3 100644
--- a/src/tools/clippy/tests/ui/unnecessary_map_or.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_map_or.stderr
@@ -13,7 +13,7 @@ LL +     let _ = Some(5) == Some(5);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:14:13
+  --> tests/ui/unnecessary_map_or.rs:15:13
    |
 LL |     let _ = Some(5).map_or(true, |n| n != 5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,10 +25,11 @@ LL +     let _ = Some(5) != Some(5);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:15:13
+  --> tests/ui/unnecessary_map_or.rs:17:13
    |
 LL |       let _ = Some(5).map_or(false, |n| {
    |  _____________^
+LL | |
 LL | |         let _ = 1;
 LL | |         n == 5
 LL | |     });
@@ -37,6 +38,7 @@ LL | |     });
 help: use a standard comparison instead
    |
 LL -     let _ = Some(5).map_or(false, |n| {
+LL -
 LL -         let _ = 1;
 LL -         n == 5
 LL -     });
@@ -44,10 +46,11 @@ LL +     let _ = Some(5) == Some(5);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:19:13
+  --> tests/ui/unnecessary_map_or.rs:22:13
    |
 LL |       let _ = Some(5).map_or(false, |n| {
    |  _____________^
+LL | |
 LL | |         let _ = n;
 LL | |         6 >= 5
 LL | |     });
@@ -60,7 +63,7 @@ LL +     let _ = Some(5).is_some_and(|n| {
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:23:13
+  --> tests/ui/unnecessary_map_or.rs:27:13
    |
 LL |     let _ = Some(vec![5]).map_or(false, |n| n == [5]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -72,7 +75,7 @@ LL +     let _ = Some(vec![5]).is_some_and(|n| n == [5]);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:24:13
+  --> tests/ui/unnecessary_map_or.rs:29:13
    |
 LL |     let _ = Some(vec![1]).map_or(false, |n| vec![2] == n);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +87,7 @@ LL +     let _ = Some(vec![1]).is_some_and(|n| vec![2] == n);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:25:13
+  --> tests/ui/unnecessary_map_or.rs:31:13
    |
 LL |     let _ = Some(5).map_or(false, |n| n == n);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -96,7 +99,7 @@ LL +     let _ = Some(5).is_some_and(|n| n == n);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:26:13
+  --> tests/ui/unnecessary_map_or.rs:33:13
    |
 LL |     let _ = Some(5).map_or(false, |n| n == if 2 > 1 { n } else { 0 });
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -108,7 +111,7 @@ LL +     let _ = Some(5).is_some_and(|n| n == if 2 > 1 { n } else { 0 });
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:27:13
+  --> tests/ui/unnecessary_map_or.rs:35:13
    |
 LL |     let _ = Ok::<Vec<i32>, i32>(vec![5]).map_or(false, |n| n == [5]);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -120,7 +123,7 @@ LL +     let _ = Ok::<Vec<i32>, i32>(vec![5]).is_ok_and(|n| n == [5]);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:28:13
+  --> tests/ui/unnecessary_map_or.rs:37:13
    |
 LL |     let _ = Ok::<i32, i32>(5).map_or(false, |n| n == 5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -132,7 +135,7 @@ LL +     let _ = Ok::<i32, i32>(5) == Ok(5);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:29:13
+  --> tests/ui/unnecessary_map_or.rs:39:13
    |
 LL |     let _ = Some(5).map_or(false, |n| n == 5).then(|| 1);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -144,7 +147,7 @@ LL +     let _ = (Some(5) == Some(5)).then(|| 1);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:30:13
+  --> tests/ui/unnecessary_map_or.rs:41:13
    |
 LL |     let _ = Some(5).map_or(true, |n| n == 5);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -156,7 +159,7 @@ LL +     let _ = Some(5).is_none_or(|n| n == 5);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:31:13
+  --> tests/ui/unnecessary_map_or.rs:43:13
    |
 LL |     let _ = Some(5).map_or(true, |n| 5 == n);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -168,7 +171,7 @@ LL +     let _ = Some(5).is_none_or(|n| 5 == n);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:32:14
+  --> tests/ui/unnecessary_map_or.rs:45:14
    |
 LL |     let _ = !Some(5).map_or(false, |n| n == 5);
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -180,7 +183,7 @@ LL +     let _ = !(Some(5) == Some(5));
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:33:13
+  --> tests/ui/unnecessary_map_or.rs:47:13
    |
 LL |     let _ = Some(5).map_or(false, |n| n == 5) || false;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -192,7 +195,7 @@ LL +     let _ = (Some(5) == Some(5)) || false;
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:34:13
+  --> tests/ui/unnecessary_map_or.rs:49:13
    |
 LL |     let _ = Some(5).map_or(false, |n| n == 5) as usize;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -204,7 +207,7 @@ LL +     let _ = (Some(5) == Some(5)) as usize;
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:58:13
+  --> tests/ui/unnecessary_map_or.rs:74:13
    |
 LL |     let _ = r.map_or(false, |x| x == 7);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -216,7 +219,7 @@ LL +     let _ = r.is_ok_and(|x| x == 7);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:63:13
+  --> tests/ui/unnecessary_map_or.rs:80:13
    |
 LL |     let _ = r.map_or(false, func);
    |             ^^^^^^^^^^^^^^^^^^^^^
@@ -228,7 +231,7 @@ LL +     let _ = r.is_ok_and(func);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:64:13
+  --> tests/ui/unnecessary_map_or.rs:82:13
    |
 LL |     let _ = Some(5).map_or(false, func);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -240,7 +243,7 @@ LL +     let _ = Some(5).is_some_and(func);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:65:13
+  --> tests/ui/unnecessary_map_or.rs:84:13
    |
 LL |     let _ = Some(5).map_or(true, func);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -252,7 +255,7 @@ LL +     let _ = Some(5).is_none_or(func);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:70:13
+  --> tests/ui/unnecessary_map_or.rs:90:13
    |
 LL |     let _ = r.map_or(false, |x| x == 8);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -264,7 +267,7 @@ LL +     let _ = r == Ok(8);
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:90:5
+  --> tests/ui/unnecessary_map_or.rs:111:5
    |
 LL |     o.map_or(true, |n| n > 5) || (o as &Option<u32>).map_or(true, |n| n < 5)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -276,7 +279,7 @@ LL +     o.is_none_or(|n| n > 5) || (o as &Option<u32>).map_or(true, |n| n < 5)
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:90:34
+  --> tests/ui/unnecessary_map_or.rs:111:34
    |
 LL |     o.map_or(true, |n| n > 5) || (o as &Option<u32>).map_or(true, |n| n < 5)
    |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -288,7 +291,7 @@ LL +     o.map_or(true, |n| n > 5) || (o as &Option<u32>).is_none_or(|n| n < 5)
    |
 
 error: this `map_or` can be simplified
-  --> tests/ui/unnecessary_map_or.rs:103:5
+  --> tests/ui/unnecessary_map_or.rs:126:5
    |
 LL |     o.map_or(true, |n| n > 5)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -299,5 +302,29 @@ LL -     o.map_or(true, |n| n > 5)
 LL +     o.is_none_or(|n| n > 5)
    |
 
-error: aborting due to 24 previous errors
+error: this `map_or` can be simplified
+  --> tests/ui/unnecessary_map_or.rs:131:13
+   |
+LL |     let x = a.map_or(false, |a| a == *s);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use is_some_and instead
+   |
+LL -     let x = a.map_or(false, |a| a == *s);
+LL +     let x = a.is_some_and(|a| a == *s);
+   |
+
+error: this `map_or` can be simplified
+  --> tests/ui/unnecessary_map_or.rs:133:13
+   |
+LL |     let y = b.map_or(true, |b| b == *s);
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+help: use is_none_or instead
+   |
+LL -     let y = b.map_or(true, |b| b == *s);
+LL +     let y = b.is_none_or(|b| b == *s);
+   |
+
+error: aborting due to 26 previous errors
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_min_or_max.fixed b/src/tools/clippy/tests/ui/unnecessary_min_or_max.fixed
index 1f3e131516ce..2650cae5baf4 100644
--- a/src/tools/clippy/tests/ui/unnecessary_min_or_max.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_min_or_max.fixed
@@ -11,30 +11,47 @@ const X: i32 = 1;
 fn main() {
     // Both are Literals
     let _ = (-6_i32);
+    //~^ unnecessary_min_or_max
     let _ = 9;
+    //~^ unnecessary_min_or_max
     let _ = 6;
+    //~^ unnecessary_min_or_max
     let _ = 9_u32;
+    //~^ unnecessary_min_or_max
     let _ = 6;
+    //~^ unnecessary_min_or_max
     let _ = 7_u8;
+    //~^ unnecessary_min_or_max
 
     let x: u32 = 42;
     // unsigned with zero
     let _ = 0;
+    //~^ unnecessary_min_or_max
     let _ = x;
+    //~^ unnecessary_min_or_max
     let _ = 0_u32;
+    //~^ unnecessary_min_or_max
     let _ = x;
+    //~^ unnecessary_min_or_max
 
     let x: i32 = 42;
     // signed MIN
     let _ = i32::MIN;
+    //~^ unnecessary_min_or_max
     let _ = x;
+    //~^ unnecessary_min_or_max
     let _ = i32::MIN;
+    //~^ unnecessary_min_or_max
     let _ = x;
+    //~^ unnecessary_min_or_max
 
     let _ = i32::MIN - 0;
+    //~^ unnecessary_min_or_max
     let _ = x;
+    //~^ unnecessary_min_or_max
 
     let _ = i32::MIN - 0;
+    //~^ unnecessary_min_or_max
 
     // The below cases shouldn't be lint
     let mut min = u32::MAX;
diff --git a/src/tools/clippy/tests/ui/unnecessary_min_or_max.rs b/src/tools/clippy/tests/ui/unnecessary_min_or_max.rs
index 58356b9d49e7..2f3c480b3d15 100644
--- a/src/tools/clippy/tests/ui/unnecessary_min_or_max.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_min_or_max.rs
@@ -11,30 +11,47 @@ const X: i32 = 1;
 fn main() {
     // Both are Literals
     let _ = (-6_i32).min(9);
+    //~^ unnecessary_min_or_max
     let _ = (-6_i32).max(9);
+    //~^ unnecessary_min_or_max
     let _ = 9_u32.min(6);
+    //~^ unnecessary_min_or_max
     let _ = 9_u32.max(6);
+    //~^ unnecessary_min_or_max
     let _ = 6.min(7_u8);
+    //~^ unnecessary_min_or_max
     let _ = 6.max(7_u8);
+    //~^ unnecessary_min_or_max
 
     let x: u32 = 42;
     // unsigned with zero
     let _ = 0.min(x);
+    //~^ unnecessary_min_or_max
     let _ = 0.max(x);
+    //~^ unnecessary_min_or_max
     let _ = x.min(0_u32);
+    //~^ unnecessary_min_or_max
     let _ = x.max(0_u32);
+    //~^ unnecessary_min_or_max
 
     let x: i32 = 42;
     // signed MIN
     let _ = i32::MIN.min(x);
+    //~^ unnecessary_min_or_max
     let _ = i32::MIN.max(x);
+    //~^ unnecessary_min_or_max
     let _ = x.min(i32::MIN);
+    //~^ unnecessary_min_or_max
     let _ = x.max(i32::MIN);
+    //~^ unnecessary_min_or_max
 
     let _ = x.min(i32::MIN - 0);
+    //~^ unnecessary_min_or_max
     let _ = x.max(i32::MIN);
+    //~^ unnecessary_min_or_max
 
     let _ = x.min(i32::MIN - 0);
+    //~^ unnecessary_min_or_max
 
     // The below cases shouldn't be lint
     let mut min = u32::MAX;
diff --git a/src/tools/clippy/tests/ui/unnecessary_min_or_max.stderr b/src/tools/clippy/tests/ui/unnecessary_min_or_max.stderr
index f5cd31fbaf24..dfe6910dfa5c 100644
--- a/src/tools/clippy/tests/ui/unnecessary_min_or_max.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_min_or_max.stderr
@@ -8,97 +8,97 @@ LL |     let _ = (-6_i32).min(9);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_min_or_max)]`
 
 error: `(-6_i32)` is never greater than `9` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:14:13
+  --> tests/ui/unnecessary_min_or_max.rs:15:13
    |
 LL |     let _ = (-6_i32).max(9);
    |             ^^^^^^^^^^^^^^^ help: try: `9`
 
 error: `9_u32` is never smaller than `6` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:15:13
+  --> tests/ui/unnecessary_min_or_max.rs:17:13
    |
 LL |     let _ = 9_u32.min(6);
    |             ^^^^^^^^^^^^ help: try: `6`
 
 error: `9_u32` is never smaller than `6` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:16:13
+  --> tests/ui/unnecessary_min_or_max.rs:19:13
    |
 LL |     let _ = 9_u32.max(6);
    |             ^^^^^^^^^^^^ help: try: `9_u32`
 
 error: `6` is never greater than `7_u8` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:17:13
+  --> tests/ui/unnecessary_min_or_max.rs:21:13
    |
 LL |     let _ = 6.min(7_u8);
    |             ^^^^^^^^^^^ help: try: `6`
 
 error: `6` is never greater than `7_u8` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:18:13
+  --> tests/ui/unnecessary_min_or_max.rs:23:13
    |
 LL |     let _ = 6.max(7_u8);
    |             ^^^^^^^^^^^ help: try: `7_u8`
 
 error: `0` is never greater than `x` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:22:13
+  --> tests/ui/unnecessary_min_or_max.rs:28:13
    |
 LL |     let _ = 0.min(x);
    |             ^^^^^^^^ help: try: `0`
 
 error: `0` is never greater than `x` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:23:13
+  --> tests/ui/unnecessary_min_or_max.rs:30:13
    |
 LL |     let _ = 0.max(x);
    |             ^^^^^^^^ help: try: `x`
 
 error: `x` is never smaller than `0_u32` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:24:13
+  --> tests/ui/unnecessary_min_or_max.rs:32:13
    |
 LL |     let _ = x.min(0_u32);
    |             ^^^^^^^^^^^^ help: try: `0_u32`
 
 error: `x` is never smaller than `0_u32` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:25:13
+  --> tests/ui/unnecessary_min_or_max.rs:34:13
    |
 LL |     let _ = x.max(0_u32);
    |             ^^^^^^^^^^^^ help: try: `x`
 
 error: `i32::MIN` is never greater than `x` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:29:13
+  --> tests/ui/unnecessary_min_or_max.rs:39:13
    |
 LL |     let _ = i32::MIN.min(x);
    |             ^^^^^^^^^^^^^^^ help: try: `i32::MIN`
 
 error: `i32::MIN` is never greater than `x` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:30:13
+  --> tests/ui/unnecessary_min_or_max.rs:41:13
    |
 LL |     let _ = i32::MIN.max(x);
    |             ^^^^^^^^^^^^^^^ help: try: `x`
 
 error: `x` is never smaller than `i32::MIN` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:31:13
+  --> tests/ui/unnecessary_min_or_max.rs:43:13
    |
 LL |     let _ = x.min(i32::MIN);
    |             ^^^^^^^^^^^^^^^ help: try: `i32::MIN`
 
 error: `x` is never smaller than `i32::MIN` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:32:13
+  --> tests/ui/unnecessary_min_or_max.rs:45:13
    |
 LL |     let _ = x.max(i32::MIN);
    |             ^^^^^^^^^^^^^^^ help: try: `x`
 
 error: `x` is never smaller than `i32::MIN - 0` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:34:13
+  --> tests/ui/unnecessary_min_or_max.rs:48:13
    |
 LL |     let _ = x.min(i32::MIN - 0);
    |             ^^^^^^^^^^^^^^^^^^^ help: try: `i32::MIN - 0`
 
 error: `x` is never smaller than `i32::MIN` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:35:13
+  --> tests/ui/unnecessary_min_or_max.rs:50:13
    |
 LL |     let _ = x.max(i32::MIN);
    |             ^^^^^^^^^^^^^^^ help: try: `x`
 
 error: `x` is never smaller than `i32::MIN - 0` and has therefore no effect
-  --> tests/ui/unnecessary_min_or_max.rs:37:13
+  --> tests/ui/unnecessary_min_or_max.rs:53:13
    |
 LL |     let _ = x.min(i32::MIN - 0);
    |             ^^^^^^^^^^^^^^^^^^^ help: try: `i32::MIN - 0`
diff --git a/src/tools/clippy/tests/ui/unnecessary_operation.fixed b/src/tools/clippy/tests/ui/unnecessary_operation.fixed
index 006f123cbcdf..05dfb72f48d2 100644
--- a/src/tools/clippy/tests/ui/unnecessary_operation.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_operation.fixed
@@ -68,22 +68,39 @@ where
 
 fn main() {
     get_number();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     get_struct();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     5;get_number();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     5;6;get_number();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     5;get_number();
+    //~^ unnecessary_operation
     42;get_number();
+    //~^ unnecessary_operation
     assert!([42, 55].len() > get_usize());
+    //~^ unnecessary_operation
     42;get_number();
+    //~^ unnecessary_operation
     get_number();
+    //~^ unnecessary_operation
     assert!([42; 55].len() > get_usize());
+    //~^ unnecessary_operation
     get_number();
     String::from("blah");
 
@@ -124,5 +141,5 @@ const _: () = {
 
 const fn foo() {
     assert!([42, 55].len() > get_usize());
-    //~^ ERROR: unnecessary operation
+    //~^ unnecessary_operation
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_operation.rs b/src/tools/clippy/tests/ui/unnecessary_operation.rs
index b4067c740741..6ef74c3eb1c1 100644
--- a/src/tools/clippy/tests/ui/unnecessary_operation.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_operation.rs
@@ -68,26 +68,45 @@ where
 
 fn main() {
     Tuple(get_number());
+    //~^ unnecessary_operation
     Struct { field: get_number() };
+    //~^ unnecessary_operation
     Struct { ..get_struct() };
+    //~^ unnecessary_operation
     Enum::Tuple(get_number());
+    //~^ unnecessary_operation
     Enum::Struct { field: get_number() };
+    //~^ unnecessary_operation
     5 + get_number();
+    //~^ unnecessary_operation
     *&get_number();
+    //~^ unnecessary_operation
     &get_number();
+    //~^ unnecessary_operation
     (5, 6, get_number());
+    //~^ unnecessary_operation
     get_number()..;
+    //~^ unnecessary_operation
     ..get_number();
+    //~^ unnecessary_operation
     5..get_number();
+    //~^ unnecessary_operation
     [42, get_number()];
+    //~^ unnecessary_operation
     [42, 55][get_usize()];
+    //~^ unnecessary_operation
     (42, get_number()).1;
+    //~^ unnecessary_operation
     [get_number(); 55];
+    //~^ unnecessary_operation
     [42; 55][get_usize()];
+    //~^ unnecessary_operation
     {
+        //~^ unnecessary_operation
         get_number()
     };
     FooString {
+        //~^ unnecessary_operation
         s: String::from("blah"),
     };
 
@@ -128,5 +147,5 @@ const _: () = {
 
 const fn foo() {
     [42, 55][get_usize()];
-    //~^ ERROR: unnecessary operation
+    //~^ unnecessary_operation
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_operation.stderr b/src/tools/clippy/tests/ui/unnecessary_operation.stderr
index 036a9a44bbad..eb98af09e7a3 100644
--- a/src/tools/clippy/tests/ui/unnecessary_operation.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_operation.stderr
@@ -8,119 +8,121 @@ LL |     Tuple(get_number());
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_operation)]`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:71:5
+  --> tests/ui/unnecessary_operation.rs:72:5
    |
 LL |     Struct { field: get_number() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:72:5
+  --> tests/ui/unnecessary_operation.rs:74:5
    |
 LL |     Struct { ..get_struct() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_struct();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:73:5
+  --> tests/ui/unnecessary_operation.rs:76:5
    |
 LL |     Enum::Tuple(get_number());
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:74:5
+  --> tests/ui/unnecessary_operation.rs:78:5
    |
 LL |     Enum::Struct { field: get_number() };
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:75:5
+  --> tests/ui/unnecessary_operation.rs:80:5
    |
 LL |     5 + get_number();
    |     ^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:76:5
+  --> tests/ui/unnecessary_operation.rs:82:5
    |
 LL |     *&get_number();
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:77:5
+  --> tests/ui/unnecessary_operation.rs:84:5
    |
 LL |     &get_number();
    |     ^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:78:5
+  --> tests/ui/unnecessary_operation.rs:86:5
    |
 LL |     (5, 6, get_number());
    |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;6;get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:79:5
+  --> tests/ui/unnecessary_operation.rs:88:5
    |
 LL |     get_number()..;
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:80:5
+  --> tests/ui/unnecessary_operation.rs:90:5
    |
 LL |     ..get_number();
    |     ^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:81:5
+  --> tests/ui/unnecessary_operation.rs:92:5
    |
 LL |     5..get_number();
    |     ^^^^^^^^^^^^^^^^ help: statement can be reduced to: `5;get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:82:5
+  --> tests/ui/unnecessary_operation.rs:94:5
    |
 LL |     [42, get_number()];
    |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:83:5
+  --> tests/ui/unnecessary_operation.rs:96:5
    |
 LL |     [42, 55][get_usize()];
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42, 55].len() > get_usize());`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:84:5
+  --> tests/ui/unnecessary_operation.rs:98:5
    |
 LL |     (42, get_number()).1;
    |     ^^^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `42;get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:85:5
+  --> tests/ui/unnecessary_operation.rs:100:5
    |
 LL |     [get_number(); 55];
    |     ^^^^^^^^^^^^^^^^^^^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:86:5
+  --> tests/ui/unnecessary_operation.rs:102:5
    |
 LL |     [42; 55][get_usize()];
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42; 55].len() > get_usize());`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:87:5
+  --> tests/ui/unnecessary_operation.rs:104:5
    |
 LL | /     {
+LL | |
 LL | |         get_number()
 LL | |     };
    | |______^ help: statement can be reduced to: `get_number();`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:90:5
+  --> tests/ui/unnecessary_operation.rs:108:5
    |
 LL | /     FooString {
+LL | |
 LL | |         s: String::from("blah"),
 LL | |     };
    | |______^ help: statement can be reduced to: `String::from("blah");`
 
 error: unnecessary operation
-  --> tests/ui/unnecessary_operation.rs:130:5
+  --> tests/ui/unnecessary_operation.rs:149:5
    |
 LL |     [42, 55][get_usize()];
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: statement can be written as: `assert!([42, 55].len() > get_usize());`
diff --git a/src/tools/clippy/tests/ui/unnecessary_os_str_debug_formatting.rs b/src/tools/clippy/tests/ui/unnecessary_os_str_debug_formatting.rs
new file mode 100644
index 000000000000..12663ec9a528
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unnecessary_os_str_debug_formatting.rs
@@ -0,0 +1,22 @@
+#![warn(clippy::unnecessary_debug_formatting)]
+
+use std::ffi::{OsStr, OsString};
+
+fn main() {
+    let os_str = OsStr::new("abc");
+    let os_string = os_str.to_os_string();
+
+    // negative tests
+    println!("{}", os_str.display());
+    println!("{}", os_string.display());
+
+    // positive tests
+    println!("{:?}", os_str); //~ unnecessary_debug_formatting
+    println!("{:?}", os_string); //~ unnecessary_debug_formatting
+
+    println!("{os_str:?}"); //~ unnecessary_debug_formatting
+    println!("{os_string:?}"); //~ unnecessary_debug_formatting
+
+    let _: String = format!("{:?}", os_str); //~ unnecessary_debug_formatting
+    let _: String = format!("{:?}", os_string); //~ unnecessary_debug_formatting
+}
diff --git a/src/tools/clippy/tests/ui/unnecessary_os_str_debug_formatting.stderr b/src/tools/clippy/tests/ui/unnecessary_os_str_debug_formatting.stderr
new file mode 100644
index 000000000000..001309ab817a
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unnecessary_os_str_debug_formatting.stderr
@@ -0,0 +1,58 @@
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_os_str_debug_formatting.rs:14:22
+   |
+LL |     println!("{:?}", os_str);
+   |                      ^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_str.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+   = note: `-D clippy::unnecessary-debug-formatting` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_debug_formatting)]`
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_os_str_debug_formatting.rs:15:22
+   |
+LL |     println!("{:?}", os_string);
+   |                      ^^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_string.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_os_str_debug_formatting.rs:17:16
+   |
+LL |     println!("{os_str:?}");
+   |                ^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_str.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_os_str_debug_formatting.rs:18:16
+   |
+LL |     println!("{os_string:?}");
+   |                ^^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_string.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `format!` args
+  --> tests/ui/unnecessary_os_str_debug_formatting.rs:20:37
+   |
+LL |     let _: String = format!("{:?}", os_str);
+   |                                     ^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_str.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `format!` args
+  --> tests/ui/unnecessary_os_str_debug_formatting.rs:21:37
+   |
+LL |     let _: String = format!("{:?}", os_string);
+   |                                     ^^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_string.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: aborting due to 6 previous errors
+
diff --git a/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.fixed b/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.fixed
index 75cd63db8a1a..dc0e495be30f 100644
--- a/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.fixed
@@ -8,10 +8,12 @@ fn ref_string_argument(_value: &String) {}
 fn main() {
     // should be linted
     ref_str_argument("");
+    //~^ unnecessary_owned_empty_strings
 
     // should be linted
     #[allow(clippy::manual_string_new)]
     ref_str_argument("");
+    //~^ unnecessary_owned_empty_strings
 
     // should not be linted
     ref_str_argument("");
diff --git a/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.rs b/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.rs
index 2edc0bd86d38..e2c5de447444 100644
--- a/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.rs
@@ -8,10 +8,12 @@ fn ref_string_argument(_value: &String) {}
 fn main() {
     // should be linted
     ref_str_argument(&String::new());
+    //~^ unnecessary_owned_empty_strings
 
     // should be linted
     #[allow(clippy::manual_string_new)]
     ref_str_argument(&String::from(""));
+    //~^ unnecessary_owned_empty_strings
 
     // should not be linted
     ref_str_argument("");
diff --git a/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.stderr b/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.stderr
index 1820ea4ef5d8..8bcf3ee88765 100644
--- a/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_owned_empty_strings.stderr
@@ -8,7 +8,7 @@ LL |     ref_str_argument(&String::new());
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_owned_empty_strings)]`
 
 error: usage of `&String::from("")` for a function expecting a `&str` argument
-  --> tests/ui/unnecessary_owned_empty_strings.rs:14:22
+  --> tests/ui/unnecessary_owned_empty_strings.rs:15:22
    |
 LL |     ref_str_argument(&String::from(""));
    |                      ^^^^^^^^^^^^^^^^^ help: try: `""`
diff --git a/src/tools/clippy/tests/ui/unnecessary_path_debug_formatting.rs b/src/tools/clippy/tests/ui/unnecessary_path_debug_formatting.rs
new file mode 100644
index 000000000000..02adeece2809
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unnecessary_path_debug_formatting.rs
@@ -0,0 +1,43 @@
+#![warn(clippy::unnecessary_debug_formatting)]
+
+use std::ffi::{OsStr, OsString};
+use std::ops::Deref;
+use std::path::{Path, PathBuf};
+
+struct DerefPath<'a> {
+    path: &'a Path,
+}
+
+impl Deref for DerefPath<'_> {
+    type Target = Path;
+    fn deref(&self) -> &Self::Target {
+        self.path
+    }
+}
+
+fn main() {
+    let path = Path::new("/a/b/c");
+    let path_buf = path.to_path_buf();
+    let os_str = OsStr::new("abc");
+    let os_string = os_str.to_os_string();
+
+    // negative tests
+    println!("{}", path.display());
+    println!("{}", path_buf.display());
+
+    // positive tests
+    println!("{:?}", os_str); //~ unnecessary_debug_formatting
+    println!("{:?}", os_string); //~ unnecessary_debug_formatting
+
+    println!("{:?}", path); //~ unnecessary_debug_formatting
+    println!("{:?}", path_buf); //~ unnecessary_debug_formatting
+
+    println!("{path:?}"); //~ unnecessary_debug_formatting
+    println!("{path_buf:?}"); //~ unnecessary_debug_formatting
+
+    let _: String = format!("{:?}", path); //~ unnecessary_debug_formatting
+    let _: String = format!("{:?}", path_buf); //~ unnecessary_debug_formatting
+
+    let deref_path = DerefPath { path };
+    println!("{:?}", &*deref_path); //~ unnecessary_debug_formatting
+}
diff --git a/src/tools/clippy/tests/ui/unnecessary_path_debug_formatting.stderr b/src/tools/clippy/tests/ui/unnecessary_path_debug_formatting.stderr
new file mode 100644
index 000000000000..f12fa72c84b3
--- /dev/null
+++ b/src/tools/clippy/tests/ui/unnecessary_path_debug_formatting.stderr
@@ -0,0 +1,85 @@
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:29:22
+   |
+LL |     println!("{:?}", os_str);
+   |                      ^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_str.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+   = note: `-D clippy::unnecessary-debug-formatting` implied by `-D warnings`
+   = help: to override `-D warnings` add `#[allow(clippy::unnecessary_debug_formatting)]`
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:30:22
+   |
+LL |     println!("{:?}", os_string);
+   |                      ^^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `os_string.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:32:22
+   |
+LL |     println!("{:?}", path);
+   |                      ^^^^
+   |
+   = help: use `Display` formatting and change this to `path.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:33:22
+   |
+LL |     println!("{:?}", path_buf);
+   |                      ^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `path_buf.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:35:16
+   |
+LL |     println!("{path:?}");
+   |                ^^^^
+   |
+   = help: use `Display` formatting and change this to `path.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:36:16
+   |
+LL |     println!("{path_buf:?}");
+   |                ^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `path_buf.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `format!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:38:37
+   |
+LL |     let _: String = format!("{:?}", path);
+   |                                     ^^^^
+   |
+   = help: use `Display` formatting and change this to `path.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `format!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:39:37
+   |
+LL |     let _: String = format!("{:?}", path_buf);
+   |                                     ^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `path_buf.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: unnecessary `Debug` formatting in `println!` args
+  --> tests/ui/unnecessary_path_debug_formatting.rs:42:22
+   |
+LL |     println!("{:?}", &*deref_path);
+   |                      ^^^^^^^^^^^^
+   |
+   = help: use `Display` formatting and change this to `&*deref_path.display()`
+   = note: switching to `Display` formatting will change how the value is shown; escaped characters will no longer be escaped and surrounding quotes will be removed
+
+error: aborting due to 9 previous errors
+
diff --git a/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.fixed b/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.fixed
index 224e0b52d75d..5d7e3fa355fd 100644
--- a/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.fixed
@@ -3,16 +3,19 @@
 
 fn main() {
     let x: Result<(), ()> = Ok(());
-    x.unwrap_or_else(|err| err); //~ ERROR: unused "map closure" when calling
+    x.unwrap_or_else(|err| err);
+    //~^ unnecessary_result_map_or_else
 
     // Type ascribtion.
     let x: Result<(), ()> = Ok(());
-    x.unwrap_or_else(|err: ()| err); //~ ERROR: unused "map closure" when calling
+    x.unwrap_or_else(|err: ()| err);
+    //~^ unnecessary_result_map_or_else
 
     // Auto-deref.
     let y = String::new();
     let x: Result<&String, &String> = Ok(&y);
-    let y: &str = x.unwrap_or_else(|err| err); //~ ERROR: unused "map closure" when calling
+    let y: &str = x.unwrap_or_else(|err| err);
+    //~^ unnecessary_result_map_or_else
 
     // Temporary variable.
     let x: Result<(), ()> = Ok(());
diff --git a/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.rs b/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.rs
index 4fe950a4cfa6..d2bab0f9d9c1 100644
--- a/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.rs
@@ -3,21 +3,24 @@
 
 fn main() {
     let x: Result<(), ()> = Ok(());
-    x.map_or_else(|err| err, |n| n); //~ ERROR: unused "map closure" when calling
+    x.map_or_else(|err| err, |n| n);
+    //~^ unnecessary_result_map_or_else
 
     // Type ascribtion.
     let x: Result<(), ()> = Ok(());
-    x.map_or_else(|err: ()| err, |n: ()| n); //~ ERROR: unused "map closure" when calling
+    x.map_or_else(|err: ()| err, |n: ()| n);
+    //~^ unnecessary_result_map_or_else
 
     // Auto-deref.
     let y = String::new();
     let x: Result<&String, &String> = Ok(&y);
-    let y: &str = x.map_or_else(|err| err, |n| n); //~ ERROR: unused "map closure" when calling
+    let y: &str = x.map_or_else(|err| err, |n| n);
+    //~^ unnecessary_result_map_or_else
 
     // Temporary variable.
     let x: Result<(), ()> = Ok(());
     x.map_or_else(
-        //~^ ERROR: unused "map closure" when calling
+        //~^ unnecessary_result_map_or_else
         |err| err,
         |n| {
             let tmp = n;
diff --git a/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.stderr b/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.stderr
index e3a6dbf8ecd8..e6afa50217cc 100644
--- a/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_result_map_or_else.stderr
@@ -8,19 +8,19 @@ LL |     x.map_or_else(|err| err, |n| n);
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_result_map_or_else)]`
 
 error: unused "map closure" when calling `Result::map_or_else` value
-  --> tests/ui/unnecessary_result_map_or_else.rs:10:5
+  --> tests/ui/unnecessary_result_map_or_else.rs:11:5
    |
 LL |     x.map_or_else(|err: ()| err, |n: ()| n);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `x.unwrap_or_else(|err: ()| err)`
 
 error: unused "map closure" when calling `Result::map_or_else` value
-  --> tests/ui/unnecessary_result_map_or_else.rs:15:19
+  --> tests/ui/unnecessary_result_map_or_else.rs:17:19
    |
 LL |     let y: &str = x.map_or_else(|err| err, |n| n);
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using `unwrap_or_else`: `x.unwrap_or_else(|err| err)`
 
 error: unused "map closure" when calling `Result::map_or_else` value
-  --> tests/ui/unnecessary_result_map_or_else.rs:19:5
+  --> tests/ui/unnecessary_result_map_or_else.rs:22:5
    |
 LL | /     x.map_or_else(
 LL | |
diff --git a/src/tools/clippy/tests/ui/unnecessary_safety_comment.rs b/src/tools/clippy/tests/ui/unnecessary_safety_comment.rs
index bdc6fa0f46bb..4440089b3633 100644
--- a/src/tools/clippy/tests/ui/unnecessary_safety_comment.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_safety_comment.rs
@@ -4,19 +4,23 @@
 mod unsafe_items_invalid_comment {
     // SAFETY:
     const CONST: u32 = 0;
-    //~^ ERROR: constant item has unnecessary safety comment
+    //~^ unnecessary_safety_comment
+
     // SAFETY:
     static STATIC: u32 = 0;
-    //~^ ERROR: static item has unnecessary safety comment
+    //~^ unnecessary_safety_comment
+
     // SAFETY:
     struct Struct;
-    //~^ ERROR: struct has unnecessary safety comment
+    //~^ unnecessary_safety_comment
+
     // SAFETY:
     enum Enum {}
-    //~^ ERROR: enum has unnecessary safety comment
+    //~^ unnecessary_safety_comment
+
     // SAFETY:
     mod module {}
-    //~^ ERROR: module has unnecessary safety comment
+    //~^ unnecessary_safety_comment
 }
 
 mod unnecessary_from_macro {
@@ -36,6 +40,7 @@ mod unnecessary_from_macro {
         ($t:ty) => {
             // Safety: unnecessary
             impl T for $t {}
+            //~^ unnecessary_safety_comment
         };
     }
 
@@ -45,15 +50,15 @@ mod unnecessary_from_macro {
 fn unnecessary_on_stmt_and_expr() -> u32 {
     // SAFETY: unnecessary
     let num = 42;
-    //~^ ERROR: statement has unnecessary safety comment
+    //~^ unnecessary_safety_comment
 
     // SAFETY: unnecessary
     if num > 24 {}
-    //~^ ERROR: statement has unnecessary safety comment
+    //~^ unnecessary_safety_comment
 
     // SAFETY: unnecessary
     24
-    //~^ ERROR: expression has unnecessary safety comment
+    //~^ unnecessary_safety_comment
 }
 
 mod issue_10084 {
diff --git a/src/tools/clippy/tests/ui/unnecessary_safety_comment.stderr b/src/tools/clippy/tests/ui/unnecessary_safety_comment.stderr
index 139ed769975b..b56e8b354931 100644
--- a/src/tools/clippy/tests/ui/unnecessary_safety_comment.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_safety_comment.stderr
@@ -13,55 +13,55 @@ LL |     // SAFETY:
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_comment)]`
 
 error: static item has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:9:5
+  --> tests/ui/unnecessary_safety_comment.rs:10:5
    |
 LL |     static STATIC: u32 = 0;
    |     ^^^^^^^^^^^^^^^^^^^^^^^
    |
 help: consider removing the safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:8:5
+  --> tests/ui/unnecessary_safety_comment.rs:9:5
    |
 LL |     // SAFETY:
    |     ^^^^^^^^^^
 
 error: struct has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:12:5
+  --> tests/ui/unnecessary_safety_comment.rs:14:5
    |
 LL |     struct Struct;
    |     ^^^^^^^^^^^^^^
    |
 help: consider removing the safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:11:5
+  --> tests/ui/unnecessary_safety_comment.rs:13:5
    |
 LL |     // SAFETY:
    |     ^^^^^^^^^^
 
 error: enum has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:15:5
+  --> tests/ui/unnecessary_safety_comment.rs:18:5
    |
 LL |     enum Enum {}
    |     ^^^^^^^^^^^^
    |
-help: consider removing the safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:14:5
-   |
-LL |     // SAFETY:
-   |     ^^^^^^^^^^
-
-error: module has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:18:5
-   |
-LL |     mod module {}
-   |     ^^^^^^^^^^^^^
-   |
 help: consider removing the safety comment
   --> tests/ui/unnecessary_safety_comment.rs:17:5
    |
 LL |     // SAFETY:
    |     ^^^^^^^^^^
 
+error: module has unnecessary safety comment
+  --> tests/ui/unnecessary_safety_comment.rs:22:5
+   |
+LL |     mod module {}
+   |     ^^^^^^^^^^^^^
+   |
+help: consider removing the safety comment
+  --> tests/ui/unnecessary_safety_comment.rs:21:5
+   |
+LL |     // SAFETY:
+   |     ^^^^^^^^^^
+
 error: impl has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:38:13
+  --> tests/ui/unnecessary_safety_comment.rs:42:13
    |
 LL |             impl T for $t {}
    |             ^^^^^^^^^^^^^^^^
@@ -70,44 +70,44 @@ LL |     with_safety_comment!(i32);
    |     ------------------------- in this macro invocation
    |
 help: consider removing the safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:37:13
+  --> tests/ui/unnecessary_safety_comment.rs:41:13
    |
 LL |             // Safety: unnecessary
    |             ^^^^^^^^^^^^^^^^^^^^^^
    = note: this error originates in the macro `with_safety_comment` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: expression has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:55:5
+  --> tests/ui/unnecessary_safety_comment.rs:60:5
    |
 LL |     24
    |     ^^
    |
 help: consider removing the safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:54:5
+  --> tests/ui/unnecessary_safety_comment.rs:59:5
    |
 LL |     // SAFETY: unnecessary
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:47:5
+  --> tests/ui/unnecessary_safety_comment.rs:52:5
    |
 LL |     let num = 42;
    |     ^^^^^^^^^^^^^
    |
 help: consider removing the safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:46:5
+  --> tests/ui/unnecessary_safety_comment.rs:51:5
    |
 LL |     // SAFETY: unnecessary
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: statement has unnecessary safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:51:5
+  --> tests/ui/unnecessary_safety_comment.rs:56:5
    |
 LL |     if num > 24 {}
    |     ^^^^^^^^^^^^^^
    |
 help: consider removing the safety comment
-  --> tests/ui/unnecessary_safety_comment.rs:50:5
+  --> tests/ui/unnecessary_safety_comment.rs:55:5
    |
 LL |     // SAFETY: unnecessary
    |     ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_self_imports.fixed b/src/tools/clippy/tests/ui/unnecessary_self_imports.fixed
index c265dcd2414f..0fd74705bde0 100644
--- a/src/tools/clippy/tests/ui/unnecessary_self_imports.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_self_imports.fixed
@@ -3,7 +3,9 @@
 
 use std::collections::hash_map::{self, *};
 use std::fs as alias;
+//~^ unnecessary_self_imports
 use std::io::{self, Read};
 use std::rc;
+//~^ unnecessary_self_imports
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/unnecessary_self_imports.rs b/src/tools/clippy/tests/ui/unnecessary_self_imports.rs
index c3fcf7c951a1..d09c5fcb8caa 100644
--- a/src/tools/clippy/tests/ui/unnecessary_self_imports.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_self_imports.rs
@@ -3,7 +3,9 @@
 
 use std::collections::hash_map::{self, *};
 use std::fs::{self as alias};
+//~^ unnecessary_self_imports
 use std::io::{self, Read};
 use std::rc::{self};
+//~^ unnecessary_self_imports
 
 fn main() {}
diff --git a/src/tools/clippy/tests/ui/unnecessary_self_imports.stderr b/src/tools/clippy/tests/ui/unnecessary_self_imports.stderr
index 9b143b48c9a6..1bb22c46a6c1 100644
--- a/src/tools/clippy/tests/ui/unnecessary_self_imports.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_self_imports.stderr
@@ -11,7 +11,7 @@ LL | use std::fs::{self as alias};
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_self_imports)]`
 
 error: import ending with `::{self}`
-  --> tests/ui/unnecessary_self_imports.rs:7:1
+  --> tests/ui/unnecessary_self_imports.rs:8:1
    |
 LL | use std::rc::{self};
    | ^^^^^^^^^-----------
diff --git a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.fixed b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.fixed
index 343c88b98155..f10d804c8ccc 100644
--- a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.fixed
@@ -27,13 +27,13 @@ fn main() {
     if a == 2 {
         println!("This is weird");
     }
-    //~^ ERROR: unnecessary semicolon
+    //~^ unnecessary_semicolon
 
     a.match {
         3 => println!("three"),
         _ => println!("not three"),
     }
-    //~^ ERROR: unnecessary semicolon
+    //~^ unnecessary_semicolon
 }
 
 // This is a problem in edition 2021 and below
@@ -45,6 +45,7 @@ fn borrow_issue() {
         },
         None => {},
     };
+    //~[edition2024]^ unnecessary_semicolon
 }
 
 fn no_borrow_issue(a: u32, b: u32) {
@@ -54,6 +55,7 @@ fn no_borrow_issue(a: u32, b: u32) {
         },
         None => {},
     }
+    //~^ unnecessary_semicolon
 }
 
 fn issue14100() -> bool {
diff --git a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.stderr b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.stderr
index ccff33084172..a3b139f73805 100644
--- a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2021.stderr
@@ -14,7 +14,7 @@ LL |     };
    |      ^ help: remove
 
 error: unnecessary semicolon
-  --> tests/ui/unnecessary_semicolon.rs:56:6
+  --> tests/ui/unnecessary_semicolon.rs:57:6
    |
 LL |     };
    |      ^ help: remove
diff --git a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.fixed b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.fixed
index 1cba5760eb0a..32a3bb9b4081 100644
--- a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.fixed
@@ -27,13 +27,13 @@ fn main() {
     if a == 2 {
         println!("This is weird");
     }
-    //~^ ERROR: unnecessary semicolon
+    //~^ unnecessary_semicolon
 
     a.match {
         3 => println!("three"),
         _ => println!("not three"),
     }
-    //~^ ERROR: unnecessary semicolon
+    //~^ unnecessary_semicolon
 }
 
 // This is a problem in edition 2021 and below
@@ -45,6 +45,7 @@ fn borrow_issue() {
         },
         None => {},
     }
+    //~[edition2024]^ unnecessary_semicolon
 }
 
 fn no_borrow_issue(a: u32, b: u32) {
@@ -54,6 +55,7 @@ fn no_borrow_issue(a: u32, b: u32) {
         },
         None => {},
     }
+    //~^ unnecessary_semicolon
 }
 
 fn issue14100() -> bool {
diff --git a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.stderr b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.stderr
index 4e526af2147d..d5ccae7fdf58 100644
--- a/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_semicolon.edition2024.stderr
@@ -20,7 +20,7 @@ LL |     };
    |      ^ help: remove
 
 error: unnecessary semicolon
-  --> tests/ui/unnecessary_semicolon.rs:56:6
+  --> tests/ui/unnecessary_semicolon.rs:57:6
    |
 LL |     };
    |      ^ help: remove
diff --git a/src/tools/clippy/tests/ui/unnecessary_semicolon.rs b/src/tools/clippy/tests/ui/unnecessary_semicolon.rs
index 6abbbd79aaf2..91b282180224 100644
--- a/src/tools/clippy/tests/ui/unnecessary_semicolon.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_semicolon.rs
@@ -27,13 +27,13 @@ fn main() {
     if a == 2 {
         println!("This is weird");
     };
-    //~^ ERROR: unnecessary semicolon
+    //~^ unnecessary_semicolon
 
     a.match {
         3 => println!("three"),
         _ => println!("not three"),
     };
-    //~^ ERROR: unnecessary semicolon
+    //~^ unnecessary_semicolon
 }
 
 // This is a problem in edition 2021 and below
@@ -45,6 +45,7 @@ fn borrow_issue() {
         },
         None => {},
     };
+    //~[edition2024]^ unnecessary_semicolon
 }
 
 fn no_borrow_issue(a: u32, b: u32) {
@@ -54,6 +55,7 @@ fn no_borrow_issue(a: u32, b: u32) {
         },
         None => {},
     };
+    //~^ unnecessary_semicolon
 }
 
 fn issue14100() -> bool {
diff --git a/src/tools/clippy/tests/ui/unnecessary_sort_by.fixed b/src/tools/clippy/tests/ui/unnecessary_sort_by.fixed
index 6b667e00c978..5255ab173efb 100644
--- a/src/tools/clippy/tests/ui/unnecessary_sort_by.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_sort_by.fixed
@@ -10,13 +10,19 @@ fn unnecessary_sort_by() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     // Forward examples
     vec.sort();
+    //~^ unnecessary_sort_by
     vec.sort_unstable();
+    //~^ unnecessary_sort_by
     vec.sort_by_key(|a| (a + 5).abs());
+    //~^ unnecessary_sort_by
     vec.sort_unstable_by_key(|a| id(-a));
+    //~^ unnecessary_sort_by
     // Reverse examples
     vec.sort_by(|a, b| b.cmp(a)); // not linted to avoid suggesting `Reverse(b)` which would borrow
     vec.sort_by_key(|b| std::cmp::Reverse((b + 5).abs()));
+    //~^ unnecessary_sort_by
     vec.sort_unstable_by_key(|b| std::cmp::Reverse(id(-b)));
+    //~^ unnecessary_sort_by
     // Negative examples (shouldn't be changed)
     let c = &7;
     vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
@@ -27,7 +33,9 @@ fn unnecessary_sort_by() {
     // Vectors of references are fine as long as the resulting key does not borrow
     let mut vec: Vec<&&&isize> = vec![&&&3, &&&6, &&&1, &&&2, &&&5];
     vec.sort_by_key(|a| (***a).abs());
+    //~^ unnecessary_sort_by
     vec.sort_unstable_by_key(|a| (***a).abs());
+    //~^ unnecessary_sort_by
     // `Reverse(b)` would borrow in the following cases, don't lint
     vec.sort_by(|a, b| b.cmp(a));
     vec.sort_unstable_by(|a, b| b.cmp(a));
@@ -87,10 +95,14 @@ mod issue_6001 {
 
         // Forward
         args.sort_by_key(|a| a.name());
+        //~^ unnecessary_sort_by
         args.sort_unstable_by_key(|a| a.name());
+        //~^ unnecessary_sort_by
         // Reverse
         args.sort_by_key(|b| std::cmp::Reverse(b.name()));
+        //~^ unnecessary_sort_by
         args.sort_unstable_by_key(|b| std::cmp::Reverse(b.name()));
+        //~^ unnecessary_sort_by
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_sort_by.rs b/src/tools/clippy/tests/ui/unnecessary_sort_by.rs
index 0ff20fb9ef28..65db7ca3f137 100644
--- a/src/tools/clippy/tests/ui/unnecessary_sort_by.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_sort_by.rs
@@ -10,13 +10,19 @@ fn unnecessary_sort_by() {
     let mut vec: Vec<isize> = vec![3, 6, 1, 2, 5];
     // Forward examples
     vec.sort_by(|a, b| a.cmp(b));
+    //~^ unnecessary_sort_by
     vec.sort_unstable_by(|a, b| a.cmp(b));
+    //~^ unnecessary_sort_by
     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
+    //~^ unnecessary_sort_by
     vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
+    //~^ unnecessary_sort_by
     // Reverse examples
     vec.sort_by(|a, b| b.cmp(a)); // not linted to avoid suggesting `Reverse(b)` which would borrow
     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
+    //~^ unnecessary_sort_by
     vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
+    //~^ unnecessary_sort_by
     // Negative examples (shouldn't be changed)
     let c = &7;
     vec.sort_by(|a, b| (b - a).cmp(&(a - b)));
@@ -27,7 +33,9 @@ fn unnecessary_sort_by() {
     // Vectors of references are fine as long as the resulting key does not borrow
     let mut vec: Vec<&&&isize> = vec![&&&3, &&&6, &&&1, &&&2, &&&5];
     vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    //~^ unnecessary_sort_by
     vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
+    //~^ unnecessary_sort_by
     // `Reverse(b)` would borrow in the following cases, don't lint
     vec.sort_by(|a, b| b.cmp(a));
     vec.sort_unstable_by(|a, b| b.cmp(a));
@@ -87,10 +95,14 @@ mod issue_6001 {
 
         // Forward
         args.sort_by(|a, b| a.name().cmp(&b.name()));
+        //~^ unnecessary_sort_by
         args.sort_unstable_by(|a, b| a.name().cmp(&b.name()));
+        //~^ unnecessary_sort_by
         // Reverse
         args.sort_by(|a, b| b.name().cmp(&a.name()));
+        //~^ unnecessary_sort_by
         args.sort_unstable_by(|a, b| b.name().cmp(&a.name()));
+        //~^ unnecessary_sort_by
     }
 }
 
diff --git a/src/tools/clippy/tests/ui/unnecessary_sort_by.stderr b/src/tools/clippy/tests/ui/unnecessary_sort_by.stderr
index e2013a4e6f9d..9a38d3746da8 100644
--- a/src/tools/clippy/tests/ui/unnecessary_sort_by.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_sort_by.stderr
@@ -8,67 +8,67 @@ LL |     vec.sort_by(|a, b| a.cmp(b));
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_sort_by)]`
 
 error: consider using `sort`
-  --> tests/ui/unnecessary_sort_by.rs:13:5
+  --> tests/ui/unnecessary_sort_by.rs:14:5
    |
 LL |     vec.sort_unstable_by(|a, b| a.cmp(b));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable()`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:14:5
+  --> tests/ui/unnecessary_sort_by.rs:16:5
    |
 LL |     vec.sort_by(|a, b| (a + 5).abs().cmp(&(b + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| (a + 5).abs())`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:15:5
+  --> tests/ui/unnecessary_sort_by.rs:18:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-a).cmp(&id(-b)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|a| id(-a))`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:18:5
+  --> tests/ui/unnecessary_sort_by.rs:22:5
    |
 LL |     vec.sort_by(|a, b| (b + 5).abs().cmp(&(a + 5).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|b| std::cmp::Reverse((b + 5).abs()))`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:19:5
+  --> tests/ui/unnecessary_sort_by.rs:24:5
    |
 LL |     vec.sort_unstable_by(|a, b| id(-b).cmp(&id(-a)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|b| std::cmp::Reverse(id(-b)))`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:29:5
+  --> tests/ui/unnecessary_sort_by.rs:35:5
    |
 LL |     vec.sort_by(|a, b| (***a).abs().cmp(&(***b).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|a| (***a).abs())`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:30:5
+  --> tests/ui/unnecessary_sort_by.rs:37:5
    |
 LL |     vec.sort_unstable_by(|a, b| (***a).abs().cmp(&(***b).abs()));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_unstable_by_key(|a| (***a).abs())`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:89:9
+  --> tests/ui/unnecessary_sort_by.rs:97:9
    |
 LL |         args.sort_by(|a, b| a.name().cmp(&b.name()));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_by_key(|a| a.name())`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:90:9
+  --> tests/ui/unnecessary_sort_by.rs:99:9
    |
 LL |         args.sort_unstable_by(|a, b| a.name().cmp(&b.name()));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_unstable_by_key(|a| a.name())`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:92:9
+  --> tests/ui/unnecessary_sort_by.rs:102:9
    |
 LL |         args.sort_by(|a, b| b.name().cmp(&a.name()));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_by_key(|b| std::cmp::Reverse(b.name()))`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by.rs:93:9
+  --> tests/ui/unnecessary_sort_by.rs:104:9
    |
 LL |         args.sort_unstable_by(|a, b| b.name().cmp(&a.name()));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `args.sort_unstable_by_key(|b| std::cmp::Reverse(b.name()))`
diff --git a/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.fixed b/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.fixed
index c7be000b820c..40e6aecd1b6d 100644
--- a/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.fixed
@@ -8,6 +8,7 @@ fn issue_11524() -> Vec<i32> {
 
     // Should lint and suggest `vec.sort_by_key(|a| a + 1);`
     vec.sort_by_key(|a| a + 1);
+    //~^ unnecessary_sort_by
     vec
 }
 
@@ -16,5 +17,6 @@ fn issue_11524_2() -> Vec<i32> {
 
     // Should lint and suggest `vec.sort_by_key(|b| core::cmp::Reverse(b + 1));`
     vec.sort_by_key(|b| core::cmp::Reverse(b + 1));
+    //~^ unnecessary_sort_by
     vec
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.rs b/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.rs
index 5f44be97c61f..184c90d959eb 100644
--- a/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.rs
@@ -8,6 +8,7 @@ fn issue_11524() -> Vec<i32> {
 
     // Should lint and suggest `vec.sort_by_key(|a| a + 1);`
     vec.sort_by(|a, b| (a + 1).cmp(&(b + 1)));
+    //~^ unnecessary_sort_by
     vec
 }
 
@@ -16,5 +17,6 @@ fn issue_11524_2() -> Vec<i32> {
 
     // Should lint and suggest `vec.sort_by_key(|b| core::cmp::Reverse(b + 1));`
     vec.sort_by(|a, b| (b + 1).cmp(&(a + 1)));
+    //~^ unnecessary_sort_by
     vec
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.stderr b/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.stderr
index a57fbc7a6328..de3ef4123514 100644
--- a/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_sort_by_no_std.stderr
@@ -8,7 +8,7 @@ LL |     vec.sort_by(|a, b| (a + 1).cmp(&(b + 1)));
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_sort_by)]`
 
 error: consider using `sort_by_key`
-  --> tests/ui/unnecessary_sort_by_no_std.rs:18:5
+  --> tests/ui/unnecessary_sort_by_no_std.rs:19:5
    |
 LL |     vec.sort_by(|a, b| (b + 1).cmp(&(a + 1)));
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `vec.sort_by_key(|b| core::cmp::Reverse(b + 1))`
diff --git a/src/tools/clippy/tests/ui/unnecessary_struct_initialization.fixed b/src/tools/clippy/tests/ui/unnecessary_struct_initialization.fixed
index b0e8f4546353..07dc90acfa30 100644
--- a/src/tools/clippy/tests/ui/unnecessary_struct_initialization.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_struct_initialization.fixed
@@ -35,6 +35,7 @@ impl Clone for V {
     fn clone(&self) -> Self {
         // Lint: `Self` implements `Copy`
         *self
+        //~^ unnecessary_struct_initialization
     }
 }
 
@@ -42,9 +43,11 @@ fn main() {
     // Should lint: `a` would be consumed anyway
     let a = S { f: String::from("foo") };
     let mut b = a;
+    //~^ unnecessary_struct_initialization
 
     // Should lint: `b` would be consumed, and is mutable
     let c = &mut b;
+    //~^ unnecessary_struct_initialization
 
     // Should not lint as `d` is not mutable
     let d = S { f: String::from("foo") };
@@ -53,6 +56,7 @@ fn main() {
     // Should lint as `f` would be consumed anyway
     let f = S { f: String::from("foo") };
     let g = &f;
+    //~^ unnecessary_struct_initialization
 
     // Should lint: the result of an expression is mutable
     let h = &mut *Box::new(S { f: String::from("foo") });
@@ -77,6 +81,7 @@ fn main() {
     // Should lint: all fields of `q` would be consumed anyway
     let q = W { f1: 42, f2: 1337 };
     let r = q;
+    //~^ unnecessary_struct_initialization
 
     // Should not lint: not all fields of `t` from same source
     let s = W { f1: 1337, f2: 42 };
@@ -88,6 +93,7 @@ fn main() {
     // Should lint: all fields of `v` would be consumed anyway
     let v = W { f1: 42, f2: 1337 };
     let w = v;
+    //~^ unnecessary_struct_initialization
 
     // Should not lint: source differs between fields and base
     let x = W { f1: 42, f2: 1337 };
@@ -96,6 +102,7 @@ fn main() {
     // Should lint: range desugars to struct
     let r1 = 0..5;
     let r2 = r1;
+    //~^ unnecessary_struct_initialization
 
     references();
     shorthand();
@@ -109,6 +116,7 @@ fn references() {
     // Should lint as `d` is a shared reference
     let c = W { f1: 42, f2: 1337 };
     let d = &c;
+    //~^ unnecessary_struct_initialization
 
     // Should not lint as `e` is not mutable
     let e = W { f1: 42, f2: 1337 };
@@ -117,6 +125,7 @@ fn references() {
     // Should lint as `h` is a shared reference
     let g = W { f1: 42, f2: 1337 };
     let h = &g;
+    //~^ unnecessary_struct_initialization
 
     // Should not lint as `j` is copy
     let i = V { f: 0x1701d };
diff --git a/src/tools/clippy/tests/ui/unnecessary_struct_initialization.rs b/src/tools/clippy/tests/ui/unnecessary_struct_initialization.rs
index b0db71af4d4c..12a444fc878b 100644
--- a/src/tools/clippy/tests/ui/unnecessary_struct_initialization.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_struct_initialization.rs
@@ -35,6 +35,7 @@ impl Clone for V {
     fn clone(&self) -> Self {
         // Lint: `Self` implements `Copy`
         Self { ..*self }
+        //~^ unnecessary_struct_initialization
     }
 }
 
@@ -42,9 +43,11 @@ fn main() {
     // Should lint: `a` would be consumed anyway
     let a = S { f: String::from("foo") };
     let mut b = S { ..a };
+    //~^ unnecessary_struct_initialization
 
     // Should lint: `b` would be consumed, and is mutable
     let c = &mut S { ..b };
+    //~^ unnecessary_struct_initialization
 
     // Should not lint as `d` is not mutable
     let d = S { f: String::from("foo") };
@@ -53,9 +56,11 @@ fn main() {
     // Should lint as `f` would be consumed anyway
     let f = S { f: String::from("foo") };
     let g = &S { ..f };
+    //~^ unnecessary_struct_initialization
 
     // Should lint: the result of an expression is mutable
     let h = &mut S {
+        //~^ unnecessary_struct_initialization
         ..*Box::new(S { f: String::from("foo") })
     };
 
@@ -75,12 +80,14 @@ fn main() {
 
     // Should lint: the result of an expression is mutable and temporary
     let p = &mut T {
+        //~^ unnecessary_struct_initialization
         ..*Box::new(T { f: 5 })
     };
 
     // Should lint: all fields of `q` would be consumed anyway
     let q = W { f1: 42, f2: 1337 };
     let r = W { f1: q.f1, f2: q.f2 };
+    //~^ unnecessary_struct_initialization
 
     // Should not lint: not all fields of `t` from same source
     let s = W { f1: 1337, f2: 42 };
@@ -92,6 +99,7 @@ fn main() {
     // Should lint: all fields of `v` would be consumed anyway
     let v = W { f1: 42, f2: 1337 };
     let w = W { f1: v.f1, ..v };
+    //~^ unnecessary_struct_initialization
 
     // Should not lint: source differs between fields and base
     let x = W { f1: 42, f2: 1337 };
@@ -100,6 +108,7 @@ fn main() {
     // Should lint: range desugars to struct
     let r1 = 0..5;
     let r2 = r1.start..r1.end;
+    //~^ unnecessary_struct_initialization
 
     references();
     shorthand();
@@ -113,6 +122,7 @@ fn references() {
     // Should lint as `d` is a shared reference
     let c = W { f1: 42, f2: 1337 };
     let d = &W { f1: c.f1, f2: c.f2 };
+    //~^ unnecessary_struct_initialization
 
     // Should not lint as `e` is not mutable
     let e = W { f1: 42, f2: 1337 };
@@ -121,6 +131,7 @@ fn references() {
     // Should lint as `h` is a shared reference
     let g = W { f1: 42, f2: 1337 };
     let h = &W { f1: g.f1, ..g };
+    //~^ unnecessary_struct_initialization
 
     // Should not lint as `j` is copy
     let i = V { f: 0x1701d };
diff --git a/src/tools/clippy/tests/ui/unnecessary_struct_initialization.stderr b/src/tools/clippy/tests/ui/unnecessary_struct_initialization.stderr
index 56982cc0a39f..5177b3252547 100644
--- a/src/tools/clippy/tests/ui/unnecessary_struct_initialization.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_struct_initialization.stderr
@@ -8,67 +8,69 @@ LL |         Self { ..*self }
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_struct_initialization)]`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:44:17
+  --> tests/ui/unnecessary_struct_initialization.rs:45:17
    |
 LL |     let mut b = S { ..a };
    |                 ^^^^^^^^^ help: replace with: `a`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:47:18
+  --> tests/ui/unnecessary_struct_initialization.rs:49:18
    |
 LL |     let c = &mut S { ..b };
    |                  ^^^^^^^^^ help: replace with: `b`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:55:14
+  --> tests/ui/unnecessary_struct_initialization.rs:58:14
    |
 LL |     let g = &S { ..f };
    |              ^^^^^^^^^ help: replace with: `f`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:58:18
+  --> tests/ui/unnecessary_struct_initialization.rs:62:18
    |
 LL |       let h = &mut S {
    |  __________________^
+LL | |
 LL | |         ..*Box::new(S { f: String::from("foo") })
 LL | |     };
    | |_____^ help: replace with: `*Box::new(S { f: String::from("foo") })`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:77:18
+  --> tests/ui/unnecessary_struct_initialization.rs:82:18
    |
 LL |       let p = &mut T {
    |  __________________^
+LL | |
 LL | |         ..*Box::new(T { f: 5 })
 LL | |     };
    | |_____^ help: replace with: `*Box::new(T { f: 5 })`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:83:13
+  --> tests/ui/unnecessary_struct_initialization.rs:89:13
    |
 LL |     let r = W { f1: q.f1, f2: q.f2 };
    |             ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `q`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:94:13
+  --> tests/ui/unnecessary_struct_initialization.rs:101:13
    |
 LL |     let w = W { f1: v.f1, ..v };
    |             ^^^^^^^^^^^^^^^^^^^ help: replace with: `v`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:102:14
+  --> tests/ui/unnecessary_struct_initialization.rs:110:14
    |
 LL |     let r2 = r1.start..r1.end;
    |              ^^^^^^^^^^^^^^^^ help: replace with: `r1`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:115:14
+  --> tests/ui/unnecessary_struct_initialization.rs:124:14
    |
 LL |     let d = &W { f1: c.f1, f2: c.f2 };
    |              ^^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `c`
 
 error: unnecessary struct building
-  --> tests/ui/unnecessary_struct_initialization.rs:123:14
+  --> tests/ui/unnecessary_struct_initialization.rs:133:14
    |
 LL |     let h = &W { f1: g.f1, ..g };
    |              ^^^^^^^^^^^^^^^^^^^ help: replace with: `g`
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed b/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed
index 027dac419375..bf271aef763b 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned.fixed
@@ -3,7 +3,8 @@
     clippy::needless_borrows_for_generic_args,
     clippy::ptr_arg,
     clippy::manual_async_fn,
-    clippy::needless_lifetimes
+    clippy::needless_lifetimes,
+    clippy::owned_cow
 )]
 #![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
@@ -62,82 +63,151 @@ fn main() {
     let x_ref = &x;
 
     require_c_str(&Cow::from(c_str));
+    //~^ unnecessary_to_owned
     require_c_str(c_str);
+    //~^ unnecessary_to_owned
 
     require_os_str(os_str);
+    //~^ unnecessary_to_owned
     require_os_str(&Cow::from(os_str));
+    //~^ unnecessary_to_owned
     require_os_str(os_str);
+    //~^ unnecessary_to_owned
 
     require_path(path);
+    //~^ unnecessary_to_owned
     require_path(&Cow::from(path));
+    //~^ unnecessary_to_owned
     require_path(path);
+    //~^ unnecessary_to_owned
 
     require_str(s);
+    //~^ unnecessary_to_owned
     require_str(&Cow::from(s));
+    //~^ unnecessary_to_owned
     require_str(s);
+    //~^ unnecessary_to_owned
     require_str(x_ref.as_ref());
+    //~^ unnecessary_to_owned
 
     require_slice(slice);
+    //~^ unnecessary_to_owned
     require_slice(&Cow::from(slice));
+    //~^ unnecessary_to_owned
     require_slice(array.as_ref());
+    //~^ unnecessary_to_owned
     require_slice(array_ref.as_ref());
+    //~^ unnecessary_to_owned
     require_slice(slice);
+    //~^ unnecessary_to_owned
     require_slice(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_x(&Cow::<X>::Owned(x.clone()));
+    //~^ unnecessary_to_owned
     require_x(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_deref_c_str(c_str);
+    //~^ unnecessary_to_owned
     require_deref_os_str(os_str);
+    //~^ unnecessary_to_owned
     require_deref_path(path);
+    //~^ unnecessary_to_owned
     require_deref_str(s);
+    //~^ unnecessary_to_owned
     require_deref_slice(slice);
+    //~^ unnecessary_to_owned
 
     require_impl_deref_c_str(c_str);
+    //~^ unnecessary_to_owned
     require_impl_deref_os_str(os_str);
+    //~^ unnecessary_to_owned
     require_impl_deref_path(path);
+    //~^ unnecessary_to_owned
     require_impl_deref_str(s);
+    //~^ unnecessary_to_owned
     require_impl_deref_slice(slice);
+    //~^ unnecessary_to_owned
 
     require_deref_str_slice(s, slice);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_deref_slice_str(slice, s);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
 
     require_as_ref_c_str(c_str);
+    //~^ unnecessary_to_owned
     require_as_ref_os_str(os_str);
+    //~^ unnecessary_to_owned
     require_as_ref_path(path);
+    //~^ unnecessary_to_owned
     require_as_ref_str(s);
+    //~^ unnecessary_to_owned
     require_as_ref_str(&x);
+    //~^ unnecessary_to_owned
     require_as_ref_slice(array);
+    //~^ unnecessary_to_owned
     require_as_ref_slice(array_ref);
+    //~^ unnecessary_to_owned
     require_as_ref_slice(slice);
+    //~^ unnecessary_to_owned
 
     require_impl_as_ref_c_str(c_str);
+    //~^ unnecessary_to_owned
     require_impl_as_ref_os_str(os_str);
+    //~^ unnecessary_to_owned
     require_impl_as_ref_path(path);
+    //~^ unnecessary_to_owned
     require_impl_as_ref_str(s);
+    //~^ unnecessary_to_owned
     require_impl_as_ref_str(&x);
+    //~^ unnecessary_to_owned
     require_impl_as_ref_slice(array);
+    //~^ unnecessary_to_owned
     require_impl_as_ref_slice(array_ref);
+    //~^ unnecessary_to_owned
     require_impl_as_ref_slice(slice);
+    //~^ unnecessary_to_owned
 
     require_as_ref_str_slice(s, array);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_str_slice(s, array_ref);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_str_slice(s, slice);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_slice_str(array, s);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_slice_str(array_ref, s);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_slice_str(slice, s);
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
 
     let _ = x.join(x_ref);
+    //~^ unnecessary_to_owned
 
     let _ = slice.iter().copied();
+    //~^ unnecessary_to_owned
     let _ = slice.iter().copied();
+    //~^ unnecessary_to_owned
     let _ = [std::path::PathBuf::new()][..].iter().cloned();
+    //~^ unnecessary_to_owned
     let _ = [std::path::PathBuf::new()][..].iter().cloned();
+    //~^ unnecessary_to_owned
 
     let _ = slice.iter().copied();
+    //~^ unnecessary_to_owned
     let _ = slice.iter().copied();
+    //~^ unnecessary_to_owned
     let _ = [std::path::PathBuf::new()][..].iter().cloned();
+    //~^ unnecessary_to_owned
     let _ = [std::path::PathBuf::new()][..].iter().cloned();
+    //~^ unnecessary_to_owned
 
     let _ = check_files(&[FileType::Account]);
 
@@ -153,15 +223,23 @@ fn main() {
 
     // The following should be flagged by `redundant_clone`, but not by this lint.
     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap());
+    //~^ redundant_clone
     require_os_str(&OsString::from("x"));
+    //~^ redundant_clone
     require_path(&std::path::PathBuf::from("x"));
+    //~^ redundant_clone
     require_str(&String::from("x"));
+    //~^ redundant_clone
     require_slice(&[String::from("x")]);
+    //~^ redundant_clone
 
     let slice = [0u8; 1024];
     let _ref_str: &str = core::str::from_utf8(&slice).expect("not UTF-8");
+    //~^ unnecessary_to_owned
     let _ref_str: &str = core::str::from_utf8(b"foo").unwrap();
+    //~^ unnecessary_to_owned
     let _ref_str: &str = core::str::from_utf8(b"foo".as_slice()).unwrap();
+    //~^ unnecessary_to_owned
     // Expression is of type `&String`, can't suggest `str::from_utf8` here
     let _ref_string = &String::from_utf8(b"foo".to_vec()).unwrap();
     macro_rules! arg_from_macro {
@@ -219,6 +297,7 @@ fn require_as_ref_slice_str<T, U: AsRef<[T]>, V: AsRef<str>>(_: U, _: V) {}
 // https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
 fn check_files(file_types: &[FileType]) -> bool {
     for t in file_types {
+        //~^ unnecessary_to_owned
         let path = match get_file_path(t) {
             Ok(p) => p,
             Err(_) => {
@@ -242,11 +321,13 @@ fn require_string(_: &String) {}
 fn _msrv_1_35() {
     // `copied` was stabilized in 1.36, so clippy should use `cloned`.
     let _ = &["x"][..].iter().cloned();
+    //~^ unnecessary_to_owned
 }
 
 #[clippy::msrv = "1.36"]
 fn _msrv_1_36() {
     let _ = &["x"][..].iter().copied();
+    //~^ unnecessary_to_owned
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/8507
@@ -295,6 +376,7 @@ mod issue_8507 {
     // Should lint because Y is copy.
     fn test_y(y: Y) -> Box<dyn Abstracted> {
         Box::new(build(y))
+        //~^ unnecessary_to_owned
     }
 }
 
@@ -404,6 +486,7 @@ mod issue_9351 {
     // Should lint
     fn single_return() -> impl AsRef<str> {
         id("abc")
+        //~^ unnecessary_to_owned
     }
 
     // Should not lint
@@ -547,6 +630,7 @@ mod issue_11952 {
 
     fn bar() {
         IntoFuture::into_future(foo([], &0));
+        //~^ unnecessary_to_owned
     }
 }
 
@@ -556,18 +640,23 @@ fn borrow_checks() {
 
     fn inner(a: &[&str]) {
         let mut s = HashSet::from([vec!["a"]]);
-        s.remove(a); //~ ERROR: unnecessary use of `to_vec`
+        s.remove(a);
+        //~^ unnecessary_to_owned
     }
 
     let mut s = HashSet::from(["a".to_string()]);
-    s.remove("b"); //~ ERROR: unnecessary use of `to_owned`
-    s.remove("b"); //~ ERROR: unnecessary use of `to_string`
+    s.remove("b");
+    //~^ unnecessary_to_owned
+    s.remove("b");
+    //~^ unnecessary_to_owned
     // Should not warn.
     s.remove("b");
 
     let mut s = HashSet::from([vec!["a"]]);
-    s.remove(["b"].as_slice()); //~ ERROR: unnecessary use of `to_vec`
-    s.remove((&["b"]).as_slice()); //~ ERROR: unnecessary use of `to_vec`
+    s.remove(["b"].as_slice());
+    //~^ unnecessary_to_owned
+    s.remove((&["b"]).as_slice());
+    //~^ unnecessary_to_owned
 
     // Should not warn.
     s.remove(&["b"].to_vec().clone());
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned.rs b/src/tools/clippy/tests/ui/unnecessary_to_owned.rs
index b89f3d552f84..95b95ab6bd22 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned.rs
@@ -3,7 +3,8 @@
     clippy::needless_borrows_for_generic_args,
     clippy::ptr_arg,
     clippy::manual_async_fn,
-    clippy::needless_lifetimes
+    clippy::needless_lifetimes,
+    clippy::owned_cow
 )]
 #![warn(clippy::unnecessary_to_owned, clippy::redundant_clone)]
 
@@ -62,82 +63,151 @@ fn main() {
     let x_ref = &x;
 
     require_c_str(&Cow::from(c_str).into_owned());
+    //~^ unnecessary_to_owned
     require_c_str(&c_str.to_owned());
+    //~^ unnecessary_to_owned
 
     require_os_str(&os_str.to_os_string());
+    //~^ unnecessary_to_owned
     require_os_str(&Cow::from(os_str).into_owned());
+    //~^ unnecessary_to_owned
     require_os_str(&os_str.to_owned());
+    //~^ unnecessary_to_owned
 
     require_path(&path.to_path_buf());
+    //~^ unnecessary_to_owned
     require_path(&Cow::from(path).into_owned());
+    //~^ unnecessary_to_owned
     require_path(&path.to_owned());
+    //~^ unnecessary_to_owned
 
     require_str(&s.to_string());
+    //~^ unnecessary_to_owned
     require_str(&Cow::from(s).into_owned());
+    //~^ unnecessary_to_owned
     require_str(&s.to_owned());
+    //~^ unnecessary_to_owned
     require_str(&x_ref.to_string());
+    //~^ unnecessary_to_owned
 
     require_slice(&slice.to_vec());
+    //~^ unnecessary_to_owned
     require_slice(&Cow::from(slice).into_owned());
+    //~^ unnecessary_to_owned
     require_slice(&array.to_owned());
+    //~^ unnecessary_to_owned
     require_slice(&array_ref.to_owned());
+    //~^ unnecessary_to_owned
     require_slice(&slice.to_owned());
+    //~^ unnecessary_to_owned
     require_slice(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
+    //~^ unnecessary_to_owned
     require_x(&x_ref.to_owned()); // No longer flagged because of #8759.
 
     require_deref_c_str(c_str.to_owned());
+    //~^ unnecessary_to_owned
     require_deref_os_str(os_str.to_owned());
+    //~^ unnecessary_to_owned
     require_deref_path(path.to_owned());
+    //~^ unnecessary_to_owned
     require_deref_str(s.to_owned());
+    //~^ unnecessary_to_owned
     require_deref_slice(slice.to_owned());
+    //~^ unnecessary_to_owned
 
     require_impl_deref_c_str(c_str.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_deref_os_str(os_str.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_deref_path(path.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_deref_str(s.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_deref_slice(slice.to_owned());
+    //~^ unnecessary_to_owned
 
     require_deref_str_slice(s.to_owned(), slice.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_deref_slice_str(slice.to_owned(), s.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
 
     require_as_ref_c_str(c_str.to_owned());
+    //~^ unnecessary_to_owned
     require_as_ref_os_str(os_str.to_owned());
+    //~^ unnecessary_to_owned
     require_as_ref_path(path.to_owned());
+    //~^ unnecessary_to_owned
     require_as_ref_str(s.to_owned());
+    //~^ unnecessary_to_owned
     require_as_ref_str(x.to_owned());
+    //~^ unnecessary_to_owned
     require_as_ref_slice(array.to_owned());
+    //~^ unnecessary_to_owned
     require_as_ref_slice(array_ref.to_owned());
+    //~^ unnecessary_to_owned
     require_as_ref_slice(slice.to_owned());
+    //~^ unnecessary_to_owned
 
     require_impl_as_ref_c_str(c_str.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_as_ref_os_str(os_str.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_as_ref_path(path.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_as_ref_str(s.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_as_ref_str(x.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_as_ref_slice(array.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_as_ref_slice(array_ref.to_owned());
+    //~^ unnecessary_to_owned
     require_impl_as_ref_slice(slice.to_owned());
+    //~^ unnecessary_to_owned
 
     require_as_ref_str_slice(s.to_owned(), array.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_slice_str(array.to_owned(), s.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
+    //~^ unnecessary_to_owned
+    //~| unnecessary_to_owned
 
     let _ = x.join(&x_ref.to_string());
+    //~^ unnecessary_to_owned
 
     let _ = slice.to_vec().into_iter();
+    //~^ unnecessary_to_owned
     let _ = slice.to_owned().into_iter();
+    //~^ unnecessary_to_owned
     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
+    //~^ unnecessary_to_owned
     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
+    //~^ unnecessary_to_owned
 
     let _ = IntoIterator::into_iter(slice.to_vec());
+    //~^ unnecessary_to_owned
     let _ = IntoIterator::into_iter(slice.to_owned());
+    //~^ unnecessary_to_owned
     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
+    //~^ unnecessary_to_owned
     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
+    //~^ unnecessary_to_owned
 
     let _ = check_files(&[FileType::Account]);
 
@@ -153,15 +223,23 @@ fn main() {
 
     // The following should be flagged by `redundant_clone`, but not by this lint.
     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
+    //~^ redundant_clone
     require_os_str(&OsString::from("x").to_os_string());
+    //~^ redundant_clone
     require_path(&std::path::PathBuf::from("x").to_path_buf());
+    //~^ redundant_clone
     require_str(&String::from("x").to_string());
+    //~^ redundant_clone
     require_slice(&[String::from("x")].to_owned());
+    //~^ redundant_clone
 
     let slice = [0u8; 1024];
     let _ref_str: &str = &String::from_utf8(slice.to_vec()).expect("not UTF-8");
+    //~^ unnecessary_to_owned
     let _ref_str: &str = &String::from_utf8(b"foo".to_vec()).unwrap();
+    //~^ unnecessary_to_owned
     let _ref_str: &str = &String::from_utf8(b"foo".as_slice().to_owned()).unwrap();
+    //~^ unnecessary_to_owned
     // Expression is of type `&String`, can't suggest `str::from_utf8` here
     let _ref_string = &String::from_utf8(b"foo".to_vec()).unwrap();
     macro_rules! arg_from_macro {
@@ -219,6 +297,7 @@ fn require_as_ref_slice_str<T, U: AsRef<[T]>, V: AsRef<str>>(_: U, _: V) {}
 // https://github.com/breard-r/acmed/blob/1f0dcc32aadbc5e52de6d23b9703554c0f925113/acmed/src/storage.rs#L262
 fn check_files(file_types: &[FileType]) -> bool {
     for t in file_types.to_vec() {
+        //~^ unnecessary_to_owned
         let path = match get_file_path(&t) {
             Ok(p) => p,
             Err(_) => {
@@ -242,11 +321,13 @@ fn require_string(_: &String) {}
 fn _msrv_1_35() {
     // `copied` was stabilized in 1.36, so clippy should use `cloned`.
     let _ = &["x"][..].to_vec().into_iter();
+    //~^ unnecessary_to_owned
 }
 
 #[clippy::msrv = "1.36"]
 fn _msrv_1_36() {
     let _ = &["x"][..].to_vec().into_iter();
+    //~^ unnecessary_to_owned
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/8507
@@ -295,6 +376,7 @@ mod issue_8507 {
     // Should lint because Y is copy.
     fn test_y(y: Y) -> Box<dyn Abstracted> {
         Box::new(build(y.to_string()))
+        //~^ unnecessary_to_owned
     }
 }
 
@@ -404,6 +486,7 @@ mod issue_9351 {
     // Should lint
     fn single_return() -> impl AsRef<str> {
         id("abc".to_string())
+        //~^ unnecessary_to_owned
     }
 
     // Should not lint
@@ -547,6 +630,7 @@ mod issue_11952 {
 
     fn bar() {
         IntoFuture::into_future(foo([].to_vec(), &0));
+        //~^ unnecessary_to_owned
     }
 }
 
@@ -556,18 +640,23 @@ fn borrow_checks() {
 
     fn inner(a: &[&str]) {
         let mut s = HashSet::from([vec!["a"]]);
-        s.remove(&a.to_vec()); //~ ERROR: unnecessary use of `to_vec`
+        s.remove(&a.to_vec());
+        //~^ unnecessary_to_owned
     }
 
     let mut s = HashSet::from(["a".to_string()]);
-    s.remove(&"b".to_owned()); //~ ERROR: unnecessary use of `to_owned`
-    s.remove(&"b".to_string()); //~ ERROR: unnecessary use of `to_string`
+    s.remove(&"b".to_owned());
+    //~^ unnecessary_to_owned
+    s.remove(&"b".to_string());
+    //~^ unnecessary_to_owned
     // Should not warn.
     s.remove("b");
 
     let mut s = HashSet::from([vec!["a"]]);
-    s.remove(&["b"].to_vec()); //~ ERROR: unnecessary use of `to_vec`
-    s.remove(&(&["b"]).to_vec()); //~ ERROR: unnecessary use of `to_vec`
+    s.remove(&["b"].to_vec());
+    //~^ unnecessary_to_owned
+    s.remove(&(&["b"]).to_vec());
+    //~^ unnecessary_to_owned
 
     // Should not warn.
     s.remove(&["b"].to_vec().clone());
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr b/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr
index 498ac68cdaa0..4daa3876e60e 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned.stderr
@@ -1,11 +1,11 @@
 error: redundant clone
-  --> tests/ui/unnecessary_to_owned.rs:155:64
+  --> tests/ui/unnecessary_to_owned.rs:225:64
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                                                                ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/unnecessary_to_owned.rs:155:20
+  --> tests/ui/unnecessary_to_owned.rs:225:20
    |
 LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -13,55 +13,55 @@ LL |     require_c_str(&CString::from_vec_with_nul(vec![0]).unwrap().to_owned())
    = help: to override `-D warnings` add `#[allow(clippy::redundant_clone)]`
 
 error: redundant clone
-  --> tests/ui/unnecessary_to_owned.rs:156:40
+  --> tests/ui/unnecessary_to_owned.rs:227:40
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                                        ^^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/unnecessary_to_owned.rs:156:21
+  --> tests/ui/unnecessary_to_owned.rs:227:21
    |
 LL |     require_os_str(&OsString::from("x").to_os_string());
    |                     ^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/unnecessary_to_owned.rs:157:48
+  --> tests/ui/unnecessary_to_owned.rs:229:48
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                                                ^^^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/unnecessary_to_owned.rs:157:19
+  --> tests/ui/unnecessary_to_owned.rs:229:19
    |
 LL |     require_path(&std::path::PathBuf::from("x").to_path_buf());
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/unnecessary_to_owned.rs:158:35
+  --> tests/ui/unnecessary_to_owned.rs:231:35
    |
 LL |     require_str(&String::from("x").to_string());
    |                                   ^^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/unnecessary_to_owned.rs:158:18
+  --> tests/ui/unnecessary_to_owned.rs:231:18
    |
 LL |     require_str(&String::from("x").to_string());
    |                  ^^^^^^^^^^^^^^^^^
 
 error: redundant clone
-  --> tests/ui/unnecessary_to_owned.rs:159:39
+  --> tests/ui/unnecessary_to_owned.rs:233:39
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                                       ^^^^^^^^^^^ help: remove this
    |
 note: this value is dropped without further use
-  --> tests/ui/unnecessary_to_owned.rs:159:20
+  --> tests/ui/unnecessary_to_owned.rs:233:20
    |
 LL |     require_slice(&[String::from("x")].to_owned());
    |                    ^^^^^^^^^^^^^^^^^^^
 
 error: unnecessary use of `into_owned`
-  --> tests/ui/unnecessary_to_owned.rs:64:36
+  --> tests/ui/unnecessary_to_owned.rs:65:36
    |
 LL |     require_c_str(&Cow::from(c_str).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
@@ -70,415 +70,415 @@ LL |     require_c_str(&Cow::from(c_str).into_owned());
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:65:19
+  --> tests/ui/unnecessary_to_owned.rs:67:19
    |
 LL |     require_c_str(&c_str.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_os_string`
-  --> tests/ui/unnecessary_to_owned.rs:67:20
+  --> tests/ui/unnecessary_to_owned.rs:70:20
    |
 LL |     require_os_str(&os_str.to_os_string());
    |                    ^^^^^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `into_owned`
-  --> tests/ui/unnecessary_to_owned.rs:68:38
+  --> tests/ui/unnecessary_to_owned.rs:72:38
    |
 LL |     require_os_str(&Cow::from(os_str).into_owned());
    |                                      ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:69:20
+  --> tests/ui/unnecessary_to_owned.rs:74:20
    |
 LL |     require_os_str(&os_str.to_owned());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_path_buf`
-  --> tests/ui/unnecessary_to_owned.rs:71:18
+  --> tests/ui/unnecessary_to_owned.rs:77:18
    |
 LL |     require_path(&path.to_path_buf());
    |                  ^^^^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `into_owned`
-  --> tests/ui/unnecessary_to_owned.rs:72:34
+  --> tests/ui/unnecessary_to_owned.rs:79:34
    |
 LL |     require_path(&Cow::from(path).into_owned());
    |                                  ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:73:18
+  --> tests/ui/unnecessary_to_owned.rs:81:18
    |
 LL |     require_path(&path.to_owned());
    |                  ^^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned.rs:75:17
+  --> tests/ui/unnecessary_to_owned.rs:84:17
    |
 LL |     require_str(&s.to_string());
    |                 ^^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `into_owned`
-  --> tests/ui/unnecessary_to_owned.rs:76:30
+  --> tests/ui/unnecessary_to_owned.rs:86:30
    |
 LL |     require_str(&Cow::from(s).into_owned());
    |                              ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:77:17
+  --> tests/ui/unnecessary_to_owned.rs:88:17
    |
 LL |     require_str(&s.to_owned());
    |                 ^^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned.rs:78:17
+  --> tests/ui/unnecessary_to_owned.rs:90:17
    |
 LL |     require_str(&x_ref.to_string());
    |                 ^^^^^^^^^^^^^^^^^^ help: use: `x_ref.as_ref()`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:80:19
+  --> tests/ui/unnecessary_to_owned.rs:93:19
    |
 LL |     require_slice(&slice.to_vec());
    |                   ^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> tests/ui/unnecessary_to_owned.rs:81:36
+  --> tests/ui/unnecessary_to_owned.rs:95:36
    |
 LL |     require_slice(&Cow::from(slice).into_owned());
    |                                    ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:82:19
+  --> tests/ui/unnecessary_to_owned.rs:97:19
    |
 LL |     require_slice(&array.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `array.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:83:19
+  --> tests/ui/unnecessary_to_owned.rs:99:19
    |
 LL |     require_slice(&array_ref.to_owned());
    |                   ^^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref.as_ref()`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:84:19
+  --> tests/ui/unnecessary_to_owned.rs:101:19
    |
 LL |     require_slice(&slice.to_owned());
    |                   ^^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `into_owned`
-  --> tests/ui/unnecessary_to_owned.rs:87:42
+  --> tests/ui/unnecessary_to_owned.rs:105:42
    |
 LL |     require_x(&Cow::<X>::Owned(x.clone()).into_owned());
    |                                          ^^^^^^^^^^^^^ help: remove this
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:90:25
+  --> tests/ui/unnecessary_to_owned.rs:109:25
    |
 LL |     require_deref_c_str(c_str.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:91:26
+  --> tests/ui/unnecessary_to_owned.rs:111:26
    |
 LL |     require_deref_os_str(os_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:92:24
+  --> tests/ui/unnecessary_to_owned.rs:113:24
    |
 LL |     require_deref_path(path.to_owned());
    |                        ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:93:23
+  --> tests/ui/unnecessary_to_owned.rs:115:23
    |
 LL |     require_deref_str(s.to_owned());
    |                       ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:94:25
+  --> tests/ui/unnecessary_to_owned.rs:117:25
    |
 LL |     require_deref_slice(slice.to_owned());
    |                         ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:96:30
+  --> tests/ui/unnecessary_to_owned.rs:120:30
    |
 LL |     require_impl_deref_c_str(c_str.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:97:31
+  --> tests/ui/unnecessary_to_owned.rs:122:31
    |
 LL |     require_impl_deref_os_str(os_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:98:29
+  --> tests/ui/unnecessary_to_owned.rs:124:29
    |
 LL |     require_impl_deref_path(path.to_owned());
    |                             ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:99:28
+  --> tests/ui/unnecessary_to_owned.rs:126:28
    |
 LL |     require_impl_deref_str(s.to_owned());
    |                            ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:100:30
+  --> tests/ui/unnecessary_to_owned.rs:128:30
    |
 LL |     require_impl_deref_slice(slice.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:102:29
+  --> tests/ui/unnecessary_to_owned.rs:131:29
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:102:43
+  --> tests/ui/unnecessary_to_owned.rs:131:43
    |
 LL |     require_deref_str_slice(s.to_owned(), slice.to_owned());
    |                                           ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:103:29
+  --> tests/ui/unnecessary_to_owned.rs:134:29
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                             ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:103:47
+  --> tests/ui/unnecessary_to_owned.rs:134:47
    |
 LL |     require_deref_slice_str(slice.to_owned(), s.to_owned());
    |                                               ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:105:26
+  --> tests/ui/unnecessary_to_owned.rs:138:26
    |
 LL |     require_as_ref_c_str(c_str.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:106:27
+  --> tests/ui/unnecessary_to_owned.rs:140:27
    |
 LL |     require_as_ref_os_str(os_str.to_owned());
    |                           ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:107:25
+  --> tests/ui/unnecessary_to_owned.rs:142:25
    |
 LL |     require_as_ref_path(path.to_owned());
    |                         ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:108:24
+  --> tests/ui/unnecessary_to_owned.rs:144:24
    |
 LL |     require_as_ref_str(s.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:109:24
+  --> tests/ui/unnecessary_to_owned.rs:146:24
    |
 LL |     require_as_ref_str(x.to_owned());
    |                        ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:110:26
+  --> tests/ui/unnecessary_to_owned.rs:148:26
    |
 LL |     require_as_ref_slice(array.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:111:26
+  --> tests/ui/unnecessary_to_owned.rs:150:26
    |
 LL |     require_as_ref_slice(array_ref.to_owned());
    |                          ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:112:26
+  --> tests/ui/unnecessary_to_owned.rs:152:26
    |
 LL |     require_as_ref_slice(slice.to_owned());
    |                          ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:114:31
+  --> tests/ui/unnecessary_to_owned.rs:155:31
    |
 LL |     require_impl_as_ref_c_str(c_str.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `c_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:115:32
+  --> tests/ui/unnecessary_to_owned.rs:157:32
    |
 LL |     require_impl_as_ref_os_str(os_str.to_owned());
    |                                ^^^^^^^^^^^^^^^^^ help: use: `os_str`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:116:30
+  --> tests/ui/unnecessary_to_owned.rs:159:30
    |
 LL |     require_impl_as_ref_path(path.to_owned());
    |                              ^^^^^^^^^^^^^^^ help: use: `path`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:117:29
+  --> tests/ui/unnecessary_to_owned.rs:161:29
    |
 LL |     require_impl_as_ref_str(s.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:118:29
+  --> tests/ui/unnecessary_to_owned.rs:163:29
    |
 LL |     require_impl_as_ref_str(x.to_owned());
    |                             ^^^^^^^^^^^^ help: use: `&x`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:119:31
+  --> tests/ui/unnecessary_to_owned.rs:165:31
    |
 LL |     require_impl_as_ref_slice(array.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:120:31
+  --> tests/ui/unnecessary_to_owned.rs:167:31
    |
 LL |     require_impl_as_ref_slice(array_ref.to_owned());
    |                               ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:121:31
+  --> tests/ui/unnecessary_to_owned.rs:169:31
    |
 LL |     require_impl_as_ref_slice(slice.to_owned());
    |                               ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:123:30
+  --> tests/ui/unnecessary_to_owned.rs:172:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:123:44
+  --> tests/ui/unnecessary_to_owned.rs:172:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:124:30
+  --> tests/ui/unnecessary_to_owned.rs:175:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:124:44
+  --> tests/ui/unnecessary_to_owned.rs:175:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), array_ref.to_owned());
    |                                            ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:125:30
+  --> tests/ui/unnecessary_to_owned.rs:178:30
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                              ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:125:44
+  --> tests/ui/unnecessary_to_owned.rs:178:44
    |
 LL |     require_as_ref_str_slice(s.to_owned(), slice.to_owned());
    |                                            ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:126:30
+  --> tests/ui/unnecessary_to_owned.rs:181:30
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `array`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:126:48
+  --> tests/ui/unnecessary_to_owned.rs:181:48
    |
 LL |     require_as_ref_slice_str(array.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:127:30
+  --> tests/ui/unnecessary_to_owned.rs:184:30
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^^^^^ help: use: `array_ref`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:127:52
+  --> tests/ui/unnecessary_to_owned.rs:184:52
    |
 LL |     require_as_ref_slice_str(array_ref.to_owned(), s.to_owned());
    |                                                    ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:128:30
+  --> tests/ui/unnecessary_to_owned.rs:187:30
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                              ^^^^^^^^^^^^^^^^ help: use: `slice`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:128:48
+  --> tests/ui/unnecessary_to_owned.rs:187:48
    |
 LL |     require_as_ref_slice_str(slice.to_owned(), s.to_owned());
    |                                                ^^^^^^^^^^^^ help: use: `s`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned.rs:130:20
+  --> tests/ui/unnecessary_to_owned.rs:191:20
    |
 LL |     let _ = x.join(&x_ref.to_string());
    |                    ^^^^^^^^^^^^^^^^^^ help: use: `x_ref`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:132:13
+  --> tests/ui/unnecessary_to_owned.rs:194:13
    |
 LL |     let _ = slice.to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:133:13
+  --> tests/ui/unnecessary_to_owned.rs:196:13
    |
 LL |     let _ = slice.to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:134:13
+  --> tests/ui/unnecessary_to_owned.rs:198:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_vec().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:135:13
+  --> tests/ui/unnecessary_to_owned.rs:200:13
    |
 LL |     let _ = [std::path::PathBuf::new()][..].to_owned().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:137:13
+  --> tests/ui/unnecessary_to_owned.rs:203:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:138:13
+  --> tests/ui/unnecessary_to_owned.rs:205:13
    |
 LL |     let _ = IntoIterator::into_iter(slice.to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `slice.iter().copied()`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:139:13
+  --> tests/ui/unnecessary_to_owned.rs:207:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_vec());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:140:13
+  --> tests/ui/unnecessary_to_owned.rs:209:13
    |
 LL |     let _ = IntoIterator::into_iter([std::path::PathBuf::new()][..].to_owned());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[std::path::PathBuf::new()][..].iter().cloned()`
 
 error: allocating a new `String` only to create a temporary `&str` from it
-  --> tests/ui/unnecessary_to_owned.rs:162:26
+  --> tests/ui/unnecessary_to_owned.rs:237:26
    |
 LL |     let _ref_str: &str = &String::from_utf8(slice.to_vec()).expect("not UTF-8");
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -490,7 +490,7 @@ LL +     let _ref_str: &str = core::str::from_utf8(&slice).expect("not UTF-8");
    |
 
 error: allocating a new `String` only to create a temporary `&str` from it
-  --> tests/ui/unnecessary_to_owned.rs:163:26
+  --> tests/ui/unnecessary_to_owned.rs:239:26
    |
 LL |     let _ref_str: &str = &String::from_utf8(b"foo".to_vec()).unwrap();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -502,7 +502,7 @@ LL +     let _ref_str: &str = core::str::from_utf8(b"foo").unwrap();
    |
 
 error: allocating a new `String` only to create a temporary `&str` from it
-  --> tests/ui/unnecessary_to_owned.rs:164:26
+  --> tests/ui/unnecessary_to_owned.rs:241:26
    |
 LL |     let _ref_str: &str = &String::from_utf8(b"foo".as_slice().to_owned()).unwrap();
    |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -514,7 +514,7 @@ LL +     let _ref_str: &str = core::str::from_utf8(b"foo".as_slice()).unwrap();
    |
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:221:14
+  --> tests/ui/unnecessary_to_owned.rs:299:14
    |
 LL |     for t in file_types.to_vec() {
    |              ^^^^^^^^^^^^^^^^^^^
@@ -522,65 +522,66 @@ LL |     for t in file_types.to_vec() {
 help: remove any references to the binding
    |
 LL ~     for t in file_types {
+LL |
 LL ~         let path = match get_file_path(t) {
    |
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:244:14
+  --> tests/ui/unnecessary_to_owned.rs:323:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().cloned()`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:249:14
+  --> tests/ui/unnecessary_to_owned.rs:329:14
    |
 LL |     let _ = &["x"][..].to_vec().into_iter();
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `["x"][..].iter().copied()`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned.rs:297:24
+  --> tests/ui/unnecessary_to_owned.rs:378:24
    |
 LL |         Box::new(build(y.to_string()))
    |                        ^^^^^^^^^^^^^ help: use: `y`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned.rs:406:12
+  --> tests/ui/unnecessary_to_owned.rs:488:12
    |
 LL |         id("abc".to_string())
    |            ^^^^^^^^^^^^^^^^^ help: use: `"abc"`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:549:37
+  --> tests/ui/unnecessary_to_owned.rs:632:37
    |
 LL |         IntoFuture::into_future(foo([].to_vec(), &0));
    |                                     ^^^^^^^^^^^ help: use: `[]`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:559:18
+  --> tests/ui/unnecessary_to_owned.rs:643:18
    |
 LL |         s.remove(&a.to_vec());
    |                  ^^^^^^^^^^^ help: replace it with: `a`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned.rs:563:14
+  --> tests/ui/unnecessary_to_owned.rs:648:14
    |
 LL |     s.remove(&"b".to_owned());
    |              ^^^^^^^^^^^^^^^ help: replace it with: `"b"`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned.rs:564:14
+  --> tests/ui/unnecessary_to_owned.rs:650:14
    |
 LL |     s.remove(&"b".to_string());
    |              ^^^^^^^^^^^^^^^^ help: replace it with: `"b"`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:569:14
+  --> tests/ui/unnecessary_to_owned.rs:656:14
    |
 LL |     s.remove(&["b"].to_vec());
    |              ^^^^^^^^^^^^^^^ help: replace it with: `["b"].as_slice()`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned.rs:570:14
+  --> tests/ui/unnecessary_to_owned.rs:658:14
    |
 LL |     s.remove(&(&["b"]).to_vec());
    |              ^^^^^^^^^^^^^^^^^^ help: replace it with: `(&["b"]).as_slice()`
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.fixed b/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.fixed
index e0ba216f41bf..f43d92a2d9ba 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.fixed
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.fixed
@@ -17,22 +17,29 @@ impl ToString for Issue12068 {
 
 fn main() {
     let _ = "a".split('a').next().unwrap();
-    //~^ ERROR: unnecessary use of `to_string`
+    //~^ unnecessary_to_owned
+
     let _ = "a".split("a").next().unwrap();
-    //~^ ERROR: unnecessary use of `to_string`
+    //~^ unnecessary_to_owned
+
     let _ = "a".split('a').next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
+
     let _ = "a".split("a").next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
+
     let _ = Issue12068.as_ref().split('a').next().unwrap();
-    //~^ ERROR: unnecessary use of `to_string`
+    //~^ unnecessary_to_owned
 
     let _ = [1].split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_vec`
+    //~^ unnecessary_to_owned
+
     let _ = [1].split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_vec`
+    //~^ unnecessary_to_owned
+
     let _ = [1].split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
+
     let _ = [1].split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.rs b/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.rs
index 70efc6ebba5d..bdf5f98bf61e 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.rs
@@ -17,22 +17,29 @@ impl ToString for Issue12068 {
 
 fn main() {
     let _ = "a".to_string().split('a').next().unwrap();
-    //~^ ERROR: unnecessary use of `to_string`
+    //~^ unnecessary_to_owned
+
     let _ = "a".to_string().split("a").next().unwrap();
-    //~^ ERROR: unnecessary use of `to_string`
+    //~^ unnecessary_to_owned
+
     let _ = "a".to_owned().split('a').next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
+
     let _ = "a".to_owned().split("a").next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
+
     let _ = Issue12068.to_string().split('a').next().unwrap();
-    //~^ ERROR: unnecessary use of `to_string`
+    //~^ unnecessary_to_owned
 
     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_vec`
+    //~^ unnecessary_to_owned
+
     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_vec`
+    //~^ unnecessary_to_owned
+
     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
+
     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
-    //~^ ERROR: unnecessary use of `to_owned`
+    //~^ unnecessary_to_owned
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.stderr b/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.stderr
index cf5c964bcf3c..5e4fbb1035d6 100644
--- a/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_to_owned_on_split.stderr
@@ -8,49 +8,49 @@ LL |     let _ = "a".to_string().split('a').next().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_to_owned)]`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:21:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:22:13
    |
 LL |     let _ = "a".to_string().split("a").next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split("a")`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:23:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:25:13
    |
 LL |     let _ = "a".to_owned().split('a').next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split('a')`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:25:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:28:13
    |
 LL |     let _ = "a".to_owned().split("a").next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `"a".split("a")`
 
 error: unnecessary use of `to_string`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:27:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:31:13
    |
 LL |     let _ = Issue12068.to_string().split('a').next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `Issue12068.as_ref().split('a')`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:30:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:34:13
    |
 LL |     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_vec`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:32:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:37:13
    |
 LL |     let _ = [1].to_vec().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:34:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:40:13
    |
 LL |     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
 
 error: unnecessary use of `to_owned`
-  --> tests/ui/unnecessary_to_owned_on_split.rs:36:13
+  --> tests/ui/unnecessary_to_owned_on_split.rs:43:13
    |
 LL |     let _ = [1].to_owned().split(|x| *x == 2).next().unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use: `[1].split(|x| *x == 2)`
diff --git a/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.rs b/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.rs
index 5ad117eb8db6..7a847d2e3b50 100644
--- a/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.rs
@@ -17,6 +17,7 @@ pub fn destroy_the_planet() {
 ///
 /// This function shouldn't be called unless the horsemen are ready
 pub fn apocalypse(universe: &mut ()) {
+    //~^ unnecessary_safety_doc
     unimplemented!();
 }
 
@@ -43,6 +44,7 @@ mod private_mod {
     ///
     /// Unnecessary safety!
     pub fn republished() {
+        //~^ unnecessary_safety_doc
         unimplemented!();
     }
 }
@@ -56,6 +58,7 @@ pub trait SafeTraitSafeMethods {
     ///
     /// Unnecessary!
     fn documented(self);
+    //~^ unnecessary_safety_doc
 }
 
 pub trait SafeTrait {
@@ -66,6 +69,7 @@ pub trait SafeTrait {
 ///
 /// Unnecessary!
 pub trait DocumentedSafeTrait {
+    //~^ unnecessary_safety_doc
     fn method2();
 }
 
@@ -94,6 +98,7 @@ impl Struct {
     ///
     /// Unnecessary!
     pub fn documented() -> Self {
+        //~^ unnecessary_safety_doc
         unimplemented!();
     }
 
@@ -121,6 +126,7 @@ macro_rules! very_safe {
         ///
         /// Driving is very safe already!
         pub fn drive() {
+            //~^ unnecessary_safety_doc
             whee()
         }
     };
@@ -149,5 +155,6 @@ pub mod __macro {
 
 /// # Implementation safety
 pub trait DocumentedSafeTraitWithImplementationHeader {
+    //~^ unnecessary_safety_doc
     fn method();
 }
diff --git a/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.stderr b/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.stderr
index d8a9f0aa38c3..dd9d8b65f75e 100644
--- a/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_unsafety_doc.stderr
@@ -8,31 +8,31 @@ LL | pub fn apocalypse(universe: &mut ()) {
    = help: to override `-D warnings` add `#[allow(clippy::unnecessary_safety_doc)]`
 
 error: safe function's docs have unnecessary `# Safety` section
-  --> tests/ui/unnecessary_unsafety_doc.rs:45:5
+  --> tests/ui/unnecessary_unsafety_doc.rs:46:5
    |
 LL |     pub fn republished() {
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: safe function's docs have unnecessary `# Safety` section
-  --> tests/ui/unnecessary_unsafety_doc.rs:58:5
+  --> tests/ui/unnecessary_unsafety_doc.rs:60:5
    |
 LL |     fn documented(self);
    |     ^^^^^^^^^^^^^^^^^^^^
 
 error: docs for safe trait have unnecessary `# Safety` section
-  --> tests/ui/unnecessary_unsafety_doc.rs:68:1
+  --> tests/ui/unnecessary_unsafety_doc.rs:71:1
    |
 LL | pub trait DocumentedSafeTrait {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: safe function's docs have unnecessary `# Safety` section
-  --> tests/ui/unnecessary_unsafety_doc.rs:96:5
+  --> tests/ui/unnecessary_unsafety_doc.rs:100:5
    |
 LL |     pub fn documented() -> Self {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: safe function's docs have unnecessary `# Safety` section
-  --> tests/ui/unnecessary_unsafety_doc.rs:123:9
+  --> tests/ui/unnecessary_unsafety_doc.rs:128:9
    |
 LL |         pub fn drive() {
    |         ^^^^^^^^^^^^^^
@@ -43,7 +43,7 @@ LL | very_safe!();
    = note: this error originates in the macro `very_safe` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: docs for safe trait have unnecessary `# Safety` section
-  --> tests/ui/unnecessary_unsafety_doc.rs:151:1
+  --> tests/ui/unnecessary_unsafety_doc.rs:157:1
    |
 LL | pub trait DocumentedSafeTraitWithImplementationHeader {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnecessary_wraps.rs b/src/tools/clippy/tests/ui/unnecessary_wraps.rs
index 200aefff1bbf..4770ef3b4830 100644
--- a/src/tools/clippy/tests/ui/unnecessary_wraps.rs
+++ b/src/tools/clippy/tests/ui/unnecessary_wraps.rs
@@ -7,8 +7,8 @@
 
 // should be linted
 fn func1(a: bool, b: bool) -> Option<i32> {
-    //~^ ERROR: this function's return value is unnecessarily wrapped by `Option`
-    //~| NOTE: `-D clippy::unnecessary-wraps` implied by `-D warnings`
+    //~^ unnecessary_wraps
+
     if a && b {
         return Some(42);
     }
@@ -22,7 +22,8 @@ fn func1(a: bool, b: bool) -> Option<i32> {
 
 // should be linted
 fn func2(a: bool, b: bool) -> Option<i32> {
-    //~^ ERROR: this function's return value is unnecessarily wrapped by `Option`
+    //~^ unnecessary_wraps
+
     if a && b {
         return Some(10);
     }
@@ -41,7 +42,8 @@ fn func4(a: bool) -> Option<i32> {
 
 // should be linted
 fn func5() -> Option<i32> {
-    //~^ ERROR: this function's return value is unnecessarily wrapped by `Option`
+    //~^ unnecessary_wraps
+
     Some(1)
 }
 
@@ -52,7 +54,8 @@ fn func6() -> Option<i32> {
 
 // should be linted
 fn func7() -> Result<i32, ()> {
-    //~^ ERROR: this function's return value is unnecessarily wrapped by `Result`
+    //~^ unnecessary_wraps
+
     Ok(1)
 }
 
@@ -81,7 +84,8 @@ impl A {
 
     // should be linted
     fn func12() -> Option<i32> {
-        //~^ ERROR: this function's return value is unnecessarily wrapped by `Option`
+        //~^ unnecessary_wraps
+
         Some(1)
     }
 }
@@ -109,7 +113,8 @@ fn issue_6384(s: &str) -> Option<&str> {
 
 // should be linted
 fn issue_6640_1(a: bool, b: bool) -> Option<()> {
-    //~^ ERROR: this function's return value is unnecessary
+    //~^ unnecessary_wraps
+
     if a && b {
         return Some(());
     }
@@ -123,7 +128,8 @@ fn issue_6640_1(a: bool, b: bool) -> Option<()> {
 
 // should be linted
 fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
-    //~^ ERROR: this function's return value is unnecessary
+    //~^ unnecessary_wraps
+
     if a && b {
         return Ok(());
     }
diff --git a/src/tools/clippy/tests/ui/unnecessary_wraps.stderr b/src/tools/clippy/tests/ui/unnecessary_wraps.stderr
index b06ab91dc8de..ba562f5a50be 100644
--- a/src/tools/clippy/tests/ui/unnecessary_wraps.stderr
+++ b/src/tools/clippy/tests/ui/unnecessary_wraps.stderr
@@ -32,9 +32,9 @@ error: this function's return value is unnecessarily wrapped by `Option`
    |
 LL | / fn func2(a: bool, b: bool) -> Option<i32> {
 LL | |
+LL | |
 LL | |     if a && b {
-LL | |         return Some(10);
-LL | |     }
+...  |
 LL | |     if a { Some(20) } else { Some(30) }
 LL | | }
    | |_^
@@ -52,10 +52,11 @@ LL ~     if a { 20 } else { 30 }
    |
 
 error: this function's return value is unnecessarily wrapped by `Option`
-  --> tests/ui/unnecessary_wraps.rs:43:1
+  --> tests/ui/unnecessary_wraps.rs:44:1
    |
 LL | / fn func5() -> Option<i32> {
 LL | |
+LL | |
 LL | |     Some(1)
 LL | | }
    | |_^
@@ -72,10 +73,11 @@ LL +     1
    |
 
 error: this function's return value is unnecessarily wrapped by `Result`
-  --> tests/ui/unnecessary_wraps.rs:54:1
+  --> tests/ui/unnecessary_wraps.rs:56:1
    |
 LL | / fn func7() -> Result<i32, ()> {
 LL | |
+LL | |
 LL | |     Ok(1)
 LL | | }
    | |_^
@@ -92,10 +94,11 @@ LL +     1
    |
 
 error: this function's return value is unnecessarily wrapped by `Option`
-  --> tests/ui/unnecessary_wraps.rs:83:5
+  --> tests/ui/unnecessary_wraps.rs:86:5
    |
 LL | /     fn func12() -> Option<i32> {
 LL | |
+LL | |
 LL | |         Some(1)
 LL | |     }
    | |_____^
@@ -112,12 +115,12 @@ LL +         1
    |
 
 error: this function's return value is unnecessary
-  --> tests/ui/unnecessary_wraps.rs:111:1
+  --> tests/ui/unnecessary_wraps.rs:115:1
    |
 LL | / fn issue_6640_1(a: bool, b: bool) -> Option<()> {
 LL | |
+LL | |
 LL | |     if a && b {
-LL | |         return Some(());
 ...  |
 LL | | }
    | |_^
@@ -139,12 +142,12 @@ LL ~         return ;
    |
 
 error: this function's return value is unnecessary
-  --> tests/ui/unnecessary_wraps.rs:125:1
+  --> tests/ui/unnecessary_wraps.rs:130:1
    |
 LL | / fn issue_6640_2(a: bool, b: bool) -> Result<(), i32> {
 LL | |
+LL | |
 LL | |     if a && b {
-LL | |         return Ok(());
 ...  |
 LL | | }
    | |_^
diff --git a/src/tools/clippy/tests/ui/unneeded_field_pattern.rs b/src/tools/clippy/tests/ui/unneeded_field_pattern.rs
index 1d42f81711bd..327b64e7c4aa 100644
--- a/src/tools/clippy/tests/ui/unneeded_field_pattern.rs
+++ b/src/tools/clippy/tests/ui/unneeded_field_pattern.rs
@@ -16,8 +16,9 @@ fn main() {
 
     match f {
         Foo { a: _, b: 0, .. } => {},
-
+        //~^ unneeded_field_pattern
         Foo { a: _, b: _, c: _ } => {},
+        //~^ unneeded_field_pattern
     }
     match f {
         Foo { b: 0, .. } => {}, // should be OK
diff --git a/src/tools/clippy/tests/ui/unneeded_struct_pattern.fixed b/src/tools/clippy/tests/ui/unneeded_struct_pattern.fixed
index 5bd269896a6b..665ab98913be 100644
--- a/src/tools/clippy/tests/ui/unneeded_struct_pattern.fixed
+++ b/src/tools/clippy/tests/ui/unneeded_struct_pattern.fixed
@@ -15,11 +15,13 @@ fn main() {
     match Some(114514) {
         Some(v) => v,
         None => 0,
+        //~^ unneeded_struct_pattern
     };
 
     match Some(1919810) {
         Some(v) => v,
         None => 0,
+        //~^ unneeded_struct_pattern
     };
 
     match Some(123456) {
@@ -30,15 +32,23 @@ fn main() {
     match Some(Some(123456)) {
         Some(Some(v)) => v,
         Some(None) => 0,
+        //~^ unneeded_struct_pattern
         None => 0,
+        //~^ unneeded_struct_pattern
     };
 
     if let None = Some(0) {}
+    //~^ unneeded_struct_pattern
     if let None = Some(0) {}
+    //~^ unneeded_struct_pattern
     if let Some(None) = Some(Some(0)) {}
+    //~^ unneeded_struct_pattern
     let None = Some(0) else { panic!() };
+    //~^ unneeded_struct_pattern
     let None = Some(0) else { panic!() };
+    //~^ unneeded_struct_pattern
     let Some(None) = Some(Some(0)) else { panic!() };
+    //~^ unneeded_struct_pattern
 
     enum Custom {
         HasFields {
@@ -54,26 +64,28 @@ fn main() {
     match Custom::Init {
         Custom::HasFields { field: value } => value,
         Custom::HasBracketsNoFields {} => 0,
-        Custom::NoBrackets => 0, //~ ERROR: struct pattern is not needed for a unit variant
-        Custom::NoBracketsNonExhaustive => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets => 0,              //~ unneeded_struct_pattern
+        Custom::NoBracketsNonExhaustive => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match Custom::Init {
         Custom::HasFields { field: value } => value,
         Custom::HasBracketsNoFields { .. } => 0,
-        Custom::NoBrackets => 0, //~ ERROR: struct pattern is not needed for a unit variant
-        Custom::NoBracketsNonExhaustive => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets => 0,              //~ unneeded_struct_pattern
+        Custom::NoBracketsNonExhaustive => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match Custom::Init {
-        Custom::NoBrackets if true => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets if true => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match Custom::Init {
-        Custom::NoBrackets | Custom::NoBracketsNonExhaustive => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets | Custom::NoBracketsNonExhaustive => 0,
+        //~^ unneeded_struct_pattern
+        //~| unneeded_struct_pattern
         _ => 0,
     };
 
@@ -87,23 +99,24 @@ fn main() {
         noop();
     }
     if let Custom::NoBrackets = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBrackets = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBrackets | Custom::NoBracketsNonExhaustive = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
+        //~| unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBracketsNonExhaustive = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBracketsNonExhaustive = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
 
@@ -118,18 +131,18 @@ fn main() {
     let Custom::HasBracketsNoFields { .. } = Custom::Init else {
         panic!()
     };
-    let Custom::NoBrackets = Custom::Init else { panic!() }; //~ ERROR: struct pattern is not needed for a unit variant
+    let Custom::NoBrackets = Custom::Init else { panic!() }; //~ unneeded_struct_pattern
 
     let Custom::NoBrackets = Custom::Init else {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         panic!()
     };
     let Custom::NoBracketsNonExhaustive = Custom::Init else {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         panic!()
     };
     let Custom::NoBracketsNonExhaustive = Custom::Init else {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         panic!()
     };
 
@@ -137,11 +150,11 @@ fn main() {
         Variant,
     }
 
-    fn pat_in_fn_param_1(Refutable::Variant: Refutable) {} //~ ERROR: struct pattern is not needed for a unit variant
-    fn pat_in_fn_param_2(Refutable::Variant: Refutable) {} //~ ERROR: struct pattern is not needed for a unit variant
+    fn pat_in_fn_param_1(Refutable::Variant: Refutable) {} //~ unneeded_struct_pattern
+    fn pat_in_fn_param_2(Refutable::Variant: Refutable) {} //~ unneeded_struct_pattern
 
-    for Refutable::Variant in [] {} //~ ERROR: struct pattern is not needed for a unit variant
-    for Refutable::Variant in [] {} //~ ERROR: struct pattern is not needed for a unit variant
+    for Refutable::Variant in [] {} //~ unneeded_struct_pattern
+    for Refutable::Variant in [] {} //~ unneeded_struct_pattern
 }
 
 fn external_crate() {
@@ -155,13 +168,13 @@ fn external_crate() {
 
     match ExhaustiveUnit {
         // Exhaustive variant
-        ExhaustiveUnit => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        ExhaustiveUnit => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match ExhaustiveUnit {
         // Exhaustive variant
-        ExhaustiveUnit => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        ExhaustiveUnit => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
diff --git a/src/tools/clippy/tests/ui/unneeded_struct_pattern.rs b/src/tools/clippy/tests/ui/unneeded_struct_pattern.rs
index c7658617ad37..7cadb6c7fbb5 100644
--- a/src/tools/clippy/tests/ui/unneeded_struct_pattern.rs
+++ b/src/tools/clippy/tests/ui/unneeded_struct_pattern.rs
@@ -15,11 +15,13 @@ fn main() {
     match Some(114514) {
         Some(v) => v,
         None {} => 0,
+        //~^ unneeded_struct_pattern
     };
 
     match Some(1919810) {
         Some(v) => v,
         None { .. } => 0,
+        //~^ unneeded_struct_pattern
     };
 
     match Some(123456) {
@@ -30,15 +32,23 @@ fn main() {
     match Some(Some(123456)) {
         Some(Some(v)) => v,
         Some(None {}) => 0,
+        //~^ unneeded_struct_pattern
         None {} => 0,
+        //~^ unneeded_struct_pattern
     };
 
     if let None {} = Some(0) {}
+    //~^ unneeded_struct_pattern
     if let None { .. } = Some(0) {}
+    //~^ unneeded_struct_pattern
     if let Some(None {}) = Some(Some(0)) {}
+    //~^ unneeded_struct_pattern
     let None {} = Some(0) else { panic!() };
+    //~^ unneeded_struct_pattern
     let None { .. } = Some(0) else { panic!() };
+    //~^ unneeded_struct_pattern
     let Some(None {}) = Some(Some(0)) else { panic!() };
+    //~^ unneeded_struct_pattern
 
     enum Custom {
         HasFields {
@@ -54,26 +64,28 @@ fn main() {
     match Custom::Init {
         Custom::HasFields { field: value } => value,
         Custom::HasBracketsNoFields {} => 0,
-        Custom::NoBrackets {} => 0, //~ ERROR: struct pattern is not needed for a unit variant
-        Custom::NoBracketsNonExhaustive {} => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets {} => 0,              //~ unneeded_struct_pattern
+        Custom::NoBracketsNonExhaustive {} => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match Custom::Init {
         Custom::HasFields { field: value } => value,
         Custom::HasBracketsNoFields { .. } => 0,
-        Custom::NoBrackets { .. } => 0, //~ ERROR: struct pattern is not needed for a unit variant
-        Custom::NoBracketsNonExhaustive { .. } => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets { .. } => 0,              //~ unneeded_struct_pattern
+        Custom::NoBracketsNonExhaustive { .. } => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match Custom::Init {
-        Custom::NoBrackets {} if true => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets {} if true => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match Custom::Init {
-        Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} => 0,
+        //~^ unneeded_struct_pattern
+        //~| unneeded_struct_pattern
         _ => 0,
     };
 
@@ -87,23 +99,24 @@ fn main() {
         noop();
     }
     if let Custom::NoBrackets {} = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBrackets { .. } = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
+        //~| unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBracketsNonExhaustive {} = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
     if let Custom::NoBracketsNonExhaustive { .. } = Custom::Init {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         noop();
     }
 
@@ -118,18 +131,18 @@ fn main() {
     let Custom::HasBracketsNoFields { .. } = Custom::Init else {
         panic!()
     };
-    let Custom::NoBrackets {} = Custom::Init else { panic!() }; //~ ERROR: struct pattern is not needed for a unit variant
+    let Custom::NoBrackets {} = Custom::Init else { panic!() }; //~ unneeded_struct_pattern
 
     let Custom::NoBrackets { .. } = Custom::Init else {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         panic!()
     };
     let Custom::NoBracketsNonExhaustive {} = Custom::Init else {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         panic!()
     };
     let Custom::NoBracketsNonExhaustive { .. } = Custom::Init else {
-        //~^ ERROR: struct pattern is not needed for a unit variant
+        //~^ unneeded_struct_pattern
         panic!()
     };
 
@@ -137,11 +150,11 @@ fn main() {
         Variant,
     }
 
-    fn pat_in_fn_param_1(Refutable::Variant {}: Refutable) {} //~ ERROR: struct pattern is not needed for a unit variant
-    fn pat_in_fn_param_2(Refutable::Variant { .. }: Refutable) {} //~ ERROR: struct pattern is not needed for a unit variant
+    fn pat_in_fn_param_1(Refutable::Variant {}: Refutable) {} //~ unneeded_struct_pattern
+    fn pat_in_fn_param_2(Refutable::Variant { .. }: Refutable) {} //~ unneeded_struct_pattern
 
-    for Refutable::Variant {} in [] {} //~ ERROR: struct pattern is not needed for a unit variant
-    for Refutable::Variant { .. } in [] {} //~ ERROR: struct pattern is not needed for a unit variant
+    for Refutable::Variant {} in [] {} //~ unneeded_struct_pattern
+    for Refutable::Variant { .. } in [] {} //~ unneeded_struct_pattern
 }
 
 fn external_crate() {
@@ -155,13 +168,13 @@ fn external_crate() {
 
     match ExhaustiveUnit {
         // Exhaustive variant
-        ExhaustiveUnit { .. } => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        ExhaustiveUnit { .. } => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
     match ExhaustiveUnit {
         // Exhaustive variant
-        ExhaustiveUnit {} => 0, //~ ERROR: struct pattern is not needed for a unit variant
+        ExhaustiveUnit {} => 0, //~ unneeded_struct_pattern
         _ => 0,
     };
 
diff --git a/src/tools/clippy/tests/ui/unneeded_struct_pattern.stderr b/src/tools/clippy/tests/ui/unneeded_struct_pattern.stderr
index 3a7f59583802..7c0c3c9e4462 100644
--- a/src/tools/clippy/tests/ui/unneeded_struct_pattern.stderr
+++ b/src/tools/clippy/tests/ui/unneeded_struct_pattern.stderr
@@ -8,193 +8,193 @@ LL |         None {} => 0,
    = help: to override `-D warnings` add `#[allow(clippy::unneeded_struct_pattern)]`
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:22:13
+  --> tests/ui/unneeded_struct_pattern.rs:23:13
    |
 LL |         None { .. } => 0,
    |             ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:32:18
+  --> tests/ui/unneeded_struct_pattern.rs:34:18
    |
 LL |         Some(None {}) => 0,
    |                  ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:33:13
+  --> tests/ui/unneeded_struct_pattern.rs:36:13
    |
 LL |         None {} => 0,
    |             ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:36:16
+  --> tests/ui/unneeded_struct_pattern.rs:40:16
    |
 LL |     if let None {} = Some(0) {}
    |                ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:37:16
+  --> tests/ui/unneeded_struct_pattern.rs:42:16
    |
 LL |     if let None { .. } = Some(0) {}
    |                ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:38:21
+  --> tests/ui/unneeded_struct_pattern.rs:44:21
    |
 LL |     if let Some(None {}) = Some(Some(0)) {}
    |                     ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:39:13
+  --> tests/ui/unneeded_struct_pattern.rs:46:13
    |
 LL |     let None {} = Some(0) else { panic!() };
    |             ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:40:13
+  --> tests/ui/unneeded_struct_pattern.rs:48:13
    |
 LL |     let None { .. } = Some(0) else { panic!() };
    |             ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:41:18
+  --> tests/ui/unneeded_struct_pattern.rs:50:18
    |
 LL |     let Some(None {}) = Some(Some(0)) else { panic!() };
    |                  ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:57:27
+  --> tests/ui/unneeded_struct_pattern.rs:67:27
    |
 LL |         Custom::NoBrackets {} => 0,
    |                           ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:58:40
+  --> tests/ui/unneeded_struct_pattern.rs:68:40
    |
 LL |         Custom::NoBracketsNonExhaustive {} => 0,
    |                                        ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:65:27
+  --> tests/ui/unneeded_struct_pattern.rs:75:27
    |
 LL |         Custom::NoBrackets { .. } => 0,
    |                           ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:66:40
+  --> tests/ui/unneeded_struct_pattern.rs:76:40
    |
 LL |         Custom::NoBracketsNonExhaustive { .. } => 0,
    |                                        ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:71:27
+  --> tests/ui/unneeded_struct_pattern.rs:81:27
    |
 LL |         Custom::NoBrackets {} if true => 0,
    |                           ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:76:27
+  --> tests/ui/unneeded_struct_pattern.rs:86:27
    |
 LL |         Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} => 0,
    |                           ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:76:64
+  --> tests/ui/unneeded_struct_pattern.rs:86:64
    |
 LL |         Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} => 0,
    |                                                                ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:89:30
+  --> tests/ui/unneeded_struct_pattern.rs:101:30
    |
 LL |     if let Custom::NoBrackets {} = Custom::Init {
    |                              ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:93:30
+  --> tests/ui/unneeded_struct_pattern.rs:105:30
    |
 LL |     if let Custom::NoBrackets { .. } = Custom::Init {
    |                              ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:97:30
+  --> tests/ui/unneeded_struct_pattern.rs:109:30
    |
 LL |     if let Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} = Custom::Init {
    |                              ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:97:67
+  --> tests/ui/unneeded_struct_pattern.rs:109:67
    |
 LL |     if let Custom::NoBrackets {} | Custom::NoBracketsNonExhaustive {} = Custom::Init {
    |                                                                   ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:101:43
+  --> tests/ui/unneeded_struct_pattern.rs:114:43
    |
 LL |     if let Custom::NoBracketsNonExhaustive {} = Custom::Init {
    |                                           ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:105:43
+  --> tests/ui/unneeded_struct_pattern.rs:118:43
    |
 LL |     if let Custom::NoBracketsNonExhaustive { .. } = Custom::Init {
    |                                           ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:121:27
+  --> tests/ui/unneeded_struct_pattern.rs:134:27
    |
 LL |     let Custom::NoBrackets {} = Custom::Init else { panic!() };
    |                           ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:123:27
+  --> tests/ui/unneeded_struct_pattern.rs:136:27
    |
 LL |     let Custom::NoBrackets { .. } = Custom::Init else {
    |                           ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:127:40
+  --> tests/ui/unneeded_struct_pattern.rs:140:40
    |
 LL |     let Custom::NoBracketsNonExhaustive {} = Custom::Init else {
    |                                        ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:131:40
+  --> tests/ui/unneeded_struct_pattern.rs:144:40
    |
 LL |     let Custom::NoBracketsNonExhaustive { .. } = Custom::Init else {
    |                                        ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:140:44
+  --> tests/ui/unneeded_struct_pattern.rs:153:44
    |
 LL |     fn pat_in_fn_param_1(Refutable::Variant {}: Refutable) {}
    |                                            ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:141:44
+  --> tests/ui/unneeded_struct_pattern.rs:154:44
    |
 LL |     fn pat_in_fn_param_2(Refutable::Variant { .. }: Refutable) {}
    |                                            ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:143:27
+  --> tests/ui/unneeded_struct_pattern.rs:156:27
    |
 LL |     for Refutable::Variant {} in [] {}
    |                           ^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:144:27
+  --> tests/ui/unneeded_struct_pattern.rs:157:27
    |
 LL |     for Refutable::Variant { .. } in [] {}
    |                           ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:158:23
+  --> tests/ui/unneeded_struct_pattern.rs:171:23
    |
 LL |         ExhaustiveUnit { .. } => 0,
    |                       ^^^^^^^ help: remove the struct pattern
 
 error: struct pattern is not needed for a unit variant
-  --> tests/ui/unneeded_struct_pattern.rs:164:23
+  --> tests/ui/unneeded_struct_pattern.rs:177:23
    |
 LL |         ExhaustiveUnit {} => 0,
    |                       ^^^ help: remove the struct pattern
diff --git a/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.fixed b/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.fixed
index cbf91ed4910a..7e6a493b86c1 100644
--- a/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.fixed
+++ b/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.fixed
@@ -10,11 +10,17 @@ fn main() {
     let t = (0, 1, 2, 3);
 
     if let (0, ..) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (0, ..) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (.., 0) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (.., 0) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (0, ..) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (0, ..) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (_, 0, ..) = t {};
     if let (.., 0, _) = t {};
     if let (0, _, _, _) = t {};
@@ -24,6 +30,7 @@ fn main() {
     #[rustfmt::skip]
     {
         if let (0, ..,) = t {};
+        //~^ unneeded_wildcard_pattern
     }
 
     struct S(usize, usize, usize, usize);
@@ -31,11 +38,17 @@ fn main() {
     let s = S(0, 1, 2, 3);
 
     if let S(0, ..) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(0, ..) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(.., 0) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(.., 0) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(0, ..) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(0, ..) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(_, 0, ..) = s {};
     if let S(.., 0, _) = s {};
     if let S(0, _, _, _) = s {};
@@ -45,6 +58,7 @@ fn main() {
     #[rustfmt::skip]
     {
         if let S(0, ..,) = s {};
+        //~^ unneeded_wildcard_pattern
     }
     external! {
         let t = (0, 1, 2, 3);
diff --git a/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.rs b/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.rs
index 10df2b93d5e0..c91383e2cca5 100644
--- a/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.rs
+++ b/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.rs
@@ -10,11 +10,17 @@ fn main() {
     let t = (0, 1, 2, 3);
 
     if let (0, .., _) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (0, _, ..) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (_, .., 0) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (.., _, 0) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (0, _, _, ..) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (0, .., _, _) = t {};
+    //~^ unneeded_wildcard_pattern
     if let (_, 0, ..) = t {};
     if let (.., 0, _) = t {};
     if let (0, _, _, _) = t {};
@@ -24,6 +30,7 @@ fn main() {
     #[rustfmt::skip]
     {
         if let (0, .., _, _,) = t {};
+        //~^ unneeded_wildcard_pattern
     }
 
     struct S(usize, usize, usize, usize);
@@ -31,11 +38,17 @@ fn main() {
     let s = S(0, 1, 2, 3);
 
     if let S(0, .., _) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(0, _, ..) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(_, .., 0) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(.., _, 0) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(0, _, _, ..) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(0, .., _, _) = s {};
+    //~^ unneeded_wildcard_pattern
     if let S(_, 0, ..) = s {};
     if let S(.., 0, _) = s {};
     if let S(0, _, _, _) = s {};
@@ -45,6 +58,7 @@ fn main() {
     #[rustfmt::skip]
     {
         if let S(0, .., _, _,) = s {};
+        //~^ unneeded_wildcard_pattern
     }
     external! {
         let t = (0, 1, 2, 3);
diff --git a/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.stderr b/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.stderr
index ceb7d7fe9e09..20666268a8ca 100644
--- a/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.stderr
+++ b/src/tools/clippy/tests/ui/unneeded_wildcard_pattern.stderr
@@ -11,79 +11,79 @@ LL | #![deny(clippy::unneeded_wildcard_pattern)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> tests/ui/unneeded_wildcard_pattern.rs:13:16
+  --> tests/ui/unneeded_wildcard_pattern.rs:14:16
    |
 LL |     if let (0, _, ..) = t {};
    |                ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> tests/ui/unneeded_wildcard_pattern.rs:14:13
+  --> tests/ui/unneeded_wildcard_pattern.rs:16:13
    |
 LL |     if let (_, .., 0) = t {};
    |             ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> tests/ui/unneeded_wildcard_pattern.rs:15:15
+  --> tests/ui/unneeded_wildcard_pattern.rs:18:15
    |
 LL |     if let (.., _, 0) = t {};
    |               ^^^ help: remove it
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> tests/ui/unneeded_wildcard_pattern.rs:16:16
+  --> tests/ui/unneeded_wildcard_pattern.rs:20:16
    |
 LL |     if let (0, _, _, ..) = t {};
    |                ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> tests/ui/unneeded_wildcard_pattern.rs:17:18
+  --> tests/ui/unneeded_wildcard_pattern.rs:22:18
    |
 LL |     if let (0, .., _, _) = t {};
    |                  ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> tests/ui/unneeded_wildcard_pattern.rs:26:22
+  --> tests/ui/unneeded_wildcard_pattern.rs:32:22
    |
 LL |         if let (0, .., _, _,) = t {};
    |                      ^^^^^^ help: remove them
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> tests/ui/unneeded_wildcard_pattern.rs:33:19
+  --> tests/ui/unneeded_wildcard_pattern.rs:40:19
    |
 LL |     if let S(0, .., _) = s {};
    |                   ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> tests/ui/unneeded_wildcard_pattern.rs:34:17
+  --> tests/ui/unneeded_wildcard_pattern.rs:42:17
    |
 LL |     if let S(0, _, ..) = s {};
    |                 ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> tests/ui/unneeded_wildcard_pattern.rs:35:14
+  --> tests/ui/unneeded_wildcard_pattern.rs:44:14
    |
 LL |     if let S(_, .., 0) = s {};
    |              ^^^ help: remove it
 
 error: this pattern is unneeded as the `..` pattern can match that element
-  --> tests/ui/unneeded_wildcard_pattern.rs:36:16
+  --> tests/ui/unneeded_wildcard_pattern.rs:46:16
    |
 LL |     if let S(.., _, 0) = s {};
    |                ^^^ help: remove it
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> tests/ui/unneeded_wildcard_pattern.rs:37:17
+  --> tests/ui/unneeded_wildcard_pattern.rs:48:17
    |
 LL |     if let S(0, _, _, ..) = s {};
    |                 ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> tests/ui/unneeded_wildcard_pattern.rs:38:19
+  --> tests/ui/unneeded_wildcard_pattern.rs:50:19
    |
 LL |     if let S(0, .., _, _) = s {};
    |                   ^^^^^^ help: remove them
 
 error: these patterns are unneeded as the `..` pattern can match those elements
-  --> tests/ui/unneeded_wildcard_pattern.rs:47:23
+  --> tests/ui/unneeded_wildcard_pattern.rs:60:23
    |
 LL |         if let S(0, .., _, _,) = s {};
    |                       ^^^^^^ help: remove them
diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns.fixed b/src/tools/clippy/tests/ui/unnested_or_patterns.fixed
index 53ec556d1008..791b2fa131f2 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns.fixed
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns.fixed
@@ -14,27 +14,43 @@ fn main() {
     if let &0 | &2 = &0 {}
 
     if let box (0 | 2) = Box::new(0) {}
+    //~^ unnested_or_patterns
     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
+    //~^ unnested_or_patterns
     const C0: Option<u8> = Some(1);
     if let Some(1 | 2) | C0 = None {}
+    //~^ unnested_or_patterns
     if let &mut (0 | 2) = &mut 0 {}
+    //~^ unnested_or_patterns
     if let x @ (0 | 2) = 0 {}
+    //~^ unnested_or_patterns
     if let (0, 1 | 2 | 3) = (0, 0) {}
+    //~^ unnested_or_patterns
     if let (1 | 2 | 3, 0) = (0, 0) {}
+    //~^ unnested_or_patterns
     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
+    //~^ unnested_or_patterns
     if let [0 | 1] = [0] {}
+    //~^ unnested_or_patterns
     if let [x, 0 | 1] = [0, 1] {}
+    //~^ unnested_or_patterns
     if let [x, 0 | 1 | 2] = [0, 1] {}
+    //~^ unnested_or_patterns
     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
+    //~^ unnested_or_patterns
     struct TS(u8, u8);
     if let TS(0 | 1, x) = TS(0, 0) {}
+    //~^ unnested_or_patterns
     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
+    //~^ unnested_or_patterns
     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
+    //~^ unnested_or_patterns
     struct S {
         x: u8,
         y: u8,
     }
     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
+    //~^ unnested_or_patterns
     if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
 }
 
@@ -46,4 +62,5 @@ fn msrv_1_52() {
 #[clippy::msrv = "1.53"]
 fn msrv_1_53() {
     if let [1 | 53] = [0] {}
+    //~^ unnested_or_patterns
 }
diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns.rs b/src/tools/clippy/tests/ui/unnested_or_patterns.rs
index e5e378e922af..e7e7c7cd2e49 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns.rs
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns.rs
@@ -14,27 +14,43 @@ fn main() {
     if let &0 | &2 = &0 {}
 
     if let box 0 | box 2 = Box::new(0) {}
+    //~^ unnested_or_patterns
     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
+    //~^ unnested_or_patterns
     const C0: Option<u8> = Some(1);
     if let Some(1) | C0 | Some(2) = None {}
+    //~^ unnested_or_patterns
     if let &mut 0 | &mut 2 = &mut 0 {}
+    //~^ unnested_or_patterns
     if let x @ 0 | x @ 2 = 0 {}
+    //~^ unnested_or_patterns
     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
+    //~^ unnested_or_patterns
     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
+    //~^ unnested_or_patterns
     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
+    //~^ unnested_or_patterns
     if let [0] | [1] = [0] {}
+    //~^ unnested_or_patterns
     if let [x, 0] | [x, 1] = [0, 1] {}
+    //~^ unnested_or_patterns
     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
+    //~^ unnested_or_patterns
     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
+    //~^ unnested_or_patterns
     struct TS(u8, u8);
     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
+    //~^ unnested_or_patterns
     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
+    //~^ unnested_or_patterns
     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
+    //~^ unnested_or_patterns
     struct S {
         x: u8,
         y: u8,
     }
     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
+    //~^ unnested_or_patterns
     if let S { x: 0, y, .. } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
 }
 
@@ -46,4 +62,5 @@ fn msrv_1_52() {
 #[clippy::msrv = "1.53"]
 fn msrv_1_53() {
     if let [1] | [53] = [0] {}
+    //~^ unnested_or_patterns
 }
diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns.stderr b/src/tools/clippy/tests/ui/unnested_or_patterns.stderr
index 4325df143042..ec5eb983c5a0 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns.stderr
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns.stderr
@@ -13,7 +13,7 @@ LL +     if let box (0 | 2) = Box::new(0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:17:12
+  --> tests/ui/unnested_or_patterns.rs:18:12
    |
 LL |     if let box ((0 | 1)) | box (2 | 3) | box 4 = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:19:12
+  --> tests/ui/unnested_or_patterns.rs:21:12
    |
 LL |     if let Some(1) | C0 | Some(2) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     if let Some(1 | 2) | C0 = None {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:20:12
+  --> tests/ui/unnested_or_patterns.rs:23:12
    |
 LL |     if let &mut 0 | &mut 2 = &mut 0 {}
    |            ^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     if let &mut (0 | 2) = &mut 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:21:12
+  --> tests/ui/unnested_or_patterns.rs:25:12
    |
 LL |     if let x @ 0 | x @ 2 = 0 {}
    |            ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     if let x @ (0 | 2) = 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:22:12
+  --> tests/ui/unnested_or_patterns.rs:27:12
    |
 LL |     if let (0, 1) | (0, 2) | (0, 3) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     if let (0, 1 | 2 | 3) = (0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:23:12
+  --> tests/ui/unnested_or_patterns.rs:29:12
    |
 LL |     if let (1, 0) | (2, 0) | (3, 0) = (0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     if let (1 | 2 | 3, 0) = (0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:24:12
+  --> tests/ui/unnested_or_patterns.rs:31:12
    |
 LL |     if let (x, ..) | (x, 1) | (x, 2) = (0, 1) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     if let (x, ..) | (x, 1 | 2) = (0, 1) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:25:12
+  --> tests/ui/unnested_or_patterns.rs:33:12
    |
 LL |     if let [0] | [1] = [0] {}
    |            ^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     if let [0 | 1] = [0] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:26:12
+  --> tests/ui/unnested_or_patterns.rs:35:12
    |
 LL |     if let [x, 0] | [x, 1] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     if let [x, 0 | 1] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:27:12
+  --> tests/ui/unnested_or_patterns.rs:37:12
    |
 LL |     if let [x, 0] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -133,7 +133,7 @@ LL +     if let [x, 0 | 1 | 2] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:28:12
+  --> tests/ui/unnested_or_patterns.rs:39:12
    |
 LL |     if let [x, ..] | [x, 1] | [x, 2] = [0, 1] {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     if let [x, ..] | [x, 1 | 2] = [0, 1] {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:30:12
+  --> tests/ui/unnested_or_patterns.rs:42:12
    |
 LL |     if let TS(0, x) | TS(1, x) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -157,7 +157,7 @@ LL +     if let TS(0 | 1, x) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:31:12
+  --> tests/ui/unnested_or_patterns.rs:44:12
    |
 LL |     if let TS(1, 0) | TS(2, 0) | TS(3, 0) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -169,7 +169,7 @@ LL +     if let TS(1 | 2 | 3, 0) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:32:12
+  --> tests/ui/unnested_or_patterns.rs:46:12
    |
 LL |     if let TS(x, ..) | TS(x, 1) | TS(x, 2) = TS(0, 0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -181,7 +181,7 @@ LL +     if let TS(x, ..) | TS(x, 1 | 2) = TS(0, 0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:37:12
+  --> tests/ui/unnested_or_patterns.rs:52:12
    |
 LL |     if let S { x: 0, y } | S { y, x: 1 } = (S { x: 0, y: 1 }) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -193,7 +193,7 @@ LL +     if let S { x: 0 | 1, y } = (S { x: 0, y: 1 }) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns.rs:48:12
+  --> tests/ui/unnested_or_patterns.rs:64:12
    |
 LL |     if let [1] | [53] = [0] {}
    |            ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed b/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed
index b2a4e83dadc3..6d601ea5e57f 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns2.fixed
@@ -10,11 +10,19 @@
 
 fn main() {
     if let Some(Some(0 | 1)) = None {}
+    //~^ unnested_or_patterns
     if let Some(Some(0 | 1 | 2)) = None {}
+    //~^ unnested_or_patterns
     if let Some(Some(0 | 1 | 2 | 3 | 4)) = None {}
+    //~^ unnested_or_patterns
     if let Some(Some(0 | 1 | 2)) = None {}
+    //~^ unnested_or_patterns
     if let ((0 | 1 | 2,),) = ((0,),) {}
+    //~^ unnested_or_patterns
     if let 0 | 1 | 2 = 0 {}
+    //~^ unnested_or_patterns
     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
+    //~^ unnested_or_patterns
     if let box box (0 | 2 | 4) = Box::new(Box::new(0)) {}
+    //~^ unnested_or_patterns
 }
diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns2.rs b/src/tools/clippy/tests/ui/unnested_or_patterns2.rs
index 58435f8990d2..7e5ea0161bff 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns2.rs
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns2.rs
@@ -10,11 +10,19 @@
 
 fn main() {
     if let Some(Some(0)) | Some(Some(1)) = None {}
+    //~^ unnested_or_patterns
     if let Some(Some(0)) | Some(Some(1) | Some(2)) = None {}
+    //~^ unnested_or_patterns
     if let Some(Some(0 | 1) | Some(2)) | Some(Some(3) | Some(4)) = None {}
+    //~^ unnested_or_patterns
     if let Some(Some(0) | Some(1 | 2)) = None {}
+    //~^ unnested_or_patterns
     if let ((0,),) | ((1,) | (2,),) = ((0,),) {}
+    //~^ unnested_or_patterns
     if let 0 | (1 | 2) = 0 {}
+    //~^ unnested_or_patterns
     if let box (0 | 1) | (box 2 | box (3 | 4)) = Box::new(0) {}
+    //~^ unnested_or_patterns
     if let box box 0 | box (box 2 | box 4) = Box::new(Box::new(0)) {}
+    //~^ unnested_or_patterns
 }
diff --git a/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr b/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr
index 3d8968551b96..3fc8fa174c93 100644
--- a/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr
+++ b/src/tools/clippy/tests/ui/unnested_or_patterns2.stderr
@@ -13,7 +13,7 @@ LL +     if let Some(Some(0 | 1)) = None {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns2.rs:13:12
+  --> tests/ui/unnested_or_patterns2.rs:14:12
    |
 LL |     if let Some(Some(0)) | Some(Some(1) | Some(2)) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     if let Some(Some(0 | 1 | 2)) = None {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns2.rs:14:12
+  --> tests/ui/unnested_or_patterns2.rs:16:12
    |
 LL |     if let Some(Some(0 | 1) | Some(2)) | Some(Some(3) | Some(4)) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     if let Some(Some(0 | 1 | 2 | 3 | 4)) = None {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns2.rs:15:12
+  --> tests/ui/unnested_or_patterns2.rs:18:12
    |
 LL |     if let Some(Some(0) | Some(1 | 2)) = None {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     if let Some(Some(0 | 1 | 2)) = None {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns2.rs:16:12
+  --> tests/ui/unnested_or_patterns2.rs:20:12
    |
 LL |     if let ((0,),) | ((1,) | (2,),) = ((0,),) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     if let ((0 | 1 | 2,),) = ((0,),) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns2.rs:17:12
+  --> tests/ui/unnested_or_patterns2.rs:22:12
    |
 LL |     if let 0 | (1 | 2) = 0 {}
    |            ^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     if let 0 | 1 | 2 = 0 {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns2.rs:18:12
+  --> tests/ui/unnested_or_patterns2.rs:24:12
    |
 LL |     if let box (0 | 1) | (box 2 | box (3 | 4)) = Box::new(0) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     if let box (0 | 1 | 2 | 3 | 4) = Box::new(0) {}
    |
 
 error: unnested or-patterns
-  --> tests/ui/unnested_or_patterns2.rs:19:12
+  --> tests/ui/unnested_or_patterns2.rs:26:12
    |
 LL |     if let box box 0 | box (box 2 | box 4) = Box::new(Box::new(0)) {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unreadable_literal.fixed b/src/tools/clippy/tests/ui/unreadable_literal.fixed
index fb9c2672db82..646481ab040b 100644
--- a/src/tools/clippy/tests/ui/unreadable_literal.fixed
+++ b/src/tools/clippy/tests/ui/unreadable_literal.fixed
@@ -29,14 +29,24 @@ fn main() {
         1.123_4_f32,
     );
     let _bad = (0b11_0110_i64, 0x1234_5678_usize, 123_456_f32, 1.234_567_f32);
+    //~^ unreadable_literal
+    //~| unreadable_literal
+    //~| unreadable_literal
+    //~| unreadable_literal
     let _good_sci = 1.1234e1;
     let _bad_sci = 1.123_456e1;
+    //~^ unreadable_literal
 
     let _fail1 = 0x00ab_cdef;
+    //~^ unreadable_literal
     let _fail2: u32 = 0xBAFE_BAFE;
+    //~^ unreadable_literal
     let _fail3 = 0x0abc_deff;
+    //~^ unreadable_literal
     let _fail4: i128 = 0x00ab_cabc_abca_bcab_cabc;
+    //~^ unreadable_literal
     let _fail5 = 1.100_300_400;
+    //~^ unreadable_literal
 
     let _ = foo!();
     let _ = bar!();
diff --git a/src/tools/clippy/tests/ui/unreadable_literal.rs b/src/tools/clippy/tests/ui/unreadable_literal.rs
index 0a24fa852546..973d1a8e196a 100644
--- a/src/tools/clippy/tests/ui/unreadable_literal.rs
+++ b/src/tools/clippy/tests/ui/unreadable_literal.rs
@@ -29,14 +29,24 @@ fn main() {
         1.123_4_f32,
     );
     let _bad = (0b110110_i64, 0x12345678_usize, 123456_f32, 1.234567_f32);
+    //~^ unreadable_literal
+    //~| unreadable_literal
+    //~| unreadable_literal
+    //~| unreadable_literal
     let _good_sci = 1.1234e1;
     let _bad_sci = 1.123456e1;
+    //~^ unreadable_literal
 
     let _fail1 = 0xabcdef;
+    //~^ unreadable_literal
     let _fail2: u32 = 0xBAFEBAFE;
+    //~^ unreadable_literal
     let _fail3 = 0xabcdeff;
+    //~^ unreadable_literal
     let _fail4: i128 = 0xabcabcabcabcabcabc;
+    //~^ unreadable_literal
     let _fail5 = 1.100300400;
+    //~^ unreadable_literal
 
     let _ = foo!();
     let _ = bar!();
diff --git a/src/tools/clippy/tests/ui/unreadable_literal.stderr b/src/tools/clippy/tests/ui/unreadable_literal.stderr
index 5e350d760643..d019bf1b1feb 100644
--- a/src/tools/clippy/tests/ui/unreadable_literal.stderr
+++ b/src/tools/clippy/tests/ui/unreadable_literal.stderr
@@ -26,37 +26,37 @@ LL |     let _bad = (0b110110_i64, 0x12345678_usize, 123456_f32, 1.234567_f32);
    |                                                             ^^^^^^^^^^^^ help: consider: `1.234_567_f32`
 
 error: long literal lacking separators
-  --> tests/ui/unreadable_literal.rs:33:20
+  --> tests/ui/unreadable_literal.rs:37:20
    |
 LL |     let _bad_sci = 1.123456e1;
    |                    ^^^^^^^^^^ help: consider: `1.123_456e1`
 
 error: long literal lacking separators
-  --> tests/ui/unreadable_literal.rs:35:18
+  --> tests/ui/unreadable_literal.rs:40:18
    |
 LL |     let _fail1 = 0xabcdef;
    |                  ^^^^^^^^ help: consider: `0x00ab_cdef`
 
 error: long literal lacking separators
-  --> tests/ui/unreadable_literal.rs:36:23
+  --> tests/ui/unreadable_literal.rs:42:23
    |
 LL |     let _fail2: u32 = 0xBAFEBAFE;
    |                       ^^^^^^^^^^ help: consider: `0xBAFE_BAFE`
 
 error: long literal lacking separators
-  --> tests/ui/unreadable_literal.rs:37:18
+  --> tests/ui/unreadable_literal.rs:44:18
    |
 LL |     let _fail3 = 0xabcdeff;
    |                  ^^^^^^^^^ help: consider: `0x0abc_deff`
 
 error: long literal lacking separators
-  --> tests/ui/unreadable_literal.rs:38:24
+  --> tests/ui/unreadable_literal.rs:46:24
    |
 LL |     let _fail4: i128 = 0xabcabcabcabcabcabc;
    |                        ^^^^^^^^^^^^^^^^^^^^ help: consider: `0x00ab_cabc_abca_bcab_cabc`
 
 error: long literal lacking separators
-  --> tests/ui/unreadable_literal.rs:39:18
+  --> tests/ui/unreadable_literal.rs:48:18
    |
 LL |     let _fail5 = 1.100300400;
    |                  ^^^^^^^^^^^ help: consider: `1.100_300_400`
diff --git a/src/tools/clippy/tests/ui/unsafe_removed_from_name.rs b/src/tools/clippy/tests/ui/unsafe_removed_from_name.rs
index e9e6c8312f5e..2e1d8b60a0e2 100644
--- a/src/tools/clippy/tests/ui/unsafe_removed_from_name.rs
+++ b/src/tools/clippy/tests/ui/unsafe_removed_from_name.rs
@@ -3,11 +3,10 @@
 #![warn(clippy::unsafe_removed_from_name)]
 
 use std::cell::UnsafeCell as TotallySafeCell;
-//~^ ERROR: removed `unsafe` from the name of `UnsafeCell` in use as `TotallySafeCell`
-//~| NOTE: `-D clippy::unsafe-removed-from-name` implied by `-D warnings`
+//~^ unsafe_removed_from_name
 
 use std::cell::UnsafeCell as TotallySafeCellAgain;
-//~^ ERROR: removed `unsafe` from the name of `UnsafeCell` in use as `TotallySafeCellAgain`
+//~^ unsafe_removed_from_name
 
 // Shouldn't error
 use std::cell::RefCell as ProbablyNotUnsafe;
@@ -26,12 +25,12 @@ mod mod_with_some_unsafe_things {
 }
 
 use mod_with_some_unsafe_things::Unsafe as LieAboutModSafety;
-//~^ ERROR: removed `unsafe` from the name of `Unsafe` in use as `LieAboutModSafety`
+//~^ unsafe_removed_from_name
 
 // merged imports
 use mod_with_some_unsafe_things::{Unsafe as A, Unsafe as B};
-//~^ ERROR: removed `unsafe` from the name of `Unsafe` in use as `A`
-//~| ERROR: removed `unsafe` from the name of `Unsafe` in use as `B`
+//~^ unsafe_removed_from_name
+//~| unsafe_removed_from_name
 
 // Shouldn't error
 use mod_with_some_unsafe_things::Safe as IPromiseItsSafeThisTime;
diff --git a/src/tools/clippy/tests/ui/unsafe_removed_from_name.stderr b/src/tools/clippy/tests/ui/unsafe_removed_from_name.stderr
index 998cdbb579f6..5268c16ec9ba 100644
--- a/src/tools/clippy/tests/ui/unsafe_removed_from_name.stderr
+++ b/src/tools/clippy/tests/ui/unsafe_removed_from_name.stderr
@@ -8,25 +8,25 @@ LL | use std::cell::UnsafeCell as TotallySafeCell;
    = help: to override `-D warnings` add `#[allow(clippy::unsafe_removed_from_name)]`
 
 error: removed `unsafe` from the name of `UnsafeCell` in use as `TotallySafeCellAgain`
-  --> tests/ui/unsafe_removed_from_name.rs:9:1
+  --> tests/ui/unsafe_removed_from_name.rs:8:1
    |
 LL | use std::cell::UnsafeCell as TotallySafeCellAgain;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: removed `unsafe` from the name of `Unsafe` in use as `LieAboutModSafety`
-  --> tests/ui/unsafe_removed_from_name.rs:28:1
+  --> tests/ui/unsafe_removed_from_name.rs:27:1
    |
 LL | use mod_with_some_unsafe_things::Unsafe as LieAboutModSafety;
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: removed `unsafe` from the name of `Unsafe` in use as `A`
-  --> tests/ui/unsafe_removed_from_name.rs:32:1
+  --> tests/ui/unsafe_removed_from_name.rs:31:1
    |
 LL | use mod_with_some_unsafe_things::{Unsafe as A, Unsafe as B};
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: removed `unsafe` from the name of `Unsafe` in use as `B`
-  --> tests/ui/unsafe_removed_from_name.rs:32:1
+  --> tests/ui/unsafe_removed_from_name.rs:31:1
    |
 LL | use mod_with_some_unsafe_things::{Unsafe as A, Unsafe as B};
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unseparated_prefix_literals.fixed b/src/tools/clippy/tests/ui/unseparated_prefix_literals.fixed
index 93f7f747b7cd..e13dd561d627 100644
--- a/src/tools/clippy/tests/ui/unseparated_prefix_literals.fixed
+++ b/src/tools/clippy/tests/ui/unseparated_prefix_literals.fixed
@@ -13,6 +13,7 @@ struct Foo;
 macro_rules! lit_from_macro {
     () => {
         42_usize
+        //~^ unseparated_literal_suffix
     };
 }
 
@@ -21,15 +22,22 @@ fn main() {
     let _ok2 = 1234_isize;
     let _ok3 = 0x123_isize;
     let _fail1 = 1234_i32;
+    //~^ unseparated_literal_suffix
     let _fail2 = 1234_u32;
+    //~^ unseparated_literal_suffix
     let _fail3 = 1234_isize;
+    //~^ unseparated_literal_suffix
     let _fail4 = 1234_usize;
+    //~^ unseparated_literal_suffix
     let _fail5 = 0x123_isize;
+    //~^ unseparated_literal_suffix
 
     let _okf1 = 1.5_f32;
     let _okf2 = 1_f32;
     let _failf1 = 1.5_f32;
+    //~^ unseparated_literal_suffix
     let _failf2 = 1_f32;
+    //~^ unseparated_literal_suffix
 
     // Test for macro
     let _ = lit_from_macro!();
@@ -38,4 +46,5 @@ fn main() {
     let _ = line!();
     // Because `assert!` contains `line!()` macro.
     assert_eq!(4897_u32, 32223);
+    //~^ unseparated_literal_suffix
 }
diff --git a/src/tools/clippy/tests/ui/unseparated_prefix_literals.rs b/src/tools/clippy/tests/ui/unseparated_prefix_literals.rs
index c960ff6b5dcc..6f7b16ccba54 100644
--- a/src/tools/clippy/tests/ui/unseparated_prefix_literals.rs
+++ b/src/tools/clippy/tests/ui/unseparated_prefix_literals.rs
@@ -13,6 +13,7 @@ struct Foo;
 macro_rules! lit_from_macro {
     () => {
         42usize
+        //~^ unseparated_literal_suffix
     };
 }
 
@@ -21,15 +22,22 @@ fn main() {
     let _ok2 = 1234_isize;
     let _ok3 = 0x123_isize;
     let _fail1 = 1234i32;
+    //~^ unseparated_literal_suffix
     let _fail2 = 1234u32;
+    //~^ unseparated_literal_suffix
     let _fail3 = 1234isize;
+    //~^ unseparated_literal_suffix
     let _fail4 = 1234usize;
+    //~^ unseparated_literal_suffix
     let _fail5 = 0x123isize;
+    //~^ unseparated_literal_suffix
 
     let _okf1 = 1.5_f32;
     let _okf2 = 1_f32;
     let _failf1 = 1.5f32;
+    //~^ unseparated_literal_suffix
     let _failf2 = 1f32;
+    //~^ unseparated_literal_suffix
 
     // Test for macro
     let _ = lit_from_macro!();
@@ -38,4 +46,5 @@ fn main() {
     let _ = line!();
     // Because `assert!` contains `line!()` macro.
     assert_eq!(4897u32, 32223);
+    //~^ unseparated_literal_suffix
 }
diff --git a/src/tools/clippy/tests/ui/unseparated_prefix_literals.stderr b/src/tools/clippy/tests/ui/unseparated_prefix_literals.stderr
index 1c51f7ada91f..4cfbf5e4b74e 100644
--- a/src/tools/clippy/tests/ui/unseparated_prefix_literals.stderr
+++ b/src/tools/clippy/tests/ui/unseparated_prefix_literals.stderr
@@ -1,5 +1,5 @@
 error: integer type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:23:18
+  --> tests/ui/unseparated_prefix_literals.rs:24:18
    |
 LL |     let _fail1 = 1234i32;
    |                  ^^^^^^^ help: add an underscore: `1234_i32`
@@ -8,37 +8,37 @@ LL |     let _fail1 = 1234i32;
    = help: to override `-D warnings` add `#[allow(clippy::unseparated_literal_suffix)]`
 
 error: integer type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:24:18
+  --> tests/ui/unseparated_prefix_literals.rs:26:18
    |
 LL |     let _fail2 = 1234u32;
    |                  ^^^^^^^ help: add an underscore: `1234_u32`
 
 error: integer type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:25:18
+  --> tests/ui/unseparated_prefix_literals.rs:28:18
    |
 LL |     let _fail3 = 1234isize;
    |                  ^^^^^^^^^ help: add an underscore: `1234_isize`
 
 error: integer type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:26:18
+  --> tests/ui/unseparated_prefix_literals.rs:30:18
    |
 LL |     let _fail4 = 1234usize;
    |                  ^^^^^^^^^ help: add an underscore: `1234_usize`
 
 error: integer type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:27:18
+  --> tests/ui/unseparated_prefix_literals.rs:32:18
    |
 LL |     let _fail5 = 0x123isize;
    |                  ^^^^^^^^^^ help: add an underscore: `0x123_isize`
 
 error: float type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:31:19
+  --> tests/ui/unseparated_prefix_literals.rs:37:19
    |
 LL |     let _failf1 = 1.5f32;
    |                   ^^^^^^ help: add an underscore: `1.5_f32`
 
 error: float type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:32:19
+  --> tests/ui/unseparated_prefix_literals.rs:39:19
    |
 LL |     let _failf2 = 1f32;
    |                   ^^^^ help: add an underscore: `1_f32`
@@ -55,7 +55,7 @@ LL |     let _ = lit_from_macro!();
    = note: this error originates in the macro `lit_from_macro` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: integer type suffix should be separated by an underscore
-  --> tests/ui/unseparated_prefix_literals.rs:40:16
+  --> tests/ui/unseparated_prefix_literals.rs:48:16
    |
 LL |     assert_eq!(4897u32, 32223);
    |                ^^^^^^^ help: add an underscore: `4897_u32`
diff --git a/src/tools/clippy/tests/ui/unused_async.rs b/src/tools/clippy/tests/ui/unused_async.rs
index 838d6f0aa971..5aaf7b9f5b59 100644
--- a/src/tools/clippy/tests/ui/unused_async.rs
+++ b/src/tools/clippy/tests/ui/unused_async.rs
@@ -10,7 +10,8 @@ mod issue10800 {
     use std::future::ready;
 
     async fn async_block_await() {
-        //~^ ERROR: unused `async` for function with no await statements
+        //~^ unused_async
+
         async {
             ready(()).await;
         };
@@ -43,7 +44,7 @@ mod issue9695 {
     async fn f() {}
     async fn f2() {}
     async fn f3() {}
-    //~^ ERROR: unused `async` for function with no await statements
+    //~^ unused_async
 
     fn needs_async_fn<F: Future<Output = ()>>(_: fn() -> F) {}
 
@@ -72,7 +73,8 @@ mod issue13466 {
 }
 
 async fn foo() -> i32 {
-    //~^ ERROR: unused `async` for function with no await statements
+    //~^ unused_async
+
     4
 }
 
@@ -84,7 +86,8 @@ struct S;
 
 impl S {
     async fn unused(&self) -> i32 {
-        //~^ ERROR: unused `async` for function with no await statements
+        //~^ unused_async
+
         1
     }
 
diff --git a/src/tools/clippy/tests/ui/unused_async.stderr b/src/tools/clippy/tests/ui/unused_async.stderr
index 4811df63658a..f95fdd865300 100644
--- a/src/tools/clippy/tests/ui/unused_async.stderr
+++ b/src/tools/clippy/tests/ui/unused_async.stderr
@@ -3,6 +3,7 @@ error: unused `async` for function with no await statements
    |
 LL | /     async fn async_block_await() {
 LL | |
+LL | |
 LL | |         async {
 LL | |             ready(()).await;
 LL | |         };
@@ -11,7 +12,7 @@ LL | |     }
    |
    = help: consider removing the `async` from this function
 note: `await` used in an async block, which does not require the enclosing function to be `async`
-  --> tests/ui/unused_async.rs:15:23
+  --> tests/ui/unused_async.rs:16:23
    |
 LL |             ready(()).await;
    |                       ^^^^^
@@ -19,7 +20,7 @@ LL |             ready(()).await;
    = help: to override `-D warnings` add `#[allow(clippy::unused_async)]`
 
 error: unused `async` for function with no await statements
-  --> tests/ui/unused_async.rs:45:5
+  --> tests/ui/unused_async.rs:46:5
    |
 LL |     async fn f3() {}
    |     ^^^^^^^^^^^^^^^^
@@ -27,10 +28,11 @@ LL |     async fn f3() {}
    = help: consider removing the `async` from this function
 
 error: unused `async` for function with no await statements
-  --> tests/ui/unused_async.rs:74:1
+  --> tests/ui/unused_async.rs:75:1
    |
 LL | / async fn foo() -> i32 {
 LL | |
+LL | |
 LL | |     4
 LL | | }
    | |_^
@@ -38,10 +40,11 @@ LL | | }
    = help: consider removing the `async` from this function
 
 error: unused `async` for function with no await statements
-  --> tests/ui/unused_async.rs:86:5
+  --> tests/ui/unused_async.rs:88:5
    |
 LL | /     async fn unused(&self) -> i32 {
 LL | |
+LL | |
 LL | |         1
 LL | |     }
    | |_____^
diff --git a/src/tools/clippy/tests/ui/unused_enumerate_index.fixed b/src/tools/clippy/tests/ui/unused_enumerate_index.fixed
index cffd02b0acc8..258e52971cea 100644
--- a/src/tools/clippy/tests/ui/unused_enumerate_index.fixed
+++ b/src/tools/clippy/tests/ui/unused_enumerate_index.fixed
@@ -10,6 +10,7 @@ fn get_enumerate() -> Enumerate<std::vec::IntoIter<i32>> {
 fn main() {
     let v = [1, 2, 3];
     for x in v.iter() {
+        //~^ unused_enumerate_index
         println!("{x}");
     }
 
@@ -57,12 +58,15 @@ fn main() {
 
     let dummy = Dummy3(vec![1, 2, 3].into_iter());
     for x in dummy {
+        //~^ unused_enumerate_index
         println!("{x}");
     }
 
     let _ = vec![1, 2, 3].into_iter().map(|x| println!("{x}"));
+    //~^ unused_enumerate_index
 
     let p = vec![1, 2, 3].into_iter();
+    //~^ unused_enumerate_index
     p.map(|x| println!("{x}"));
 
     // This shouldn't trigger the lint. `get_enumerate` may come from an external library on which we
@@ -84,6 +88,7 @@ fn main() {
         };
     }
     _ = mac2!().map(|_v| {});
+    //~^ unused_enumerate_index
 
     // This shouldn't trigger the lint because of the `allow`.
     #[allow(clippy::unused_enumerate_index)]
@@ -92,15 +97,18 @@ fn main() {
 
     // This should keep the explicit type of `x`.
     let v = [1, 2, 3].iter().copied();
+    //~^ unused_enumerate_index
     let x = v.map(|x: i32| x).sum::<i32>();
     assert_eq!(x, 6);
 
     // This should keep the explicit type of `x`.
     let v = [1, 2, 3].iter().copied();
+    //~^ unused_enumerate_index
     let x = v.map(|x: i32| x).sum::<i32>();
     assert_eq!(x, 6);
 
     let v = [1, 2, 3].iter().copied();
+    //~^ unused_enumerate_index
     let x = v.map(|x| x).sum::<i32>();
     assert_eq!(x, 6);
 }
diff --git a/src/tools/clippy/tests/ui/unused_enumerate_index.rs b/src/tools/clippy/tests/ui/unused_enumerate_index.rs
index f2b5f8b91247..a17e3259a9b0 100644
--- a/src/tools/clippy/tests/ui/unused_enumerate_index.rs
+++ b/src/tools/clippy/tests/ui/unused_enumerate_index.rs
@@ -10,6 +10,7 @@ fn get_enumerate() -> Enumerate<std::vec::IntoIter<i32>> {
 fn main() {
     let v = [1, 2, 3];
     for (_, x) in v.iter().enumerate() {
+        //~^ unused_enumerate_index
         println!("{x}");
     }
 
@@ -57,12 +58,15 @@ fn main() {
 
     let dummy = Dummy3(vec![1, 2, 3].into_iter());
     for (_, x) in dummy.enumerate() {
+        //~^ unused_enumerate_index
         println!("{x}");
     }
 
     let _ = vec![1, 2, 3].into_iter().enumerate().map(|(_, x)| println!("{x}"));
+    //~^ unused_enumerate_index
 
     let p = vec![1, 2, 3].into_iter().enumerate();
+    //~^ unused_enumerate_index
     p.map(|(_, x)| println!("{x}"));
 
     // This shouldn't trigger the lint. `get_enumerate` may come from an external library on which we
@@ -84,6 +88,7 @@ fn main() {
         };
     }
     _ = mac2!().enumerate().map(|(_, _v)| {});
+    //~^ unused_enumerate_index
 
     // This shouldn't trigger the lint because of the `allow`.
     #[allow(clippy::unused_enumerate_index)]
@@ -92,15 +97,18 @@ fn main() {
 
     // This should keep the explicit type of `x`.
     let v = [1, 2, 3].iter().copied().enumerate();
+    //~^ unused_enumerate_index
     let x = v.map(|(_, x): (usize, i32)| x).sum::<i32>();
     assert_eq!(x, 6);
 
     // This should keep the explicit type of `x`.
     let v = [1, 2, 3].iter().copied().enumerate();
+    //~^ unused_enumerate_index
     let x = v.map(|(_, x): (_, i32)| x).sum::<i32>();
     assert_eq!(x, 6);
 
     let v = [1, 2, 3].iter().copied().enumerate();
+    //~^ unused_enumerate_index
     let x = v.map(|(_, x)| x).sum::<i32>();
     assert_eq!(x, 6);
 }
diff --git a/src/tools/clippy/tests/ui/unused_enumerate_index.stderr b/src/tools/clippy/tests/ui/unused_enumerate_index.stderr
index 02d65f064308..14d1d20a66e4 100644
--- a/src/tools/clippy/tests/ui/unused_enumerate_index.stderr
+++ b/src/tools/clippy/tests/ui/unused_enumerate_index.stderr
@@ -13,7 +13,7 @@ LL +     for x in v.iter() {
    |
 
 error: you seem to use `.enumerate()` and immediately discard the index
-  --> tests/ui/unused_enumerate_index.rs:59:19
+  --> tests/ui/unused_enumerate_index.rs:60:19
    |
 LL |     for (_, x) in dummy.enumerate() {
    |                   ^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     for x in dummy {
    |
 
 error: you seem to use `.enumerate()` and immediately discard the index
-  --> tests/ui/unused_enumerate_index.rs:63:39
+  --> tests/ui/unused_enumerate_index.rs:65:39
    |
 LL |     let _ = vec![1, 2, 3].into_iter().enumerate().map(|(_, x)| println!("{x}"));
    |                                       ^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     let _ = vec![1, 2, 3].into_iter().map(|x| println!("{x}"));
    |
 
 error: you seem to use `.enumerate()` and immediately discard the index
-  --> tests/ui/unused_enumerate_index.rs:65:39
+  --> tests/ui/unused_enumerate_index.rs:68:39
    |
 LL |     let p = vec![1, 2, 3].into_iter().enumerate();
    |                                       ^^^^^^^^^^^
@@ -45,11 +45,12 @@ LL |     let p = vec![1, 2, 3].into_iter().enumerate();
 help: remove the `.enumerate()` call
    |
 LL ~     let p = vec![1, 2, 3].into_iter();
+LL |
 LL ~     p.map(|x| println!("{x}"));
    |
 
 error: you seem to use `.enumerate()` and immediately discard the index
-  --> tests/ui/unused_enumerate_index.rs:86:17
+  --> tests/ui/unused_enumerate_index.rs:90:17
    |
 LL |     _ = mac2!().enumerate().map(|(_, _v)| {});
    |                 ^^^^^^^^^^^
@@ -60,18 +61,6 @@ LL -     _ = mac2!().enumerate().map(|(_, _v)| {});
 LL +     _ = mac2!().map(|_v| {});
    |
 
-error: you seem to use `.enumerate()` and immediately discard the index
-  --> tests/ui/unused_enumerate_index.rs:94:39
-   |
-LL |     let v = [1, 2, 3].iter().copied().enumerate();
-   |                                       ^^^^^^^^^^^
-   |
-help: remove the `.enumerate()` call
-   |
-LL ~     let v = [1, 2, 3].iter().copied();
-LL ~     let x = v.map(|x: i32| x).sum::<i32>();
-   |
-
 error: you seem to use `.enumerate()` and immediately discard the index
   --> tests/ui/unused_enumerate_index.rs:99:39
    |
@@ -81,11 +70,12 @@ LL |     let v = [1, 2, 3].iter().copied().enumerate();
 help: remove the `.enumerate()` call
    |
 LL ~     let v = [1, 2, 3].iter().copied();
+LL |
 LL ~     let x = v.map(|x: i32| x).sum::<i32>();
    |
 
 error: you seem to use `.enumerate()` and immediately discard the index
-  --> tests/ui/unused_enumerate_index.rs:103:39
+  --> tests/ui/unused_enumerate_index.rs:105:39
    |
 LL |     let v = [1, 2, 3].iter().copied().enumerate();
    |                                       ^^^^^^^^^^^
@@ -93,6 +83,20 @@ LL |     let v = [1, 2, 3].iter().copied().enumerate();
 help: remove the `.enumerate()` call
    |
 LL ~     let v = [1, 2, 3].iter().copied();
+LL |
+LL ~     let x = v.map(|x: i32| x).sum::<i32>();
+   |
+
+error: you seem to use `.enumerate()` and immediately discard the index
+  --> tests/ui/unused_enumerate_index.rs:110:39
+   |
+LL |     let v = [1, 2, 3].iter().copied().enumerate();
+   |                                       ^^^^^^^^^^^
+   |
+help: remove the `.enumerate()` call
+   |
+LL ~     let v = [1, 2, 3].iter().copied();
+LL |
 LL ~     let x = v.map(|x| x).sum::<i32>();
    |
 
diff --git a/src/tools/clippy/tests/ui/unused_format_specs.1.fixed b/src/tools/clippy/tests/ui/unused_format_specs.1.fixed
index 157c2b08d3cf..05bd1df9a523 100644
--- a/src/tools/clippy/tests/ui/unused_format_specs.1.fixed
+++ b/src/tools/clippy/tests/ui/unused_format_specs.1.fixed
@@ -10,18 +10,18 @@ macro_rules! format_args_from_macro {
 fn main() {
     // prints `.`, not `     .`
     println!("{:5}.", format!(""));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
-    //~| NOTE: `-D clippy::unused-format-specs` implied by `-D warnings`
+    //~^ unused_format_specs
+
     //prints `abcde`, not `abc`
     println!("{:.3}", format!("abcde"));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     println!("{}.", format_args_from_macro!());
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     let args = format_args!("");
     println!("{args}");
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 }
 
 fn should_not_lint() {
@@ -46,17 +46,18 @@ macro_rules! usr_println {
 fn should_lint_user() {
     // prints `.`, not `     .`
     usr_println!(true, "{:5}.", format!(""));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
+
     //prints `abcde`, not `abc`
     usr_println!(true, "{:.3}", format!("abcde"));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     usr_println!(true, "{}.", format_args_from_macro!());
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     let args = format_args!("");
     usr_println!(true, "{args}");
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 }
 
 fn should_not_lint_user() {
diff --git a/src/tools/clippy/tests/ui/unused_format_specs.2.fixed b/src/tools/clippy/tests/ui/unused_format_specs.2.fixed
index 92c7b951f3ca..c1f3d4fa20c6 100644
--- a/src/tools/clippy/tests/ui/unused_format_specs.2.fixed
+++ b/src/tools/clippy/tests/ui/unused_format_specs.2.fixed
@@ -10,18 +10,18 @@ macro_rules! format_args_from_macro {
 fn main() {
     // prints `.`, not `     .`
     println!("{}.", format_args!(""));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
-    //~| NOTE: `-D clippy::unused-format-specs` implied by `-D warnings`
+    //~^ unused_format_specs
+
     //prints `abcde`, not `abc`
     println!("{}", format_args!("abcde"));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     println!("{}.", format_args_from_macro!());
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     let args = format_args!("");
     println!("{args}");
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 }
 
 fn should_not_lint() {
@@ -46,17 +46,18 @@ macro_rules! usr_println {
 fn should_lint_user() {
     // prints `.`, not `     .`
     usr_println!(true, "{}.", format_args!(""));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
+
     //prints `abcde`, not `abc`
     usr_println!(true, "{}", format_args!("abcde"));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     usr_println!(true, "{}.", format_args_from_macro!());
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     let args = format_args!("");
     usr_println!(true, "{args}");
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 }
 
 fn should_not_lint_user() {
diff --git a/src/tools/clippy/tests/ui/unused_format_specs.rs b/src/tools/clippy/tests/ui/unused_format_specs.rs
index a5df4d8a8668..b47047ba34e5 100644
--- a/src/tools/clippy/tests/ui/unused_format_specs.rs
+++ b/src/tools/clippy/tests/ui/unused_format_specs.rs
@@ -10,18 +10,18 @@ macro_rules! format_args_from_macro {
 fn main() {
     // prints `.`, not `     .`
     println!("{:5}.", format_args!(""));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
-    //~| NOTE: `-D clippy::unused-format-specs` implied by `-D warnings`
+    //~^ unused_format_specs
+
     //prints `abcde`, not `abc`
     println!("{:.3}", format_args!("abcde"));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     println!("{:5}.", format_args_from_macro!());
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     let args = format_args!("");
     println!("{args:5}");
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 }
 
 fn should_not_lint() {
@@ -46,17 +46,18 @@ macro_rules! usr_println {
 fn should_lint_user() {
     // prints `.`, not `     .`
     usr_println!(true, "{:5}.", format_args!(""));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
+
     //prints `abcde`, not `abc`
     usr_println!(true, "{:.3}", format_args!("abcde"));
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     usr_println!(true, "{:5}.", format_args_from_macro!());
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 
     let args = format_args!("");
     usr_println!(true, "{args:5}");
-    //~^ ERROR: format specifiers have no effect on `format_args!()`
+    //~^ unused_format_specs
 }
 
 fn should_not_lint_user() {
diff --git a/src/tools/clippy/tests/ui/unused_format_specs.stderr b/src/tools/clippy/tests/ui/unused_format_specs.stderr
index d3c0530ced46..b07058fd568d 100644
--- a/src/tools/clippy/tests/ui/unused_format_specs.stderr
+++ b/src/tools/clippy/tests/ui/unused_format_specs.stderr
@@ -78,7 +78,7 @@ LL +     usr_println!(true, "{}.", format_args!(""));
    |
 
 error: format specifiers have no effect on `format_args!()`
-  --> tests/ui/unused_format_specs.rs:51:25
+  --> tests/ui/unused_format_specs.rs:52:25
    |
 LL |     usr_println!(true, "{:.3}", format_args!("abcde"));
    |                         ^^^^^
@@ -95,7 +95,7 @@ LL +     usr_println!(true, "{}", format_args!("abcde"));
    |
 
 error: format specifiers have no effect on `format_args!()`
-  --> tests/ui/unused_format_specs.rs:54:25
+  --> tests/ui/unused_format_specs.rs:55:25
    |
 LL |     usr_println!(true, "{:5}.", format_args_from_macro!());
    |                         ^^^^
@@ -108,7 +108,7 @@ LL +     usr_println!(true, "{}.", format_args_from_macro!());
    |
 
 error: format specifiers have no effect on `format_args!()`
-  --> tests/ui/unused_format_specs.rs:58:25
+  --> tests/ui/unused_format_specs.rs:59:25
    |
 LL |     usr_println!(true, "{args:5}");
    |                         ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unused_io_amount.rs b/src/tools/clippy/tests/ui/unused_io_amount.rs
index 175c4ca76895..32a50375806a 100644
--- a/src/tools/clippy/tests/ui/unused_io_amount.rs
+++ b/src/tools/clippy/tests/ui/unused_io_amount.rs
@@ -8,26 +8,26 @@ use std::io::{self, Read};
 
 fn question_mark<T: io::Read + io::Write>(s: &mut T) -> io::Result<()> {
     s.write(b"test")?;
-    //~^ ERROR: written amount is not handled
+    //~^ unused_io_amount
     let mut buf = [0u8; 4];
     s.read(&mut buf)?;
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
     Ok(())
 }
 
 fn unwrap<T: io::Read + io::Write>(s: &mut T) {
     s.write(b"test").unwrap();
-    //~^ ERROR: written amount is not handled
+    //~^ unused_io_amount
     let mut buf = [0u8; 4];
     s.read(&mut buf).unwrap();
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
 }
 
 fn vectored<T: io::Read + io::Write>(s: &mut T) -> io::Result<()> {
     s.read_vectored(&mut [io::IoSliceMut::new(&mut [])])?;
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
     s.write_vectored(&[io::IoSlice::new(&[])])?;
-    //~^ ERROR: written amount is not handled
+    //~^ unused_io_amount
     Ok(())
 }
 
@@ -35,7 +35,7 @@ fn ok(file: &str) -> Option<()> {
     let mut reader = std::fs::File::open(file).ok()?;
     let mut result = [0u8; 0];
     reader.read(&mut result).ok()?;
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
     Some(())
 }
 
@@ -45,7 +45,7 @@ fn or_else(file: &str) -> io::Result<()> {
     let mut reader = std::fs::File::open(file)?;
     let mut result = [0u8; 0];
     reader.read(&mut result).or_else(|err| Err(err))?;
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
     Ok(())
 }
 
@@ -58,7 +58,7 @@ fn or(file: &str) -> Result<(), Error> {
     let mut reader = std::fs::File::open(file).unwrap();
     let mut result = [0u8; 0];
     reader.read(&mut result).or(Err(Error::Kind))?;
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
     Ok(())
 }
 
@@ -66,7 +66,7 @@ fn combine_or(file: &str) -> Result<(), Error> {
     let mut reader = std::fs::File::open(file).unwrap();
     let mut result = [0u8; 0];
     reader
-        //~^ ERROR: read amount is not handled
+        //~^ unused_io_amount
         .read(&mut result)
         .or(Err(Error::Kind))
         .or(Err(Error::Kind))
@@ -76,25 +76,25 @@ fn combine_or(file: &str) -> Result<(), Error> {
 
 fn is_ok_err<T: io::Read + io::Write>(s: &mut T) {
     s.write(b"ok").is_ok();
-    //~^ ERROR: written amount is not handled
+    //~^ unused_io_amount
     s.write(b"err").is_err();
-    //~^ ERROR: written amount is not handled
+    //~^ unused_io_amount
     let mut buf = [0u8; 0];
     s.read(&mut buf).is_ok();
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
     s.read(&mut buf).is_err();
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
 }
 
 async fn bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
     w.write(b"hello world").await.unwrap();
-    //~^ ERROR: written amount is not handled
+    //~^ unused_io_amount
 }
 
 async fn bad_async_read<R: AsyncRead + Unpin>(r: &mut R) {
     let mut buf = [0u8; 0];
     r.read(&mut buf[..]).await.unwrap();
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
 }
 
 async fn io_not_ignored_async_write<W: AsyncWrite + Unpin>(mut w: W) {
@@ -102,13 +102,14 @@ async fn io_not_ignored_async_write<W: AsyncWrite + Unpin>(mut w: W) {
     // warning about _that_ (or we would, if it were enabled), but we
     // won't get one about ignoring the return value.
     w.write(b"hello world");
+    //~^ unused_io_amount
 }
 
 fn bad_async_write_closure<W: AsyncWrite + Unpin + 'static>(w: W) -> impl futures::Future<Output = io::Result<()>> {
     let mut w = w;
     async move {
         w.write(b"hello world").await?;
-        //~^ ERROR: written amount is not handled
+        //~^ unused_io_amount
         Ok(())
     }
 }
@@ -117,7 +118,7 @@ async fn async_read_nested_or<R: AsyncRead + Unpin>(r: &mut R, do_it: bool) -> R
     let mut buf = [0u8; 1];
     if do_it {
         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
-        //~^ ERROR: read amount is not handled
+        //~^ unused_io_amount
     }
     Ok(buf)
 }
@@ -126,13 +127,13 @@ use tokio::io::{AsyncRead as TokioAsyncRead, AsyncReadExt as _, AsyncWrite as To
 
 async fn bad_async_write_tokio<W: TokioAsyncWrite + Unpin>(w: &mut W) {
     w.write(b"hello world").await.unwrap();
-    //~^ ERROR: written amount is not handled
+    //~^ unused_io_amount
 }
 
 async fn bad_async_read_tokio<R: TokioAsyncRead + Unpin>(r: &mut R) {
     let mut buf = [0u8; 0];
     r.read(&mut buf[..]).await.unwrap();
-    //~^ ERROR: read amount is not handled
+    //~^ unused_io_amount
 }
 
 async fn undetected_bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
@@ -145,35 +146,31 @@ async fn undetected_bad_async_write<W: AsyncWrite + Unpin>(w: &mut W) {
 
 fn match_okay_underscore<T: io::Read + io::Write>(s: &mut T) {
     match s.write(b"test") {
-        //~^ ERROR: written amount is not handled
+        //~^ unused_io_amount
         Ok(_) => todo!(),
-        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
         Err(_) => todo!(),
     };
 
     let mut buf = [0u8; 4];
     match s.read(&mut buf) {
-        //~^ ERROR: read amount is not handled
+        //~^ unused_io_amount
         Ok(_) => todo!(),
-        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
         Err(_) => todo!(),
     }
 }
 
 fn match_okay_underscore_read_expr<T: io::Read + io::Write>(s: &mut T) {
     match s.read(&mut [0u8; 4]) {
-        //~^ ERROR: read amount is not handled
+        //~^ unused_io_amount
         Ok(_) => todo!(),
-        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
         Err(_) => todo!(),
     }
 }
 
 fn match_okay_underscore_write_expr<T: io::Read + io::Write>(s: &mut T) {
     match s.write(b"test") {
-        //~^ ERROR: written amount is not handled
+        //~^ unused_io_amount
         Ok(_) => todo!(),
-        //~^ NOTE: the result is consumed here, but the amount of I/O bytes remains unhandled
         Err(_) => todo!(),
     }
 }
@@ -184,21 +181,21 @@ fn returned_value_should_not_lint<T: io::Read + io::Write>(s: &mut T) -> Result<
 
 fn if_okay_underscore_read_expr<T: io::Read + io::Write>(s: &mut T) {
     if let Ok(_) = s.read(&mut [0u8; 4]) {
-        //~^ ERROR: read amount is not handled
+        //~^ unused_io_amount
         todo!()
     }
 }
 
 fn if_okay_underscore_write_expr<T: io::Read + io::Write>(s: &mut T) {
     if let Ok(_) = s.write(b"test") {
-        //~^ ERROR: written amount is not handled
+        //~^ unused_io_amount
         todo!()
     }
 }
 
 fn if_okay_dots_write_expr<T: io::Read + io::Write>(s: &mut T) {
     if let Ok(..) = s.write(b"test") {
-        //~^ ERROR: written amount is not handled
+        //~^ unused_io_amount
         todo!()
     }
 }
diff --git a/src/tools/clippy/tests/ui/unused_io_amount.stderr b/src/tools/clippy/tests/ui/unused_io_amount.stderr
index 771e463ca010..71bb4c40de84 100644
--- a/src/tools/clippy/tests/ui/unused_io_amount.stderr
+++ b/src/tools/clippy/tests/ui/unused_io_amount.stderr
@@ -138,7 +138,7 @@ LL |     w.write(b"hello world");
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: written amount is not handled
-  --> tests/ui/unused_io_amount.rs:110:9
+  --> tests/ui/unused_io_amount.rs:111:9
    |
 LL |         w.write(b"hello world").await?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -146,7 +146,7 @@ LL |         w.write(b"hello world").await?;
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> tests/ui/unused_io_amount.rs:119:9
+  --> tests/ui/unused_io_amount.rs:120:9
    |
 LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -154,7 +154,7 @@ LL |         r.read(&mut buf[..]).await.or(Err(Error::Kind))?;
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> tests/ui/unused_io_amount.rs:128:5
+  --> tests/ui/unused_io_amount.rs:129:5
    |
 LL |     w.write(b"hello world").await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -162,7 +162,7 @@ LL |     w.write(b"hello world").await.unwrap();
    = help: use `AsyncWriteExt::write_all` instead, or handle partial writes
 
 error: read amount is not handled
-  --> tests/ui/unused_io_amount.rs:134:5
+  --> tests/ui/unused_io_amount.rs:135:5
    |
 LL |     r.read(&mut buf[..]).await.unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -170,14 +170,14 @@ LL |     r.read(&mut buf[..]).await.unwrap();
    = help: use `AsyncReadExt::read_exact` instead, or handle partial reads
 
 error: written amount is not handled
-  --> tests/ui/unused_io_amount.rs:147:11
+  --> tests/ui/unused_io_amount.rs:148:11
    |
 LL |     match s.write(b"test") {
    |           ^^^^^^^^^^^^^^^^
    |
    = help: use `Write::write_all` instead, or handle partial writes
 note: the result is consumed here, but the amount of I/O bytes remains unhandled
-  --> tests/ui/unused_io_amount.rs:149:9
+  --> tests/ui/unused_io_amount.rs:150:9
    |
 LL |         Ok(_) => todo!(),
    |         ^^^^^
@@ -196,66 +196,66 @@ LL |         Ok(_) => todo!(),
    |         ^^^^^
 
 error: read amount is not handled
-  --> tests/ui/unused_io_amount.rs:164:11
+  --> tests/ui/unused_io_amount.rs:163:11
    |
 LL |     match s.read(&mut [0u8; 4]) {
    |           ^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `Read::read_exact` instead, or handle partial reads
 note: the result is consumed here, but the amount of I/O bytes remains unhandled
-  --> tests/ui/unused_io_amount.rs:166:9
+  --> tests/ui/unused_io_amount.rs:165:9
    |
 LL |         Ok(_) => todo!(),
    |         ^^^^^
 
 error: written amount is not handled
-  --> tests/ui/unused_io_amount.rs:173:11
+  --> tests/ui/unused_io_amount.rs:171:11
    |
 LL |     match s.write(b"test") {
    |           ^^^^^^^^^^^^^^^^
    |
    = help: use `Write::write_all` instead, or handle partial writes
 note: the result is consumed here, but the amount of I/O bytes remains unhandled
-  --> tests/ui/unused_io_amount.rs:175:9
+  --> tests/ui/unused_io_amount.rs:173:9
    |
 LL |         Ok(_) => todo!(),
    |         ^^^^^
 
 error: read amount is not handled
-  --> tests/ui/unused_io_amount.rs:186:8
+  --> tests/ui/unused_io_amount.rs:183:8
    |
 LL |     if let Ok(_) = s.read(&mut [0u8; 4]) {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `Read::read_exact` instead, or handle partial reads
 note: the result is consumed here, but the amount of I/O bytes remains unhandled
-  --> tests/ui/unused_io_amount.rs:186:12
+  --> tests/ui/unused_io_amount.rs:183:12
    |
 LL |     if let Ok(_) = s.read(&mut [0u8; 4]) {
    |            ^^^^^
 
 error: written amount is not handled
-  --> tests/ui/unused_io_amount.rs:193:8
+  --> tests/ui/unused_io_amount.rs:190:8
    |
 LL |     if let Ok(_) = s.write(b"test") {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `Write::write_all` instead, or handle partial writes
 note: the result is consumed here, but the amount of I/O bytes remains unhandled
-  --> tests/ui/unused_io_amount.rs:193:12
+  --> tests/ui/unused_io_amount.rs:190:12
    |
 LL |     if let Ok(_) = s.write(b"test") {
    |            ^^^^^
 
 error: written amount is not handled
-  --> tests/ui/unused_io_amount.rs:200:8
+  --> tests/ui/unused_io_amount.rs:197:8
    |
 LL |     if let Ok(..) = s.write(b"test") {
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: use `Write::write_all` instead, or handle partial writes
 note: the result is consumed here, but the amount of I/O bytes remains unhandled
-  --> tests/ui/unused_io_amount.rs:200:12
+  --> tests/ui/unused_io_amount.rs:197:12
    |
 LL |     if let Ok(..) = s.write(b"test") {
    |            ^^^^^^
diff --git a/src/tools/clippy/tests/ui/unused_peekable.rs b/src/tools/clippy/tests/ui/unused_peekable.rs
index 5865bba43508..e7fe297764eb 100644
--- a/src/tools/clippy/tests/ui/unused_peekable.rs
+++ b/src/tools/clippy/tests/ui/unused_peekable.rs
@@ -11,17 +11,17 @@ fn main() {
 #[allow(clippy::unused_unit)]
 fn invalid() {
     let peekable = std::iter::empty::<u32>().peekable();
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
 
     // Only lint `new_local`
     let old_local = std::iter::empty::<u32>().peekable();
     let new_local = old_local;
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
 
     // Behind mut ref
     let mut by_mut_ref_test = std::iter::empty::<u32>().peekable();
     let by_mut_ref = &mut by_mut_ref_test;
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
 
     // Explicitly returns `Peekable`
     fn returns_peekable() -> Peekable<Empty<u32>> {
@@ -29,26 +29,29 @@ fn invalid() {
     }
 
     let peekable_from_fn = returns_peekable();
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
 
     // Using a method not exclusive to `Peekable`
     let mut peekable_using_iterator_method = std::iter::empty::<u32>().peekable();
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
+
     peekable_using_iterator_method.next();
 
     // Passed by ref to another function
     fn takes_ref(_peek: &Peekable<Empty<u32>>) {}
     let passed_along_ref = std::iter::empty::<u32>().peekable();
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
+
     takes_ref(&passed_along_ref);
 
     // `by_ref` without `peek`
     let mut by_ref_test = std::iter::empty::<u32>().peekable();
     let _by_ref = by_ref_test.by_ref();
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
 
     let mut peekable_in_for_loop = std::iter::empty::<u32>().peekable();
-    //~^ ERROR: `peek` never called on `Peekable` iterator
+    //~^ unused_peekable
+
     for x in peekable_in_for_loop {}
 }
 
diff --git a/src/tools/clippy/tests/ui/unused_peekable.stderr b/src/tools/clippy/tests/ui/unused_peekable.stderr
index 00c6a52bab33..9330d8c58001 100644
--- a/src/tools/clippy/tests/ui/unused_peekable.stderr
+++ b/src/tools/clippy/tests/ui/unused_peekable.stderr
@@ -41,7 +41,7 @@ LL |     let mut peekable_using_iterator_method = std::iter::empty::<u32>().peek
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> tests/ui/unused_peekable.rs:41:9
+  --> tests/ui/unused_peekable.rs:42:9
    |
 LL |     let passed_along_ref = std::iter::empty::<u32>().peekable();
    |         ^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     let passed_along_ref = std::iter::empty::<u32>().peekable();
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> tests/ui/unused_peekable.rs:47:9
+  --> tests/ui/unused_peekable.rs:49:9
    |
 LL |     let _by_ref = by_ref_test.by_ref();
    |         ^^^^^^^
@@ -57,7 +57,7 @@ LL |     let _by_ref = by_ref_test.by_ref();
    = help: consider removing the call to `peekable`
 
 error: `peek` never called on `Peekable` iterator
-  --> tests/ui/unused_peekable.rs:50:13
+  --> tests/ui/unused_peekable.rs:52:13
    |
 LL |     let mut peekable_in_for_loop = std::iter::empty::<u32>().peekable();
    |             ^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unused_result_ok.fixed b/src/tools/clippy/tests/ui/unused_result_ok.fixed
index e78fde5c9e3c..faedd96216c2 100644
--- a/src/tools/clippy/tests/ui/unused_result_ok.fixed
+++ b/src/tools/clippy/tests/ui/unused_result_ok.fixed
@@ -7,6 +7,7 @@ extern crate proc_macros;
 
 fn bad_style(x: &str) {
     let _ = x.parse::<u32>();
+    //~^ unused_result_ok
 }
 
 fn good_style(x: &str) -> Option<u32> {
@@ -16,6 +17,7 @@ fn good_style(x: &str) -> Option<u32> {
 #[rustfmt::skip]
 fn strange_parse(x: &str) {
     let _ = x   .   parse::<i32>();
+    //~^ unused_result_ok
 }
 
 macro_rules! v {
@@ -27,11 +29,13 @@ macro_rules! v {
 macro_rules! w {
     () => {
         let _ = Ok::<(), ()>(());
+        //~^ unused_result_ok
     };
 }
 
 fn main() {
     let _ = v!();
+    //~^ unused_result_ok
     w!();
 
     external! {
diff --git a/src/tools/clippy/tests/ui/unused_result_ok.rs b/src/tools/clippy/tests/ui/unused_result_ok.rs
index 117d64c4cec6..6ab974861b63 100644
--- a/src/tools/clippy/tests/ui/unused_result_ok.rs
+++ b/src/tools/clippy/tests/ui/unused_result_ok.rs
@@ -7,6 +7,7 @@ extern crate proc_macros;
 
 fn bad_style(x: &str) {
     x.parse::<u32>().ok();
+    //~^ unused_result_ok
 }
 
 fn good_style(x: &str) -> Option<u32> {
@@ -16,6 +17,7 @@ fn good_style(x: &str) -> Option<u32> {
 #[rustfmt::skip]
 fn strange_parse(x: &str) {
     x   .   parse::<i32>()   .   ok   ();
+    //~^ unused_result_ok
 }
 
 macro_rules! v {
@@ -27,11 +29,13 @@ macro_rules! v {
 macro_rules! w {
     () => {
         Ok::<(), ()>(()).ok();
+        //~^ unused_result_ok
     };
 }
 
 fn main() {
     v!().ok();
+    //~^ unused_result_ok
     w!();
 
     external! {
diff --git a/src/tools/clippy/tests/ui/unused_result_ok.stderr b/src/tools/clippy/tests/ui/unused_result_ok.stderr
index 024aafa6bbb8..0e134ba3ccba 100644
--- a/src/tools/clippy/tests/ui/unused_result_ok.stderr
+++ b/src/tools/clippy/tests/ui/unused_result_ok.stderr
@@ -13,7 +13,7 @@ LL +     let _ = x.parse::<u32>();
    |
 
 error: ignoring a result with `.ok()` is misleading
-  --> tests/ui/unused_result_ok.rs:18:5
+  --> tests/ui/unused_result_ok.rs:19:5
    |
 LL |     x   .   parse::<i32>()   .   ok   ();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL +     let _ = x   .   parse::<i32>();
    |
 
 error: ignoring a result with `.ok()` is misleading
-  --> tests/ui/unused_result_ok.rs:34:5
+  --> tests/ui/unused_result_ok.rs:37:5
    |
 LL |     v!().ok();
    |     ^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     let _ = v!();
    |
 
 error: ignoring a result with `.ok()` is misleading
-  --> tests/ui/unused_result_ok.rs:29:9
+  --> tests/ui/unused_result_ok.rs:31:9
    |
 LL |         Ok::<(), ()>(()).ok();
    |         ^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unused_rounding.fixed b/src/tools/clippy/tests/ui/unused_rounding.fixed
index 7af2c8650a3d..461d97c55531 100644
--- a/src/tools/clippy/tests/ui/unused_rounding.fixed
+++ b/src/tools/clippy/tests/ui/unused_rounding.fixed
@@ -4,15 +4,20 @@
 
 fn main() {
     let _ = 1f32;
+    //~^ unused_rounding
     let _ = 1.0f64;
+    //~^ unused_rounding
     let _ = 1.00f32;
+    //~^ unused_rounding
     let _ = 2e-54f64.floor();
 
     // issue9866
     let _ = 3.3_f32.round();
     let _ = 3.3_f64.round();
     let _ = 3.0_f32;
+    //~^ unused_rounding
 
     let _ = 3_3.0_0_f32;
+    //~^ unused_rounding
     let _ = 3_3.0_1_f64.round();
 }
diff --git a/src/tools/clippy/tests/ui/unused_rounding.rs b/src/tools/clippy/tests/ui/unused_rounding.rs
index 1b0b22a9b685..0d5ebf941a5e 100644
--- a/src/tools/clippy/tests/ui/unused_rounding.rs
+++ b/src/tools/clippy/tests/ui/unused_rounding.rs
@@ -4,15 +4,20 @@
 
 fn main() {
     let _ = 1f32.ceil();
+    //~^ unused_rounding
     let _ = 1.0f64.floor();
+    //~^ unused_rounding
     let _ = 1.00f32.round();
+    //~^ unused_rounding
     let _ = 2e-54f64.floor();
 
     // issue9866
     let _ = 3.3_f32.round();
     let _ = 3.3_f64.round();
     let _ = 3.0_f32.round();
+    //~^ unused_rounding
 
     let _ = 3_3.0_0_f32.round();
+    //~^ unused_rounding
     let _ = 3_3.0_1_f64.round();
 }
diff --git a/src/tools/clippy/tests/ui/unused_rounding.stderr b/src/tools/clippy/tests/ui/unused_rounding.stderr
index c5ae2da75f84..494b0cc7352d 100644
--- a/src/tools/clippy/tests/ui/unused_rounding.stderr
+++ b/src/tools/clippy/tests/ui/unused_rounding.stderr
@@ -8,25 +8,25 @@ LL |     let _ = 1f32.ceil();
    = help: to override `-D warnings` add `#[allow(clippy::unused_rounding)]`
 
 error: used the `floor` method with a whole number float
-  --> tests/ui/unused_rounding.rs:7:13
+  --> tests/ui/unused_rounding.rs:8:13
    |
 LL |     let _ = 1.0f64.floor();
    |             ^^^^^^^^^^^^^^ help: remove the `floor` method call: `1.0f64`
 
 error: used the `round` method with a whole number float
-  --> tests/ui/unused_rounding.rs:8:13
+  --> tests/ui/unused_rounding.rs:10:13
    |
 LL |     let _ = 1.00f32.round();
    |             ^^^^^^^^^^^^^^^ help: remove the `round` method call: `1.00f32`
 
 error: used the `round` method with a whole number float
-  --> tests/ui/unused_rounding.rs:14:13
+  --> tests/ui/unused_rounding.rs:17:13
    |
 LL |     let _ = 3.0_f32.round();
    |             ^^^^^^^^^^^^^^^ help: remove the `round` method call: `3.0_f32`
 
 error: used the `round` method with a whole number float
-  --> tests/ui/unused_rounding.rs:16:13
+  --> tests/ui/unused_rounding.rs:20:13
    |
 LL |     let _ = 3_3.0_0_f32.round();
    |             ^^^^^^^^^^^^^^^^^^^ help: remove the `round` method call: `3_3.0_0_f32`
diff --git a/src/tools/clippy/tests/ui/unused_self.rs b/src/tools/clippy/tests/ui/unused_self.rs
index d3d06037cb49..cb80d946aced 100644
--- a/src/tools/clippy/tests/ui/unused_self.rs
+++ b/src/tools/clippy/tests/ui/unused_self.rs
@@ -9,25 +9,34 @@ mod unused_self {
 
     impl A {
         fn unused_self_move(self) {}
-        //~^ ERROR: unused `self` argument
+        //~^ unused_self
+
         fn unused_self_ref(&self) {}
-        //~^ ERROR: unused `self` argument
+        //~^ unused_self
+
         fn unused_self_mut_ref(&mut self) {}
-        //~^ ERROR: unused `self` argument
+        //~^ unused_self
+
         fn unused_self_pin_ref(self: Pin<&Self>) {}
-        //~^ ERROR: unused `self` argument
+        //~^ unused_self
+
         fn unused_self_pin_mut_ref(self: Pin<&mut Self>) {}
-        //~^ ERROR: unused `self` argument
+        //~^ unused_self
+
         fn unused_self_pin_nested(self: Pin<Arc<Self>>) {}
-        //~^ ERROR: unused `self` argument
+        //~^ unused_self
+
         fn unused_self_box(self: Box<Self>) {}
-        //~^ ERROR: unused `self` argument
+        //~^ unused_self
+
         fn unused_with_other_used_args(&self, x: u8, y: u8) -> u8 {
-            //~^ ERROR: unused `self` argument
+            //~^ unused_self
+
             x + y
         }
         fn unused_self_class_method(&self) {
-            //~^ ERROR: unused `self` argument
+            //~^ unused_self
+
             Self::static_method();
         }
 
diff --git a/src/tools/clippy/tests/ui/unused_self.stderr b/src/tools/clippy/tests/ui/unused_self.stderr
index 5d5f1b643a4a..e29f5f96c886 100644
--- a/src/tools/clippy/tests/ui/unused_self.stderr
+++ b/src/tools/clippy/tests/ui/unused_self.stderr
@@ -9,7 +9,7 @@ LL |         fn unused_self_move(self) {}
    = help: to override `-D warnings` add `#[allow(clippy::unused_self)]`
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:13:28
+  --> tests/ui/unused_self.rs:14:28
    |
 LL |         fn unused_self_ref(&self) {}
    |                            ^^^^^
@@ -17,7 +17,7 @@ LL |         fn unused_self_ref(&self) {}
    = help: consider refactoring to an associated function
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:15:32
+  --> tests/ui/unused_self.rs:17:32
    |
 LL |         fn unused_self_mut_ref(&mut self) {}
    |                                ^^^^^^^^^
@@ -25,7 +25,7 @@ LL |         fn unused_self_mut_ref(&mut self) {}
    = help: consider refactoring to an associated function
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:17:32
+  --> tests/ui/unused_self.rs:20:32
    |
 LL |         fn unused_self_pin_ref(self: Pin<&Self>) {}
    |                                ^^^^
@@ -33,7 +33,7 @@ LL |         fn unused_self_pin_ref(self: Pin<&Self>) {}
    = help: consider refactoring to an associated function
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:19:36
+  --> tests/ui/unused_self.rs:23:36
    |
 LL |         fn unused_self_pin_mut_ref(self: Pin<&mut Self>) {}
    |                                    ^^^^
@@ -41,7 +41,7 @@ LL |         fn unused_self_pin_mut_ref(self: Pin<&mut Self>) {}
    = help: consider refactoring to an associated function
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:21:35
+  --> tests/ui/unused_self.rs:26:35
    |
 LL |         fn unused_self_pin_nested(self: Pin<Arc<Self>>) {}
    |                                   ^^^^
@@ -49,7 +49,7 @@ LL |         fn unused_self_pin_nested(self: Pin<Arc<Self>>) {}
    = help: consider refactoring to an associated function
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:23:28
+  --> tests/ui/unused_self.rs:29:28
    |
 LL |         fn unused_self_box(self: Box<Self>) {}
    |                            ^^^^
@@ -57,7 +57,7 @@ LL |         fn unused_self_box(self: Box<Self>) {}
    = help: consider refactoring to an associated function
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:25:40
+  --> tests/ui/unused_self.rs:32:40
    |
 LL |         fn unused_with_other_used_args(&self, x: u8, y: u8) -> u8 {
    |                                        ^^^^^
@@ -65,7 +65,7 @@ LL |         fn unused_with_other_used_args(&self, x: u8, y: u8) -> u8 {
    = help: consider refactoring to an associated function
 
 error: unused `self` argument
-  --> tests/ui/unused_self.rs:29:37
+  --> tests/ui/unused_self.rs:37:37
    |
 LL |         fn unused_self_class_method(&self) {
    |                                     ^^^^^
diff --git a/src/tools/clippy/tests/ui/unused_trait_names.fixed b/src/tools/clippy/tests/ui/unused_trait_names.fixed
index 7dfd0db65aa1..17e32ddfd9d9 100644
--- a/src/tools/clippy/tests/ui/unused_trait_names.fixed
+++ b/src/tools/clippy/tests/ui/unused_trait_names.fixed
@@ -10,6 +10,7 @@ fn main() {}
 
 fn bad() {
     use std::any::Any as _;
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
@@ -29,6 +30,7 @@ fn used_good() {
 
 fn multi_bad() {
     use std::any::{self, Any as _, TypeId};
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
@@ -41,12 +43,14 @@ fn multi_good() {
 
 fn renamed_bad() {
     use std::any::Any as _;
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
 
 fn multi_renamed_bad() {
     use std::any::{Any as _, TypeId as MyTypeId};
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
@@ -70,6 +74,7 @@ mod used_mod_good {
 mod mod_import_bad {
     fn mod_import_bad() {
         use std::any::Any as _;
+        //~^ unused_trait_names
 
         println!("{:?}", "foo".type_id());
     }
@@ -111,6 +116,7 @@ mod nested_mod_used_good3 {
 
 mod nested_mod_used_bad {
     use std::any::Any as _;
+    //~^ unused_trait_names
 
     fn bar() {
         println!("{:?}", "foo".type_id());
@@ -130,6 +136,7 @@ mod nested_mod_used_bad {
 // the code would still compile.
 mod nested_mod_used_bad1 {
     use std::any::Any as _;
+    //~^ unused_trait_names
 
     use std::any::Any as MyAny;
 
@@ -189,6 +196,7 @@ fn msrv_1_32() {
 #[clippy::msrv = "1.33"]
 fn msrv_1_33() {
     use simple_trait::{MyStruct, MyTrait as _};
+    //~^ unused_trait_names
     MyStruct.do_things();
 }
 
@@ -196,6 +204,7 @@ mod lint_inside_macro_expansion_bad {
     macro_rules! foo {
         () => {
             use std::any::Any as _;
+            //~^ unused_trait_names
             fn bar() {
                 "bar".type_id();
             }
@@ -243,6 +252,7 @@ proc_macros::with_span!(
 #[warn(unused)]
 mod unused_import {
     
+    //~^ ERROR: unused import
 }
 
 #[allow(clippy::unused_trait_names)]
diff --git a/src/tools/clippy/tests/ui/unused_trait_names.rs b/src/tools/clippy/tests/ui/unused_trait_names.rs
index ce44eedbc79c..3cf8597e5351 100644
--- a/src/tools/clippy/tests/ui/unused_trait_names.rs
+++ b/src/tools/clippy/tests/ui/unused_trait_names.rs
@@ -10,6 +10,7 @@ fn main() {}
 
 fn bad() {
     use std::any::Any;
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
@@ -29,6 +30,7 @@ fn used_good() {
 
 fn multi_bad() {
     use std::any::{self, Any, TypeId};
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
@@ -41,12 +43,14 @@ fn multi_good() {
 
 fn renamed_bad() {
     use std::any::Any as MyAny;
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
 
 fn multi_renamed_bad() {
     use std::any::{Any as MyAny, TypeId as MyTypeId};
+    //~^ unused_trait_names
 
     println!("{:?}", "foo".type_id());
 }
@@ -70,6 +74,7 @@ mod used_mod_good {
 mod mod_import_bad {
     fn mod_import_bad() {
         use std::any::Any;
+        //~^ unused_trait_names
 
         println!("{:?}", "foo".type_id());
     }
@@ -111,6 +116,7 @@ mod nested_mod_used_good3 {
 
 mod nested_mod_used_bad {
     use std::any::Any;
+    //~^ unused_trait_names
 
     fn bar() {
         println!("{:?}", "foo".type_id());
@@ -130,6 +136,7 @@ mod nested_mod_used_bad {
 // the code would still compile.
 mod nested_mod_used_bad1 {
     use std::any::Any;
+    //~^ unused_trait_names
 
     use std::any::Any as MyAny;
 
@@ -189,6 +196,7 @@ fn msrv_1_32() {
 #[clippy::msrv = "1.33"]
 fn msrv_1_33() {
     use simple_trait::{MyStruct, MyTrait};
+    //~^ unused_trait_names
     MyStruct.do_things();
 }
 
@@ -196,6 +204,7 @@ mod lint_inside_macro_expansion_bad {
     macro_rules! foo {
         () => {
             use std::any::Any;
+            //~^ unused_trait_names
             fn bar() {
                 "bar".type_id();
             }
@@ -243,6 +252,7 @@ proc_macros::with_span!(
 #[warn(unused)]
 mod unused_import {
     use std::any::Any;
+    //~^ ERROR: unused import
 }
 
 #[allow(clippy::unused_trait_names)]
diff --git a/src/tools/clippy/tests/ui/unused_trait_names.stderr b/src/tools/clippy/tests/ui/unused_trait_names.stderr
index f59d8f58a170..3183289d8533 100644
--- a/src/tools/clippy/tests/ui/unused_trait_names.stderr
+++ b/src/tools/clippy/tests/ui/unused_trait_names.stderr
@@ -1,5 +1,5 @@
 error: unused import: `std::any::Any`
-  --> tests/ui/unused_trait_names.rs:245:9
+  --> tests/ui/unused_trait_names.rs:254:9
    |
 LL |     use std::any::Any;
    |         ^^^^^^^^^^^^^
@@ -17,49 +17,49 @@ LL |     use std::any::Any;
    = help: to override `-D warnings` add `#[allow(clippy::unused_trait_names)]`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:31:26
+  --> tests/ui/unused_trait_names.rs:32:26
    |
 LL |     use std::any::{self, Any, TypeId};
    |                          ^^^ help: use: `Any as _`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:43:19
+  --> tests/ui/unused_trait_names.rs:45:19
    |
 LL |     use std::any::Any as MyAny;
    |                   ^^^^^^^^^^^^ help: use: `Any as _`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:49:20
+  --> tests/ui/unused_trait_names.rs:52:20
    |
 LL |     use std::any::{Any as MyAny, TypeId as MyTypeId};
    |                    ^^^^^^^^^^^^ help: use: `Any as _`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:72:23
+  --> tests/ui/unused_trait_names.rs:76:23
    |
 LL |         use std::any::Any;
    |                       ^^^ help: use: `Any as _`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:113:19
+  --> tests/ui/unused_trait_names.rs:118:19
    |
 LL |     use std::any::Any;
    |                   ^^^ help: use: `Any as _`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:132:19
+  --> tests/ui/unused_trait_names.rs:138:19
    |
 LL |     use std::any::Any;
    |                   ^^^ help: use: `Any as _`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:191:34
+  --> tests/ui/unused_trait_names.rs:198:34
    |
 LL |     use simple_trait::{MyStruct, MyTrait};
    |                                  ^^^^^^^ help: use: `MyTrait as _`
 
 error: importing trait that is only used anonymously
-  --> tests/ui/unused_trait_names.rs:198:27
+  --> tests/ui/unused_trait_names.rs:206:27
    |
 LL |             use std::any::Any;
    |                           ^^^ help: use: `Any as _`
diff --git a/src/tools/clippy/tests/ui/unused_unit.fixed b/src/tools/clippy/tests/ui/unused_unit.fixed
index 04fe2d3b7af1..e3c02681c9fd 100644
--- a/src/tools/clippy/tests/ui/unused_unit.fixed
+++ b/src/tools/clippy/tests/ui/unused_unit.fixed
@@ -18,8 +18,12 @@ struct Unitter;
 impl Unitter {
     #[allow(clippy::no_effect)]
     pub fn get_unit<F: Fn(), G>(&self, f: F, _g: G)
+    //~^ unused_unit
+    //~| unused_unit
     where G: Fn() {
+    //~^ unused_unit
         let _y: &dyn Fn() = &f;
+        //~^ unused_unit
         (); // this should not lint, as it's not in return type position
     }
 }
@@ -27,25 +31,35 @@ impl Unitter {
 impl Into<()> for Unitter {
     #[rustfmt::skip]
     fn into(self) {
+    //~^ unused_unit
         
+        //~^ unused_unit
     }
 }
 
 trait Trait {
     fn redundant<F: FnOnce(), G, H>(&self, _f: F, _g: G, _h: H)
+    //~^ unused_unit
     where
         G: FnMut(),
+        //~^ unused_unit
         H: Fn();
+        //~^ unused_unit
 }
 
 impl Trait for Unitter {
     fn redundant<F: FnOnce(), G, H>(&self, _f: F, _g: G, _h: H)
+    //~^ unused_unit
     where
         G: FnMut(),
+        //~^ unused_unit
         H: Fn() {}
+        //~^ unused_unit
 }
 
 fn return_unit() {  }
+//~^ unused_unit
+//~| unused_unit
 
 #[allow(clippy::needless_return)]
 #[allow(clippy::never_loop)]
@@ -56,8 +70,10 @@ fn main() {
     return_unit();
     loop {
         break;
+        //~^ unused_unit
     }
     return;
+    //~^ unused_unit
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/4076
@@ -75,12 +91,15 @@ fn foo() {
 
 #[rustfmt::skip]
 fn test(){}
+//~^ unused_unit
 
 #[rustfmt::skip]
 fn test2(){}
+//~^ unused_unit
 
 #[rustfmt::skip]
 fn test3(){}
+//~^ unused_unit
 
 fn macro_expr() {
     macro_rules! e {
diff --git a/src/tools/clippy/tests/ui/unused_unit.rs b/src/tools/clippy/tests/ui/unused_unit.rs
index 25c2ed59873a..4353026c594c 100644
--- a/src/tools/clippy/tests/ui/unused_unit.rs
+++ b/src/tools/clippy/tests/ui/unused_unit.rs
@@ -18,8 +18,12 @@ struct Unitter;
 impl Unitter {
     #[allow(clippy::no_effect)]
     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
+    //~^ unused_unit
+    //~| unused_unit
     where G: Fn() -> () {
+    //~^ unused_unit
         let _y: &dyn Fn() -> () = &f;
+        //~^ unused_unit
         (); // this should not lint, as it's not in return type position
     }
 }
@@ -27,25 +31,35 @@ impl Unitter {
 impl Into<()> for Unitter {
     #[rustfmt::skip]
     fn into(self) -> () {
+    //~^ unused_unit
         ()
+        //~^ unused_unit
     }
 }
 
 trait Trait {
     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
+    //~^ unused_unit
     where
         G: FnMut() -> (),
+        //~^ unused_unit
         H: Fn() -> ();
+        //~^ unused_unit
 }
 
 impl Trait for Unitter {
     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
+    //~^ unused_unit
     where
         G: FnMut() -> (),
+        //~^ unused_unit
         H: Fn() -> () {}
+        //~^ unused_unit
 }
 
 fn return_unit() -> () { () }
+//~^ unused_unit
+//~| unused_unit
 
 #[allow(clippy::needless_return)]
 #[allow(clippy::never_loop)]
@@ -56,8 +70,10 @@ fn main() {
     return_unit();
     loop {
         break();
+        //~^ unused_unit
     }
     return();
+    //~^ unused_unit
 }
 
 // https://github.com/rust-lang/rust-clippy/issues/4076
@@ -75,12 +91,15 @@ fn foo() {
 
 #[rustfmt::skip]
 fn test()->(){}
+//~^ unused_unit
 
 #[rustfmt::skip]
 fn test2() ->(){}
+//~^ unused_unit
 
 #[rustfmt::skip]
 fn test3()-> (){}
+//~^ unused_unit
 
 fn macro_expr() {
     macro_rules! e {
diff --git a/src/tools/clippy/tests/ui/unused_unit.stderr b/src/tools/clippy/tests/ui/unused_unit.stderr
index 104159ad5fc6..172fe0655028 100644
--- a/src/tools/clippy/tests/ui/unused_unit.stderr
+++ b/src/tools/clippy/tests/ui/unused_unit.stderr
@@ -17,49 +17,31 @@ LL |     pub fn get_unit<F: Fn() -> (), G>(&self, f: F, _g: G) -> ()
    |                            ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:21:18
+  --> tests/ui/unused_unit.rs:23:18
    |
 LL |     where G: Fn() -> () {
    |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:22:26
+  --> tests/ui/unused_unit.rs:25:26
    |
 LL |         let _y: &dyn Fn() -> () = &f;
    |                          ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:29:18
+  --> tests/ui/unused_unit.rs:33:18
    |
 LL |     fn into(self) -> () {
    |                  ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> tests/ui/unused_unit.rs:30:9
+  --> tests/ui/unused_unit.rs:35:9
    |
 LL |         ()
    |         ^^ help: remove the final `()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:35:29
-   |
-LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
-   |                             ^^^^^^ help: remove the `-> ()`
-
-error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:37:19
-   |
-LL |         G: FnMut() -> (),
-   |                   ^^^^^^ help: remove the `-> ()`
-
-error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:38:16
-   |
-LL |         H: Fn() -> ();
-   |                ^^^^^^ help: remove the `-> ()`
-
-error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:42:29
+  --> tests/ui/unused_unit.rs:41:29
    |
 LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
    |                             ^^^^^^ help: remove the `-> ()`
@@ -71,49 +53,67 @@ LL |         G: FnMut() -> (),
    |                   ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:45:16
+  --> tests/ui/unused_unit.rs:46:16
+   |
+LL |         H: Fn() -> ();
+   |                ^^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> tests/ui/unused_unit.rs:51:29
+   |
+LL |     fn redundant<F: FnOnce() -> (), G, H>(&self, _f: F, _g: G, _h: H)
+   |                             ^^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> tests/ui/unused_unit.rs:54:19
+   |
+LL |         G: FnMut() -> (),
+   |                   ^^^^^^ help: remove the `-> ()`
+
+error: unneeded unit return type
+  --> tests/ui/unused_unit.rs:56:16
    |
 LL |         H: Fn() -> () {}
    |                ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:48:17
+  --> tests/ui/unused_unit.rs:60:17
    |
 LL | fn return_unit() -> () { () }
    |                 ^^^^^^ help: remove the `-> ()`
 
 error: unneeded unit expression
-  --> tests/ui/unused_unit.rs:48:26
+  --> tests/ui/unused_unit.rs:60:26
    |
 LL | fn return_unit() -> () { () }
    |                          ^^ help: remove the final `()`
 
 error: unneeded `()`
-  --> tests/ui/unused_unit.rs:58:14
+  --> tests/ui/unused_unit.rs:72:14
    |
 LL |         break();
    |              ^^ help: remove the `()`
 
 error: unneeded `()`
-  --> tests/ui/unused_unit.rs:60:11
+  --> tests/ui/unused_unit.rs:75:11
    |
 LL |     return();
    |           ^^ help: remove the `()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:77:10
+  --> tests/ui/unused_unit.rs:93:10
    |
 LL | fn test()->(){}
    |          ^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:80:11
+  --> tests/ui/unused_unit.rs:97:11
    |
 LL | fn test2() ->(){}
    |           ^^^^^ help: remove the `-> ()`
 
 error: unneeded unit return type
-  --> tests/ui/unused_unit.rs:83:11
+  --> tests/ui/unused_unit.rs:101:11
    |
 LL | fn test3()-> (){}
    |           ^^^^^ help: remove the `-> ()`
diff --git a/src/tools/clippy/tests/ui/unwrap.rs b/src/tools/clippy/tests/ui/unwrap.rs
index 8ad7e98503bf..3191b396f99b 100644
--- a/src/tools/clippy/tests/ui/unwrap.rs
+++ b/src/tools/clippy/tests/ui/unwrap.rs
@@ -4,15 +4,16 @@
 fn unwrap_option() {
     let opt = Some(0);
     let _ = opt.unwrap();
-    //~^ ERROR: used `unwrap()` on an `Option` value
+    //~^ unwrap_used
 }
 
 fn unwrap_result() {
     let res: Result<u8, u8> = Ok(0);
     let _ = res.unwrap();
-    //~^ ERROR: used `unwrap()` on a `Result` value
+    //~^ unwrap_used
+
     let _ = res.unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on a `Result` value
+    //~^ unwrap_used
 }
 
 fn main() {
diff --git a/src/tools/clippy/tests/ui/unwrap.stderr b/src/tools/clippy/tests/ui/unwrap.stderr
index 3c1b37bc3d9b..c242541a6bd7 100644
--- a/src/tools/clippy/tests/ui/unwrap.stderr
+++ b/src/tools/clippy/tests/ui/unwrap.stderr
@@ -19,7 +19,7 @@ LL |     let _ = res.unwrap();
    = help: consider using `expect()` to provide a better panic message
 
 error: used `unwrap_err()` on a `Result` value
-  --> tests/ui/unwrap.rs:14:13
+  --> tests/ui/unwrap.rs:15:13
    |
 LL |     let _ = res.unwrap_err();
    |             ^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unwrap_expect_used.rs b/src/tools/clippy/tests/ui/unwrap_expect_used.rs
index a56bd0a8d079..d0bb571273b5 100644
--- a/src/tools/clippy/tests/ui/unwrap_expect_used.rs
+++ b/src/tools/clippy/tests/ui/unwrap_expect_used.rs
@@ -25,9 +25,10 @@ impl<T> OptionExt for Option<T> {
 
 fn main() {
     Some(3).unwrap();
-    //~^ ERROR: used `unwrap()` on an `Option` value
+    //~^ unwrap_used
+
     Some(3).expect("Hello world!");
-    //~^ ERROR: used `expect()` on an `Option` value
+    //~^ expect_used
 
     // Don't trigger on unwrap_err on an option
     Some(3).unwrap_err();
@@ -43,11 +44,25 @@ fn main() {
 
     let a: Result<i32, i32> = Ok(3);
     a.unwrap();
-    //~^ ERROR: used `unwrap()` on a `Result` value
+    //~^ unwrap_used
+
     a.expect("Hello world!");
-    //~^ ERROR: used `expect()` on a `Result` value
+    //~^ expect_used
+
     a.unwrap_err();
-    //~^ ERROR: used `unwrap_err()` on a `Result` value
+    //~^ unwrap_used
+
     a.expect_err("Hello error!");
-    //~^ ERROR: used `expect_err()` on a `Result` value
+    //~^ expect_used
+
+    // Don't trigger in compile time contexts by default
+    const SOME: Option<i32> = Some(3);
+    const UNWRAPPED: i32 = SOME.unwrap();
+    const EXPECTED: i32 = SOME.expect("Not three?");
+    const {
+        SOME.unwrap();
+    }
+    const {
+        SOME.expect("Still not three?");
+    }
 }
diff --git a/src/tools/clippy/tests/ui/unwrap_expect_used.stderr b/src/tools/clippy/tests/ui/unwrap_expect_used.stderr
index 9069522a4df1..79eac3f58ccb 100644
--- a/src/tools/clippy/tests/ui/unwrap_expect_used.stderr
+++ b/src/tools/clippy/tests/ui/unwrap_expect_used.stderr
@@ -9,7 +9,7 @@ LL |     Some(3).unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_used)]`
 
 error: used `expect()` on an `Option` value
-  --> tests/ui/unwrap_expect_used.rs:29:5
+  --> tests/ui/unwrap_expect_used.rs:30:5
    |
 LL |     Some(3).expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     Some(3).expect("Hello world!");
    = help: to override `-D warnings` add `#[allow(clippy::expect_used)]`
 
 error: used `unwrap()` on a `Result` value
-  --> tests/ui/unwrap_expect_used.rs:45:5
+  --> tests/ui/unwrap_expect_used.rs:46:5
    |
 LL |     a.unwrap();
    |     ^^^^^^^^^^
@@ -27,7 +27,7 @@ LL |     a.unwrap();
    = note: if this value is an `Err`, it will panic
 
 error: used `expect()` on a `Result` value
-  --> tests/ui/unwrap_expect_used.rs:47:5
+  --> tests/ui/unwrap_expect_used.rs:49:5
    |
 LL |     a.expect("Hello world!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -35,7 +35,7 @@ LL |     a.expect("Hello world!");
    = note: if this value is an `Err`, it will panic
 
 error: used `unwrap_err()` on a `Result` value
-  --> tests/ui/unwrap_expect_used.rs:49:5
+  --> tests/ui/unwrap_expect_used.rs:52:5
    |
 LL |     a.unwrap_err();
    |     ^^^^^^^^^^^^^^
@@ -43,7 +43,7 @@ LL |     a.unwrap_err();
    = note: if this value is an `Ok`, it will panic
 
 error: used `expect_err()` on a `Result` value
-  --> tests/ui/unwrap_expect_used.rs:51:5
+  --> tests/ui/unwrap_expect_used.rs:55:5
    |
 LL |     a.expect_err("Hello error!");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unwrap_in_result.rs b/src/tools/clippy/tests/ui/unwrap_in_result.rs
index 62c6d959c84b..4e872c67b423 100644
--- a/src/tools/clippy/tests/ui/unwrap_in_result.rs
+++ b/src/tools/clippy/tests/ui/unwrap_in_result.rs
@@ -20,7 +20,8 @@ impl A {
 
     // should be detected
     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
-        //~^ ERROR: used unwrap or expect in a function that returns result or option
+        //~^ unwrap_in_result
+
         // checks whether a string represents a number divisible by 3
         let i = i_str.parse::<i32>().unwrap();
         if i % 3 == 0 {
@@ -31,7 +32,8 @@ impl A {
     }
 
     fn example_option_expect(i_str: String) -> Option<bool> {
-        //~^ ERROR: used unwrap or expect in a function that returns result or option
+        //~^ unwrap_in_result
+
         let i = i_str.parse::<i32>().expect("not a number");
         if i % 3 == 0 {
             return Some(true);
@@ -40,6 +42,7 @@ impl A {
     }
 
     fn in_closure(a: Option<bool>) -> Option<bool> {
+        //~^ unwrap_in_result
         let c = || a.unwrap();
         Some(c())
     }
diff --git a/src/tools/clippy/tests/ui/unwrap_in_result.stderr b/src/tools/clippy/tests/ui/unwrap_in_result.stderr
index 201d4ae36ae3..5e3eab813e07 100644
--- a/src/tools/clippy/tests/ui/unwrap_in_result.stderr
+++ b/src/tools/clippy/tests/ui/unwrap_in_result.stderr
@@ -2,16 +2,13 @@ error: used unwrap or expect in a function that returns result or option
   --> tests/ui/unwrap_in_result.rs:22:5
    |
 LL | /     fn bad_divisible_by_3(i_str: String) -> Result<bool, String> {
-LL | |
-LL | |         // checks whether a string represents a number divisible by 3
-LL | |         let i = i_str.parse::<i32>().unwrap();
 ...  |
 LL | |     }
    | |_____^
    |
    = help: unwrap and expect should not be used in a function that returns result or option
 note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:25:17
+  --> tests/ui/unwrap_in_result.rs:26:17
    |
 LL |         let i = i_str.parse::<i32>().unwrap();
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -19,12 +16,12 @@ LL |         let i = i_str.parse::<i32>().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_in_result)]`
 
 error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:33:5
+  --> tests/ui/unwrap_in_result.rs:34:5
    |
 LL | /     fn example_option_expect(i_str: String) -> Option<bool> {
 LL | |
+LL | |
 LL | |         let i = i_str.parse::<i32>().expect("not a number");
-LL | |         if i % 3 == 0 {
 ...  |
 LL | |         None
 LL | |     }
@@ -32,15 +29,16 @@ LL | |     }
    |
    = help: unwrap and expect should not be used in a function that returns result or option
 note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:35:17
+  --> tests/ui/unwrap_in_result.rs:37:17
    |
 LL |         let i = i_str.parse::<i32>().expect("not a number");
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: used unwrap or expect in a function that returns result or option
-  --> tests/ui/unwrap_in_result.rs:42:5
+  --> tests/ui/unwrap_in_result.rs:44:5
    |
 LL | /     fn in_closure(a: Option<bool>) -> Option<bool> {
+LL | |
 LL | |         let c = || a.unwrap();
 LL | |         Some(c())
 LL | |     }
@@ -48,7 +46,7 @@ LL | |     }
    |
    = help: unwrap and expect should not be used in a function that returns result or option
 note: potential non-recoverable error(s)
-  --> tests/ui/unwrap_in_result.rs:43:20
+  --> tests/ui/unwrap_in_result.rs:46:20
    |
 LL |         let c = || a.unwrap();
    |                    ^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/unwrap_or.fixed b/src/tools/clippy/tests/ui/unwrap_or.fixed
index 62bc1966da6f..c794ed577032 100644
--- a/src/tools/clippy/tests/ui/unwrap_or.fixed
+++ b/src/tools/clippy/tests/ui/unwrap_or.fixed
@@ -3,11 +3,10 @@
 
 fn main() {
     let s = Some(String::from("test string")).unwrap_or_else(|| "Fail".to_string()).len();
-    //~^ ERROR: function call inside of `unwrap_or`
-    //~| NOTE: `-D clippy::or-fun-call` implied by `-D warnings`
+    //~^ or_fun_call
 }
 
 fn new_lines() {
     let s = Some(String::from("test string")).unwrap_or_else(|| "Fail".to_string()).len();
-    //~^ ERROR: function call inside of `unwrap_or`
+    //~^ or_fun_call
 }
diff --git a/src/tools/clippy/tests/ui/unwrap_or.rs b/src/tools/clippy/tests/ui/unwrap_or.rs
index e8e4b6b7168f..11a6883b7403 100644
--- a/src/tools/clippy/tests/ui/unwrap_or.rs
+++ b/src/tools/clippy/tests/ui/unwrap_or.rs
@@ -3,11 +3,10 @@
 
 fn main() {
     let s = Some(String::from("test string")).unwrap_or("Fail".to_string()).len();
-    //~^ ERROR: function call inside of `unwrap_or`
-    //~| NOTE: `-D clippy::or-fun-call` implied by `-D warnings`
+    //~^ or_fun_call
 }
 
 fn new_lines() {
     let s = Some(String::from("test string")).unwrap_or("Fail".to_string()).len();
-    //~^ ERROR: function call inside of `unwrap_or`
+    //~^ or_fun_call
 }
diff --git a/src/tools/clippy/tests/ui/unwrap_or.stderr b/src/tools/clippy/tests/ui/unwrap_or.stderr
index b712f8cf693d..e95633680acc 100644
--- a/src/tools/clippy/tests/ui/unwrap_or.stderr
+++ b/src/tools/clippy/tests/ui/unwrap_or.stderr
@@ -8,7 +8,7 @@ LL |     let s = Some(String::from("test string")).unwrap_or("Fail".to_string())
    = help: to override `-D warnings` add `#[allow(clippy::or_fun_call)]`
 
 error: function call inside of `unwrap_or`
-  --> tests/ui/unwrap_or.rs:11:47
+  --> tests/ui/unwrap_or.rs:10:47
    |
 LL |     let s = Some(String::from("test string")).unwrap_or("Fail".to_string()).len();
    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_else(|| "Fail".to_string())`
diff --git a/src/tools/clippy/tests/ui/unwrap_or_else_default.fixed b/src/tools/clippy/tests/ui/unwrap_or_else_default.fixed
index 8d5d34175c52..561cbce473de 100644
--- a/src/tools/clippy/tests/ui/unwrap_or_else_default.fixed
+++ b/src/tools/clippy/tests/ui/unwrap_or_else_default.fixed
@@ -44,6 +44,7 @@ fn unwrap_or_else_default() {
 
     let with_new = Some(vec![1]);
     with_new.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let with_err: Result<_, ()> = Ok(vec![1]);
     with_err.unwrap_or_else(make);
@@ -58,43 +59,56 @@ fn unwrap_or_else_default() {
 
     let with_real_default = None::<HasDefaultAndDuplicate>;
     with_real_default.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let with_default_trait = Some(1);
     with_default_trait.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let with_default_type = Some(1);
     with_default_type.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let with_default_type: Option<Vec<u64>> = None;
     with_default_type.unwrap_or_default();
+    //~^ unwrap_or_default
 
     let empty_string = None::<String>;
     empty_string.unwrap_or_default();
+    //~^ unwrap_or_default
 }
 
 fn type_certainty(option: Option<Vec<u64>>) {
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     let option: std::option::Option<std::vec::Vec<u64>> = None;
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     let option: Option<Vec<u64>> = None;
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     let option = std::option::Option::<std::vec::Vec<u64>>::None;
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     let option = Option::<Vec<u64>>::None;
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     let option = std::option::Option::None::<std::vec::Vec<u64>>;
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     let option = Option::None::<Vec<u64>>;
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     let option = None::<Vec<u64>>;
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 
     // should not be changed: type annotation with infer, unconcretized initializer
     let option: Option<Vec<_>> = None;
@@ -111,6 +125,7 @@ fn type_certainty(option: Option<Vec<u64>>) {
     type Alias = Option<Vec<u32>>;
     let option: Alias = Option::<Vec<u32>>::Some(Vec::new());
     option.unwrap_or_default().push(1);
+    //~^ unwrap_or_default
 }
 
 fn method_call_with_deref() {
@@ -128,6 +143,7 @@ fn method_call_with_deref() {
     let inner_map = outer_map.get_mut(&option.unwrap()).unwrap();
 
     let _ = inner_map.entry(0).or_default();
+    //~^ unwrap_or_default
 }
 
 fn missing_suggested_method() {
diff --git a/src/tools/clippy/tests/ui/unwrap_or_else_default.rs b/src/tools/clippy/tests/ui/unwrap_or_else_default.rs
index adbcb4b44659..8389be964fe6 100644
--- a/src/tools/clippy/tests/ui/unwrap_or_else_default.rs
+++ b/src/tools/clippy/tests/ui/unwrap_or_else_default.rs
@@ -44,6 +44,7 @@ fn unwrap_or_else_default() {
 
     let with_new = Some(vec![1]);
     with_new.unwrap_or_else(Vec::new);
+    //~^ unwrap_or_default
 
     let with_err: Result<_, ()> = Ok(vec![1]);
     with_err.unwrap_or_else(make);
@@ -58,43 +59,56 @@ fn unwrap_or_else_default() {
 
     let with_real_default = None::<HasDefaultAndDuplicate>;
     with_real_default.unwrap_or_else(<HasDefaultAndDuplicate as Default>::default);
+    //~^ unwrap_or_default
 
     let with_default_trait = Some(1);
     with_default_trait.unwrap_or_else(Default::default);
+    //~^ unwrap_or_default
 
     let with_default_type = Some(1);
     with_default_type.unwrap_or_else(u64::default);
+    //~^ unwrap_or_default
 
     let with_default_type: Option<Vec<u64>> = None;
     with_default_type.unwrap_or_else(Vec::new);
+    //~^ unwrap_or_default
 
     let empty_string = None::<String>;
     empty_string.unwrap_or_else(|| "".to_string());
+    //~^ unwrap_or_default
 }
 
 fn type_certainty(option: Option<Vec<u64>>) {
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     let option: std::option::Option<std::vec::Vec<u64>> = None;
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     let option: Option<Vec<u64>> = None;
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     let option = std::option::Option::<std::vec::Vec<u64>>::None;
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     let option = Option::<Vec<u64>>::None;
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     let option = std::option::Option::None::<std::vec::Vec<u64>>;
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     let option = Option::None::<Vec<u64>>;
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     let option = None::<Vec<u64>>;
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 
     // should not be changed: type annotation with infer, unconcretized initializer
     let option: Option<Vec<_>> = None;
@@ -111,6 +125,7 @@ fn type_certainty(option: Option<Vec<u64>>) {
     type Alias = Option<Vec<u32>>;
     let option: Alias = Option::<Vec<u32>>::Some(Vec::new());
     option.unwrap_or_else(Vec::new).push(1);
+    //~^ unwrap_or_default
 }
 
 fn method_call_with_deref() {
@@ -128,6 +143,7 @@ fn method_call_with_deref() {
     let inner_map = outer_map.get_mut(&option.unwrap()).unwrap();
 
     let _ = inner_map.entry(0).or_insert_with(Default::default);
+    //~^ unwrap_or_default
 }
 
 fn missing_suggested_method() {
diff --git a/src/tools/clippy/tests/ui/unwrap_or_else_default.stderr b/src/tools/clippy/tests/ui/unwrap_or_else_default.stderr
index e4b4a0a1f6aa..a001f7e46add 100644
--- a/src/tools/clippy/tests/ui/unwrap_or_else_default.stderr
+++ b/src/tools/clippy/tests/ui/unwrap_or_else_default.stderr
@@ -8,47 +8,35 @@ LL |     with_new.unwrap_or_else(Vec::new);
    = help: to override `-D warnings` add `#[allow(clippy::unwrap_or_default)]`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:60:23
+  --> tests/ui/unwrap_or_else_default.rs:61:23
    |
 LL |     with_real_default.unwrap_or_else(<HasDefaultAndDuplicate as Default>::default);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:63:24
+  --> tests/ui/unwrap_or_else_default.rs:65:24
    |
 LL |     with_default_trait.unwrap_or_else(Default::default);
    |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:66:23
+  --> tests/ui/unwrap_or_else_default.rs:69:23
    |
 LL |     with_default_type.unwrap_or_else(u64::default);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:69:23
+  --> tests/ui/unwrap_or_else_default.rs:73:23
    |
 LL |     with_default_type.unwrap_or_else(Vec::new);
    |                       ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:72:18
+  --> tests/ui/unwrap_or_else_default.rs:77:18
    |
 LL |     empty_string.unwrap_or_else(|| "".to_string());
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
-error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:76:12
-   |
-LL |     option.unwrap_or_else(Vec::new).push(1);
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
-
-error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:79:12
-   |
-LL |     option.unwrap_or_else(Vec::new).push(1);
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
-
 error: use of `unwrap_or_else` to construct default value
   --> tests/ui/unwrap_or_else_default.rs:82:12
    |
@@ -56,19 +44,13 @@ LL |     option.unwrap_or_else(Vec::new).push(1);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:85:12
+  --> tests/ui/unwrap_or_else_default.rs:86:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:88:12
-   |
-LL |     option.unwrap_or_else(Vec::new).push(1);
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
-
-error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:91:12
+  --> tests/ui/unwrap_or_else_default.rs:90:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
@@ -80,19 +62,37 @@ LL |     option.unwrap_or_else(Vec::new).push(1);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:97:12
+  --> tests/ui/unwrap_or_else_default.rs:98:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `unwrap_or_else` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:113:12
+  --> tests/ui/unwrap_or_else_default.rs:102:12
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `unwrap_or_else` to construct default value
+  --> tests/ui/unwrap_or_else_default.rs:106:12
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `unwrap_or_else` to construct default value
+  --> tests/ui/unwrap_or_else_default.rs:110:12
+   |
+LL |     option.unwrap_or_else(Vec::new).push(1);
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
+
+error: use of `unwrap_or_else` to construct default value
+  --> tests/ui/unwrap_or_else_default.rs:127:12
    |
 LL |     option.unwrap_or_else(Vec::new).push(1);
    |            ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `unwrap_or_default()`
 
 error: use of `or_insert_with` to construct default value
-  --> tests/ui/unwrap_or_else_default.rs:130:32
+  --> tests/ui/unwrap_or_else_default.rs:145:32
    |
 LL |     let _ = inner_map.entry(0).or_insert_with(Default::default);
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `or_default()`
diff --git a/src/tools/clippy/tests/ui/upper_case_acronyms.fixed b/src/tools/clippy/tests/ui/upper_case_acronyms.fixed
index a8023ed00d21..da44c8e3026e 100644
--- a/src/tools/clippy/tests/ui/upper_case_acronyms.fixed
+++ b/src/tools/clippy/tests/ui/upper_case_acronyms.fixed
@@ -7,22 +7,21 @@ struct CString; // not linted
 enum Flags {
     NS, // not linted
     Cwr,
-    //~^ ERROR: name `CWR` contains a capitalized acronym
-    //~| NOTE: `-D clippy::upper-case-acronyms` implied by `-D warnings`
+    //~^ upper_case_acronyms
     Ece,
-    //~^ ERROR: name `ECE` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Urg,
-    //~^ ERROR: name `URG` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Ack,
-    //~^ ERROR: name `ACK` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Psh,
-    //~^ ERROR: name `PSH` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Rst,
-    //~^ ERROR: name `RST` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Syn,
-    //~^ ERROR: name `SYN` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Fin,
-    //~^ ERROR: name `FIN` contains a capitalized acronym
+    //~^ upper_case_acronyms
 }
 
 // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
@@ -43,18 +42,18 @@ pub enum ParseError<T> {
 // private, do lint here
 enum ParseErrorPrivate<T> {
     Wasd(u8),
-    //~^ ERROR: name `WASD` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Utf8(std::string::FromUtf8Error),
     Parse(T, String),
 }
 
 // do lint here
 struct Json;
-//~^ ERROR: name `JSON` contains a capitalized acronym
+//~^ upper_case_acronyms
 
 // do lint here
 enum Yaml {
-    //~^ ERROR: name `YAML` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Num(u32),
     Str(String),
 }
@@ -62,7 +61,7 @@ enum Yaml {
 // test for issue #7708
 enum AllowOnField {
     Disallow,
-    //~^ ERROR: name `DISALLOW` contains a capitalized acronym
+    //~^ upper_case_acronyms
     #[allow(clippy::upper_case_acronyms)]
     ALLOW,
 }
diff --git a/src/tools/clippy/tests/ui/upper_case_acronyms.rs b/src/tools/clippy/tests/ui/upper_case_acronyms.rs
index c4711b87ec38..d223b02acda9 100644
--- a/src/tools/clippy/tests/ui/upper_case_acronyms.rs
+++ b/src/tools/clippy/tests/ui/upper_case_acronyms.rs
@@ -7,22 +7,21 @@ struct CString; // not linted
 enum Flags {
     NS, // not linted
     CWR,
-    //~^ ERROR: name `CWR` contains a capitalized acronym
-    //~| NOTE: `-D clippy::upper-case-acronyms` implied by `-D warnings`
+    //~^ upper_case_acronyms
     ECE,
-    //~^ ERROR: name `ECE` contains a capitalized acronym
+    //~^ upper_case_acronyms
     URG,
-    //~^ ERROR: name `URG` contains a capitalized acronym
+    //~^ upper_case_acronyms
     ACK,
-    //~^ ERROR: name `ACK` contains a capitalized acronym
+    //~^ upper_case_acronyms
     PSH,
-    //~^ ERROR: name `PSH` contains a capitalized acronym
+    //~^ upper_case_acronyms
     RST,
-    //~^ ERROR: name `RST` contains a capitalized acronym
+    //~^ upper_case_acronyms
     SYN,
-    //~^ ERROR: name `SYN` contains a capitalized acronym
+    //~^ upper_case_acronyms
     FIN,
-    //~^ ERROR: name `FIN` contains a capitalized acronym
+    //~^ upper_case_acronyms
 }
 
 // linted with cfg option, beware that lint suggests `GccllvmSomething` instead of
@@ -43,18 +42,18 @@ pub enum ParseError<T> {
 // private, do lint here
 enum ParseErrorPrivate<T> {
     WASD(u8),
-    //~^ ERROR: name `WASD` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Utf8(std::string::FromUtf8Error),
     Parse(T, String),
 }
 
 // do lint here
 struct JSON;
-//~^ ERROR: name `JSON` contains a capitalized acronym
+//~^ upper_case_acronyms
 
 // do lint here
 enum YAML {
-    //~^ ERROR: name `YAML` contains a capitalized acronym
+    //~^ upper_case_acronyms
     Num(u32),
     Str(String),
 }
@@ -62,7 +61,7 @@ enum YAML {
 // test for issue #7708
 enum AllowOnField {
     DISALLOW,
-    //~^ ERROR: name `DISALLOW` contains a capitalized acronym
+    //~^ upper_case_acronyms
     #[allow(clippy::upper_case_acronyms)]
     ALLOW,
 }
diff --git a/src/tools/clippy/tests/ui/upper_case_acronyms.stderr b/src/tools/clippy/tests/ui/upper_case_acronyms.stderr
index 1f8046c8e841..dd548fc143e2 100644
--- a/src/tools/clippy/tests/ui/upper_case_acronyms.stderr
+++ b/src/tools/clippy/tests/ui/upper_case_acronyms.stderr
@@ -8,67 +8,67 @@ LL |     CWR,
    = help: to override `-D warnings` add `#[allow(clippy::upper_case_acronyms)]`
 
 error: name `ECE` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:12:5
+  --> tests/ui/upper_case_acronyms.rs:11:5
    |
 LL |     ECE,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Ece`
 
 error: name `URG` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:14:5
+  --> tests/ui/upper_case_acronyms.rs:13:5
    |
 LL |     URG,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Urg`
 
 error: name `ACK` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:16:5
+  --> tests/ui/upper_case_acronyms.rs:15:5
    |
 LL |     ACK,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter (notice the capitalization): `Ack`
 
 error: name `PSH` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:18:5
+  --> tests/ui/upper_case_acronyms.rs:17:5
    |
 LL |     PSH,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Psh`
 
 error: name `RST` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:20:5
+  --> tests/ui/upper_case_acronyms.rs:19:5
    |
 LL |     RST,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Rst`
 
 error: name `SYN` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:22:5
+  --> tests/ui/upper_case_acronyms.rs:21:5
    |
 LL |     SYN,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Syn`
 
 error: name `FIN` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:24:5
+  --> tests/ui/upper_case_acronyms.rs:23:5
    |
 LL |     FIN,
    |     ^^^ help: consider making the acronym lowercase, except the initial letter: `Fin`
 
 error: name `WASD` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:45:5
+  --> tests/ui/upper_case_acronyms.rs:44:5
    |
 LL |     WASD(u8),
    |     ^^^^ help: consider making the acronym lowercase, except the initial letter: `Wasd`
 
 error: name `JSON` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:52:8
+  --> tests/ui/upper_case_acronyms.rs:51:8
    |
 LL | struct JSON;
    |        ^^^^ help: consider making the acronym lowercase, except the initial letter: `Json`
 
 error: name `YAML` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:56:6
+  --> tests/ui/upper_case_acronyms.rs:55:6
    |
 LL | enum YAML {
    |      ^^^^ help: consider making the acronym lowercase, except the initial letter: `Yaml`
 
 error: name `DISALLOW` contains a capitalized acronym
-  --> tests/ui/upper_case_acronyms.rs:64:5
+  --> tests/ui/upper_case_acronyms.rs:63:5
    |
 LL |     DISALLOW,
    |     ^^^^^^^^ help: consider making the acronym lowercase, except the initial letter: `Disallow`
diff --git a/src/tools/clippy/tests/ui/use_self.fixed b/src/tools/clippy/tests/ui/use_self.fixed
index ffc5b74d7bd6..f15e5e0a5bb4 100644
--- a/src/tools/clippy/tests/ui/use_self.fixed
+++ b/src/tools/clippy/tests/ui/use_self.fixed
@@ -21,16 +21,22 @@ mod use_self {
 
     impl Foo {
         fn new() -> Self {
+            //~^ use_self
             Self {}
+            //~^ use_self
         }
         fn test() -> Self {
+            //~^ use_self
             Self::new()
+            //~^ use_self
         }
     }
 
     impl Default for Foo {
         fn default() -> Self {
+            //~^ use_self
             Self::new()
+            //~^ use_self
         }
     }
 }
@@ -72,6 +78,7 @@ mod lifetimes {
         }
 
         fn clone(&self) -> Self {
+            //~^ use_self
             Foo { foo_str: self.foo_str }
         }
 
@@ -105,6 +112,8 @@ mod existential {
 
     impl Foo {
         fn bad(foos: &[Self]) -> impl Iterator<Item = &Self> {
+            //~^ use_self
+            //~| use_self
             foos.iter()
         }
 
@@ -120,6 +129,7 @@ mod tuple_structs {
     impl TS {
         pub fn ts() -> Self {
             Self(0)
+            //~^ use_self
         }
     }
 }
@@ -155,7 +165,9 @@ mod nesting {
 
             impl Bar {
                 fn bar() -> Self {
+                    //~^ use_self
                     Self { foo: Foo {} }
+                    //~^ use_self
                 }
             }
 
@@ -167,7 +179,9 @@ mod nesting {
 
         // Should lint here
         fn baz() -> Self {
+            //~^ use_self
             Self {}
+            //~^ use_self
         }
     }
 
@@ -185,8 +199,11 @@ mod nesting {
 
         fn method2() {
             let _ = Self::B(42);
+            //~^ use_self
             let _ = Self::C { field: true };
+            //~^ use_self
             let _ = Self::A;
+            //~^ use_self
         }
     }
 }
@@ -229,9 +246,12 @@ mod rustfix {
 
         fn fun_2() {
             Self::fun_1();
+            //~^ use_self
             Self::A;
+            //~^ use_self
 
             Self {};
+            //~^ use_self
         }
     }
 }
@@ -251,6 +271,7 @@ mod issue3567 {
     impl Test for TestStruct {
         fn test() -> TestStruct {
             Self::from_something()
+            //~^ use_self
         }
     }
 }
@@ -265,11 +286,15 @@ mod paths_created_by_lowering {
         const B: usize = 1;
 
         async fn g() -> Self {
+            //~^ use_self
             Self {}
+            //~^ use_self
         }
 
         fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
             &p[Self::A..Self::B]
+            //~^ use_self
+            //~| use_self
         }
     }
 
@@ -293,7 +318,9 @@ mod generics {
     impl<T> Foo<T> {
         // `Self` is applicable here
         fn foo(value: T) -> Self {
+            //~^ use_self
             Self { value }
+            //~^ use_self
         }
 
         // `Cannot` use `Self` as a return type as the generic types are different
@@ -466,6 +493,7 @@ mod nested_paths {
     impl A<submod::C> {
         fn test() -> Self {
             Self::new::<submod::B>(submod::B {})
+            //~^ use_self
         }
     }
 }
@@ -503,6 +531,7 @@ mod issue7206 {
     impl<'a> S2<S<'a>> {
         fn new_again() -> Self {
             Self::new()
+            //~^ use_self
         }
     }
 }
@@ -540,13 +569,16 @@ mod use_self_in_pat {
         fn do_stuff(self) {
             match self {
                 Self::Bar => unimplemented!(),
+                //~^ use_self
                 Self::Baz => unimplemented!(),
+                //~^ use_self
             }
             match Some(1) {
                 Some(_) => unimplemented!(),
                 None => unimplemented!(),
             }
             if let Self::Bar = self {
+                //~^ use_self
                 unimplemented!()
             }
         }
@@ -571,16 +603,22 @@ mod issue8845 {
         fn get_value(&self) -> u8 {
             match self {
                 Self::Num(n) => *n,
+                //~^ use_self
                 Self::TupleNums(n, _m) => *n,
+                //~^ use_self
                 Self::StructNums { one, two: _ } => *one,
+                //~^ use_self
             }
         }
 
         fn use_crate(&self) -> u8 {
             match self {
                 Self::Num(n) => *n,
+                //~^ use_self
                 Self::TupleNums(n, _m) => *n,
+                //~^ use_self
                 Self::StructNums { one, two: _ } => *one,
+                //~^ use_self
             }
         }
 
@@ -597,11 +635,13 @@ mod issue8845 {
     impl Foo {
         fn get_value(&self) -> u8 {
             let Self(x) = self;
+            //~^ use_self
             *x
         }
 
         fn use_crate(&self) -> u8 {
             let Self(x) = self;
+            //~^ use_self
             *x
         }
     }
@@ -609,11 +649,13 @@ mod issue8845 {
     impl Bar {
         fn get_value(&self) -> u8 {
             let Self { x, .. } = self;
+            //~^ use_self
             *x
         }
 
         fn use_crate(&self) -> u8 {
             let Self { x, .. } = self;
+            //~^ use_self
             *x
         }
     }
@@ -653,6 +695,7 @@ fn msrv_1_37() {
         fn foo(self) {
             match self {
                 Self::A => {},
+                //~^ use_self
             }
         }
     }
@@ -667,3 +710,48 @@ mod issue_10371 {
         }
     }
 }
+
+mod issue_13092 {
+    use std::cell::RefCell;
+    macro_rules! macro_inner_item {
+        ($ty:ty) => {
+            fn foo(_: $ty) {
+                fn inner(_: $ty) {}
+            }
+        };
+    }
+
+    #[derive(Default)]
+    struct MyStruct;
+
+    impl MyStruct {
+        macro_inner_item!(MyStruct);
+    }
+
+    impl MyStruct {
+        thread_local! {
+            static SPECIAL: RefCell<MyStruct> = RefCell::default();
+        }
+    }
+}
+
+mod crash_check_13128 {
+    struct A;
+
+    impl A {
+        fn a() {
+            struct B;
+
+            // pushes a NoCheck
+            impl Iterator for &B {
+                // Pops the NoCheck
+                type Item = A;
+
+                // Lints A -> Self
+                fn next(&mut self) -> Option<A> {
+                    Some(A)
+                }
+            }
+        }
+    }
+}
diff --git a/src/tools/clippy/tests/ui/use_self.rs b/src/tools/clippy/tests/ui/use_self.rs
index eb9d96168bcd..b6376938611e 100644
--- a/src/tools/clippy/tests/ui/use_self.rs
+++ b/src/tools/clippy/tests/ui/use_self.rs
@@ -21,16 +21,22 @@ mod use_self {
 
     impl Foo {
         fn new() -> Foo {
+            //~^ use_self
             Foo {}
+            //~^ use_self
         }
         fn test() -> Foo {
+            //~^ use_self
             Foo::new()
+            //~^ use_self
         }
     }
 
     impl Default for Foo {
         fn default() -> Foo {
+            //~^ use_self
             Foo::new()
+            //~^ use_self
         }
     }
 }
@@ -72,6 +78,7 @@ mod lifetimes {
         }
 
         fn clone(&self) -> Foo<'a> {
+            //~^ use_self
             Foo { foo_str: self.foo_str }
         }
 
@@ -105,6 +112,8 @@ mod existential {
 
     impl Foo {
         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
+            //~^ use_self
+            //~| use_self
             foos.iter()
         }
 
@@ -120,6 +129,7 @@ mod tuple_structs {
     impl TS {
         pub fn ts() -> Self {
             TS(0)
+            //~^ use_self
         }
     }
 }
@@ -155,7 +165,9 @@ mod nesting {
 
             impl Bar {
                 fn bar() -> Bar {
+                    //~^ use_self
                     Bar { foo: Foo {} }
+                    //~^ use_self
                 }
             }
 
@@ -167,7 +179,9 @@ mod nesting {
 
         // Should lint here
         fn baz() -> Foo {
+            //~^ use_self
             Foo {}
+            //~^ use_self
         }
     }
 
@@ -185,8 +199,11 @@ mod nesting {
 
         fn method2() {
             let _ = Enum::B(42);
+            //~^ use_self
             let _ = Enum::C { field: true };
+            //~^ use_self
             let _ = Enum::A;
+            //~^ use_self
         }
     }
 }
@@ -229,9 +246,12 @@ mod rustfix {
 
         fn fun_2() {
             nested::A::fun_1();
+            //~^ use_self
             nested::A::A;
+            //~^ use_self
 
             nested::A {};
+            //~^ use_self
         }
     }
 }
@@ -251,6 +271,7 @@ mod issue3567 {
     impl Test for TestStruct {
         fn test() -> TestStruct {
             TestStruct::from_something()
+            //~^ use_self
         }
     }
 }
@@ -265,11 +286,15 @@ mod paths_created_by_lowering {
         const B: usize = 1;
 
         async fn g() -> S {
+            //~^ use_self
             S {}
+            //~^ use_self
         }
 
         fn f<'a>(&self, p: &'a [u8]) -> &'a [u8] {
             &p[S::A..S::B]
+            //~^ use_self
+            //~| use_self
         }
     }
 
@@ -293,7 +318,9 @@ mod generics {
     impl<T> Foo<T> {
         // `Self` is applicable here
         fn foo(value: T) -> Foo<T> {
+            //~^ use_self
             Foo::<T> { value }
+            //~^ use_self
         }
 
         // `Cannot` use `Self` as a return type as the generic types are different
@@ -466,6 +493,7 @@ mod nested_paths {
     impl A<submod::C> {
         fn test() -> Self {
             A::new::<submod::B>(submod::B {})
+            //~^ use_self
         }
     }
 }
@@ -503,6 +531,7 @@ mod issue7206 {
     impl<'a> S2<S<'a>> {
         fn new_again() -> Self {
             S2::new()
+            //~^ use_self
         }
     }
 }
@@ -540,13 +569,16 @@ mod use_self_in_pat {
         fn do_stuff(self) {
             match self {
                 Foo::Bar => unimplemented!(),
+                //~^ use_self
                 Foo::Baz => unimplemented!(),
+                //~^ use_self
             }
             match Some(1) {
                 Some(_) => unimplemented!(),
                 None => unimplemented!(),
             }
             if let Foo::Bar = self {
+                //~^ use_self
                 unimplemented!()
             }
         }
@@ -571,16 +603,22 @@ mod issue8845 {
         fn get_value(&self) -> u8 {
             match self {
                 Something::Num(n) => *n,
+                //~^ use_self
                 Something::TupleNums(n, _m) => *n,
+                //~^ use_self
                 Something::StructNums { one, two: _ } => *one,
+                //~^ use_self
             }
         }
 
         fn use_crate(&self) -> u8 {
             match self {
                 crate::issue8845::Something::Num(n) => *n,
+                //~^ use_self
                 crate::issue8845::Something::TupleNums(n, _m) => *n,
+                //~^ use_self
                 crate::issue8845::Something::StructNums { one, two: _ } => *one,
+                //~^ use_self
             }
         }
 
@@ -597,11 +635,13 @@ mod issue8845 {
     impl Foo {
         fn get_value(&self) -> u8 {
             let Foo(x) = self;
+            //~^ use_self
             *x
         }
 
         fn use_crate(&self) -> u8 {
             let crate::issue8845::Foo(x) = self;
+            //~^ use_self
             *x
         }
     }
@@ -609,11 +649,13 @@ mod issue8845 {
     impl Bar {
         fn get_value(&self) -> u8 {
             let Bar { x, .. } = self;
+            //~^ use_self
             *x
         }
 
         fn use_crate(&self) -> u8 {
             let crate::issue8845::Bar { x, .. } = self;
+            //~^ use_self
             *x
         }
     }
@@ -653,6 +695,7 @@ fn msrv_1_37() {
         fn foo(self) {
             match self {
                 E::A => {},
+                //~^ use_self
             }
         }
     }
@@ -667,3 +710,48 @@ mod issue_10371 {
         }
     }
 }
+
+mod issue_13092 {
+    use std::cell::RefCell;
+    macro_rules! macro_inner_item {
+        ($ty:ty) => {
+            fn foo(_: $ty) {
+                fn inner(_: $ty) {}
+            }
+        };
+    }
+
+    #[derive(Default)]
+    struct MyStruct;
+
+    impl MyStruct {
+        macro_inner_item!(MyStruct);
+    }
+
+    impl MyStruct {
+        thread_local! {
+            static SPECIAL: RefCell<MyStruct> = RefCell::default();
+        }
+    }
+}
+
+mod crash_check_13128 {
+    struct A;
+
+    impl A {
+        fn a() {
+            struct B;
+
+            // pushes a NoCheck
+            impl Iterator for &B {
+                // Pops the NoCheck
+                type Item = A;
+
+                // Lints A -> Self
+                fn next(&mut self) -> Option<A> {
+                    Some(A)
+                }
+            }
+        }
+    }
+}
diff --git a/src/tools/clippy/tests/ui/use_self.stderr b/src/tools/clippy/tests/ui/use_self.stderr
index bd5b685b45d5..781327696ac1 100644
--- a/src/tools/clippy/tests/ui/use_self.stderr
+++ b/src/tools/clippy/tests/ui/use_self.stderr
@@ -8,253 +8,253 @@ LL |         fn new() -> Foo {
    = help: to override `-D warnings` add `#[allow(clippy::use_self)]`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:24:13
+  --> tests/ui/use_self.rs:25:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:26:22
+  --> tests/ui/use_self.rs:28:22
    |
 LL |         fn test() -> Foo {
    |                      ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:27:13
+  --> tests/ui/use_self.rs:30:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:32:25
+  --> tests/ui/use_self.rs:36:25
    |
 LL |         fn default() -> Foo {
    |                         ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:33:13
+  --> tests/ui/use_self.rs:38:13
    |
 LL |             Foo::new()
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:74:28
+  --> tests/ui/use_self.rs:80:28
    |
 LL |         fn clone(&self) -> Foo<'a> {
    |                            ^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:107:24
+  --> tests/ui/use_self.rs:114:24
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:107:55
+  --> tests/ui/use_self.rs:114:55
    |
 LL |         fn bad(foos: &[Foo]) -> impl Iterator<Item = &Foo> {
    |                                                       ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:122:13
+  --> tests/ui/use_self.rs:131:13
    |
 LL |             TS(0)
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:157:29
+  --> tests/ui/use_self.rs:167:29
    |
 LL |                 fn bar() -> Bar {
    |                             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:158:21
+  --> tests/ui/use_self.rs:169:21
    |
 LL |                     Bar { foo: Foo {} }
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:169:21
+  --> tests/ui/use_self.rs:181:21
    |
 LL |         fn baz() -> Foo {
    |                     ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:170:13
+  --> tests/ui/use_self.rs:183:13
    |
 LL |             Foo {}
    |             ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:187:21
+  --> tests/ui/use_self.rs:201:21
    |
 LL |             let _ = Enum::B(42);
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:188:21
+  --> tests/ui/use_self.rs:203:21
    |
 LL |             let _ = Enum::C { field: true };
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:189:21
+  --> tests/ui/use_self.rs:205:21
    |
 LL |             let _ = Enum::A;
    |                     ^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:231:13
+  --> tests/ui/use_self.rs:248:13
    |
 LL |             nested::A::fun_1();
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:232:13
+  --> tests/ui/use_self.rs:250:13
    |
 LL |             nested::A::A;
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:234:13
+  --> tests/ui/use_self.rs:253:13
    |
 LL |             nested::A {};
    |             ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:253:13
+  --> tests/ui/use_self.rs:273:13
    |
 LL |             TestStruct::from_something()
    |             ^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:267:25
+  --> tests/ui/use_self.rs:288:25
    |
 LL |         async fn g() -> S {
    |                         ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:268:13
+  --> tests/ui/use_self.rs:290:13
    |
 LL |             S {}
    |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:272:16
+  --> tests/ui/use_self.rs:295:16
    |
 LL |             &p[S::A..S::B]
    |                ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:272:22
+  --> tests/ui/use_self.rs:295:22
    |
 LL |             &p[S::A..S::B]
    |                      ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:295:29
+  --> tests/ui/use_self.rs:320:29
    |
 LL |         fn foo(value: T) -> Foo<T> {
    |                             ^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:296:13
+  --> tests/ui/use_self.rs:322:13
    |
 LL |             Foo::<T> { value }
    |             ^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:468:13
+  --> tests/ui/use_self.rs:495:13
    |
 LL |             A::new::<submod::B>(submod::B {})
    |             ^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:505:13
+  --> tests/ui/use_self.rs:533:13
    |
 LL |             S2::new()
    |             ^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:542:17
+  --> tests/ui/use_self.rs:571:17
    |
 LL |                 Foo::Bar => unimplemented!(),
    |                 ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:543:17
+  --> tests/ui/use_self.rs:573:17
    |
 LL |                 Foo::Baz => unimplemented!(),
    |                 ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:549:20
+  --> tests/ui/use_self.rs:580:20
    |
 LL |             if let Foo::Bar = self {
    |                    ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:573:17
+  --> tests/ui/use_self.rs:605:17
    |
 LL |                 Something::Num(n) => *n,
    |                 ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:574:17
+  --> tests/ui/use_self.rs:607:17
    |
 LL |                 Something::TupleNums(n, _m) => *n,
    |                 ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:575:17
+  --> tests/ui/use_self.rs:609:17
    |
 LL |                 Something::StructNums { one, two: _ } => *one,
    |                 ^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:581:17
+  --> tests/ui/use_self.rs:616:17
    |
 LL |                 crate::issue8845::Something::Num(n) => *n,
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:582:17
+  --> tests/ui/use_self.rs:618:17
    |
 LL |                 crate::issue8845::Something::TupleNums(n, _m) => *n,
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:583:17
+  --> tests/ui/use_self.rs:620:17
    |
 LL |                 crate::issue8845::Something::StructNums { one, two: _ } => *one,
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:599:17
+  --> tests/ui/use_self.rs:637:17
    |
 LL |             let Foo(x) = self;
    |                 ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:604:17
+  --> tests/ui/use_self.rs:643:17
    |
 LL |             let crate::issue8845::Foo(x) = self;
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:611:17
+  --> tests/ui/use_self.rs:651:17
    |
 LL |             let Bar { x, .. } = self;
    |                 ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:616:17
+  --> tests/ui/use_self.rs:657:17
    |
 LL |             let crate::issue8845::Bar { x, .. } = self;
    |                 ^^^^^^^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self.rs:655:17
+  --> tests/ui/use_self.rs:697:17
    |
 LL |                 E::A => {},
    |                 ^ help: use the applicable keyword: `Self`
diff --git a/src/tools/clippy/tests/ui/use_self_trait.fixed b/src/tools/clippy/tests/ui/use_self_trait.fixed
index 2758ec7aca1f..c5d800dc94e1 100644
--- a/src/tools/clippy/tests/ui/use_self_trait.fixed
+++ b/src/tools/clippy/tests/ui/use_self_trait.fixed
@@ -17,28 +17,42 @@ struct Bad;
 
 impl SelfTrait for Bad {
     fn refs(p1: &Self) -> &Self {
+        //~^ use_self
+        //~| use_self
         p1
     }
 
     fn ref_refs<'a>(p1: &'a &'a Self) -> &'a &'a Self {
+        //~^ use_self
+        //~| use_self
         p1
     }
 
     fn mut_refs(p1: &mut Self) -> &mut Self {
+        //~^ use_self
+        //~| use_self
         p1
     }
 
     fn nested(_p1: Box<Self>, _p2: (&u8, &Self)) {}
+    //~^ use_self
+    //~| use_self
 
     fn vals(_: Self) -> Self {
+        //~^ use_self
+        //~| use_self
         Self
+        //~^ use_self
     }
 }
 
 impl Mul for Bad {
     type Output = Self;
+    //~^ use_self
 
     fn mul(self, rhs: Self) -> Self {
+        //~^ use_self
+        //~| use_self
         rhs
     }
 }
@@ -46,6 +60,7 @@ impl Mul for Bad {
 impl Clone for Bad {
     fn clone(&self) -> Self {
         Self
+        //~^ use_self
     }
 }
 
@@ -143,6 +158,8 @@ mod full_path_replacement {
     impl Error for std::fmt::Error {
         fn custom<T: std::fmt::Display>(_msg: T) -> Self {
             Self // Should lint
+            //
+            //~^^ use_self
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/use_self_trait.rs b/src/tools/clippy/tests/ui/use_self_trait.rs
index 31031e8f50b2..dcf5820afc26 100644
--- a/src/tools/clippy/tests/ui/use_self_trait.rs
+++ b/src/tools/clippy/tests/ui/use_self_trait.rs
@@ -17,28 +17,42 @@ struct Bad;
 
 impl SelfTrait for Bad {
     fn refs(p1: &Bad) -> &Bad {
+        //~^ use_self
+        //~| use_self
         p1
     }
 
     fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
+        //~^ use_self
+        //~| use_self
         p1
     }
 
     fn mut_refs(p1: &mut Bad) -> &mut Bad {
+        //~^ use_self
+        //~| use_self
         p1
     }
 
     fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
+    //~^ use_self
+    //~| use_self
 
     fn vals(_: Bad) -> Bad {
+        //~^ use_self
+        //~| use_self
         Bad
+        //~^ use_self
     }
 }
 
 impl Mul for Bad {
     type Output = Bad;
+    //~^ use_self
 
     fn mul(self, rhs: Bad) -> Bad {
+        //~^ use_self
+        //~| use_self
         rhs
     }
 }
@@ -46,6 +60,7 @@ impl Mul for Bad {
 impl Clone for Bad {
     fn clone(&self) -> Self {
         Bad
+        //~^ use_self
     }
 }
 
@@ -143,6 +158,8 @@ mod full_path_replacement {
     impl Error for std::fmt::Error {
         fn custom<T: std::fmt::Display>(_msg: T) -> Self {
             std::fmt::Error // Should lint
+            //
+            //~^^ use_self
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/use_self_trait.stderr b/src/tools/clippy/tests/ui/use_self_trait.stderr
index 9cbb728ebe66..1b664b3b7a28 100644
--- a/src/tools/clippy/tests/ui/use_self_trait.stderr
+++ b/src/tools/clippy/tests/ui/use_self_trait.stderr
@@ -14,85 +14,85 @@ LL |     fn refs(p1: &Bad) -> &Bad {
    |                           ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:23:33
+  --> tests/ui/use_self_trait.rs:25:33
    |
 LL |     fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
    |                                 ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:23:49
+  --> tests/ui/use_self_trait.rs:25:49
    |
 LL |     fn ref_refs<'a>(p1: &'a &'a Bad) -> &'a &'a Bad {
    |                                                 ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:27:26
+  --> tests/ui/use_self_trait.rs:31:26
    |
 LL |     fn mut_refs(p1: &mut Bad) -> &mut Bad {
    |                          ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:27:39
+  --> tests/ui/use_self_trait.rs:31:39
    |
 LL |     fn mut_refs(p1: &mut Bad) -> &mut Bad {
    |                                       ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:31:24
+  --> tests/ui/use_self_trait.rs:37:24
    |
 LL |     fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
    |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:31:42
+  --> tests/ui/use_self_trait.rs:37:42
    |
 LL |     fn nested(_p1: Box<Bad>, _p2: (&u8, &Bad)) {}
    |                                          ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:33:16
+  --> tests/ui/use_self_trait.rs:41:16
    |
 LL |     fn vals(_: Bad) -> Bad {
    |                ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:33:24
+  --> tests/ui/use_self_trait.rs:41:24
    |
 LL |     fn vals(_: Bad) -> Bad {
    |                        ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:34:9
+  --> tests/ui/use_self_trait.rs:44:9
    |
 LL |         Bad
    |         ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:39:19
+  --> tests/ui/use_self_trait.rs:50:19
    |
 LL |     type Output = Bad;
    |                   ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:41:23
+  --> tests/ui/use_self_trait.rs:53:23
    |
 LL |     fn mul(self, rhs: Bad) -> Bad {
    |                       ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:41:31
+  --> tests/ui/use_self_trait.rs:53:31
    |
 LL |     fn mul(self, rhs: Bad) -> Bad {
    |                               ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:48:9
+  --> tests/ui/use_self_trait.rs:62:9
    |
 LL |         Bad
    |         ^^^ help: use the applicable keyword: `Self`
 
 error: unnecessary structure name repetition
-  --> tests/ui/use_self_trait.rs:145:13
+  --> tests/ui/use_self_trait.rs:160:13
    |
 LL |             std::fmt::Error // Should lint
    |             ^^^^^^^^^^^^^^^ help: use the applicable keyword: `Self`
diff --git a/src/tools/clippy/tests/ui/used_underscore_binding.rs b/src/tools/clippy/tests/ui/used_underscore_binding.rs
index 84dccf28f3b2..3b063fd16be1 100644
--- a/src/tools/clippy/tests/ui/used_underscore_binding.rs
+++ b/src/tools/clippy/tests/ui/used_underscore_binding.rs
@@ -21,12 +21,16 @@ macro_rules! test_macro {
 /// Tests that we lint if we use a binding with a single leading underscore
 fn prefix_underscore(_foo: u32) -> u32 {
     _foo + 1
+    //~^ used_underscore_binding
 }
 
 /// Tests that we lint if we use a `_`-variable defined outside within a macro expansion
 fn in_macro_or_desugar(_foo: u32) {
     println!("{}", _foo);
+    //~^ used_underscore_binding
     assert_eq!(_foo, _foo);
+    //~^ used_underscore_binding
+    //~| used_underscore_binding
 
     test_macro!() + 1;
 }
@@ -40,6 +44,7 @@ struct StructFieldTest {
 fn in_struct_field() {
     let mut s = StructFieldTest { _underscore_field: 0 };
     s._underscore_field += 1;
+    //~^ used_underscore_binding
 }
 
 /// Tests that we do not lint if the struct field is used in code created with derive.
@@ -101,6 +106,7 @@ async fn await_desugaring() {
     ({
         let _i = 5;
         uses_i(_i);
+        //~^ used_underscore_binding
         foo()
     })
     .await
diff --git a/src/tools/clippy/tests/ui/used_underscore_binding.stderr b/src/tools/clippy/tests/ui/used_underscore_binding.stderr
index f9e8013d3ad5..7d94d79f9b3b 100644
--- a/src/tools/clippy/tests/ui/used_underscore_binding.stderr
+++ b/src/tools/clippy/tests/ui/used_underscore_binding.stderr
@@ -13,61 +13,61 @@ LL | fn prefix_underscore(_foo: u32) -> u32 {
    = help: to override `-D warnings` add `#[allow(clippy::used_underscore_binding)]`
 
 error: used underscore-prefixed binding
-  --> tests/ui/used_underscore_binding.rs:28:20
+  --> tests/ui/used_underscore_binding.rs:29:20
    |
 LL |     println!("{}", _foo);
    |                    ^^^^
    |
 note: binding is defined here
-  --> tests/ui/used_underscore_binding.rs:27:24
+  --> tests/ui/used_underscore_binding.rs:28:24
    |
 LL | fn in_macro_or_desugar(_foo: u32) {
    |                        ^^^^
 
 error: used underscore-prefixed binding
-  --> tests/ui/used_underscore_binding.rs:29:16
+  --> tests/ui/used_underscore_binding.rs:31:16
    |
 LL |     assert_eq!(_foo, _foo);
    |                ^^^^
    |
 note: binding is defined here
-  --> tests/ui/used_underscore_binding.rs:27:24
+  --> tests/ui/used_underscore_binding.rs:28:24
    |
 LL | fn in_macro_or_desugar(_foo: u32) {
    |                        ^^^^
 
 error: used underscore-prefixed binding
-  --> tests/ui/used_underscore_binding.rs:29:22
+  --> tests/ui/used_underscore_binding.rs:31:22
    |
 LL |     assert_eq!(_foo, _foo);
    |                      ^^^^
    |
 note: binding is defined here
-  --> tests/ui/used_underscore_binding.rs:27:24
+  --> tests/ui/used_underscore_binding.rs:28:24
    |
 LL | fn in_macro_or_desugar(_foo: u32) {
    |                        ^^^^
 
 error: used underscore-prefixed binding
-  --> tests/ui/used_underscore_binding.rs:42:5
+  --> tests/ui/used_underscore_binding.rs:46:5
    |
 LL |     s._underscore_field += 1;
    |     ^^^^^^^^^^^^^^^^^^^
    |
 note: binding is defined here
-  --> tests/ui/used_underscore_binding.rs:36:5
+  --> tests/ui/used_underscore_binding.rs:40:5
    |
 LL |     _underscore_field: u32,
    |     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: used underscore-prefixed binding
-  --> tests/ui/used_underscore_binding.rs:103:16
+  --> tests/ui/used_underscore_binding.rs:108:16
    |
 LL |         uses_i(_i);
    |                ^^
    |
 note: binding is defined here
-  --> tests/ui/used_underscore_binding.rs:102:13
+  --> tests/ui/used_underscore_binding.rs:107:13
    |
 LL |         let _i = 5;
    |             ^^
diff --git a/src/tools/clippy/tests/ui/used_underscore_items.rs b/src/tools/clippy/tests/ui/used_underscore_items.rs
index 223016a5c966..3401df6ae743 100644
--- a/src/tools/clippy/tests/ui/used_underscore_items.rs
+++ b/src/tools/clippy/tests/ui/used_underscore_items.rs
@@ -41,16 +41,25 @@ mod a {
 
 fn main() {
     _foo1();
+    //~^ used_underscore_items
     let _ = _foo2();
+    //~^ used_underscore_items
     a::b::c::_foo3();
+    //~^ used_underscore_items
     let _ = &_FooStruct {};
+    //~^ used_underscore_items
     let _ = _FooStruct {};
+    //~^ used_underscore_items
 
     let foo_struct = _FooStruct {};
+    //~^ used_underscore_items
     foo_struct._method_call();
+    //~^ used_underscore_items
 
     let foo_struct2 = a::b::c::_FooStruct2 {};
+    //~^ used_underscore_items
     foo_struct2._method_call();
+    //~^ used_underscore_items
 }
 
 // should not lint exteranl crate.
@@ -61,3 +70,13 @@ fn external_item_call() {
 
     external_item::_exernal_foo();
 }
+
+// should not lint foreign functions.
+// issue #14156
+extern "C" {
+    pub fn _exit(code: i32) -> !;
+}
+
+fn _f() {
+    unsafe { _exit(1) }
+}
diff --git a/src/tools/clippy/tests/ui/used_underscore_items.stderr b/src/tools/clippy/tests/ui/used_underscore_items.stderr
index 93ac3a6fec6b..d6e23f1e726a 100644
--- a/src/tools/clippy/tests/ui/used_underscore_items.stderr
+++ b/src/tools/clippy/tests/ui/used_underscore_items.stderr
@@ -13,7 +13,7 @@ LL | fn _foo1() {}
    = help: to override `-D warnings` add `#[allow(clippy::used_underscore_items)]`
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:44:13
+  --> tests/ui/used_underscore_items.rs:45:13
    |
 LL |     let _ = _foo2();
    |             ^^^^^^^
@@ -25,7 +25,7 @@ LL | fn _foo2() -> i32 {
    | ^^^^^^^^^^^^^^^^^
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:45:5
+  --> tests/ui/used_underscore_items.rs:47:5
    |
 LL |     a::b::c::_foo3();
    |     ^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL |             pub fn _foo3() {}
    |             ^^^^^^^^^^^^^^
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:46:14
+  --> tests/ui/used_underscore_items.rs:49:14
    |
 LL |     let _ = &_FooStruct {};
    |              ^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL | struct _FooStruct {}
    | ^^^^^^^^^^^^^^^^^
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:47:13
+  --> tests/ui/used_underscore_items.rs:51:13
    |
 LL |     let _ = _FooStruct {};
    |             ^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL | struct _FooStruct {}
    | ^^^^^^^^^^^^^^^^^
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:49:22
+  --> tests/ui/used_underscore_items.rs:54:22
    |
 LL |     let foo_struct = _FooStruct {};
    |                      ^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL | struct _FooStruct {}
    | ^^^^^^^^^^^^^^^^^
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:50:5
+  --> tests/ui/used_underscore_items.rs:56:5
    |
 LL |     foo_struct._method_call();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL |     fn _method_call(self) {}
    |     ^^^^^^^^^^^^^^^^^^^^^
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:52:23
+  --> tests/ui/used_underscore_items.rs:59:23
    |
 LL |     let foo_struct2 = a::b::c::_FooStruct2 {};
    |                       ^^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |             pub struct _FooStruct2 {}
    |             ^^^^^^^^^^^^^^^^^^^^^^
 
 error: used underscore-prefixed item
-  --> tests/ui/used_underscore_items.rs:53:5
+  --> tests/ui/used_underscore_items.rs:61:5
    |
 LL |     foo_struct2._method_call();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/useful_asref.rs b/src/tools/clippy/tests/ui/useful_asref.rs
index d17db9371ee8..a37c2785bde2 100644
--- a/src/tools/clippy/tests/ui/useful_asref.rs
+++ b/src/tools/clippy/tests/ui/useful_asref.rs
@@ -1,3 +1,5 @@
+//@ check-pass
+
 #![deny(clippy::useless_asref)]
 #![allow(clippy::needless_lifetimes)]
 
diff --git a/src/tools/clippy/tests/ui/useless_asref.fixed b/src/tools/clippy/tests/ui/useless_asref.fixed
index ddbb9255b466..8c1f948fb580 100644
--- a/src/tools/clippy/tests/ui/useless_asref.fixed
+++ b/src/tools/clippy/tests/ui/useless_asref.fixed
@@ -8,6 +8,7 @@
 )]
 
 use std::fmt::Debug;
+use std::ops::Deref;
 use std::rc::{Rc, Weak as RcWeak};
 use std::sync::{Arc, Weak as ArcWeak};
 
@@ -48,14 +49,18 @@ fn not_ok() {
     {
         let rslice: &[i32] = &*mrslice;
         foo_rstr(rstr);
+        //~^ useless_asref
         foo_rstr(rstr);
         foo_rslice(rslice);
+        //~^ useless_asref
         foo_rslice(rslice);
     }
     {
         foo_mrslice(mrslice);
+        //~^ useless_asref
         foo_mrslice(mrslice);
         foo_rslice(mrslice);
+        //~^ useless_asref
         foo_rslice(mrslice);
     }
 
@@ -63,19 +68,24 @@ fn not_ok() {
         let rrrrrstr = &&&&rstr;
         let rrrrrslice = &&&&&*mrslice;
         foo_rslice(rrrrrslice);
+        //~^ useless_asref
         foo_rslice(rrrrrslice);
         foo_rstr(rrrrrstr);
+        //~^ useless_asref
         foo_rstr(rrrrrstr);
     }
     {
         let mrrrrrslice = &mut &mut &mut &mut mrslice;
         foo_mrslice(mrrrrrslice);
+        //~^ useless_asref
         foo_mrslice(mrrrrrslice);
         foo_rslice(mrrrrrslice);
+        //~^ useless_asref
         foo_rslice(mrrrrrslice);
     }
     #[allow(unused_parens, clippy::double_parens, clippy::needless_borrow)]
     foo_rrrrmr((&&&&MoreRef));
+    //~^ useless_asref
 
     generic_not_ok(mrslice);
     generic_ok(mrslice);
@@ -126,8 +136,10 @@ fn foo_rt<T: Debug + ?Sized>(t: &T) {
 
 fn generic_not_ok<T: AsMut<T> + AsRef<T> + Debug + ?Sized>(mrt: &mut T) {
     foo_mrt(mrt);
+    //~^ useless_asref
     foo_mrt(mrt);
     foo_rt(mrt);
+    //~^ useless_asref
     foo_rt(mrt);
 }
 
@@ -139,11 +151,13 @@ fn generic_ok<U: AsMut<T> + AsRef<T> + ?Sized, T: Debug + ?Sized>(mru: &mut U) {
 fn foo() {
     let x = Some(String::new());
     let z = x.clone();
-    //~^ ERROR: this call to `as_ref.map(...)` does nothing
+    //~^ useless_asref
+
     let z = x.clone();
-    //~^ ERROR: this call to `as_ref.map(...)` does nothing
+    //~^ useless_asref
+
     let z = x.clone();
-    //~^ ERROR: this call to `as_ref.map(...)` does nothing
+    //~^ useless_asref
 }
 
 mod issue12135 {
@@ -167,16 +181,18 @@ mod issue12135 {
 
     pub fn f(x: &Struct) -> Option<Foo> {
         x.field.clone();
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
+
         x.field.clone();
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
+
         x.field.clone();
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
 
         // https://github.com/rust-lang/rust-clippy/pull/12136#discussion_r1451565223
         #[allow(clippy::clone_on_copy)]
         Some(1).clone();
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
 
         x.field.as_ref().map(|v| v.method().clone())
     }
@@ -198,6 +214,40 @@ fn issue_12528() {
     let _ = opt.as_ref().map(RcWeak::clone);
 }
 
+fn issue_14088() {
+    let s = Some("foo");
+    let _: Option<&str> = s.as_ref().map(|x| x.as_ref());
+}
+
+pub struct Wrap<T> {
+    inner: T,
+}
+
+impl<T> Deref for Wrap<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+struct NonCloneableError;
+
+pub struct Issue12357 {
+    current: Option<Wrap<Arc<u32>>>,
+}
+
+impl Issue12357 {
+    fn f(&self) -> Option<Arc<u32>> {
+        self.current.as_ref().map(|p| Arc::clone(p))
+    }
+
+    fn g(&self) {
+        let result: Result<String, NonCloneableError> = Ok("Hello".to_string());
+        let cloned = result.as_ref().map(|s| s.clone());
+    }
+}
+
 fn main() {
     not_ok();
     ok();
diff --git a/src/tools/clippy/tests/ui/useless_asref.rs b/src/tools/clippy/tests/ui/useless_asref.rs
index b0405e930a25..d9db2d4f5596 100644
--- a/src/tools/clippy/tests/ui/useless_asref.rs
+++ b/src/tools/clippy/tests/ui/useless_asref.rs
@@ -8,6 +8,7 @@
 )]
 
 use std::fmt::Debug;
+use std::ops::Deref;
 use std::rc::{Rc, Weak as RcWeak};
 use std::sync::{Arc, Weak as ArcWeak};
 
@@ -48,14 +49,18 @@ fn not_ok() {
     {
         let rslice: &[i32] = &*mrslice;
         foo_rstr(rstr.as_ref());
+        //~^ useless_asref
         foo_rstr(rstr);
         foo_rslice(rslice.as_ref());
+        //~^ useless_asref
         foo_rslice(rslice);
     }
     {
         foo_mrslice(mrslice.as_mut());
+        //~^ useless_asref
         foo_mrslice(mrslice);
         foo_rslice(mrslice.as_ref());
+        //~^ useless_asref
         foo_rslice(mrslice);
     }
 
@@ -63,19 +68,24 @@ fn not_ok() {
         let rrrrrstr = &&&&rstr;
         let rrrrrslice = &&&&&*mrslice;
         foo_rslice(rrrrrslice.as_ref());
+        //~^ useless_asref
         foo_rslice(rrrrrslice);
         foo_rstr(rrrrrstr.as_ref());
+        //~^ useless_asref
         foo_rstr(rrrrrstr);
     }
     {
         let mrrrrrslice = &mut &mut &mut &mut mrslice;
         foo_mrslice(mrrrrrslice.as_mut());
+        //~^ useless_asref
         foo_mrslice(mrrrrrslice);
         foo_rslice(mrrrrrslice.as_ref());
+        //~^ useless_asref
         foo_rslice(mrrrrrslice);
     }
     #[allow(unused_parens, clippy::double_parens, clippy::needless_borrow)]
     foo_rrrrmr((&&&&MoreRef).as_ref());
+    //~^ useless_asref
 
     generic_not_ok(mrslice);
     generic_ok(mrslice);
@@ -126,8 +136,10 @@ fn foo_rt<T: Debug + ?Sized>(t: &T) {
 
 fn generic_not_ok<T: AsMut<T> + AsRef<T> + Debug + ?Sized>(mrt: &mut T) {
     foo_mrt(mrt.as_mut());
+    //~^ useless_asref
     foo_mrt(mrt);
     foo_rt(mrt.as_ref());
+    //~^ useless_asref
     foo_rt(mrt);
 }
 
@@ -139,11 +151,13 @@ fn generic_ok<U: AsMut<T> + AsRef<T> + ?Sized, T: Debug + ?Sized>(mru: &mut U) {
 fn foo() {
     let x = Some(String::new());
     let z = x.as_ref().map(String::clone);
-    //~^ ERROR: this call to `as_ref.map(...)` does nothing
+    //~^ useless_asref
+
     let z = x.as_ref().map(|z| z.clone());
-    //~^ ERROR: this call to `as_ref.map(...)` does nothing
+    //~^ useless_asref
+
     let z = x.as_ref().map(|z| String::clone(z));
-    //~^ ERROR: this call to `as_ref.map(...)` does nothing
+    //~^ useless_asref
 }
 
 mod issue12135 {
@@ -167,16 +181,18 @@ mod issue12135 {
 
     pub fn f(x: &Struct) -> Option<Foo> {
         x.field.as_ref().map(|v| v.clone());
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
+
         x.field.as_ref().map(Clone::clone);
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
+
         x.field.as_ref().map(|v| Clone::clone(v));
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
 
         // https://github.com/rust-lang/rust-clippy/pull/12136#discussion_r1451565223
         #[allow(clippy::clone_on_copy)]
         Some(1).as_ref().map(|&x| x.clone());
-        //~^ ERROR: this call to `as_ref.map(...)` does nothing
+        //~^ useless_asref
 
         x.field.as_ref().map(|v| v.method().clone())
     }
@@ -198,6 +214,40 @@ fn issue_12528() {
     let _ = opt.as_ref().map(RcWeak::clone);
 }
 
+fn issue_14088() {
+    let s = Some("foo");
+    let _: Option<&str> = s.as_ref().map(|x| x.as_ref());
+}
+
+pub struct Wrap<T> {
+    inner: T,
+}
+
+impl<T> Deref for Wrap<T> {
+    type Target = T;
+
+    fn deref(&self) -> &Self::Target {
+        &self.inner
+    }
+}
+
+struct NonCloneableError;
+
+pub struct Issue12357 {
+    current: Option<Wrap<Arc<u32>>>,
+}
+
+impl Issue12357 {
+    fn f(&self) -> Option<Arc<u32>> {
+        self.current.as_ref().map(|p| Arc::clone(p))
+    }
+
+    fn g(&self) {
+        let result: Result<String, NonCloneableError> = Ok("Hello".to_string());
+        let cloned = result.as_ref().map(|s| s.clone());
+    }
+}
+
 fn main() {
     not_ok();
     ok();
diff --git a/src/tools/clippy/tests/ui/useless_asref.stderr b/src/tools/clippy/tests/ui/useless_asref.stderr
index 5f495c396705..8255f5d9d2ab 100644
--- a/src/tools/clippy/tests/ui/useless_asref.stderr
+++ b/src/tools/clippy/tests/ui/useless_asref.stderr
@@ -1,5 +1,5 @@
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:50:18
+  --> tests/ui/useless_asref.rs:51:18
    |
 LL |         foo_rstr(rstr.as_ref());
    |                  ^^^^^^^^^^^^^ help: try: `rstr`
@@ -11,103 +11,103 @@ LL | #![deny(clippy::useless_asref)]
    |         ^^^^^^^^^^^^^^^^^^^^^
 
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:52:20
+  --> tests/ui/useless_asref.rs:54:20
    |
 LL |         foo_rslice(rslice.as_ref());
    |                    ^^^^^^^^^^^^^^^ help: try: `rslice`
 
 error: this call to `as_mut` does nothing
-  --> tests/ui/useless_asref.rs:56:21
+  --> tests/ui/useless_asref.rs:59:21
    |
 LL |         foo_mrslice(mrslice.as_mut());
    |                     ^^^^^^^^^^^^^^^^ help: try: `mrslice`
 
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:58:20
+  --> tests/ui/useless_asref.rs:62:20
    |
 LL |         foo_rslice(mrslice.as_ref());
    |                    ^^^^^^^^^^^^^^^^ help: try: `mrslice`
 
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:65:20
+  --> tests/ui/useless_asref.rs:70:20
    |
 LL |         foo_rslice(rrrrrslice.as_ref());
    |                    ^^^^^^^^^^^^^^^^^^^ help: try: `rrrrrslice`
 
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:67:18
+  --> tests/ui/useless_asref.rs:73:18
    |
 LL |         foo_rstr(rrrrrstr.as_ref());
    |                  ^^^^^^^^^^^^^^^^^ help: try: `rrrrrstr`
 
 error: this call to `as_mut` does nothing
-  --> tests/ui/useless_asref.rs:72:21
+  --> tests/ui/useless_asref.rs:79:21
    |
 LL |         foo_mrslice(mrrrrrslice.as_mut());
    |                     ^^^^^^^^^^^^^^^^^^^^ help: try: `mrrrrrslice`
 
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:74:20
+  --> tests/ui/useless_asref.rs:82:20
    |
 LL |         foo_rslice(mrrrrrslice.as_ref());
    |                    ^^^^^^^^^^^^^^^^^^^^ help: try: `mrrrrrslice`
 
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:78:16
+  --> tests/ui/useless_asref.rs:87:16
    |
 LL |     foo_rrrrmr((&&&&MoreRef).as_ref());
    |                ^^^^^^^^^^^^^^^^^^^^^^ help: try: `(&&&&MoreRef)`
 
 error: this call to `as_mut` does nothing
-  --> tests/ui/useless_asref.rs:128:13
+  --> tests/ui/useless_asref.rs:138:13
    |
 LL |     foo_mrt(mrt.as_mut());
    |             ^^^^^^^^^^^^ help: try: `mrt`
 
 error: this call to `as_ref` does nothing
-  --> tests/ui/useless_asref.rs:130:12
+  --> tests/ui/useless_asref.rs:141:12
    |
 LL |     foo_rt(mrt.as_ref());
    |            ^^^^^^^^^^^^ help: try: `mrt`
 
 error: this call to `as_ref.map(...)` does nothing
-  --> tests/ui/useless_asref.rs:141:13
+  --> tests/ui/useless_asref.rs:153:13
    |
 LL |     let z = x.as_ref().map(String::clone);
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.clone()`
 
 error: this call to `as_ref.map(...)` does nothing
-  --> tests/ui/useless_asref.rs:143:13
+  --> tests/ui/useless_asref.rs:156:13
    |
 LL |     let z = x.as_ref().map(|z| z.clone());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.clone()`
 
 error: this call to `as_ref.map(...)` does nothing
-  --> tests/ui/useless_asref.rs:145:13
+  --> tests/ui/useless_asref.rs:159:13
    |
 LL |     let z = x.as_ref().map(|z| String::clone(z));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.clone()`
 
 error: this call to `as_ref.map(...)` does nothing
-  --> tests/ui/useless_asref.rs:169:9
+  --> tests/ui/useless_asref.rs:183:9
    |
 LL |         x.field.as_ref().map(|v| v.clone());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.field.clone()`
 
 error: this call to `as_ref.map(...)` does nothing
-  --> tests/ui/useless_asref.rs:171:9
+  --> tests/ui/useless_asref.rs:186:9
    |
 LL |         x.field.as_ref().map(Clone::clone);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.field.clone()`
 
 error: this call to `as_ref.map(...)` does nothing
-  --> tests/ui/useless_asref.rs:173:9
+  --> tests/ui/useless_asref.rs:189:9
    |
 LL |         x.field.as_ref().map(|v| Clone::clone(v));
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `x.field.clone()`
 
 error: this call to `as_ref.map(...)` does nothing
-  --> tests/ui/useless_asref.rs:178:9
+  --> tests/ui/useless_asref.rs:194:9
    |
 LL |         Some(1).as_ref().map(|&x| x.clone());
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Some(1).clone()`
diff --git a/src/tools/clippy/tests/ui/useless_attribute.fixed b/src/tools/clippy/tests/ui/useless_attribute.fixed
index de1062f123b7..a96c8f46f551 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.fixed
+++ b/src/tools/clippy/tests/ui/useless_attribute.fixed
@@ -6,7 +6,9 @@
 #![feature(rustc_private)]
 
 #![allow(dead_code)]
+//~^ useless_attribute
 #![cfg_attr(clippy, allow(dead_code))]
+//~^ useless_attribute
 #[rustfmt::skip]
 #[allow(unused_imports)]
 #[allow(unused_extern_crates)]
@@ -18,6 +20,7 @@ extern crate proc_macro_derive;
 
 fn test_indented_attr() {
     #![allow(clippy::almost_swapped)]
+    //~^ useless_attribute
     use std::collections::HashSet;
 
     let _ = HashSet::<u32>::default();
diff --git a/src/tools/clippy/tests/ui/useless_attribute.rs b/src/tools/clippy/tests/ui/useless_attribute.rs
index 94657dd1ca37..b26410134bbb 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.rs
+++ b/src/tools/clippy/tests/ui/useless_attribute.rs
@@ -6,7 +6,9 @@
 #![feature(rustc_private)]
 
 #[allow(dead_code)]
+//~^ useless_attribute
 #[cfg_attr(clippy, allow(dead_code))]
+//~^ useless_attribute
 #[rustfmt::skip]
 #[allow(unused_imports)]
 #[allow(unused_extern_crates)]
@@ -18,6 +20,7 @@ extern crate proc_macro_derive;
 
 fn test_indented_attr() {
     #[allow(clippy::almost_swapped)]
+    //~^ useless_attribute
     use std::collections::HashSet;
 
     let _ = HashSet::<u32>::default();
diff --git a/src/tools/clippy/tests/ui/useless_attribute.stderr b/src/tools/clippy/tests/ui/useless_attribute.stderr
index 19f0e02de680..91383adf994b 100644
--- a/src/tools/clippy/tests/ui/useless_attribute.stderr
+++ b/src/tools/clippy/tests/ui/useless_attribute.stderr
@@ -8,13 +8,13 @@ LL | #[allow(dead_code)]
    = help: to override `-D warnings` add `#[allow(clippy::useless_attribute)]`
 
 error: useless lint attribute
-  --> tests/ui/useless_attribute.rs:9:1
+  --> tests/ui/useless_attribute.rs:10:1
    |
 LL | #[cfg_attr(clippy, allow(dead_code))]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![cfg_attr(clippy, allow(dead_code)`
 
 error: useless lint attribute
-  --> tests/ui/useless_attribute.rs:20:5
+  --> tests/ui/useless_attribute.rs:22:5
    |
 LL |     #[allow(clippy::almost_swapped)]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: if you just forgot a `!`, use: `#![allow(clippy::almost_swapped)]`
diff --git a/src/tools/clippy/tests/ui/useless_conversion.fixed b/src/tools/clippy/tests/ui/useless_conversion.fixed
index 697d437b3885..489caacf2123 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.fixed
+++ b/src/tools/clippy/tests/ui/useless_conversion.fixed
@@ -7,7 +7,9 @@ use std::ops::ControlFlow;
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = val;
+    //~^ useless_conversion
     val
+    //~^ useless_conversion
 }
 
 fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
@@ -20,6 +22,7 @@ fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
 fn test_questionmark() -> Result<(), ()> {
     {
         let _: i32 = 0i32;
+        //~^ useless_conversion
         Ok(Ok(()))
     }??;
     Ok(())
@@ -50,28 +53,33 @@ fn lint_into_iter_on_mutable_local_implementing_iterator_in_expr() {
     let text = "foo\r\nbar\n\nbaz\n";
     let mut lines = text.lines();
     if Some("ok") == lines.next() {}
+    //~^ useless_conversion
 }
 
 fn lint_into_iter_on_expr_implementing_iterator() {
     let text = "foo\r\nbar\n\nbaz\n";
     let mut lines = text.lines();
+    //~^ useless_conversion
     if Some("ok") == lines.next() {}
 }
 
 fn lint_into_iter_on_expr_implementing_iterator_2() {
     let text = "foo\r\nbar\n\nbaz\n";
     if Some("ok") == text.lines().next() {}
+    //~^ useless_conversion
 }
 
 #[allow(const_item_mutation)]
 fn lint_into_iter_on_const_implementing_iterator() {
     const NUMBERS: std::ops::Range<i32> = 0..10;
     let _ = NUMBERS.next();
+    //~^ useless_conversion
 }
 
 fn lint_into_iter_on_const_implementing_iterator_2() {
     const NUMBERS: std::ops::Range<i32> = 0..10;
     let mut n = NUMBERS;
+    //~^ useless_conversion
     n.next();
 }
 
@@ -134,27 +142,38 @@ fn main() {
     }
 
     let _: String = "foo".to_string();
+    //~^ useless_conversion
     let _: String = "foo".to_string();
+    //~^ useless_conversion
     let _ = "foo".to_string();
+    //~^ useless_conversion
     let _ = format!("A: {:04}", 123);
+    //~^ useless_conversion
     let _ = "".lines();
+    //~^ useless_conversion
     let _ = vec![1, 2, 3].into_iter();
+    //~^ useless_conversion
     let _: String = format!("Hello {}", "world");
+    //~^ useless_conversion
 
     // keep parentheses around `a + b` for suggestion (see #4750)
     let a: i32 = 1;
     let b: i32 = 1;
     let _ = (a + b) * 3;
+    //~^ useless_conversion
 
     // see #7205
     let s: Foo<'a'> = Foo;
     let _: Foo<'b'> = s.into();
     let s2: Foo<'a'> = Foo;
     let _: Foo<'a'> = s2;
+    //~^ useless_conversion
     let s3: Foo<'a'> = Foo;
     let _ = s3;
+    //~^ useless_conversion
     let s4: Foo<'a'> = Foo;
     let _ = vec![s4, s4, s4].into_iter();
+    //~^ useless_conversion
 
     issue11300::bar();
 }
@@ -187,12 +206,17 @@ fn explicit_into_iter_fn_arg() {
 
     a(vec![1, 2].into_iter());
     b(vec![1, 2]);
+    //~^ useless_conversion
     c(vec![1, 2]);
+    //~^ useless_conversion
     d(vec![1, 2]);
+    //~^ useless_conversion
     b([&1, &2, &3].into_iter().cloned());
 
     b(vec![1, 2]);
+    //~^ useless_conversion
     b(vec![1, 2]);
+    //~^ useless_conversion
 
     macro_rules! macro_generated {
         () => {
@@ -239,6 +263,7 @@ mod issue11300 {
 
         // This should trigger the lint, receiver type [i32; 3] also implements `Helper`
         foo2::<i32, _>([1, 2, 3]);
+        //~^ useless_conversion
 
         // This again should *not* lint, since X = () and I = std::array::IntoIter<i32, 3>,
         // and `[i32; 3]: Helper<()>` is not true (only `std::array::IntoIter<i32, 3>: Helper<()>` is).
@@ -247,6 +272,7 @@ mod issue11300 {
         // This should lint. Removing the `.into_iter()` means that `I` gets substituted with `[i32; 3]`,
         // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unnecessary.
         foo3([1, 2, 3]);
+        //~^ useless_conversion
     }
 
     fn ice() {
@@ -256,6 +282,7 @@ mod issue11300 {
         }
 
         S1.foo([1, 2]);
+        //~^ useless_conversion
 
         // ICE that occurred in itertools
         trait Itertools {
@@ -275,6 +302,7 @@ mod issue11300 {
         let v0: Vec<i32> = vec![0, 2, 4];
         let v1: Vec<i32> = vec![1, 3, 5, 7];
         v0.into_iter().interleave_shortest(v1);
+        //~^ useless_conversion
 
         trait TraitWithLifetime<'a> {}
         impl<'a> TraitWithLifetime<'a> for std::array::IntoIter<&'a i32, 2> {}
@@ -303,16 +331,20 @@ impl From<Foo<'a'>> for Foo<'b'> {
 fn direct_application() {
     let _: Result<(), std::io::Error> = test_issue_3913();
     //~^ useless_conversion
+
     let _: Result<(), std::io::Error> = test_issue_3913();
     //~^ useless_conversion
+
     let _: Result<(), std::io::Error> = test_issue_3913();
     //~^ useless_conversion
+
     let _: Result<(), std::io::Error> = test_issue_3913();
     //~^ useless_conversion
 
     let c: ControlFlow<()> = ControlFlow::Continue(());
     let _: ControlFlow<()> = c;
     //~^ useless_conversion
+
     let c: ControlFlow<()> = ControlFlow::Continue(());
     let _: ControlFlow<()> = c;
     //~^ useless_conversion
diff --git a/src/tools/clippy/tests/ui/useless_conversion.rs b/src/tools/clippy/tests/ui/useless_conversion.rs
index 4d8ad61a8c99..4f3a3b00ea20 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.rs
+++ b/src/tools/clippy/tests/ui/useless_conversion.rs
@@ -7,7 +7,9 @@ use std::ops::ControlFlow;
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = T::from(val);
+    //~^ useless_conversion
     val.into()
+    //~^ useless_conversion
 }
 
 fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
@@ -20,6 +22,7 @@ fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
 fn test_questionmark() -> Result<(), ()> {
     {
         let _: i32 = 0i32.into();
+        //~^ useless_conversion
         Ok(Ok(()))
     }??;
     Ok(())
@@ -50,28 +53,33 @@ fn lint_into_iter_on_mutable_local_implementing_iterator_in_expr() {
     let text = "foo\r\nbar\n\nbaz\n";
     let mut lines = text.lines();
     if Some("ok") == lines.into_iter().next() {}
+    //~^ useless_conversion
 }
 
 fn lint_into_iter_on_expr_implementing_iterator() {
     let text = "foo\r\nbar\n\nbaz\n";
     let mut lines = text.lines().into_iter();
+    //~^ useless_conversion
     if Some("ok") == lines.next() {}
 }
 
 fn lint_into_iter_on_expr_implementing_iterator_2() {
     let text = "foo\r\nbar\n\nbaz\n";
     if Some("ok") == text.lines().into_iter().next() {}
+    //~^ useless_conversion
 }
 
 #[allow(const_item_mutation)]
 fn lint_into_iter_on_const_implementing_iterator() {
     const NUMBERS: std::ops::Range<i32> = 0..10;
     let _ = NUMBERS.into_iter().next();
+    //~^ useless_conversion
 }
 
 fn lint_into_iter_on_const_implementing_iterator_2() {
     const NUMBERS: std::ops::Range<i32> = 0..10;
     let mut n = NUMBERS.into_iter();
+    //~^ useless_conversion
     n.next();
 }
 
@@ -134,27 +142,38 @@ fn main() {
     }
 
     let _: String = "foo".to_string().into();
+    //~^ useless_conversion
     let _: String = From::from("foo".to_string());
+    //~^ useless_conversion
     let _ = String::from("foo".to_string());
+    //~^ useless_conversion
     let _ = String::from(format!("A: {:04}", 123));
+    //~^ useless_conversion
     let _ = "".lines().into_iter();
+    //~^ useless_conversion
     let _ = vec![1, 2, 3].into_iter().into_iter();
+    //~^ useless_conversion
     let _: String = format!("Hello {}", "world").into();
+    //~^ useless_conversion
 
     // keep parentheses around `a + b` for suggestion (see #4750)
     let a: i32 = 1;
     let b: i32 = 1;
     let _ = i32::from(a + b) * 3;
+    //~^ useless_conversion
 
     // see #7205
     let s: Foo<'a'> = Foo;
     let _: Foo<'b'> = s.into();
     let s2: Foo<'a'> = Foo;
     let _: Foo<'a'> = s2.into();
+    //~^ useless_conversion
     let s3: Foo<'a'> = Foo;
     let _ = Foo::<'a'>::from(s3);
+    //~^ useless_conversion
     let s4: Foo<'a'> = Foo;
     let _ = vec![s4, s4, s4].into_iter().into_iter();
+    //~^ useless_conversion
 
     issue11300::bar();
 }
@@ -187,12 +206,17 @@ fn explicit_into_iter_fn_arg() {
 
     a(vec![1, 2].into_iter());
     b(vec![1, 2].into_iter());
+    //~^ useless_conversion
     c(vec![1, 2].into_iter());
+    //~^ useless_conversion
     d(vec![1, 2].into_iter());
+    //~^ useless_conversion
     b([&1, &2, &3].into_iter().cloned());
 
     b(vec![1, 2].into_iter().into_iter());
+    //~^ useless_conversion
     b(vec![1, 2].into_iter().into_iter().into_iter());
+    //~^ useless_conversion
 
     macro_rules! macro_generated {
         () => {
@@ -239,6 +263,7 @@ mod issue11300 {
 
         // This should trigger the lint, receiver type [i32; 3] also implements `Helper`
         foo2::<i32, _>([1, 2, 3].into_iter());
+        //~^ useless_conversion
 
         // This again should *not* lint, since X = () and I = std::array::IntoIter<i32, 3>,
         // and `[i32; 3]: Helper<()>` is not true (only `std::array::IntoIter<i32, 3>: Helper<()>` is).
@@ -247,6 +272,7 @@ mod issue11300 {
         // This should lint. Removing the `.into_iter()` means that `I` gets substituted with `[i32; 3]`,
         // and `i32: Helper2<[i32, 3]>` is true, so this call is indeed unnecessary.
         foo3([1, 2, 3].into_iter());
+        //~^ useless_conversion
     }
 
     fn ice() {
@@ -256,6 +282,7 @@ mod issue11300 {
         }
 
         S1.foo([1, 2].into_iter());
+        //~^ useless_conversion
 
         // ICE that occurred in itertools
         trait Itertools {
@@ -275,6 +302,7 @@ mod issue11300 {
         let v0: Vec<i32> = vec![0, 2, 4];
         let v1: Vec<i32> = vec![1, 3, 5, 7];
         v0.into_iter().interleave_shortest(v1.into_iter());
+        //~^ useless_conversion
 
         trait TraitWithLifetime<'a> {}
         impl<'a> TraitWithLifetime<'a> for std::array::IntoIter<&'a i32, 2> {}
@@ -303,16 +331,20 @@ impl From<Foo<'a'>> for Foo<'b'> {
 fn direct_application() {
     let _: Result<(), std::io::Error> = test_issue_3913().map(Into::into);
     //~^ useless_conversion
+
     let _: Result<(), std::io::Error> = test_issue_3913().map_err(Into::into);
     //~^ useless_conversion
+
     let _: Result<(), std::io::Error> = test_issue_3913().map(From::from);
     //~^ useless_conversion
+
     let _: Result<(), std::io::Error> = test_issue_3913().map_err(From::from);
     //~^ useless_conversion
 
     let c: ControlFlow<()> = ControlFlow::Continue(());
     let _: ControlFlow<()> = c.map_break(Into::into);
     //~^ useless_conversion
+
     let c: ControlFlow<()> = ControlFlow::Continue(());
     let _: ControlFlow<()> = c.map_continue(Into::into);
     //~^ useless_conversion
diff --git a/src/tools/clippy/tests/ui/useless_conversion.stderr b/src/tools/clippy/tests/ui/useless_conversion.stderr
index ed50f3071862..3cde2a786e46 100644
--- a/src/tools/clippy/tests/ui/useless_conversion.stderr
+++ b/src/tools/clippy/tests/ui/useless_conversion.stderr
@@ -11,115 +11,115 @@ LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: useless conversion to the same type: `T`
-  --> tests/ui/useless_conversion.rs:10:5
+  --> tests/ui/useless_conversion.rs:11:5
    |
 LL |     val.into()
    |     ^^^^^^^^^^ help: consider removing `.into()`: `val`
 
 error: useless conversion to the same type: `i32`
-  --> tests/ui/useless_conversion.rs:22:22
+  --> tests/ui/useless_conversion.rs:24:22
    |
 LL |         let _: i32 = 0i32.into();
    |                      ^^^^^^^^^^^ help: consider removing `.into()`: `0i32`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:52:22
+  --> tests/ui/useless_conversion.rs:55:22
    |
 LL |     if Some("ok") == lines.into_iter().next() {}
    |                      ^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `lines`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:57:21
+  --> tests/ui/useless_conversion.rs:61:21
    |
 LL |     let mut lines = text.lines().into_iter();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:63:22
+  --> tests/ui/useless_conversion.rs:68:22
    |
 LL |     if Some("ok") == text.lines().into_iter().next() {}
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `text.lines()`
 
 error: useless conversion to the same type: `std::ops::Range<i32>`
-  --> tests/ui/useless_conversion.rs:69:13
+  --> tests/ui/useless_conversion.rs:75:13
    |
 LL |     let _ = NUMBERS.into_iter().next();
    |             ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
 
 error: useless conversion to the same type: `std::ops::Range<i32>`
-  --> tests/ui/useless_conversion.rs:74:17
+  --> tests/ui/useless_conversion.rs:81:17
    |
 LL |     let mut n = NUMBERS.into_iter();
    |                 ^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `NUMBERS`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:136:21
+  --> tests/ui/useless_conversion.rs:144:21
    |
 LL |     let _: String = "foo".to_string().into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:137:21
+  --> tests/ui/useless_conversion.rs:146:21
    |
 LL |     let _: String = From::from("foo".to_string());
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `From::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:138:13
+  --> tests/ui/useless_conversion.rs:148:13
    |
 LL |     let _ = String::from("foo".to_string());
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `"foo".to_string()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:139:13
+  --> tests/ui/useless_conversion.rs:150:13
    |
 LL |     let _ = String::from(format!("A: {:04}", 123));
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `String::from()`: `format!("A: {:04}", 123)`
 
 error: useless conversion to the same type: `std::str::Lines<'_>`
-  --> tests/ui/useless_conversion.rs:140:13
+  --> tests/ui/useless_conversion.rs:152:13
    |
 LL |     let _ = "".lines().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `"".lines()`
 
 error: useless conversion to the same type: `std::vec::IntoIter<i32>`
-  --> tests/ui/useless_conversion.rs:141:13
+  --> tests/ui/useless_conversion.rs:154:13
    |
 LL |     let _ = vec![1, 2, 3].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![1, 2, 3].into_iter()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion.rs:142:21
+  --> tests/ui/useless_conversion.rs:156:21
    |
 LL |     let _: String = format!("Hello {}", "world").into();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into()`: `format!("Hello {}", "world")`
 
 error: useless conversion to the same type: `i32`
-  --> tests/ui/useless_conversion.rs:147:13
+  --> tests/ui/useless_conversion.rs:162:13
    |
 LL |     let _ = i32::from(a + b) * 3;
    |             ^^^^^^^^^^^^^^^^ help: consider removing `i32::from()`: `(a + b)`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> tests/ui/useless_conversion.rs:153:23
+  --> tests/ui/useless_conversion.rs:169:23
    |
 LL |     let _: Foo<'a'> = s2.into();
    |                       ^^^^^^^^^ help: consider removing `.into()`: `s2`
 
 error: useless conversion to the same type: `Foo<'a'>`
-  --> tests/ui/useless_conversion.rs:155:13
+  --> tests/ui/useless_conversion.rs:172:13
    |
 LL |     let _ = Foo::<'a'>::from(s3);
    |             ^^^^^^^^^^^^^^^^^^^^ help: consider removing `Foo::<'a'>::from()`: `s3`
 
 error: useless conversion to the same type: `std::vec::IntoIter<Foo<'a'>>`
-  --> tests/ui/useless_conversion.rs:157:13
+  --> tests/ui/useless_conversion.rs:175:13
    |
 LL |     let _ = vec![s4, s4, s4].into_iter().into_iter();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing `.into_iter()`: `vec![s4, s4, s4].into_iter()`
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:189:7
+  --> tests/ui/useless_conversion.rs:208:7
    |
 LL |     b(vec![1, 2].into_iter());
    |       ^^^^^^^^^^------------
@@ -127,13 +127,13 @@ LL |     b(vec![1, 2].into_iter());
    |                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:179:13
+  --> tests/ui/useless_conversion.rs:198:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:190:7
+  --> tests/ui/useless_conversion.rs:210:7
    |
 LL |     c(vec![1, 2].into_iter());
    |       ^^^^^^^^^^------------
@@ -141,13 +141,13 @@ LL |     c(vec![1, 2].into_iter());
    |                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:180:18
+  --> tests/ui/useless_conversion.rs:199:18
    |
 LL |     fn c(_: impl IntoIterator<Item = i32>) {}
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:191:7
+  --> tests/ui/useless_conversion.rs:212:7
    |
 LL |     d(vec![1, 2].into_iter());
    |       ^^^^^^^^^^------------
@@ -155,13 +155,13 @@ LL |     d(vec![1, 2].into_iter());
    |                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:183:12
+  --> tests/ui/useless_conversion.rs:202:12
    |
 LL |         T: IntoIterator<Item = i32>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:194:7
+  --> tests/ui/useless_conversion.rs:216:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter());
    |       ^^^^^^^^^^------------------------
@@ -169,13 +169,13 @@ LL |     b(vec![1, 2].into_iter().into_iter());
    |                 help: consider removing the `.into_iter()`s
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:179:13
+  --> tests/ui/useless_conversion.rs:198:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:195:7
+  --> tests/ui/useless_conversion.rs:218:7
    |
 LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
    |       ^^^^^^^^^^------------------------------------
@@ -183,13 +183,13 @@ LL |     b(vec![1, 2].into_iter().into_iter().into_iter());
    |                 help: consider removing the `.into_iter()`s
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:179:13
+  --> tests/ui/useless_conversion.rs:198:13
    |
 LL |     fn b<T: IntoIterator<Item = i32>>(_: T) {}
    |             ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:241:24
+  --> tests/ui/useless_conversion.rs:265:24
    |
 LL |         foo2::<i32, _>([1, 2, 3].into_iter());
    |                        ^^^^^^^^^------------
@@ -197,13 +197,13 @@ LL |         foo2::<i32, _>([1, 2, 3].into_iter());
    |                                 help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:220:12
+  --> tests/ui/useless_conversion.rs:244:12
    |
 LL |         I: IntoIterator<Item = i32> + Helper<X>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:249:14
+  --> tests/ui/useless_conversion.rs:274:14
    |
 LL |         foo3([1, 2, 3].into_iter());
    |              ^^^^^^^^^------------
@@ -211,13 +211,13 @@ LL |         foo3([1, 2, 3].into_iter());
    |                       help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:229:12
+  --> tests/ui/useless_conversion.rs:253:12
    |
 LL |         I: IntoIterator<Item = i32>,
    |            ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:258:16
+  --> tests/ui/useless_conversion.rs:284:16
    |
 LL |         S1.foo([1, 2].into_iter());
    |                ^^^^^^------------
@@ -225,13 +225,13 @@ LL |         S1.foo([1, 2].into_iter());
    |                      help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:255:27
+  --> tests/ui/useless_conversion.rs:281:27
    |
 LL |             pub fn foo<I: IntoIterator>(&self, _: I) {}
    |                           ^^^^^^^^^^^^
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:277:44
+  --> tests/ui/useless_conversion.rs:304:44
    |
 LL |         v0.into_iter().interleave_shortest(v1.into_iter());
    |                                            ^^------------
@@ -239,67 +239,67 @@ LL |         v0.into_iter().interleave_shortest(v1.into_iter());
    |                                              help: consider removing the `.into_iter()`
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:264:20
+  --> tests/ui/useless_conversion.rs:291:20
    |
 LL |                 J: IntoIterator,
    |                    ^^^^^^^^^^^^
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:304:58
+  --> tests/ui/useless_conversion.rs:332:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map(Into::into);
    |                                                          ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `std::io::Error`
-  --> tests/ui/useless_conversion.rs:306:58
+  --> tests/ui/useless_conversion.rs:335:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map_err(Into::into);
    |                                                          ^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:308:58
+  --> tests/ui/useless_conversion.rs:338:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map(From::from);
    |                                                          ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `std::io::Error`
-  --> tests/ui/useless_conversion.rs:310:58
+  --> tests/ui/useless_conversion.rs:341:58
    |
 LL |     let _: Result<(), std::io::Error> = test_issue_3913().map_err(From::from);
    |                                                          ^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:314:31
+  --> tests/ui/useless_conversion.rs:345:31
    |
 LL |     let _: ControlFlow<()> = c.map_break(Into::into);
    |                               ^^^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `()`
-  --> tests/ui/useless_conversion.rs:317:31
+  --> tests/ui/useless_conversion.rs:349:31
    |
 LL |     let _: ControlFlow<()> = c.map_continue(Into::into);
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `u32`
-  --> tests/ui/useless_conversion.rs:331:41
+  --> tests/ui/useless_conversion.rs:363:41
    |
 LL |     let _: Vec<u32> = [1u32].into_iter().map(Into::into).collect();
    |                                         ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: useless conversion to the same type: `T`
-  --> tests/ui/useless_conversion.rs:342:18
+  --> tests/ui/useless_conversion.rs:374:18
    |
 LL |     x.into_iter().map(Into::into).collect()
    |                  ^^^^^^^^^^^^^^^^ help: consider removing
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:358:29
+  --> tests/ui/useless_conversion.rs:390:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:347:32
+  --> tests/ui/useless_conversion.rs:379:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -310,13 +310,13 @@ LL +             takes_into_iter(&self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:366:29
+  --> tests/ui/useless_conversion.rs:398:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:347:32
+  --> tests/ui/useless_conversion.rs:379:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -327,13 +327,13 @@ LL +             takes_into_iter(&mut self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:375:29
+  --> tests/ui/useless_conversion.rs:407:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:347:32
+  --> tests/ui/useless_conversion.rs:379:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -344,13 +344,13 @@ LL +             takes_into_iter(*self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:384:29
+  --> tests/ui/useless_conversion.rs:416:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:347:32
+  --> tests/ui/useless_conversion.rs:379:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -361,13 +361,13 @@ LL +             takes_into_iter(&*self.my_field);
    |
 
 error: explicit call to `.into_iter()` in function argument accepting `IntoIterator`
-  --> tests/ui/useless_conversion.rs:393:29
+  --> tests/ui/useless_conversion.rs:425:29
    |
 LL |             takes_into_iter(self.my_field.into_iter());
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this parameter accepts any `IntoIterator`, so you don't need to call `.into_iter()`
-  --> tests/ui/useless_conversion.rs:347:32
+  --> tests/ui/useless_conversion.rs:379:32
    |
 LL |     fn takes_into_iter(_: impl IntoIterator<Item = String>) {}
    |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/useless_conversion_try.rs b/src/tools/clippy/tests/ui/useless_conversion_try.rs
index 23edeae12b83..d16506d94aa3 100644
--- a/src/tools/clippy/tests/ui/useless_conversion_try.rs
+++ b/src/tools/clippy/tests/ui/useless_conversion_try.rs
@@ -7,9 +7,10 @@
 
 fn test_generic<T: Copy>(val: T) -> T {
     let _ = T::try_from(val).unwrap();
-    //~^ ERROR: useless conversion to the same type: `T`
+    //~^ useless_conversion
+
     val.try_into().unwrap()
-    //~^ ERROR: useless conversion to the same type: `T`
+    //~^ useless_conversion
 }
 
 fn test_generic2<T: Copy + Into<i32> + Into<U>, U: From<T>>(val: T) {
@@ -32,19 +33,25 @@ fn main() {
         let _: String = "foo".try_into().unwrap();
     }
     let _: String = "foo".to_string().try_into().unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ useless_conversion
+
     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ useless_conversion
+
     let _ = String::try_from("foo".to_string()).unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ useless_conversion
+
     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ useless_conversion
+
     let _: String = format!("Hello {}", "world").try_into().unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ useless_conversion
+
     let _: String = String::new().try_into().unwrap();
-    //~^ ERROR: useless conversion to the same type: `std::string::String`
+    //~^ useless_conversion
+
     let _: String = match String::from("_").try_into() {
-        //~^ ERROR: useless conversion to the same type: `std::string::String`
+        //~^ useless_conversion
         Ok(a) => a,
         Err(_) => String::new(),
     };
diff --git a/src/tools/clippy/tests/ui/useless_conversion_try.stderr b/src/tools/clippy/tests/ui/useless_conversion_try.stderr
index 30a43629dbd6..1c62426c8952 100644
--- a/src/tools/clippy/tests/ui/useless_conversion_try.stderr
+++ b/src/tools/clippy/tests/ui/useless_conversion_try.stderr
@@ -12,7 +12,7 @@ LL | #![deny(clippy::useless_conversion)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: useless conversion to the same type: `T`
-  --> tests/ui/useless_conversion_try.rs:11:5
+  --> tests/ui/useless_conversion_try.rs:12:5
    |
 LL |     val.try_into().unwrap()
    |     ^^^^^^^^^^^^^^
@@ -20,7 +20,7 @@ LL |     val.try_into().unwrap()
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion_try.rs:34:21
+  --> tests/ui/useless_conversion_try.rs:35:21
    |
 LL |     let _: String = "foo".to_string().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,7 +28,7 @@ LL |     let _: String = "foo".to_string().try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion_try.rs:36:21
+  --> tests/ui/useless_conversion_try.rs:38:21
    |
 LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     let _: String = TryFrom::try_from("foo".to_string()).unwrap();
    = help: consider removing `TryFrom::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion_try.rs:38:13
+  --> tests/ui/useless_conversion_try.rs:41:13
    |
 LL |     let _ = String::try_from("foo".to_string()).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -44,7 +44,7 @@ LL |     let _ = String::try_from("foo".to_string()).unwrap();
    = help: consider removing `String::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion_try.rs:40:13
+  --> tests/ui/useless_conversion_try.rs:44:13
    |
 LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -52,7 +52,7 @@ LL |     let _ = String::try_from(format!("A: {:04}", 123)).unwrap();
    = help: consider removing `String::try_from()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion_try.rs:42:21
+  --> tests/ui/useless_conversion_try.rs:47:21
    |
 LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -60,7 +60,7 @@ LL |     let _: String = format!("Hello {}", "world").try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion_try.rs:44:21
+  --> tests/ui/useless_conversion_try.rs:50:21
    |
 LL |     let _: String = String::new().try_into().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -68,7 +68,7 @@ LL |     let _: String = String::new().try_into().unwrap();
    = help: consider removing `.try_into()`
 
 error: useless conversion to the same type: `std::string::String`
-  --> tests/ui/useless_conversion_try.rs:46:27
+  --> tests/ui/useless_conversion_try.rs:53:27
    |
 LL |     let _: String = match String::from("_").try_into() {
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.fixed b/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.fixed
index 03b34afa54ec..f7f60bbe3f8d 100644
--- a/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.fixed
+++ b/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.fixed
@@ -5,7 +5,7 @@ use std::num::{NonZero, NonZeroUsize};
 #[clippy::msrv = "1.83"]
 const fn func() -> NonZeroUsize {
     const { NonZeroUsize::new(3).unwrap() }
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 }
 
 #[clippy::msrv = "1.82"]
@@ -35,17 +35,17 @@ macro_rules! nzu {
 
 fn main() {
     const _A: NonZeroUsize = NonZeroUsize::new(3).unwrap();
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     static _B: NonZero<u8> = NonZero::<u8>::new(42).unwrap();
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     const _C: usize = unsafe { NonZeroUsize::new(3).unwrap().get() };
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     const AUX: usize = 3;
     const _D: NonZeroUsize = NonZeroUsize::new(AUX).unwrap();
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     const _X: NonZeroUsize = uns!(NonZeroUsize::new_unchecked(3));
     const _Y: NonZeroUsize = unsafe { nzu!() };
diff --git a/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.rs b/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.rs
index d450e3a03ec5..c90a63915efb 100644
--- a/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.rs
+++ b/src/tools/clippy/tests/ui/useless_nonzero_new_unchecked.rs
@@ -5,7 +5,7 @@ use std::num::{NonZero, NonZeroUsize};
 #[clippy::msrv = "1.83"]
 const fn func() -> NonZeroUsize {
     const { unsafe { NonZeroUsize::new_unchecked(3) } }
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 }
 
 #[clippy::msrv = "1.82"]
@@ -35,17 +35,17 @@ macro_rules! nzu {
 
 fn main() {
     const _A: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(3) };
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     static _B: NonZero<u8> = unsafe { NonZero::<u8>::new_unchecked(42) };
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     const _C: usize = unsafe { NonZeroUsize::new_unchecked(3).get() };
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     const AUX: usize = 3;
     const _D: NonZeroUsize = unsafe { NonZeroUsize::new_unchecked(AUX) };
-    //~^ ERROR: `Option::unwrap()` can be safely used in a `const` context
+    //~^ useless_nonzero_new_unchecked
 
     const _X: NonZeroUsize = uns!(NonZeroUsize::new_unchecked(3));
     const _Y: NonZeroUsize = unsafe { nzu!() };
diff --git a/src/tools/clippy/tests/ui/vec.fixed b/src/tools/clippy/tests/ui/vec.fixed
index 9e755a82af45..f360a8afadf6 100644
--- a/src/tools/clippy/tests/ui/vec.fixed
+++ b/src/tools/clippy/tests/ui/vec.fixed
@@ -28,24 +28,34 @@ impl Line {
 
 fn main() {
     on_slice(&[]);
+    //~^ useless_vec
     on_slice(&[]);
     on_mut_slice(&mut []);
+    //~^ useless_vec
 
     on_slice(&[1, 2]);
+    //~^ useless_vec
     on_slice(&[1, 2]);
     on_mut_slice(&mut [1, 2]);
+    //~^ useless_vec
 
     on_slice(&[1, 2]);
+    //~^ useless_vec
     on_slice(&[1, 2]);
     on_mut_slice(&mut [1, 2]);
+    //~^ useless_vec
     #[rustfmt::skip]
     on_slice(&[1, 2]);
+    //~^ useless_vec
     on_slice(&[1, 2]);
     on_mut_slice(&mut [1, 2]);
+    //~^ useless_vec
 
     on_slice(&[1; 2]);
+    //~^ useless_vec
     on_slice(&[1; 2]);
     on_mut_slice(&mut [1; 2]);
+    //~^ useless_vec
 
     on_vec(&vec![]);
     on_vec(&vec![1, 2]);
@@ -72,17 +82,21 @@ fn main() {
 
     // https://github.com/rust-lang/rust-clippy/issues/2262#issuecomment-783979246
     let _x: i32 = [1, 2, 3].iter().sum();
+    //~^ useless_vec
 
     // Do lint
     let mut x = [1, 2, 3];
+    //~^ useless_vec
     x.fill(123);
     dbg!(x[0]);
     dbg!(x.len());
     dbg!(x.iter().sum::<i32>());
 
     let _x: &[i32] = &[1, 2, 3];
+    //~^ useless_vec
 
     for _ in [1, 2, 3] {}
+    //~^ useless_vec
 
     // Don't lint
     let x = vec![1, 2, 3];
@@ -122,6 +136,7 @@ fn issue11075() {
     }
     #[allow(clippy::never_loop)]
     for _string in [repro!(true), repro!(null)] {
+        //~^ useless_vec
         unimplemented!();
     }
 
@@ -139,6 +154,8 @@ fn issue11075() {
     }
 
     in_macro!(1, [1, 2], [1; 2]);
+    //~^ useless_vec
+    //~| useless_vec
 
     macro_rules! from_macro {
         () => {
@@ -158,10 +175,12 @@ fn issue11075() {
 #[clippy::msrv = "1.53"]
 fn above() {
     for a in [1, 2, 3] {
+        //~^ useless_vec
         let _: usize = a;
     }
 
     for a in [String::new(), String::new()] {
+        //~^ useless_vec
         let _: String = a;
     }
 }
@@ -193,7 +212,8 @@ fn issue11861() {
 
     // Do not lint the next line
     this_macro_needs_vec!(vec![1]);
-    this_macro_doesnt_need_vec!([1]); //~ ERROR: useless use of `vec!`
+    this_macro_doesnt_need_vec!([1]);
+    //~^ useless_vec
 
     macro_rules! m {
         ($x:expr) => {
@@ -220,4 +240,5 @@ fn issue_11958() {
 
 fn issue_12101() {
     for a in &[1, 2] {}
+    //~^ useless_vec
 }
diff --git a/src/tools/clippy/tests/ui/vec.rs b/src/tools/clippy/tests/ui/vec.rs
index c483271438b1..a779d33557cb 100644
--- a/src/tools/clippy/tests/ui/vec.rs
+++ b/src/tools/clippy/tests/ui/vec.rs
@@ -28,24 +28,34 @@ impl Line {
 
 fn main() {
     on_slice(&vec![]);
+    //~^ useless_vec
     on_slice(&[]);
     on_mut_slice(&mut vec![]);
+    //~^ useless_vec
 
     on_slice(&vec![1, 2]);
+    //~^ useless_vec
     on_slice(&[1, 2]);
     on_mut_slice(&mut vec![1, 2]);
+    //~^ useless_vec
 
     on_slice(&vec![1, 2]);
+    //~^ useless_vec
     on_slice(&[1, 2]);
     on_mut_slice(&mut vec![1, 2]);
+    //~^ useless_vec
     #[rustfmt::skip]
     on_slice(&vec!(1, 2));
+    //~^ useless_vec
     on_slice(&[1, 2]);
     on_mut_slice(&mut vec![1, 2]);
+    //~^ useless_vec
 
     on_slice(&vec![1; 2]);
+    //~^ useless_vec
     on_slice(&[1; 2]);
     on_mut_slice(&mut vec![1; 2]);
+    //~^ useless_vec
 
     on_vec(&vec![]);
     on_vec(&vec![1, 2]);
@@ -72,17 +82,21 @@ fn main() {
 
     // https://github.com/rust-lang/rust-clippy/issues/2262#issuecomment-783979246
     let _x: i32 = vec![1, 2, 3].iter().sum();
+    //~^ useless_vec
 
     // Do lint
     let mut x = vec![1, 2, 3];
+    //~^ useless_vec
     x.fill(123);
     dbg!(x[0]);
     dbg!(x.len());
     dbg!(x.iter().sum::<i32>());
 
     let _x: &[i32] = &vec![1, 2, 3];
+    //~^ useless_vec
 
     for _ in vec![1, 2, 3] {}
+    //~^ useless_vec
 
     // Don't lint
     let x = vec![1, 2, 3];
@@ -122,6 +136,7 @@ fn issue11075() {
     }
     #[allow(clippy::never_loop)]
     for _string in vec![repro!(true), repro!(null)] {
+        //~^ useless_vec
         unimplemented!();
     }
 
@@ -139,6 +154,8 @@ fn issue11075() {
     }
 
     in_macro!(1, vec![1, 2], vec![1; 2]);
+    //~^ useless_vec
+    //~| useless_vec
 
     macro_rules! from_macro {
         () => {
@@ -158,10 +175,12 @@ fn issue11075() {
 #[clippy::msrv = "1.53"]
 fn above() {
     for a in vec![1, 2, 3] {
+        //~^ useless_vec
         let _: usize = a;
     }
 
     for a in vec![String::new(), String::new()] {
+        //~^ useless_vec
         let _: String = a;
     }
 }
@@ -193,7 +212,8 @@ fn issue11861() {
 
     // Do not lint the next line
     this_macro_needs_vec!(vec![1]);
-    this_macro_doesnt_need_vec!(vec![1]); //~ ERROR: useless use of `vec!`
+    this_macro_doesnt_need_vec!(vec![1]);
+    //~^ useless_vec
 
     macro_rules! m {
         ($x:expr) => {
@@ -220,4 +240,5 @@ fn issue_11958() {
 
 fn issue_12101() {
     for a in &(vec![1, 2]) {}
+    //~^ useless_vec
 }
diff --git a/src/tools/clippy/tests/ui/vec.stderr b/src/tools/clippy/tests/ui/vec.stderr
index 3faea8033fe2..806d6617200f 100644
--- a/src/tools/clippy/tests/ui/vec.stderr
+++ b/src/tools/clippy/tests/ui/vec.stderr
@@ -8,31 +8,19 @@ LL |     on_slice(&vec![]);
    = help: to override `-D warnings` add `#[allow(clippy::useless_vec)]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:32:18
+  --> tests/ui/vec.rs:33:18
    |
 LL |     on_mut_slice(&mut vec![]);
    |                  ^^^^^^^^^^^ help: you can use a slice directly: `&mut []`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:34:14
+  --> tests/ui/vec.rs:36:14
    |
 LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:36:18
-   |
-LL |     on_mut_slice(&mut vec![1, 2]);
-   |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
-
-error: useless use of `vec!`
-  --> tests/ui/vec.rs:38:14
-   |
-LL |     on_slice(&vec![1, 2]);
-   |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
-
-error: useless use of `vec!`
-  --> tests/ui/vec.rs:40:18
+  --> tests/ui/vec.rs:39:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
@@ -40,89 +28,101 @@ LL |     on_mut_slice(&mut vec![1, 2]);
 error: useless use of `vec!`
   --> tests/ui/vec.rs:42:14
    |
-LL |     on_slice(&vec!(1, 2));
+LL |     on_slice(&vec![1, 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:44:18
+  --> tests/ui/vec.rs:45:18
    |
 LL |     on_mut_slice(&mut vec![1, 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:46:14
+  --> tests/ui/vec.rs:48:14
+   |
+LL |     on_slice(&vec!(1, 2));
+   |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
+
+error: useless use of `vec!`
+  --> tests/ui/vec.rs:51:18
+   |
+LL |     on_mut_slice(&mut vec![1, 2]);
+   |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1, 2]`
+
+error: useless use of `vec!`
+  --> tests/ui/vec.rs:54:14
    |
 LL |     on_slice(&vec![1; 2]);
    |              ^^^^^^^^^^^ help: you can use a slice directly: `&[1; 2]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:48:18
+  --> tests/ui/vec.rs:57:18
    |
 LL |     on_mut_slice(&mut vec![1; 2]);
    |                  ^^^^^^^^^^^^^^^ help: you can use a slice directly: `&mut [1; 2]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:74:19
+  --> tests/ui/vec.rs:84:19
    |
 LL |     let _x: i32 = vec![1, 2, 3].iter().sum();
    |                   ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:77:17
+  --> tests/ui/vec.rs:88:17
    |
 LL |     let mut x = vec![1, 2, 3];
    |                 ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:83:22
+  --> tests/ui/vec.rs:95:22
    |
 LL |     let _x: &[i32] = &vec![1, 2, 3];
    |                      ^^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:85:14
+  --> tests/ui/vec.rs:98:14
    |
 LL |     for _ in vec![1, 2, 3] {}
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:124:20
+  --> tests/ui/vec.rs:138:20
    |
 LL |     for _string in vec![repro!(true), repro!(null)] {
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[repro!(true), repro!(null)]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:141:18
+  --> tests/ui/vec.rs:156:18
    |
 LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
    |                  ^^^^^^^^^^ help: you can use an array directly: `[1, 2]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:141:30
+  --> tests/ui/vec.rs:156:30
    |
 LL |     in_macro!(1, vec![1, 2], vec![1; 2]);
    |                              ^^^^^^^^^^ help: you can use an array directly: `[1; 2]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:160:14
+  --> tests/ui/vec.rs:177:14
    |
 LL |     for a in vec![1, 2, 3] {
    |              ^^^^^^^^^^^^^ help: you can use an array directly: `[1, 2, 3]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:164:14
+  --> tests/ui/vec.rs:182:14
    |
 LL |     for a in vec![String::new(), String::new()] {
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: you can use an array directly: `[String::new(), String::new()]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:196:33
+  --> tests/ui/vec.rs:215:33
    |
 LL |     this_macro_doesnt_need_vec!(vec![1]);
    |                                 ^^^^^^^ help: you can use an array directly: `[1]`
 
 error: useless use of `vec!`
-  --> tests/ui/vec.rs:222:14
+  --> tests/ui/vec.rs:242:14
    |
 LL |     for a in &(vec![1, 2]) {}
    |              ^^^^^^^^^^^^^ help: you can use a slice directly: `&[1, 2]`
diff --git a/src/tools/clippy/tests/ui/vec_box_sized.rs b/src/tools/clippy/tests/ui/vec_box_sized.rs
index 49eaf8e062af..897add423b6d 100644
--- a/src/tools/clippy/tests/ui/vec_box_sized.rs
+++ b/src/tools/clippy/tests/ui/vec_box_sized.rs
@@ -24,22 +24,30 @@ unsafe impl Allocator for DummyAllocator {
 mod should_trigger {
     use super::{DummyAllocator, SizedStruct};
     const C: Vec<Box<i32>> = Vec::new();
+    //~^ vec_box
     static S: Vec<Box<i32>> = Vec::new();
+    //~^ vec_box
 
     struct StructWithVecBox {
         sized_type: Vec<Box<SizedStruct>>,
+        //~^ vec_box
     }
 
     struct A(Vec<Box<SizedStruct>>);
+    //~^ vec_box
     struct B(Vec<Vec<Box<(u32)>>>);
+    //~^ vec_box
 
     fn allocator_global_defined_vec() -> Vec<Box<i32>, std::alloc::Global> {
+        //~^ vec_box
         Vec::new()
     }
     fn allocator_global_defined_box() -> Vec<Box<i32, std::alloc::Global>> {
+        //~^ vec_box
         Vec::new()
     }
     fn allocator_match() -> Vec<Box<i32, DummyAllocator>, DummyAllocator> {
+        //~^ vec_box
         Vec::new_in(DummyAllocator)
     }
 }
@@ -77,6 +85,7 @@ mod inner_mod {
         use super::inner::S;
 
         pub fn f() -> Vec<Box<S>> {
+            //~^ vec_box
             vec![]
         }
     }
diff --git a/src/tools/clippy/tests/ui/vec_box_sized.stderr b/src/tools/clippy/tests/ui/vec_box_sized.stderr
index 0ffcc8314340..65db267977a6 100644
--- a/src/tools/clippy/tests/ui/vec_box_sized.stderr
+++ b/src/tools/clippy/tests/ui/vec_box_sized.stderr
@@ -8,49 +8,49 @@ LL |     const C: Vec<Box<i32>> = Vec::new();
    = help: to override `-D warnings` add `#[allow(clippy::vec_box)]`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:27:15
+  --> tests/ui/vec_box_sized.rs:28:15
    |
 LL |     static S: Vec<Box<i32>> = Vec::new();
    |               ^^^^^^^^^^^^^ help: try: `Vec<i32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:30:21
+  --> tests/ui/vec_box_sized.rs:32:21
    |
 LL |         sized_type: Vec<Box<SizedStruct>>,
    |                     ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:33:14
+  --> tests/ui/vec_box_sized.rs:36:14
    |
 LL |     struct A(Vec<Box<SizedStruct>>);
    |              ^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<SizedStruct>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:34:18
+  --> tests/ui/vec_box_sized.rs:38:18
    |
 LL |     struct B(Vec<Vec<Box<(u32)>>>);
    |                  ^^^^^^^^^^^^^^^ help: try: `Vec<u32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:36:42
+  --> tests/ui/vec_box_sized.rs:41:42
    |
 LL |     fn allocator_global_defined_vec() -> Vec<Box<i32>, std::alloc::Global> {
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<i32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:39:42
+  --> tests/ui/vec_box_sized.rs:45:42
    |
 LL |     fn allocator_global_defined_box() -> Vec<Box<i32, std::alloc::Global>> {
    |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<i32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:42:29
+  --> tests/ui/vec_box_sized.rs:49:29
    |
 LL |     fn allocator_match() -> Vec<Box<i32, DummyAllocator>, DummyAllocator> {
    |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `Vec<i32>`
 
 error: `Vec<T>` is already on the heap, the boxing is unnecessary
-  --> tests/ui/vec_box_sized.rs:79:23
+  --> tests/ui/vec_box_sized.rs:87:23
    |
 LL |         pub fn f() -> Vec<Box<S>> {
    |                       ^^^^^^^^^^^ help: try: `Vec<S>`
diff --git a/src/tools/clippy/tests/ui/vec_init_then_push.rs b/src/tools/clippy/tests/ui/vec_init_then_push.rs
index 1c60a75c56ae..a32187edfea6 100644
--- a/src/tools/clippy/tests/ui/vec_init_then_push.rs
+++ b/src/tools/clippy/tests/ui/vec_init_then_push.rs
@@ -3,16 +3,18 @@
 //@no-rustfix
 fn main() {
     let mut def_err: Vec<u32> = Default::default();
-    //~^ ERROR: calls to `push` immediately after creation
-    //~| NOTE: `-D clippy::vec-init-then-push` implied by `-D warnings`
+    //~^ vec_init_then_push
+
     def_err.push(0);
 
     let mut new_err = Vec::<u32>::new();
-    //~^ ERROR: calls to `push` immediately after creation
+    //~^ vec_init_then_push
+
     new_err.push(1);
 
     let mut cap_err = Vec::with_capacity(2);
-    //~^ ERROR: calls to `push` immediately after creation
+    //~^ vec_init_then_push
+
     cap_err.push(0);
     cap_err.push(1);
     cap_err.push(2);
@@ -25,7 +27,8 @@ fn main() {
     cap_ok.push(0);
 
     new_err = Vec::new();
-    //~^ ERROR: calls to `push` immediately after creation
+    //~^ vec_init_then_push
+
     new_err.push(0);
 
     let mut vec = Vec::new();
@@ -76,7 +79,8 @@ fn _cond_push(x: bool) -> Vec<u32> {
 
 fn _push_then_edit(x: u32) -> Vec<u32> {
     let mut v = Vec::new();
-    //~^ ERROR: calls to `push` immediately after creation
+    //~^ vec_init_then_push
+
     v.push(x);
     v.push(1);
     v[0] = v[1] + 5;
@@ -85,7 +89,8 @@ fn _push_then_edit(x: u32) -> Vec<u32> {
 
 fn _cond_push_with_large_start(x: bool) -> Vec<u32> {
     let mut v = Vec::new();
-    //~^ ERROR: calls to `push` immediately after creation
+    //~^ vec_init_then_push
+
     v.push(0);
     v.push(1);
     v.push(0);
@@ -99,7 +104,8 @@ fn _cond_push_with_large_start(x: bool) -> Vec<u32> {
     }
 
     let mut v2 = Vec::new();
-    //~^ ERROR: calls to `push` immediately after creation
+    //~^ vec_init_then_push
+
     v2.push(0);
     v2.push(1);
     v2.push(0);
@@ -115,7 +121,8 @@ fn _cond_push_with_large_start(x: bool) -> Vec<u32> {
 
 fn f() {
     let mut v = Vec::new();
-    //~^ ERROR: calls to `push` immediately after creation
+    //~^ vec_init_then_push
+
     v.push((0i32, 0i32));
     let y = v[0].0.abs();
 }
diff --git a/src/tools/clippy/tests/ui/vec_init_then_push.stderr b/src/tools/clippy/tests/ui/vec_init_then_push.stderr
index f35625c9b085..1900ad7bd6a0 100644
--- a/src/tools/clippy/tests/ui/vec_init_then_push.stderr
+++ b/src/tools/clippy/tests/ui/vec_init_then_push.stderr
@@ -13,66 +13,68 @@ error: calls to `push` immediately after creation
   --> tests/ui/vec_init_then_push.rs:10:5
    |
 LL | /     let mut new_err = Vec::<u32>::new();
-LL | |
+...  |
 LL | |     new_err.push(1);
    | |____________________^ help: consider using the `vec![]` macro: `let mut new_err = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/vec_init_then_push.rs:14:5
+  --> tests/ui/vec_init_then_push.rs:15:5
    |
 LL | /     let mut cap_err = Vec::with_capacity(2);
 LL | |
+LL | |
 LL | |     cap_err.push(0);
 LL | |     cap_err.push(1);
 LL | |     cap_err.push(2);
    | |____________________^ help: consider using the `vec![]` macro: `let mut cap_err = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/vec_init_then_push.rs:27:5
+  --> tests/ui/vec_init_then_push.rs:29:5
    |
 LL | /     new_err = Vec::new();
-LL | |
+...  |
 LL | |     new_err.push(0);
    | |____________________^ help: consider using the `vec![]` macro: `new_err = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/vec_init_then_push.rs:78:5
+  --> tests/ui/vec_init_then_push.rs:81:5
    |
 LL | /     let mut v = Vec::new();
 LL | |
+LL | |
 LL | |     v.push(x);
 LL | |     v.push(1);
    | |______________^ help: consider using the `vec![]` macro: `let mut v = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/vec_init_then_push.rs:87:5
+  --> tests/ui/vec_init_then_push.rs:91:5
    |
 LL | /     let mut v = Vec::new();
 LL | |
+LL | |
 LL | |     v.push(0);
-LL | |     v.push(1);
 ...  |
 LL | |     v.push(1);
 LL | |     v.push(0);
    | |______________^ help: consider using the `vec![]` macro: `let mut v = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/vec_init_then_push.rs:101:5
+  --> tests/ui/vec_init_then_push.rs:106:5
    |
 LL | /     let mut v2 = Vec::new();
 LL | |
+LL | |
 LL | |     v2.push(0);
-LL | |     v2.push(1);
 ...  |
 LL | |     v2.push(1);
 LL | |     v2.push(0);
    | |_______________^ help: consider using the `vec![]` macro: `let mut v2 = vec![..];`
 
 error: calls to `push` immediately after creation
-  --> tests/ui/vec_init_then_push.rs:117:5
+  --> tests/ui/vec_init_then_push.rs:123:5
    |
 LL | /     let mut v = Vec::new();
-LL | |
+...  |
 LL | |     v.push((0i32, 0i32));
    | |_________________________^ help: consider using the `vec![]` macro: `let v = vec![..];`
 
diff --git a/src/tools/clippy/tests/ui/vec_resize_to_zero.fixed b/src/tools/clippy/tests/ui/vec_resize_to_zero.fixed
index b4c2d8209e76..260943f655e3 100644
--- a/src/tools/clippy/tests/ui/vec_resize_to_zero.fixed
+++ b/src/tools/clippy/tests/ui/vec_resize_to_zero.fixed
@@ -5,7 +5,7 @@ fn main() {
 
     // applicable here
     v.clear();
-    //~^ ERROR: emptying a vector with `resize`
+    //~^ vec_resize_to_zero
 
     // not applicable
     v.resize(2, 5);
diff --git a/src/tools/clippy/tests/ui/vec_resize_to_zero.rs b/src/tools/clippy/tests/ui/vec_resize_to_zero.rs
index 5b11c940f21a..d6054715143c 100644
--- a/src/tools/clippy/tests/ui/vec_resize_to_zero.rs
+++ b/src/tools/clippy/tests/ui/vec_resize_to_zero.rs
@@ -5,7 +5,7 @@ fn main() {
 
     // applicable here
     v.resize(0, 5);
-    //~^ ERROR: emptying a vector with `resize`
+    //~^ vec_resize_to_zero
 
     // not applicable
     v.resize(2, 5);
diff --git a/src/tools/clippy/tests/ui/verbose_file_reads.rs b/src/tools/clippy/tests/ui/verbose_file_reads.rs
index 9dd4f4e1d9be..374cd39df947 100644
--- a/src/tools/clippy/tests/ui/verbose_file_reads.rs
+++ b/src/tools/clippy/tests/ui/verbose_file_reads.rs
@@ -21,10 +21,12 @@ fn main() -> std::io::Result<()> {
     let mut f = File::open(path)?;
     let mut buffer = Vec::new();
     f.read_to_end(&mut buffer)?;
-    //~^ ERROR: use of `File::read_to_end`
+    //~^ verbose_file_reads
+
     // ...and this
     let mut string_buffer = String::new();
     f.read_to_string(&mut string_buffer)?;
-    //~^ ERROR: use of `File::read_to_string`
+    //~^ verbose_file_reads
+
     Ok(())
 }
diff --git a/src/tools/clippy/tests/ui/verbose_file_reads.stderr b/src/tools/clippy/tests/ui/verbose_file_reads.stderr
index e85068fc7a9c..9e6f6788562f 100644
--- a/src/tools/clippy/tests/ui/verbose_file_reads.stderr
+++ b/src/tools/clippy/tests/ui/verbose_file_reads.stderr
@@ -9,7 +9,7 @@ LL |     f.read_to_end(&mut buffer)?;
    = help: to override `-D warnings` add `#[allow(clippy::verbose_file_reads)]`
 
 error: use of `File::read_to_string`
-  --> tests/ui/verbose_file_reads.rs:27:5
+  --> tests/ui/verbose_file_reads.rs:28:5
    |
 LL |     f.read_to_string(&mut string_buffer)?;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/waker_clone_wake.fixed b/src/tools/clippy/tests/ui/waker_clone_wake.fixed
index 9c02b9a90fdd..d7b5000a5d50 100644
--- a/src/tools/clippy/tests/ui/waker_clone_wake.fixed
+++ b/src/tools/clippy/tests/ui/waker_clone_wake.fixed
@@ -13,8 +13,10 @@ macro_rules! mac {
 
 pub fn wake(cx: &mut std::task::Context) {
     cx.waker().wake_by_ref();
+    //~^ waker_clone_wake
 
     mac!(cx).wake_by_ref();
+    //~^ waker_clone_wake
 }
 
 pub fn no_lint(cx: &mut std::task::Context, c: &Custom) {
diff --git a/src/tools/clippy/tests/ui/waker_clone_wake.rs b/src/tools/clippy/tests/ui/waker_clone_wake.rs
index edc3bbd8fc08..27fa922d1112 100644
--- a/src/tools/clippy/tests/ui/waker_clone_wake.rs
+++ b/src/tools/clippy/tests/ui/waker_clone_wake.rs
@@ -13,8 +13,10 @@ macro_rules! mac {
 
 pub fn wake(cx: &mut std::task::Context) {
     cx.waker().clone().wake();
+    //~^ waker_clone_wake
 
     mac!(cx).clone().wake();
+    //~^ waker_clone_wake
 }
 
 pub fn no_lint(cx: &mut std::task::Context, c: &Custom) {
diff --git a/src/tools/clippy/tests/ui/waker_clone_wake.stderr b/src/tools/clippy/tests/ui/waker_clone_wake.stderr
index bf2c02a76c9b..9eb167d13107 100644
--- a/src/tools/clippy/tests/ui/waker_clone_wake.stderr
+++ b/src/tools/clippy/tests/ui/waker_clone_wake.stderr
@@ -8,7 +8,7 @@ LL |     cx.waker().clone().wake();
    = help: to override `-D warnings` add `#[allow(clippy::waker_clone_wake)]`
 
 error: cloning a `Waker` only to wake it
-  --> tests/ui/waker_clone_wake.rs:17:5
+  --> tests/ui/waker_clone_wake.rs:18:5
    |
 LL |     mac!(cx).clone().wake();
    |     ^^^^^^^^^^^^^^^^^^^^^^^ help: replace with: `mac!(cx).wake_by_ref()`
diff --git a/src/tools/clippy/tests/ui/while_float.rs b/src/tools/clippy/tests/ui/while_float.rs
index a3b0618948e6..727b954ffcca 100644
--- a/src/tools/clippy/tests/ui/while_float.rs
+++ b/src/tools/clippy/tests/ui/while_float.rs
@@ -2,9 +2,11 @@
 fn main() {
     let mut x = 0.0_f32;
     while x < 42.0_f32 {
+        //~^ while_float
         x += 0.5;
     }
     while x < 42.0 {
+        //~^ while_float
         x += 1.0;
     }
     let mut x = 0;
diff --git a/src/tools/clippy/tests/ui/while_float.stderr b/src/tools/clippy/tests/ui/while_float.stderr
index b8e934b97c6c..e83e1b925c16 100644
--- a/src/tools/clippy/tests/ui/while_float.stderr
+++ b/src/tools/clippy/tests/ui/while_float.stderr
@@ -11,7 +11,7 @@ LL | #[deny(clippy::while_float)]
    |        ^^^^^^^^^^^^^^^^^^^
 
 error: while condition comparing floats
-  --> tests/ui/while_float.rs:7:11
+  --> tests/ui/while_float.rs:8:11
    |
 LL |     while x < 42.0 {
    |           ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/while_let_loop.rs b/src/tools/clippy/tests/ui/while_let_loop.rs
index fa5325bebffa..d591ab984cfa 100644
--- a/src/tools/clippy/tests/ui/while_let_loop.rs
+++ b/src/tools/clippy/tests/ui/while_let_loop.rs
@@ -4,8 +4,8 @@
 fn main() {
     let y = Some(true);
     loop {
-        //~^ ERROR: this loop could be written as a `while let` loop
-        //~| NOTE: `-D clippy::while-let-loop` implied by `-D warnings`
+        //~^ while_let_loop
+
         if let Some(_x) = y {
             let _v = 1;
         } else {
@@ -23,7 +23,8 @@ fn main() {
     }
 
     loop {
-        //~^ ERROR: this loop could be written as a `while let` loop
+        //~^ while_let_loop
+
         match y {
             Some(_x) => true,
             None => break,
@@ -31,7 +32,8 @@ fn main() {
     }
 
     loop {
-        //~^ ERROR: this loop could be written as a `while let` loop
+        //~^ while_let_loop
+
         let x = match y {
             Some(x) => x,
             None => break,
@@ -41,7 +43,8 @@ fn main() {
     }
 
     loop {
-        //~^ ERROR: this loop could be written as a `while let` loop
+        //~^ while_let_loop
+
         let x = match y {
             Some(x) => x,
             None => break,
@@ -72,7 +75,8 @@ fn main() {
 
     // #675, this used to have a wrong suggestion
     loop {
-        //~^ ERROR: this loop could be written as a `while let` loop
+        //~^ while_let_loop
+
         let (e, l) = match "".split_whitespace().next() {
             Some(word) => (word.is_empty(), word.len()),
             None => break,
diff --git a/src/tools/clippy/tests/ui/while_let_loop.stderr b/src/tools/clippy/tests/ui/while_let_loop.stderr
index 10c2311d82f7..bd482857e675 100644
--- a/src/tools/clippy/tests/ui/while_let_loop.stderr
+++ b/src/tools/clippy/tests/ui/while_let_loop.stderr
@@ -17,43 +17,43 @@ error: this loop could be written as a `while let` loop
    |
 LL | /     loop {
 LL | |
+LL | |
 LL | |         match y {
-LL | |             Some(_x) => true,
-LL | |             None => break,
+...  |
 LL | |         };
 LL | |     }
    | |_____^ help: try: `while let Some(_x) = y { .. }`
 
 error: this loop could be written as a `while let` loop
-  --> tests/ui/while_let_loop.rs:33:5
+  --> tests/ui/while_let_loop.rs:34:5
    |
 LL | /     loop {
 LL | |
+LL | |
 LL | |         let x = match y {
-LL | |             Some(x) => x,
 ...  |
 LL | |         let _str = "foo";
 LL | |     }
    | |_____^ help: try: `while let Some(x) = y { .. }`
 
 error: this loop could be written as a `while let` loop
-  --> tests/ui/while_let_loop.rs:43:5
+  --> tests/ui/while_let_loop.rs:45:5
    |
 LL | /     loop {
 LL | |
+LL | |
 LL | |         let x = match y {
-LL | |             Some(x) => x,
 ...  |
 LL | |     }
    | |_____^ help: try: `while let Some(x) = y { .. }`
 
 error: this loop could be written as a `while let` loop
-  --> tests/ui/while_let_loop.rs:74:5
+  --> tests/ui/while_let_loop.rs:77:5
    |
 LL | /     loop {
 LL | |
+LL | |
 LL | |         let (e, l) = match "".split_whitespace().next() {
-LL | |             Some(word) => (word.is_empty(), word.len()),
 ...  |
 LL | |         let _ = (e, l);
 LL | |     }
diff --git a/src/tools/clippy/tests/ui/while_let_on_iterator.fixed b/src/tools/clippy/tests/ui/while_let_on_iterator.fixed
index b8087c6e000f..f9ccefab5898 100644
--- a/src/tools/clippy/tests/ui/while_let_on_iterator.fixed
+++ b/src/tools/clippy/tests/ui/while_let_on_iterator.fixed
@@ -13,16 +13,19 @@
 fn base() {
     let mut iter = 1..20;
     for x in iter {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 
     let mut iter = 1..20;
     for x in iter {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 
     let mut iter = 1..20;
     for _ in iter {}
+    //~^ while_let_on_iterator
 
     let mut iter = 1..20;
     while let None = iter.next() {} // this is fine (if nonsensical)
@@ -99,6 +102,7 @@ fn refutable2() {
 
         let mut it = v.windows(2);
         for [..] in it {}
+        //~^ while_let_on_iterator
 
         let v = vec![[1], [2], [3]];
         let mut it = v.iter();
@@ -106,6 +110,7 @@ fn refutable2() {
 
         let mut it = v.iter();
         for [_x] in it {}
+        //~^ while_let_on_iterator
     }
 
     // binding
@@ -119,6 +124,7 @@ fn refutable2() {
         let v = vec![[1], [2], [3]];
         let mut it = v.iter();
         for x @ [_] in it {
+            //~^ while_let_on_iterator
             println!("{:?}", x);
         }
     }
@@ -139,6 +145,7 @@ fn nested_loops() {
     loop {
         let mut y = a.iter();
         for _ in y {
+            //~^ while_let_on_iterator
             // use a for loop here
         }
     }
@@ -196,6 +203,7 @@ fn issue6491() {
     let mut it = 1..40;
     while let Some(n) = it.next() {
         for m in it.by_ref() {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -207,8 +215,10 @@ fn issue6491() {
     // This is fine, inner loop uses a new iterator.
     let mut it = 1..40;
     for n in it {
+        //~^ while_let_on_iterator
         let mut it = 1..40;
         for m in it {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -218,6 +228,7 @@ fn issue6491() {
         // Weird binding shouldn't change anything.
         let (mut it, _) = (1..40, 0);
         for m in it {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -227,6 +238,7 @@ fn issue6491() {
         // Used after the loop, needs &mut.
         let mut it = 1..40;
         for m in it.by_ref() {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -244,6 +256,7 @@ fn issue6231() {
     let mut opt = Some(0);
     while let Some(n) = opt.take().or_else(|| it.next()) {
         for m in it.by_ref() {
+            //~^ while_let_on_iterator
             if n % 10 == 0 {
                 break;
             }
@@ -259,6 +272,7 @@ fn issue1924() {
         fn f(&mut self) -> Option<u32> {
             // Used as a field.
             for i in self.0.by_ref() {
+                //~^ while_let_on_iterator
                 if !(3..8).contains(&i) {
                     return Some(i);
                 }
@@ -291,6 +305,7 @@ fn issue1924() {
             }
             // This one is fine, a different field is borrowed
             for i in self.0.0.0.by_ref() {
+                //~^ while_let_on_iterator
                 if i == 1 {
                     return self.0.1.take();
                 } else {
@@ -320,6 +335,7 @@ fn issue1924() {
     // Needs &mut, field of the iterator is accessed after the loop
     let mut it = S2(1..40, 0);
     for n in it.by_ref() {
+        //~^ while_let_on_iterator
         if n == 0 {
             break;
         }
@@ -332,6 +348,7 @@ fn issue7249() {
     let mut x = || {
         // Needs &mut, the closure can be called multiple times
         for x in it.by_ref() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -346,6 +363,7 @@ fn issue7510() {
     let it = &mut it;
     // Needs to reborrow `it` as the binding isn't mutable
     for x in it.by_ref() {
+        //~^ while_let_on_iterator
         if x % 2 == 0 {
             break;
         }
@@ -357,6 +375,7 @@ fn issue7510() {
     let it = S(&mut it);
     // Needs to reborrow `it.0` as the binding isn't mutable
     for x in it.0.by_ref() {
+        //~^ while_let_on_iterator
         if x % 2 == 0 {
             break;
         }
@@ -392,6 +411,7 @@ fn custom_deref() {
 
     let mut s = S2(S1 { x: 0..10 });
     for x in s.x.by_ref() {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 }
@@ -399,6 +419,7 @@ fn custom_deref() {
 fn issue_8113() {
     let mut x = [0..10];
     for x in x[0].by_ref() {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 }
@@ -407,6 +428,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     (|| {
         for x in it.by_ref() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -417,6 +439,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     f(|| {
         for x in it {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -427,6 +450,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     f2(|| {
         for x in it.by_ref() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -437,6 +461,7 @@ fn fn_once_closure() {
     f3(|| {
         let mut it = 0..10;
         for x in it {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -449,6 +474,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     f4(|| {
         for x in it {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -459,6 +485,7 @@ fn fn_once_closure() {
 fn issue13123() {
     let mut it = 0..20;
     'label: for n in it {
+        //~^ while_let_on_iterator
         if n % 25 == 0 {
             break 'label;
         }
@@ -468,6 +495,7 @@ fn issue13123() {
 fn main() {
     let mut it = 0..20;
     for _ in it {
+        //~^ while_let_on_iterator
         println!("test");
     }
 }
diff --git a/src/tools/clippy/tests/ui/while_let_on_iterator.rs b/src/tools/clippy/tests/ui/while_let_on_iterator.rs
index 8e02f59b5126..f957f2e5a523 100644
--- a/src/tools/clippy/tests/ui/while_let_on_iterator.rs
+++ b/src/tools/clippy/tests/ui/while_let_on_iterator.rs
@@ -13,16 +13,19 @@
 fn base() {
     let mut iter = 1..20;
     while let Option::Some(x) = iter.next() {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 
     let mut iter = 1..20;
     while let Some(x) = iter.next() {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 
     let mut iter = 1..20;
     while let Some(_) = iter.next() {}
+    //~^ while_let_on_iterator
 
     let mut iter = 1..20;
     while let None = iter.next() {} // this is fine (if nonsensical)
@@ -99,6 +102,7 @@ fn refutable2() {
 
         let mut it = v.windows(2);
         while let Some([..]) = it.next() {}
+        //~^ while_let_on_iterator
 
         let v = vec![[1], [2], [3]];
         let mut it = v.iter();
@@ -106,6 +110,7 @@ fn refutable2() {
 
         let mut it = v.iter();
         while let Some([_x]) = it.next() {}
+        //~^ while_let_on_iterator
     }
 
     // binding
@@ -119,6 +124,7 @@ fn refutable2() {
         let v = vec![[1], [2], [3]];
         let mut it = v.iter();
         while let Some(x @ [_]) = it.next() {
+            //~^ while_let_on_iterator
             println!("{:?}", x);
         }
     }
@@ -139,6 +145,7 @@ fn nested_loops() {
     loop {
         let mut y = a.iter();
         while let Some(_) = y.next() {
+            //~^ while_let_on_iterator
             // use a for loop here
         }
     }
@@ -196,6 +203,7 @@ fn issue6491() {
     let mut it = 1..40;
     while let Some(n) = it.next() {
         while let Some(m) = it.next() {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -207,8 +215,10 @@ fn issue6491() {
     // This is fine, inner loop uses a new iterator.
     let mut it = 1..40;
     while let Some(n) = it.next() {
+        //~^ while_let_on_iterator
         let mut it = 1..40;
         while let Some(m) = it.next() {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -218,6 +228,7 @@ fn issue6491() {
         // Weird binding shouldn't change anything.
         let (mut it, _) = (1..40, 0);
         while let Some(m) = it.next() {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -227,6 +238,7 @@ fn issue6491() {
         // Used after the loop, needs &mut.
         let mut it = 1..40;
         while let Some(m) = it.next() {
+            //~^ while_let_on_iterator
             if m % 10 == 0 {
                 break;
             }
@@ -244,6 +256,7 @@ fn issue6231() {
     let mut opt = Some(0);
     while let Some(n) = opt.take().or_else(|| it.next()) {
         while let Some(m) = it.next() {
+            //~^ while_let_on_iterator
             if n % 10 == 0 {
                 break;
             }
@@ -259,6 +272,7 @@ fn issue1924() {
         fn f(&mut self) -> Option<u32> {
             // Used as a field.
             while let Some(i) = self.0.next() {
+                //~^ while_let_on_iterator
                 if !(3..8).contains(&i) {
                     return Some(i);
                 }
@@ -291,6 +305,7 @@ fn issue1924() {
             }
             // This one is fine, a different field is borrowed
             while let Some(i) = self.0.0.0.next() {
+                //~^ while_let_on_iterator
                 if i == 1 {
                     return self.0.1.take();
                 } else {
@@ -320,6 +335,7 @@ fn issue1924() {
     // Needs &mut, field of the iterator is accessed after the loop
     let mut it = S2(1..40, 0);
     while let Some(n) = it.next() {
+        //~^ while_let_on_iterator
         if n == 0 {
             break;
         }
@@ -332,6 +348,7 @@ fn issue7249() {
     let mut x = || {
         // Needs &mut, the closure can be called multiple times
         while let Some(x) = it.next() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -346,6 +363,7 @@ fn issue7510() {
     let it = &mut it;
     // Needs to reborrow `it` as the binding isn't mutable
     while let Some(x) = it.next() {
+        //~^ while_let_on_iterator
         if x % 2 == 0 {
             break;
         }
@@ -357,6 +375,7 @@ fn issue7510() {
     let it = S(&mut it);
     // Needs to reborrow `it.0` as the binding isn't mutable
     while let Some(x) = it.0.next() {
+        //~^ while_let_on_iterator
         if x % 2 == 0 {
             break;
         }
@@ -392,6 +411,7 @@ fn custom_deref() {
 
     let mut s = S2(S1 { x: 0..10 });
     while let Some(x) = s.x.next() {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 }
@@ -399,6 +419,7 @@ fn custom_deref() {
 fn issue_8113() {
     let mut x = [0..10];
     while let Some(x) = x[0].next() {
+        //~^ while_let_on_iterator
         println!("{}", x);
     }
 }
@@ -407,6 +428,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     (|| {
         while let Some(x) = it.next() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -417,6 +439,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     f(|| {
         while let Some(x) = it.next() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -427,6 +450,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     f2(|| {
         while let Some(x) = it.next() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -437,6 +461,7 @@ fn fn_once_closure() {
     f3(|| {
         let mut it = 0..10;
         while let Some(x) = it.next() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -449,6 +474,7 @@ fn fn_once_closure() {
     let mut it = 0..10;
     f4(|| {
         while let Some(x) = it.next() {
+            //~^ while_let_on_iterator
             if x % 2 == 0 {
                 break;
             }
@@ -459,6 +485,7 @@ fn fn_once_closure() {
 fn issue13123() {
     let mut it = 0..20;
     'label: while let Some(n) = it.next() {
+        //~^ while_let_on_iterator
         if n % 25 == 0 {
             break 'label;
         }
@@ -468,6 +495,7 @@ fn issue13123() {
 fn main() {
     let mut it = 0..20;
     while let Some(..) = it.next() {
+        //~^ while_let_on_iterator
         println!("test");
     }
 }
diff --git a/src/tools/clippy/tests/ui/while_let_on_iterator.stderr b/src/tools/clippy/tests/ui/while_let_on_iterator.stderr
index d96b26acf345..50f20227b90f 100644
--- a/src/tools/clippy/tests/ui/while_let_on_iterator.stderr
+++ b/src/tools/clippy/tests/ui/while_let_on_iterator.stderr
@@ -8,59 +8,53 @@ LL |     while let Option::Some(x) = iter.next() {
    = help: to override `-D warnings` add `#[allow(clippy::while_let_on_iterator)]`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:20:5
+  --> tests/ui/while_let_on_iterator.rs:21:5
    |
 LL |     while let Some(x) = iter.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in iter`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:25:5
+  --> tests/ui/while_let_on_iterator.rs:27:5
    |
 LL |     while let Some(_) = iter.next() {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in iter`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:101:9
+  --> tests/ui/while_let_on_iterator.rs:104:9
    |
 LL |         while let Some([..]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [..] in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:108:9
+  --> tests/ui/while_let_on_iterator.rs:112:9
    |
 LL |         while let Some([_x]) = it.next() {}
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for [_x] in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:121:9
+  --> tests/ui/while_let_on_iterator.rs:126:9
    |
 LL |         while let Some(x @ [_]) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x @ [_] in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:141:9
+  --> tests/ui/while_let_on_iterator.rs:147:9
    |
 LL |         while let Some(_) = y.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in y`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:198:9
+  --> tests/ui/while_let_on_iterator.rs:205:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:209:5
+  --> tests/ui/while_let_on_iterator.rs:217:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it`
 
-error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:211:9
-   |
-LL |         while let Some(m) = it.next() {
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
-
 error: this loop could be written as a `for` loop
   --> tests/ui/while_let_on_iterator.rs:220:9
    |
@@ -68,103 +62,109 @@ LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:229:9
+  --> tests/ui/while_let_on_iterator.rs:230:9
+   |
+LL |         while let Some(m) = it.next() {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it`
+
+error: this loop could be written as a `for` loop
+  --> tests/ui/while_let_on_iterator.rs:240:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:246:9
+  --> tests/ui/while_let_on_iterator.rs:258:9
    |
 LL |         while let Some(m) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for m in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:261:13
+  --> tests/ui/while_let_on_iterator.rs:274:13
    |
 LL |             while let Some(i) = self.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:293:13
+  --> tests/ui/while_let_on_iterator.rs:307:13
    |
 LL |             while let Some(i) = self.0.0.0.next() {
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for i in self.0.0.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:322:5
+  --> tests/ui/while_let_on_iterator.rs:337:5
    |
 LL |     while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for n in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:334:9
+  --> tests/ui/while_let_on_iterator.rs:350:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:348:5
+  --> tests/ui/while_let_on_iterator.rs:365:5
    |
 LL |     while let Some(x) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:359:5
+  --> tests/ui/while_let_on_iterator.rs:377:5
    |
 LL |     while let Some(x) = it.0.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.0.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:394:5
+  --> tests/ui/while_let_on_iterator.rs:413:5
    |
 LL |     while let Some(x) = s.x.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in s.x.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:401:5
+  --> tests/ui/while_let_on_iterator.rs:421:5
    |
 LL |     while let Some(x) = x[0].next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in x[0].by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:409:9
+  --> tests/ui/while_let_on_iterator.rs:430:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:419:9
+  --> tests/ui/while_let_on_iterator.rs:441:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:429:9
+  --> tests/ui/while_let_on_iterator.rs:452:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it.by_ref()`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:439:9
+  --> tests/ui/while_let_on_iterator.rs:463:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:451:9
+  --> tests/ui/while_let_on_iterator.rs:476:9
    |
 LL |         while let Some(x) = it.next() {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for x in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:461:5
+  --> tests/ui/while_let_on_iterator.rs:487:5
    |
 LL |     'label: while let Some(n) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `'label: for n in it`
 
 error: this loop could be written as a `for` loop
-  --> tests/ui/while_let_on_iterator.rs:470:5
+  --> tests/ui/while_let_on_iterator.rs:497:5
    |
 LL |     while let Some(..) = it.next() {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `for _ in it`
diff --git a/src/tools/clippy/tests/ui/wild_in_or_pats.rs b/src/tools/clippy/tests/ui/wild_in_or_pats.rs
index bc8a1dbee71d..ced13cc50c5d 100644
--- a/src/tools/clippy/tests/ui/wild_in_or_pats.rs
+++ b/src/tools/clippy/tests/ui/wild_in_or_pats.rs
@@ -6,7 +6,8 @@ fn main() {
             dbg!("matched a");
         },
         "bar" | _ => {
-            //~^ ERROR: wildcard pattern covers any other pattern as it will match anyway
+            //~^ wildcard_in_or_patterns
+
             dbg!("matched (bar or) wild");
         },
     };
@@ -15,7 +16,8 @@ fn main() {
             dbg!("matched a");
         },
         "bar" | "bar2" | _ => {
-            //~^ ERROR: wildcard pattern covers any other pattern as it will match anyway
+            //~^ wildcard_in_or_patterns
+
             dbg!("matched (bar or bar2 or) wild");
         },
     };
@@ -24,7 +26,8 @@ fn main() {
             dbg!("matched a");
         },
         _ | "bar" | _ => {
-            //~^ ERROR: wildcard pattern covers any other pattern as it will match anyway
+            //~^ wildcard_in_or_patterns
+
             dbg!("matched (bar or) wild");
         },
     };
@@ -33,7 +36,8 @@ fn main() {
             dbg!("matched a");
         },
         _ | "bar" => {
-            //~^ ERROR: wildcard pattern covers any other pattern as it will match anyway
+            //~^ wildcard_in_or_patterns
+
             dbg!("matched (bar or) wild");
         },
     };
@@ -67,6 +71,7 @@ fn main() {
             dbg!("Change the color");
         },
         ExhaustiveEnum::Quit | _ => {
+            //~^ wildcard_in_or_patterns
             dbg!("Quit or other");
         },
     };
@@ -102,6 +107,7 @@ fn main() {
             dbg!("On the y axis at {y}");
         },
         ExhaustiveStruct { x: 1, y: 1 } | _ => {
+            //~^ wildcard_in_or_patterns
             dbg!("On neither axis: ({x}, {y})");
         },
     }
diff --git a/src/tools/clippy/tests/ui/wild_in_or_pats.stderr b/src/tools/clippy/tests/ui/wild_in_or_pats.stderr
index 5e409d6dfa6d..09b2b533cd3e 100644
--- a/src/tools/clippy/tests/ui/wild_in_or_pats.stderr
+++ b/src/tools/clippy/tests/ui/wild_in_or_pats.stderr
@@ -9,7 +9,7 @@ LL |         "bar" | _ => {
    = help: to override `-D warnings` add `#[allow(clippy::wildcard_in_or_patterns)]`
 
 error: wildcard pattern covers any other pattern as it will match anyway
-  --> tests/ui/wild_in_or_pats.rs:17:9
+  --> tests/ui/wild_in_or_pats.rs:18:9
    |
 LL |         "bar" | "bar2" | _ => {
    |         ^^^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |         "bar" | "bar2" | _ => {
    = help: consider handling `_` separately
 
 error: wildcard pattern covers any other pattern as it will match anyway
-  --> tests/ui/wild_in_or_pats.rs:26:9
+  --> tests/ui/wild_in_or_pats.rs:28:9
    |
 LL |         _ | "bar" | _ => {
    |         ^^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |         _ | "bar" | _ => {
    = help: consider handling `_` separately
 
 error: wildcard pattern covers any other pattern as it will match anyway
-  --> tests/ui/wild_in_or_pats.rs:35:9
+  --> tests/ui/wild_in_or_pats.rs:38:9
    |
 LL |         _ | "bar" => {
    |         ^^^^^^^^^
@@ -33,7 +33,7 @@ LL |         _ | "bar" => {
    = help: consider handling `_` separately
 
 error: wildcard pattern covers any other pattern as it will match anyway
-  --> tests/ui/wild_in_or_pats.rs:69:9
+  --> tests/ui/wild_in_or_pats.rs:73:9
    |
 LL |         ExhaustiveEnum::Quit | _ => {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,7 +41,7 @@ LL |         ExhaustiveEnum::Quit | _ => {
    = help: consider handling `_` separately
 
 error: wildcard pattern covers any other pattern as it will match anyway
-  --> tests/ui/wild_in_or_pats.rs:104:9
+  --> tests/ui/wild_in_or_pats.rs:109:9
    |
 LL |         ExhaustiveStruct { x: 1, y: 1 } | _ => {
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/wildcard_enum_match_arm.fixed b/src/tools/clippy/tests/ui/wildcard_enum_match_arm.fixed
index 1089415733a9..141ff6eb2ac7 100644
--- a/src/tools/clippy/tests/ui/wildcard_enum_match_arm.fixed
+++ b/src/tools/clippy/tests/ui/wildcard_enum_match_arm.fixed
@@ -37,14 +37,17 @@ fn main() {
     match color {
         Color::Red => println!("Red"),
         Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan => eprintln!("Not red"),
+        //~^ wildcard_enum_match_arm
     };
     match color {
         Color::Red => println!("Red"),
         _not_red @ Color::Green | _not_red @ Color::Blue | _not_red @ Color::Rgb(..) | _not_red @ Color::Cyan => eprintln!("Not red"),
+        //~^ wildcard_enum_match_arm
     };
     let _str = match color {
         Color::Red => "Red".to_owned(),
         not_red @ Color::Green | not_red @ Color::Blue | not_red @ Color::Rgb(..) | not_red @ Color::Cyan => format!("{:?}", not_red),
+        //~^ wildcard_enum_match_arm
     };
     match color {
         Color::Red => {},
@@ -61,6 +64,7 @@ fn main() {
     match color {
         Color::Rgb(r, _, _) if r > 0 => "Some red",
         Color::Red | Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan => "No red",
+        //~^ wildcard_enum_match_arm
     };
     match color {
         Color::Red | Color::Green | Color::Blue | Color::Cyan => {},
@@ -78,6 +82,7 @@ fn main() {
     match error_kind {
         ErrorKind::NotFound => {},
         ErrorKind::PermissionDenied | _ => {},
+        //~^ wildcard_enum_match_arm
     }
     match error_kind {
         ErrorKind::NotFound => {},
@@ -96,6 +101,7 @@ fn main() {
         match Enum::A {
             Enum::A => (),
             Enum::B | Enum::__Private => (),
+            //~^ wildcard_enum_match_arm
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/wildcard_enum_match_arm.rs b/src/tools/clippy/tests/ui/wildcard_enum_match_arm.rs
index d9285c56f3ef..a13684e9100b 100644
--- a/src/tools/clippy/tests/ui/wildcard_enum_match_arm.rs
+++ b/src/tools/clippy/tests/ui/wildcard_enum_match_arm.rs
@@ -37,14 +37,17 @@ fn main() {
     match color {
         Color::Red => println!("Red"),
         _ => eprintln!("Not red"),
+        //~^ wildcard_enum_match_arm
     };
     match color {
         Color::Red => println!("Red"),
         _not_red => eprintln!("Not red"),
+        //~^ wildcard_enum_match_arm
     };
     let _str = match color {
         Color::Red => "Red".to_owned(),
         not_red => format!("{:?}", not_red),
+        //~^ wildcard_enum_match_arm
     };
     match color {
         Color::Red => {},
@@ -61,6 +64,7 @@ fn main() {
     match color {
         Color::Rgb(r, _, _) if r > 0 => "Some red",
         _ => "No red",
+        //~^ wildcard_enum_match_arm
     };
     match color {
         Color::Red | Color::Green | Color::Blue | Color::Cyan => {},
@@ -78,6 +82,7 @@ fn main() {
     match error_kind {
         ErrorKind::NotFound => {},
         _ => {},
+        //~^ wildcard_enum_match_arm
     }
     match error_kind {
         ErrorKind::NotFound => {},
@@ -96,6 +101,7 @@ fn main() {
         match Enum::A {
             Enum::A => (),
             _ => (),
+            //~^ wildcard_enum_match_arm
         }
     }
 }
diff --git a/src/tools/clippy/tests/ui/wildcard_enum_match_arm.stderr b/src/tools/clippy/tests/ui/wildcard_enum_match_arm.stderr
index 70ac768aaacd..088c6b7b2841 100644
--- a/src/tools/clippy/tests/ui/wildcard_enum_match_arm.stderr
+++ b/src/tools/clippy/tests/ui/wildcard_enum_match_arm.stderr
@@ -11,31 +11,31 @@ LL | #![deny(clippy::wildcard_enum_match_arm)]
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: wildcard match will also match any future added variants
-  --> tests/ui/wildcard_enum_match_arm.rs:43:9
+  --> tests/ui/wildcard_enum_match_arm.rs:44:9
    |
 LL |         _not_red => eprintln!("Not red"),
    |         ^^^^^^^^ help: try: `_not_red @ Color::Green | _not_red @ Color::Blue | _not_red @ Color::Rgb(..) | _not_red @ Color::Cyan`
 
 error: wildcard match will also match any future added variants
-  --> tests/ui/wildcard_enum_match_arm.rs:47:9
+  --> tests/ui/wildcard_enum_match_arm.rs:49:9
    |
 LL |         not_red => format!("{:?}", not_red),
    |         ^^^^^^^ help: try: `not_red @ Color::Green | not_red @ Color::Blue | not_red @ Color::Rgb(..) | not_red @ Color::Cyan`
 
 error: wildcard match will also match any future added variants
-  --> tests/ui/wildcard_enum_match_arm.rs:63:9
+  --> tests/ui/wildcard_enum_match_arm.rs:66:9
    |
 LL |         _ => "No red",
    |         ^ help: try: `Color::Red | Color::Green | Color::Blue | Color::Rgb(..) | Color::Cyan`
 
 error: wildcard matches known variants and will also match future added variants
-  --> tests/ui/wildcard_enum_match_arm.rs:80:9
+  --> tests/ui/wildcard_enum_match_arm.rs:84:9
    |
 LL |         _ => {},
    |         ^ help: try: `ErrorKind::PermissionDenied | _`
 
 error: wildcard match will also match any future added variants
-  --> tests/ui/wildcard_enum_match_arm.rs:98:13
+  --> tests/ui/wildcard_enum_match_arm.rs:103:13
    |
 LL |             _ => (),
    |             ^ help: try: `Enum::B | Enum::__Private`
diff --git a/src/tools/clippy/tests/ui/wildcard_imports.fixed b/src/tools/clippy/tests/ui/wildcard_imports.fixed
index 46890ee9213f..a26b4a34190c 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports.fixed
+++ b/src/tools/clippy/tests/ui/wildcard_imports.fixed
@@ -13,15 +13,21 @@
 extern crate wildcard_imports_helper;
 
 use crate::fn_mod::foo;
+//~^ wildcard_imports
 use crate::mod_mod::inner_mod;
+//~^ wildcard_imports
 use crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod};
+//~^ wildcard_imports
 #[macro_use]
 use crate::struct_mod::{A, inner_struct_mod};
+//~^ wildcard_imports
 
 #[allow(unused_imports)]
 use wildcard_imports_helper::inner::inner_for_self_import;
 use wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar;
+//~^ wildcard_imports
 use wildcard_imports_helper::{ExternA, extern_foo};
+//~^ wildcard_imports
 
 use std::io::prelude::*;
 use wildcard_imports_helper::extern_prelude::v1::*;
@@ -92,6 +98,7 @@ mod underscore_mod {
 
     fn does_lint() {
         use self::exports_underscore_ish::{_Deref, dummy};
+        //~^ wildcard_imports
         let _ = (&0).deref();
         dummy();
     }
@@ -123,13 +130,16 @@ mod in_fn_test {
 
     fn test_intern() {
         use crate::fn_mod::foo;
+        //~^ wildcard_imports
 
         foo();
     }
 
     fn test_extern() {
         use wildcard_imports_helper::inner::inner_for_self_import::{self, inner_extern_foo};
+        //~^ wildcard_imports
         use wildcard_imports_helper::{ExternA, extern_foo};
+        //~^ wildcard_imports
 
         inner_for_self_import::inner_extern_foo();
         inner_extern_foo();
@@ -142,6 +152,8 @@ mod in_fn_test {
     fn test_inner_nested() {
         #[rustfmt::skip]
         use self::{inner::inner_foo, inner2::inner_bar};
+        //~^ wildcard_imports
+        //~| wildcard_imports
 
         inner_foo();
         inner_bar();
@@ -149,6 +161,7 @@ mod in_fn_test {
 
     fn test_extern_reexported() {
         use wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported};
+        //~^ wildcard_imports
 
         extern_exported();
         let _ = ExternExportedStruct;
@@ -178,6 +191,7 @@ mod in_fn_test {
 
 fn test_reexported() {
     use crate::in_fn_test::{ExportedEnum, ExportedStruct, exported};
+    //~^ wildcard_imports
 
     exported();
     let _ = ExportedStruct;
@@ -187,6 +201,7 @@ fn test_reexported() {
 #[rustfmt::skip]
 fn test_weird_formatting() {
     use crate:: in_fn_test::exported;
+    //~^ wildcard_imports
     use crate:: fn_mod::foo;
 
     exported();
@@ -198,6 +213,7 @@ mod super_imports {
 
     mod should_be_replaced {
         use super::foofoo;
+        //~^ wildcard_imports
 
         fn with_super() {
             let _ = foofoo();
@@ -236,6 +252,7 @@ mod super_imports {
         fn insidefoo() {}
         mod inner {
             use super::insidefoo;
+            //~^ wildcard_imports
             fn with_super() {
                 let _ = insidefoo();
             }
@@ -244,6 +261,7 @@ mod super_imports {
 
     mod use_explicit_should_be_replaced {
         use crate::super_imports::foofoo;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
@@ -253,6 +271,7 @@ mod super_imports {
     mod use_double_super_should_be_replaced {
         mod inner {
             use super::super::foofoo;
+            //~^ wildcard_imports
 
             fn with_double_super() {
                 let _ = foofoo();
@@ -262,6 +281,7 @@ mod super_imports {
 
     mod use_super_explicit_should_be_replaced {
         use super::super::super_imports::foofoo;
+        //~^ wildcard_imports
 
         fn with_super_explicit() {
             let _ = foofoo();
@@ -270,6 +290,7 @@ mod super_imports {
 
     mod attestation_should_be_replaced {
         use super::foofoo;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
diff --git a/src/tools/clippy/tests/ui/wildcard_imports.rs b/src/tools/clippy/tests/ui/wildcard_imports.rs
index 1a5586cbb88d..2168f0a8918d 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports.rs
+++ b/src/tools/clippy/tests/ui/wildcard_imports.rs
@@ -13,15 +13,21 @@
 extern crate wildcard_imports_helper;
 
 use crate::fn_mod::*;
+//~^ wildcard_imports
 use crate::mod_mod::*;
+//~^ wildcard_imports
 use crate::multi_fn_mod::*;
+//~^ wildcard_imports
 #[macro_use]
 use crate::struct_mod::*;
+//~^ wildcard_imports
 
 #[allow(unused_imports)]
 use wildcard_imports_helper::inner::inner_for_self_import;
 use wildcard_imports_helper::inner::inner_for_self_import::*;
+//~^ wildcard_imports
 use wildcard_imports_helper::*;
+//~^ wildcard_imports
 
 use std::io::prelude::*;
 use wildcard_imports_helper::extern_prelude::v1::*;
@@ -92,6 +98,7 @@ mod underscore_mod {
 
     fn does_lint() {
         use self::exports_underscore_ish::*;
+        //~^ wildcard_imports
         let _ = (&0).deref();
         dummy();
     }
@@ -123,13 +130,16 @@ mod in_fn_test {
 
     fn test_intern() {
         use crate::fn_mod::*;
+        //~^ wildcard_imports
 
         foo();
     }
 
     fn test_extern() {
         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
+        //~^ wildcard_imports
         use wildcard_imports_helper::*;
+        //~^ wildcard_imports
 
         inner_for_self_import::inner_extern_foo();
         inner_extern_foo();
@@ -142,6 +152,8 @@ mod in_fn_test {
     fn test_inner_nested() {
         #[rustfmt::skip]
         use self::{inner::*, inner2::*};
+        //~^ wildcard_imports
+        //~| wildcard_imports
 
         inner_foo();
         inner_bar();
@@ -149,6 +161,7 @@ mod in_fn_test {
 
     fn test_extern_reexported() {
         use wildcard_imports_helper::*;
+        //~^ wildcard_imports
 
         extern_exported();
         let _ = ExternExportedStruct;
@@ -178,6 +191,7 @@ mod in_fn_test {
 
 fn test_reexported() {
     use crate::in_fn_test::*;
+    //~^ wildcard_imports
 
     exported();
     let _ = ExportedStruct;
@@ -187,7 +201,9 @@ fn test_reexported() {
 #[rustfmt::skip]
 fn test_weird_formatting() {
     use crate:: in_fn_test::  * ;
+    //~^ wildcard_imports
     use crate:: fn_mod::
+    //~^ wildcard_imports
         *;
 
     exported();
@@ -199,6 +215,7 @@ mod super_imports {
 
     mod should_be_replaced {
         use super::*;
+        //~^ wildcard_imports
 
         fn with_super() {
             let _ = foofoo();
@@ -237,6 +254,7 @@ mod super_imports {
         fn insidefoo() {}
         mod inner {
             use super::*;
+            //~^ wildcard_imports
             fn with_super() {
                 let _ = insidefoo();
             }
@@ -245,6 +263,7 @@ mod super_imports {
 
     mod use_explicit_should_be_replaced {
         use crate::super_imports::*;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
@@ -254,6 +273,7 @@ mod super_imports {
     mod use_double_super_should_be_replaced {
         mod inner {
             use super::super::*;
+            //~^ wildcard_imports
 
             fn with_double_super() {
                 let _ = foofoo();
@@ -263,6 +283,7 @@ mod super_imports {
 
     mod use_super_explicit_should_be_replaced {
         use super::super::super_imports::*;
+        //~^ wildcard_imports
 
         fn with_super_explicit() {
             let _ = foofoo();
@@ -271,6 +292,7 @@ mod super_imports {
 
     mod attestation_should_be_replaced {
         use super::*;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
diff --git a/src/tools/clippy/tests/ui/wildcard_imports.stderr b/src/tools/clippy/tests/ui/wildcard_imports.stderr
index 8e88f216394d..f774126102bc 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports.stderr
+++ b/src/tools/clippy/tests/ui/wildcard_imports.stderr
@@ -8,129 +8,130 @@ LL | use crate::fn_mod::*;
    = help: to override `-D warnings` add `#[allow(clippy::wildcard_imports)]`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:16:5
+  --> tests/ui/wildcard_imports.rs:17:5
    |
 LL | use crate::mod_mod::*;
    |     ^^^^^^^^^^^^^^^^^ help: try: `crate::mod_mod::inner_mod`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:17:5
+  --> tests/ui/wildcard_imports.rs:19:5
    |
 LL | use crate::multi_fn_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:19:5
+  --> tests/ui/wildcard_imports.rs:22:5
    |
 LL | use crate::struct_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::struct_mod::{A, inner_struct_mod}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:23:5
+  --> tests/ui/wildcard_imports.rs:27:5
    |
 LL | use wildcard_imports_helper::inner::inner_for_self_import::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:24:5
+  --> tests/ui/wildcard_imports.rs:29:5
    |
 LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:94:13
+  --> tests/ui/wildcard_imports.rs:100:13
    |
 LL |         use self::exports_underscore_ish::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `self::exports_underscore_ish::{_Deref, dummy}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:125:13
+  --> tests/ui/wildcard_imports.rs:132:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:131:75
+  --> tests/ui/wildcard_imports.rs:139:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:132:13
+  --> tests/ui/wildcard_imports.rs:141:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:144:20
+  --> tests/ui/wildcard_imports.rs:154:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:144:30
+  --> tests/ui/wildcard_imports.rs:154:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:151:13
+  --> tests/ui/wildcard_imports.rs:163:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:180:9
+  --> tests/ui/wildcard_imports.rs:193:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:189:9
+  --> tests/ui/wildcard_imports.rs:203:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:190:9
+  --> tests/ui/wildcard_imports.rs:205:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
+LL | |
 LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:201:13
+  --> tests/ui/wildcard_imports.rs:217:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:239:17
+  --> tests/ui/wildcard_imports.rs:256:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:247:13
+  --> tests/ui/wildcard_imports.rs:265:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:256:17
+  --> tests/ui/wildcard_imports.rs:275:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:265:13
+  --> tests/ui/wildcard_imports.rs:285:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports.rs:273:13
+  --> tests/ui/wildcard_imports.rs:294:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
diff --git a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.fixed b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.fixed
index 197dd3b94df0..a3d1aebba8af 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.fixed
+++ b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.fixed
@@ -11,14 +11,20 @@
 extern crate wildcard_imports_helper;
 
 use crate::fn_mod::foo;
+//~^ wildcard_imports
 use crate::mod_mod::inner_mod;
+//~^ wildcard_imports
 use crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod};
+//~^ wildcard_imports
 use crate::struct_mod::{A, inner_struct_mod};
+//~^ wildcard_imports
 
 #[allow(unused_imports)]
 use wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar;
+//~^ wildcard_imports
 use wildcard_imports_helper::prelude::v1::*;
 use wildcard_imports_helper::{ExternA, extern_foo};
+//~^ wildcard_imports
 
 use std::io::prelude::*;
 
@@ -87,6 +93,7 @@ mod underscore_mod {
 
     fn does_lint() {
         use exports_underscore_ish::{_Deref, dummy};
+        //~^ wildcard_imports
         let _ = (&0).deref();
         dummy();
     }
@@ -117,13 +124,16 @@ mod in_fn_test {
 
     fn test_intern() {
         use crate::fn_mod::foo;
+        //~^ wildcard_imports
 
         foo();
     }
 
     fn test_extern() {
         use wildcard_imports_helper::inner::inner_for_self_import::{self, inner_extern_foo};
+        //~^ wildcard_imports
         use wildcard_imports_helper::{ExternA, extern_foo};
+        //~^ wildcard_imports
 
         inner_for_self_import::inner_extern_foo();
         inner_extern_foo();
@@ -136,6 +146,8 @@ mod in_fn_test {
     fn test_inner_nested() {
         #[rustfmt::skip]
         use self::{inner::inner_foo, inner2::inner_bar};
+        //~^ wildcard_imports
+        //~| wildcard_imports
 
         inner_foo();
         inner_bar();
@@ -143,6 +155,7 @@ mod in_fn_test {
 
     fn test_extern_reexported() {
         use wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported};
+        //~^ wildcard_imports
 
         extern_exported();
         let _ = ExternExportedStruct;
@@ -172,6 +185,7 @@ mod in_fn_test {
 
 fn test_reexported() {
     use crate::in_fn_test::{ExportedEnum, ExportedStruct, exported};
+    //~^ wildcard_imports
 
     exported();
     let _ = ExportedStruct;
@@ -181,6 +195,7 @@ fn test_reexported() {
 #[rustfmt::skip]
 fn test_weird_formatting() {
     use crate:: in_fn_test::exported;
+    //~^ wildcard_imports
     use crate:: fn_mod::foo;
 
     exported();
@@ -192,6 +207,7 @@ mod super_imports {
 
     mod should_be_replaced {
         use super::foofoo;
+        //~^ wildcard_imports
 
         fn with_super() {
             let _ = foofoo();
@@ -230,6 +246,7 @@ mod super_imports {
         fn insidefoo() {}
         mod inner {
             use super::insidefoo;
+            //~^ wildcard_imports
             fn with_super() {
                 let _ = insidefoo();
             }
@@ -238,6 +255,7 @@ mod super_imports {
 
     mod use_explicit_should_be_replaced {
         use crate::super_imports::foofoo;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
@@ -247,6 +265,7 @@ mod super_imports {
     mod use_double_super_should_be_replaced {
         mod inner {
             use super::super::foofoo;
+            //~^ wildcard_imports
 
             fn with_double_super() {
                 let _ = foofoo();
@@ -256,6 +275,7 @@ mod super_imports {
 
     mod use_super_explicit_should_be_replaced {
         use super::super::super_imports::foofoo;
+        //~^ wildcard_imports
 
         fn with_super_explicit() {
             let _ = foofoo();
@@ -264,6 +284,7 @@ mod super_imports {
 
     mod attestation_should_be_replaced {
         use super::foofoo;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
diff --git a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.stderr b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.stderr
index 66adacd95dcc..a1b557f39f0d 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.stderr
+++ b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2018.stderr
@@ -8,129 +8,130 @@ LL | use crate::fn_mod::*;
    = help: to override `-D warnings` add `#[allow(clippy::wildcard_imports)]`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:14:5
+  --> tests/ui/wildcard_imports_2021.rs:15:5
    |
 LL | use crate::mod_mod::*;
    |     ^^^^^^^^^^^^^^^^^ help: try: `crate::mod_mod::inner_mod`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:15:5
+  --> tests/ui/wildcard_imports_2021.rs:17:5
    |
 LL | use crate::multi_fn_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:16:5
+  --> tests/ui/wildcard_imports_2021.rs:19:5
    |
 LL | use crate::struct_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::struct_mod::{A, inner_struct_mod}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:19:5
+  --> tests/ui/wildcard_imports_2021.rs:23:5
    |
 LL | use wildcard_imports_helper::inner::inner_for_self_import::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:21:5
+  --> tests/ui/wildcard_imports_2021.rs:26:5
    |
 LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:89:13
+  --> tests/ui/wildcard_imports_2021.rs:95:13
    |
 LL |         use exports_underscore_ish::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `exports_underscore_ish::{_Deref, dummy}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:119:13
+  --> tests/ui/wildcard_imports_2021.rs:126:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:125:75
+  --> tests/ui/wildcard_imports_2021.rs:133:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:126:13
+  --> tests/ui/wildcard_imports_2021.rs:135:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:138:20
+  --> tests/ui/wildcard_imports_2021.rs:148:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:138:30
+  --> tests/ui/wildcard_imports_2021.rs:148:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:145:13
+  --> tests/ui/wildcard_imports_2021.rs:157:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:174:9
+  --> tests/ui/wildcard_imports_2021.rs:187:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:183:9
+  --> tests/ui/wildcard_imports_2021.rs:197:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:184:9
+  --> tests/ui/wildcard_imports_2021.rs:199:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
+LL | |
 LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:195:13
+  --> tests/ui/wildcard_imports_2021.rs:211:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:233:17
+  --> tests/ui/wildcard_imports_2021.rs:250:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:241:13
+  --> tests/ui/wildcard_imports_2021.rs:259:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:250:17
+  --> tests/ui/wildcard_imports_2021.rs:269:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:259:13
+  --> tests/ui/wildcard_imports_2021.rs:279:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:267:13
+  --> tests/ui/wildcard_imports_2021.rs:288:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
diff --git a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.fixed b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.fixed
index 197dd3b94df0..a3d1aebba8af 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.fixed
+++ b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.fixed
@@ -11,14 +11,20 @@
 extern crate wildcard_imports_helper;
 
 use crate::fn_mod::foo;
+//~^ wildcard_imports
 use crate::mod_mod::inner_mod;
+//~^ wildcard_imports
 use crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod};
+//~^ wildcard_imports
 use crate::struct_mod::{A, inner_struct_mod};
+//~^ wildcard_imports
 
 #[allow(unused_imports)]
 use wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar;
+//~^ wildcard_imports
 use wildcard_imports_helper::prelude::v1::*;
 use wildcard_imports_helper::{ExternA, extern_foo};
+//~^ wildcard_imports
 
 use std::io::prelude::*;
 
@@ -87,6 +93,7 @@ mod underscore_mod {
 
     fn does_lint() {
         use exports_underscore_ish::{_Deref, dummy};
+        //~^ wildcard_imports
         let _ = (&0).deref();
         dummy();
     }
@@ -117,13 +124,16 @@ mod in_fn_test {
 
     fn test_intern() {
         use crate::fn_mod::foo;
+        //~^ wildcard_imports
 
         foo();
     }
 
     fn test_extern() {
         use wildcard_imports_helper::inner::inner_for_self_import::{self, inner_extern_foo};
+        //~^ wildcard_imports
         use wildcard_imports_helper::{ExternA, extern_foo};
+        //~^ wildcard_imports
 
         inner_for_self_import::inner_extern_foo();
         inner_extern_foo();
@@ -136,6 +146,8 @@ mod in_fn_test {
     fn test_inner_nested() {
         #[rustfmt::skip]
         use self::{inner::inner_foo, inner2::inner_bar};
+        //~^ wildcard_imports
+        //~| wildcard_imports
 
         inner_foo();
         inner_bar();
@@ -143,6 +155,7 @@ mod in_fn_test {
 
     fn test_extern_reexported() {
         use wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported};
+        //~^ wildcard_imports
 
         extern_exported();
         let _ = ExternExportedStruct;
@@ -172,6 +185,7 @@ mod in_fn_test {
 
 fn test_reexported() {
     use crate::in_fn_test::{ExportedEnum, ExportedStruct, exported};
+    //~^ wildcard_imports
 
     exported();
     let _ = ExportedStruct;
@@ -181,6 +195,7 @@ fn test_reexported() {
 #[rustfmt::skip]
 fn test_weird_formatting() {
     use crate:: in_fn_test::exported;
+    //~^ wildcard_imports
     use crate:: fn_mod::foo;
 
     exported();
@@ -192,6 +207,7 @@ mod super_imports {
 
     mod should_be_replaced {
         use super::foofoo;
+        //~^ wildcard_imports
 
         fn with_super() {
             let _ = foofoo();
@@ -230,6 +246,7 @@ mod super_imports {
         fn insidefoo() {}
         mod inner {
             use super::insidefoo;
+            //~^ wildcard_imports
             fn with_super() {
                 let _ = insidefoo();
             }
@@ -238,6 +255,7 @@ mod super_imports {
 
     mod use_explicit_should_be_replaced {
         use crate::super_imports::foofoo;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
@@ -247,6 +265,7 @@ mod super_imports {
     mod use_double_super_should_be_replaced {
         mod inner {
             use super::super::foofoo;
+            //~^ wildcard_imports
 
             fn with_double_super() {
                 let _ = foofoo();
@@ -256,6 +275,7 @@ mod super_imports {
 
     mod use_super_explicit_should_be_replaced {
         use super::super::super_imports::foofoo;
+        //~^ wildcard_imports
 
         fn with_super_explicit() {
             let _ = foofoo();
@@ -264,6 +284,7 @@ mod super_imports {
 
     mod attestation_should_be_replaced {
         use super::foofoo;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
diff --git a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.stderr b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.stderr
index 66adacd95dcc..a1b557f39f0d 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.stderr
+++ b/src/tools/clippy/tests/ui/wildcard_imports_2021.edition2021.stderr
@@ -8,129 +8,130 @@ LL | use crate::fn_mod::*;
    = help: to override `-D warnings` add `#[allow(clippy::wildcard_imports)]`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:14:5
+  --> tests/ui/wildcard_imports_2021.rs:15:5
    |
 LL | use crate::mod_mod::*;
    |     ^^^^^^^^^^^^^^^^^ help: try: `crate::mod_mod::inner_mod`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:15:5
+  --> tests/ui/wildcard_imports_2021.rs:17:5
    |
 LL | use crate::multi_fn_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::multi_fn_mod::{multi_bar, multi_foo, multi_inner_mod}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:16:5
+  --> tests/ui/wildcard_imports_2021.rs:19:5
    |
 LL | use crate::struct_mod::*;
    |     ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::struct_mod::{A, inner_struct_mod}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:19:5
+  --> tests/ui/wildcard_imports_2021.rs:23:5
    |
 LL | use wildcard_imports_helper::inner::inner_for_self_import::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::inner::inner_for_self_import::inner_extern_bar`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:21:5
+  --> tests/ui/wildcard_imports_2021.rs:26:5
    |
 LL | use wildcard_imports_helper::*;
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:89:13
+  --> tests/ui/wildcard_imports_2021.rs:95:13
    |
 LL |         use exports_underscore_ish::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `exports_underscore_ish::{_Deref, dummy}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:119:13
+  --> tests/ui/wildcard_imports_2021.rs:126:13
    |
 LL |         use crate::fn_mod::*;
    |             ^^^^^^^^^^^^^^^^ help: try: `crate::fn_mod::foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:125:75
+  --> tests/ui/wildcard_imports_2021.rs:133:75
    |
 LL |         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
    |                                                                           ^ help: try: `inner_extern_foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:126:13
+  --> tests/ui/wildcard_imports_2021.rs:135:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternA, extern_foo}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:138:20
+  --> tests/ui/wildcard_imports_2021.rs:148:20
    |
 LL |         use self::{inner::*, inner2::*};
    |                    ^^^^^^^^ help: try: `inner::inner_foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:138:30
+  --> tests/ui/wildcard_imports_2021.rs:148:30
    |
 LL |         use self::{inner::*, inner2::*};
    |                              ^^^^^^^^^ help: try: `inner2::inner_bar`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:145:13
+  --> tests/ui/wildcard_imports_2021.rs:157:13
    |
 LL |         use wildcard_imports_helper::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `wildcard_imports_helper::{ExternExportedEnum, ExternExportedStruct, extern_exported}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:174:9
+  --> tests/ui/wildcard_imports_2021.rs:187:9
    |
 LL |     use crate::in_fn_test::*;
    |         ^^^^^^^^^^^^^^^^^^^^ help: try: `crate::in_fn_test::{ExportedEnum, ExportedStruct, exported}`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:183:9
+  --> tests/ui/wildcard_imports_2021.rs:197:9
    |
 LL |     use crate:: in_fn_test::  * ;
    |         ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate:: in_fn_test::exported`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:184:9
+  --> tests/ui/wildcard_imports_2021.rs:199:9
    |
 LL |       use crate:: fn_mod::
    |  _________^
+LL | |
 LL | |         *;
    | |_________^ help: try: `crate:: fn_mod::foo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:195:13
+  --> tests/ui/wildcard_imports_2021.rs:211:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:233:17
+  --> tests/ui/wildcard_imports_2021.rs:250:17
    |
 LL |             use super::*;
    |                 ^^^^^^^^ help: try: `super::insidefoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:241:13
+  --> tests/ui/wildcard_imports_2021.rs:259:13
    |
 LL |         use crate::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^ help: try: `crate::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:250:17
+  --> tests/ui/wildcard_imports_2021.rs:269:17
    |
 LL |             use super::super::*;
    |                 ^^^^^^^^^^^^^^^ help: try: `super::super::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:259:13
+  --> tests/ui/wildcard_imports_2021.rs:279:13
    |
 LL |         use super::super::super_imports::*;
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `super::super::super_imports::foofoo`
 
 error: usage of wildcard import
-  --> tests/ui/wildcard_imports_2021.rs:267:13
+  --> tests/ui/wildcard_imports_2021.rs:288:13
    |
 LL |         use super::*;
    |             ^^^^^^^^ help: try: `super::foofoo`
diff --git a/src/tools/clippy/tests/ui/wildcard_imports_2021.rs b/src/tools/clippy/tests/ui/wildcard_imports_2021.rs
index 606ff080e774..8075c15bc14f 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports_2021.rs
+++ b/src/tools/clippy/tests/ui/wildcard_imports_2021.rs
@@ -11,14 +11,20 @@
 extern crate wildcard_imports_helper;
 
 use crate::fn_mod::*;
+//~^ wildcard_imports
 use crate::mod_mod::*;
+//~^ wildcard_imports
 use crate::multi_fn_mod::*;
+//~^ wildcard_imports
 use crate::struct_mod::*;
+//~^ wildcard_imports
 
 #[allow(unused_imports)]
 use wildcard_imports_helper::inner::inner_for_self_import::*;
+//~^ wildcard_imports
 use wildcard_imports_helper::prelude::v1::*;
 use wildcard_imports_helper::*;
+//~^ wildcard_imports
 
 use std::io::prelude::*;
 
@@ -87,6 +93,7 @@ mod underscore_mod {
 
     fn does_lint() {
         use exports_underscore_ish::*;
+        //~^ wildcard_imports
         let _ = (&0).deref();
         dummy();
     }
@@ -117,13 +124,16 @@ mod in_fn_test {
 
     fn test_intern() {
         use crate::fn_mod::*;
+        //~^ wildcard_imports
 
         foo();
     }
 
     fn test_extern() {
         use wildcard_imports_helper::inner::inner_for_self_import::{self, *};
+        //~^ wildcard_imports
         use wildcard_imports_helper::*;
+        //~^ wildcard_imports
 
         inner_for_self_import::inner_extern_foo();
         inner_extern_foo();
@@ -136,6 +146,8 @@ mod in_fn_test {
     fn test_inner_nested() {
         #[rustfmt::skip]
         use self::{inner::*, inner2::*};
+        //~^ wildcard_imports
+        //~| wildcard_imports
 
         inner_foo();
         inner_bar();
@@ -143,6 +155,7 @@ mod in_fn_test {
 
     fn test_extern_reexported() {
         use wildcard_imports_helper::*;
+        //~^ wildcard_imports
 
         extern_exported();
         let _ = ExternExportedStruct;
@@ -172,6 +185,7 @@ mod in_fn_test {
 
 fn test_reexported() {
     use crate::in_fn_test::*;
+    //~^ wildcard_imports
 
     exported();
     let _ = ExportedStruct;
@@ -181,7 +195,9 @@ fn test_reexported() {
 #[rustfmt::skip]
 fn test_weird_formatting() {
     use crate:: in_fn_test::  * ;
+    //~^ wildcard_imports
     use crate:: fn_mod::
+    //~^ wildcard_imports
         *;
 
     exported();
@@ -193,6 +209,7 @@ mod super_imports {
 
     mod should_be_replaced {
         use super::*;
+        //~^ wildcard_imports
 
         fn with_super() {
             let _ = foofoo();
@@ -231,6 +248,7 @@ mod super_imports {
         fn insidefoo() {}
         mod inner {
             use super::*;
+            //~^ wildcard_imports
             fn with_super() {
                 let _ = insidefoo();
             }
@@ -239,6 +257,7 @@ mod super_imports {
 
     mod use_explicit_should_be_replaced {
         use crate::super_imports::*;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
@@ -248,6 +267,7 @@ mod super_imports {
     mod use_double_super_should_be_replaced {
         mod inner {
             use super::super::*;
+            //~^ wildcard_imports
 
             fn with_double_super() {
                 let _ = foofoo();
@@ -257,6 +277,7 @@ mod super_imports {
 
     mod use_super_explicit_should_be_replaced {
         use super::super::super_imports::*;
+        //~^ wildcard_imports
 
         fn with_super_explicit() {
             let _ = foofoo();
@@ -265,6 +286,7 @@ mod super_imports {
 
     mod attestation_should_be_replaced {
         use super::*;
+        //~^ wildcard_imports
 
         fn with_explicit() {
             let _ = foofoo();
diff --git a/src/tools/clippy/tests/ui/wildcard_imports_cfgtest.rs b/src/tools/clippy/tests/ui/wildcard_imports_cfgtest.rs
index 203c4e15b50c..c41458d5bb0a 100644
--- a/src/tools/clippy/tests/ui/wildcard_imports_cfgtest.rs
+++ b/src/tools/clippy/tests/ui/wildcard_imports_cfgtest.rs
@@ -1,3 +1,4 @@
+//@check-pass
 //@compile-flags: --test
 
 #![warn(clippy::wildcard_imports)]
diff --git a/src/tools/clippy/tests/ui/write_literal.fixed b/src/tools/clippy/tests/ui/write_literal.fixed
index f1def776e1bc..e84f768e33d0 100644
--- a/src/tools/clippy/tests/ui/write_literal.fixed
+++ b/src/tools/clippy/tests/ui/write_literal.fixed
@@ -29,46 +29,55 @@ fn main() {
 
     // these should throw warnings
     write!(v, "Hello world");
-    //~^ ERROR: literal with an empty format string
-    //~| NOTE: `-D clippy::write-literal` implied by `-D warnings`
+    //~^ write_literal
+
     writeln!(v, "Hello {} world", world);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "Hello world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "a literal {:.4}", 5);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 
     // positional args don't change the fact
     // that we're using a literal -- this should
     // throw a warning
     writeln!(v, "hello world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "world hello");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 
     // named args shouldn't change anything either
     writeln!(v, "hello world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "world hello");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 
     // #10128
     writeln!(v, "hello {0} world", 2);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "world {0} hello", 2);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "hello {0} {1}, {bar}", 2, 3, bar = 4);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "hello {0} {1}, world {2}", 2, 3, 4);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 }
 
 fn issue_13959() {
     let mut v = Vec::new();
     writeln!(v, "\"");
+    //~^ write_literal
     writeln!(
         v,
         "
+        //~^ write_literal
         foo
         \\
         \\\\
diff --git a/src/tools/clippy/tests/ui/write_literal.rs b/src/tools/clippy/tests/ui/write_literal.rs
index 1b7df91b47e1..fc29fcbede7e 100644
--- a/src/tools/clippy/tests/ui/write_literal.rs
+++ b/src/tools/clippy/tests/ui/write_literal.rs
@@ -29,47 +29,56 @@ fn main() {
 
     // these should throw warnings
     write!(v, "Hello {}", "world");
-    //~^ ERROR: literal with an empty format string
-    //~| NOTE: `-D clippy::write-literal` implied by `-D warnings`
+    //~^ write_literal
+
     writeln!(v, "Hello {} {}", world, "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "Hello {}", "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{} {:.4}", "a literal", 5);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 
     // positional args don't change the fact
     // that we're using a literal -- this should
     // throw a warning
     writeln!(v, "{0} {1}", "hello", "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{1} {0}", "hello", "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 
     // named args shouldn't change anything either
     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 
     // #10128
     writeln!(v, "{0} {1} {2}", "hello", 2, "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{2} {1} {0}", "hello", 2, "world");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{0} {1} {2}, {bar}", "hello", 2, 3, bar = 4);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{0} {1} {2}, {3} {4}", "hello", 2, 3, "world", 4);
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
 }
 
 fn issue_13959() {
     let mut v = Vec::new();
     writeln!(v, "{}", r#"""#);
+    //~^ write_literal
     writeln!(
         v,
         "{}",
         r#"
+        //~^ write_literal
         foo
         \
         \\
diff --git a/src/tools/clippy/tests/ui/write_literal.stderr b/src/tools/clippy/tests/ui/write_literal.stderr
index 35c93d567cd3..d53c2a7de2e0 100644
--- a/src/tools/clippy/tests/ui/write_literal.stderr
+++ b/src/tools/clippy/tests/ui/write_literal.stderr
@@ -25,7 +25,7 @@ LL +     writeln!(v, "Hello {} world", world);
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:36:29
+  --> tests/ui/write_literal.rs:37:29
    |
 LL |     writeln!(v, "Hello {}", "world");
    |                             ^^^^^^^
@@ -37,7 +37,7 @@ LL +     writeln!(v, "Hello world");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:38:29
+  --> tests/ui/write_literal.rs:40:29
    |
 LL |     writeln!(v, "{} {:.4}", "a literal", 5);
    |                             ^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     writeln!(v, "a literal {:.4}", 5);
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:44:28
+  --> tests/ui/write_literal.rs:46:28
    |
 LL |     writeln!(v, "{0} {1}", "hello", "world");
    |                            ^^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     writeln!(v, "hello world");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:46:28
+  --> tests/ui/write_literal.rs:49:28
    |
 LL |     writeln!(v, "{1} {0}", "hello", "world");
    |                            ^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     writeln!(v, "world hello");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:50:38
+  --> tests/ui/write_literal.rs:53:38
    |
 LL |     writeln!(v, "{foo} {bar}", foo = "hello", bar = "world");
    |                                      ^^^^^^^^^^^^^^^^^^^^^^
@@ -85,7 +85,7 @@ LL +     writeln!(v, "hello world");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:52:38
+  --> tests/ui/write_literal.rs:56:38
    |
 LL |     writeln!(v, "{bar} {foo}", foo = "hello", bar = "world");
    |                                      ^^^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL +     writeln!(v, "world hello");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:56:32
+  --> tests/ui/write_literal.rs:60:32
    |
 LL |     writeln!(v, "{0} {1} {2}", "hello", 2, "world");
    |                                ^^^^^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL +     writeln!(v, "hello {0} world", 2);
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:58:32
+  --> tests/ui/write_literal.rs:63:32
    |
 LL |     writeln!(v, "{2} {1} {0}", "hello", 2, "world");
    |                                ^^^^^^^^^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL +     writeln!(v, "world {0} hello", 2);
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:60:39
+  --> tests/ui/write_literal.rs:66:39
    |
 LL |     writeln!(v, "{0} {1} {2}, {bar}", "hello", 2, 3, bar = 4);
    |                                       ^^^^^^^
@@ -133,7 +133,7 @@ LL +     writeln!(v, "hello {0} {1}, {bar}", 2, 3, bar = 4);
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:62:41
+  --> tests/ui/write_literal.rs:69:41
    |
 LL |     writeln!(v, "{0} {1} {2}, {3} {4}", "hello", 2, 3, "world", 4);
    |                                         ^^^^^^^^^^^^^^^^^^^^^^
@@ -145,7 +145,7 @@ LL +     writeln!(v, "hello {0} {1}, world {2}", 2, 3, 4);
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:68:23
+  --> tests/ui/write_literal.rs:75:23
    |
 LL |     writeln!(v, "{}", r#"""#);
    |                       ^^^^^^
@@ -157,12 +157,12 @@ LL +     writeln!(v, "\"");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal.rs:72:9
+  --> tests/ui/write_literal.rs:80:9
    |
 LL | /         r#"
+LL | |
 LL | |         foo
 LL | |         \
-LL | |         \\
 ...  |
 LL | |         bar
 LL | | "#
@@ -171,6 +171,7 @@ LL | | "#
 help: try
    |
 LL ~         "
+LL +
 LL +         foo
 LL +         \\
 LL +         \\\\
diff --git a/src/tools/clippy/tests/ui/write_literal_2.rs b/src/tools/clippy/tests/ui/write_literal_2.rs
index b2ed552d46bc..f896782aaf3b 100644
--- a/src/tools/clippy/tests/ui/write_literal_2.rs
+++ b/src/tools/clippy/tests/ui/write_literal_2.rs
@@ -8,44 +8,58 @@ fn main() {
     let mut v = Vec::new();
 
     writeln!(v, "{}", "{hello}");
-    //~^ ERROR: literal with an empty format string
-    //~| NOTE: `-D clippy::write-literal` implied by `-D warnings`
+    //~^ write_literal
+
     writeln!(v, r"{}", r"{hello}");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{}", '\'');
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{}", '"');
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, r"{}", '"');
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, r"{}", '\'');
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(
         v,
         "some {}",
         "hello \
+        //~^ write_literal
         world!",
-        //~^^ ERROR: literal with an empty format string
     );
     writeln!(
         v,
         "some {}\
         {} \\ {}",
-        "1", "2", "3",
+        "1",
+        "2",
+        "3",
+        //~^^^ write_literal
     );
     writeln!(v, "{}", "\\");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, r"{}", "\\");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, r#"{}"#, "\\");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{}", r"\");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     writeln!(v, "{}", "\r");
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     // hard mode
     writeln!(v, r#"{}{}"#, '#', '"');
-    //~^ ERROR: literal with an empty format string
+    //~^ write_literal
+
     // should not lint
     writeln!(v, r"{}", "\r");
 }
diff --git a/src/tools/clippy/tests/ui/write_literal_2.stderr b/src/tools/clippy/tests/ui/write_literal_2.stderr
index 9fba3ce548a0..29803d6a8b18 100644
--- a/src/tools/clippy/tests/ui/write_literal_2.stderr
+++ b/src/tools/clippy/tests/ui/write_literal_2.stderr
@@ -25,7 +25,7 @@ LL +     writeln!(v, r"{{hello}}");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:15:23
+  --> tests/ui/write_literal_2.rs:16:23
    |
 LL |     writeln!(v, "{}", '\'');
    |                       ^^^^
@@ -37,7 +37,7 @@ LL +     writeln!(v, "'");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:17:23
+  --> tests/ui/write_literal_2.rs:19:23
    |
 LL |     writeln!(v, "{}", '"');
    |                       ^^^
@@ -49,13 +49,13 @@ LL +     writeln!(v, "\"");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:19:24
+  --> tests/ui/write_literal_2.rs:22:24
    |
 LL |     writeln!(v, r"{}", '"');
    |                        ^^^
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:21:24
+  --> tests/ui/write_literal_2.rs:25:24
    |
 LL |     writeln!(v, r"{}", '\'');
    |                        ^^^^
@@ -67,23 +67,27 @@ LL +     writeln!(v, r"'");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:26:9
+  --> tests/ui/write_literal_2.rs:31:9
    |
 LL | /         "hello \
+LL | |
 LL | |         world!",
    | |_______________^
    |
 help: try
    |
 LL ~         "some hello \
+LL +
 LL ~         world!",
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:34:9
+  --> tests/ui/write_literal_2.rs:39:9
    |
-LL |         "1", "2", "3",
-   |         ^^^^^^^^^^^^^
+LL | /         "1",
+LL | |         "2",
+LL | |         "3",
+   | |___________^
    |
 help: try
    |
@@ -92,7 +96,7 @@ LL ~         2 \\ 3",
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:36:23
+  --> tests/ui/write_literal_2.rs:44:23
    |
 LL |     writeln!(v, "{}", "\\");
    |                       ^^^^
@@ -104,7 +108,7 @@ LL +     writeln!(v, "\\");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:38:24
+  --> tests/ui/write_literal_2.rs:47:24
    |
 LL |     writeln!(v, r"{}", "\\");
    |                        ^^^^
@@ -116,7 +120,7 @@ LL +     writeln!(v, r"\");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:40:26
+  --> tests/ui/write_literal_2.rs:50:26
    |
 LL |     writeln!(v, r#"{}"#, "\\");
    |                          ^^^^
@@ -128,7 +132,7 @@ LL +     writeln!(v, r#"\"#);
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:42:23
+  --> tests/ui/write_literal_2.rs:53:23
    |
 LL |     writeln!(v, "{}", r"\");
    |                       ^^^^
@@ -140,7 +144,7 @@ LL +     writeln!(v, "\\");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:44:23
+  --> tests/ui/write_literal_2.rs:56:23
    |
 LL |     writeln!(v, "{}", "\r");
    |                       ^^^^
@@ -152,7 +156,7 @@ LL +     writeln!(v, "\r");
    |
 
 error: literal with an empty format string
-  --> tests/ui/write_literal_2.rs:47:28
+  --> tests/ui/write_literal_2.rs:60:28
    |
 LL |     writeln!(v, r#"{}{}"#, '#', '"');
    |                            ^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/write_with_newline.fixed b/src/tools/clippy/tests/ui/write_with_newline.fixed
index 82afff5c81f5..40742bbbb427 100644
--- a/src/tools/clippy/tests/ui/write_with_newline.fixed
+++ b/src/tools/clippy/tests/ui/write_with_newline.fixed
@@ -10,16 +10,19 @@ fn main() {
 
     // These should fail
     writeln!(v, "Hello");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
-    //~| NOTE: `-D clippy::write-with-newline` implied by `-D warnings`
+    //~^ write_with_newline
+
     writeln!(v, "Hello {}", "world");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     writeln!(v, "Hello {} {}", "world", "#2");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     writeln!(v, "{}", 1265);
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     writeln!(v);
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
 
     // These should be fine
     write!(v, "");
@@ -42,7 +45,8 @@ fn main() {
     // #3514
     write!(v, "\\n");
     writeln!(v, "\\");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     write!(v, "\\\\n");
 
     // Raw strings
@@ -51,11 +55,11 @@ fn main() {
 
     // Literal newlines should also fail
     writeln!(
-        //~^ ERROR: using `write!()` with a format string that ends in a single newline
+        //~^ write_with_newline
         v
     );
     writeln!(
-        //~^ ERROR: using `write!()` with a format string that ends in a single newline
+        //~^ write_with_newline
         v
     );
 
@@ -63,7 +67,8 @@ fn main() {
     write!(v, "\r\n");
     write!(v, "foo\r\n");
     writeln!(v, "\\r");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     write!(v, "foo\rbar\n");
 
     // Ignore expanded format strings
diff --git a/src/tools/clippy/tests/ui/write_with_newline.rs b/src/tools/clippy/tests/ui/write_with_newline.rs
index 96e4bf0fbc4b..ad6af69e7813 100644
--- a/src/tools/clippy/tests/ui/write_with_newline.rs
+++ b/src/tools/clippy/tests/ui/write_with_newline.rs
@@ -10,16 +10,19 @@ fn main() {
 
     // These should fail
     write!(v, "Hello\n");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
-    //~| NOTE: `-D clippy::write-with-newline` implied by `-D warnings`
+    //~^ write_with_newline
+
     write!(v, "Hello {}\n", "world");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     write!(v, "Hello {} {}\n", "world", "#2");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     write!(v, "{}\n", 1265);
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     write!(v, "\n");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
 
     // These should be fine
     write!(v, "");
@@ -42,7 +45,8 @@ fn main() {
     // #3514
     write!(v, "\\n");
     write!(v, "\\\n");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     write!(v, "\\\\n");
 
     // Raw strings
@@ -51,13 +55,13 @@ fn main() {
 
     // Literal newlines should also fail
     write!(
-        //~^ ERROR: using `write!()` with a format string that ends in a single newline
+        //~^ write_with_newline
         v,
         "
 "
     );
     write!(
-        //~^ ERROR: using `write!()` with a format string that ends in a single newline
+        //~^ write_with_newline
         v,
         r"
 "
@@ -67,7 +71,8 @@ fn main() {
     write!(v, "\r\n");
     write!(v, "foo\r\n");
     write!(v, "\\r\n");
-    //~^ ERROR: using `write!()` with a format string that ends in a single newline
+    //~^ write_with_newline
+
     write!(v, "foo\rbar\n");
 
     // Ignore expanded format strings
diff --git a/src/tools/clippy/tests/ui/write_with_newline.stderr b/src/tools/clippy/tests/ui/write_with_newline.stderr
index 7eb741107a7b..7243b7943df0 100644
--- a/src/tools/clippy/tests/ui/write_with_newline.stderr
+++ b/src/tools/clippy/tests/ui/write_with_newline.stderr
@@ -25,7 +25,7 @@ LL +     writeln!(v, "Hello {}", "world");
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> tests/ui/write_with_newline.rs:17:5
+  --> tests/ui/write_with_newline.rs:18:5
    |
 LL |     write!(v, "Hello {} {}\n", "world", "#2");
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -37,7 +37,7 @@ LL +     writeln!(v, "Hello {} {}", "world", "#2");
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> tests/ui/write_with_newline.rs:19:5
+  --> tests/ui/write_with_newline.rs:21:5
    |
 LL |     write!(v, "{}\n", 1265);
    |     ^^^^^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL +     writeln!(v, "{}", 1265);
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> tests/ui/write_with_newline.rs:21:5
+  --> tests/ui/write_with_newline.rs:24:5
    |
 LL |     write!(v, "\n");
    |     ^^^^^^^^^^^^^^^
@@ -61,7 +61,7 @@ LL +     writeln!(v);
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> tests/ui/write_with_newline.rs:44:5
+  --> tests/ui/write_with_newline.rs:47:5
    |
 LL |     write!(v, "\\\n");
    |     ^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL +     writeln!(v, "\\");
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> tests/ui/write_with_newline.rs:53:5
+  --> tests/ui/write_with_newline.rs:57:5
    |
 LL | /     write!(
 LL | |
@@ -91,7 +91,7 @@ LL ~         v
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> tests/ui/write_with_newline.rs:59:5
+  --> tests/ui/write_with_newline.rs:63:5
    |
 LL | /     write!(
 LL | |
@@ -109,7 +109,7 @@ LL ~         v
    |
 
 error: using `write!()` with a format string that ends in a single newline
-  --> tests/ui/write_with_newline.rs:69:5
+  --> tests/ui/write_with_newline.rs:73:5
    |
 LL |     write!(v, "\\r\n");
    |     ^^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/writeln_empty_string.fixed b/src/tools/clippy/tests/ui/writeln_empty_string.fixed
index f6a7481f6422..5cb702b10f2d 100644
--- a/src/tools/clippy/tests/ui/writeln_empty_string.fixed
+++ b/src/tools/clippy/tests/ui/writeln_empty_string.fixed
@@ -7,9 +7,11 @@ fn main() {
 
     // These should fail
     writeln!(v);
+    //~^ writeln_empty_string
 
     let mut suggestion = Vec::new();
     writeln!(suggestion);
+    //~^ writeln_empty_string
 
     // These should be fine
     writeln!(v);
diff --git a/src/tools/clippy/tests/ui/writeln_empty_string.rs b/src/tools/clippy/tests/ui/writeln_empty_string.rs
index 0297dba8c45d..e6478264a578 100644
--- a/src/tools/clippy/tests/ui/writeln_empty_string.rs
+++ b/src/tools/clippy/tests/ui/writeln_empty_string.rs
@@ -7,9 +7,11 @@ fn main() {
 
     // These should fail
     writeln!(v, "");
+    //~^ writeln_empty_string
 
     let mut suggestion = Vec::new();
     writeln!(suggestion, "");
+    //~^ writeln_empty_string
 
     // These should be fine
     writeln!(v);
diff --git a/src/tools/clippy/tests/ui/writeln_empty_string.stderr b/src/tools/clippy/tests/ui/writeln_empty_string.stderr
index 20ece6a41926..43e76309ba64 100644
--- a/src/tools/clippy/tests/ui/writeln_empty_string.stderr
+++ b/src/tools/clippy/tests/ui/writeln_empty_string.stderr
@@ -10,7 +10,7 @@ LL |     writeln!(v, "");
    = help: to override `-D warnings` add `#[allow(clippy::writeln_empty_string)]`
 
 error: empty string literal in `writeln!`
-  --> tests/ui/writeln_empty_string.rs:12:5
+  --> tests/ui/writeln_empty_string.rs:13:5
    |
 LL |     writeln!(suggestion, "");
    |     ^^^^^^^^^^^^^^^^^^^----^
diff --git a/src/tools/clippy/tests/ui/wrong_self_convention.rs b/src/tools/clippy/tests/ui/wrong_self_convention.rs
index d7ed883b767c..840dfe7c6524 100644
--- a/src/tools/clippy/tests/ui/wrong_self_convention.rs
+++ b/src/tools/clippy/tests/ui/wrong_self_convention.rs
@@ -14,14 +14,15 @@ impl Foo {
     fn is_u32(&self) {}
     fn to_i32(self) {}
     fn from_i32(self) {}
-    //~^ ERROR: methods called `from_*` usually take no `self`
+    //~^ wrong_self_convention
 
     pub fn as_i64(self) {}
     pub fn into_i64(self) {}
     pub fn is_i64(self) {}
     pub fn to_i64(self) {}
     pub fn from_i64(self) {}
-    //~^ ERROR: methods called `from_*` usually take no `self`
+    //~^ wrong_self_convention
+
     // check whether the lint can be allowed at the function level
     #[allow(clippy::wrong_self_convention)]
     pub fn from_cake(self) {}
@@ -34,30 +35,38 @@ struct Bar;
 
 impl Bar {
     fn as_i32(self) {}
-    //~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mutabl
+    //~^ wrong_self_convention
+
     fn as_u32(&self) {}
     fn into_i32(&self) {}
-    //~^ ERROR: methods called `into_*` usually take `self` by value
+    //~^ wrong_self_convention
+
     fn into_u32(self) {}
     fn is_i32(self) {}
-    //~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `self` b
+    //~^ wrong_self_convention
+
     fn is_u32(&self) {}
     fn to_i32(self) {}
-    //~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is not
+    //~^ wrong_self_convention
+
     fn to_u32(&self) {}
     fn from_i32(self) {}
-    //~^ ERROR: methods called `from_*` usually take no `self`
+    //~^ wrong_self_convention
 
     pub fn as_i64(self) {}
-    //~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mutabl
+    //~^ wrong_self_convention
+
     pub fn into_i64(&self) {}
-    //~^ ERROR: methods called `into_*` usually take `self` by value
+    //~^ wrong_self_convention
+
     pub fn is_i64(self) {}
-    //~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `self` b
+    //~^ wrong_self_convention
+
     pub fn to_i64(self) {}
-    //~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is not
+    //~^ wrong_self_convention
+
     pub fn from_i64(self) {}
-    //~^ ERROR: methods called `from_*` usually take no `self`
+    //~^ wrong_self_convention
 
     // test for false positives
     fn as_(self) {}
@@ -103,19 +112,23 @@ mod issue4037 {
 mod issue6307 {
     trait T: Sized {
         fn as_i32(self) {}
-        //~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mu
+        //~^ wrong_self_convention
+
         fn as_u32(&self) {}
         fn into_i32(self) {}
         fn into_i32_ref(&self) {}
-        //~^ ERROR: methods called `into_*` usually take `self` by value
+        //~^ wrong_self_convention
+
         fn into_u32(self) {}
         fn is_i32(self) {}
-        //~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `sel
+        //~^ wrong_self_convention
+
         fn is_u32(&self) {}
         fn to_i32(self) {}
         fn to_u32(&self) {}
         fn from_i32(self) {}
-        //~^ ERROR: methods called `from_*` usually take no `self`
+        //~^ wrong_self_convention
+
         // check whether the lint can be allowed at the function level
         #[allow(clippy::wrong_self_convention)]
         fn from_cake(self) {}
@@ -131,19 +144,23 @@ mod issue6307 {
 
     trait U {
         fn as_i32(self);
-        //~^ ERROR: methods called `as_*` usually take `self` by reference or `self` by mu
+        //~^ wrong_self_convention
+
         fn as_u32(&self);
         fn into_i32(self);
         fn into_i32_ref(&self);
-        //~^ ERROR: methods called `into_*` usually take `self` by value
+        //~^ wrong_self_convention
+
         fn into_u32(self);
         fn is_i32(self);
-        //~^ ERROR: methods called `is_*` usually take `self` by mutable reference or `sel
+        //~^ wrong_self_convention
+
         fn is_u32(&self);
         fn to_i32(self);
         fn to_u32(&self);
         fn from_i32(self);
-        //~^ ERROR: methods called `from_*` usually take no `self`
+        //~^ wrong_self_convention
+
         // check whether the lint can be allowed at the function level
         #[allow(clippy::wrong_self_convention)]
         fn from_cake(self);
@@ -162,14 +179,16 @@ mod issue6307 {
         fn as_u32(&self);
         fn into_i32(self);
         fn into_i32_ref(&self);
-        //~^ ERROR: methods called `into_*` usually take `self` by value
+        //~^ wrong_self_convention
+
         fn into_u32(self);
         fn is_i32(self);
         fn is_u32(&self);
         fn to_i32(self);
         fn to_u32(&self);
         fn from_i32(self);
-        //~^ ERROR: methods called `from_*` usually take no `self`
+        //~^ wrong_self_convention
+
         // check whether the lint can be allowed at the function level
         #[allow(clippy::wrong_self_convention)]
         fn from_cake(self);
@@ -194,7 +213,8 @@ mod issue6727 {
         }
         // trigger lint
         fn to_u64_v2(&self) -> u64 {
-            //~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is
+            //~^ wrong_self_convention
+
             1
         }
     }
@@ -204,7 +224,8 @@ mod issue6727 {
     impl FooNoCopy {
         // trigger lint
         fn to_u64(self) -> u64 {
-            //~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is
+            //~^ wrong_self_convention
+
             2
         }
         fn to_u64_v2(&self) -> u64 {
diff --git a/src/tools/clippy/tests/ui/wrong_self_convention.stderr b/src/tools/clippy/tests/ui/wrong_self_convention.stderr
index 5c286721c478..e720ddf3fae1 100644
--- a/src/tools/clippy/tests/ui/wrong_self_convention.stderr
+++ b/src/tools/clippy/tests/ui/wrong_self_convention.stderr
@@ -17,7 +17,7 @@ LL |     pub fn from_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> tests/ui/wrong_self_convention.rs:36:15
+  --> tests/ui/wrong_self_convention.rs:37:15
    |
 LL |     fn as_i32(self) {}
    |               ^^^^
@@ -25,7 +25,7 @@ LL |     fn as_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> tests/ui/wrong_self_convention.rs:39:17
+  --> tests/ui/wrong_self_convention.rs:41:17
    |
 LL |     fn into_i32(&self) {}
    |                 ^^^^^
@@ -33,7 +33,7 @@ LL |     fn into_i32(&self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
-  --> tests/ui/wrong_self_convention.rs:42:15
+  --> tests/ui/wrong_self_convention.rs:45:15
    |
 LL |     fn is_i32(self) {}
    |               ^^^^
@@ -41,7 +41,7 @@ LL |     fn is_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> tests/ui/wrong_self_convention.rs:45:15
+  --> tests/ui/wrong_self_convention.rs:49:15
    |
 LL |     fn to_i32(self) {}
    |               ^^^^
@@ -49,7 +49,7 @@ LL |     fn to_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> tests/ui/wrong_self_convention.rs:48:17
+  --> tests/ui/wrong_self_convention.rs:53:17
    |
 LL |     fn from_i32(self) {}
    |                 ^^^^
@@ -57,7 +57,7 @@ LL |     fn from_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> tests/ui/wrong_self_convention.rs:51:19
+  --> tests/ui/wrong_self_convention.rs:56:19
    |
 LL |     pub fn as_i64(self) {}
    |                   ^^^^
@@ -65,7 +65,7 @@ LL |     pub fn as_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> tests/ui/wrong_self_convention.rs:53:21
+  --> tests/ui/wrong_self_convention.rs:59:21
    |
 LL |     pub fn into_i64(&self) {}
    |                     ^^^^^
@@ -73,7 +73,7 @@ LL |     pub fn into_i64(&self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
-  --> tests/ui/wrong_self_convention.rs:55:19
+  --> tests/ui/wrong_self_convention.rs:62:19
    |
 LL |     pub fn is_i64(self) {}
    |                   ^^^^
@@ -81,7 +81,7 @@ LL |     pub fn is_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> tests/ui/wrong_self_convention.rs:57:19
+  --> tests/ui/wrong_self_convention.rs:65:19
    |
 LL |     pub fn to_i64(self) {}
    |                   ^^^^
@@ -89,7 +89,7 @@ LL |     pub fn to_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> tests/ui/wrong_self_convention.rs:59:21
+  --> tests/ui/wrong_self_convention.rs:68:21
    |
 LL |     pub fn from_i64(self) {}
    |                     ^^^^
@@ -97,7 +97,7 @@ LL |     pub fn from_i64(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> tests/ui/wrong_self_convention.rs:105:19
+  --> tests/ui/wrong_self_convention.rs:114:19
    |
 LL |         fn as_i32(self) {}
    |                   ^^^^
@@ -105,7 +105,7 @@ LL |         fn as_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> tests/ui/wrong_self_convention.rs:109:25
+  --> tests/ui/wrong_self_convention.rs:119:25
    |
 LL |         fn into_i32_ref(&self) {}
    |                         ^^^^^
@@ -113,7 +113,7 @@ LL |         fn into_i32_ref(&self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
-  --> tests/ui/wrong_self_convention.rs:112:19
+  --> tests/ui/wrong_self_convention.rs:123:19
    |
 LL |         fn is_i32(self) {}
    |                   ^^^^
@@ -121,7 +121,7 @@ LL |         fn is_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> tests/ui/wrong_self_convention.rs:117:21
+  --> tests/ui/wrong_self_convention.rs:129:21
    |
 LL |         fn from_i32(self) {}
    |                     ^^^^
@@ -129,7 +129,7 @@ LL |         fn from_i32(self) {}
    = help: consider choosing a less ambiguous name
 
 error: methods called `as_*` usually take `self` by reference or `self` by mutable reference
-  --> tests/ui/wrong_self_convention.rs:133:19
+  --> tests/ui/wrong_self_convention.rs:146:19
    |
 LL |         fn as_i32(self);
    |                   ^^^^
@@ -137,7 +137,7 @@ LL |         fn as_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> tests/ui/wrong_self_convention.rs:137:25
+  --> tests/ui/wrong_self_convention.rs:151:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
@@ -145,7 +145,7 @@ LL |         fn into_i32_ref(&self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `is_*` usually take `self` by mutable reference or `self` by reference or no `self`
-  --> tests/ui/wrong_self_convention.rs:140:19
+  --> tests/ui/wrong_self_convention.rs:155:19
    |
 LL |         fn is_i32(self);
    |                   ^^^^
@@ -153,7 +153,7 @@ LL |         fn is_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> tests/ui/wrong_self_convention.rs:145:21
+  --> tests/ui/wrong_self_convention.rs:161:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
@@ -161,7 +161,7 @@ LL |         fn from_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `into_*` usually take `self` by value
-  --> tests/ui/wrong_self_convention.rs:164:25
+  --> tests/ui/wrong_self_convention.rs:181:25
    |
 LL |         fn into_i32_ref(&self);
    |                         ^^^^^
@@ -169,7 +169,7 @@ LL |         fn into_i32_ref(&self);
    = help: consider choosing a less ambiguous name
 
 error: methods called `from_*` usually take no `self`
-  --> tests/ui/wrong_self_convention.rs:171:21
+  --> tests/ui/wrong_self_convention.rs:189:21
    |
 LL |         fn from_i32(self);
    |                     ^^^^
@@ -177,7 +177,7 @@ LL |         fn from_i32(self);
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is `Copy`) usually take `self` by value
-  --> tests/ui/wrong_self_convention.rs:196:22
+  --> tests/ui/wrong_self_convention.rs:215:22
    |
 LL |         fn to_u64_v2(&self) -> u64 {
    |                      ^^^^^
@@ -185,7 +185,7 @@ LL |         fn to_u64_v2(&self) -> u64 {
    = help: consider choosing a less ambiguous name
 
 error: methods with the following characteristics: (`to_*` and `self` type is not `Copy`) usually take `self` by reference
-  --> tests/ui/wrong_self_convention.rs:206:19
+  --> tests/ui/wrong_self_convention.rs:226:19
    |
 LL |         fn to_u64(self) -> u64 {
    |                   ^^^^
diff --git a/src/tools/clippy/tests/ui/wrong_self_convention2.rs b/src/tools/clippy/tests/ui/wrong_self_convention2.rs
index 44b70f877be4..0a3e4982a49a 100644
--- a/src/tools/clippy/tests/ui/wrong_self_convention2.rs
+++ b/src/tools/clippy/tests/ui/wrong_self_convention2.rs
@@ -52,7 +52,8 @@ mod issue7179 {
 
         // lint
         pub fn from_be_self(self) -> Self {
-            //~^ ERROR: methods called `from_*` usually take no `self`
+            //~^ wrong_self_convention
+
             S(i32::from_be(self.0))
         }
     }
@@ -62,7 +63,7 @@ mod issue7179 {
         fn from_be(s: Self) -> Self;
         // lint
         fn from_be_self(self) -> Self;
-        //~^ ERROR: methods called `from_*` usually take no `self`
+        //~^ wrong_self_convention
     }
 
     trait Foo: Sized {
diff --git a/src/tools/clippy/tests/ui/wrong_self_convention2.stderr b/src/tools/clippy/tests/ui/wrong_self_convention2.stderr
index 7aabdcd408c6..2eafb95d9bbe 100644
--- a/src/tools/clippy/tests/ui/wrong_self_convention2.stderr
+++ b/src/tools/clippy/tests/ui/wrong_self_convention2.stderr
@@ -9,7 +9,7 @@ LL |         pub fn from_be_self(self) -> Self {
    = help: to override `-D warnings` add `#[allow(clippy::wrong_self_convention)]`
 
 error: methods called `from_*` usually take no `self`
-  --> tests/ui/wrong_self_convention2.rs:64:25
+  --> tests/ui/wrong_self_convention2.rs:65:25
    |
 LL |         fn from_be_self(self) -> Self;
    |                         ^^^^
diff --git a/src/tools/clippy/tests/ui/wrong_self_conventions_mut.rs b/src/tools/clippy/tests/ui/wrong_self_conventions_mut.rs
index 9169fc6d71f6..eb6f08fff424 100644
--- a/src/tools/clippy/tests/ui/wrong_self_conventions_mut.rs
+++ b/src/tools/clippy/tests/ui/wrong_self_conventions_mut.rs
@@ -12,7 +12,8 @@ mod issue6758 {
     impl<T> Test<T> {
         // If a method starts with `to_` and not ends with `_mut` it should expect `&self`
         pub fn to_many(&mut self) -> Option<&mut [T]> {
-            //~^ ERROR: methods with the following characteristics: (`to_*` and `self` type is
+            //~^ wrong_self_convention
+
             match self {
                 Self::Many(data) => Some(data),
                 _ => None,
@@ -21,7 +22,8 @@ mod issue6758 {
 
         // If a method starts with `to_` and ends with `_mut` it should expect `&mut self`
         pub fn to_many_mut(&self) -> Option<&[T]> {
-            //~^ ERROR: methods with the following characteristics: (`to_*` and `*_mut`) usual
+            //~^ wrong_self_convention
+
             match self {
                 Self::Many(data) => Some(data),
                 _ => None,
diff --git a/src/tools/clippy/tests/ui/wrong_self_conventions_mut.stderr b/src/tools/clippy/tests/ui/wrong_self_conventions_mut.stderr
index f52a36632101..5ea2e8192efe 100644
--- a/src/tools/clippy/tests/ui/wrong_self_conventions_mut.stderr
+++ b/src/tools/clippy/tests/ui/wrong_self_conventions_mut.stderr
@@ -9,7 +9,7 @@ LL |         pub fn to_many(&mut self) -> Option<&mut [T]> {
    = help: to override `-D warnings` add `#[allow(clippy::wrong_self_convention)]`
 
 error: methods with the following characteristics: (`to_*` and `*_mut`) usually take `self` by mutable reference
-  --> tests/ui/wrong_self_conventions_mut.rs:23:28
+  --> tests/ui/wrong_self_conventions_mut.rs:24:28
    |
 LL |         pub fn to_many_mut(&self) -> Option<&[T]> {
    |                            ^^^^^
diff --git a/src/tools/clippy/tests/ui/zero_div_zero.rs b/src/tools/clippy/tests/ui/zero_div_zero.rs
index 340ed5ef1339..79a309f49933 100644
--- a/src/tools/clippy/tests/ui/zero_div_zero.rs
+++ b/src/tools/clippy/tests/ui/zero_div_zero.rs
@@ -2,13 +2,17 @@
 #[warn(clippy::zero_divided_by_zero)]
 fn main() {
     let nan = 0.0 / 0.0;
-    //~^ ERROR: constant division of `0.0` with `0.0` will always result in NaN
+    //~^ zero_divided_by_zero
+
     let f64_nan = 0.0 / 0.0f64;
-    //~^ ERROR: constant division of `0.0` with `0.0` will always result in NaN
+    //~^ zero_divided_by_zero
+
     let other_f64_nan = 0.0f64 / 0.0;
-    //~^ ERROR: constant division of `0.0` with `0.0` will always result in NaN
+    //~^ zero_divided_by_zero
+
     let one_more_f64_nan = 0.0f64 / 0.0f64;
-    //~^ ERROR: constant division of `0.0` with `0.0` will always result in NaN
+    //~^ zero_divided_by_zero
+
     let zero = 0.0;
     let other_zero = 0.0;
     let other_nan = zero / other_zero; // fine - this lint doesn't propagate constants.
diff --git a/src/tools/clippy/tests/ui/zero_div_zero.stderr b/src/tools/clippy/tests/ui/zero_div_zero.stderr
index 5294ebdfa5da..bcf752d7c26c 100644
--- a/src/tools/clippy/tests/ui/zero_div_zero.stderr
+++ b/src/tools/clippy/tests/ui/zero_div_zero.stderr
@@ -9,7 +9,7 @@ LL |     let nan = 0.0 / 0.0;
    = help: to override `-D warnings` add `#[allow(clippy::zero_divided_by_zero)]`
 
 error: constant division of `0.0` with `0.0` will always result in NaN
-  --> tests/ui/zero_div_zero.rs:6:19
+  --> tests/ui/zero_div_zero.rs:7:19
    |
 LL |     let f64_nan = 0.0 / 0.0f64;
    |                   ^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL |     let f64_nan = 0.0 / 0.0f64;
    = help: consider using `f64::NAN` if you would like a constant representing NaN
 
 error: constant division of `0.0` with `0.0` will always result in NaN
-  --> tests/ui/zero_div_zero.rs:8:25
+  --> tests/ui/zero_div_zero.rs:10:25
    |
 LL |     let other_f64_nan = 0.0f64 / 0.0;
    |                         ^^^^^^^^^^^^
@@ -25,7 +25,7 @@ LL |     let other_f64_nan = 0.0f64 / 0.0;
    = help: consider using `f64::NAN` if you would like a constant representing NaN
 
 error: constant division of `0.0` with `0.0` will always result in NaN
-  --> tests/ui/zero_div_zero.rs:10:28
+  --> tests/ui/zero_div_zero.rs:13:28
    |
 LL |     let one_more_f64_nan = 0.0f64 / 0.0f64;
    |                            ^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/zero_offset.rs b/src/tools/clippy/tests/ui/zero_offset.rs
index c7a69dee4b2d..bedb09536c53 100644
--- a/src/tools/clippy/tests/ui/zero_offset.rs
+++ b/src/tools/clippy/tests/ui/zero_offset.rs
@@ -3,24 +3,29 @@ fn main() {
     unsafe {
         let m = &mut () as *mut ();
         m.offset(0);
-        //~^ ERROR: offset calculation on zero-sized value
-        //~| NOTE: `#[deny(clippy::zst_offset)]` on by default
+        //~^ zst_offset
+
         m.wrapping_add(0);
-        //~^ ERROR: offset calculation on zero-sized value
+        //~^ zst_offset
+
         m.sub(0);
-        //~^ ERROR: offset calculation on zero-sized value
+        //~^ zst_offset
+
         m.wrapping_sub(0);
-        //~^ ERROR: offset calculation on zero-sized value
+        //~^ zst_offset
 
         let c = &() as *const ();
         c.offset(0);
-        //~^ ERROR: offset calculation on zero-sized value
+        //~^ zst_offset
+
         c.wrapping_add(0);
-        //~^ ERROR: offset calculation on zero-sized value
+        //~^ zst_offset
+
         c.sub(0);
-        //~^ ERROR: offset calculation on zero-sized value
+        //~^ zst_offset
+
         c.wrapping_sub(0);
-        //~^ ERROR: offset calculation on zero-sized value
+        //~^ zst_offset
 
         let sized = &1 as *const i32;
         sized.offset(0);
diff --git a/src/tools/clippy/tests/ui/zero_offset.stderr b/src/tools/clippy/tests/ui/zero_offset.stderr
index a1efe3904c18..b69c7b92d56a 100644
--- a/src/tools/clippy/tests/ui/zero_offset.stderr
+++ b/src/tools/clippy/tests/ui/zero_offset.stderr
@@ -13,37 +13,37 @@ LL |         m.wrapping_add(0);
    |         ^^^^^^^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> tests/ui/zero_offset.rs:10:9
+  --> tests/ui/zero_offset.rs:11:9
    |
 LL |         m.sub(0);
    |         ^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> tests/ui/zero_offset.rs:12:9
+  --> tests/ui/zero_offset.rs:14:9
    |
 LL |         m.wrapping_sub(0);
    |         ^^^^^^^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> tests/ui/zero_offset.rs:16:9
+  --> tests/ui/zero_offset.rs:18:9
    |
 LL |         c.offset(0);
    |         ^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> tests/ui/zero_offset.rs:18:9
+  --> tests/ui/zero_offset.rs:21:9
    |
 LL |         c.wrapping_add(0);
    |         ^^^^^^^^^^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> tests/ui/zero_offset.rs:20:9
+  --> tests/ui/zero_offset.rs:24:9
    |
 LL |         c.sub(0);
    |         ^^^^^^^^
 
 error: offset calculation on zero-sized value
-  --> tests/ui/zero_offset.rs:22:9
+  --> tests/ui/zero_offset.rs:27:9
    |
 LL |         c.wrapping_sub(0);
    |         ^^^^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/zero_ptr.fixed b/src/tools/clippy/tests/ui/zero_ptr.fixed
index 5d99bc9b757d..f2375d57f3a2 100644
--- a/src/tools/clippy/tests/ui/zero_ptr.fixed
+++ b/src/tools/clippy/tests/ui/zero_ptr.fixed
@@ -2,11 +2,16 @@ pub fn foo(_const: *const f32, _mut: *mut i64) {}
 
 fn main() {
     let _ = std::ptr::null::<usize>();
+    //~^ zero_ptr
     let _ = std::ptr::null_mut::<f64>();
+    //~^ zero_ptr
     let _: *const u8 = std::ptr::null();
+    //~^ zero_ptr
 
     foo(0 as _, 0 as _);
     foo(std::ptr::null(), std::ptr::null_mut());
+    //~^ zero_ptr
+    //~| zero_ptr
 
     let z = 0;
     let _ = z as *const usize; // this is currently not caught
diff --git a/src/tools/clippy/tests/ui/zero_ptr.rs b/src/tools/clippy/tests/ui/zero_ptr.rs
index 09d321c7a18d..ee01e426a43b 100644
--- a/src/tools/clippy/tests/ui/zero_ptr.rs
+++ b/src/tools/clippy/tests/ui/zero_ptr.rs
@@ -2,11 +2,16 @@ pub fn foo(_const: *const f32, _mut: *mut i64) {}
 
 fn main() {
     let _ = 0 as *const usize;
+    //~^ zero_ptr
     let _ = 0 as *mut f64;
+    //~^ zero_ptr
     let _: *const u8 = 0 as *const _;
+    //~^ zero_ptr
 
     foo(0 as _, 0 as _);
     foo(0 as *const _, 0 as *mut _);
+    //~^ zero_ptr
+    //~| zero_ptr
 
     let z = 0;
     let _ = z as *const usize; // this is currently not caught
diff --git a/src/tools/clippy/tests/ui/zero_ptr.stderr b/src/tools/clippy/tests/ui/zero_ptr.stderr
index a580bebd5d3a..8dc781f36258 100644
--- a/src/tools/clippy/tests/ui/zero_ptr.stderr
+++ b/src/tools/clippy/tests/ui/zero_ptr.stderr
@@ -8,25 +8,25 @@ LL |     let _ = 0 as *const usize;
    = help: to override `-D warnings` add `#[allow(clippy::zero_ptr)]`
 
 error: `0 as *mut _` detected
-  --> tests/ui/zero_ptr.rs:5:13
+  --> tests/ui/zero_ptr.rs:6:13
    |
 LL |     let _ = 0 as *mut f64;
    |             ^^^^^^^^^^^^^ help: try: `std::ptr::null_mut::<f64>()`
 
 error: `0 as *const _` detected
-  --> tests/ui/zero_ptr.rs:6:24
+  --> tests/ui/zero_ptr.rs:8:24
    |
 LL |     let _: *const u8 = 0 as *const _;
    |                        ^^^^^^^^^^^^^ help: try: `std::ptr::null()`
 
 error: `0 as *const _` detected
-  --> tests/ui/zero_ptr.rs:9:9
+  --> tests/ui/zero_ptr.rs:12:9
    |
 LL |     foo(0 as *const _, 0 as *mut _);
    |         ^^^^^^^^^^^^^ help: try: `std::ptr::null()`
 
 error: `0 as *mut _` detected
-  --> tests/ui/zero_ptr.rs:9:24
+  --> tests/ui/zero_ptr.rs:12:24
    |
 LL |     foo(0 as *const _, 0 as *mut _);
    |                        ^^^^^^^^^^^ help: try: `std::ptr::null_mut()`
diff --git a/src/tools/clippy/tests/ui/zero_ptr_no_std.fixed b/src/tools/clippy/tests/ui/zero_ptr_no_std.fixed
index 25143eee8cc3..bbb2464e41d2 100644
--- a/src/tools/clippy/tests/ui/zero_ptr_no_std.fixed
+++ b/src/tools/clippy/tests/ui/zero_ptr_no_std.fixed
@@ -4,7 +4,10 @@
 
 pub fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let _ = core::ptr::null::<usize>();
+    //~^ zero_ptr
     let _ = core::ptr::null_mut::<f64>();
+    //~^ zero_ptr
     let _: *const u8 = core::ptr::null();
+    //~^ zero_ptr
     0
 }
diff --git a/src/tools/clippy/tests/ui/zero_ptr_no_std.rs b/src/tools/clippy/tests/ui/zero_ptr_no_std.rs
index 965733b45d92..22fe2d24e4b1 100644
--- a/src/tools/clippy/tests/ui/zero_ptr_no_std.rs
+++ b/src/tools/clippy/tests/ui/zero_ptr_no_std.rs
@@ -4,7 +4,10 @@
 
 pub fn main(_argc: isize, _argv: *const *const u8) -> isize {
     let _ = 0 as *const usize;
+    //~^ zero_ptr
     let _ = 0 as *mut f64;
+    //~^ zero_ptr
     let _: *const u8 = 0 as *const _;
+    //~^ zero_ptr
     0
 }
diff --git a/src/tools/clippy/tests/ui/zero_ptr_no_std.stderr b/src/tools/clippy/tests/ui/zero_ptr_no_std.stderr
index 014bf312bf32..77978d0a38b2 100644
--- a/src/tools/clippy/tests/ui/zero_ptr_no_std.stderr
+++ b/src/tools/clippy/tests/ui/zero_ptr_no_std.stderr
@@ -11,13 +11,13 @@ LL | #![deny(clippy::zero_ptr)]
    |         ^^^^^^^^^^^^^^^^
 
 error: `0 as *mut _` detected
-  --> tests/ui/zero_ptr_no_std.rs:7:13
+  --> tests/ui/zero_ptr_no_std.rs:8:13
    |
 LL |     let _ = 0 as *mut f64;
    |             ^^^^^^^^^^^^^ help: try: `core::ptr::null_mut::<f64>()`
 
 error: `0 as *const _` detected
-  --> tests/ui/zero_ptr_no_std.rs:8:24
+  --> tests/ui/zero_ptr_no_std.rs:10:24
    |
 LL |     let _: *const u8 = 0 as *const _;
    |                        ^^^^^^^^^^^^^ help: try: `core::ptr::null()`
diff --git a/src/tools/clippy/tests/ui/zero_repeat_side_effects.fixed b/src/tools/clippy/tests/ui/zero_repeat_side_effects.fixed
index 989e8ae70e58..fb9d7880a4a7 100644
--- a/src/tools/clippy/tests/ui/zero_repeat_side_effects.fixed
+++ b/src/tools/clippy/tests/ui/zero_repeat_side_effects.fixed
@@ -16,27 +16,36 @@ fn main() {
 
     // on arrays
     f(); let a: [i32; 0] = [];
+    //~^ zero_repeat_side_effects
     let mut b;
     f(); b = [] as [i32; 0];
+    //~^ zero_repeat_side_effects
 
     // on vecs
     // vecs dont support inferring value of consts
     f(); let c: std::vec::Vec<i32> = vec![];
+    //~^ zero_repeat_side_effects
     let d;
     f(); d = vec![] as std::vec::Vec<i32>;
+    //~^ zero_repeat_side_effects
 
     // for macros
     println!("side effect"); let e: [(); 0] = [];
+    //~^ zero_repeat_side_effects
 
     // for nested calls
     { f() }; let g: [i32; 0] = [];
+    //~^ zero_repeat_side_effects
 
     // as function param
     drop({ f(); vec![] as std::vec::Vec<i32> });
+    //~^ zero_repeat_side_effects
 
     // when singled out/not part of assignment/local
     { f(); vec![] as std::vec::Vec<i32> };
+    //~^ zero_repeat_side_effects
     { f(); [] as [i32; 0] };
+    //~^ zero_repeat_side_effects
 
     // should not trigger
     let a = [f(); N];
diff --git a/src/tools/clippy/tests/ui/zero_repeat_side_effects.rs b/src/tools/clippy/tests/ui/zero_repeat_side_effects.rs
index 68511f41a95e..8b22ff840244 100644
--- a/src/tools/clippy/tests/ui/zero_repeat_side_effects.rs
+++ b/src/tools/clippy/tests/ui/zero_repeat_side_effects.rs
@@ -16,27 +16,36 @@ fn main() {
 
     // on arrays
     let a = [f(); 0];
+    //~^ zero_repeat_side_effects
     let mut b;
     b = [f(); 0];
+    //~^ zero_repeat_side_effects
 
     // on vecs
     // vecs dont support inferring value of consts
     let c = vec![f(); 0];
+    //~^ zero_repeat_side_effects
     let d;
     d = vec![f(); 0];
+    //~^ zero_repeat_side_effects
 
     // for macros
     let e = [println!("side effect"); 0];
+    //~^ zero_repeat_side_effects
 
     // for nested calls
     let g = [{ f() }; 0];
+    //~^ zero_repeat_side_effects
 
     // as function param
     drop(vec![f(); 0]);
+    //~^ zero_repeat_side_effects
 
     // when singled out/not part of assignment/local
     vec![f(); 0];
+    //~^ zero_repeat_side_effects
     [f(); 0];
+    //~^ zero_repeat_side_effects
 
     // should not trigger
     let a = [f(); N];
diff --git a/src/tools/clippy/tests/ui/zero_repeat_side_effects.stderr b/src/tools/clippy/tests/ui/zero_repeat_side_effects.stderr
index d578e22b9716..2dba52e2112e 100644
--- a/src/tools/clippy/tests/ui/zero_repeat_side_effects.stderr
+++ b/src/tools/clippy/tests/ui/zero_repeat_side_effects.stderr
@@ -8,49 +8,49 @@ LL |     let a = [f(); 0];
    = help: to override `-D warnings` add `#[allow(clippy::zero_repeat_side_effects)]`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:20:5
+  --> tests/ui/zero_repeat_side_effects.rs:21:5
    |
 LL |     b = [f(); 0];
    |     ^^^^^^^^^^^^ help: consider using: `f(); b = [] as [i32; 0]`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:24:5
+  --> tests/ui/zero_repeat_side_effects.rs:26:5
    |
 LL |     let c = vec![f(); 0];
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `f(); let c: std::vec::Vec<i32> = vec![];`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:26:5
+  --> tests/ui/zero_repeat_side_effects.rs:29:5
    |
 LL |     d = vec![f(); 0];
    |     ^^^^^^^^^^^^^^^^ help: consider using: `f(); d = vec![] as std::vec::Vec<i32>`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:29:5
+  --> tests/ui/zero_repeat_side_effects.rs:33:5
    |
 LL |     let e = [println!("side effect"); 0];
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: consider using: `println!("side effect"); let e: [(); 0] = [];`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:32:5
+  --> tests/ui/zero_repeat_side_effects.rs:37:5
    |
 LL |     let g = [{ f() }; 0];
    |     ^^^^^^^^^^^^^^^^^^^^^ help: consider using: `{ f() }; let g: [i32; 0] = [];`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:35:10
+  --> tests/ui/zero_repeat_side_effects.rs:41:10
    |
 LL |     drop(vec![f(); 0]);
    |          ^^^^^^^^^^^^ help: consider using: `{ f(); vec![] as std::vec::Vec<i32> }`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:38:5
+  --> tests/ui/zero_repeat_side_effects.rs:45:5
    |
 LL |     vec![f(); 0];
    |     ^^^^^^^^^^^^ help: consider using: `{ f(); vec![] as std::vec::Vec<i32> }`
 
 error: function or method calls as the initial value in zero-sized array initializers may cause side effects
-  --> tests/ui/zero_repeat_side_effects.rs:39:5
+  --> tests/ui/zero_repeat_side_effects.rs:47:5
    |
 LL |     [f(); 0];
    |     ^^^^^^^^ help: consider using: `{ f(); [] as [i32; 0] }`
diff --git a/src/tools/clippy/tests/ui/zero_sized_btreemap_values.rs b/src/tools/clippy/tests/ui/zero_sized_btreemap_values.rs
index 565f639201ff..cdeea15f28bc 100644
--- a/src/tools/clippy/tests/ui/zero_sized_btreemap_values.rs
+++ b/src/tools/clippy/tests/ui/zero_sized_btreemap_values.rs
@@ -3,28 +3,28 @@ use std::collections::BTreeMap;
 
 const CONST_OK: Option<BTreeMap<String, usize>> = None;
 const CONST_NOT_OK: Option<BTreeMap<String, ()>> = None;
-//~^ ERROR: map with zero-sized value type
+//~^ zero_sized_map_values
 
 static STATIC_OK: Option<BTreeMap<String, usize>> = None;
 static STATIC_NOT_OK: Option<BTreeMap<String, ()>> = None;
-//~^ ERROR: map with zero-sized value type
+//~^ zero_sized_map_values
 
 type OkMap = BTreeMap<String, usize>;
 type NotOkMap = BTreeMap<String, ()>;
-//~^ ERROR: map with zero-sized value type
+//~^ zero_sized_map_values
 
 enum TestEnum {
     Ok(BTreeMap<String, usize>),
     NotOk(BTreeMap<String, ()>),
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
 
 struct Test {
     ok: BTreeMap<String, usize>,
     not_ok: BTreeMap<String, ()>,
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
     also_not_ok: Vec<BTreeMap<usize, ()>>,
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
 
 trait TestTrait {
@@ -33,7 +33,7 @@ trait TestTrait {
     fn produce_output() -> Self::Output;
 
     fn weird_map(&self, map: BTreeMap<usize, ()>);
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
 
 impl Test {
@@ -42,7 +42,8 @@ impl Test {
     }
 
     fn not_ok(&self) -> BTreeMap<String, ()> {
-        //~^ ERROR: map with zero-sized value type
+        //~^ zero_sized_map_values
+
         todo!()
     }
 }
@@ -60,8 +61,9 @@ impl TestTrait for Test {
 }
 
 fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
-    //~^ ERROR: map with zero-sized value type
-    //~| ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
+    //~| zero_sized_map_values
+
     todo!();
 }
 
@@ -71,10 +73,11 @@ fn test2(map: BTreeMap<String, usize>, key: &str) -> BTreeMap<String, usize> {
 
 fn main() {
     let _: BTreeMap<String, ()> = BTreeMap::new();
-    //~^ ERROR: map with zero-sized value type
-    //~| ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
+    //~| zero_sized_map_values
+
     let _: BTreeMap<String, usize> = BTreeMap::new();
 
     let _: BTreeMap<_, _> = std::iter::empty::<(String, ())>().collect();
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
diff --git a/src/tools/clippy/tests/ui/zero_sized_btreemap_values.stderr b/src/tools/clippy/tests/ui/zero_sized_btreemap_values.stderr
index 65fc81e10e6c..40acb0b211f7 100644
--- a/src/tools/clippy/tests/ui/zero_sized_btreemap_values.stderr
+++ b/src/tools/clippy/tests/ui/zero_sized_btreemap_values.stderr
@@ -65,7 +65,7 @@ LL |     fn not_ok(&self) -> BTreeMap<String, ()> {
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_btreemap_values.rs:62:14
+  --> tests/ui/zero_sized_btreemap_values.rs:63:14
    |
 LL | fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
    |              ^^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL | fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_btreemap_values.rs:62:50
+  --> tests/ui/zero_sized_btreemap_values.rs:63:50
    |
 LL | fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
    |                                                  ^^^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL | fn test(map: BTreeMap<String, ()>, key: &str) -> BTreeMap<String, ()> {
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_btreemap_values.rs:73:35
+  --> tests/ui/zero_sized_btreemap_values.rs:75:35
    |
 LL |     let _: BTreeMap<String, ()> = BTreeMap::new();
    |                                   ^^^^^^^^
@@ -89,7 +89,7 @@ LL |     let _: BTreeMap<String, ()> = BTreeMap::new();
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_btreemap_values.rs:73:12
+  --> tests/ui/zero_sized_btreemap_values.rs:75:12
    |
 LL |     let _: BTreeMap<String, ()> = BTreeMap::new();
    |            ^^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     let _: BTreeMap<String, ()> = BTreeMap::new();
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_btreemap_values.rs:78:12
+  --> tests/ui/zero_sized_btreemap_values.rs:81:12
    |
 LL |     let _: BTreeMap<_, _> = std::iter::empty::<(String, ())>().collect();
    |            ^^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/zero_sized_hashmap_values.rs b/src/tools/clippy/tests/ui/zero_sized_hashmap_values.rs
index 5498261ee95a..4beeef421f30 100644
--- a/src/tools/clippy/tests/ui/zero_sized_hashmap_values.rs
+++ b/src/tools/clippy/tests/ui/zero_sized_hashmap_values.rs
@@ -3,28 +3,28 @@ use std::collections::HashMap;
 
 const CONST_OK: Option<HashMap<String, usize>> = None;
 const CONST_NOT_OK: Option<HashMap<String, ()>> = None;
-//~^ ERROR: map with zero-sized value type
+//~^ zero_sized_map_values
 
 static STATIC_OK: Option<HashMap<String, usize>> = None;
 static STATIC_NOT_OK: Option<HashMap<String, ()>> = None;
-//~^ ERROR: map with zero-sized value type
+//~^ zero_sized_map_values
 
 type OkMap = HashMap<String, usize>;
 type NotOkMap = HashMap<String, ()>;
-//~^ ERROR: map with zero-sized value type
+//~^ zero_sized_map_values
 
 enum TestEnum {
     Ok(HashMap<String, usize>),
     NotOk(HashMap<String, ()>),
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
 
 struct Test {
     ok: HashMap<String, usize>,
     not_ok: HashMap<String, ()>,
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
     also_not_ok: Vec<HashMap<usize, ()>>,
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
 
 trait TestTrait {
@@ -33,7 +33,7 @@ trait TestTrait {
     fn produce_output() -> Self::Output;
 
     fn weird_map(&self, map: HashMap<usize, ()>);
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
 
 impl Test {
@@ -42,7 +42,8 @@ impl Test {
     }
 
     fn not_ok(&self) -> HashMap<String, ()> {
-        //~^ ERROR: map with zero-sized value type
+        //~^ zero_sized_map_values
+
         todo!()
     }
 }
@@ -60,8 +61,9 @@ impl TestTrait for Test {
 }
 
 fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
-    //~^ ERROR: map with zero-sized value type
-    //~| ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
+    //~| zero_sized_map_values
+
     todo!();
 }
 
@@ -71,10 +73,11 @@ fn test2(map: HashMap<String, usize>, key: &str) -> HashMap<String, usize> {
 
 fn main() {
     let _: HashMap<String, ()> = HashMap::new();
-    //~^ ERROR: map with zero-sized value type
-    //~| ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
+    //~| zero_sized_map_values
+
     let _: HashMap<String, usize> = HashMap::new();
 
     let _: HashMap<_, _> = std::iter::empty::<(String, ())>().collect();
-    //~^ ERROR: map with zero-sized value type
+    //~^ zero_sized_map_values
 }
diff --git a/src/tools/clippy/tests/ui/zero_sized_hashmap_values.stderr b/src/tools/clippy/tests/ui/zero_sized_hashmap_values.stderr
index 08afef58a2aa..ed8536acfe8f 100644
--- a/src/tools/clippy/tests/ui/zero_sized_hashmap_values.stderr
+++ b/src/tools/clippy/tests/ui/zero_sized_hashmap_values.stderr
@@ -65,7 +65,7 @@ LL |     fn not_ok(&self) -> HashMap<String, ()> {
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:62:14
+  --> tests/ui/zero_sized_hashmap_values.rs:63:14
    |
 LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
    |              ^^^^^^^^^^^^^^^^^^^
@@ -73,7 +73,7 @@ LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:62:49
+  --> tests/ui/zero_sized_hashmap_values.rs:63:49
    |
 LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
    |                                                 ^^^^^^^^^^^^^^^^^^^
@@ -81,7 +81,7 @@ LL | fn test(map: HashMap<String, ()>, key: &str) -> HashMap<String, ()> {
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:73:34
+  --> tests/ui/zero_sized_hashmap_values.rs:75:34
    |
 LL |     let _: HashMap<String, ()> = HashMap::new();
    |                                  ^^^^^^^
@@ -89,7 +89,7 @@ LL |     let _: HashMap<String, ()> = HashMap::new();
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:73:12
+  --> tests/ui/zero_sized_hashmap_values.rs:75:12
    |
 LL |     let _: HashMap<String, ()> = HashMap::new();
    |            ^^^^^^^^^^^^^^^^^^^
@@ -97,7 +97,7 @@ LL |     let _: HashMap<String, ()> = HashMap::new();
    = help: consider using a set instead
 
 error: map with zero-sized value type
-  --> tests/ui/zero_sized_hashmap_values.rs:78:12
+  --> tests/ui/zero_sized_hashmap_values.rs:81:12
    |
 LL |     let _: HashMap<_, _> = std::iter::empty::<(String, ())>().collect();
    |            ^^^^^^^^^^^^^
diff --git a/src/tools/clippy/tests/ui/zombie_processes.rs b/src/tools/clippy/tests/ui/zombie_processes.rs
index 6f0d2760a860..25bbc02ffb76 100644
--- a/src/tools/clippy/tests/ui/zombie_processes.rs
+++ b/src/tools/clippy/tests/ui/zombie_processes.rs
@@ -13,6 +13,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         x.kill();
         x.id();
     }
@@ -40,6 +41,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         let v = &x;
         // (allow shared refs is fine because one cannot call `.wait()` through that)
     }
@@ -65,6 +67,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         if true {
             std::process::exit(0);
         }
@@ -72,6 +75,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         if true {
             while false {}
             // Calling `exit()` after leaving a while loop should still be linted.
@@ -98,6 +102,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         if true {
             return;
         }
@@ -107,6 +112,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         if true {
             x.wait().unwrap();
         }
@@ -115,6 +121,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         if true {
             x.wait().unwrap();
         } else {
@@ -125,6 +132,7 @@ fn main() {
     {
         let mut x = Command::new("").spawn().unwrap();
         //~^ zombie_processes
+
         if true {
             // this else block exists to test the other help message
         } else {
diff --git a/src/tools/clippy/tests/ui/zombie_processes.stderr b/src/tools/clippy/tests/ui/zombie_processes.stderr
index afc518c60db2..0374d097b1b5 100644
--- a/src/tools/clippy/tests/ui/zombie_processes.stderr
+++ b/src/tools/clippy/tests/ui/zombie_processes.stderr
@@ -11,7 +11,7 @@ LL |         let mut x = Command::new("").spawn().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::zombie_processes)]`
 
 error: spawned process is never `wait()`ed on
-  --> tests/ui/zombie_processes.rs:41:21
+  --> tests/ui/zombie_processes.rs:42:21
    |
 LL |         let mut x = Command::new("").spawn().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -21,7 +21,7 @@ LL |         let mut x = Command::new("").spawn().unwrap();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is never `wait()`ed on
-  --> tests/ui/zombie_processes.rs:66:21
+  --> tests/ui/zombie_processes.rs:68:21
    |
 LL |         let mut x = Command::new("").spawn().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -31,7 +31,7 @@ LL |         let mut x = Command::new("").spawn().unwrap();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is never `wait()`ed on
-  --> tests/ui/zombie_processes.rs:73:21
+  --> tests/ui/zombie_processes.rs:76:21
    |
 LL |         let mut x = Command::new("").spawn().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -41,18 +41,18 @@ LL |         let mut x = Command::new("").spawn().unwrap();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is not `wait()`ed on in all code paths
-  --> tests/ui/zombie_processes.rs:99:21
+  --> tests/ui/zombie_processes.rs:103:21
    |
 LL |         let mut x = Command::new("").spawn().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: no `wait()` call exists on the code path to this early return
-  --> tests/ui/zombie_processes.rs:102:13
+  --> tests/ui/zombie_processes.rs:107:13
    |
 LL |             return;
    |             ^^^^^^
 note: `wait()` call exists, but it is unreachable due to the early return
-  --> tests/ui/zombie_processes.rs:104:9
+  --> tests/ui/zombie_processes.rs:109:9
    |
 LL |         x.wait().unwrap();
    |         ^
@@ -61,20 +61,20 @@ LL |         x.wait().unwrap();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is not `wait()`ed on in all code paths
-  --> tests/ui/zombie_processes.rs:108:21
+  --> tests/ui/zombie_processes.rs:113:21
    |
 LL |         let mut x = Command::new("").spawn().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: this if expression has a `wait()` call, but it is missing an else block
-  --> tests/ui/zombie_processes.rs:110:9
+  --> tests/ui/zombie_processes.rs:116:9
    |
 LL | /         if true {
 LL | |             x.wait().unwrap();
 LL | |         }
    | |_________^
 note: `wait()` called here
-  --> tests/ui/zombie_processes.rs:111:13
+  --> tests/ui/zombie_processes.rs:117:13
    |
 LL |             x.wait().unwrap();
    |             ^
@@ -83,13 +83,13 @@ LL |             x.wait().unwrap();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is not `wait()`ed on in all code paths
-  --> tests/ui/zombie_processes.rs:116:21
+  --> tests/ui/zombie_processes.rs:122:21
    |
 LL |         let mut x = Command::new("").spawn().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `wait()` is not called in this if branch
-  --> tests/ui/zombie_processes.rs:120:10
+  --> tests/ui/zombie_processes.rs:127:10
    |
 LL |           } else {
    |  __________^
@@ -97,7 +97,7 @@ LL | |             // this else block exists to test the other help message
 LL | |         }
    | |_________^
 note: `wait()` is called in the other branch
-  --> tests/ui/zombie_processes.rs:119:13
+  --> tests/ui/zombie_processes.rs:126:13
    |
 LL |             x.wait().unwrap();
    |             ^
@@ -106,20 +106,20 @@ LL |             x.wait().unwrap();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is not `wait()`ed on in all code paths
-  --> tests/ui/zombie_processes.rs:126:21
+  --> tests/ui/zombie_processes.rs:133:21
    |
 LL |         let mut x = Command::new("").spawn().unwrap();
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
 note: `wait()` is not called in this if branch
-  --> tests/ui/zombie_processes.rs:128:9
+  --> tests/ui/zombie_processes.rs:136:9
    |
 LL | /         if true {
 LL | |             // this else block exists to test the other help message
 LL | |         } else {
    | |_________^
 note: `wait()` is called in the other branch
-  --> tests/ui/zombie_processes.rs:131:13
+  --> tests/ui/zombie_processes.rs:139:13
    |
 LL |             x.wait().unwrap();
    |             ^
diff --git a/src/tools/clippy/tests/ui/zombie_processes_fixable.fixed b/src/tools/clippy/tests/ui/zombie_processes_fixable.fixed
index 6045262f519a..220abbfcfd7b 100644
--- a/src/tools/clippy/tests/ui/zombie_processes_fixable.fixed
+++ b/src/tools/clippy/tests/ui/zombie_processes_fixable.fixed
@@ -5,16 +5,20 @@ use std::process::{Child, Command};
 
 fn main() {
     let _ = Command::new("").spawn().unwrap().wait();
-    //~^ ERROR: spawned process is never `wait()`ed on
+    //~^ zombie_processes
+
     Command::new("").spawn().unwrap().wait();
-    //~^ ERROR: spawned process is never `wait()`ed on
+    //~^ zombie_processes
+
     spawn_proc().wait();
-    //~^ ERROR: spawned process is never `wait()`ed on
+    //~^ zombie_processes
+
     spawn_proc().wait().unwrap(); // OK
 }
 
 fn not_main() {
     Command::new("").spawn().unwrap().wait();
+    //~^ zombie_processes
 }
 
 fn spawn_proc() -> Child {
diff --git a/src/tools/clippy/tests/ui/zombie_processes_fixable.rs b/src/tools/clippy/tests/ui/zombie_processes_fixable.rs
index e1ecb771641e..820a839cd461 100644
--- a/src/tools/clippy/tests/ui/zombie_processes_fixable.rs
+++ b/src/tools/clippy/tests/ui/zombie_processes_fixable.rs
@@ -5,16 +5,20 @@ use std::process::{Child, Command};
 
 fn main() {
     let _ = Command::new("").spawn().unwrap();
-    //~^ ERROR: spawned process is never `wait()`ed on
+    //~^ zombie_processes
+
     Command::new("").spawn().unwrap();
-    //~^ ERROR: spawned process is never `wait()`ed on
+    //~^ zombie_processes
+
     spawn_proc();
-    //~^ ERROR: spawned process is never `wait()`ed on
+    //~^ zombie_processes
+
     spawn_proc().wait().unwrap(); // OK
 }
 
 fn not_main() {
     Command::new("").spawn().unwrap();
+    //~^ zombie_processes
 }
 
 fn spawn_proc() -> Child {
diff --git a/src/tools/clippy/tests/ui/zombie_processes_fixable.stderr b/src/tools/clippy/tests/ui/zombie_processes_fixable.stderr
index e1c40472c325..abc593fe4396 100644
--- a/src/tools/clippy/tests/ui/zombie_processes_fixable.stderr
+++ b/src/tools/clippy/tests/ui/zombie_processes_fixable.stderr
@@ -10,7 +10,7 @@ LL |     let _ = Command::new("").spawn().unwrap();
    = help: to override `-D warnings` add `#[allow(clippy::zombie_processes)]`
 
 error: spawned process is never `wait()`ed on
-  --> tests/ui/zombie_processes_fixable.rs:9:5
+  --> tests/ui/zombie_processes_fixable.rs:10:5
    |
 LL |     Command::new("").spawn().unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- help: try: `.wait()`
@@ -19,7 +19,7 @@ LL |     Command::new("").spawn().unwrap();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is never `wait()`ed on
-  --> tests/ui/zombie_processes_fixable.rs:11:5
+  --> tests/ui/zombie_processes_fixable.rs:13:5
    |
 LL |     spawn_proc();
    |     ^^^^^^^^^^^^- help: try: `.wait()`
@@ -28,7 +28,7 @@ LL |     spawn_proc();
    = note: see https://doc.rust-lang.org/stable/std/process/struct.Child.html#warning
 
 error: spawned process is never `wait()`ed on
-  --> tests/ui/zombie_processes_fixable.rs:17:5
+  --> tests/ui/zombie_processes_fixable.rs:20:5
    |
 LL |     Command::new("").spawn().unwrap();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^- help: try: `.wait()`
diff --git a/src/tools/clippy/tests/ui/{literal_string_with_formatting_args}.rs b/src/tools/clippy/tests/ui/{literal_string_with_formatting_args}.rs
new file mode 100644
index 000000000000..3096558a516a
--- /dev/null
+++ b/src/tools/clippy/tests/ui/{literal_string_with_formatting_args}.rs
@@ -0,0 +1,48 @@
+//@check-pass
+
+// Regression test for <https://github.com/rust-lang/rust-clippy/issues/13885>.
+// The `dbg` macro generates a literal with the name of the current file, so
+// we need to ensure the lint is not emitted in this case.
+
+// Clippy sets `-Zflatten_format_args=no`, which changes the default behavior of how format args
+// are lowered and only that one has this non-macro span. Adding the flag makes it repro on
+// godbolt and shows a root context span for the file name string.
+//
+// So instead of having:
+//
+// ```
+// Lit(
+//     Spanned {
+//         node: Str(
+//             "[/app/example.rs:2:5] \"something\" = ",
+//             Cooked,
+//         ),
+//         span: /rustc/eb54a50837ad4bcc9842924f27e7287ca66e294c/library/std/src/macros.rs:365:35: 365:58 (#4),
+//     },
+// ),
+// ```
+//
+// We get:
+//
+// ```
+// Lit(
+//     Spanned {
+//         node: Str(
+//             "/app/example.rs",
+//             Cooked,
+//         ),
+//         span: /app/example.rs:2:5: 2:22 (#0),
+//     },
+// )
+// ```
+
+#![crate_name = "foo"]
+#![allow(unused)]
+#![warn(clippy::literal_string_with_formatting_args)]
+
+fn another_bad() {
+    let literal_string_with_formatting_args = 0;
+    dbg!("something");
+}
+
+fn main() {}
diff --git a/src/tools/clippy/tests/versioncheck.rs b/src/tools/clippy/tests/versioncheck.rs
index ed357137095b..f6fc2354ca08 100644
--- a/src/tools/clippy/tests/versioncheck.rs
+++ b/src/tools/clippy/tests/versioncheck.rs
@@ -90,3 +90,14 @@ fn check_that_clippy_has_the_same_major_version_as_rustc() {
         },
     }
 }
+
+#[test]
+fn check_host_compiler() {
+    // do not run this test inside the upstream rustc repo:
+    if option_env!("RUSTC_TEST_SUITE").is_some() {
+        return;
+    }
+
+    let version = rustc_tools_util::get_version_info!();
+    assert_eq!(version.host_compiler, Some("nightly".to_string()));
+}
diff --git a/src/tools/compiletest/src/common.rs b/src/tools/compiletest/src/common.rs
index 98ab7adf5a72..b302c6a49f58 100644
--- a/src/tools/compiletest/src/common.rs
+++ b/src/tools/compiletest/src/common.rs
@@ -220,8 +220,10 @@ pub struct Config {
     /// The directory containing the test suite sources. Must be a subdirectory of `src_root`.
     pub src_test_suite_root: PathBuf,
 
-    /// The directory where programs should be built
-    pub build_base: PathBuf,
+    /// Root build directory (e.g. `build/`).
+    pub build_root: PathBuf,
+    /// Test suite specific build directory (e.g. `build/host/test/ui/`).
+    pub build_test_suite_root: PathBuf,
 
     /// The directory containing the compiler sysroot
     pub sysroot_base: PathBuf,
@@ -347,7 +349,7 @@ pub struct Config {
 
     /// If true, this will generate a coverage file with UI test files that run `MachineApplicable`
     /// diagnostics but are missing `run-rustfix` annotations. The generated coverage file is
-    /// created in `/<build_base>/rustfix_missing_coverage.txt`
+    /// created in `<test_suite_build_root>/rustfix_missing_coverage.txt`
     pub rustfix_coverage: bool,
 
     /// whether to run `tidy` (html-tidy) when a rustdoc test fails
@@ -812,12 +814,16 @@ pub const UI_STDERR_16: &str = "16bit.stderr";
 pub const UI_COVERAGE: &str = "coverage";
 pub const UI_COVERAGE_MAP: &str = "cov-map";
 
-/// Absolute path to the directory where all output for all tests in the given
-/// `relative_dir` group should reside. Example:
-///   /path/to/build/host-tuple/test/ui/relative/
+/// Absolute path to the directory where all output for all tests in the given `relative_dir` group
+/// should reside. Example:
+///
+/// ```text
+/// /path/to/build/host-tuple/test/ui/relative/
+/// ```
+///
 /// This is created early when tests are collected to avoid race conditions.
 pub fn output_relative_path(config: &Config, relative_dir: &Path) -> PathBuf {
-    config.build_base.join(relative_dir)
+    config.build_test_suite_root.join(relative_dir)
 }
 
 /// Generates a unique name for the test, such as `testname.revision.mode`.
diff --git a/src/tools/compiletest/src/header.rs b/src/tools/compiletest/src/header.rs
index 3bdf37a1f294..53ee901b8bc4 100644
--- a/src/tools/compiletest/src/header.rs
+++ b/src/tools/compiletest/src/header.rs
@@ -1070,10 +1070,11 @@ impl Config {
     }
 }
 
+// FIXME(jieyouxu): fix some of these variable names to more accurately reflect what they do.
 fn expand_variables(mut value: String, config: &Config) -> String {
     const CWD: &str = "{{cwd}}";
     const SRC_BASE: &str = "{{src-base}}";
-    const BUILD_BASE: &str = "{{build-base}}";
+    const TEST_SUITE_BUILD_BASE: &str = "{{build-base}}";
     const RUST_SRC_BASE: &str = "{{rust-src-base}}";
     const SYSROOT_BASE: &str = "{{sysroot-base}}";
     const TARGET_LINKER: &str = "{{target-linker}}";
@@ -1088,12 +1089,13 @@ fn expand_variables(mut value: String, config: &Config) -> String {
         value = value.replace(SRC_BASE, &config.src_test_suite_root.to_str().unwrap());
     }
 
-    if value.contains(BUILD_BASE) {
-        value = value.replace(BUILD_BASE, &config.build_base.to_string_lossy());
+    if value.contains(TEST_SUITE_BUILD_BASE) {
+        value =
+            value.replace(TEST_SUITE_BUILD_BASE, &config.build_test_suite_root.to_str().unwrap());
     }
 
     if value.contains(SYSROOT_BASE) {
-        value = value.replace(SYSROOT_BASE, &config.sysroot_base.to_string_lossy());
+        value = value.replace(SYSROOT_BASE, &config.sysroot_base.to_str().unwrap());
     }
 
     if value.contains(TARGET_LINKER) {
diff --git a/src/tools/compiletest/src/header/tests.rs b/src/tools/compiletest/src/header/tests.rs
index 84c1cb0963e3..d7079fdeee6c 100644
--- a/src/tools/compiletest/src/header/tests.rs
+++ b/src/tools/compiletest/src/header/tests.rs
@@ -155,7 +155,8 @@ impl ConfigBuilder {
             "--jsondocck-path=",
             "--src-root=",
             "--src-test-suite-root=",
-            "--build-base=",
+            "--build-root=",
+            "--build-test-suite-root=",
             "--sysroot-base=",
             "--cc=c",
             "--cxx=c++",
diff --git a/src/tools/compiletest/src/lib.rs b/src/tools/compiletest/src/lib.rs
index 979821701385..9dff7047bc4a 100644
--- a/src/tools/compiletest/src/lib.rs
+++ b/src/tools/compiletest/src/lib.rs
@@ -63,7 +63,8 @@ pub fn parse_config(args: Vec<String>) -> Config {
         .optopt("", "llvm-filecheck", "path to LLVM's FileCheck binary", "DIR")
         .reqopt("", "src-root", "directory containing sources", "PATH")
         .reqopt("", "src-test-suite-root", "directory containing test suite sources", "PATH")
-        .reqopt("", "build-base", "directory to deposit test outputs", "PATH")
+        .reqopt("", "build-root", "path to root build directory", "PATH")
+        .reqopt("", "build-test-suite-root", "path to test suite specific build directory", "PATH")
         .reqopt("", "sysroot-base", "directory containing the compiler sysroot", "PATH")
         .reqopt("", "stage", "stage number under test", "N")
         .reqopt("", "stage-id", "the target-stage identifier", "stageN-TARGET")
@@ -157,7 +158,7 @@ pub fn parse_config(args: Vec<String>) -> Config {
             "",
             "rustfix-coverage",
             "enable this to generate a Rustfix coverage file, which is saved in \
-            `./<build_base>/rustfix_missing_coverage.txt`",
+            `./<build_test_suite_root>/rustfix_missing_coverage.txt`",
         )
         .optflag("", "force-rerun", "rerun tests even if the inputs are unchanged")
         .optflag("", "only-modified", "only run tests that result been modified")
@@ -309,6 +310,10 @@ pub fn parse_config(args: Vec<String>) -> Config {
         src_test_suite_root.display()
     );
 
+    let build_root = opt_path(matches, "build-root");
+    let build_test_suite_root = opt_path(matches, "build-test-suite-root");
+    assert!(build_test_suite_root.starts_with(&build_root));
+
     Config {
         bless: matches.opt_present("bless"),
         compile_lib_path: make_absolute(opt_path(matches, "compile-lib-path")),
@@ -327,7 +332,9 @@ pub fn parse_config(args: Vec<String>) -> Config {
         src_root,
         src_test_suite_root,
 
-        build_base: opt_path(matches, "build-base"),
+        build_root,
+        build_test_suite_root,
+
         sysroot_base: opt_path(matches, "sysroot-base"),
 
         stage,
@@ -438,7 +445,11 @@ pub fn log_config(config: &Config) {
     logv(c, format!("src_root: {}", config.src_root.display()));
     logv(c, format!("src_test_suite_root: {}", config.src_test_suite_root.display()));
 
-    logv(c, format!("build_base: {:?}", config.build_base.display()));
+    logv(c, format!("build_root: {}", config.build_root.display()));
+    logv(c, format!("build_test_suite_root: {}", config.build_test_suite_root.display()));
+
+    logv(c, format!("sysroot_base: {}", config.sysroot_base.display()));
+
     logv(c, format!("stage: {}", config.stage));
     logv(c, format!("stage_id: {}", config.stage_id));
     logv(c, format!("mode: {}", config.mode));
@@ -488,7 +499,7 @@ pub fn run_tests(config: Arc<Config>) {
     // we first make sure that the coverage file does not exist.
     // It will be created later on.
     if config.rustfix_coverage {
-        let mut coverage_file_path = config.build_base.clone();
+        let mut coverage_file_path = config.build_test_suite_root.clone();
         coverage_file_path.push("rustfix_missing_coverage.txt");
         if coverage_file_path.exists() {
             if let Err(e) = fs::remove_file(&coverage_file_path) {
diff --git a/src/tools/compiletest/src/runtest.rs b/src/tools/compiletest/src/runtest.rs
index 536e19bc4933..f36d43b211ff 100644
--- a/src/tools/compiletest/src/runtest.rs
+++ b/src/tools/compiletest/src/runtest.rs
@@ -535,7 +535,9 @@ impl<'test> TestCx<'test> {
             .arg(&out_dir)
             .arg(&format!("--target={}", target))
             .arg("-L")
-            .arg(&self.config.build_base)
+            // FIXME(jieyouxu): this search path seems questionable. Is this intended for
+            // `rust_test_helpers` in ui tests?
+            .arg(&self.config.build_test_suite_root)
             .arg("-L")
             .arg(aux_dir)
             .arg("-A")
@@ -1366,7 +1368,7 @@ impl<'test> TestCx<'test> {
         // Note: avoid adding a subdirectory of an already filtered directory here, otherwise the
         // same slice of text will be double counted and the truncation might not happen.
         add_path(&self.config.src_test_suite_root);
-        add_path(&self.config.build_base);
+        add_path(&self.config.build_test_suite_root);
 
         read2_abbreviated(child, &filter_paths_from_len).expect("failed to read output")
     }
@@ -1421,7 +1423,7 @@ impl<'test> TestCx<'test> {
     }
 
     fn get_mir_dump_dir(&self) -> PathBuf {
-        let mut mir_dump_dir = PathBuf::from(self.config.build_base.as_path());
+        let mut mir_dump_dir = self.config.build_test_suite_root.clone();
         debug!("input_file: {:?}", self.testpaths.file);
         mir_dump_dir.push(&self.testpaths.relative_dir);
         mir_dump_dir.push(self.testpaths.file.file_stem().unwrap());
@@ -2410,14 +2412,10 @@ impl<'test> TestCx<'test> {
         let rust_src_dir = rust_src_dir.read_link().unwrap_or(rust_src_dir.to_path_buf());
         normalize_path(&rust_src_dir.join("library"), "$SRC_DIR_REAL");
 
-        // Paths into the build directory
-        let test_build_dir = &self.config.build_base;
-        let parent_build_dir = test_build_dir.parent().unwrap().parent().unwrap().parent().unwrap();
-
         // eg. /home/user/rust/build/x86_64-unknown-linux-gnu/test/ui
-        normalize_path(test_build_dir, "$TEST_BUILD_DIR");
+        normalize_path(&self.config.build_test_suite_root, "$TEST_BUILD_DIR");
         // eg. /home/user/rust/build
-        normalize_path(parent_build_dir, "$BUILD_DIR");
+        normalize_path(&self.config.build_root, "$BUILD_DIR");
 
         if json {
             // escaped newlines in json strings should be readable
diff --git a/src/tools/compiletest/src/runtest/run_make.rs b/src/tools/compiletest/src/runtest/run_make.rs
index 74e6af36ea1d..9bb3993223e2 100644
--- a/src/tools/compiletest/src/runtest/run_make.rs
+++ b/src/tools/compiletest/src/runtest/run_make.rs
@@ -179,12 +179,7 @@ impl TestCx<'_> {
         //    library.
         // 2. We need to run the recipe binary.
 
-        // `self.config.build_base` is actually the build base folder + "test" + test suite name, it
-        // looks like `build/<host_triple>/test/run-make`. But we want `build/<host_triple>/`. Note
-        // that the `build` directory does not need to be called `build`, nor does it need to be
-        // under `src_root`, so we must compute it based off of `self.config.build_base`.
-        let build_root =
-            self.config.build_base.parent().and_then(Path::parent).unwrap().to_path_buf();
+        let host_build_root = self.config.build_root.join(&self.config.host);
 
         // We construct the following directory tree for each rmake.rs test:
         // ```
@@ -242,10 +237,10 @@ impl TestCx<'_> {
 
         let stage_number = self.config.stage;
 
-        let stage_tools_bin = build_root.join(format!("stage{stage_number}-tools-bin"));
+        let stage_tools_bin = host_build_root.join(format!("stage{stage_number}-tools-bin"));
         let support_lib_path = stage_tools_bin.join("librun_make_support.rlib");
 
-        let stage_tools = build_root.join(format!("stage{stage_number}-tools"));
+        let stage_tools = host_build_root.join(format!("stage{stage_number}-tools"));
         let support_lib_deps = stage_tools.join(&self.config.host).join("release").join("deps");
         let support_lib_deps_deps = stage_tools.join("release").join("deps");
 
@@ -311,7 +306,7 @@ impl TestCx<'_> {
         // to work correctly.
         //
         // See <https://github.com/rust-lang/rust/pull/122248> for more background.
-        let stage0_sysroot = build_root.join("stage0-sysroot");
+        let stage0_sysroot = host_build_root.join("stage0-sysroot");
         if std::env::var_os("COMPILETEST_FORCE_STAGE0").is_some() {
             rustc.arg("--sysroot").arg(&stage0_sysroot);
         }
@@ -326,7 +321,7 @@ impl TestCx<'_> {
         // provided through env vars.
 
         // Compute stage-specific standard library paths.
-        let stage_std_path = build_root.join(format!("stage{stage_number}")).join("lib");
+        let stage_std_path = host_build_root.join(format!("stage{stage_number}")).join("lib");
 
         // Compute dynamic library search paths for recipes.
         let recipe_dylib_search_paths = {
@@ -372,7 +367,7 @@ impl TestCx<'_> {
             // Provide path to sources root.
             .env("SOURCE_ROOT", &self.config.src_root)
             // Path to the host build directory.
-            .env("BUILD_ROOT", &build_root)
+            .env("BUILD_ROOT", &host_build_root)
             // Provide path to stage-corresponding rustc.
             .env("RUSTC", &self.config.rustc_path)
             // Provide the directory to libraries that are needed to run the *compiler*. This is not
diff --git a/src/tools/compiletest/src/runtest/ui.rs b/src/tools/compiletest/src/runtest/ui.rs
index 0c6d46188e6f..3329e10745f8 100644
--- a/src/tools/compiletest/src/runtest/ui.rs
+++ b/src/tools/compiletest/src/runtest/ui.rs
@@ -66,7 +66,7 @@ impl TestCx<'_> {
                 && !self.props.run_rustfix
                 && !self.props.rustfix_only_machine_applicable
             {
-                let mut coverage_file_path = self.config.build_base.clone();
+                let mut coverage_file_path = self.config.build_test_suite_root.clone();
                 coverage_file_path.push("rustfix_missing_coverage.txt");
                 debug!("coverage_file_path: {}", coverage_file_path.display());
 
diff --git a/src/tools/enzyme b/src/tools/enzyme
index 5004a8f6f5d8..a35f4f773118 160000
--- a/src/tools/enzyme
+++ b/src/tools/enzyme
@@ -1 +1 @@
-Subproject commit 5004a8f6f5d8468b64fae457afb7d96e1784c783
+Subproject commit a35f4f773118ccfbd8d05102eb12a34097b1ee55
diff --git a/src/tools/miri/.github/workflows/ci.yml b/src/tools/miri/.github/workflows/ci.yml
index 81df0964d591..59bae513a58f 100644
--- a/src/tools/miri/.github/workflows/ci.yml
+++ b/src/tools/miri/.github/workflows/ci.yml
@@ -30,6 +30,8 @@ jobs:
     steps:
       - uses: actions/checkout@v4
       - uses: ./.github/workflows/setup
+        with:
+          toolchain_flags: "--host ${{ matrix.host_target }}"
 
       # The `style` job only runs on Linux; this makes sure the Windows-host-specific
       # code is also covered by clippy.
diff --git a/src/tools/miri/.github/workflows/setup/action.yml b/src/tools/miri/.github/workflows/setup/action.yml
index bf5749a7b17e..146b432171e1 100644
--- a/src/tools/miri/.github/workflows/setup/action.yml
+++ b/src/tools/miri/.github/workflows/setup/action.yml
@@ -1,5 +1,9 @@
 name: "Miri CI setup"
 description: "Sets up Miri CI"
+inputs:
+  toolchain_flags:
+    required: false
+    default: ''
 runs:
   using: "composite"
   steps:
@@ -45,7 +49,7 @@ runs:
             echo "Building against latest rustc git version"
             git ls-remote https://github.com/rust-lang/rust/ HEAD | cut -f 1 > rust-version
           fi
-          ./miri toolchain
+          ./miri toolchain ${{ inputs.toolchain_flags }}
         shell: bash
 
       - name: Show Rust version (miri toolchain)
diff --git a/src/tools/miri/Cargo.toml b/src/tools/miri/Cargo.toml
index de80722fc3df..728a7552fd8c 100644
--- a/src/tools/miri/Cargo.toml
+++ b/src/tools/miri/Cargo.toml
@@ -67,6 +67,10 @@ default = ["stack-cache"]
 stack-cache = []
 stack-cache-consistency-check = ["stack-cache"]
 
+[lints.rust.unexpected_cfgs]
+level = "warn"
+check-cfg = ['cfg(bootstrap)']
+
 # Be aware that this file is inside a workspace when used via the
 # submodule in the rustc repo. That means there are many cargo features
 # we cannot use, such as profiles.
diff --git a/src/tools/miri/build.rs b/src/tools/miri/build.rs
deleted file mode 100644
index 0918c9b13214..000000000000
--- a/src/tools/miri/build.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-fn main() {
-    // Don't rebuild miri when nothing changed.
-    println!("cargo:rerun-if-changed=build.rs");
-    // Re-export the TARGET environment variable so it can be accessed by miri. Needed to know the
-    // "host" triple inside Miri.
-    let target = std::env::var("TARGET").unwrap();
-    println!("cargo:rustc-env=TARGET={target}");
-    // Allow some cfgs.
-    println!("cargo::rustc-check-cfg=cfg(bootstrap)");
-}
diff --git a/src/tools/miri/ci/ci.sh b/src/tools/miri/ci/ci.sh
index 5583030b490a..3327ad17c44e 100755
--- a/src/tools/miri/ci/ci.sh
+++ b/src/tools/miri/ci/ci.sh
@@ -1,5 +1,5 @@
 #!/bin/bash
-set -euo pipefail
+set -eu
 
 function begingroup {
   echo "::group::$@"
@@ -11,6 +11,17 @@ function endgroup {
   echo "::endgroup"
 }
 
+begingroup "Sanity-check environment"
+
+# Ensure the HOST_TARGET is what it should be.
+if ! rustc -vV | grep -q "^host: $HOST_TARGET\$"; then
+  echo "This runner should be using host target $HOST_TARGET but rustc disagrees:"
+  rustc -vV
+  exit 1
+fi
+
+endgroup
+
 begingroup "Building Miri"
 
 # Global configuration
diff --git a/src/tools/miri/rust-version b/src/tools/miri/rust-version
index 6e84524c8aa8..b3e207f53b8b 100644
--- a/src/tools/miri/rust-version
+++ b/src/tools/miri/rust-version
@@ -1 +1 @@
-6dd75f0d6802f56564f5f9c947a85ded286d3986
+f5729cfed3c45e061e8a443677fc1d5ef9277df7
diff --git a/src/tools/miri/src/bin/miri.rs b/src/tools/miri/src/bin/miri.rs
index 6b051da1b5a6..56ee96502b3e 100644
--- a/src/tools/miri/src/bin/miri.rs
+++ b/src/tools/miri/src/bin/miri.rs
@@ -29,8 +29,8 @@ use std::num::NonZero;
 use std::ops::Range;
 use std::path::PathBuf;
 use std::str::FromStr;
-use std::sync::{Arc, Once};
 use std::sync::atomic::{AtomicI32, AtomicU32, Ordering};
+use std::sync::{Arc, Once};
 
 use miri::{
     BacktraceStyle, BorrowTrackerMethod, MiriConfig, MiriEntryFnType, ProvenanceMode, RetagFields,
@@ -720,8 +720,8 @@ fn main() {
 
     // Ensure we have parallelism for many-seeds mode.
     if many_seeds.is_some() && !rustc_args.iter().any(|arg| arg.starts_with("-Zthreads=")) {
-        // Clamp to 10 threads; things get a lot less efficient beyond that due to lock contention.
-        let threads = std::thread::available_parallelism().map_or(1, |n| n.get()).min(10);
+        // Clamp to 20 threads; things get a less efficient beyond that due to lock contention.
+        let threads = std::thread::available_parallelism().map_or(1, |n| n.get()).min(20);
         rustc_args.push(format!("-Zthreads={threads}"));
     }
     let many_seeds =
diff --git a/src/tools/miri/src/helpers.rs b/src/tools/miri/src/helpers.rs
index a26f12cdfb1e..12e7d0f1a62c 100644
--- a/src/tools/miri/src/helpers.rs
+++ b/src/tools/miri/src/helpers.rs
@@ -999,7 +999,20 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         &'a [OpTy<'tcx>; N]: TryFrom<&'a [OpTy<'tcx>]>,
     {
         self.check_abi_and_shim_symbol_clash(abi, exp_abi, link_name)?;
-        check_arg_count(args)
+
+        if abi.c_variadic {
+            throw_ub_format!(
+                "calling a non-variadic function with a variadic caller-side signature"
+            );
+        }
+        if let Ok(ops) = args.try_into() {
+            return interp_ok(ops);
+        }
+        throw_ub_format!(
+            "incorrect number of arguments for `{link_name}`: got {}, expected {}",
+            args.len(),
+            N
+        )
     }
 
     /// Check shim for variadic function.
@@ -1015,7 +1028,23 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         &'a [OpTy<'tcx>; N]: TryFrom<&'a [OpTy<'tcx>]>,
     {
         self.check_abi_and_shim_symbol_clash(abi, exp_abi, link_name)?;
-        check_vargarg_fixed_arg_count(link_name, abi, args)
+
+        if !abi.c_variadic {
+            throw_ub_format!(
+                "calling a variadic function with a non-variadic caller-side signature"
+            );
+        }
+        if abi.fixed_count != u32::try_from(N).unwrap() {
+            throw_ub_format!(
+                "incorrect number of fixed arguments for variadic function `{}`: got {}, expected {N}",
+                link_name.as_str(),
+                abi.fixed_count
+            )
+        }
+        if let Some(args) = args.split_first_chunk() {
+            return interp_ok(args);
+        }
+        panic!("mismatch between signature and `args` slice");
     }
 
     /// Mark a machine allocation that was just created as immutable.
@@ -1199,7 +1228,7 @@ impl<'tcx> MiriMachine<'tcx> {
 }
 
 /// Check that the number of args is what we expect.
-pub fn check_arg_count<'a, 'tcx, const N: usize>(
+pub fn check_intrinsic_arg_count<'a, 'tcx, const N: usize>(
     args: &'a [OpTy<'tcx>],
 ) -> InterpResult<'tcx, &'a [OpTy<'tcx>; N]>
 where
@@ -1208,7 +1237,11 @@ where
     if let Ok(ops) = args.try_into() {
         return interp_ok(ops);
     }
-    throw_ub_format!("incorrect number of arguments: got {}, expected {}", args.len(), N)
+    throw_ub_format!(
+        "incorrect number of arguments for intrinsic: got {}, expected {}",
+        args.len(),
+        N
+    )
 }
 
 /// Check that the number of varargs is at least the minimum what we expect.
@@ -1228,34 +1261,6 @@ pub fn check_min_vararg_count<'a, 'tcx, const N: usize>(
     )
 }
 
-/// Check the number of fixed args of a vararg function.
-/// Returns a tuple that consisting of an array of fixed args, and a slice of varargs.
-fn check_vargarg_fixed_arg_count<'a, 'tcx, const N: usize>(
-    link_name: Symbol,
-    abi: &FnAbi<'tcx, Ty<'tcx>>,
-    args: &'a [OpTy<'tcx>],
-) -> InterpResult<'tcx, (&'a [OpTy<'tcx>; N], &'a [OpTy<'tcx>])> {
-    if !abi.c_variadic {
-        throw_ub_format!("calling a variadic function with a non-variadic caller-side signature");
-    }
-    if abi.fixed_count != u32::try_from(N).unwrap() {
-        throw_ub_format!(
-            "incorrect number of fixed arguments for variadic function `{}`: got {}, expected {N}",
-            link_name.as_str(),
-            abi.fixed_count
-        )
-    }
-    if let Some(args) = args.split_first_chunk() {
-        return interp_ok(args);
-    }
-    throw_ub_format!(
-        "incorrect number of arguments for `{}`: got {}, expected at least {}",
-        link_name.as_str(),
-        args.len(),
-        N
-    )
-}
-
 pub fn isolation_abort_error<'tcx>(name: &str) -> InterpResult<'tcx> {
     throw_machine_stop!(TerminationInfo::UnsupportedInIsolation(format!(
         "{name} not available when isolation is enabled",
diff --git a/src/tools/miri/src/intrinsics/atomic.rs b/src/tools/miri/src/intrinsics/atomic.rs
index 6d2a575ed765..dcafa7b6cabe 100644
--- a/src/tools/miri/src/intrinsics/atomic.rs
+++ b/src/tools/miri/src/intrinsics/atomic.rs
@@ -1,7 +1,7 @@
 use rustc_middle::mir::BinOp;
 use rustc_middle::{mir, ty};
 
-use self::helpers::check_arg_count;
+use self::helpers::check_intrinsic_arg_count;
 use crate::*;
 
 pub enum AtomicOp {
@@ -131,7 +131,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        let [place] = check_arg_count(args)?;
+        let [place] = check_intrinsic_arg_count(args)?;
         let place = this.deref_pointer(place)?;
 
         // Perform atomic load.
@@ -144,7 +144,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     fn atomic_store(&mut self, args: &[OpTy<'tcx>], atomic: AtomicWriteOrd) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        let [place, val] = check_arg_count(args)?;
+        let [place, val] = check_intrinsic_arg_count(args)?;
         let place = this.deref_pointer(place)?;
 
         // Perform regular load.
@@ -159,7 +159,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
         args: &[OpTy<'tcx>],
         atomic: AtomicFenceOrd,
     ) -> InterpResult<'tcx> {
-        let [] = check_arg_count(args)?;
+        let [] = check_intrinsic_arg_count(args)?;
         let _ = atomic;
         //FIXME: compiler fences are currently ignored
         interp_ok(())
@@ -171,7 +171,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
         atomic: AtomicFenceOrd,
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
-        let [] = check_arg_count(args)?;
+        let [] = check_intrinsic_arg_count(args)?;
         this.atomic_fence(atomic)?;
         interp_ok(())
     }
@@ -185,7 +185,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        let [place, rhs] = check_arg_count(args)?;
+        let [place, rhs] = check_intrinsic_arg_count(args)?;
         let place = this.deref_pointer(place)?;
         let rhs = this.read_immediate(rhs)?;
 
@@ -226,7 +226,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        let [place, new] = check_arg_count(args)?;
+        let [place, new] = check_intrinsic_arg_count(args)?;
         let place = this.deref_pointer(place)?;
         let new = this.read_scalar(new)?;
 
@@ -245,7 +245,7 @@ trait EvalContextPrivExt<'tcx>: MiriInterpCxExt<'tcx> {
     ) -> InterpResult<'tcx> {
         let this = self.eval_context_mut();
 
-        let [place, expect_old, new] = check_arg_count(args)?;
+        let [place, expect_old, new] = check_intrinsic_arg_count(args)?;
         let place = this.deref_pointer(place)?;
         let expect_old = this.read_immediate(expect_old)?; // read as immediate for the sake of `binary_op()`
         let new = this.read_scalar(new)?;
diff --git a/src/tools/miri/src/intrinsics/mod.rs b/src/tools/miri/src/intrinsics/mod.rs
index 0faad0f7621a..85fb280a9a90 100644
--- a/src/tools/miri/src/intrinsics/mod.rs
+++ b/src/tools/miri/src/intrinsics/mod.rs
@@ -7,12 +7,13 @@ use rand::Rng;
 use rustc_abi::Size;
 use rustc_apfloat::{Float, Round};
 use rustc_middle::mir;
-use rustc_middle::ty::{self, FloatTy};
+use rustc_middle::ty::{self, FloatTy, ScalarInt};
 use rustc_span::{Symbol, sym};
 
 use self::atomic::EvalContextExt as _;
-use self::helpers::{ToHost, ToSoft, check_arg_count};
+use self::helpers::{ToHost, ToSoft, check_intrinsic_arg_count};
 use self::simd::EvalContextExt as _;
+use crate::math::apply_random_float_error_ulp;
 use crate::*;
 
 impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
@@ -104,24 +105,24 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
             // Raw memory accesses
             "volatile_load" => {
-                let [place] = check_arg_count(args)?;
+                let [place] = check_intrinsic_arg_count(args)?;
                 let place = this.deref_pointer(place)?;
                 this.copy_op(&place, dest)?;
             }
             "volatile_store" => {
-                let [place, dest] = check_arg_count(args)?;
+                let [place, dest] = check_intrinsic_arg_count(args)?;
                 let place = this.deref_pointer(place)?;
                 this.copy_op(dest, &place)?;
             }
 
             "volatile_set_memory" => {
-                let [ptr, val_byte, count] = check_arg_count(args)?;
+                let [ptr, val_byte, count] = check_intrinsic_arg_count(args)?;
                 this.write_bytes_intrinsic(ptr, val_byte, count, "volatile_set_memory")?;
             }
 
             // Memory model / provenance manipulation
             "ptr_mask" => {
-                let [ptr, mask] = check_arg_count(args)?;
+                let [ptr, mask] = check_intrinsic_arg_count(args)?;
 
                 let ptr = this.read_pointer(ptr)?;
                 let mask = this.read_target_usize(mask)?;
@@ -137,7 +138,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             // ```
             // Would not be considered UB, or the other way around (`is_val_statically_known(0)`).
             "is_val_statically_known" => {
-                let [_arg] = check_arg_count(args)?;
+                let [_arg] = check_intrinsic_arg_count(args)?;
                 // FIXME: should we check for validity here? It's tricky because we do not have a
                 // place. Codegen does not seem to set any attributes like `noundef` for intrinsic
                 // calls, so we don't *have* to do anything.
@@ -146,7 +147,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
 
             "floorf16" | "ceilf16" | "truncf16" | "roundf16" | "round_ties_even_f16" => {
-                let [f] = check_arg_count(args)?;
+                let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f16()?;
                 let mode = match intrinsic_name {
                     "floorf16" => Round::TowardNegative,
@@ -161,7 +162,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
             "floorf32" | "ceilf32" | "truncf32" | "roundf32" | "round_ties_even_f32" => {
-                let [f] = check_arg_count(args)?;
+                let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f32()?;
                 let mode = match intrinsic_name {
                     "floorf32" => Round::TowardNegative,
@@ -176,7 +177,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
             "floorf64" | "ceilf64" | "truncf64" | "roundf64" | "round_ties_even_f64" => {
-                let [f] = check_arg_count(args)?;
+                let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f64()?;
                 let mode = match intrinsic_name {
                     "floorf64" => Round::TowardNegative,
@@ -191,7 +192,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
             "floorf128" | "ceilf128" | "truncf128" | "roundf128" | "round_ties_even_f128" => {
-                let [f] = check_arg_count(args)?;
+                let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f128()?;
                 let mode = match intrinsic_name {
                     "floorf128" => Round::TowardNegative,
@@ -206,65 +207,98 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
 
+            "sqrtf32" => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f32()?;
+                // Sqrt is specified to be fully precise.
+                let res = math::sqrt(f);
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+            "sqrtf64" => {
+                let [f] = check_intrinsic_arg_count(args)?;
+                let f = this.read_scalar(f)?.to_f64()?;
+                // Sqrt is specified to be fully precise.
+                let res = math::sqrt(f);
+                let res = this.adjust_nan(res, &[f]);
+                this.write_scalar(res, dest)?;
+            }
+
             #[rustfmt::skip]
             | "sinf32"
             | "cosf32"
-            | "sqrtf32"
             | "expf32"
             | "exp2f32"
             | "logf32"
             | "log10f32"
             | "log2f32"
             => {
-                let [f] = check_arg_count(args)?;
+                let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f32()?;
-                // Using host floats except for sqrt (but it's fine, these operations do not have
+                // Using host floats (but it's fine, these operations do not have
                 // guaranteed precision).
+                let host = f.to_host();
                 let res = match intrinsic_name {
-                    "sinf32" => f.to_host().sin().to_soft(),
-                    "cosf32" => f.to_host().cos().to_soft(),
-                    "sqrtf32" => math::sqrt(f),
-                    "expf32" => f.to_host().exp().to_soft(),
-                    "exp2f32" => f.to_host().exp2().to_soft(),
-                    "logf32" => f.to_host().ln().to_soft(),
-                    "log10f32" => f.to_host().log10().to_soft(),
-                    "log2f32" => f.to_host().log2().to_soft(),
+                    "sinf32" => host.sin(),
+                    "cosf32" => host.cos(),
+                    "expf32" => host.exp(),
+                    "exp2f32" => host.exp2(),
+                    "logf32" => host.ln(),
+                    "log10f32" => host.log10(),
+                    "log2f32" => host.log2(),
                     _ => bug!(),
                 };
+                let res = res.to_soft();
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = apply_random_float_error_ulp(
+                //     this,
+                //     res,
+                //     4, // log2(16)
+                // );
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
             #[rustfmt::skip]
             | "sinf64"
             | "cosf64"
-            | "sqrtf64"
             | "expf64"
             | "exp2f64"
             | "logf64"
             | "log10f64"
             | "log2f64"
             => {
-                let [f] = check_arg_count(args)?;
+                let [f] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f64()?;
-                // Using host floats except for sqrt (but it's fine, these operations do not have
+                // Using host floats (but it's fine, these operations do not have
                 // guaranteed precision).
+                let host = f.to_host();
                 let res = match intrinsic_name {
-                    "sinf64" => f.to_host().sin().to_soft(),
-                    "cosf64" => f.to_host().cos().to_soft(),
-                    "sqrtf64" => math::sqrt(f),
-                    "expf64" => f.to_host().exp().to_soft(),
-                    "exp2f64" => f.to_host().exp2().to_soft(),
-                    "logf64" => f.to_host().ln().to_soft(),
-                    "log10f64" => f.to_host().log10().to_soft(),
-                    "log2f64" => f.to_host().log2().to_soft(),
+                    "sinf64" => host.sin(),
+                    "cosf64" => host.cos(),
+                    "expf64" => host.exp(),
+                    "exp2f64" => host.exp2(),
+                    "logf64" => host.ln(),
+                    "log10f64" => host.log10(),
+                    "log2f64" => host.log2(),
                     _ => bug!(),
                 };
+                let res = res.to_soft();
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = apply_random_float_error_ulp(
+                //     this,
+                //     res,
+                //     4, // log2(16)
+                // );
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
 
             "fmaf32" => {
-                let [a, b, c] = check_arg_count(args)?;
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
                 let a = this.read_scalar(a)?.to_f32()?;
                 let b = this.read_scalar(b)?.to_f32()?;
                 let c = this.read_scalar(c)?.to_f32()?;
@@ -274,7 +308,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
             "fmaf64" => {
-                let [a, b, c] = check_arg_count(args)?;
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
                 let a = this.read_scalar(a)?.to_f64()?;
                 let b = this.read_scalar(b)?.to_f64()?;
                 let c = this.read_scalar(c)?.to_f64()?;
@@ -285,7 +319,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
 
             "fmuladdf32" => {
-                let [a, b, c] = check_arg_count(args)?;
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
                 let a = this.read_scalar(a)?.to_f32()?;
                 let b = this.read_scalar(b)?.to_f32()?;
                 let c = this.read_scalar(c)?.to_f32()?;
@@ -300,7 +334,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
             "fmuladdf64" => {
-                let [a, b, c] = check_arg_count(args)?;
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
                 let a = this.read_scalar(a)?.to_f64()?;
                 let b = this.read_scalar(b)?.to_f64()?;
                 let c = this.read_scalar(c)?.to_f64()?;
@@ -316,7 +350,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
 
             "powf32" => {
-                let [f1, f2] = check_arg_count(args)?;
+                // FIXME: apply random relative error but without altering behaviour of powf
+                let [f1, f2] = check_intrinsic_arg_count(args)?;
                 let f1 = this.read_scalar(f1)?.to_f32()?;
                 let f2 = this.read_scalar(f2)?.to_f32()?;
                 // Using host floats (but it's fine, this operation does not have guaranteed precision).
@@ -325,7 +360,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
             "powf64" => {
-                let [f1, f2] = check_arg_count(args)?;
+                // FIXME: apply random relative error but without altering behaviour of powf
+                let [f1, f2] = check_intrinsic_arg_count(args)?;
                 let f1 = this.read_scalar(f1)?.to_f64()?;
                 let f2 = this.read_scalar(f2)?.to_f64()?;
                 // Using host floats (but it's fine, this operation does not have guaranteed precision).
@@ -335,7 +371,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
 
             "powif32" => {
-                let [f, i] = check_arg_count(args)?;
+                // FIXME: apply random relative error but without altering behaviour of powi
+                let [f, i] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f32()?;
                 let i = this.read_scalar(i)?.to_i32()?;
                 // Using host floats (but it's fine, this operation does not have guaranteed precision).
@@ -344,7 +381,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(res, dest)?;
             }
             "powif64" => {
-                let [f, i] = check_arg_count(args)?;
+                // FIXME: apply random relative error but without altering behaviour of powi
+                let [f, i] = check_intrinsic_arg_count(args)?;
                 let f = this.read_scalar(f)?.to_f64()?;
                 let i = this.read_scalar(i)?.to_i32()?;
                 // Using host floats (but it's fine, this operation does not have guaranteed precision).
@@ -360,7 +398,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             | "fdiv_algebraic"
             | "frem_algebraic"
             => {
-                let [a, b] = check_arg_count(args)?;
+                let [a, b] = check_intrinsic_arg_count(args)?;
                 let a = this.read_immediate(a)?;
                 let b = this.read_immediate(b)?;
                 let op = match intrinsic_name {
@@ -372,7 +410,10 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     _ => bug!(),
                 };
                 let res = this.binary_op(op, &a, &b)?;
-                // `binary_op` already called `generate_nan` if necessary.
+                // `binary_op` already called `generate_nan` if needed.
+                // Apply a relative error of 16ULP to simulate non-deterministic precision loss
+                // due to optimizations.
+                let res = apply_random_float_error_to_imm(this, res, 4 /* log2(16) */)?;
                 this.write_immediate(*res, dest)?;
             }
 
@@ -383,7 +424,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             | "fdiv_fast"
             | "frem_fast"
             => {
-                let [a, b] = check_arg_count(args)?;
+                let [a, b] = check_intrinsic_arg_count(args)?;
                 let a = this.read_immediate(a)?;
                 let b = this.read_immediate(b)?;
                 let op = match intrinsic_name {
@@ -418,16 +459,19 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     _ => {}
                 }
                 let res = this.binary_op(op, &a, &b)?;
+                // This cannot be a NaN so we also don't have to apply any non-determinism.
+                // (Also, `binary_op` already called `generate_nan` if needed.)
                 if !float_finite(&res)? {
                     throw_ub_format!("`{intrinsic_name}` intrinsic produced non-finite value as result");
                 }
-                // This cannot be a NaN so we also don't have to apply any non-determinism.
-                // (Also, `binary_op` already called `generate_nan` if needed.)
+                // Apply a relative error of 16ULP to simulate non-deterministic precision loss
+                // due to optimizations.
+                let res = apply_random_float_error_to_imm(this, res, 4 /* log2(16) */)?;
                 this.write_immediate(*res, dest)?;
             }
 
             "float_to_int_unchecked" => {
-                let [val] = check_arg_count(args)?;
+                let [val] = check_intrinsic_arg_count(args)?;
                 let val = this.read_immediate(val)?;
 
                 let res = this
@@ -444,7 +488,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
 
             // Other
             "breakpoint" => {
-                let [] = check_arg_count(args)?;
+                let [] = check_intrinsic_arg_count(args)?;
                 // normally this would raise a SIGTRAP, which aborts if no debugger is connected
                 throw_machine_stop!(TerminationInfo::Abort(format!("trace/breakpoint trap")))
             }
@@ -455,3 +499,26 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         interp_ok(EmulateItemResult::NeedsReturn)
     }
 }
+
+/// Applies a random 16ULP floating point error to `val` and returns the new value.
+/// Will fail if `val` is not a floating point number.
+fn apply_random_float_error_to_imm<'tcx>(
+    ecx: &mut MiriInterpCx<'tcx>,
+    val: ImmTy<'tcx>,
+    ulp_exponent: u32,
+) -> InterpResult<'tcx, ImmTy<'tcx>> {
+    let scalar = val.to_scalar_int()?;
+    let res: ScalarInt = match val.layout.ty.kind() {
+        ty::Float(FloatTy::F16) =>
+            apply_random_float_error_ulp(ecx, scalar.to_f16(), ulp_exponent).into(),
+        ty::Float(FloatTy::F32) =>
+            apply_random_float_error_ulp(ecx, scalar.to_f32(), ulp_exponent).into(),
+        ty::Float(FloatTy::F64) =>
+            apply_random_float_error_ulp(ecx, scalar.to_f64(), ulp_exponent).into(),
+        ty::Float(FloatTy::F128) =>
+            apply_random_float_error_ulp(ecx, scalar.to_f128(), ulp_exponent).into(),
+        _ => bug!("intrinsic called with non-float input type"),
+    };
+
+    interp_ok(ImmTy::from_scalar_int(res, val.layout))
+}
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index 45e316b190a6..de5da6ec898a 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -7,7 +7,9 @@ use rustc_middle::ty::layout::LayoutOf;
 use rustc_middle::{mir, ty};
 use rustc_span::{Symbol, sym};
 
-use crate::helpers::{ToHost, ToSoft, bool_to_simd_element, check_arg_count, simd_element_to_bool};
+use crate::helpers::{
+    ToHost, ToSoft, bool_to_simd_element, check_intrinsic_arg_count, simd_element_to_bool,
+};
 use crate::*;
 
 #[derive(Copy, Clone)]
@@ -50,7 +52,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             | "bswap"
             | "bitreverse"
             => {
-                let [op] = check_arg_count(args)?;
+                let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
                 let (dest, dest_len) = this.project_to_simd(dest)?;
 
@@ -197,7 +199,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             => {
                 use mir::BinOp;
 
-                let [left, right] = check_arg_count(args)?;
+                let [left, right] = check_intrinsic_arg_count(args)?;
                 let (left, left_len) = this.project_to_simd(left)?;
                 let (right, right_len) = this.project_to_simd(right)?;
                 let (dest, dest_len) = this.project_to_simd(dest)?;
@@ -288,7 +290,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
             "fma" | "relaxed_fma" => {
-                let [a, b, c] = check_arg_count(args)?;
+                let [a, b, c] = check_intrinsic_arg_count(args)?;
                 let (a, a_len) = this.project_to_simd(a)?;
                 let (b, b_len) = this.project_to_simd(b)?;
                 let (c, c_len) = this.project_to_simd(c)?;
@@ -352,7 +354,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             | "reduce_min" => {
                 use mir::BinOp;
 
-                let [op] = check_arg_count(args)?;
+                let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
 
                 let imm_from_bool =
@@ -415,7 +417,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             | "reduce_mul_ordered" => {
                 use mir::BinOp;
 
-                let [op, init] = check_arg_count(args)?;
+                let [op, init] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
                 let init = this.read_immediate(init)?;
 
@@ -433,7 +435,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_immediate(*res, dest)?;
             }
             "select" => {
-                let [mask, yes, no] = check_arg_count(args)?;
+                let [mask, yes, no] = check_intrinsic_arg_count(args)?;
                 let (mask, mask_len) = this.project_to_simd(mask)?;
                 let (yes, yes_len) = this.project_to_simd(yes)?;
                 let (no, no_len) = this.project_to_simd(no)?;
@@ -455,7 +457,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             // Variant of `select` that takes a bitmask rather than a "vector of bool".
             "select_bitmask" => {
-                let [mask, yes, no] = check_arg_count(args)?;
+                let [mask, yes, no] = check_intrinsic_arg_count(args)?;
                 let (yes, yes_len) = this.project_to_simd(yes)?;
                 let (no, no_len) = this.project_to_simd(no)?;
                 let (dest, dest_len) = this.project_to_simd(dest)?;
@@ -529,7 +531,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
             }
             // Converts a "vector of bool" into a bitmask.
             "bitmask" => {
-                let [op] = check_arg_count(args)?;
+                let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
                 let bitmask_len = op_len.next_multiple_of(8);
                 if bitmask_len > 64 {
@@ -577,7 +579,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
             "cast" | "as" | "cast_ptr" | "expose_provenance" | "with_exposed_provenance" => {
-                let [op] = check_arg_count(args)?;
+                let [op] = check_intrinsic_arg_count(args)?;
                 let (op, op_len) = this.project_to_simd(op)?;
                 let (dest, dest_len) = this.project_to_simd(dest)?;
 
@@ -633,8 +635,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this.write_immediate(*val, &dest)?;
                 }
             }
-            "shuffle_generic" => {
-                let [left, right] = check_arg_count(args)?;
+            "shuffle_const_generic" => {
+                let [left, right] = check_intrinsic_arg_count(args)?;
                 let (left, left_len) = this.project_to_simd(left)?;
                 let (right, right_len) = this.project_to_simd(right)?;
                 let (dest, dest_len) = this.project_to_simd(dest)?;
@@ -657,14 +659,14 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         this.read_immediate(&this.project_index(&right, right_idx)?)?
                     } else {
                         throw_ub_format!(
-                            "`simd_shuffle_generic` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
+                            "`simd_shuffle_const_generic` index {src_index} is out-of-bounds for 2 vectors with length {dest_len}"
                         );
                     };
                     this.write_immediate(*val, &dest)?;
                 }
             }
             "shuffle" => {
-                let [left, right, index] = check_arg_count(args)?;
+                let [left, right, index] = check_intrinsic_arg_count(args)?;
                 let (left, left_len) = this.project_to_simd(left)?;
                 let (right, right_len) = this.project_to_simd(right)?;
                 let (index, index_len) = this.project_to_simd(index)?;
@@ -695,7 +697,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
             "gather" => {
-                let [passthru, ptrs, mask] = check_arg_count(args)?;
+                let [passthru, ptrs, mask] = check_intrinsic_arg_count(args)?;
                 let (passthru, passthru_len) = this.project_to_simd(passthru)?;
                 let (ptrs, ptrs_len) = this.project_to_simd(ptrs)?;
                 let (mask, mask_len) = this.project_to_simd(mask)?;
@@ -721,7 +723,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
             "scatter" => {
-                let [value, ptrs, mask] = check_arg_count(args)?;
+                let [value, ptrs, mask] = check_intrinsic_arg_count(args)?;
                 let (value, value_len) = this.project_to_simd(value)?;
                 let (ptrs, ptrs_len) = this.project_to_simd(ptrs)?;
                 let (mask, mask_len) = this.project_to_simd(mask)?;
@@ -741,7 +743,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
             "masked_load" => {
-                let [mask, ptr, default] = check_arg_count(args)?;
+                let [mask, ptr, default] = check_intrinsic_arg_count(args)?;
                 let (mask, mask_len) = this.project_to_simd(mask)?;
                 let ptr = this.read_pointer(ptr)?;
                 let (default, default_len) = this.project_to_simd(default)?;
@@ -767,7 +769,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 }
             }
             "masked_store" => {
-                let [mask, ptr, vals] = check_arg_count(args)?;
+                let [mask, ptr, vals] = check_intrinsic_arg_count(args)?;
                 let (mask, mask_len) = this.project_to_simd(mask)?;
                 let ptr = this.read_pointer(ptr)?;
                 let (vals, vals_len) = this.project_to_simd(vals)?;
diff --git a/src/tools/miri/src/lib.rs b/src/tools/miri/src/lib.rs
index 89ad803ac3be..0bf5ae87f383 100644
--- a/src/tools/miri/src/lib.rs
+++ b/src/tools/miri/src/lib.rs
@@ -1,4 +1,5 @@
 #![feature(rustc_private)]
+#![feature(cfg_match)]
 #![feature(cell_update)]
 #![feature(float_gamma)]
 #![feature(float_erf)]
@@ -15,7 +16,6 @@
 #![feature(unqualified_local_imports)]
 #![feature(derive_coerce_pointee)]
 #![feature(arbitrary_self_types)]
-#![feature(extract_if)]
 // Configure clippy and other lints
 #![allow(
     clippy::collapsible_else_if,
diff --git a/src/tools/miri/src/machine.rs b/src/tools/miri/src/machine.rs
index 6bd1076a8a84..4ece8f7895de 100644
--- a/src/tools/miri/src/machine.rs
+++ b/src/tools/miri/src/machine.rs
@@ -713,12 +713,13 @@ impl<'tcx> MiriMachine<'tcx> {
             clock: Clock::new(config.isolated_op == IsolatedOp::Allow),
             #[cfg(unix)]
             native_lib: config.native_lib.as_ref().map(|lib_file_path| {
+                let host_triple = rustc_session::config::host_tuple();
                 let target_triple = tcx.sess.opts.target_triple.tuple();
                 // Check if host target == the session target.
-                if env!("TARGET") != target_triple {
+                if host_triple != target_triple {
                     panic!(
                         "calling external C functions in linked .so file requires host and target to be the same: host={}, target={}",
-                        env!("TARGET"),
+                        host_triple,
                         target_triple,
                     );
                 }
diff --git a/src/tools/miri/src/math.rs b/src/tools/miri/src/math.rs
index 7117f722fee8..fdd021f85394 100644
--- a/src/tools/miri/src/math.rs
+++ b/src/tools/miri/src/math.rs
@@ -27,6 +27,22 @@ pub(crate) fn apply_random_float_error<F: rustc_apfloat::Float>(
     (val * (F::from_u128(1).value + err).value).value
 }
 
+/// [`apply_random_float_error`] gives instructions to apply a 2^N ULP error.
+/// This function implements these instructions such that applying a 2^N ULP error is less error prone.
+/// So for a 2^N ULP error, you would pass N as the `ulp_exponent` argument.
+pub(crate) fn apply_random_float_error_ulp<F: rustc_apfloat::Float>(
+    ecx: &mut crate::MiriInterpCx<'_>,
+    val: F,
+    ulp_exponent: u32,
+) -> F {
+    let n = i32::try_from(ulp_exponent)
+        .expect("`err_scale_for_ulp`: exponent is too large to create an error scale");
+    // we know this fits
+    let prec = i32::try_from(F::PRECISION).unwrap();
+    let err_scale = -(prec - n - 1);
+    apply_random_float_error(ecx, val, err_scale)
+}
+
 pub(crate) fn sqrt<S: rustc_apfloat::ieee::Semantics>(x: IeeeFloat<S>) -> IeeeFloat<S> {
     match x.category() {
         // preserve zero sign
diff --git a/src/tools/miri/src/shims/aarch64.rs b/src/tools/miri/src/shims/aarch64.rs
new file mode 100644
index 000000000000..7cccc9e51d8e
--- /dev/null
+++ b/src/tools/miri/src/shims/aarch64.rs
@@ -0,0 +1,78 @@
+use rustc_middle::mir::BinOp;
+use rustc_middle::ty::Ty;
+use rustc_span::Symbol;
+use rustc_target::callconv::{Conv, FnAbi};
+
+use crate::*;
+
+impl<'tcx> EvalContextExt<'tcx> for crate::MiriInterpCx<'tcx> {}
+pub(super) trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
+    fn emulate_aarch64_intrinsic(
+        &mut self,
+        link_name: Symbol,
+        abi: &FnAbi<'tcx, Ty<'tcx>>,
+        args: &[OpTy<'tcx>],
+        dest: &MPlaceTy<'tcx>,
+    ) -> InterpResult<'tcx, EmulateItemResult> {
+        let this = self.eval_context_mut();
+        // Prefix should have already been checked.
+        let unprefixed_name = link_name.as_str().strip_prefix("llvm.aarch64.").unwrap();
+        match unprefixed_name {
+            "isb" => {
+                let [arg] = this.check_shim(abi, Conv::C, link_name, args)?;
+                let arg = this.read_scalar(arg)?.to_i32()?;
+                match arg {
+                    // SY ("full system scope")
+                    15 => {
+                        this.yield_active_thread();
+                    }
+                    _ => {
+                        throw_unsup_format!("unsupported llvm.aarch64.isb argument {}", arg);
+                    }
+                }
+            }
+
+            // Used to implement the vpmaxq_u8 function.
+            // Computes the maximum of adjacent pairs; the first half of the output is produced from the
+            // `left` input, the second half of the output from the `right` input.
+            // https://developer.arm.com/architectures/instruction-sets/intrinsics/vpmaxq_u8
+            "neon.umaxp.v16i8" => {
+                let [left, right] = this.check_shim(abi, Conv::C, link_name, args)?;
+
+                let (left, left_len) = this.project_to_simd(left)?;
+                let (right, right_len) = this.project_to_simd(right)?;
+                let (dest, lane_count) = this.project_to_simd(dest)?;
+                assert_eq!(left_len, right_len);
+                assert_eq!(lane_count, left_len);
+
+                for lane_idx in 0..lane_count {
+                    let src = if lane_idx < (lane_count / 2) { &left } else { &right };
+                    let src_idx = lane_idx.strict_rem(lane_count / 2);
+
+                    let lhs_lane =
+                        this.read_immediate(&this.project_index(src, src_idx.strict_mul(2))?)?;
+                    let rhs_lane = this.read_immediate(
+                        &this.project_index(src, src_idx.strict_mul(2).strict_add(1))?,
+                    )?;
+
+                    // Compute `if lhs > rhs { lhs } else { rhs }`, i.e., `max`.
+                    let res_lane = if this
+                        .binary_op(BinOp::Gt, &lhs_lane, &rhs_lane)?
+                        .to_scalar()
+                        .to_bool()?
+                    {
+                        lhs_lane
+                    } else {
+                        rhs_lane
+                    };
+
+                    let dest = this.project_index(&dest, lane_idx)?;
+                    this.write_immediate(*res_lane, &dest)?;
+                }
+            }
+
+            _ => return interp_ok(EmulateItemResult::NotSupported),
+        }
+        interp_ok(EmulateItemResult::NeedsReturn)
+    }
+}
diff --git a/src/tools/miri/src/shims/foreign_items.rs b/src/tools/miri/src/shims/foreign_items.rs
index bedc1ebdc950..505c079143a4 100644
--- a/src/tools/miri/src/shims/foreign_items.rs
+++ b/src/tools/miri/src/shims/foreign_items.rs
@@ -766,6 +766,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     _ => bug!(),
                 };
                 let res = res.to_soft();
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = math::apply_random_float_error_ulp(
+                //     this,
+                //     res,
+                //     4, // log2(16)
+                // );
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
@@ -788,6 +796,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     "fdimf" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
                     _ => bug!(),
                 };
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = math::apply_random_float_error_ulp(
+                //     this,
+                //     res,
+                //     4, // log2(16)
+                // );
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
             }
@@ -827,6 +843,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     _ => bug!(),
                 };
                 let res = res.to_soft();
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = math::apply_random_float_error_ulp(
+                //     this,
+                //     res.to_soft(),
+                //     4, // log2(16)
+                // );
                 let res = this.adjust_nan(res, &[f]);
                 this.write_scalar(res, dest)?;
             }
@@ -849,6 +873,14 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     "fdim" => f1.to_host().abs_sub(f2.to_host()).to_soft(),
                     _ => bug!(),
                 };
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = math::apply_random_float_error_ulp(
+                //     this,
+                //     res,
+                //     4, // log2(16)
+                // );
                 let res = this.adjust_nan(res, &[f1, f2]);
                 this.write_scalar(res, dest)?;
             }
@@ -874,7 +906,12 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Using host floats (but it's fine, these operations do not have guaranteed precision).
                 let (res, sign) = x.to_host().ln_gamma();
                 this.write_int(sign, &signp)?;
-                let res = this.adjust_nan(res.to_soft(), &[x]);
+                let res = res.to_soft();
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = math::apply_random_float_error_ulp(this, res, 4 /* log2(16) */);
+                let res = this.adjust_nan(res, &[x]);
                 this.write_scalar(res, dest)?;
             }
             "lgamma_r" => {
@@ -885,7 +922,12 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Using host floats (but it's fine, these operations do not have guaranteed precision).
                 let (res, sign) = x.to_host().ln_gamma();
                 this.write_int(sign, &signp)?;
-                let res = this.adjust_nan(res.to_soft(), &[x]);
+                let res = res.to_soft();
+                // Apply a relative error of 16ULP to introduce some non-determinism
+                // simulating imprecise implementations and optimizations.
+                // FIXME: temporarily disabled as it breaks std tests.
+                // let res = math::apply_random_float_error_ulp(this, res, 4 /* log2(16) */);
+                let res = this.adjust_nan(res, &[x]);
                 this.write_scalar(res, dest)?;
             }
 
@@ -947,20 +989,12 @@ trait EvalContextExtPriv<'tcx>: crate::MiriInterpCxExt<'tcx> {
                     this, link_name, abi, args, dest,
                 );
             }
-            // FIXME: Move these to an `arm` submodule.
-            "llvm.aarch64.isb" if this.tcx.sess.target.arch == "aarch64" => {
-                let [arg] = this.check_shim(abi, Conv::C, link_name, args)?;
-                let arg = this.read_scalar(arg)?.to_i32()?;
-                match arg {
-                    // SY ("full system scope")
-                    15 => {
-                        this.yield_active_thread();
-                    }
-                    _ => {
-                        throw_unsup_format!("unsupported llvm.aarch64.isb argument {}", arg);
-                    }
-                }
+            name if name.starts_with("llvm.aarch64.") && this.tcx.sess.target.arch == "aarch64" => {
+                return shims::aarch64::EvalContextExt::emulate_aarch64_intrinsic(
+                    this, link_name, abi, args, dest,
+                );
             }
+            // FIXME: Move this to an `arm` submodule.
             "llvm.arm.hint" if this.tcx.sess.target.arch == "arm" => {
                 let [arg] = this.check_shim(abi, Conv::C, link_name, args)?;
                 let arg = this.read_scalar(arg)?.to_i32()?;
diff --git a/src/tools/miri/src/shims/mod.rs b/src/tools/miri/src/shims/mod.rs
index 61681edcf762..b498551ace34 100644
--- a/src/tools/miri/src/shims/mod.rs
+++ b/src/tools/miri/src/shims/mod.rs
@@ -1,5 +1,6 @@
 #![warn(clippy::arithmetic_side_effects)]
 
+mod aarch64;
 mod alloc;
 mod backtrace;
 mod files;
diff --git a/src/tools/miri/src/shims/panic.rs b/src/tools/miri/src/shims/panic.rs
index 83f331bb173d..fc58d88591f8 100644
--- a/src/tools/miri/src/shims/panic.rs
+++ b/src/tools/miri/src/shims/panic.rs
@@ -15,7 +15,7 @@ use rustc_abi::ExternAbi;
 use rustc_middle::{mir, ty};
 use rustc_target::spec::PanicStrategy;
 
-use self::helpers::check_arg_count;
+use self::helpers::check_intrinsic_arg_count;
 use crate::*;
 
 /// Holds all of the relevant data for when unwinding hits a `try` frame.
@@ -77,7 +77,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
         // a pointer to `Box<dyn Any + Send + 'static>`.
 
         // Get all the arguments.
-        let [try_fn, data, catch_fn] = check_arg_count(args)?;
+        let [try_fn, data, catch_fn] = check_intrinsic_arg_count(args)?;
         let try_fn = this.read_pointer(try_fn)?;
         let data = this.read_immediate(data)?;
         let catch_fn = this.read_pointer(catch_fn)?;
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index d459ec7cb774..09757071075a 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -815,7 +815,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.handle_miri_start_unwind(payload)?;
                 return interp_ok(EmulateItemResult::NeedsUnwind);
             }
-            "getuid" => {
+            "getuid" | "geteuid" => {
                 let [] = this.check_shim(abi, Conv::C, link_name, args)?;
                 // For now, just pretend we always have this fixed UID.
                 this.write_int(UID, dest)?;
diff --git a/src/tools/miri/src/shims/unix/fs.rs b/src/tools/miri/src/shims/unix/fs.rs
index c7399b00d3fe..f8e0c638c90d 100644
--- a/src/tools/miri/src/shims/unix/fs.rs
+++ b/src/tools/miri/src/shims/unix/fs.rs
@@ -178,92 +178,91 @@ impl UnixFileDescription for FileHandle {
         op: FlockOp,
     ) -> InterpResult<'tcx, io::Result<()>> {
         assert!(communicate_allowed, "isolation should have prevented even opening a file");
-        #[cfg(target_family = "unix")]
-        {
-            use std::os::fd::AsRawFd;
+        cfg_match! {
+            all(target_family = "unix", not(target_os = "solaris")) => {
+                use std::os::fd::AsRawFd;
 
-            use FlockOp::*;
-            // We always use non-blocking call to prevent interpreter from being blocked
-            let (host_op, lock_nb) = match op {
-                SharedLock { nonblocking } => (libc::LOCK_SH | libc::LOCK_NB, nonblocking),
-                ExclusiveLock { nonblocking } => (libc::LOCK_EX | libc::LOCK_NB, nonblocking),
-                Unlock => (libc::LOCK_UN, false),
-            };
+                use FlockOp::*;
+                // We always use non-blocking call to prevent interpreter from being blocked
+                let (host_op, lock_nb) = match op {
+                    SharedLock { nonblocking } => (libc::LOCK_SH | libc::LOCK_NB, nonblocking),
+                    ExclusiveLock { nonblocking } => (libc::LOCK_EX | libc::LOCK_NB, nonblocking),
+                    Unlock => (libc::LOCK_UN, false),
+                };
 
-            let fd = self.file.as_raw_fd();
-            let ret = unsafe { libc::flock(fd, host_op) };
-            let res = match ret {
-                0 => Ok(()),
-                -1 => {
-                    let err = io::Error::last_os_error();
-                    if !lock_nb && err.kind() == io::ErrorKind::WouldBlock {
-                        throw_unsup_format!("blocking `flock` is not currently supported");
-                    }
-                    Err(err)
-                }
-                ret => panic!("Unexpected return value from flock: {ret}"),
-            };
-            interp_ok(res)
-        }
-
-        #[cfg(target_family = "windows")]
-        {
-            use std::os::windows::io::AsRawHandle;
-
-            use windows_sys::Win32::Foundation::{
-                ERROR_IO_PENDING, ERROR_LOCK_VIOLATION, FALSE, HANDLE, TRUE,
-            };
-            use windows_sys::Win32::Storage::FileSystem::{
-                LOCKFILE_EXCLUSIVE_LOCK, LOCKFILE_FAIL_IMMEDIATELY, LockFileEx, UnlockFile,
-            };
-
-            let fh = self.file.as_raw_handle() as HANDLE;
-
-            use FlockOp::*;
-            let (ret, lock_nb) = match op {
-                SharedLock { nonblocking } | ExclusiveLock { nonblocking } => {
-                    // We always use non-blocking call to prevent interpreter from being blocked
-                    let mut flags = LOCKFILE_FAIL_IMMEDIATELY;
-                    if matches!(op, ExclusiveLock { .. }) {
-                        flags |= LOCKFILE_EXCLUSIVE_LOCK;
-                    }
-                    let ret = unsafe { LockFileEx(fh, flags, 0, !0, !0, &mut std::mem::zeroed()) };
-                    (ret, nonblocking)
-                }
-                Unlock => {
-                    let ret = unsafe { UnlockFile(fh, 0, 0, !0, !0) };
-                    (ret, false)
-                }
-            };
-
-            let res = match ret {
-                TRUE => Ok(()),
-                FALSE => {
-                    let mut err = io::Error::last_os_error();
-                    // This only runs on Windows hosts so we can use `raw_os_error`.
-                    // We have to be careful not to forward that error code to target code.
-                    let code: u32 = err.raw_os_error().unwrap().try_into().unwrap();
-                    if matches!(code, ERROR_IO_PENDING | ERROR_LOCK_VIOLATION) {
-                        if lock_nb {
-                            // The io error mapping does not know about these error codes,
-                            // so we translate it to `WouldBlock` manually.
-                            let desc = format!("LockFileEx wouldblock error: {err}");
-                            err = io::Error::new(io::ErrorKind::WouldBlock, desc);
-                        } else {
+                let fd = self.file.as_raw_fd();
+                let ret = unsafe { libc::flock(fd, host_op) };
+                let res = match ret {
+                    0 => Ok(()),
+                    -1 => {
+                        let err = io::Error::last_os_error();
+                        if !lock_nb && err.kind() == io::ErrorKind::WouldBlock {
                             throw_unsup_format!("blocking `flock` is not currently supported");
                         }
+                        Err(err)
                     }
-                    Err(err)
-                }
-                _ => panic!("Unexpected return value: {ret}"),
-            };
-            interp_ok(res)
-        }
+                    ret => panic!("Unexpected return value from flock: {ret}"),
+                };
+                interp_ok(res)
+            }
+            target_family = "windows" => {
+                use std::os::windows::io::AsRawHandle;
 
-        #[cfg(not(any(target_family = "unix", target_family = "windows")))]
-        {
-            let _ = op;
-            compile_error!("flock is supported only on UNIX and Windows hosts");
+                use windows_sys::Win32::Foundation::{
+                    ERROR_IO_PENDING, ERROR_LOCK_VIOLATION, FALSE, HANDLE, TRUE,
+                };
+                use windows_sys::Win32::Storage::FileSystem::{
+                    LOCKFILE_EXCLUSIVE_LOCK, LOCKFILE_FAIL_IMMEDIATELY, LockFileEx, UnlockFile,
+                };
+
+                let fh = self.file.as_raw_handle() as HANDLE;
+
+                use FlockOp::*;
+                let (ret, lock_nb) = match op {
+                    SharedLock { nonblocking } | ExclusiveLock { nonblocking } => {
+                        // We always use non-blocking call to prevent interpreter from being blocked
+                        let mut flags = LOCKFILE_FAIL_IMMEDIATELY;
+                        if matches!(op, ExclusiveLock { .. }) {
+                            flags |= LOCKFILE_EXCLUSIVE_LOCK;
+                        }
+                        let ret = unsafe { LockFileEx(fh, flags, 0, !0, !0, &mut std::mem::zeroed()) };
+                        (ret, nonblocking)
+                    }
+                    Unlock => {
+                        let ret = unsafe { UnlockFile(fh, 0, 0, !0, !0) };
+                        (ret, false)
+                    }
+                };
+
+                let res = match ret {
+                    TRUE => Ok(()),
+                    FALSE => {
+                        let mut err = io::Error::last_os_error();
+                        // This only runs on Windows hosts so we can use `raw_os_error`.
+                        // We have to be careful not to forward that error code to target code.
+                        let code: u32 = err.raw_os_error().unwrap().try_into().unwrap();
+                        if matches!(code, ERROR_IO_PENDING | ERROR_LOCK_VIOLATION) {
+                            if lock_nb {
+                                // The io error mapping does not know about these error codes,
+                                // so we translate it to `WouldBlock` manually.
+                                let desc = format!("LockFileEx wouldblock error: {err}");
+                                err = io::Error::new(io::ErrorKind::WouldBlock, desc);
+                            } else {
+                                throw_unsup_format!("blocking `flock` is not currently supported");
+                            }
+                        }
+                        Err(err)
+                    }
+                    _ => panic!("Unexpected return value: {ret}"),
+                };
+                interp_ok(res)
+            }
+            _ => {
+                let _ = op;
+                throw_unsup_format!(
+                    "flock is supported only on UNIX (except Solaris) and Windows hosts"
+                );
+            }
         }
     }
 }
diff --git a/src/tools/miri/src/shims/unix/linux/foreign_items.rs b/src/tools/miri/src/shims/unix/linux/foreign_items.rs
index 10af245dcc08..f5da7b0170b6 100644
--- a/src/tools/miri/src/shims/unix/linux/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/linux/foreign_items.rs
@@ -133,8 +133,8 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 this.write_scalar(ptr, dest)?;
             }
             "mremap" => {
-                let [old_address, old_size, new_size, flags] =
-                    this.check_shim(abi, Conv::C, link_name, args)?;
+                let ([old_address, old_size, new_size, flags], _) =
+                    this.check_shim_variadic(abi, Conv::C, link_name, args)?;
                 let ptr = this.mremap(old_address, old_size, new_size, flags)?;
                 this.write_scalar(ptr, dest)?;
             }
diff --git a/src/tools/miri/src/shims/unix/linux_like/sync.rs b/src/tools/miri/src/shims/unix/linux_like/sync.rs
index 280bee4800fe..86e8b57824c2 100644
--- a/src/tools/miri/src/shims/unix/linux_like/sync.rs
+++ b/src/tools/miri/src/shims/unix/linux_like/sync.rs
@@ -13,14 +13,6 @@ pub fn futex<'tcx>(
     varargs: &[OpTy<'tcx>],
     dest: &MPlaceTy<'tcx>,
 ) -> InterpResult<'tcx> {
-    // The amount of arguments used depends on the type of futex operation.
-    // The full futex syscall takes six arguments (excluding the syscall
-    // number), which is also the maximum amount of arguments a linux syscall
-    // can take on most architectures.
-    // However, not all futex operations use all six arguments. The unused ones
-    // may or may not be left out from the `syscall()` call.
-    // Therefore we don't use `check_arg_count` here, but only check for the
-    // number of arguments to fall within a range.
     let [addr, op, val] = check_min_vararg_count("`syscall(SYS_futex, ...)`", varargs)?;
 
     // The first three arguments (after the syscall number itself) are the same to all futex operations:
diff --git a/src/tools/miri/tests/fail/erroneous_const.stderr b/src/tools/miri/tests/fail/erroneous_const.stderr
index 3528620cb6a8..2906ac6b20a7 100644
--- a/src/tools/miri/tests/fail/erroneous_const.stderr
+++ b/src/tools/miri/tests/fail/erroneous_const.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `PrintName::<i32>::VOID` failed
   --> tests/fail/erroneous_const.rs:LL:CC
    |
 LL |     const VOID: ! = panic!();
-   |                     ^^^^^^^^ the evaluated program panicked at 'explicit panic', tests/fail/erroneous_const.rs:LL:CC
+   |                     ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.rs b/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.rs
index 967a78bf8318..db7bd223bd45 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.rs
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.rs
@@ -5,6 +5,6 @@ fn main() {
 
     unsafe {
         abort(1);
-        //~^ ERROR: Undefined Behavior: incorrect number of arguments: got 1, expected 0
+        //~^ ERROR: Undefined Behavior: incorrect number of arguments for `abort`: got 1, expected 0
     }
 }
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr b/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr
index 687d0538b3c7..3c81ba4e1417 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_abort.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: incorrect number of arguments: got 1, expected 0
+error: Undefined Behavior: incorrect number of arguments for `abort`: got 1, expected 0
   --> tests/fail/function_calls/check_arg_count_abort.rs:LL:CC
    |
 LL |         abort(1);
-   |         ^^^^^^^^ incorrect number of arguments: got 1, expected 0
+   |         ^^^^^^^^ incorrect number of arguments for `abort`: got 1, expected 0
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.rs b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.rs
index 223c95ffca46..41aebea2d8ad 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.rs
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.rs
@@ -4,6 +4,6 @@ fn main() {
     }
 
     unsafe {
-        let _ = malloc(); //~ ERROR: Undefined Behavior: incorrect number of arguments: got 0, expected 1
+        let _ = malloc(); //~ ERROR: Undefined Behavior: incorrect number of arguments for `malloc`: got 0, expected 1
     };
 }
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr
index d778eae64fa4..eacd4045ae05 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_few_args.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: incorrect number of arguments: got 0, expected 1
+error: Undefined Behavior: incorrect number of arguments for `malloc`: got 0, expected 1
   --> tests/fail/function_calls/check_arg_count_too_few_args.rs:LL:CC
    |
 LL |         let _ = malloc();
-   |                 ^^^^^^^^ incorrect number of arguments: got 0, expected 1
+   |                 ^^^^^^^^ incorrect number of arguments for `malloc`: got 0, expected 1
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.rs b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.rs
index 7ee9c40bf7a4..1f5c509c6666 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.rs
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.rs
@@ -4,6 +4,6 @@ fn main() {
     }
 
     unsafe {
-        let _ = malloc(1, 2); //~ ERROR: Undefined Behavior: incorrect number of arguments: got 2, expected 1
+        let _ = malloc(1, 2); //~ ERROR: Undefined Behavior: incorrect number of arguments for `malloc`: got 2, expected 1
     };
 }
diff --git a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr
index dfec2a862870..42d5e98c01af 100644
--- a/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr
+++ b/src/tools/miri/tests/fail/function_calls/check_arg_count_too_many_args.stderr
@@ -1,8 +1,8 @@
-error: Undefined Behavior: incorrect number of arguments: got 2, expected 1
+error: Undefined Behavior: incorrect number of arguments for `malloc`: got 2, expected 1
   --> tests/fail/function_calls/check_arg_count_too_many_args.rs:LL:CC
    |
 LL |         let _ = malloc(1, 2);
-   |                 ^^^^^^^^^^^^ incorrect number of arguments: got 2, expected 1
+   |                 ^^^^^^^^^^^^ incorrect number of arguments for `malloc`: got 2, expected 1
    |
    = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
    = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
diff --git a/src/tools/miri/tests/fail/shims/vararg_caller_signature_mismatch.rs b/src/tools/miri/tests/fail/shims/vararg_caller_signature_mismatch.rs
new file mode 100644
index 000000000000..515e467fb54d
--- /dev/null
+++ b/src/tools/miri/tests/fail/shims/vararg_caller_signature_mismatch.rs
@@ -0,0 +1,14 @@
+//@ignore-target: windows # No libc pipe on Windows
+
+// Declare a non-variadic function as variadic.
+extern "C" {
+    fn pipe(fds: *mut std::ffi::c_int, ...) -> std::ffi::c_int;
+}
+
+// Test the error caused by invoking non-vararg shim with a vararg import.
+fn main() {
+    let mut fds = [-1, -1];
+    let res = unsafe { pipe(fds.as_mut_ptr()) };
+    //~^ ERROR: calling a non-variadic function with a variadic caller-side signature
+    assert_eq!(res, 0);
+}
diff --git a/src/tools/miri/tests/fail/shims/vararg_caller_signature_mismatch.stderr b/src/tools/miri/tests/fail/shims/vararg_caller_signature_mismatch.stderr
new file mode 100644
index 000000000000..2782f3b3269c
--- /dev/null
+++ b/src/tools/miri/tests/fail/shims/vararg_caller_signature_mismatch.stderr
@@ -0,0 +1,15 @@
+error: Undefined Behavior: calling a non-variadic function with a variadic caller-side signature
+  --> tests/fail/shims/vararg_caller_signature_mismatch.rs:LL:CC
+   |
+LL |     let res = unsafe { pipe(fds.as_mut_ptr()) };
+   |                        ^^^^^^^^^^^^^^^^^^^^^^ calling a non-variadic function with a variadic caller-side signature
+   |
+   = help: this indicates a bug in the program: it performed an invalid operation, and caused Undefined Behavior
+   = help: see https://doc.rust-lang.org/nightly/reference/behavior-considered-undefined.html for further information
+   = note: BACKTRACE:
+   = note: inside `main` at tests/fail/shims/vararg_caller_signature_mismatch.rs:LL:CC
+
+note: some details are omitted, run with `MIRIFLAGS=-Zmiri-backtrace=full` for a verbose backtrace
+
+error: aborting due to 1 previous error
+
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-misc.rs b/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
index f07007fa7054..d1c0085b024a 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-misc.rs
@@ -78,11 +78,16 @@ fn test_getuid() {
     let _val = unsafe { libc::getuid() };
 }
 
+fn test_geteuid() {
+    let _val = unsafe { libc::geteuid() };
+}
+
 fn main() {
     test_thread_local_errno();
     test_environ();
     test_dlsym();
     test_getuid();
+    test_geteuid();
 
     #[cfg(target_os = "linux")]
     test_sigrt();
diff --git a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
index bbf0e2159530..9163fd3d06fa 100644
--- a/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
+++ b/src/tools/miri/tests/pass-dep/libc/libc-socketpair.rs
@@ -88,8 +88,7 @@ fn test_socketpair_threaded() {
         assert_eq!(res, 5);
         assert_eq!(buf, "abcde".as_bytes());
     });
-    // FIXME: we should yield here once blocking is implemented.
-    //thread::yield_now();
+    thread::yield_now();
     let data = "abcde".as_bytes().as_ptr();
     let res = unsafe { libc::write(fds[0], data as *const libc::c_void, 5) };
     assert_eq!(res, 5);
@@ -97,14 +96,11 @@ fn test_socketpair_threaded() {
 
     // Read and write from different direction
     let thread2 = thread::spawn(move || {
-        // FIXME: we should yield here once blocking is implemented.
-        //thread::yield_now();
+        thread::yield_now();
         let data = "12345".as_bytes().as_ptr();
         let res = unsafe { libc::write(fds[1], data as *const libc::c_void, 5) };
         assert_eq!(res, 5);
     });
-    // FIXME: we should not yield here once blocking is implemented.
-    thread::yield_now();
     let mut buf: [u8; 5] = [0; 5];
     let res = unsafe { libc::read(fds[0], buf.as_mut_ptr().cast(), buf.len() as libc::size_t) };
     assert_eq!(res, 5);
diff --git a/src/tools/miri/tests/pass/float.rs b/src/tools/miri/tests/pass/float.rs
index 51cafbb3f43b..b3b6fe1a5d73 100644
--- a/src/tools/miri/tests/pass/float.rs
+++ b/src/tools/miri/tests/pass/float.rs
@@ -13,11 +13,34 @@ use std::fmt::{Debug, Display, LowerHex};
 use std::hint::black_box;
 use std::{f32, f64};
 
+/// Compare the two floats, allowing for $ulp many ULPs of error.
+///
+/// ULP means "Units in the Last Place" or "Units of Least Precision".
+/// The ULP of a float `a`` is the smallest possible change at `a`, so the ULP difference represents how
+/// many discrete floating-point steps are needed to reach the actual value from the expected value.
+///
+/// Essentially ULP can be seen as a distance metric of floating-point numbers, but with
+/// the same amount of "spacing" between all consecutive representable values. So even though 2 very large floating point numbers
+/// have a large value difference, their ULP can still be 1, so they are still "approximatly equal",
+/// but the EPSILON check would have failed.
 macro_rules! assert_approx_eq {
-    ($a:expr, $b:expr) => {{
-        let (a, b) = (&$a, &$b);
-        assert!((*a - *b).abs() < 1.0e-6, "{} is not approximately equal to {}", *a, *b);
+    ($a:expr, $b:expr, $ulp:expr) => {{
+        let (actual, expected) = ($a, $b);
+        let allowed_ulp_diff = $ulp;
+        let _force_same_type = actual == expected;
+        // Approximate the ULP by taking half the distance between the number one place "up"
+        // and the number one place "down".
+        let ulp = (expected.next_up() - expected.next_down()) / 2.0;
+        let ulp_diff = ((actual - expected) / ulp).abs().round() as i32;
+        if ulp_diff > allowed_ulp_diff {
+            panic!("{actual:?} is not approximately equal to {expected:?}\ndifference in ULP: {ulp_diff} > {allowed_ulp_diff}");
+        };
     }};
+
+    ($a:expr, $b: expr) => {
+        // accept up to 64ULP (16ULP for host floats and 16ULP for miri artificial error and 32 for any rounding errors)
+        assert_approx_eq!($a, $b, 64);
+    };
 }
 
 fn main() {
@@ -33,6 +56,7 @@ fn main() {
     test_algebraic();
     test_fmuladd();
     test_min_max_nondet();
+    test_non_determinism();
 }
 
 trait Float: Copy + PartialEq + Debug {
@@ -1029,7 +1053,7 @@ pub fn libm() {
     assert_approx_eq!(f64::consts::FRAC_PI_4.sin().asin(), f64::consts::FRAC_PI_4);
 
     assert_approx_eq!(1.0f32.sinh(), 1.1752012f32);
-    assert_approx_eq!(1.0f64.sinh(), 1.1752012f64);
+    assert_approx_eq!(1.0f64.sinh(), 1.1752011936438014f64);
     assert_approx_eq!(2.0f32.asinh(), 1.443635475178810342493276740273105f32);
     assert_approx_eq!((-2.0f64).asinh(), -1.443635475178810342493276740273105f64);
 
@@ -1041,12 +1065,12 @@ pub fn libm() {
     assert_approx_eq!(f64::consts::FRAC_PI_4.cos().acos(), f64::consts::FRAC_PI_4);
 
     assert_approx_eq!(1.0f32.cosh(), 1.54308f32);
-    assert_approx_eq!(1.0f64.cosh(), 1.54308f64);
+    assert_approx_eq!(1.0f64.cosh(), 1.5430806348152437f64);
     assert_approx_eq!(2.0f32.acosh(), 1.31695789692481670862504634730796844f32);
     assert_approx_eq!(3.0f64.acosh(), 1.76274717403908605046521864995958461f64);
 
     assert_approx_eq!(1.0f32.tan(), 1.557408f32);
-    assert_approx_eq!(1.0f64.tan(), 1.557408f64);
+    assert_approx_eq!(1.0f64.tan(), 1.5574077246549023f64);
     assert_approx_eq!(1.0_f32, 1.0_f32.tan().atan());
     assert_approx_eq!(1.0_f64, 1.0_f64.tan().atan());
     assert_approx_eq!(1.0f32.atan2(2.0f32), 0.46364761f32);
@@ -1091,11 +1115,11 @@ fn test_fast() {
     pub fn test_operations_f16(a: f16, b: f16) {
         // make sure they all map to the correct operation
         unsafe {
-            assert_eq!(fadd_fast(a, b), a + b);
-            assert_eq!(fsub_fast(a, b), a - b);
-            assert_eq!(fmul_fast(a, b), a * b);
-            assert_eq!(fdiv_fast(a, b), a / b);
-            assert_eq!(frem_fast(a, b), a % b);
+            assert_approx_eq!(fadd_fast(a, b), a + b);
+            assert_approx_eq!(fsub_fast(a, b), a - b);
+            assert_approx_eq!(fmul_fast(a, b), a * b);
+            assert_approx_eq!(fdiv_fast(a, b), a / b);
+            assert_approx_eq!(frem_fast(a, b), a % b);
         }
     }
 
@@ -1103,11 +1127,11 @@ fn test_fast() {
     pub fn test_operations_f32(a: f32, b: f32) {
         // make sure they all map to the correct operation
         unsafe {
-            assert_eq!(fadd_fast(a, b), a + b);
-            assert_eq!(fsub_fast(a, b), a - b);
-            assert_eq!(fmul_fast(a, b), a * b);
-            assert_eq!(fdiv_fast(a, b), a / b);
-            assert_eq!(frem_fast(a, b), a % b);
+            assert_approx_eq!(fadd_fast(a, b), a + b);
+            assert_approx_eq!(fsub_fast(a, b), a - b);
+            assert_approx_eq!(fmul_fast(a, b), a * b);
+            assert_approx_eq!(fdiv_fast(a, b), a / b);
+            assert_approx_eq!(frem_fast(a, b), a % b);
         }
     }
 
@@ -1115,11 +1139,11 @@ fn test_fast() {
     pub fn test_operations_f64(a: f64, b: f64) {
         // make sure they all map to the correct operation
         unsafe {
-            assert_eq!(fadd_fast(a, b), a + b);
-            assert_eq!(fsub_fast(a, b), a - b);
-            assert_eq!(fmul_fast(a, b), a * b);
-            assert_eq!(fdiv_fast(a, b), a / b);
-            assert_eq!(frem_fast(a, b), a % b);
+            assert_approx_eq!(fadd_fast(a, b), a + b);
+            assert_approx_eq!(fsub_fast(a, b), a - b);
+            assert_approx_eq!(fmul_fast(a, b), a * b);
+            assert_approx_eq!(fdiv_fast(a, b), a / b);
+            assert_approx_eq!(frem_fast(a, b), a % b);
         }
     }
 
@@ -1127,11 +1151,11 @@ fn test_fast() {
     pub fn test_operations_f128(a: f128, b: f128) {
         // make sure they all map to the correct operation
         unsafe {
-            assert_eq!(fadd_fast(a, b), a + b);
-            assert_eq!(fsub_fast(a, b), a - b);
-            assert_eq!(fmul_fast(a, b), a * b);
-            assert_eq!(fdiv_fast(a, b), a / b);
-            assert_eq!(frem_fast(a, b), a % b);
+            assert_approx_eq!(fadd_fast(a, b), a + b);
+            assert_approx_eq!(fsub_fast(a, b), a - b);
+            assert_approx_eq!(fmul_fast(a, b), a * b);
+            assert_approx_eq!(fdiv_fast(a, b), a / b);
+            assert_approx_eq!(frem_fast(a, b), a % b);
         }
     }
 
@@ -1153,41 +1177,41 @@ fn test_algebraic() {
     #[inline(never)]
     pub fn test_operations_f16(a: f16, b: f16) {
         // make sure they all map to the correct operation
-        assert_eq!(fadd_algebraic(a, b), a + b);
-        assert_eq!(fsub_algebraic(a, b), a - b);
-        assert_eq!(fmul_algebraic(a, b), a * b);
-        assert_eq!(fdiv_algebraic(a, b), a / b);
-        assert_eq!(frem_algebraic(a, b), a % b);
+        assert_approx_eq!(fadd_algebraic(a, b), a + b);
+        assert_approx_eq!(fsub_algebraic(a, b), a - b);
+        assert_approx_eq!(fmul_algebraic(a, b), a * b);
+        assert_approx_eq!(fdiv_algebraic(a, b), a / b);
+        assert_approx_eq!(frem_algebraic(a, b), a % b);
     }
 
     #[inline(never)]
     pub fn test_operations_f32(a: f32, b: f32) {
         // make sure they all map to the correct operation
-        assert_eq!(fadd_algebraic(a, b), a + b);
-        assert_eq!(fsub_algebraic(a, b), a - b);
-        assert_eq!(fmul_algebraic(a, b), a * b);
-        assert_eq!(fdiv_algebraic(a, b), a / b);
-        assert_eq!(frem_algebraic(a, b), a % b);
+        assert_approx_eq!(fadd_algebraic(a, b), a + b);
+        assert_approx_eq!(fsub_algebraic(a, b), a - b);
+        assert_approx_eq!(fmul_algebraic(a, b), a * b);
+        assert_approx_eq!(fdiv_algebraic(a, b), a / b);
+        assert_approx_eq!(frem_algebraic(a, b), a % b);
     }
 
     #[inline(never)]
     pub fn test_operations_f64(a: f64, b: f64) {
         // make sure they all map to the correct operation
-        assert_eq!(fadd_algebraic(a, b), a + b);
-        assert_eq!(fsub_algebraic(a, b), a - b);
-        assert_eq!(fmul_algebraic(a, b), a * b);
-        assert_eq!(fdiv_algebraic(a, b), a / b);
-        assert_eq!(frem_algebraic(a, b), a % b);
+        assert_approx_eq!(fadd_algebraic(a, b), a + b);
+        assert_approx_eq!(fsub_algebraic(a, b), a - b);
+        assert_approx_eq!(fmul_algebraic(a, b), a * b);
+        assert_approx_eq!(fdiv_algebraic(a, b), a / b);
+        assert_approx_eq!(frem_algebraic(a, b), a % b);
     }
 
     #[inline(never)]
     pub fn test_operations_f128(a: f128, b: f128) {
         // make sure they all map to the correct operation
-        assert_eq!(fadd_algebraic(a, b), a + b);
-        assert_eq!(fsub_algebraic(a, b), a - b);
-        assert_eq!(fmul_algebraic(a, b), a * b);
-        assert_eq!(fdiv_algebraic(a, b), a / b);
-        assert_eq!(frem_algebraic(a, b), a % b);
+        assert_approx_eq!(fadd_algebraic(a, b), a + b);
+        assert_approx_eq!(fsub_algebraic(a, b), a - b);
+        assert_approx_eq!(fmul_algebraic(a, b), a * b);
+        assert_approx_eq!(fdiv_algebraic(a, b), a / b);
+        assert_approx_eq!(frem_algebraic(a, b), a % b);
     }
 
     test_operations_f16(11., 2.);
@@ -1245,3 +1269,122 @@ fn test_min_max_nondet() {
     ensure_both(|| f128::min(0.0, -0.0).is_sign_positive());
     ensure_both(|| f128::max(0.0, -0.0).is_sign_positive());
 }
+
+fn test_non_determinism() {
+    use std::intrinsics::{
+        fadd_algebraic, fadd_fast, fdiv_algebraic, fdiv_fast, fmul_algebraic, fmul_fast,
+        frem_algebraic, frem_fast, fsub_algebraic, fsub_fast,
+    };
+    use std::{f32, f64};
+    // TODO: Also test powi and powf when the non-determinism is implemented for them
+
+    /// Ensure that the operation is non-deterministic
+    #[track_caller]
+    fn ensure_nondet<T: PartialEq + std::fmt::Debug>(f: impl Fn() -> T) {
+
+        let rounds = 16;
+        let first = f();
+        for _ in 1..rounds {
+            if f() != first {
+                // We saw two different values!
+                return;
+            }
+        }
+        // We saw the same thing N times.
+        // FIXME: temporarily disabled as it breaks std tests.
+        //panic!("expected non-determinism, got {rounds} times the same result: {first:?}");
+    }
+
+    macro_rules! test_operations_f {
+        ($a:expr, $b:expr) => {
+            ensure_nondet(|| fadd_algebraic($a, $b));
+            ensure_nondet(|| fsub_algebraic($a, $b));
+            ensure_nondet(|| fmul_algebraic($a, $b));
+            ensure_nondet(|| fdiv_algebraic($a, $b));
+            ensure_nondet(|| frem_algebraic($a, $b));
+
+            unsafe {
+                ensure_nondet(|| fadd_fast($a, $b));
+                ensure_nondet(|| fsub_fast($a, $b));
+                ensure_nondet(|| fmul_fast($a, $b));
+                ensure_nondet(|| fdiv_fast($a, $b));
+                ensure_nondet(|| frem_fast($a, $b));
+            }
+        };
+    }
+
+    pub fn test_operations_f16(a: f16, b: f16) {
+        test_operations_f!(a, b);
+    }
+    pub fn test_operations_f32(a: f32, b: f32) {
+        test_operations_f!(a, b);
+        ensure_nondet(|| a.log(b));
+        ensure_nondet(|| a.exp());
+        ensure_nondet(|| 10f32.exp2());
+        ensure_nondet(|| f32::consts::E.ln());
+        ensure_nondet(|| 1f32.ln_1p());
+        ensure_nondet(|| 10f32.log10());
+        ensure_nondet(|| 8f32.log2());
+        ensure_nondet(|| 27.0f32.cbrt());
+        ensure_nondet(|| 3.0f32.hypot(4.0f32));
+        ensure_nondet(|| 1f32.sin());
+        ensure_nondet(|| 0f32.cos());
+        // On i686-pc-windows-msvc , these functions are implemented by calling the `f64` version,
+        // which means the little rounding errors Miri introduces are discard by the cast down to `f32`.
+        // Just skip the test for them.
+        if !cfg!(all(target_os = "windows", target_env = "msvc", target_arch = "x86")) {
+            ensure_nondet(|| 1.0f32.tan());
+            ensure_nondet(|| 1.0f32.asin());
+            ensure_nondet(|| 5.0f32.acos());
+            ensure_nondet(|| 1.0f32.atan());
+            ensure_nondet(|| 1.0f32.atan2(2.0f32));
+            ensure_nondet(|| 1.0f32.sinh());
+            ensure_nondet(|| 1.0f32.cosh());
+            ensure_nondet(|| 1.0f32.tanh());
+        }
+        ensure_nondet(|| 1.0f32.asinh());
+        ensure_nondet(|| 2.0f32.acosh());
+        ensure_nondet(|| 0.5f32.atanh());
+        ensure_nondet(|| 5.0f32.gamma());
+        ensure_nondet(|| 5.0f32.ln_gamma());
+        ensure_nondet(|| 5.0f32.erf());
+        ensure_nondet(|| 5.0f32.erfc());
+    }
+    pub fn test_operations_f64(a: f64, b: f64) {
+        test_operations_f!(a, b);
+        ensure_nondet(|| a.log(b));
+        ensure_nondet(|| a.exp());
+        ensure_nondet(|| 50f64.exp2());
+        ensure_nondet(|| 3f64.ln());
+        ensure_nondet(|| 1f64.ln_1p());
+        ensure_nondet(|| f64::consts::E.log10());
+        ensure_nondet(|| f64::consts::E.log2());
+        ensure_nondet(|| 27.0f64.cbrt());
+        ensure_nondet(|| 3.0f64.hypot(4.0f64));
+        ensure_nondet(|| 1f64.sin());
+        ensure_nondet(|| 0f64.cos());
+        ensure_nondet(|| 1.0f64.tan());
+        ensure_nondet(|| 1.0f64.asin());
+        ensure_nondet(|| 5.0f64.acos());
+        ensure_nondet(|| 1.0f64.atan());
+        ensure_nondet(|| 1.0f64.atan2(2.0f64));
+        ensure_nondet(|| 1.0f64.sinh());
+        ensure_nondet(|| 1.0f64.cosh());
+        ensure_nondet(|| 1.0f64.tanh());
+        ensure_nondet(|| 1.0f64.asinh());
+        ensure_nondet(|| 3.0f64.acosh());
+        ensure_nondet(|| 0.5f64.atanh());
+        ensure_nondet(|| 5.0f64.gamma());
+        ensure_nondet(|| 5.0f64.ln_gamma());
+        ensure_nondet(|| 5.0f64.erf());
+        ensure_nondet(|| 5.0f64.erfc());
+    }
+    pub fn test_operations_f128(a: f128, b: f128) {
+        test_operations_f!(a, b);
+    }
+
+    test_operations_f16(5., 7.);
+    test_operations_f32(12., 5.);
+    test_operations_f64(19., 11.);
+    test_operations_f128(25., 18.);
+}
diff --git a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
index b6c5522b3d20..f043bb7ce9f5 100644
--- a/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
+++ b/src/tools/miri/tests/pass/intrinsics/portable-simd.rs
@@ -16,7 +16,7 @@ use std::simd::prelude::*;
 
 #[rustc_intrinsic]
 #[rustc_nounwind]
-pub unsafe fn simd_shuffle_generic<T, U, const IDX: &'static [u32]>(_x: T, _y: T) -> U;
+pub unsafe fn simd_shuffle_const_generic<T, U, const IDX: &'static [u32]>(_x: T, _y: T) -> U;
 
 fn simd_ops_f32() {
     let a = f32x4::splat(10.0);
@@ -619,13 +619,13 @@ fn simd_intrinsics() {
             simd_select(i8x4::from_array([0, -1, -1, 0]), b, a),
             i32x4::from_array([10, 2, 10, 10])
         );
-        assert_eq!(simd_shuffle_generic::<_, i32x4, { &[3, 1, 0, 2] }>(a, b), a,);
+        assert_eq!(simd_shuffle_const_generic::<_, i32x4, { &[3, 1, 0, 2] }>(a, b), a,);
         assert_eq!(
             simd_shuffle::<_, _, i32x4>(a, b, const { u32x4::from_array([3u32, 1, 0, 2]) }),
             a,
         );
         assert_eq!(
-            simd_shuffle_generic::<_, i32x4, { &[7, 5, 4, 6] }>(a, b),
+            simd_shuffle_const_generic::<_, i32x4, { &[7, 5, 4, 6] }>(a, b),
             i32x4::from_array([4, 2, 1, 10]),
         );
         assert_eq!(
diff --git a/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-neon.rs b/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-neon.rs
new file mode 100644
index 000000000000..84485dbad8c9
--- /dev/null
+++ b/src/tools/miri/tests/pass/shims/aarch64/intrinsics-aarch64-neon.rs
@@ -0,0 +1,40 @@
+// We're testing aarch64 target specific features
+//@only-target: aarch64
+//@compile-flags: -C target-feature=+neon
+
+use std::arch::aarch64::*;
+use std::arch::is_aarch64_feature_detected;
+
+fn main() {
+    assert!(is_aarch64_feature_detected!("neon"));
+
+    unsafe {
+        test_neon();
+    }
+}
+
+#[target_feature(enable = "neon")]
+unsafe fn test_neon() {
+    // Adapted from library/stdarch/crates/core_arch/src/aarch64/neon/mod.rs
+    unsafe fn test_vpmaxq_u8() {
+        let a = vld1q_u8([1, 2, 3, 4, 5, 6, 7, 8, 1, 2, 3, 4, 5, 6, 7, 8].as_ptr());
+        let b = vld1q_u8([0, 3, 2, 5, 4, 7, 6, 9, 0, 3, 2, 5, 4, 7, 6, 9].as_ptr());
+        let e = [2, 4, 6, 8, 2, 4, 6, 8, 3, 5, 7, 9, 3, 5, 7, 9];
+        let mut r = [0; 16];
+        vst1q_u8(r.as_mut_ptr(), vpmaxq_u8(a, b));
+        assert_eq!(r, e);
+    }
+    test_vpmaxq_u8();
+
+    unsafe fn test_vpmaxq_u8_is_unsigned() {
+        let a = vld1q_u8(
+            [255, 0, 253, 252, 251, 250, 249, 248, 255, 254, 253, 252, 251, 250, 249, 248].as_ptr(),
+        );
+        let b = vld1q_u8([254, 3, 2, 5, 4, 7, 6, 9, 0, 3, 2, 5, 4, 7, 6, 9].as_ptr());
+        let e = [255, 253, 251, 249, 255, 253, 251, 249, 254, 5, 7, 9, 3, 5, 7, 9];
+        let mut r = [0; 16];
+        vst1q_u8(r.as_mut_ptr(), vpmaxq_u8(a, b));
+        assert_eq!(r, e);
+    }
+    test_vpmaxq_u8_is_unsigned();
+}
diff --git a/src/tools/miri/tests/ui.rs b/src/tools/miri/tests/ui.rs
index 3bc953c3a5fb..85ce38f57d63 100644
--- a/src/tools/miri/tests/ui.rs
+++ b/src/tools/miri/tests/ui.rs
@@ -217,15 +217,11 @@ fn run_tests(
         ui_test::default_file_filter,
         // This could be used to overwrite the `Config` on a per-test basis.
         |_, _| {},
-        (
-            match args.format {
-                Format::Terse => status_emitter::Text::quiet(),
-                Format::Pretty => status_emitter::Text::verbose(),
-            },
-            status_emitter::Gha::</* GHA Actions groups*/ false> {
-                name: format!("{mode:?} {path} ({target})"),
-            },
-        ),
+        // No GHA output as that would also show in the main rustc repo.
+        match args.format {
+            Format::Terse => status_emitter::Text::quiet(),
+            Format::Pretty => status_emitter::Text::verbose(),
+        },
     )
 }
 
diff --git a/src/tools/miri/tests/x86_64-unknown-kernel.json b/src/tools/miri/tests/x86_64-unknown-kernel.json
index 8135b618d0d3..8da67d3a1c6b 100644
--- a/src/tools/miri/tests/x86_64-unknown-kernel.json
+++ b/src/tools/miri/tests/x86_64-unknown-kernel.json
@@ -10,6 +10,7 @@
   "vendor": "unknown",
   "linker": "rust-lld",
   "linker-flavor": "gnu-lld",
+  "rustc-abi": "x86-softfloat",
   "features": "-mmx,-sse,-sse2,-sse3,-ssse3,-sse4.1,-sse4.2,-avx,-avx2,+soft-float",
   "dynamic-linking": false,
   "executables": true,
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
index e2ab336d2e46..a4e49e0aa10a 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/layout.rs
@@ -192,7 +192,7 @@ fn layout_of_simd_ty(
     Ok(Arc::new(Layout {
         variants: Variants::Single { index: struct_variant_idx() },
         fields,
-        backend_repr: BackendRepr::Vector { element: e_abi, count: e_len },
+        backend_repr: BackendRepr::SimdVector { element: e_abi, count: e_len },
         largest_niche: e_ly.largest_niche,
         uninhabited: false,
         size,
diff --git a/src/tools/rustfmt/src/types.rs b/src/tools/rustfmt/src/types.rs
index 0009490e86fe..7b44b47c7196 100644
--- a/src/tools/rustfmt/src/types.rs
+++ b/src/tools/rustfmt/src/types.rs
@@ -1019,7 +1019,11 @@ impl Rewrite for ast::Ty {
             }
             ast::TyKind::UnsafeBinder(ref binder) => {
                 let mut result = String::new();
-                if let Some(ref lifetime_str) =
+                if binder.generic_params.is_empty() {
+                    // We always want to write `unsafe<>` since `unsafe<> Ty`
+                    // and `Ty` are distinct types.
+                    result.push_str("unsafe<> ")
+                } else if let Some(ref lifetime_str) =
                     rewrite_bound_params(context, shape, &binder.generic_params)
                 {
                     result.push_str("unsafe<");
diff --git a/src/tools/rustfmt/tests/source/unsafe-binders.rs b/src/tools/rustfmt/tests/source/unsafe-binders.rs
index ccf7c8bb9afa..2f43af54d204 100644
--- a/src/tools/rustfmt/tests/source/unsafe-binders.rs
+++ b/src/tools/rustfmt/tests/source/unsafe-binders.rs
@@ -9,3 +9,6 @@ struct Foo {
 struct Bar(unsafe<'a> &'a ());
 
 impl Trait for unsafe<'a> &'a () {}
+
+fn empty()
+-> unsafe<> () {}
diff --git a/src/tools/rustfmt/tests/target/unsafe-binders.rs b/src/tools/rustfmt/tests/target/unsafe-binders.rs
index 9d308f4a8946..d52dc5595196 100644
--- a/src/tools/rustfmt/tests/target/unsafe-binders.rs
+++ b/src/tools/rustfmt/tests/target/unsafe-binders.rs
@@ -7,3 +7,5 @@ struct Foo {
 struct Bar(unsafe<'a> &'a ());
 
 impl Trait for unsafe<'a> &'a () {}
+
+fn empty() -> unsafe<> () {}
diff --git a/src/tools/tidy/src/issues.txt b/src/tools/tidy/src/issues.txt
index 1cb47353469f..253e13375c73 100644
--- a/src/tools/tidy/src/issues.txt
+++ b/src/tools/tidy/src/issues.txt
@@ -3827,7 +3827,6 @@ ui/suggestions/issue-103646.rs
 ui/suggestions/issue-104086-suggest-let.rs
 ui/suggestions/issue-104287.rs
 ui/suggestions/issue-104327.rs
-ui/suggestions/issue-104328.rs
 ui/suggestions/issue-104961.rs
 ui/suggestions/issue-105226.rs
 ui/suggestions/issue-105494.rs
diff --git a/tests/assembly/aarch64-pointer-auth.rs b/tests/assembly/aarch64-pointer-auth.rs
index 344e9e74bc2a..8c0069826795 100644
--- a/tests/assembly/aarch64-pointer-auth.rs
+++ b/tests/assembly/aarch64-pointer-auth.rs
@@ -1,5 +1,6 @@
 // Test that PAC instructions are emitted when branch-protection is specified.
 
+//@ add-core-stubs
 //@ revisions: PACRET PAUTHLR_NOP PAUTHLR
 //@ assembly-output: emit-asm
 //@ needs-llvm-components: aarch64
@@ -14,8 +15,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // PACRET: hint #25
 // PACRET: hint #29
diff --git a/tests/assembly/cmse.rs b/tests/assembly/cmse.rs
index e0ada8dc2f15..2984df92225c 100644
--- a/tests/assembly/cmse.rs
+++ b/tests/assembly/cmse.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: hard soft
 //@ assembly-output: emit-asm
 //@ [hard] compile-flags: --target thumbv8m.main-none-eabihf --crate-type lib -Copt-level=1
@@ -7,10 +8,9 @@
 #![crate_type = "lib"]
 #![feature(abi_c_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items)]
 #![no_core]
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
+
+extern crate minicore;
+use minicore::*;
 
 // CHECK-LABEL: __acle_se_entry_point:
 // CHECK-NEXT: entry_point:
diff --git a/tests/assembly/dwarf-mixed-versions-lto.rs b/tests/assembly/dwarf-mixed-versions-lto.rs
index 5b8e5ff4f4a4..f1fc0814c9db 100644
--- a/tests/assembly/dwarf-mixed-versions-lto.rs
+++ b/tests/assembly/dwarf-mixed-versions-lto.rs
@@ -1,5 +1,6 @@
 // This test ensures that if LTO occurs between crates with different DWARF versions, we
 // will choose the highest DWARF version for the final binary. This matches Clang's behavior.
+// Note: `.2byte` directive is used on MIPS.
 
 //@ only-linux
 //@ aux-build:dwarf-mixed-versions-lto-aux.rs
@@ -14,6 +15,6 @@ fn main() {
 }
 
 // CHECK: .section .debug_info
-// CHECK-NOT: {{\.(short|hword)}} 2
-// CHECK-NOT: {{\.(short|hword)}} 4
-// CHECK: {{\.(short|hword)}} 5
+// CHECK-NOT: {{\.(short|hword|2byte)}} 2
+// CHECK-NOT: {{\.(short|hword|2byte)}} 4
+// CHECK: {{\.(short|hword|2byte)}} 5
diff --git a/tests/assembly/dwarf4.rs b/tests/assembly/dwarf4.rs
index 22be8e5603f2..6013adf3386a 100644
--- a/tests/assembly/dwarf4.rs
+++ b/tests/assembly/dwarf4.rs
@@ -1,5 +1,6 @@
 // Makes sure that `-Z dwarf-version=4` causes `rustc` to emit DWARF version 4.
 //@ assembly-output: emit-asm
+//@ add-core-stubs
 //@ compile-flags: -g --target x86_64-unknown-linux-gnu -Z dwarf-version=4 -Copt-level=0
 //@ needs-llvm-components: x86
 
@@ -7,10 +8,8 @@
 #![crate_type = "rlib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 pub fn wibble() {}
 
diff --git a/tests/assembly/dwarf5.rs b/tests/assembly/dwarf5.rs
index 35f2716e9fa9..9cd596e78345 100644
--- a/tests/assembly/dwarf5.rs
+++ b/tests/assembly/dwarf5.rs
@@ -1,4 +1,5 @@
 // Makes sure that `-Z dwarf-version=5` causes `rustc` to emit DWARF version 5.
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 //@ compile-flags: -g --target x86_64-unknown-linux-gnu -Z dwarf-version=5 -Copt-level=0
 //@ needs-llvm-components: x86
@@ -7,10 +8,8 @@
 #![crate_type = "rlib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 pub fn wibble() {}
 
diff --git a/tests/assembly/pic-relocation-model.rs b/tests/assembly/pic-relocation-model.rs
index 73db94791ec6..d35cd968389a 100644
--- a/tests/assembly/pic-relocation-model.rs
+++ b/tests/assembly/pic-relocation-model.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x64
 //@ assembly-output: emit-asm
 //@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=pic
@@ -7,10 +8,8 @@
 #![no_core]
 #![crate_type = "rlib"]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK-LABEL: call_other_fn:
 // CHECK:       {{(jmpq|callq)}} *other_fn@GOTPCREL(%rip)
diff --git a/tests/assembly/pie-relocation-model.rs b/tests/assembly/pie-relocation-model.rs
index e632b4dd5823..5c74b34eb313 100644
--- a/tests/assembly/pie-relocation-model.rs
+++ b/tests/assembly/pie-relocation-model.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x64
 //@ assembly-output: emit-asm
 //@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=pie
@@ -7,10 +8,8 @@
 #![no_core]
 #![crate_type = "rlib"]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK-LABEL: call_other_fn:
 // With PIE local functions are called "directly".
diff --git a/tests/assembly/powerpc64-struct-abi.rs b/tests/assembly/powerpc64-struct-abi.rs
index 0332eb94d8a7..eb27afc4f23c 100644
--- a/tests/assembly/powerpc64-struct-abi.rs
+++ b/tests/assembly/powerpc64-struct-abi.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: elfv1-be elfv2-be elfv2-le aix
 //@ assembly-output: emit-asm
 //@ compile-flags: -Copt-level=3
@@ -20,21 +21,9 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
-#[lang = "copy"]
-trait Copy {}
-
-#[lang = "freeze"]
-trait Freeze {}
-
-#[lang = "unpin"]
-trait Unpin {}
-
-impl Copy for u8 {}
-impl Copy for u16 {}
-impl Copy for u32 {}
 impl Copy for FiveU32s {}
 impl Copy for FiveU16s {}
 impl Copy for ThreeU8s {}
diff --git a/tests/assembly/riscv-soft-abi-with-float-features.rs b/tests/assembly/riscv-soft-abi-with-float-features.rs
index 8ccfa72a7b6f..72cbd3841c12 100644
--- a/tests/assembly/riscv-soft-abi-with-float-features.rs
+++ b/tests/assembly/riscv-soft-abi-with-float-features.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 //@ compile-flags: --target riscv64imac-unknown-none-elf -Ctarget-feature=+f,+d
 //@ needs-llvm-components: riscv
@@ -9,15 +10,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for f16 {}
-impl Copy for f32 {}
-impl Copy for f64 {}
+extern crate minicore;
+use minicore::*;
 
 // This test checks that the floats are all returned in `a0` as required by the `lp64` ABI.
 
diff --git a/tests/assembly/rust-abi-arg-attr.rs b/tests/assembly/rust-abi-arg-attr.rs
index e55a53fbdeb9..5b5eeb29f0f4 100644
--- a/tests/assembly/rust-abi-arg-attr.rs
+++ b/tests/assembly/rust-abi-arg-attr.rs
@@ -51,10 +51,7 @@ enum Ordering {
 }
 
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-fn three_way_compare<T: Copy>(lhs: T, rhs: T) -> Ordering {
-    loop {}
-}
+fn three_way_compare<T: Copy>(lhs: T, rhs: T) -> Ordering;
 
 // ^^^^^ core
 
diff --git a/tests/assembly/s390x-backchain-toggle.rs b/tests/assembly/s390x-backchain-toggle.rs
index 7ef0292d911e..83c7b82d0d4b 100644
--- a/tests/assembly/s390x-backchain-toggle.rs
+++ b/tests/assembly/s390x-backchain-toggle.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: enable-backchain disable-backchain
 //@ assembly-output: emit-asm
 //@ compile-flags: -Copt-level=3 --crate-type=lib --target=s390x-unknown-linux-gnu
@@ -8,8 +9,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 extern "C" {
     fn extern_func();
diff --git a/tests/assembly/simd-bitmask.rs b/tests/assembly/simd-bitmask.rs
index 4a829c4dd98b..a632791153b2 100644
--- a/tests/assembly/simd-bitmask.rs
+++ b/tests/assembly/simd-bitmask.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86 x86-avx2 x86-avx512 aarch64
 //@ [x86] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 //@ [x86] needs-llvm-components: x86
@@ -16,12 +17,8 @@
 #![no_core]
 #![allow(non_camel_case_types)]
 
-// Because we don't have core yet.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(simd)]
 pub struct m8x16([i8; 16]);
diff --git a/tests/assembly/simd-intrinsic-gather.rs b/tests/assembly/simd-intrinsic-gather.rs
index 3152de35f295..8c17a58046d8 100644
--- a/tests/assembly/simd-intrinsic-gather.rs
+++ b/tests/assembly/simd-intrinsic-gather.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86-avx512
 //@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 //@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
@@ -9,12 +10,8 @@
 #![no_core]
 #![allow(non_camel_case_types)]
 
-// Because we don't have core yet.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(simd)]
 pub struct f64x4([f64; 4]);
diff --git a/tests/assembly/simd-intrinsic-mask-load.rs b/tests/assembly/simd-intrinsic-mask-load.rs
index efe3e3752fab..a0d0514c0141 100644
--- a/tests/assembly/simd-intrinsic-mask-load.rs
+++ b/tests/assembly/simd-intrinsic-mask-load.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86-avx2 x86-avx512
 //@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 //@ [x86-avx2] compile-flags: -C target-feature=+avx2
@@ -12,13 +13,8 @@
 #![no_core]
 #![allow(non_camel_case_types)]
 
-// Because we don't have core yet.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
-impl<T: ?Sized> Copy for *const T {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(simd)]
 pub struct i8x16([i8; 16]);
diff --git a/tests/assembly/simd-intrinsic-mask-reduce.rs b/tests/assembly/simd-intrinsic-mask-reduce.rs
index 4d4adda6c24f..959c4ddefdb0 100644
--- a/tests/assembly/simd-intrinsic-mask-reduce.rs
+++ b/tests/assembly/simd-intrinsic-mask-reduce.rs
@@ -1,4 +1,5 @@
 // verify that simd mask reductions do not introduce additional bit shift operations
+//@ add-core-stubs
 //@ revisions: x86 aarch64
 //@ [x86] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 // Set the base cpu explicitly, in case the default has been changed.
@@ -13,12 +14,8 @@
 #![no_core]
 #![allow(non_camel_case_types)]
 
-// Because we don't have core yet.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(simd)]
 pub struct mask8x16([i8; 16]);
diff --git a/tests/assembly/simd-intrinsic-mask-store.rs b/tests/assembly/simd-intrinsic-mask-store.rs
index f5d924f24a76..4be9194943c7 100644
--- a/tests/assembly/simd-intrinsic-mask-store.rs
+++ b/tests/assembly/simd-intrinsic-mask-store.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86-avx2 x86-avx512
 //@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 //@ [x86-avx2] compile-flags: -C target-feature=+avx2
@@ -12,13 +13,8 @@
 #![no_core]
 #![allow(non_camel_case_types)]
 
-// Because we don't have core yet.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
-impl<T: ?Sized> Copy for *mut T {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(simd)]
 pub struct i8x16([i8; 16]);
diff --git a/tests/assembly/simd-intrinsic-scatter.rs b/tests/assembly/simd-intrinsic-scatter.rs
index 5f52ababd19c..715de04af4d7 100644
--- a/tests/assembly/simd-intrinsic-scatter.rs
+++ b/tests/assembly/simd-intrinsic-scatter.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86-avx512
 //@ [x86-avx512] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 //@ [x86-avx512] compile-flags: -C target-feature=+avx512f,+avx512vl,+avx512bw,+avx512dq
@@ -9,12 +10,8 @@
 #![no_core]
 #![allow(non_camel_case_types)]
 
-// Because we don't have core yet.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(simd)]
 pub struct f64x4([f64; 4]);
diff --git a/tests/assembly/simd-intrinsic-select.rs b/tests/assembly/simd-intrinsic-select.rs
index 74784a772133..7f1e42662bfb 100644
--- a/tests/assembly/simd-intrinsic-select.rs
+++ b/tests/assembly/simd-intrinsic-select.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86-avx2 x86-avx512 aarch64
 //@ [x86-avx2] compile-flags: --target=x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
 //@ [x86-avx2] compile-flags: -C target-feature=+avx2
@@ -14,12 +15,8 @@
 #![no_core]
 #![allow(non_camel_case_types)]
 
-// Because we don't have core yet.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(simd)]
 pub struct i8x16([i8; 16]);
diff --git a/tests/assembly/sparc-struct-abi.rs b/tests/assembly/sparc-struct-abi.rs
index 3a254f179641..b1594428811f 100644
--- a/tests/assembly/sparc-struct-abi.rs
+++ b/tests/assembly/sparc-struct-abi.rs
@@ -2,6 +2,7 @@
 // - float structure members are passes in floating point registers
 // (#86163)
 
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 //@ needs-llvm-components: sparc
 //@ compile-flags: --target=sparcv9-sun-solaris -Copt-level=3
@@ -9,11 +10,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for f32 {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Franta {
diff --git a/tests/assembly/stack-probes.rs b/tests/assembly/stack-probes.rs
index e0931157ce17..de245431f470 100644
--- a/tests/assembly/stack-probes.rs
+++ b/tests/assembly/stack-probes.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86_64 i686 aarch64
 //@ assembly-output: emit-asm
 //@[x86_64] compile-flags: --target x86_64-unknown-linux-gnu -C llvm-args=-x86-asm-syntax=intel
@@ -11,12 +12,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for u8 {}
+extern crate minicore;
+use minicore::*;
 
 // Check that inline-asm stack probes are generated correctly.
 // To avoid making this test fragile to slight asm changes,
diff --git a/tests/assembly/stack-protector/stack-protector-target-support.rs b/tests/assembly/stack-protector/stack-protector-target-support.rs
index 74a609dcdcc1..e9ba0f9ba899 100644
--- a/tests/assembly/stack-protector/stack-protector-target-support.rs
+++ b/tests/assembly/stack-protector/stack-protector-target-support.rs
@@ -1,6 +1,7 @@
 // Test that stack smash protection code is emitted for all tier1 and tier2
 // targets, with the exception of nvptx64-nvidia-cuda
 //
+//@ add-core-stubs
 //@ revisions: r1 r2 r3 r4 r5 r6 r7 r8 r9 r10 r11 r12 r13 r14 r15 r16 r17 r18 r19 r20 r21 r22 r23
 //@ revisions: r24 r25 r26 r27 r28 r29 r30 r31 r32 r33     r35 r36 r37 r38 r39 r40 r41 r42 r43 r44
 //@ revisions: r45 r46 r47 r48 r49 r50 r51 r52 r53 r54 r55 r56 r57 r58 r59 r60 r61 r62 r63 r64 r65
@@ -183,10 +184,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub fn foo() {
diff --git a/tests/assembly/static-relocation-model.rs b/tests/assembly/static-relocation-model.rs
index eafdfd485baa..53fa18852b69 100644
--- a/tests/assembly/static-relocation-model.rs
+++ b/tests/assembly/static-relocation-model.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x64 A64 ppc64le
 //@ assembly-output: emit-asm
 //@ [x64] compile-flags: --target x86_64-unknown-linux-gnu -Crelocation-model=static
@@ -11,20 +12,8 @@
 #![no_core]
 #![crate_type = "rlib"]
 
-#[lang = "sized"]
-trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
-
-#[lang = "sync"]
-trait Sync {}
-
-#[lang = "drop_in_place"]
-fn drop_in_place<T>(_: *mut T) {}
-
-impl Copy for u8 {}
-impl Sync for u8 {}
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub static PIERIS: u8 = 42;
diff --git a/tests/assembly/target-feature-multiple.rs b/tests/assembly/target-feature-multiple.rs
index 83c385686476..bc432d219317 100644
--- a/tests/assembly/target-feature-multiple.rs
+++ b/tests/assembly/target-feature-multiple.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 //@ needs-llvm-components: x86
 //@ revisions: TWOFLAGS SINGLEFLAG
@@ -19,11 +20,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for u32 {}
+extern crate minicore;
+use minicore::*;
 
 // Use of these requires target features to be enabled
 extern "unadjusted" {
diff --git a/tests/assembly/targets/targets-amdgpu.rs b/tests/assembly/targets/targets-amdgpu.rs
index 501eed2e2478..1d10b8fc315c 100644
--- a/tests/assembly/targets/targets-amdgpu.rs
+++ b/tests/assembly/targets/targets-amdgpu.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 // ignore-tidy-linelength
 //@ revisions: amdgcn_amd_amdhsa
@@ -11,8 +12,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 pub fn test() -> u8 {
     42
diff --git a/tests/assembly/targets/targets-elf.rs b/tests/assembly/targets/targets-elf.rs
index 3e73d2c6eb72..dc564c60f807 100644
--- a/tests/assembly/targets/targets-elf.rs
+++ b/tests/assembly/targets/targets-elf.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 // ignore-tidy-linelength
 //@ revisions: aarch64_be_unknown_linux_gnu
@@ -709,8 +710,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // Force linkage to ensure code is actually generated
 #[no_mangle]
diff --git a/tests/assembly/targets/targets-macho.rs b/tests/assembly/targets/targets-macho.rs
index 25e9059afeb1..92bde1c6971b 100644
--- a/tests/assembly/targets/targets-macho.rs
+++ b/tests/assembly/targets/targets-macho.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 // ignore-tidy-linelength
 //@ revisions: aarch64_apple_darwin
@@ -80,8 +81,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // Force linkage to ensure code is actually generated
 #[no_mangle]
diff --git a/tests/assembly/targets/targets-nvptx.rs b/tests/assembly/targets/targets-nvptx.rs
index 9048191affa1..49c12aebaaaf 100644
--- a/tests/assembly/targets/targets-nvptx.rs
+++ b/tests/assembly/targets/targets-nvptx.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 // ignore-tidy-linelength
 //@ revisions: nvptx64_nvidia_cuda
@@ -11,8 +12,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 pub fn test() -> u8 {
     42
diff --git a/tests/assembly/targets/targets-pe.rs b/tests/assembly/targets/targets-pe.rs
index b74d0181c4d6..f895b79ba507 100644
--- a/tests/assembly/targets/targets-pe.rs
+++ b/tests/assembly/targets/targets-pe.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ assembly-output: emit-asm
 // ignore-tidy-linelength
 //@ revisions: aarch64_pc_windows_msvc
@@ -95,8 +96,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 pub fn test() -> u8 {
     42
diff --git a/tests/auxiliary/minicore.rs b/tests/auxiliary/minicore.rs
index 0aa8b6b8f891..03aa84765082 100644
--- a/tests/auxiliary/minicore.rs
+++ b/tests/auxiliary/minicore.rs
@@ -25,7 +25,8 @@
     naked_functions,
     f16,
     f128,
-    asm_experimental_arch
+    asm_experimental_arch,
+    unboxed_closures
 )]
 #![allow(unused, improper_ctypes_definitions, internal_features)]
 #![no_std]
@@ -61,7 +62,7 @@ pub auto trait Unpin {}
 
 impl_marker_trait!(
     Copy => [
-        bool, char,
+        char, bool,
         isize, i8, i16, i32, i64, i128,
         usize, u8, u16, u32, u64, u128,
         f16, f32, f64, f128,
@@ -102,6 +103,9 @@ pub struct UnsafeCell<T: ?Sized> {
 }
 impl<T: ?Sized> !Freeze for UnsafeCell<T> {}
 
+#[lang = "tuple_trait"]
+pub trait Tuple {}
+
 #[rustc_builtin_macro]
 pub macro asm("assembly template", $(operands,)* $(options($(option),*))?) {
     /* compiler built-in */
@@ -129,3 +133,61 @@ macro_rules! stringify {
         /* compiler built-in */
     };
 }
+
+#[lang = "add"]
+pub trait Add<Rhs = Self> {
+    type Output;
+
+    fn add(self, _: Rhs) -> Self::Output;
+}
+
+impl Add<isize> for isize {
+    type Output = isize;
+
+    fn add(self, other: isize) -> isize {
+        7 // avoid needing to add all of the overflow handling and panic language items
+    }
+}
+
+#[lang = "sync"]
+trait Sync {}
+impl Sync for u8 {}
+
+#[lang = "drop_in_place"]
+fn drop_in_place<T>(_: *mut T) {}
+
+#[lang = "fn_once"]
+pub trait FnOnce<Args: Tuple> {
+    #[lang = "fn_once_output"]
+    type Output;
+
+    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
+}
+
+#[lang = "fn_mut"]
+pub trait FnMut<Args: Tuple>: FnOnce<Args> {
+    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
+}
+
+#[lang = "fn"]
+pub trait Fn<Args: Tuple>: FnMut<Args> {
+    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
+}
+
+#[lang = "dispatch_from_dyn"]
+trait DispatchFromDyn<T> {}
+
+impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<&'a U> for &'a T {}
+
+#[lang = "unsize"]
+trait Unsize<T: ?Sized> {}
+
+#[lang = "coerce_unsized"]
+pub trait CoerceUnsized<T: ?Sized> {}
+
+impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
+
+#[lang = "drop"]
+trait Drop {
+    fn drop(&mut self);
+}
diff --git a/tests/codegen/aarch64-softfloat.rs b/tests/codegen/aarch64-softfloat.rs
index 85380a6c4728..4f5366e047fb 100644
--- a/tests/codegen/aarch64-softfloat.rs
+++ b/tests/codegen/aarch64-softfloat.rs
@@ -1,15 +1,12 @@
+//@ add-core-stubs
 //@ compile-flags: --target aarch64-unknown-none-softfloat -Zmerge-functions=disabled
 //@ needs-llvm-components: aarch64
 #![crate_type = "lib"]
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for f32 {}
-impl Copy for f64 {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: i64 @pass_f64_C(i64 {{[^,]*}})
 #[no_mangle]
diff --git a/tests/codegen/aarch64-struct-align-128.rs b/tests/codegen/aarch64-struct-align-128.rs
index 3fed19d96b12..ba1d19680f4e 100644
--- a/tests/codegen/aarch64-struct-align-128.rs
+++ b/tests/codegen/aarch64-struct-align-128.rs
@@ -1,5 +1,6 @@
 // Test that structs aligned to 128 bits are passed with the correct ABI on aarch64.
 
+//@ add-core-stubs
 //@ revisions: linux darwin win
 //@[linux] compile-flags: --target aarch64-unknown-linux-gnu
 //@[darwin] compile-flags: --target aarch64-apple-darwin
@@ -12,12 +13,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // Passed as `[i64 x 2]`, since it's an aggregate with size <= 128 bits, align < 128 bits.
 #[repr(C)]
diff --git a/tests/codegen/abi-efiapi.rs b/tests/codegen/abi-efiapi.rs
index 986d042268aa..1736f0daf0fa 100644
--- a/tests/codegen/abi-efiapi.rs
+++ b/tests/codegen/abi-efiapi.rs
@@ -1,5 +1,6 @@
 // Checks if the correct annotation for the efiapi ABI is passed to llvm.
 
+//@ add-core-stubs
 //@ revisions:x86_64 i686 aarch64 arm riscv
 //@[x86_64] compile-flags: --target x86_64-unknown-uefi
 //@[x86_64] needs-llvm-components: aarch64 arm riscv
@@ -17,12 +18,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 //x86_64: define win64cc void @has_efiapi
 //i686: define void @has_efiapi
diff --git a/tests/codegen/abi-repr-ext.rs b/tests/codegen/abi-repr-ext.rs
index b06d225ed70e..1da28a94d9dd 100644
--- a/tests/codegen/abi-repr-ext.rs
+++ b/tests/codegen/abi-repr-ext.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3
 
 //@ revisions:x86_64 i686 aarch64-apple aarch64-windows aarch64-linux arm riscv
@@ -24,12 +25,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(i8)]
 pub enum Type {
diff --git a/tests/codegen/abi-sysv64.rs b/tests/codegen/abi-sysv64.rs
index ec555ee5f1d9..7ade17f2baec 100644
--- a/tests/codegen/abi-sysv64.rs
+++ b/tests/codegen/abi-sysv64.rs
@@ -2,6 +2,7 @@
 // llvm. Also checks that the abi-sysv64 feature gate allows usage
 // of the sysv64 abi.
 //
+//@ add-core-stubs
 //@ needs-llvm-components: x86
 //@ compile-flags: -C no-prepopulate-passes --target=x86_64-unknown-linux-gnu -Copt-level=0
 
@@ -9,11 +10,8 @@
 #![no_core]
 #![feature(abi_x86_interrupt, no_core, lang_items)]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for i64 {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: define x86_64_sysvcc i64 @has_sysv64_abi
 #[no_mangle]
diff --git a/tests/codegen/abi-win64-zst.rs b/tests/codegen/abi-win64-zst.rs
index 825a5c1b09c1..e46f9666d42e 100644
--- a/tests/codegen/abi-win64-zst.rs
+++ b/tests/codegen/abi-win64-zst.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Z merge-functions=disabled
 //@ add-core-stubs
 
diff --git a/tests/codegen/abi-x86-interrupt.rs b/tests/codegen/abi-x86-interrupt.rs
index b8f3ebb99dd5..255ccba2c111 100644
--- a/tests/codegen/abi-x86-interrupt.rs
+++ b/tests/codegen/abi-x86-interrupt.rs
@@ -2,6 +2,7 @@
 // llvm. Also checks that the abi_x86_interrupt feature gate allows usage
 // of the x86-interrupt abi.
 
+//@ add-core-stubs
 //@ needs-llvm-components: x86
 //@ compile-flags: -C no-prepopulate-passes --target=x86_64-unknown-linux-gnu -Copt-level=0
 
@@ -9,11 +10,8 @@
 #![no_core]
 #![feature(abi_x86_interrupt, no_core, lang_items)]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for i64 {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: define x86_intrcc i64 @has_x86_interrupt_abi
 #[no_mangle]
diff --git a/tests/codegen/avr/avr-func-addrspace.rs b/tests/codegen/avr/avr-func-addrspace.rs
index 2ec7c86b5f43..2ae2f40d7b34 100644
--- a/tests/codegen/avr/avr-func-addrspace.rs
+++ b/tests/codegen/avr/avr-func-addrspace.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 --target=avr-none -C target-cpu=atmega328p --crate-type=rlib -C panic=abort
 //@ needs-llvm-components: avr
 
@@ -13,45 +14,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-impl<T: ?Sized> Copy for *const T {}
-#[lang = "legacy_receiver"]
-pub trait LegacyReceiver {}
-#[lang = "tuple_trait"]
-pub trait Tuple {}
-
-pub struct Result<T, E> {
-    _a: T,
-    _b: E,
-}
-
-impl Copy for usize {}
-impl Copy for &usize {}
-
-#[lang = "drop_in_place"]
-pub unsafe fn drop_in_place<T: ?Sized>(_: *mut T) {}
-
-#[lang = "fn_once"]
-pub trait FnOnce<Args: Tuple> {
-    #[lang = "fn_once_output"]
-    type Output;
-
-    extern "rust-call" fn call_once(self, args: Args) -> Self::Output;
-}
-
-#[lang = "fn_mut"]
-pub trait FnMut<Args: Tuple>: FnOnce<Args> {
-    extern "rust-call" fn call_mut(&mut self, args: Args) -> Self::Output;
-}
-
-#[lang = "fn"]
-pub trait Fn<Args: Tuple>: FnOnce<Args> {
-    /// Performs the call operation.
-    extern "rust-call" fn call(&self, args: Args) -> Self::Output;
-}
+extern crate minicore;
+use minicore::*;
 
 extern "rust-intrinsic" {
     pub fn transmute<Src, Dst>(src: Src) -> Dst;
diff --git a/tests/codegen/branch-protection-old-llvm.rs b/tests/codegen/branch-protection-old-llvm.rs
index 1846f35479db..14b34ac50188 100644
--- a/tests/codegen/branch-protection-old-llvm.rs
+++ b/tests/codegen/branch-protection-old-llvm.rs
@@ -1,5 +1,6 @@
 // Test that the correct module flags are emitted with different branch protection flags.
 
+//@ add-core-stubs
 //@ revisions: BTI PACRET LEAF BKEY NONE
 //@ needs-llvm-components: aarch64
 //@ [BTI] compile-flags: -Z branch-protection=bti
@@ -13,8 +14,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // A basic test function.
 pub fn test() {}
diff --git a/tests/codegen/branch-protection.rs b/tests/codegen/branch-protection.rs
index 945bad056256..ae14eae9ae0d 100644
--- a/tests/codegen/branch-protection.rs
+++ b/tests/codegen/branch-protection.rs
@@ -1,5 +1,6 @@
 // Test that the correct module flags are emitted with different branch protection flags.
 
+//@ add-core-stubs
 //@ revisions: BTI PACRET LEAF BKEY PAUTHLR PAUTHLR_BKEY PAUTHLR_LEAF PAUTHLR_BTI NONE
 //@ needs-llvm-components: aarch64
 //@ [BTI] compile-flags: -Z branch-protection=bti
@@ -17,8 +18,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // A basic test function.
 // CHECK: @test(){{.*}} [[ATTR:#[0-9]+]] {
diff --git a/tests/codegen/cast-target-abi.rs b/tests/codegen/cast-target-abi.rs
index a0801eb98269..186198bc631e 100644
--- a/tests/codegen/cast-target-abi.rs
+++ b/tests/codegen/cast-target-abi.rs
@@ -1,4 +1,5 @@
 // ignore-tidy-linelength
+//@ add-core-stubs
 //@ revisions:aarch64 loongarch64 powerpc64 sparc64 x86_64
 //@ min-llvm-version: 19
 //@ compile-flags: -Copt-level=3 -Cno-prepopulate-passes -Zlint-llvm-ir -Cllvm-args=-lint-abort-on-error
@@ -21,12 +22,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // This struct will be passed as a single `i64` or `i32`.
 // This may be (if `i64)) larger than the Rust layout, which is just `{ i16, i16 }`.
diff --git a/tests/codegen/cf-protection.rs b/tests/codegen/cf-protection.rs
index 244d1eb25442..f1349a5dcb98 100644
--- a/tests/codegen/cf-protection.rs
+++ b/tests/codegen/cf-protection.rs
@@ -1,5 +1,6 @@
 // Test that the correct module flags are emitted with different control-flow protection flags.
 
+//@ add-core-stubs
 //@ revisions: undefined none branch return full
 //@ needs-llvm-components: x86
 //@ [undefined] compile-flags:
@@ -13,8 +14,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // A basic test function.
 pub fn test() {}
diff --git a/tests/codegen/cffi/ffi-out-of-bounds-loads.rs b/tests/codegen/cffi/ffi-out-of-bounds-loads.rs
index ae8d8383f5b9..404f6237849e 100644
--- a/tests/codegen/cffi/ffi-out-of-bounds-loads.rs
+++ b/tests/codegen/cffi/ffi-out-of-bounds-loads.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: linux apple
 //@ min-llvm-version: 19
 //@ compile-flags: -Copt-level=0 -Cno-prepopulate-passes -Zlint-llvm-ir -Cllvm-args=-lint-abort-on-error
@@ -14,12 +15,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 struct S {
diff --git a/tests/codegen/comparison-operators-2-struct.rs b/tests/codegen/comparison-operators-2-struct.rs
new file mode 100644
index 000000000000..e179066ebfd7
--- /dev/null
+++ b/tests/codegen/comparison-operators-2-struct.rs
@@ -0,0 +1,61 @@
+//@ compile-flags: -C opt-level=1
+//@ min-llvm-version: 20
+
+// The `derive(PartialOrd)` for a 2-field type doesn't override `lt`/`le`/`gt`/`ge`.
+// This double-checks that the `Option<Ordering>` intermediate values used
+// in the operators for such a type all optimize away.
+
+#![crate_type = "lib"]
+
+use std::cmp::Ordering;
+
+#[derive(PartialOrd, PartialEq)]
+pub struct Foo(i32, u32);
+
+// CHECK-LABEL: @check_lt(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_lt(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp slt i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp ult i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a < b
+}
+
+// CHECK-LABEL: @check_le(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_le(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp sle i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp ule i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a <= b
+}
+
+// CHECK-LABEL: @check_gt(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_gt(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp sgt i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp ugt i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a > b
+}
+
+// CHECK-LABEL: @check_ge(
+// CHECK-SAME: i32{{.+}}%[[A0:.+]], i32{{.+}}%[[A1:.+]], i32{{.+}}%[[B0:.+]], i32{{.+}}%[[B1:.+]])
+#[no_mangle]
+pub fn check_ge(a: Foo, b: Foo) -> bool {
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R0:.+]] = icmp sge i32 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[R1:.+]] = icmp uge i32 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[R1]], i1 %[[R0]]
+    // CHECK-NEXT: ret i1 %[[R]]
+    a >= b
+}
diff --git a/tests/codegen/comparison-operators-2-tuple.rs b/tests/codegen/comparison-operators-2-tuple.rs
index 8e2915e84eb7..91a99f9b91f9 100644
--- a/tests/codegen/comparison-operators-2-tuple.rs
+++ b/tests/codegen/comparison-operators-2-tuple.rs
@@ -1,5 +1,6 @@
 //@ compile-flags: -C opt-level=1 -Z merge-functions=disabled
 //@ only-x86_64
+//@ min-llvm-version: 20
 
 #![crate_type = "lib"]
 
@@ -65,12 +66,7 @@ pub fn check_ge_direct(a: TwoTuple, b: TwoTuple) -> bool {
 }
 
 //
-// These ones are harder, since there are more intermediate values to remove.
-//
-// `<` seems to be getting lucky right now, so test that doesn't regress.
-//
-// The others, however, aren't managing to optimize away the extra `select`s yet.
-// See <https://github.com/rust-lang/rust/issues/106107> for more about this.
+// These used to not optimize as well, but thanks to LLVM 20 they work now 🎉
 //
 
 // CHECK-LABEL: @check_lt_via_cmp
@@ -89,11 +85,11 @@ pub fn check_lt_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
 // CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
 #[no_mangle]
 pub fn check_le_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
-    // FIXME-CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // FIXME-CHECK-DAG: %[[CMP0:.+]] = icmp sle i16 %[[A0]], %[[B0]]
-    // FIXME-CHECK-DAG: %[[CMP1:.+]] = icmp ule i16 %[[A1]], %[[B1]]
-    // FIXME-CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // FIXME-CHECK: ret i1 %[[R]]
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp sle i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ule i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
     Ord::cmp(&a, &b).is_le()
 }
 
@@ -101,11 +97,11 @@ pub fn check_le_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
 // CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
 #[no_mangle]
 pub fn check_gt_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
-    // FIXME-CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // FIXME-CHECK-DAG: %[[CMP0:.+]] = icmp sgt i16 %[[A0]], %[[B0]]
-    // FIXME-CHECK-DAG: %[[CMP1:.+]] = icmp ugt i16 %[[A1]], %[[B1]]
-    // FIXME-CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // FIXME-CHECK: ret i1 %[[R]]
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp sgt i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp ugt i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
     Ord::cmp(&a, &b).is_gt()
 }
 
@@ -113,10 +109,10 @@ pub fn check_gt_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
 // CHECK-SAME: (i16 noundef %[[A0:.+]], i16 noundef %[[A1:.+]], i16 noundef %[[B0:.+]], i16 noundef %[[B1:.+]])
 #[no_mangle]
 pub fn check_ge_via_cmp(a: TwoTuple, b: TwoTuple) -> bool {
-    // FIXME-CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
-    // FIXME-CHECK-DAG: %[[CMP0:.+]] = icmp sge i16 %[[A0]], %[[B0]]
-    // FIXME-CHECK-DAG: %[[CMP1:.+]] = icmp uge i16 %[[A1]], %[[B1]]
-    // FIXME-CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
-    // FIXME-CHECK: ret i1 %[[R]]
+    // CHECK-DAG: %[[EQ:.+]] = icmp eq i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP0:.+]] = icmp sge i16 %[[A0]], %[[B0]]
+    // CHECK-DAG: %[[CMP1:.+]] = icmp uge i16 %[[A1]], %[[B1]]
+    // CHECK: %[[R:.+]] = select i1 %[[EQ]], i1 %[[CMP1]], i1 %[[CMP0]]
+    // CHECK: ret i1 %[[R]]
     Ord::cmp(&a, &b).is_ge()
 }
diff --git a/tests/codegen/default-requires-uwtable.rs b/tests/codegen/default-requires-uwtable.rs
index 3cb35cea022a..54a6e171db66 100644
--- a/tests/codegen/default-requires-uwtable.rs
+++ b/tests/codegen/default-requires-uwtable.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: WINDOWS_ ANDROID_
 //@ compile-flags: -C panic=abort -Copt-level=0
 //@ [WINDOWS_] compile-flags: --target=x86_64-pc-windows-msvc
@@ -9,8 +10,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: attributes #{{.*}} uwtable
 pub fn foo() {}
diff --git a/tests/codegen/fastcall-inreg.rs b/tests/codegen/fastcall-inreg.rs
index 00b390bf1bf1..066943d6e7eb 100644
--- a/tests/codegen/fastcall-inreg.rs
+++ b/tests/codegen/fastcall-inreg.rs
@@ -2,6 +2,7 @@
 // as "inreg" like the C/C++ compilers for the platforms.
 // x86 only.
 
+//@ add-core-stubs
 //@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3
 //@ needs-llvm-components: x86
 
@@ -9,10 +10,8 @@
 #![no_core]
 #![feature(no_core, lang_items)]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 pub mod tests {
     // CHECK: @f1(i32 inreg noundef %_1, i32 inreg noundef %_2, i32 noundef %_3)
diff --git a/tests/codegen/fixed-x18.rs b/tests/codegen/fixed-x18.rs
index 4997a39a7263..a5767cfa456b 100644
--- a/tests/codegen/fixed-x18.rs
+++ b/tests/codegen/fixed-x18.rs
@@ -1,6 +1,7 @@
 // Test that the `reserve-x18` target feature is (not) emitted when
 // the `-Zfixed-x18` flag is (not) set.
 
+//@ add-core-stubs
 //@ revisions: unset set
 //@ needs-llvm-components: aarch64
 //@ compile-flags: --target aarch64-unknown-none
@@ -10,8 +11,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub fn foo() {
diff --git a/tests/codegen/frame-pointer.rs b/tests/codegen/frame-pointer.rs
index da81c2e9cd9a..1f7c9a59c988 100644
--- a/tests/codegen/frame-pointer.rs
+++ b/tests/codegen/frame-pointer.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --crate-type=rlib -Copt-level=0
 //@ revisions: aarch64-apple aarch64-linux force x64-apple x64-linux
 //@ [aarch64-apple] needs-llvm-components: aarch64
@@ -13,11 +14,9 @@
 
 #![feature(no_core, lang_items)]
 #![no_core]
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for u32 {}
+
+extern crate minicore;
+use minicore::*;
 
 // CHECK: define i32 @peach{{.*}}[[PEACH_ATTRS:\#[0-9]+]] {
 #[no_mangle]
diff --git a/tests/codegen/function-return.rs b/tests/codegen/function-return.rs
index 2b9de4e14785..4127f5160385 100644
--- a/tests/codegen/function-return.rs
+++ b/tests/codegen/function-return.rs
@@ -1,6 +1,7 @@
 // Test that the `fn_ret_thunk_extern` function attribute is (not) emitted when
 // the `-Zfunction-return={keep,thunk-extern}` flag is (not) set.
 
+//@ add-core-stubs
 //@ revisions: unset keep thunk-extern keep-thunk-extern thunk-extern-keep
 //@ needs-llvm-components: x86
 //@ compile-flags: --target x86_64-unknown-linux-gnu
@@ -13,8 +14,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub fn foo() {
diff --git a/tests/codegen/gpu-kernel-abi.rs b/tests/codegen/gpu-kernel-abi.rs
index fba179364943..8ac376d93381 100644
--- a/tests/codegen/gpu-kernel-abi.rs
+++ b/tests/codegen/gpu-kernel-abi.rs
@@ -1,17 +1,14 @@
 // Checks that the gpu-kernel calling convention correctly translates to LLVM calling conventions.
 
+//@ add-core-stubs
 //@ revisions: nvptx
 //@ [nvptx] compile-flags: --crate-type=rlib --target=nvptx64-nvidia-cuda
 //@ [nvptx] needs-llvm-components: nvptx
 #![feature(no_core, lang_items, abi_gpu_kernel)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // nvptx: define ptx_kernel void @fun(i32
 #[no_mangle]
diff --git a/tests/codegen/intrinsics/nontemporal.rs b/tests/codegen/intrinsics/nontemporal.rs
index af8892d30e7f..1d4fae83c29d 100644
--- a/tests/codegen/intrinsics/nontemporal.rs
+++ b/tests/codegen/intrinsics/nontemporal.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3
 //@revisions: with_nontemporal without_nontemporal
 //@[with_nontemporal] compile-flags: --target aarch64-unknown-linux-gnu
@@ -14,13 +15,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-
-impl Copy for u32 {}
-impl<T> Copy for *mut T {}
+extern crate minicore;
+use minicore::*;
 
 extern "rust-intrinsic" {
     pub fn nontemporal_store<T>(ptr: *mut T, val: T);
diff --git a/tests/codegen/issues/issue-114312.rs b/tests/codegen/issues/issue-114312.rs
index e9418249089d..61355dd5873c 100644
--- a/tests/codegen/issues/issue-114312.rs
+++ b/tests/codegen/issues/issue-114312.rs
@@ -15,7 +15,6 @@ pub enum Expr {
 #[no_mangle]
 pub extern "C" fn issue_114312(expr: Expr) {
     // CHECK-LABEL: @issue_114312(
-    // CHECK-NOT: readonly
     // CHECK-SAME: byval
     // CHECK-NEXT: start:
     // CHECK-NEXT: ret void
diff --git a/tests/codegen/issues/issue-84268.rs b/tests/codegen/issues/issue-84268.rs
index 8a8ea9d1ccf8..1dc55a909ad6 100644
--- a/tests/codegen/issues/issue-84268.rs
+++ b/tests/codegen/issues/issue-84268.rs
@@ -1,10 +1,7 @@
 //@ compile-flags: -Copt-level=3 --crate-type=rlib
-#![feature(intrinsics, repr_simd)]
+#![feature(core_intrinsics, repr_simd)]
 
-extern "rust-intrinsic" {
-    fn simd_fabs<T>(x: T) -> T;
-    fn simd_eq<T, U>(x: T, y: T) -> U;
-}
+use std::intrinsics::simd::{simd_eq, simd_fabs};
 
 #[repr(simd)]
 pub struct V([f32; 4]);
diff --git a/tests/codegen/issues/str-to-string-128690.rs b/tests/codegen/issues/str-to-string-128690.rs
index 8b416306ba66..d9e69764be28 100644
--- a/tests/codegen/issues/str-to-string-128690.rs
+++ b/tests/codegen/issues/str-to-string-128690.rs
@@ -2,25 +2,27 @@
 #![crate_type = "lib"]
 
 //! Make sure str::to_string is specialized not to use fmt machinery.
+//!
+//! Note that the `CHECK-NOT`s here try to match on calls to functions under `core::fmt`.
 
 // CHECK-LABEL: define {{(dso_local )?}}void @one_ref
 #[no_mangle]
 pub fn one_ref(input: &str) -> String {
-    // CHECK-NOT: {{(call|invoke).*}}fmt
+    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
     input.to_string()
 }
 
 // CHECK-LABEL: define {{(dso_local )?}}void @two_ref
 #[no_mangle]
 pub fn two_ref(input: &&str) -> String {
-    // CHECK-NOT: {{(call|invoke).*}}fmt
+    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
     input.to_string()
 }
 
 // CHECK-LABEL: define {{(dso_local )?}}void @thirteen_ref
 #[no_mangle]
 pub fn thirteen_ref(input: &&&&&&&&&&&&&str) -> String {
-    // CHECK-NOT: {{(call|invoke).*}}fmt
+    // CHECK-NOT: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
     input.to_string()
 }
 
@@ -31,6 +33,6 @@ pub fn thirteen_ref(input: &&&&&&&&&&&&&str) -> String {
 // CHECK-LABEL: define {{(dso_local )?}}void @fourteen_ref
 #[no_mangle]
 pub fn fourteen_ref(input: &&&&&&&&&&&&&&str) -> String {
-    // CHECK: {{(call|invoke).*}}fmt
+    // CHECK: {{(call|invoke)}}{{.*}}@{{.*}}core{{.*}}fmt{{.*}}
     input.to_string()
 }
diff --git a/tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs b/tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs
index b11bd657c18e..93c8d60930b7 100644
--- a/tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs
+++ b/tests/codegen/loongarch-abi/loongarch64-lp64d-abi.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target loongarch64-unknown-linux-gnu
 //@ needs-llvm-components: loongarch
 
@@ -6,12 +7,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 noundef zeroext %i)
 #[no_mangle]
diff --git a/tests/codegen/macos/i686-macosx-deployment-target.rs b/tests/codegen/macos/i686-macosx-deployment-target.rs
index 1f44bdfc6485..cfa91e61cb00 100644
--- a/tests/codegen/macos/i686-macosx-deployment-target.rs
+++ b/tests/codegen/macos/i686-macosx-deployment-target.rs
@@ -1,19 +1,15 @@
-//
 // Checks that we correctly modify the target when MACOSX_DEPLOYMENT_TARGET is set.
 // See issue #60235.
 
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 --target=i686-apple-darwin --crate-type=rlib
 //@ needs-llvm-components: x86
 //@ rustc-env:MACOSX_DEPLOYMENT_TARGET=10.14
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Bool {
diff --git a/tests/codegen/macos/i686-no-macosx-deployment-target.rs b/tests/codegen/macos/i686-no-macosx-deployment-target.rs
index a09773e0b9e2..25ec5f6acbb7 100644
--- a/tests/codegen/macos/i686-no-macosx-deployment-target.rs
+++ b/tests/codegen/macos/i686-no-macosx-deployment-target.rs
@@ -1,19 +1,15 @@
-//
 // Checks that we leave the target alone MACOSX_DEPLOYMENT_TARGET is unset.
 // See issue #60235.
 
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 --target=i686-apple-darwin --crate-type=rlib
 //@ needs-llvm-components: x86
 //@ unset-rustc-env:MACOSX_DEPLOYMENT_TARGET
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Bool {
diff --git a/tests/codegen/macos/x86_64-macosx-deployment-target.rs b/tests/codegen/macos/x86_64-macosx-deployment-target.rs
index bd8c027a9fb9..8ea95ba0575e 100644
--- a/tests/codegen/macos/x86_64-macosx-deployment-target.rs
+++ b/tests/codegen/macos/x86_64-macosx-deployment-target.rs
@@ -1,19 +1,15 @@
-//
 // Checks that we correctly modify the target when MACOSX_DEPLOYMENT_TARGET is set.
 // See issue #60235.
 
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 --target=x86_64-apple-darwin --crate-type=rlib
 //@ needs-llvm-components: x86
 //@ rustc-env:MACOSX_DEPLOYMENT_TARGET=10.14
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Bool {
diff --git a/tests/codegen/macos/x86_64-no-macosx-deployment-target.rs b/tests/codegen/macos/x86_64-no-macosx-deployment-target.rs
index ff4a8fc46f98..474094957aeb 100644
--- a/tests/codegen/macos/x86_64-no-macosx-deployment-target.rs
+++ b/tests/codegen/macos/x86_64-no-macosx-deployment-target.rs
@@ -1,19 +1,15 @@
-//
 // Checks that we leave the target alone when MACOSX_DEPLOYMENT_TARGET is unset.
 // See issue #60235.
 
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 --target=x86_64-apple-darwin --crate-type=rlib
 //@ needs-llvm-components: x86
 //@ unset-rustc-env:MACOSX_DEPLOYMENT_TARGET
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Bool {
diff --git a/tests/codegen/naked-fn/instruction-set.rs b/tests/codegen/naked-fn/instruction-set.rs
index 5b790b2034c0..a7b4c22a59bf 100644
--- a/tests/codegen/naked-fn/instruction-set.rs
+++ b/tests/codegen/naked-fn/instruction-set.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: arm-mode thumb-mode
 //@ [arm-mode] compile-flags: --target armv5te-none-eabi
 //@ [thumb-mode] compile-flags: --target thumbv5te-none-eabi
@@ -8,15 +9,8 @@
 #![feature(no_core, lang_items, rustc_attrs, naked_functions)]
 #![no_core]
 
-#[rustc_builtin_macro]
-macro_rules! naked_asm {
-    () => {};
-}
-
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // arm-mode: .arm
 // thumb-mode: .thumb
diff --git a/tests/codegen/naked-fn/naked-functions.rs b/tests/codegen/naked-fn/naked-functions.rs
index f505d27d48c6..6483e27c97a2 100644
--- a/tests/codegen/naked-fn/naked-functions.rs
+++ b/tests/codegen/naked-fn/naked-functions.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: linux win macos thumb
 //
 //@[linux] compile-flags: --target x86_64-unknown-linux-gnu
@@ -13,15 +14,8 @@
 #![feature(no_core, lang_items, rustc_attrs, naked_functions)]
 #![no_core]
 
-#[rustc_builtin_macro]
-macro_rules! naked_asm {
-    () => {};
-}
-
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // linux,win: .intel_syntax
 //
diff --git a/tests/codegen/no-jump-tables.rs b/tests/codegen/no-jump-tables.rs
index 654da2cec11c..e49de7e9dc1e 100644
--- a/tests/codegen/no-jump-tables.rs
+++ b/tests/codegen/no-jump-tables.rs
@@ -1,6 +1,7 @@
 // Test that the `no-jump-tables` function attribute are (not) emitted when
 // the `-Zno-jump-tables` flag is (not) set.
 
+//@ add-core-stubs
 //@ revisions: unset set
 //@ needs-llvm-components: x86
 //@ compile-flags: --target x86_64-unknown-linux-gnu
@@ -10,8 +11,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub fn foo() {
diff --git a/tests/codegen/overaligned-constant.rs b/tests/codegen/overaligned-constant.rs
index e5540aca3878..0f5977880f2e 100644
--- a/tests/codegen/overaligned-constant.rs
+++ b/tests/codegen/overaligned-constant.rs
@@ -9,14 +9,14 @@ struct S(i32);
 
 struct SmallStruct(f32, Option<S>, &'static [f32]);
 
-// CHECK: @0 = private unnamed_addr constant
+// CHECK: [[const:@.*]] = private unnamed_addr constant
 // CHECK-SAME: , align 8
 
 #[no_mangle]
 pub fn overaligned_constant() {
     // CHECK-LABEL: @overaligned_constant
     // CHECK: [[full:%_.*]] = alloca [32 x i8], align 8
-    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[full]], ptr align 8 @0, i64 32, i1 false)
+    // CHECK: call void @llvm.memcpy.p0.p0.i64(ptr align 8 [[full]], ptr align 8 [[const]], i64 32, i1 false)
     let mut s = S(1);
 
     s.0 = 3;
diff --git a/tests/codegen/powerpc64le-struct-align-128.rs b/tests/codegen/powerpc64le-struct-align-128.rs
index 3981cd121296..c1c1ac264854 100644
--- a/tests/codegen/powerpc64le-struct-align-128.rs
+++ b/tests/codegen/powerpc64le-struct-align-128.rs
@@ -1,6 +1,7 @@
 // Test that structs aligned to 128 bits are passed with the correct ABI on powerpc64le.
 // This is similar to aarch64-struct-align-128.rs, but for ppc.
 
+//@ add-core-stubs
 //@ compile-flags: --target powerpc64le-unknown-linux-gnu
 //@ needs-llvm-components: powerpc
 
@@ -8,12 +9,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Align8 {
diff --git a/tests/codegen/regparm-inreg.rs b/tests/codegen/regparm-inreg.rs
index 82e157311287..8dae3a83e4ed 100644
--- a/tests/codegen/regparm-inreg.rs
+++ b/tests/codegen/regparm-inreg.rs
@@ -2,6 +2,7 @@
 // marks function arguments as "inreg" like the C/C++ compilers for the platforms.
 // x86 only.
 
+//@ add-core-stubs
 //@ compile-flags: --target i686-unknown-linux-gnu -Cno-prepopulate-passes -Copt-level=3
 //@ needs-llvm-components: x86
 
@@ -14,10 +15,9 @@
 #![crate_type = "lib"]
 #![no_core]
 #![feature(no_core, lang_items, repr_simd)]
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+
+extern crate minicore;
+use minicore::*;
 
 pub mod tests {
     // regparm doesn't work for "fastcall" calling conv (only 2 inregs)
diff --git a/tests/codegen/repr/transparent-byval-struct-ptr.rs b/tests/codegen/repr/transparent-byval-struct-ptr.rs
index f9cfeb90390c..0918884144fc 100644
--- a/tests/codegen/repr/transparent-byval-struct-ptr.rs
+++ b/tests/codegen/repr/transparent-byval-struct-ptr.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: i686-linux i686-freebsd x64-linux x64-apple
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
 
@@ -21,14 +22,9 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
-impl Copy for [u32; 16] {}
 impl Copy for BigS {}
 impl Copy for BigU {}
 
diff --git a/tests/codegen/repr/transparent-imm-array.rs b/tests/codegen/repr/transparent-imm-array.rs
index f790d093cf4a..6dad04477845 100644
--- a/tests/codegen/repr/transparent-imm-array.rs
+++ b/tests/codegen/repr/transparent-imm-array.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: arm-linux arm-android armv7-linux armv7-android mips thumb sparc
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
 
@@ -27,14 +28,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for [u32; 16] {}
+extern crate minicore;
+use minicore::*;
 impl Copy for BigS {}
 impl Copy for BigU {}
 
diff --git a/tests/codegen/repr/transparent-mips64.rs b/tests/codegen/repr/transparent-mips64.rs
index 7282654b8562..98901350154e 100644
--- a/tests/codegen/repr/transparent-mips64.rs
+++ b/tests/codegen/repr/transparent-mips64.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: mips64 mips64el
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
 
@@ -13,14 +14,9 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
-impl Copy for [u32; 16] {}
 impl Copy for BigS {}
 impl Copy for BigU {}
 
diff --git a/tests/codegen/repr/transparent-opaque-ptr.rs b/tests/codegen/repr/transparent-opaque-ptr.rs
index 798b7e01bba5..7911370c478c 100644
--- a/tests/codegen/repr/transparent-opaque-ptr.rs
+++ b/tests/codegen/repr/transparent-opaque-ptr.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: aarch64-linux aarch64-darwin wasm32-wasip1
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
 
@@ -19,14 +20,9 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
-impl Copy for [u32; 16] {}
 impl Copy for BigS {}
 impl Copy for BigU {}
 
diff --git a/tests/codegen/repr/transparent-sparc64.rs b/tests/codegen/repr/transparent-sparc64.rs
index 05c090bd6721..62bfc8a5fce2 100644
--- a/tests/codegen/repr/transparent-sparc64.rs
+++ b/tests/codegen/repr/transparent-sparc64.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target sparc64-unknown-linux-gnu
 //@ needs-llvm-components: sparc
 
@@ -8,14 +9,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for [u32; 16] {}
+extern crate minicore;
+use minicore::*;
 impl Copy for BigS {}
 impl Copy for BigU {}
 
diff --git a/tests/codegen/repr/transparent-sysv64.rs b/tests/codegen/repr/transparent-sysv64.rs
index 99c855db9620..3efc3f7c3911 100644
--- a/tests/codegen/repr/transparent-sysv64.rs
+++ b/tests/codegen/repr/transparent-sysv64.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: linux apple win
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes
 
@@ -13,12 +14,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Rgb8 {
diff --git a/tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs b/tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
index 46f747ad4075..df99f6969fc1 100644
--- a/tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
+++ b/tests/codegen/riscv-abi/riscv64-lp64-lp64f-lp64d-abi.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --target riscv64gc-unknown-linux-gnu -Copt-level=3 -C no-prepopulate-passes -C panic=abort
 //@ needs-llvm-components: riscv
 
@@ -6,19 +7,8 @@
 #![feature(no_core, lang_items)]
 #![allow(improper_ctypes)]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for bool {}
-impl Copy for i8 {}
-impl Copy for u8 {}
-impl Copy for i32 {}
-impl Copy for i64 {}
-impl Copy for u64 {}
-impl Copy for f32 {}
-impl Copy for f64 {}
-impl<T> Copy for *mut T {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: define void @f_void()
 #[no_mangle]
diff --git a/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs b/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs
index bef8fe0c0441..d768ab9381aa 100644
--- a/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs
+++ b/tests/codegen/riscv-abi/riscv64-lp64d-abi.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target riscv64gc-unknown-linux-gnu
 //@ needs-llvm-components: riscv
 
@@ -6,12 +7,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: define void @f_fpr_tracking(double %0, double %1, double %2, double %3, double %4, double %5, double %6, double %7, i8 noundef zeroext %i)
 #[no_mangle]
diff --git a/tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs b/tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs
index 214370f424c2..361f03226904 100644
--- a/tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs
+++ b/tests/codegen/riscv-abi/riscv64-lp64f-lp64d-abi.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 -C no-prepopulate-passes --target riscv64gc-unknown-linux-gnu
 //@ needs-llvm-components: riscv
 
@@ -6,12 +7,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: define void @f_fpr_tracking(float %0, float %1, float %2, float %3, float %4, float %5, float %6, float %7, i8 noundef zeroext %i)
 #[no_mangle]
diff --git a/tests/codegen/riscv-target-abi.rs b/tests/codegen/riscv-target-abi.rs
index 88da4ece7ba3..d41fcb4dd845 100644
--- a/tests/codegen/riscv-target-abi.rs
+++ b/tests/codegen/riscv-target-abi.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions:riscv64gc riscv32gc riscv32imac
 
 //@[riscv64gc] compile-flags: --target=riscv64gc-unknown-linux-gnu
@@ -16,5 +17,5 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
diff --git a/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs b/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
index e2e14ab14a80..e1d7dc2d631f 100644
--- a/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
+++ b/tests/codegen/sanitizer/aarch64-shadow-call-stack-with-fixed-x18.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: aarch64 android
 //@[aarch64] compile-flags: --target aarch64-unknown-none -Zfixed-x18 -Zsanitizer=shadow-call-stack
 //@[aarch64] needs-llvm-components: aarch64
@@ -9,8 +10,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: ; Function Attrs:{{.*}}shadowcallstack
 #[no_mangle]
diff --git a/tests/codegen/sanitizer/kasan-emits-instrumentation.rs b/tests/codegen/sanitizer/kasan-emits-instrumentation.rs
index 56ee875286a2..774c9ab53f1e 100644
--- a/tests/codegen/sanitizer/kasan-emits-instrumentation.rs
+++ b/tests/codegen/sanitizer/kasan-emits-instrumentation.rs
@@ -1,5 +1,6 @@
 // Verifies that `-Zsanitizer=kernel-address` emits sanitizer instrumentation.
 
+//@ add-core-stubs
 //@ compile-flags: -Zsanitizer=kernel-address -Copt-level=0
 //@ revisions: aarch64 riscv64imac riscv64gc x86_64
 //@[aarch64] compile-flags: --target aarch64-unknown-none
@@ -15,13 +16,8 @@
 #![feature(no_core, no_sanitize, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for u8 {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK-LABEL: ; kasan_emits_instrumentation::unsanitized
 // CHECK-NEXT:  ; Function Attrs:
diff --git a/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs b/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
index d48e4016a16c..0be1ff197749 100644
--- a/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
+++ b/tests/codegen/sanitizer/kcfi/add-cfi-normalize-integers-flag.rs
@@ -1,5 +1,6 @@
 // Verifies that "cfi-normalize-integers" module flag is added.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,10 +12,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo() {}
 
diff --git a/tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs b/tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs
index 013de74f8d68..eabe0409c9a3 100644
--- a/tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs
+++ b/tests/codegen/sanitizer/kcfi/add-kcfi-flag.rs
@@ -1,5 +1,6 @@
 // Verifies that "kcfi" module flag is added.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,10 +12,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo() {}
 
diff --git a/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs b/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
index b4924719f4c1..2f18c9d84b90 100644
--- a/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
+++ b/tests/codegen/sanitizer/kcfi/add-kcfi-offset-flag.rs
@@ -1,5 +1,6 @@
 // Verifies that "kcfi-offset" module flag is added.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,10 +12,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo() {}
 
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
index ba2e397f6daa..6b40918dd3af 100644
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
+++ b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-attr-no-sanitize.rs
@@ -1,5 +1,6 @@
 // Verifies that KCFI operand bundles are omitted.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,12 +12,8 @@
 #![feature(no_core, no_sanitize, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i32 {}
+extern crate minicore;
+use minicore::*;
 
 #[no_sanitize(kcfi)]
 pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
index 4e95bdf4d7c4..942b50deb028 100644
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
+++ b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-generalized.rs
@@ -1,5 +1,6 @@
 // Verifies that generalized KCFI type metadata for functions are emitted.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,12 +12,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i32 {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}foo
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
index 31b43b509880..c89d9bdd1217 100644
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
+++ b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized-generalized.rs
@@ -1,5 +1,6 @@
 // Verifies that normalized and generalized KCFI type metadata for functions are emitted.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,12 +12,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i32 {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}foo
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
index 4755f6062aaa..220cae1a4fa3 100644
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
+++ b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi-normalized.rs
@@ -1,5 +1,6 @@
 // Verifies that normalized KCFI type metadata for functions are emitted.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,12 +12,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i32 {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}foo
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
index be9760bd9afa..bb9a00059030 100644
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
+++ b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle-itanium-cxx-abi.rs
@@ -1,5 +1,6 @@
 // Verifies that KCFI type metadata for functions are emitted.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,12 +12,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i32 {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}foo
diff --git a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
index c9c94cdb3292..8b844b991429 100644
--- a/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
+++ b/tests/codegen/sanitizer/kcfi/emit-kcfi-operand-bundle.rs
@@ -1,5 +1,6 @@
 // Verifies that KCFI operand bundles are emitted.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,12 +12,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for i32 {}
+extern crate minicore;
+use minicore::*;
 
 pub fn foo(f: fn(i32) -> i32, arg: i32) -> i32 {
     // CHECK-LABEL: define{{.*}}foo{{.*}}!{{<unknown kind #36>|kcfi_type}} !{{[0-9]+}}
diff --git a/tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs b/tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
index 5ab55a467268..15c107bea158 100644
--- a/tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
+++ b/tests/codegen/sanitizer/kcfi/emit-type-metadata-trait-objects.rs
@@ -1,5 +1,6 @@
 // Verifies that type metadata identifiers for trait objects are emitted correctly.
 //
+//@ add-core-stubs
 //@ revisions: aarch64 x86_64
 //@ [aarch64] compile-flags: --target aarch64-unknown-none
 //@ [aarch64] needs-llvm-components: aarch64
@@ -11,29 +12,8 @@
 #![feature(arbitrary_self_types, no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl<T: ?Sized> Copy for &T {}
-#[lang = "legacy_receiver"]
-trait LegacyReceiver {}
-#[lang = "dispatch_from_dyn"]
-trait DispatchFromDyn<T> {}
-impl<'a, T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<&'a U> for &'a T {}
-#[lang = "unsize"]
-trait Unsize<T: ?Sized> {}
-#[lang = "coerce_unsized"]
-pub trait CoerceUnsized<T: ?Sized> {}
-impl<'a, 'b: 'a, T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<&'a U> for &'b T {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "drop_in_place"]
-fn drop_in_place_fn<T>() {}
-#[lang = "drop"]
-trait Drop {
-    fn drop(&mut self);
-}
+extern crate minicore;
+use minicore::*;
 
 pub trait Trait1 {
     fn foo(&self);
diff --git a/tests/codegen/sanitizer/riscv64-shadow-call-stack.rs b/tests/codegen/sanitizer/riscv64-shadow-call-stack.rs
index 5833b832ba40..945e46218d04 100644
--- a/tests/codegen/sanitizer/riscv64-shadow-call-stack.rs
+++ b/tests/codegen/sanitizer/riscv64-shadow-call-stack.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --target riscv64imac-unknown-none-elf -Zsanitizer=shadow-call-stack
 //@ needs-llvm-components: riscv
 
@@ -6,8 +7,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 // CHECK: ; Function Attrs:{{.*}}shadowcallstack
 // CHECK: define dso_local void @foo() unnamed_addr #0
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
index 4a5a6391c052..485ba92272dd 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-abs.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_fabs;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_fabs<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @fabs_32x2
 #[no_mangle]
 pub unsafe fn fabs_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
index 89e54f579ff7..e8bda7c29c4b 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-ceil.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_ceil;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_ceil<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @ceil_32x2
 #[no_mangle]
 pub unsafe fn ceil_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
index b40fd5365de5..8dc967bc3adc 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-cos.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_fcos;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_fcos<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @fcos_32x2
 #[no_mangle]
 pub unsafe fn fcos_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
index fef003dde5bb..00caca2f2949 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_fexp;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_fexp<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @exp_32x2
 #[no_mangle]
 pub unsafe fn exp_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
index 779c0fc403a3..eda4053189cb 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-exp2.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_fexp2;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_fexp2<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @exp2_32x2
 #[no_mangle]
 pub unsafe fn exp2_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
index b2bd27a5b75c..ad69d4cdd88c 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-floor.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_floor;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_floor<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @floor_32x2
 #[no_mangle]
 pub unsafe fn floor_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
index 37f4782626ad..cbeefdc31c0d 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fma.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_fma;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_fma<T>(x: T, b: T, c: T) -> T;
-}
-
 // CHECK-LABEL: @fma_32x2
 #[no_mangle]
 pub unsafe fn fma_32x2(a: f32x2, b: f32x2, c: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
index 336adf6db73f..618daa4b44d0 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-fsqrt.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_fsqrt;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_fsqrt<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @fsqrt_32x2
 #[no_mangle]
 pub unsafe fn fsqrt_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
index 8e97abc3a661..98a481e4004e 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_flog;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_flog<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @log_32x2
 #[no_mangle]
 pub unsafe fn log_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
index 1d4d4dc24e9a..9108cd963f02 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log10.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_flog10;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_flog10<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @log10_32x2
 #[no_mangle]
 pub unsafe fn log10_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
index 28f2f1516175..2b20850dbd9a 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-log2.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_flog2;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_flog2<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @log2_32x2
 #[no_mangle]
 pub unsafe fn log2_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
index 50c51bebe37e..ce07b212e846 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-minmax.rs
@@ -1,19 +1,15 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_fmax, simd_fmin};
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x4(pub [f32; 4]);
 
-extern "rust-intrinsic" {
-    fn simd_fmin<T>(x: T, y: T) -> T;
-    fn simd_fmax<T>(x: T, y: T) -> T;
-}
-
 // CHECK-LABEL: @fmin
 #[no_mangle]
 pub unsafe fn fmin(a: f32x4, b: f32x4) -> f32x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-pow.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-pow.rs
deleted file mode 100644
index 3527f71c00b4..000000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-pow.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
-
-extern "rust-intrinsic" {
-    fn simd_fpow<T>(x: T, b: T) -> T;
-}
-
-// CHECK-LABEL: @fpow_32x2
-#[no_mangle]
-pub unsafe fn fpow_32x2(a: f32x2, b: f32x2) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.pow.v2f32
-    simd_fpow(a, b)
-}
-
-// CHECK-LABEL: @fpow_32x4
-#[no_mangle]
-pub unsafe fn fpow_32x4(a: f32x4, b: f32x4) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.pow.v4f32
-    simd_fpow(a, b)
-}
-
-// CHECK-LABEL: @fpow_32x8
-#[no_mangle]
-pub unsafe fn fpow_32x8(a: f32x8, b: f32x8) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.pow.v8f32
-    simd_fpow(a, b)
-}
-
-// CHECK-LABEL: @fpow_32x16
-#[no_mangle]
-pub unsafe fn fpow_32x16(a: f32x16, b: f32x16) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.pow.v16f32
-    simd_fpow(a, b)
-}
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
-// CHECK-LABEL: @fpow_64x4
-#[no_mangle]
-pub unsafe fn fpow_64x4(a: f64x4, b: f64x4) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.pow.v4f64
-    simd_fpow(a, b)
-}
-
-// CHECK-LABEL: @fpow_64x2
-#[no_mangle]
-pub unsafe fn fpow_64x2(a: f64x2, b: f64x2) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.pow.v2f64
-    simd_fpow(a, b)
-}
-
-// CHECK-LABEL: @fpow_64x8
-#[no_mangle]
-pub unsafe fn fpow_64x8(a: f64x8, b: f64x8) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.pow.v8f64
-    simd_fpow(a, b)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-powi.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-powi.rs
deleted file mode 100644
index 4f0b5e4e01a3..000000000000
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-powi.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-//@ compile-flags: -C no-prepopulate-passes
-
-#![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
-#![allow(non_camel_case_types)]
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x2(pub [f32; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x4(pub [f32; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x8(pub [f32; 8]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f32x16(pub [f32; 16]);
-
-extern "rust-intrinsic" {
-    fn simd_fpowi<T>(x: T, b: i32) -> T;
-}
-
-// CHECK-LABEL: @fpowi_32x2
-#[no_mangle]
-pub unsafe fn fpowi_32x2(a: f32x2, b: i32) -> f32x2 {
-    // CHECK: call <2 x float> @llvm.powi.v2f32
-    simd_fpowi(a, b)
-}
-
-// CHECK-LABEL: @fpowi_32x4
-#[no_mangle]
-pub unsafe fn fpowi_32x4(a: f32x4, b: i32) -> f32x4 {
-    // CHECK: call <4 x float> @llvm.powi.v4f32
-    simd_fpowi(a, b)
-}
-
-// CHECK-LABEL: @fpowi_32x8
-#[no_mangle]
-pub unsafe fn fpowi_32x8(a: f32x8, b: i32) -> f32x8 {
-    // CHECK: call <8 x float> @llvm.powi.v8f32
-    simd_fpowi(a, b)
-}
-
-// CHECK-LABEL: @fpowi_32x16
-#[no_mangle]
-pub unsafe fn fpowi_32x16(a: f32x16, b: i32) -> f32x16 {
-    // CHECK: call <16 x float> @llvm.powi.v16f32
-    simd_fpowi(a, b)
-}
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x2(pub [f64; 2]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x4(pub [f64; 4]);
-
-#[repr(simd)]
-#[derive(Copy, Clone, PartialEq, Debug)]
-pub struct f64x8(pub [f64; 8]);
-
-// CHECK-LABEL: @fpowi_64x4
-#[no_mangle]
-pub unsafe fn fpowi_64x4(a: f64x4, b: i32) -> f64x4 {
-    // CHECK: call <4 x double> @llvm.powi.v4f64
-    simd_fpowi(a, b)
-}
-
-// CHECK-LABEL: @fpowi_64x2
-#[no_mangle]
-pub unsafe fn fpowi_64x2(a: f64x2, b: i32) -> f64x2 {
-    // CHECK: call <2 x double> @llvm.powi.v2f64
-    simd_fpowi(a, b)
-}
-
-// CHECK-LABEL: @fpowi_64x8
-#[no_mangle]
-pub unsafe fn fpowi_64x8(a: f64x8, b: i32) -> f64x8 {
-    // CHECK: call <8 x double> @llvm.powi.v8f64
-    simd_fpowi(a, b)
-}
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
index 4173809e3a9b..7de26b415bbb 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-float-sin.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_fsin;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x2(pub [f32; 2]);
@@ -21,10 +22,6 @@ pub struct f32x8(pub [f32; 8]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x16(pub [f32; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_fsin<T>(x: T) -> T;
-}
-
 // CHECK-LABEL: @fsin_32x2
 #[no_mangle]
 pub unsafe fn fsin_32x2(a: f32x2) -> f32x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
index a5afa27876a0..ecf5eb24ee5b 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-arithmetic-saturating.rs
@@ -1,71 +1,71 @@
 //@ compile-flags: -C no-prepopulate-passes
-//
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 #![deny(unused)]
 
-// signed integer types
+use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i8x2([i8; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i8x4([i8; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i8x8([i8; 8]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i8x16([i8; 16]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i8x32([i8; 32]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i8x64([i8; 64]);
+#[rustfmt::skip]
+mod types {
+    // signed integer types
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i16x2([i16; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i16x4([i16; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i16x8([i16; 8]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i16x16([i16; 16]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i16x32([i16; 32]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x2([i8; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x4([i8; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x8([i8; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x16([i8; 16]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x32([i8; 32]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i8x64([i8; 64]);
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i32x2([i32; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i32x4([i32; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i32x8([i32; 8]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i32x16([i32; 16]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x2([i16; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x4([i16; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x8([i16; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x16([i16; 16]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i16x32([i16; 32]);
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i64x2([i64; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i64x4([i64; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i64x8([i64; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x2([i32; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x4([i32; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x8([i32; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i32x16([i32; 16]);
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i128x2([i128; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct i128x4([i128; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x2([i64; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x4([i64; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i64x8([i64; 8]);
 
-// unsigned integer types
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i128x2([i128; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct i128x4([i128; 4]);
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u8x2([u8; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u8x4([u8; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u8x8([u8; 8]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u8x16([u8; 16]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u8x32([u8; 32]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u8x64([u8; 64]);
+    // unsigned integer types
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u16x2([u16; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u16x4([u16; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u16x8([u16; 8]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u16x16([u16; 16]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u16x32([u16; 32]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x2([u8; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x4([u8; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x8([u8; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x16([u8; 16]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x32([u8; 32]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u8x64([u8; 64]);
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u32x2([u32; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u32x4([u32; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u32x8([u32; 8]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u32x16([u32; 16]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x2([u16; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x4([u16; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x8([u16; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x16([u16; 16]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u16x32([u16; 32]);
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u64x2([u64; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u64x4([u64; 4]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u64x8([u64; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x2([u32; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x4([u32; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x8([u32; 8]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u32x16([u32; 16]);
 
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u128x2([u128; 2]);
-#[repr(simd)] #[derive(Copy, Clone)] pub struct u128x4([u128; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x2([u64; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x4([u64; 4]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u64x8([u64; 8]);
 
-extern "rust-intrinsic" {
-    fn simd_saturating_add<T>(x: T, y: T) -> T;
-    fn simd_saturating_sub<T>(x: T, y: T) -> T;
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u128x2([u128; 2]);
+    #[repr(simd)] #[derive(Copy, Clone)] pub struct u128x4([u128; 4]);
 }
 
+use types::*;
+
 // NOTE(eddyb) `%{{x|0}}` is used because on some targets (e.g. WASM)
 // SIMD vectors are passed directly, resulting in `%x` being a vector,
 // while on others they're passed indirectly, resulting in `%x` being
@@ -213,8 +213,6 @@ pub unsafe fn sadd_i128x4(x: i128x4, y: i128x4) -> i128x4 {
     simd_saturating_add(x, y)
 }
 
-
-
 // CHECK-LABEL: @uadd_u8x2
 #[no_mangle]
 pub unsafe fn uadd_u8x2(x: u8x2, y: u8x2) -> u8x2 {
@@ -355,10 +353,6 @@ pub unsafe fn uadd_u128x4(x: u128x4, y: u128x4) -> u128x4 {
     simd_saturating_add(x, y)
 }
 
-
-
-
-
 // CHECK-LABEL: @ssub_i8x2
 #[no_mangle]
 pub unsafe fn ssub_i8x2(x: i8x2, y: i8x2) -> i8x2 {
@@ -499,8 +493,6 @@ pub unsafe fn ssub_i128x4(x: i128x4, y: i128x4) -> i128x4 {
     simd_saturating_sub(x, y)
 }
 
-
-
 // CHECK-LABEL: @usub_u8x2
 #[no_mangle]
 pub unsafe fn usub_u8x2(x: u8x2, y: u8x2) -> u8x2 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
index e9112f1f321b..a2c40aa91b51 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-bitmask.rs
@@ -2,10 +2,11 @@
 //
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_bitmask;
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct u32x2([u32; 2]);
@@ -18,10 +19,6 @@ pub struct i32x2([i32; 2]);
 #[derive(Copy, Clone)]
 pub struct i8x16([i8; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_bitmask<T, U>(x: T) -> U;
-}
-
 // NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
 // SIMD vectors are passed directly, resulting in `%x` being a vector,
 // while on others they're passed indirectly, resulting in `%x` being
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
index 7f99f695bf4f..9bb46a3546bf 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-gather.rs
@@ -3,10 +3,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_gather;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec2<T>(pub [T; 2]);
@@ -15,14 +16,13 @@ pub struct Vec2<T>(pub [T; 2]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec4<T>(pub [T; 4]);
 
-extern "rust-intrinsic" {
-    fn simd_gather<T, P, M>(value: T, pointers: P, mask: M) -> T;
-}
-
 // CHECK-LABEL: @gather_f32x2
 #[no_mangle]
-pub unsafe fn gather_f32x2(pointers: Vec2<*const f32>, mask: Vec2<i32>,
-                           values: Vec2<f32>) -> Vec2<f32> {
+pub unsafe fn gather_f32x2(
+    pointers: Vec2<*const f32>,
+    mask: Vec2<i32>,
+    values: Vec2<f32>,
+) -> Vec2<f32> {
     // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
     // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
     // CHECK: call <2 x float> @llvm.masked.gather.v2f32.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x float> {{.*}})
@@ -31,8 +31,11 @@ pub unsafe fn gather_f32x2(pointers: Vec2<*const f32>, mask: Vec2<i32>,
 
 // CHECK-LABEL: @gather_pf32x2
 #[no_mangle]
-pub unsafe fn gather_pf32x2(pointers: Vec2<*const *const f32>, mask: Vec2<i32>,
-                           values: Vec2<*const f32>) -> Vec2<*const f32> {
+pub unsafe fn gather_pf32x2(
+    pointers: Vec2<*const *const f32>,
+    mask: Vec2<i32>,
+    values: Vec2<*const f32>,
+) -> Vec2<*const f32> {
     // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
     // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
     // CHECK: call <2 x ptr> @llvm.masked.gather.v2p0.v2p0(<2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]], <2 x ptr> {{.*}})
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
index 7f46630e920d..fcc4cb5d6300 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-load.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_masked_load;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec2<T>(pub [T; 2]);
@@ -13,14 +14,9 @@ pub struct Vec2<T>(pub [T; 2]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec4<T>(pub [T; 4]);
 
-extern "rust-intrinsic" {
-    fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
-}
-
 // CHECK-LABEL: @load_f32x2
 #[no_mangle]
-pub unsafe fn load_f32x2(mask: Vec2<i32>, pointer: *const f32,
-                         values: Vec2<f32>) -> Vec2<f32> {
+pub unsafe fn load_f32x2(mask: Vec2<i32>, pointer: *const f32, values: Vec2<f32>) -> Vec2<f32> {
     // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
     // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
     // CHECK: call <2 x float> @llvm.masked.load.v2f32.p0(ptr {{.*}}, i32 4, <2 x i1> [[B]], <2 x float> {{.*}})
@@ -29,8 +25,11 @@ pub unsafe fn load_f32x2(mask: Vec2<i32>, pointer: *const f32,
 
 // CHECK-LABEL: @load_pf32x4
 #[no_mangle]
-pub unsafe fn load_pf32x4(mask: Vec4<i32>, pointer: *const *const f32,
-                          values: Vec4<*const f32>) -> Vec4<*const f32> {
+pub unsafe fn load_pf32x4(
+    mask: Vec4<i32>,
+    pointer: *const *const f32,
+    values: Vec4<*const f32>,
+) -> Vec4<*const f32> {
     // CHECK: [[A:%[0-9]+]] = lshr <4 x i32> {{.*}}, {{<i32 31, i32 31, i32 31, i32 31>|splat \(i32 31\)}}
     // CHECK: [[B:%[0-9]+]] = trunc <4 x i32> [[A]] to <4 x i1>
     // CHECK: call <4 x ptr> @llvm.masked.load.v4p0.p0(ptr {{.*}}, i32 {{.*}}, <4 x i1> [[B]], <4 x ptr> {{.*}})
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
index 0d43234f1e29..04f4a0c63829 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-masked-store.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_masked_store;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec2<T>(pub [T; 2]);
@@ -13,10 +14,6 @@ pub struct Vec2<T>(pub [T; 2]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec4<T>(pub [T; 4]);
 
-extern "rust-intrinsic" {
-    fn simd_masked_store<M, P, T>(mask: M, pointer: P, values: T) -> ();
-}
-
 // CHECK-LABEL: @store_f32x2
 #[no_mangle]
 pub unsafe fn store_f32x2(mask: Vec2<i32>, pointer: *mut f32, values: Vec2<f32>) {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
index ef7827bd96f0..9506f8f6d3a8 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-scatter.rs
@@ -3,10 +3,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_scatter;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec2<T>(pub [T; 2]);
@@ -15,25 +16,22 @@ pub struct Vec2<T>(pub [T; 2]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct Vec4<T>(pub [T; 4]);
 
-extern "rust-intrinsic" {
-    fn simd_scatter<T, P, M>(value: T, pointers: P, mask: M);
-}
-
 // CHECK-LABEL: @scatter_f32x2
 #[no_mangle]
-pub unsafe fn scatter_f32x2(pointers: Vec2<*mut f32>, mask: Vec2<i32>,
-                            values: Vec2<f32>) {
+pub unsafe fn scatter_f32x2(pointers: Vec2<*mut f32>, mask: Vec2<i32>, values: Vec2<f32>) {
     // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
     // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
     // CHECK: call void @llvm.masked.scatter.v2f32.v2p0(<2 x float> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
     simd_scatter(values, pointers, mask)
 }
 
-
 // CHECK-LABEL: @scatter_pf32x2
 #[no_mangle]
-pub unsafe fn scatter_pf32x2(pointers: Vec2<*mut *const f32>, mask: Vec2<i32>,
-                             values: Vec2<*const f32>) {
+pub unsafe fn scatter_pf32x2(
+    pointers: Vec2<*mut *const f32>,
+    mask: Vec2<i32>,
+    values: Vec2<*const f32>,
+) {
     // CHECK: [[A:%[0-9]+]] = lshr <2 x i32> {{.*}}, {{<i32 31, i32 31>|splat \(i32 31\)}}
     // CHECK: [[B:%[0-9]+]] = trunc <2 x i32> [[A]] to <2 x i1>
     // CHECK: call void @llvm.masked.scatter.v2p0.v2p0(<2 x ptr> {{.*}}, <2 x ptr> {{.*}}, i32 {{.*}}, <2 x i1> [[B]]
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
index 33ed2b437f9b..71279d9f0eac 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-generic-select.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
 
 #![crate_type = "lib"]
-
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_select, simd_select_bitmask};
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct f32x4(pub [f32; 4]);
@@ -21,11 +22,6 @@ pub struct b8x4(pub [i8; 4]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub struct i32x4([i32; 4]);
 
-extern "rust-intrinsic" {
-    fn simd_select<T, U>(x: T, a: U, b: U) -> U;
-    fn simd_select_bitmask<T, U>(x: T, a: U, b: U) -> U;
-}
-
 // CHECK-LABEL: @select_m8
 #[no_mangle]
 pub unsafe fn select_m8(m: b8x4, a: f32x4, b: f32x4) -> f32x4 {
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
index 92067db9b153..269fe41225ef 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-mask-reduce.rs
@@ -1,10 +1,11 @@
 //@ compile-flags: -C no-prepopulate-passes
-//
 
 #![crate_type = "lib"]
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_reduce_all, simd_reduce_any};
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct mask32x2([i32; 2]);
@@ -13,11 +14,6 @@ pub struct mask32x2([i32; 2]);
 #[derive(Copy, Clone)]
 pub struct mask8x16([i8; 16]);
 
-extern "rust-intrinsic" {
-    fn simd_reduce_all<T>(x: T) -> bool;
-    fn simd_reduce_any<T>(x: T) -> bool;
-}
-
 // NOTE(eddyb) `%{{x|1}}` is used because on some targets (e.g. WASM)
 // SIMD vectors are passed directly, resulting in `%x` being a vector,
 // while on others they're passed indirectly, resulting in `%x` being
diff --git a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs b/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
index 0d21d5105576..d3853361de9e 100644
--- a/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
+++ b/tests/codegen/simd-intrinsic/simd-intrinsic-transmute-array.rs
@@ -12,7 +12,7 @@
 
 #![crate_type = "lib"]
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
diff --git a/tests/codegen/simd/simd_arith_offset.rs b/tests/codegen/simd/simd_arith_offset.rs
index e14fce1d4187..b8af6fce3326 100644
--- a/tests/codegen/simd/simd_arith_offset.rs
+++ b/tests/codegen/simd/simd_arith_offset.rs
@@ -3,11 +3,9 @@
 //
 
 #![crate_type = "lib"]
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-extern "rust-intrinsic" {
-    pub(crate) fn simd_arith_offset<T, U>(ptrs: T, offsets: U) -> T;
-}
+use std::intrinsics::simd::simd_arith_offset;
 
 /// A vector of *const T.
 #[derive(Debug, Copy, Clone)]
diff --git a/tests/codegen/some-abis-do-extend-params-to-32-bits.rs b/tests/codegen/some-abis-do-extend-params-to-32-bits.rs
index 10970cacdcf0..6ca6697588fd 100644
--- a/tests/codegen/some-abis-do-extend-params-to-32-bits.rs
+++ b/tests/codegen/some-abis-do-extend-params-to-32-bits.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: -Cno-prepopulate-passes -Copt-level=0
 
 //@ revisions:x86_64 i686 aarch64-apple aarch64-windows aarch64-linux arm riscv
@@ -24,12 +25,8 @@
 #![no_std]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 // The patterns in this file are written in the style of a table to make the
 // uniformities and distinctions more apparent.
diff --git a/tests/codegen/sparc-struct-abi.rs b/tests/codegen/sparc-struct-abi.rs
index 0a8720c4fcae..32d2c5bb0ef8 100644
--- a/tests/codegen/sparc-struct-abi.rs
+++ b/tests/codegen/sparc-struct-abi.rs
@@ -1,17 +1,14 @@
 // Checks that we correctly codegen extern "C" functions returning structs.
 // See issues #52638 and #86163.
 
+//@ add-core-stubs
 //@ compile-flags: -Copt-level=3 --target=sparc64-unknown-linux-gnu --crate-type=rlib
 //@ needs-llvm-components: sparc
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "freeze"]
-trait Freeze {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 pub struct Bool {
diff --git a/tests/codegen/stack-probes-inline.rs b/tests/codegen/stack-probes-inline.rs
index c5073b9cc221..746272b09941 100644
--- a/tests/codegen/stack-probes-inline.rs
+++ b/tests/codegen/stack-probes-inline.rs
@@ -1,6 +1,7 @@
 // Check the "probe-stack" attribute for targets with `StackProbeType::Inline`,
 // or `StackProbeType::InlineOrCall` when running on newer LLVM.
 
+//@ add-core-stubs
 //@ compile-flags: -C no-prepopulate-passes
 //@ revisions: aarch64 powerpc powerpc64 powerpc64le s390x i686 x86_64
 //@[aarch64] compile-flags: --target aarch64-unknown-linux-gnu
@@ -22,8 +23,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub fn foo() {
diff --git a/tests/codegen/target-feature-overrides.rs b/tests/codegen/target-feature-overrides.rs
index f38a1ae72de5..0fc1e0136b3f 100644
--- a/tests/codegen/target-feature-overrides.rs
+++ b/tests/codegen/target-feature-overrides.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: COMPAT INCOMPAT
 //@ needs-llvm-components: x86
 //@ compile-flags: --target=x86_64-unknown-linux-gnu -Copt-level=3
@@ -9,10 +10,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 extern "C" {
     fn peach() -> u32;
diff --git a/tests/codegen/tied-features-strength.rs b/tests/codegen/tied-features-strength.rs
index 1b2b63c3d1ac..8b1f3b14fc30 100644
--- a/tests/codegen/tied-features-strength.rs
+++ b/tests/codegen/tied-features-strength.rs
@@ -1,4 +1,5 @@
 // ignore-tidy-linelength
+//@ add-core-stubs
 //@ revisions: ENABLE_SVE DISABLE_SVE DISABLE_NEON ENABLE_NEON
 //@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
 //@ needs-llvm-components: aarch64
@@ -22,7 +23,7 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 pub fn test() {}
diff --git a/tests/codegen/uninhabited-transparent-return-abi.rs b/tests/codegen/uninhabited-transparent-return-abi.rs
index 6e8b1683163e..face1577c3f6 100644
--- a/tests/codegen/uninhabited-transparent-return-abi.rs
+++ b/tests/codegen/uninhabited-transparent-return-abi.rs
@@ -24,7 +24,7 @@ extern "Rust" {
 pub fn test_uninhabited_ret_by_ref() {
     // CHECK: %_1 = alloca [24 x i8], align {{8|4}}
     // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %_1)
-    // CHECK-NEXT: call void @opaque(ptr noalias nocapture noundef nonnull sret([24 x i8]) align {{8|4}} dereferenceable(24) %_1) #2
+    // CHECK-NEXT: call void @opaque({{.*}} sret([24 x i8]) {{.*}} %_1) #2
     // CHECK-NEXT: unreachable
     unsafe {
         opaque();
@@ -36,7 +36,7 @@ pub fn test_uninhabited_ret_by_ref() {
 pub fn test_uninhabited_ret_by_ref_with_arg(rsi: u32) {
     // CHECK: %_2 = alloca [24 x i8], align {{8|4}}
     // CHECK-NEXT: call void @llvm.lifetime.start.p0(i64 24, ptr nonnull %_2)
-    // CHECK-NEXT: call void @opaque_with_arg(ptr noalias nocapture noundef nonnull sret([24 x i8]) align {{8|4}} dereferenceable(24) %_2, i32 noundef %rsi) #2
+    // CHECK-NEXT: call void @opaque_with_arg({{.*}} sret([24 x i8]) {{.*}} %_2, i32 noundef %rsi) #2
     // CHECK-NEXT: unreachable
     unsafe {
         opaque_with_arg(rsi);
diff --git a/tests/codegen/uninit-consts.rs b/tests/codegen/uninit-consts.rs
index 649927b87b40..a58008e171e2 100644
--- a/tests/codegen/uninit-consts.rs
+++ b/tests/codegen/uninit-consts.rs
@@ -11,15 +11,15 @@ pub struct PartiallyUninit {
     y: MaybeUninit<[u8; 10]>,
 }
 
-// CHECK: [[FULLY_UNINIT:@[0-9]+]] = private unnamed_addr constant <{ [10 x i8] }> undef
+// CHECK: [[FULLY_UNINIT:@.*]] = private unnamed_addr constant <{ [10 x i8] }> undef
 
-// CHECK: [[PARTIALLY_UNINIT:@[0-9]+]] = private unnamed_addr constant <{ [4 x i8], [12 x i8] }> <{ [4 x i8] c"{{\\EF\\BE\\AD\\DE|\\DE\\AD\\BE\\EF}}", [12 x i8] undef }>, align 4
+// CHECK: [[PARTIALLY_UNINIT:@.*]] = private unnamed_addr constant <{ [4 x i8], [12 x i8] }> <{ [4 x i8] c"{{\\EF\\BE\\AD\\DE|\\DE\\AD\\BE\\EF}}", [12 x i8] undef }>, align 4
 
 // This shouldn't contain undef, since it contains more chunks
 // than the default value of uninit_const_chunk_threshold.
-// CHECK: [[UNINIT_PADDING_HUGE:@[0-9]+]] = private unnamed_addr constant <{ [32768 x i8] }> <{ [32768 x i8] c"{{.+}}" }>, align 4
+// CHECK: [[UNINIT_PADDING_HUGE:@.*]] = private unnamed_addr constant <{ [32768 x i8] }> <{ [32768 x i8] c"{{.+}}" }>, align 4
 
-// CHECK: [[FULLY_UNINIT_HUGE:@[0-9]+]] = private unnamed_addr constant <{ [16384 x i8] }> undef
+// CHECK: [[FULLY_UNINIT_HUGE:@.*]] = private unnamed_addr constant <{ [16384 x i8] }> undef
 
 // CHECK-LABEL: @fully_uninit
 #[no_mangle]
diff --git a/tests/codegen/virtual-call-attrs-issue-137646.rs b/tests/codegen/virtual-call-attrs-issue-137646.rs
new file mode 100644
index 000000000000..5e453947f27d
--- /dev/null
+++ b/tests/codegen/virtual-call-attrs-issue-137646.rs
@@ -0,0 +1,37 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/137646.
+//! Since we don't know the exact implementation of the virtual call,
+//! it might write to parameters, we can't infer the readonly attribute.
+//@ compile-flags: -C opt-level=3 -C no-prepopulate-passes
+
+#![crate_type = "lib"]
+#![feature(rustc_attrs)]
+
+pub trait Trait {
+    #[rustc_nounwind]
+    fn m(&self, _: (i32, i32, i32)) {}
+}
+
+#[no_mangle]
+pub fn foo(trait_: &dyn Trait) {
+    // CHECK-LABEL: @foo(
+    // CHECK: call void
+    // CHECK-NOT: readonly
+    trait_.m((1, 1, 1));
+}
+
+#[no_mangle]
+#[rustc_nounwind]
+pub fn foo_nounwind(trait_: &dyn Trait) {
+    // CHECK-LABEL: @foo_nounwind(
+    // FIXME: Here should be invoke.
+    // COM: CHECK: invoke
+    trait_.m((1, 1, 1));
+}
+
+#[no_mangle]
+pub extern "C" fn c_nounwind(trait_: &dyn Trait) {
+    // CHECK-LABEL: @c_nounwind(
+    // FIXME: Here should be invoke.
+    // COM: CHECK: invoke
+    trait_.m((1, 1, 1));
+}
diff --git a/tests/crashes/117877.rs b/tests/crashes/117877.rs
deleted file mode 100644
index b1effc0cbcb1..000000000000
--- a/tests/crashes/117877.rs
+++ /dev/null
@@ -1,13 +0,0 @@
-//@ known-bug: #117877
-//@ edition:2021
-//@ needs-rustc-debug-assertions
-//@ only-x86_64
-#![feature(asm_const)]
-
-use std::arch::asm;
-
-async unsafe fn foo<'a>() {
-    asm!("/* {0} */", const N);
-}
-
-fn main() {}
diff --git a/tests/incremental/issue-61530.rs b/tests/incremental/issue-61530.rs
index 71ac39d0e039..673556a9d02f 100644
--- a/tests/incremental/issue-61530.rs
+++ b/tests/incremental/issue-61530.rs
@@ -1,14 +1,12 @@
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
 //@ revisions:rpass1 rpass2
 
+use std::intrinsics::simd::simd_shuffle;
+
 #[repr(simd)]
 struct I32x2([i32; 2]);
 
-extern "rust-intrinsic" {
-    fn simd_shuffle<T, I, U>(x: T, y: T, idx: I) -> U;
-}
-
 #[repr(simd)]
 struct SimdShuffleIdx<const LEN: usize>([u32; LEN]);
 
diff --git a/tests/mir-opt/issues/issue_75439.rs b/tests/mir-opt/issues/issue_75439.rs
index ea763dd1b10d..d7883f0dc71f 100644
--- a/tests/mir-opt/issues/issue_75439.rs
+++ b/tests/mir-opt/issues/issue_75439.rs
@@ -1,10 +1,14 @@
-// skip-filecheck
 // EMIT_MIR issue_75439.foo.MatchBranchSimplification.diff
 //@ ignore-endian-big
 
 use std::mem::transmute;
 
 pub fn foo(bytes: [u8; 16]) -> Option<[u8; 4]> {
+    // CHECK-LABEL: fn foo(
+    // CHECK: bb2: {
+    // CHECK-NEXT: 0: [[bb:bb[0-9]+]],
+    // CHECK-SAME: {{[0-9]+}}: [[bb]],
+
     // big endian `u32`s
     let dwords: [u32; 4] = unsafe { transmute(bytes) };
     const FF: u32 = 0x0000_ffff_u32.to_be();
diff --git a/tests/pretty/hir-pretty-attr.pp b/tests/pretty/hir-pretty-attr.pp
new file mode 100644
index 000000000000..586810b00466
--- /dev/null
+++ b/tests/pretty/hir-pretty-attr.pp
@@ -0,0 +1,11 @@
+#[prelude_import]
+use ::std::prelude::rust_2015::*;
+#[macro_use]
+extern crate std;
+//@ pretty-compare-only
+//@ pretty-mode:hir
+//@ pp-exact:hir-pretty-attr.pp
+
+#[attr="Repr([ReprC, ReprPacked(Align(4 bytes)), ReprTransparent])")]
+struct Example {
+}
diff --git a/tests/pretty/hir-pretty-attr.rs b/tests/pretty/hir-pretty-attr.rs
new file mode 100644
index 000000000000..eb5a677024a8
--- /dev/null
+++ b/tests/pretty/hir-pretty-attr.rs
@@ -0,0 +1,7 @@
+//@ pretty-compare-only
+//@ pretty-mode:hir
+//@ pp-exact:hir-pretty-attr.pp
+
+#[repr(C, packed(4))]
+#[repr(transparent)]
+struct Example {}
diff --git a/tests/run-make/const_fn_mir/dump.mir b/tests/run-make/const_fn_mir/dump.mir
index b1802c990cf8..2b5c684bbef0 100644
--- a/tests/run-make/const_fn_mir/dump.mir
+++ b/tests/run-make/const_fn_mir/dump.mir
@@ -1,5 +1,6 @@
 // WARNING: This output format is intended for human consumers only
 // and is subject to change without notice. Knock yourself out.
+// HINT: See also -Z dump-mir for MIR at specific points during compilation.
 fn foo() -> i32 {
     let mut _0: i32;
     let mut _1: (i32, bool);
diff --git a/tests/run-make/include-all-symbols-linking/lib.rs b/tests/run-make/include-all-symbols-linking/lib.rs
index 99508bcdaf31..73186ee99e3d 100644
--- a/tests/run-make/include-all-symbols-linking/lib.rs
+++ b/tests/run-make/include-all-symbols-linking/lib.rs
@@ -1,5 +1,6 @@
 mod foo {
-    #[link_section = ".rodata.STATIC"]
+    #[cfg_attr(target_os = "linux", link_section = ".rodata.STATIC")]
+    #[cfg_attr(target_vendor = "apple", link_section = "__DATA,STATIC")]
     #[used]
     static STATIC: [u32; 10] = [1; 10];
 }
diff --git a/tests/run-make/include-all-symbols-linking/rmake.rs b/tests/run-make/include-all-symbols-linking/rmake.rs
index 77fd71ab20d2..bab510fb5be3 100644
--- a/tests/run-make/include-all-symbols-linking/rmake.rs
+++ b/tests/run-make/include-all-symbols-linking/rmake.rs
@@ -7,15 +7,20 @@
 // See https://github.com/rust-lang/rust/pull/95604
 // See https://github.com/rust-lang/rust/issues/47384
 
-//@ only-linux
-// Reason: differences in object file formats on OSX and Windows
-// causes errors in the llvm_objdump step
+//@ ignore-wasm differences in object file formats causes errors in the llvm_objdump step.
+//@ ignore-windows differences in object file formats causes errors in the llvm_objdump step.
 
-use run_make_support::{dynamic_lib_name, llvm_objdump, llvm_readobj, rustc};
+use run_make_support::{dynamic_lib_name, llvm_objdump, llvm_readobj, rustc, target};
 
 fn main() {
     rustc().crate_type("lib").input("lib.rs").run();
-    rustc().crate_type("cdylib").link_args("-Tlinker.ld").input("main.rs").run();
+    let mut main = rustc();
+    main.crate_type("cdylib");
+    if target().contains("linux") {
+        main.link_args("-Tlinker.ld");
+    }
+    main.input("main.rs").run();
+
     // Ensure `#[used]` and `KEEP`-ed section is there
     llvm_objdump()
         .arg("--full-contents")
diff --git a/tests/run-make/pgo-embed-bc-lto/interesting.rs b/tests/run-make/pgo-embed-bc-lto/interesting.rs
new file mode 100644
index 000000000000..13105c17e126
--- /dev/null
+++ b/tests/run-make/pgo-embed-bc-lto/interesting.rs
@@ -0,0 +1,16 @@
+#![crate_name = "interesting"]
+#![crate_type = "rlib"]
+
+extern crate opaque;
+
+#[no_mangle]
+#[inline(never)]
+pub fn function_called_once() {
+    opaque::foo();
+}
+
+// CHECK-LABEL: @function_called_once
+// CHECK-SAME: !prof [[function_called_once_id:![0-9]+]] {
+// CHECK: "CG Profile"
+// CHECK-NOT: "CG Profile"
+// CHECK-DAG: [[function_called_once_id]] = !{!"function_entry_count", i64 1}
diff --git a/tests/run-make/pgo-embed-bc-lto/main.rs b/tests/run-make/pgo-embed-bc-lto/main.rs
new file mode 100644
index 000000000000..ce8747bef3c2
--- /dev/null
+++ b/tests/run-make/pgo-embed-bc-lto/main.rs
@@ -0,0 +1,5 @@
+extern crate interesting;
+
+fn main() {
+    interesting::function_called_once();
+}
diff --git a/tests/run-make/pgo-embed-bc-lto/opaque.rs b/tests/run-make/pgo-embed-bc-lto/opaque.rs
new file mode 100644
index 000000000000..b4467dc77968
--- /dev/null
+++ b/tests/run-make/pgo-embed-bc-lto/opaque.rs
@@ -0,0 +1,5 @@
+#![crate_name = "opaque"]
+#![crate_type = "rlib"]
+
+#[inline(never)]
+pub fn foo() {}
diff --git a/tests/run-make/pgo-embed-bc-lto/rmake.rs b/tests/run-make/pgo-embed-bc-lto/rmake.rs
new file mode 100644
index 000000000000..b7eba0c68e34
--- /dev/null
+++ b/tests/run-make/pgo-embed-bc-lto/rmake.rs
@@ -0,0 +1,67 @@
+// This test case verifies that we successfully complete an LTO build with PGO
+// using the embedded bitcode.
+// It also ensures that the generated IR correctly includes the call results.
+
+//@ needs-profiler-runtime
+//@ ignore-cross-compile
+
+use std::path::Path;
+
+use run_make_support::{
+    has_extension, has_prefix, llvm_filecheck, llvm_profdata, rfs, run, rustc, shallow_find_files,
+};
+
+fn run_test(cg_units: usize) {
+    let path_prof_data_dir = Path::new("prof_data_dir");
+    if path_prof_data_dir.exists() {
+        rfs::remove_dir_all(path_prof_data_dir);
+    }
+    rfs::create_dir_all(&path_prof_data_dir);
+    let path_merged_profdata = path_prof_data_dir.join("merged.profdata");
+    rustc().input("opaque.rs").codegen_units(1).run();
+    rustc()
+        .input("interesting.rs")
+        .profile_generate(&path_prof_data_dir)
+        .opt()
+        .crate_type("lib,cdylib")
+        .codegen_units(cg_units)
+        .run();
+    rustc()
+        .input("main.rs")
+        .arg("-Clto=thin")
+        .opt()
+        .codegen_units(cg_units)
+        .profile_generate(&path_prof_data_dir)
+        .opt()
+        .run();
+    run("main");
+    llvm_profdata().merge().output(&path_merged_profdata).input(path_prof_data_dir).run();
+    rustc()
+        .input("interesting.rs")
+        .profile_use(&path_merged_profdata)
+        .opt()
+        .crate_type("lib,cdylib")
+        .codegen_units(cg_units)
+        .emit("link")
+        .run();
+    rustc()
+        .input("main.rs")
+        .arg("-Clto=thin")
+        .opt()
+        .codegen_units(cg_units)
+        .profile_use(&path_merged_profdata)
+        .emit("llvm-ir,link")
+        .opt()
+        .run();
+    let files = shallow_find_files(".", |path| {
+        has_prefix(path, "main.interesting.interesting") && has_extension(path, "ll")
+    });
+    assert_eq!(files.len(), 1);
+    let llvm_ir = &files[0];
+    llvm_filecheck().patterns("interesting.rs").stdin_buf(rfs::read(llvm_ir)).run();
+}
+
+fn main() {
+    run_test(1);
+    run_test(16);
+}
diff --git a/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs
index 26ab1390a49a..3ec2cf66fa30 100644
--- a/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs
+++ b/tests/run-make/rustdoc-scrape-examples-macros/src/lib.rs
@@ -1,8 +1,8 @@
 // Scraped example should only include line numbers for items b and c in ex.rs
-// @!has foobar/fn.f.html '//*[@class="src-line-numbers"]' '14'
-// @has foobar/fn.f.html '//*[@class="src-line-numbers"]' '15'
-// @has foobar/fn.f.html '//*[@class="src-line-numbers"]' '21'
-// @!has foobar/fn.f.html '//*[@class="src-line-numbers"]' '22'
+//@ !has foobar/fn.f.html '//span[@data-nosnippet]' '14'
+//@ has foobar/fn.f.html '//span[@data-nosnippet]' '15'
+//@ has foobar/fn.f.html '//span[@data-nosnippet]' '21'
+//@ !has foobar/fn.f.html '//span[@data-nosnippet]' '22'
 
 pub fn f() {}
 
diff --git a/tests/run-make/rustdoc-scrape-examples-multiple/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-multiple/src/lib.rs
index bdfeda92d79a..25600915f5f9 100644
--- a/tests/run-make/rustdoc-scrape-examples-multiple/src/lib.rs
+++ b/tests/run-make/rustdoc-scrape-examples-multiple/src/lib.rs
@@ -1,6 +1,5 @@
-// @has foobar/fn.ok.html '//*[@class="docblock scraped-example-list"]//*[@class="prev"]' ''
-// @has foobar/fn.ok.html '//*[@class="more-scraped-examples"]' ''
-// @has src/ex/ex.rs.html
-// @has foobar/fn.ok.html '//a[@href="../src/ex/ex.rs.html#2"]' ''
+//@ has foobar/fn.ok.html '//*[@class="more-scraped-examples"]' ''
+//@ has src/ex/ex.rs.html
+//@ has foobar/fn.ok.html '//a[@href="../src/ex/ex.rs.html#2"]' ''
 
 pub fn ok() {}
diff --git a/tests/run-make/rustdoc-scrape-examples-ordering/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-ordering/src/lib.rs
index c53c987a7cbf..c957263c048f 100644
--- a/tests/run-make/rustdoc-scrape-examples-ordering/src/lib.rs
+++ b/tests/run-make/rustdoc-scrape-examples-ordering/src/lib.rs
@@ -1,6 +1,6 @@
-// @has foobar/fn.ok.html '//*[@class="docblock scraped-example-list"]' 'ex2'
-// @has foobar/fn.ok.html '//*[@class="more-scraped-examples"]' 'ex1'
-// @has foobar/fn.ok.html '//*[@class="highlight focus"]' 'ok'
-// @has foobar/fn.ok.html '//*[@class="highlight"]' 'ok'
+//@ has foobar/fn.ok.html '//*[@class="docblock scraped-example-list"]' 'ex2'
+//@ has foobar/fn.ok.html '//*[@class="more-scraped-examples"]' 'ex1'
+//@ has foobar/fn.ok.html '//*[@class="highlight focus"]' 'ok'
+//@ has foobar/fn.ok.html '//*[@class="highlight"]' 'ok'
 
 pub fn ok(_x: i32) {}
diff --git a/tests/run-make/rustdoc-scrape-examples-remap/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-remap/src/lib.rs
index f525a4270dde..e1dc4f915068 100644
--- a/tests/run-make/rustdoc-scrape-examples-remap/src/lib.rs
+++ b/tests/run-make/rustdoc-scrape-examples-remap/src/lib.rs
@@ -1,5 +1,5 @@
-// @has foobar/b/fn.foo.html '//*[@class="scraped-example expanded"]' 'ex.rs'
-// @has foobar/c/fn.foo.html '//*[@class="scraped-example expanded"]' 'ex.rs'
+//@ has foobar/b/fn.foo.html '//*[@class="scraped-example expanded"]' 'ex.rs'
+//@ has foobar/c/fn.foo.html '//*[@class="scraped-example expanded"]' 'ex.rs'
 
 #[path = "a.rs"]
 pub mod b;
diff --git a/tests/run-make/rustdoc-scrape-examples-test/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-test/src/lib.rs
index 22be1ad41010..93d56b7e972f 100644
--- a/tests/run-make/rustdoc-scrape-examples-test/src/lib.rs
+++ b/tests/run-make/rustdoc-scrape-examples-test/src/lib.rs
@@ -1,3 +1,3 @@
-// @has foobar/fn.ok.html '//*[@class="docblock scraped-example-list"]' ''
+//@ has foobar/fn.ok.html '//*[@class="docblock scraped-example-list"]' ''
 
 pub fn ok() {}
diff --git a/tests/run-make/rustdoc-scrape-examples-whitespace/src/lib.rs b/tests/run-make/rustdoc-scrape-examples-whitespace/src/lib.rs
index 28c34716c2f3..8fc3a5e41d2e 100644
--- a/tests/run-make/rustdoc-scrape-examples-whitespace/src/lib.rs
+++ b/tests/run-make/rustdoc-scrape-examples-whitespace/src/lib.rs
@@ -1,3 +1,3 @@
-// @has foobar/fn.ok.html '//*[@class="docblock scraped-example-list"]//code' '  '
+//@ has foobar/fn.ok.html '//*[@class="docblock scraped-example-list"]//code' '  '
 
 pub fn ok() {}
diff --git a/tests/run-make/rustdoc-themes/foo.rs b/tests/run-make/rustdoc-themes/foo.rs
index 8b1e75b0ae13..555429b07df2 100644
--- a/tests/run-make/rustdoc-themes/foo.rs
+++ b/tests/run-make/rustdoc-themes/foo.rs
@@ -1,4 +1,4 @@
-// @has test.css
-// @has foo/struct.Foo.html
-// @has - '//*[@name="rustdoc-vars"]/@data-themes' 'test'
+//@ has test.css
+//@ has foo/struct.Foo.html
+//@ has - '//*[@name="rustdoc-vars"]/@data-themes' 'test'
 pub struct Foo;
diff --git a/tests/run-make/rustdoc-with-out-dir-option/src/lib.rs b/tests/run-make/rustdoc-with-out-dir-option/src/lib.rs
index 044bb6acb19b..98753560d3a4 100644
--- a/tests/run-make/rustdoc-with-out-dir-option/src/lib.rs
+++ b/tests/run-make/rustdoc-with-out-dir-option/src/lib.rs
@@ -1,2 +1,2 @@
-// @has foobar/fn.ok.html
+//@ has foobar/fn.ok.html
 pub fn ok() {}
diff --git a/tests/run-make/rustdoc-with-output-option/src/lib.rs b/tests/run-make/rustdoc-with-output-option/src/lib.rs
index 044bb6acb19b..98753560d3a4 100644
--- a/tests/run-make/rustdoc-with-output-option/src/lib.rs
+++ b/tests/run-make/rustdoc-with-output-option/src/lib.rs
@@ -1,2 +1,2 @@
-// @has foobar/fn.ok.html
+//@ has foobar/fn.ok.html
 pub fn ok() {}
diff --git a/tests/run-make/rustdoc-with-short-out-dir-option/src/lib.rs b/tests/run-make/rustdoc-with-short-out-dir-option/src/lib.rs
index 044bb6acb19b..98753560d3a4 100644
--- a/tests/run-make/rustdoc-with-short-out-dir-option/src/lib.rs
+++ b/tests/run-make/rustdoc-with-short-out-dir-option/src/lib.rs
@@ -1,2 +1,2 @@
-// @has foobar/fn.ok.html
+//@ has foobar/fn.ok.html
 pub fn ok() {}
diff --git a/tests/run-make/staticlib-broken-bitcode/rmake.rs b/tests/run-make/staticlib-broken-bitcode/rmake.rs
new file mode 100644
index 000000000000..17d17c1f0f5e
--- /dev/null
+++ b/tests/run-make/staticlib-broken-bitcode/rmake.rs
@@ -0,0 +1,23 @@
+// Regression test for https://github.com/rust-lang/rust/issues/128955#issuecomment-2657811196
+// which checks that rustc can read an archive containing LLVM bitcode with a
+// newer version from the one rustc links against.
+use run_make_support::{llvm_ar, path, rfs, rustc, static_lib_name};
+
+fn main() {
+    rfs::create_dir("archive");
+
+    let mut bitcode = b"BC\xC0\xDE".to_vec();
+    bitcode.extend(std::iter::repeat(b'a').take(50));
+    rfs::write("archive/invalid_bitcode.o", &bitcode);
+
+    llvm_ar()
+        .arg("rcuS") // like obj_to_ar() except skips creating a symbol table
+        .output_input(
+            path("archive").join(static_lib_name("thin_archive")),
+            "archive/invalid_bitcode.o",
+        )
+        .run();
+
+    // Build an rlib which includes the members of this thin archive
+    rustc().input("rust_lib.rs").library_search_path("archive").run();
+}
diff --git a/tests/run-make/staticlib-broken-bitcode/rust_lib.rs b/tests/run-make/staticlib-broken-bitcode/rust_lib.rs
new file mode 100644
index 000000000000..c76b0f254337
--- /dev/null
+++ b/tests/run-make/staticlib-broken-bitcode/rust_lib.rs
@@ -0,0 +1,6 @@
+#![crate_type = "rlib"]
+
+#[link(name = "thin_archive", kind = "static")]
+extern "C" {
+    pub fn simple_fn();
+}
diff --git a/tests/rustdoc-gui/code-example-buttons.goml b/tests/rustdoc-gui/code-example-buttons.goml
index c62683b45da9..b96f6ddcc37a 100644
--- a/tests/rustdoc-gui/code-example-buttons.goml
+++ b/tests/rustdoc-gui/code-example-buttons.goml
@@ -26,6 +26,8 @@ click: ".example-wrap .copy-button"
 move-cursor-to: ".search-input"
 assert-count: (".example-wrap:not(:hover) .button-holder.keep-visible", 0)
 assert-css: (".example-wrap .copy-button", { "visibility": "hidden" })
+// Since we clicked on the copy button, the clipboard content should have been updated.
+assert-clipboard: 'println!("nothing fancy");\nprintln!("but with two lines!");'
 
 define-function: (
     "check-buttons",
diff --git a/tests/rustdoc-gui/copy-path.goml b/tests/rustdoc-gui/copy-path.goml
index dc05b96f7aed..e8766688f8d5 100644
--- a/tests/rustdoc-gui/copy-path.goml
+++ b/tests/rustdoc-gui/copy-path.goml
@@ -1,12 +1,17 @@
 // Checks that the "copy path" button is not triggering JS error and its display
-// isn't broken.
-go-to: "file://" + |DOC_PATH| + "/test_docs/fn.foo.html"
+// isn't broken and the copied path is as expected.
+go-to: "file://" + |DOC_PATH| + "/test_docs/foreign_impl_order/trait.Foo.html"
+
+// We ensure that the clipboard is empty.
+assert-clipboard: ""
 
 // First we store the size of the button before we click on it.
 store-size: ("#copy-path", {"width": width, "height": height})
 click: "#copy-path"
 // We wait for the new text to appear.
 wait-for: "#copy-path.clicked"
+// We check that the clipboard value is the expected one.
+assert-clipboard: "test_docs::foreign_impl_order::Foo"
 // We check that the size didn't change.
 assert-size: ("#copy-path.clicked", {"width": |width|, "height": |height|})
 // We wait for the button to turn back to its original state.
diff --git a/tests/rustdoc-gui/docblock-code-block-line-number.goml b/tests/rustdoc-gui/docblock-code-block-line-number.goml
index 032746a6bdf4..97273ceb195f 100644
--- a/tests/rustdoc-gui/docblock-code-block-line-number.goml
+++ b/tests/rustdoc-gui/docblock-code-block-line-number.goml
@@ -21,7 +21,7 @@ assert-css: (
 set-local-storage: {"rustdoc-line-numbers": "true"}
 reload:
 // We wait for the line numbers to be added into the DOM by the JS...
-wait-for: "pre.example-line-numbers"
+wait-for: ".digits-1 pre"
 
 // Otherwise, we can't check text color
 show-text: true
@@ -35,30 +35,21 @@ define-function: (
         call-function: ("switch-theme", {"theme": |theme|})
         // If the test didn't fail, it means that it was found!
         assert-css: (
-            "pre.example-line-numbers",
+            ".digits-1 pre [data-nosnippet]",
             {
                 "color": |color|,
-                "margin": "0px",
-                "padding-top": "14px",
-                "padding-bottom": "14px",
-                "padding-left": "8px",
-                "padding-right": "2px",
+                "margin-top": "0px",
+                "margin-bottom": "0px",
+                "margin-left": "0px",
+                "margin-right": "20px",
+                "padding-top": "0px",
+                "padding-bottom": "0px",
+                "padding-left": "4px",
+                "padding-right": "4px",
                 "text-align": "right",
-                // There should not be a radius on the right of the line numbers.
-                "border-top-left-radius": "6px",
-                "border-bottom-left-radius": "6px",
-                "border-top-right-radius": "0px",
-                "border-bottom-right-radius": "0px",
             },
             ALL,
         )
-        // There should not be a radius on the left of the line numbers.
-        assert-css: ("pre.example-line-numbers + .rust", {
-            "border-top-left-radius": "0px",
-            "border-bottom-left-radius": "0px",
-            "border-top-right-radius": "6px",
-            "border-bottom-right-radius": "6px",
-        })
     },
 )
 call-function: ("check-colors", {
@@ -74,9 +65,6 @@ call-function: ("check-colors", {
     "color": "#c67e2d",
 })
 
-// The first code block has two lines so let's check its `<pre>` elements lists both of them.
-assert-text: ("pre.example-line-numbers", "1\n2")
-
 // Now, try changing the setting dynamically. We'll turn it off, using the settings menu,
 // and make sure it goes away.
 
@@ -87,42 +75,17 @@ assert-css: ("#settings", {"display": "block"})
 
 // Then, click the toggle button.
 click: "input#line-numbers"
-wait-for-false: "pre.example-line-numbers"
+wait-for: ".digits-1.hide-lines"
 assert-local-storage: {"rustdoc-line-numbers": "false" }
 
-// Check that the rounded corners are back.
-assert-css: (
-    ".example-wrap .rust",
-    {
-        "border-top-left-radius": "6px",
-        "border-bottom-left-radius": "6px",
-        "border-top-right-radius": "6px",
-        "border-bottom-right-radius": "6px",
-    },
-    ALL,
-)
-
 // Finally, turn it on again.
 click: "input#line-numbers"
-wait-for: "pre.example-line-numbers"
+wait-for: ".digits-1:not(.hide-lines)"
 assert-local-storage: {"rustdoc-line-numbers": "true" }
-wait-for: "pre.example-line-numbers"
 
 // Same check with scraped examples line numbers.
 go-to: "file://" + |DOC_PATH| + "/scrape_examples/fn.test_many.html"
 
-assert-css: (
-    ".scraped-example .rust",
-    {
-        // There should not be a radius on the left of the code.
-        "border-top-left-radius": "0px",
-        "border-bottom-left-radius": "0px",
-        "border-top-right-radius": "6px",
-        "border-bottom-right-radius": "6px",
-    },
-    ALL,
-)
-
 define-function: (
     "check-padding",
     [path, padding_bottom],
@@ -203,17 +166,18 @@ assert-local-storage: {"rustdoc-line-numbers": "true" }
 assert: ".example-wrap > pre.language-txt"
 assert: ".example-wrap > pre.rust"
 assert-count: (".example-wrap", 2)
-assert-count: (".example-wrap > pre.example-line-numbers", 2)
+assert-count: (".example-wrap.digits-1", 2)
 
 click: "#settings-menu"
 wait-for: "#settings"
 
 // Then, click the toggle button.
 click: "input#line-numbers"
-wait-for-count: (".example-wrap > pre.example-line-numbers", 0)
+wait-for-count: (".example-wrap.digits-1.hide-lines", 2)
 assert-local-storage-false: {"rustdoc-line-numbers": "true" }
 
 // Now turning off the setting.
 click: "input#line-numbers"
-wait-for-count: (".example-wrap > pre.example-line-numbers", 2)
+wait-for-count: (".example-wrap.digits-1", 2)
+wait-for-count: (".example-wrap.digits-1.hide-lines", 0)
 assert-local-storage: {"rustdoc-line-numbers": "true" }
diff --git a/tests/rustdoc-gui/source-code-wrapping.goml b/tests/rustdoc-gui/source-code-wrapping.goml
new file mode 100644
index 000000000000..cb2fd3052cda
--- /dev/null
+++ b/tests/rustdoc-gui/source-code-wrapping.goml
@@ -0,0 +1,47 @@
+// Checks that the interactions with the source code pages are working as expected.
+go-to: "file://" + |DOC_PATH| + "/src/test_docs/lib.rs.html"
+show-text: true
+set-window-size: (1000, 1000)
+
+define-function: (
+    "click-code-wrapping",
+    [expected],
+    block {
+        click: "#word-wrap-source-code"
+        wait-for-local-storage: {"rustdoc-word-wrap-source-code": |expected|}
+    },
+)
+
+store-size: (".rust code", {"width": width, "height": height})
+click: "#settings-menu"
+wait-for: "#settings"
+call-function: ("click-code-wrapping", {"expected": "true"})
+wait-for-size-false: (".rust code", {"width": |width|, "height": |height|})
+store-size: (".rust code", {"width": new_width, "height": new_height})
+// The width should now be smaller than the window's and the height
+// should have increased.
+assert: |width| > |new_width| && |height| < |new_height|
+
+// Switching back to the original setting.
+call-function: ("click-code-wrapping", {"expected": "false"})
+assert-size: (".rust code", {"width": |width|, "height": |height|})
+
+// Now let's check in docs code examples.
+go-to: "file://" + |DOC_PATH| + "/test_docs/trait_bounds/index.html"
+click: "#settings-menu"
+wait-for: "#settings"
+
+store-size: (".example-wrap .rust code", {"width": rust_width, "height": rust_height})
+store-size: (".example-wrap .language-text code", {"width": txt_width, "height": txt_height})
+call-function: ("click-code-wrapping", {"expected": "true"})
+wait-for-size-false: (".example-wrap .rust code", {"width": |rust_width|, "height": |rust_height|})
+
+store-size: (".example-wrap .rust code", {"width": new_rust_width, "height": new_rust_height})
+store-size: (".example-wrap .language-text code", {"width": new_txt_width, "height": new_txt_height})
+
+assert: |rust_width| > |new_rust_width| && |rust_height| < |new_rust_height|
+assert: |txt_width| > |new_txt_width| && |txt_height| < |new_txt_height|
+
+call-function: ("click-code-wrapping", {"expected": "false"})
+wait-for-size: (".example-wrap .rust code", {"width": |rust_width|, "height": |rust_height|})
+assert-size: (".example-wrap .language-text code", {"width": |txt_width|, "height": |txt_height|})
diff --git a/tests/rustdoc-gui/src/test_docs/lib.rs b/tests/rustdoc-gui/src/test_docs/lib.rs
index f9c20ab22b89..31f6b7f09b7d 100644
--- a/tests/rustdoc-gui/src/test_docs/lib.rs
+++ b/tests/rustdoc-gui/src/test_docs/lib.rs
@@ -615,6 +615,15 @@ pub mod private {
     }
 }
 
+/// ```
+/// fn super_long_function_name_because_i_need_to_hit_the_limit_and_break_beyond_it() {
+/// }
+/// ```
+///
+/// ```text
+/// fn super_long_function_name_because_i_need_to_hit_the_limit_and_break_beyond_it_v2() {
+/// }
+/// ```
 pub mod trait_bounds {
     pub trait OneBound: Sized {}
     pub trait TwoBounds: Sized + Copy {}
diff --git a/tests/rustdoc-json/enums/discriminant/struct.rs b/tests/rustdoc-json/enums/discriminant/struct.rs
index 0ac40cda7338..24d5f5b08c20 100644
--- a/tests/rustdoc-json/enums/discriminant/struct.rs
+++ b/tests/rustdoc-json/enums/discriminant/struct.rs
@@ -1,7 +1,7 @@
 // ignore-tidy-linelength
 
 #[repr(i32)]
-//@ is "$.index[*][?(@.name=='Foo')].attrs" '["#[repr(i32)]"]'
+//@ is "$.index[*][?(@.name=='Foo')].attrs" '["#[attr=\"Repr([ReprInt(SignedInt(I32))])\")]\n"]'
 pub enum Foo {
     //@ is    "$.index[*][?(@.name=='Struct')].inner.variant.discriminant" null
     //@ count "$.index[*][?(@.name=='Struct')].inner.variant.kind.struct.fields[*]" 0
diff --git a/tests/rustdoc-json/enums/discriminant/tuple.rs b/tests/rustdoc-json/enums/discriminant/tuple.rs
index fbff5aacd674..a50ae8b9189f 100644
--- a/tests/rustdoc-json/enums/discriminant/tuple.rs
+++ b/tests/rustdoc-json/enums/discriminant/tuple.rs
@@ -1,7 +1,7 @@
 // ignore-tidy-linelength
 
 #[repr(u32)]
-//@ is "$.index[*][?(@.name=='Foo')].attrs" '["#[repr(u32)]"]'
+//@ is "$.index[*][?(@.name=='Foo')].attrs" '["#[attr=\"Repr([ReprInt(UnsignedInt(U32))])\")]\n"]'
 pub enum Foo {
     //@ is    "$.index[*][?(@.name=='Tuple')].inner.variant.discriminant" null
     //@ count "$.index[*][?(@.name=='Tuple')].inner.variant.kind.tuple[*]" 0
diff --git a/tests/rustdoc-ui/unused-extern-crate.rs b/tests/rustdoc-ui/unused-extern-crate.rs
deleted file mode 100644
index 240dd1f00e22..000000000000
--- a/tests/rustdoc-ui/unused-extern-crate.rs
+++ /dev/null
@@ -1,3 +0,0 @@
-//@ check-pass
-//@ aux-crate:panic_item=panic-item.rs
-// @has unused_extern_crate/index.html
diff --git a/tests/rustdoc-ui/auxiliary/panic-item.rs b/tests/rustdoc/auxiliary/panic-item.rs
similarity index 100%
rename from tests/rustdoc-ui/auxiliary/panic-item.rs
rename to tests/rustdoc/auxiliary/panic-item.rs
diff --git a/tests/rustdoc/const-intrinsic.rs b/tests/rustdoc/const-intrinsic.rs
index 8444d4a3aa76..7dedb083b7d0 100644
--- a/tests/rustdoc/const-intrinsic.rs
+++ b/tests/rustdoc/const-intrinsic.rs
@@ -9,19 +9,13 @@
 #[stable(since="1.0.0", feature="rust1")]
 #[rustc_const_stable(feature = "const_transmute", since = "1.56.0")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub const unsafe fn transmute<T, U>(_: T) -> U {
-    loop {}
-}
+pub const unsafe fn transmute<T, U>(_: T) -> U;
 
 //@ has 'foo/fn.unreachable.html'
 //@ has - '//pre[@class="rust item-decl"]' 'pub unsafe fn unreachable() -> !'
 #[stable(since="1.0.0", feature="rust1")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub unsafe fn unreachable() -> ! {
-    loop {}
-}
+pub unsafe fn unreachable() -> !;
 
 extern "C" {
     //@ has 'foo/fn.needs_drop.html'
diff --git a/tests/rustdoc/inline_local/staged-inline.rs b/tests/rustdoc/inline_local/staged-inline.rs
index f2131ad5f944..d0dc3f9eea7f 100644
--- a/tests/rustdoc/inline_local/staged-inline.rs
+++ b/tests/rustdoc/inline_local/staged-inline.rs
@@ -16,3 +16,31 @@ pub mod ffi {
 //@ has "foo/struct.CStr.html" "//span[@class='sub-heading']/span[@class='since']" "1.0.0"
 //@ !has - "//span[@class='sub-heading']/span[@class='since']" "1.99.0"
 pub use ffi::CStr;
+
+// https://github.com/rust-lang/rust/issues/137141
+#[stable(feature = "futures_api", since = "1.36.0")]
+//@ has "foo/task/index.html" "//span[@class='sub-heading']/span[@class='since']" "1.36.0"
+//@ !has - "//span[@class='sub-heading']/span[@class='since']" "1.0.0"
+pub mod task {
+
+    #[doc(inline)]
+    #[stable(feature = "futures_api", since = "1.36.0")]
+    //@ has "foo/task/index.html" "//span[@class='sub-heading']/span[@class='since']" "1.36.0"
+    //@ has "foo/task/ready/index.html" "//span[@class='sub-heading']/span[@class='since']" "1.64.0"
+    pub use core::task::*;
+}
+
+#[stable(feature = "futures_api", since = "1.36.0")]
+//@ has "foo/core/index.html" "//span[@class='sub-heading']/span[@class='since']" "1.36.0"
+//@ !has - "//span[@class='sub-heading']/span[@class='since']" "1.0.0"
+pub mod core {
+    #[stable(feature = "futures_api", since = "1.36.0")]
+    //@ has "foo/core/task/index.html" "//span[@class='sub-heading']/span[@class='since']" "1.36.0"
+    pub mod task {
+
+        #[stable(feature = "ready_macro", since = "1.64.0")]
+        //@ has "foo/core/task/ready/index.html" "//span[@class='sub-heading']/span[@class='since']" "1.64.0"
+        pub mod ready {
+        }
+    }
+}
diff --git a/tests/rustdoc/safe-intrinsic.rs b/tests/rustdoc/safe-intrinsic.rs
index 1edc1d9f79b9..0d2ee89415d4 100644
--- a/tests/rustdoc/safe-intrinsic.rs
+++ b/tests/rustdoc/safe-intrinsic.rs
@@ -11,14 +11,8 @@ trait Sized {}
 //@ has 'foo/fn.abort.html'
 //@ has - '//pre[@class="rust item-decl"]' 'pub fn abort() -> !'
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub fn abort() -> ! {
-    loop {}
-}
+pub fn abort() -> !;
 //@ has 'foo/fn.unreachable.html'
 //@ has - '//pre[@class="rust item-decl"]' 'pub unsafe fn unreachable() -> !'
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-pub unsafe fn unreachable() -> ! {
-    loop {}
-}
+pub unsafe fn unreachable() -> !;
diff --git a/tests/rustdoc/unused-extern-crate.rs b/tests/rustdoc/unused-extern-crate.rs
new file mode 100644
index 000000000000..cdc00fd313af
--- /dev/null
+++ b/tests/rustdoc/unused-extern-crate.rs
@@ -0,0 +1,2 @@
+//@ aux-crate:panic_item=panic-item.rs
+//@ has unused_extern_crate/index.html
diff --git a/tests/ui-fulldeps/stable-mir/check_attribute.rs b/tests/ui-fulldeps/stable-mir/check_attribute.rs
index 11cb63f3f8a5..de5ba15f6ea4 100644
--- a/tests/ui-fulldeps/stable-mir/check_attribute.rs
+++ b/tests/ui-fulldeps/stable-mir/check_attribute.rs
@@ -27,63 +27,23 @@ fn test_stable_mir() -> ControlFlow<()> {
     // Find items in the local crate.
     let items = stable_mir::all_local_items();
 
-    test_builtins(&items);
-    test_derive(&items);
     test_tool(&items);
-    test_all_attrs(&items);
 
     ControlFlow::Continue(())
 }
 
-// Test built-in attributes.
-fn test_builtins(items: &CrateItems) {
-    let target_fn = *get_item(&items, "builtins_fn").unwrap();
-    let allow_attrs = target_fn.attrs_by_path(&["allow".to_string()]);
-    assert_eq!(allow_attrs[0].as_str(), "#![allow(unused_variables)]");
-
-    let inline_attrs = target_fn.attrs_by_path(&["inline".to_string()]);
-    assert_eq!(inline_attrs[0].as_str(), "#[inline]");
-
-    let deprecated_attrs = target_fn.attrs_by_path(&["deprecated".to_string()]);
-    assert_eq!(deprecated_attrs[0].as_str(), "#[deprecated(since = \"5.2.0\")]");
-}
-
-// Test derive attribute.
-fn test_derive(items: &CrateItems) {
-    let target_struct = *get_item(&items, "Foo").unwrap();
-    let attrs = target_struct.attrs_by_path(&["derive".to_string()]);
-    // No `derive` attribute since it's expanded before MIR.
-    assert_eq!(attrs.len(), 0);
-
-    // Check derived trait method's attributes.
-    let derived_fmt = *get_item(&items, "<Foo as std::fmt::Debug>::fmt").unwrap();
-    // The Rust reference lies about this attribute. It doesn't show up in `clone` or `fmt` impl.
-    let _fmt_attrs = derived_fmt.attrs_by_path(&["automatically_derived".to_string()]);
-}
-
 // Test tool attributes.
 fn test_tool(items: &CrateItems) {
     let rustfmt_fn = *get_item(&items, "do_not_format").unwrap();
-    let rustfmt_attrs = rustfmt_fn.attrs_by_path(&["rustfmt".to_string(), "skip".to_string()]);
+    let rustfmt_attrs = rustfmt_fn.tool_attrs(&["rustfmt".to_string(), "skip".to_string()]);
     assert_eq!(rustfmt_attrs[0].as_str(), "#[rustfmt::skip]");
 
     let clippy_fn = *get_item(&items, "complex_fn").unwrap();
-    let clippy_attrs = clippy_fn.attrs_by_path(&["clippy".to_string(),
+    let clippy_attrs = clippy_fn.tool_attrs(&["clippy".to_string(),
                                                "cyclomatic_complexity".to_string()]);
     assert_eq!(clippy_attrs[0].as_str(), "#[clippy::cyclomatic_complexity = \"100\"]");
 }
 
-fn test_all_attrs(items: &CrateItems) {
-    let target_fn = *get_item(&items, "many_attrs").unwrap();
-    let all_attrs = target_fn.all_attrs();
-    assert_eq!(all_attrs[0].as_str(), "#[inline]");
-    assert_eq!(all_attrs[1].as_str(), "#[allow(unused_variables)]");
-    assert_eq!(all_attrs[2].as_str(), "#[allow(dead_code)]");
-    assert_eq!(all_attrs[3].as_str(), "#[allow(unused_imports)]");
-    assert_eq!(all_attrs[4].as_str(), "#![allow(clippy::filter_map)]");
-}
-
-
 fn get_item<'a>(
     items: &'a CrateItems,
     name: &str,
diff --git a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
index 2f772b978865..07a2a62e0668 100644
--- a/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
+++ b/tests/ui-fulldeps/stable-mir/check_intrinsics.rs
@@ -51,13 +51,11 @@ fn test_intrinsics() -> ControlFlow<()> {
 
 /// This check is unfortunately tight to the implementation of intrinsics.
 ///
-/// We want to ensure that StableMIR can handle intrinsics with and without fallback body.
+/// We want to ensure that StableMIR can handle intrinsics with and without fallback body:
+/// for intrinsics without a body, obviously we cannot expose anything.
 ///
 /// If by any chance this test breaks because you changed how an intrinsic is implemented, please
 /// update the test to invoke a different intrinsic.
-///
-/// In StableMIR, we only expose intrinsic body if they are not marked with
-/// `rustc_intrinsic_must_be_overridden`.
 fn check_instance(instance: &Instance) {
     assert_eq!(instance.kind, InstanceKind::Intrinsic);
     let name = instance.intrinsic_name().unwrap();
diff --git a/tests/ui/abi/arm-unadjusted-intrinsic.rs b/tests/ui/abi/arm-unadjusted-intrinsic.rs
index 533cd40b30a5..dcf0d9f39f67 100644
--- a/tests/ui/abi/arm-unadjusted-intrinsic.rs
+++ b/tests/ui/abi/arm-unadjusted-intrinsic.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ build-pass
 //@ revisions: arm
 //@[arm] compile-flags: --target arm-unknown-linux-gnueabi
@@ -14,19 +15,8 @@
 #![crate_type = "lib"]
 #![allow(non_camel_case_types)]
 
-/// To work cross-target this test must be no_core.
-/// This little prelude supplies what we need.
-#[lang = "sized"]
-pub trait Sized {}
-
-#[lang = "copy"]
-pub trait Copy: Sized {}
-impl Copy for i8 {}
-impl<T: ?Sized> Copy for *const T {}
-impl<T: ?Sized> Copy for *mut T {}
-
-// I hate no_core tests!
-impl<T: Copy, const N: usize> Copy for [T; N] {}
+extern crate minicore;
+use minicore::*;
 
 // Regression test for https://github.com/rust-lang/rust/issues/118124.
 
diff --git a/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr b/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr
index e1f433479857..c71797b500d6 100644
--- a/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr
+++ b/tests/ui/abi/riscv-discoverability-guidance.riscv32.stderr
@@ -1,24 +1,27 @@
 error[E0703]: invalid ABI: found `riscv-interrupt`
-  --> $DIR/riscv-discoverability-guidance.rs:17:8
+  --> $DIR/riscv-discoverability-guidance.rs:15:8
    |
 LL | extern "riscv-interrupt" fn isr() {}
-   |        ^^^^^^^^^^^^^^^^^
-   |        |
-   |        invalid ABI
-   |        help: did you mean: `"riscv-interrupt-m"`
+   |        ^^^^^^^^^^^^^^^^^ invalid ABI
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+help: there's a similarly named valid ABI `riscv-interrupt-m`
+   |
+LL | extern "riscv-interrupt-m" fn isr() {}
+   |                        ++
 
 error[E0703]: invalid ABI: found `riscv-interrupt-u`
-  --> $DIR/riscv-discoverability-guidance.rs:22:8
+  --> $DIR/riscv-discoverability-guidance.rs:20:8
    |
 LL | extern "riscv-interrupt-u" fn isr_U() {}
-   |        ^^^^^^^^^^^^^^^^^^^
-   |        |
-   |        invalid ABI
-   |        help: did you mean: `"riscv-interrupt-m"`
+   |        ^^^^^^^^^^^^^^^^^^^ invalid ABI
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+help: there's a similarly named valid ABI `riscv-interrupt-m`
+   |
+LL - extern "riscv-interrupt-u" fn isr_U() {}
+LL + extern "riscv-interrupt-m" fn isr_U() {}
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr b/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr
index e1f433479857..c71797b500d6 100644
--- a/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr
+++ b/tests/ui/abi/riscv-discoverability-guidance.riscv64.stderr
@@ -1,24 +1,27 @@
 error[E0703]: invalid ABI: found `riscv-interrupt`
-  --> $DIR/riscv-discoverability-guidance.rs:17:8
+  --> $DIR/riscv-discoverability-guidance.rs:15:8
    |
 LL | extern "riscv-interrupt" fn isr() {}
-   |        ^^^^^^^^^^^^^^^^^
-   |        |
-   |        invalid ABI
-   |        help: did you mean: `"riscv-interrupt-m"`
+   |        ^^^^^^^^^^^^^^^^^ invalid ABI
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+help: there's a similarly named valid ABI `riscv-interrupt-m`
+   |
+LL | extern "riscv-interrupt-m" fn isr() {}
+   |                        ++
 
 error[E0703]: invalid ABI: found `riscv-interrupt-u`
-  --> $DIR/riscv-discoverability-guidance.rs:22:8
+  --> $DIR/riscv-discoverability-guidance.rs:20:8
    |
 LL | extern "riscv-interrupt-u" fn isr_U() {}
-   |        ^^^^^^^^^^^^^^^^^^^
-   |        |
-   |        invalid ABI
-   |        help: did you mean: `"riscv-interrupt-m"`
+   |        ^^^^^^^^^^^^^^^^^^^ invalid ABI
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+help: there's a similarly named valid ABI `riscv-interrupt-m`
+   |
+LL - extern "riscv-interrupt-u" fn isr_U() {}
+LL + extern "riscv-interrupt-m" fn isr_U() {}
+   |
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/abi/riscv-discoverability-guidance.rs b/tests/ui/abi/riscv-discoverability-guidance.rs
index dec5059b0a7f..41cce35aefad 100644
--- a/tests/ui/abi/riscv-discoverability-guidance.rs
+++ b/tests/ui/abi/riscv-discoverability-guidance.rs
@@ -1,4 +1,5 @@
 // ignore-tidy-linelength
+//@ add-core-stubs
 //@ revisions: riscv32 riscv64
 //
 //@ [riscv32] needs-llvm-components: riscv
@@ -6,13 +7,10 @@
 //@ [riscv64] needs-llvm-components: riscv
 //@ [riscv64] compile-flags: --target=riscv64gc-unknown-none-elf -C target-feature=-unaligned-scalar-mem --crate-type=rlib
 #![no_core]
-#![feature(
-    no_core,
-    lang_items,
-    abi_riscv_interrupt
-)]
-#[lang = "sized"]
-trait Sized {}
+#![feature(no_core, lang_items, abi_riscv_interrupt)]
+
+extern crate minicore;
+use minicore::*;
 
 extern "riscv-interrupt" fn isr() {}
 //~^ ERROR invalid ABI
diff --git a/tests/ui/abi/sparcv8plus-llvm19.rs b/tests/ui/abi/sparcv8plus-llvm19.rs
index a884e5ca06f1..3d6d8568b6e5 100644
--- a/tests/ui/abi/sparcv8plus-llvm19.rs
+++ b/tests/ui/abi/sparcv8plus-llvm19.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: sparc sparcv8plus sparc_cpu_v9 sparc_feature_v8plus sparc_cpu_v9_feature_v8plus
 //@[sparc] compile-flags: --target sparc-unknown-none-elf
 //@[sparc] needs-llvm-components: sparc
@@ -15,10 +16,8 @@
 #![feature(no_core, rustc_attrs, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[rustc_builtin_macro]
 macro_rules! compile_error {
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc.stderr
index 7eedf26135f5..d3462ae87d33 100644
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc.stderr
+++ b/tests/ui/abi/sparcv8plus-llvm19.sparc.stderr
@@ -1,5 +1,5 @@
 error: -v8plus,-v9
-  --> $DIR/sparcv8plus-llvm19.rs:29:1
+  --> $DIR/sparcv8plus-llvm19.rs:28:1
    |
 LL | compile_error!("-v8plus,-v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr
index ac61df356780..9891aec94b86 100644
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr
+++ b/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,+v9
-  --> $DIR/sparcv8plus-llvm19.rs:34:1
+  --> $DIR/sparcv8plus-llvm19.rs:33:1
    |
 LL | compile_error!("+v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr
index ac61df356780..9891aec94b86 100644
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr
+++ b/tests/ui/abi/sparcv8plus-llvm19.sparc_cpu_v9_feature_v8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,+v9
-  --> $DIR/sparcv8plus-llvm19.rs:34:1
+  --> $DIR/sparcv8plus-llvm19.rs:33:1
    |
 LL | compile_error!("+v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr
index 1bf7a3ad76a8..dbcdb8ed121b 100644
--- a/tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr
+++ b/tests/ui/abi/sparcv8plus-llvm19.sparc_feature_v8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,-v9 (FIXME)
-  --> $DIR/sparcv8plus-llvm19.rs:39:1
+  --> $DIR/sparcv8plus-llvm19.rs:38:1
    |
 LL | compile_error!("+v8plus,-v9 (FIXME)");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr b/tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr
index ac61df356780..9891aec94b86 100644
--- a/tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr
+++ b/tests/ui/abi/sparcv8plus-llvm19.sparcv8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,+v9
-  --> $DIR/sparcv8plus-llvm19.rs:34:1
+  --> $DIR/sparcv8plus-llvm19.rs:33:1
    |
 LL | compile_error!("+v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.rs b/tests/ui/abi/sparcv8plus.rs
index a78ae0cd3288..6c17f7218386 100644
--- a/tests/ui/abi/sparcv8plus.rs
+++ b/tests/ui/abi/sparcv8plus.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: sparc sparcv8plus sparc_cpu_v9 sparc_feature_v8plus sparc_cpu_v9_feature_v8plus
 //@[sparc] compile-flags: --target sparc-unknown-none-elf
 //@[sparc] needs-llvm-components: sparc
@@ -15,10 +16,8 @@
 #![feature(no_core, rustc_attrs, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 #[rustc_builtin_macro]
 macro_rules! compile_error {
diff --git a/tests/ui/abi/sparcv8plus.sparc.stderr b/tests/ui/abi/sparcv8plus.sparc.stderr
index 6d14ff53ab9c..e2aa89a92731 100644
--- a/tests/ui/abi/sparcv8plus.sparc.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc.stderr
@@ -1,5 +1,5 @@
 error: -v8plus,-v9
-  --> $DIR/sparcv8plus.rs:29:1
+  --> $DIR/sparcv8plus.rs:28:1
    |
 LL | compile_error!("-v8plus,-v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr b/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr
index 00fd7ef4ea8f..2c5699f2dec2 100644
--- a/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc_cpu_v9.stderr
@@ -1,5 +1,5 @@
 error: -v8plus,+v9
-  --> $DIR/sparcv8plus.rs:42:1
+  --> $DIR/sparcv8plus.rs:41:1
    |
 LL | compile_error!("-v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr
index a3c74e67f8f1..4b96e4421f9f 100644
--- a/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc_cpu_v9_feature_v8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,+v9
-  --> $DIR/sparcv8plus.rs:33:1
+  --> $DIR/sparcv8plus.rs:32:1
    |
 LL | compile_error!("+v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr b/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr
index 84f560d158ca..dfdec88961be 100644
--- a/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr
+++ b/tests/ui/abi/sparcv8plus.sparc_feature_v8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,-v9 (FIXME)
-  --> $DIR/sparcv8plus.rs:38:1
+  --> $DIR/sparcv8plus.rs:37:1
    |
 LL | compile_error!("+v8plus,-v9 (FIXME)");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/sparcv8plus.sparcv8plus.stderr b/tests/ui/abi/sparcv8plus.sparcv8plus.stderr
index a3c74e67f8f1..4b96e4421f9f 100644
--- a/tests/ui/abi/sparcv8plus.sparcv8plus.stderr
+++ b/tests/ui/abi/sparcv8plus.sparcv8plus.stderr
@@ -1,5 +1,5 @@
 error: +v8plus,+v9
-  --> $DIR/sparcv8plus.rs:33:1
+  --> $DIR/sparcv8plus.rs:32:1
    |
 LL | compile_error!("+v8plus,+v9");
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/unsupported.aarch64.stderr b/tests/ui/abi/unsupported.aarch64.stderr
index 2eb6ab08232e..01f071f1f310 100644
--- a/tests/ui/abi/unsupported.aarch64.stderr
+++ b/tests/ui/abi/unsupported.aarch64.stderr
@@ -1,5 +1,5 @@
 warning: the calling convention "ptx-kernel" is not supported on this target
-  --> $DIR/unsupported.rs:36:15
+  --> $DIR/unsupported.rs:35:15
    |
 LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,13 +9,13 @@ LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:41:1
+  --> $DIR/unsupported.rs:40:1
    |
 LL | extern "ptx-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "aapcs" is not supported on this target
-  --> $DIR/unsupported.rs:52:17
+  --> $DIR/unsupported.rs:51:17
    |
 LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^
@@ -24,13 +24,13 @@ LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:65:1
+  --> $DIR/unsupported.rs:64:1
    |
 LL | extern "aapcs" {}
    | ^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "msp430-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:74:18
+  --> $DIR/unsupported.rs:73:18
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,13 +39,13 @@ LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:79:1
+  --> $DIR/unsupported.rs:78:1
    |
 LL | extern "msp430-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "avr-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:84:15
+  --> $DIR/unsupported.rs:83:15
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,13 +54,13 @@ LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:89:1
+  --> $DIR/unsupported.rs:88:1
    |
 LL | extern "avr-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "riscv-interrupt-m" is not supported on this target
-  --> $DIR/unsupported.rs:97:17
+  --> $DIR/unsupported.rs:96:17
    |
 LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,13 +69,13 @@ LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:108:1
+  --> $DIR/unsupported.rs:107:1
    |
 LL | extern "riscv-interrupt-m" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "x86-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:119:15
+  --> $DIR/unsupported.rs:118:15
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,13 +84,13 @@ LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:130:1
+  --> $DIR/unsupported.rs:129:1
    |
 LL | extern "x86-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "thiscall" is not supported on this target
-  --> $DIR/unsupported.rs:142:20
+  --> $DIR/unsupported.rs:141:20
    |
 LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -99,13 +99,13 @@ LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:155:1
+  --> $DIR/unsupported.rs:154:1
    |
 LL | extern "thiscall" {}
    | ^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "stdcall" is not supported on this target
-  --> $DIR/unsupported.rs:168:19
+  --> $DIR/unsupported.rs:167:19
    |
 LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    |                   ^^^^^^^^^^^^^^^^^^^^^
@@ -114,13 +114,13 @@ LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:181:1
+  --> $DIR/unsupported.rs:180:1
    |
 LL | extern "stdcall" {}
    | ^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "C-cmse-nonsecure-call" is not supported on this target
-  --> $DIR/unsupported.rs:188:21
+  --> $DIR/unsupported.rs:187:21
    |
 LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 warning: the calling convention "C-cmse-nonsecure-entry" is not supported on this target
-  --> $DIR/unsupported.rs:196:22
+  --> $DIR/unsupported.rs:195:22
    |
 LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -138,67 +138,67 @@ LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:201:1
+  --> $DIR/unsupported.rs:200:1
    |
 LL | extern "C-cmse-nonsecure-entry" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:34:1
+  --> $DIR/unsupported.rs:33:1
    |
 LL | extern "ptx-kernel" fn ptx() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:43:1
+  --> $DIR/unsupported.rs:42:1
    |
 LL | extern "gpu-kernel" fn gpu() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:46:1
+  --> $DIR/unsupported.rs:45:1
    |
 LL | extern "aapcs" fn aapcs() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:72:1
+  --> $DIR/unsupported.rs:71:1
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:82:1
+  --> $DIR/unsupported.rs:81:1
    |
 LL | extern "avr-interrupt" fn avr() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:92:1
+  --> $DIR/unsupported.rs:91:1
    |
 LL | extern "riscv-interrupt-m" fn riscv() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:114:1
+  --> $DIR/unsupported.rs:113:1
    |
 LL | extern "x86-interrupt" fn x86() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:136:1
+  --> $DIR/unsupported.rs:135:1
    |
 LL | extern "thiscall" fn thiscall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:162:1
+  --> $DIR/unsupported.rs:161:1
    |
 LL | extern "stdcall" fn stdcall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:194:1
+  --> $DIR/unsupported.rs:193:1
    |
 LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/unsupported.arm.stderr b/tests/ui/abi/unsupported.arm.stderr
index ee878379cc64..dfb4b573349b 100644
--- a/tests/ui/abi/unsupported.arm.stderr
+++ b/tests/ui/abi/unsupported.arm.stderr
@@ -1,5 +1,5 @@
 warning: the calling convention "ptx-kernel" is not supported on this target
-  --> $DIR/unsupported.rs:36:15
+  --> $DIR/unsupported.rs:35:15
    |
 LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,13 +9,13 @@ LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:41:1
+  --> $DIR/unsupported.rs:40:1
    |
 LL | extern "ptx-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "msp430-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:74:18
+  --> $DIR/unsupported.rs:73:18
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -24,13 +24,13 @@ LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:79:1
+  --> $DIR/unsupported.rs:78:1
    |
 LL | extern "msp430-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "avr-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:84:15
+  --> $DIR/unsupported.rs:83:15
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,13 +39,13 @@ LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:89:1
+  --> $DIR/unsupported.rs:88:1
    |
 LL | extern "avr-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "riscv-interrupt-m" is not supported on this target
-  --> $DIR/unsupported.rs:97:17
+  --> $DIR/unsupported.rs:96:17
    |
 LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,13 +54,13 @@ LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:108:1
+  --> $DIR/unsupported.rs:107:1
    |
 LL | extern "riscv-interrupt-m" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "x86-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:119:15
+  --> $DIR/unsupported.rs:118:15
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,13 +69,13 @@ LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:130:1
+  --> $DIR/unsupported.rs:129:1
    |
 LL | extern "x86-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "thiscall" is not supported on this target
-  --> $DIR/unsupported.rs:142:20
+  --> $DIR/unsupported.rs:141:20
    |
 LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -84,13 +84,13 @@ LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:155:1
+  --> $DIR/unsupported.rs:154:1
    |
 LL | extern "thiscall" {}
    | ^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "stdcall" is not supported on this target
-  --> $DIR/unsupported.rs:168:19
+  --> $DIR/unsupported.rs:167:19
    |
 LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    |                   ^^^^^^^^^^^^^^^^^^^^^
@@ -99,13 +99,13 @@ LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:181:1
+  --> $DIR/unsupported.rs:180:1
    |
 LL | extern "stdcall" {}
    | ^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "C-cmse-nonsecure-call" is not supported on this target
-  --> $DIR/unsupported.rs:188:21
+  --> $DIR/unsupported.rs:187:21
    |
 LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,7 +114,7 @@ LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 warning: the calling convention "C-cmse-nonsecure-entry" is not supported on this target
-  --> $DIR/unsupported.rs:196:22
+  --> $DIR/unsupported.rs:195:22
    |
 LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -123,61 +123,61 @@ LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:201:1
+  --> $DIR/unsupported.rs:200:1
    |
 LL | extern "C-cmse-nonsecure-entry" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:34:1
+  --> $DIR/unsupported.rs:33:1
    |
 LL | extern "ptx-kernel" fn ptx() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:43:1
+  --> $DIR/unsupported.rs:42:1
    |
 LL | extern "gpu-kernel" fn gpu() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:72:1
+  --> $DIR/unsupported.rs:71:1
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:82:1
+  --> $DIR/unsupported.rs:81:1
    |
 LL | extern "avr-interrupt" fn avr() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:92:1
+  --> $DIR/unsupported.rs:91:1
    |
 LL | extern "riscv-interrupt-m" fn riscv() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:114:1
+  --> $DIR/unsupported.rs:113:1
    |
 LL | extern "x86-interrupt" fn x86() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:136:1
+  --> $DIR/unsupported.rs:135:1
    |
 LL | extern "thiscall" fn thiscall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:162:1
+  --> $DIR/unsupported.rs:161:1
    |
 LL | extern "stdcall" fn stdcall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:194:1
+  --> $DIR/unsupported.rs:193:1
    |
 LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/unsupported.i686.stderr b/tests/ui/abi/unsupported.i686.stderr
index 02b2cdd356f7..d7b76a4730b2 100644
--- a/tests/ui/abi/unsupported.i686.stderr
+++ b/tests/ui/abi/unsupported.i686.stderr
@@ -1,5 +1,5 @@
 warning: the calling convention "ptx-kernel" is not supported on this target
-  --> $DIR/unsupported.rs:36:15
+  --> $DIR/unsupported.rs:35:15
    |
 LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,13 +9,13 @@ LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:41:1
+  --> $DIR/unsupported.rs:40:1
    |
 LL | extern "ptx-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "aapcs" is not supported on this target
-  --> $DIR/unsupported.rs:52:17
+  --> $DIR/unsupported.rs:51:17
    |
 LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^
@@ -24,13 +24,13 @@ LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:65:1
+  --> $DIR/unsupported.rs:64:1
    |
 LL | extern "aapcs" {}
    | ^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "msp430-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:74:18
+  --> $DIR/unsupported.rs:73:18
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,13 +39,13 @@ LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:79:1
+  --> $DIR/unsupported.rs:78:1
    |
 LL | extern "msp430-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "avr-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:84:15
+  --> $DIR/unsupported.rs:83:15
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,13 +54,13 @@ LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:89:1
+  --> $DIR/unsupported.rs:88:1
    |
 LL | extern "avr-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "riscv-interrupt-m" is not supported on this target
-  --> $DIR/unsupported.rs:97:17
+  --> $DIR/unsupported.rs:96:17
    |
 LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,13 +69,13 @@ LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:108:1
+  --> $DIR/unsupported.rs:107:1
    |
 LL | extern "riscv-interrupt-m" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "C-cmse-nonsecure-call" is not supported on this target
-  --> $DIR/unsupported.rs:188:21
+  --> $DIR/unsupported.rs:187:21
    |
 LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -84,7 +84,7 @@ LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 warning: the calling convention "C-cmse-nonsecure-entry" is not supported on this target
-  --> $DIR/unsupported.rs:196:22
+  --> $DIR/unsupported.rs:195:22
    |
 LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -93,49 +93,49 @@ LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:201:1
+  --> $DIR/unsupported.rs:200:1
    |
 LL | extern "C-cmse-nonsecure-entry" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:34:1
+  --> $DIR/unsupported.rs:33:1
    |
 LL | extern "ptx-kernel" fn ptx() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:43:1
+  --> $DIR/unsupported.rs:42:1
    |
 LL | extern "gpu-kernel" fn gpu() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:46:1
+  --> $DIR/unsupported.rs:45:1
    |
 LL | extern "aapcs" fn aapcs() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:72:1
+  --> $DIR/unsupported.rs:71:1
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:82:1
+  --> $DIR/unsupported.rs:81:1
    |
 LL | extern "avr-interrupt" fn avr() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:92:1
+  --> $DIR/unsupported.rs:91:1
    |
 LL | extern "riscv-interrupt-m" fn riscv() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:194:1
+  --> $DIR/unsupported.rs:193:1
    |
 LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/unsupported.riscv32.stderr b/tests/ui/abi/unsupported.riscv32.stderr
index abf403da8bd1..eef2ead4f0f3 100644
--- a/tests/ui/abi/unsupported.riscv32.stderr
+++ b/tests/ui/abi/unsupported.riscv32.stderr
@@ -1,5 +1,5 @@
 warning: the calling convention "ptx-kernel" is not supported on this target
-  --> $DIR/unsupported.rs:36:15
+  --> $DIR/unsupported.rs:35:15
    |
 LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,13 +9,13 @@ LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:41:1
+  --> $DIR/unsupported.rs:40:1
    |
 LL | extern "ptx-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "aapcs" is not supported on this target
-  --> $DIR/unsupported.rs:52:17
+  --> $DIR/unsupported.rs:51:17
    |
 LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^
@@ -24,13 +24,13 @@ LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:65:1
+  --> $DIR/unsupported.rs:64:1
    |
 LL | extern "aapcs" {}
    | ^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "msp430-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:74:18
+  --> $DIR/unsupported.rs:73:18
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,13 +39,13 @@ LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:79:1
+  --> $DIR/unsupported.rs:78:1
    |
 LL | extern "msp430-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "avr-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:84:15
+  --> $DIR/unsupported.rs:83:15
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,13 +54,13 @@ LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:89:1
+  --> $DIR/unsupported.rs:88:1
    |
 LL | extern "avr-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "x86-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:119:15
+  --> $DIR/unsupported.rs:118:15
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,13 +69,13 @@ LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:130:1
+  --> $DIR/unsupported.rs:129:1
    |
 LL | extern "x86-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "thiscall" is not supported on this target
-  --> $DIR/unsupported.rs:142:20
+  --> $DIR/unsupported.rs:141:20
    |
 LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -84,13 +84,13 @@ LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:155:1
+  --> $DIR/unsupported.rs:154:1
    |
 LL | extern "thiscall" {}
    | ^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "stdcall" is not supported on this target
-  --> $DIR/unsupported.rs:168:19
+  --> $DIR/unsupported.rs:167:19
    |
 LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    |                   ^^^^^^^^^^^^^^^^^^^^^
@@ -99,13 +99,13 @@ LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:181:1
+  --> $DIR/unsupported.rs:180:1
    |
 LL | extern "stdcall" {}
    | ^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "C-cmse-nonsecure-call" is not supported on this target
-  --> $DIR/unsupported.rs:188:21
+  --> $DIR/unsupported.rs:187:21
    |
 LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,7 +114,7 @@ LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 warning: the calling convention "C-cmse-nonsecure-entry" is not supported on this target
-  --> $DIR/unsupported.rs:196:22
+  --> $DIR/unsupported.rs:195:22
    |
 LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -123,61 +123,61 @@ LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:201:1
+  --> $DIR/unsupported.rs:200:1
    |
 LL | extern "C-cmse-nonsecure-entry" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:34:1
+  --> $DIR/unsupported.rs:33:1
    |
 LL | extern "ptx-kernel" fn ptx() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:43:1
+  --> $DIR/unsupported.rs:42:1
    |
 LL | extern "gpu-kernel" fn gpu() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:46:1
+  --> $DIR/unsupported.rs:45:1
    |
 LL | extern "aapcs" fn aapcs() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:72:1
+  --> $DIR/unsupported.rs:71:1
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:82:1
+  --> $DIR/unsupported.rs:81:1
    |
 LL | extern "avr-interrupt" fn avr() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:114:1
+  --> $DIR/unsupported.rs:113:1
    |
 LL | extern "x86-interrupt" fn x86() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:136:1
+  --> $DIR/unsupported.rs:135:1
    |
 LL | extern "thiscall" fn thiscall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:162:1
+  --> $DIR/unsupported.rs:161:1
    |
 LL | extern "stdcall" fn stdcall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:194:1
+  --> $DIR/unsupported.rs:193:1
    |
 LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/unsupported.riscv64.stderr b/tests/ui/abi/unsupported.riscv64.stderr
index abf403da8bd1..eef2ead4f0f3 100644
--- a/tests/ui/abi/unsupported.riscv64.stderr
+++ b/tests/ui/abi/unsupported.riscv64.stderr
@@ -1,5 +1,5 @@
 warning: the calling convention "ptx-kernel" is not supported on this target
-  --> $DIR/unsupported.rs:36:15
+  --> $DIR/unsupported.rs:35:15
    |
 LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,13 +9,13 @@ LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:41:1
+  --> $DIR/unsupported.rs:40:1
    |
 LL | extern "ptx-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "aapcs" is not supported on this target
-  --> $DIR/unsupported.rs:52:17
+  --> $DIR/unsupported.rs:51:17
    |
 LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^
@@ -24,13 +24,13 @@ LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:65:1
+  --> $DIR/unsupported.rs:64:1
    |
 LL | extern "aapcs" {}
    | ^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "msp430-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:74:18
+  --> $DIR/unsupported.rs:73:18
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,13 +39,13 @@ LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:79:1
+  --> $DIR/unsupported.rs:78:1
    |
 LL | extern "msp430-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "avr-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:84:15
+  --> $DIR/unsupported.rs:83:15
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,13 +54,13 @@ LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:89:1
+  --> $DIR/unsupported.rs:88:1
    |
 LL | extern "avr-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "x86-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:119:15
+  --> $DIR/unsupported.rs:118:15
    |
 LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,13 +69,13 @@ LL | fn x86_ptr(f: extern "x86-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:130:1
+  --> $DIR/unsupported.rs:129:1
    |
 LL | extern "x86-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "thiscall" is not supported on this target
-  --> $DIR/unsupported.rs:142:20
+  --> $DIR/unsupported.rs:141:20
    |
 LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -84,13 +84,13 @@ LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:155:1
+  --> $DIR/unsupported.rs:154:1
    |
 LL | extern "thiscall" {}
    | ^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "stdcall" is not supported on this target
-  --> $DIR/unsupported.rs:168:19
+  --> $DIR/unsupported.rs:167:19
    |
 LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    |                   ^^^^^^^^^^^^^^^^^^^^^
@@ -99,13 +99,13 @@ LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:181:1
+  --> $DIR/unsupported.rs:180:1
    |
 LL | extern "stdcall" {}
    | ^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "C-cmse-nonsecure-call" is not supported on this target
-  --> $DIR/unsupported.rs:188:21
+  --> $DIR/unsupported.rs:187:21
    |
 LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,7 +114,7 @@ LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 warning: the calling convention "C-cmse-nonsecure-entry" is not supported on this target
-  --> $DIR/unsupported.rs:196:22
+  --> $DIR/unsupported.rs:195:22
    |
 LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -123,61 +123,61 @@ LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:201:1
+  --> $DIR/unsupported.rs:200:1
    |
 LL | extern "C-cmse-nonsecure-entry" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:34:1
+  --> $DIR/unsupported.rs:33:1
    |
 LL | extern "ptx-kernel" fn ptx() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:43:1
+  --> $DIR/unsupported.rs:42:1
    |
 LL | extern "gpu-kernel" fn gpu() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:46:1
+  --> $DIR/unsupported.rs:45:1
    |
 LL | extern "aapcs" fn aapcs() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:72:1
+  --> $DIR/unsupported.rs:71:1
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:82:1
+  --> $DIR/unsupported.rs:81:1
    |
 LL | extern "avr-interrupt" fn avr() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"x86-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:114:1
+  --> $DIR/unsupported.rs:113:1
    |
 LL | extern "x86-interrupt" fn x86() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:136:1
+  --> $DIR/unsupported.rs:135:1
    |
 LL | extern "thiscall" fn thiscall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:162:1
+  --> $DIR/unsupported.rs:161:1
    |
 LL | extern "stdcall" fn stdcall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:194:1
+  --> $DIR/unsupported.rs:193:1
    |
 LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/abi/unsupported.rs b/tests/ui/abi/unsupported.rs
index 7d4142f0dee7..84646502f6fd 100644
--- a/tests/ui/abi/unsupported.rs
+++ b/tests/ui/abi/unsupported.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x64 i686 aarch64 arm riscv32 riscv64
 //
 //@ [x64] needs-llvm-components: x86
@@ -25,11 +26,9 @@
     abi_c_cmse_nonsecure_call,
     cmse_nonsecure_entry
 )]
-#[lang = "sized"]
-trait Sized {}
 
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 extern "ptx-kernel" fn ptx() {}
 //~^ ERROR is not a supported ABI
diff --git a/tests/ui/abi/unsupported.x64.stderr b/tests/ui/abi/unsupported.x64.stderr
index 824a33c948ad..80613d83e588 100644
--- a/tests/ui/abi/unsupported.x64.stderr
+++ b/tests/ui/abi/unsupported.x64.stderr
@@ -1,5 +1,5 @@
 warning: the calling convention "ptx-kernel" is not supported on this target
-  --> $DIR/unsupported.rs:36:15
+  --> $DIR/unsupported.rs:35:15
    |
 LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,13 +9,13 @@ LL | fn ptx_ptr(f: extern "ptx-kernel" fn()) {
    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:41:1
+  --> $DIR/unsupported.rs:40:1
    |
 LL | extern "ptx-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "aapcs" is not supported on this target
-  --> $DIR/unsupported.rs:52:17
+  --> $DIR/unsupported.rs:51:17
    |
 LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^
@@ -24,13 +24,13 @@ LL | fn aapcs_ptr(f: extern "aapcs" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:65:1
+  --> $DIR/unsupported.rs:64:1
    |
 LL | extern "aapcs" {}
    | ^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "msp430-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:74:18
+  --> $DIR/unsupported.rs:73:18
    |
 LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,13 +39,13 @@ LL | fn msp430_ptr(f: extern "msp430-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:79:1
+  --> $DIR/unsupported.rs:78:1
    |
 LL | extern "msp430-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "avr-interrupt" is not supported on this target
-  --> $DIR/unsupported.rs:84:15
+  --> $DIR/unsupported.rs:83:15
    |
 LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -54,13 +54,13 @@ LL | fn avr_ptr(f: extern "avr-interrupt" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:89:1
+  --> $DIR/unsupported.rs:88:1
    |
 LL | extern "avr-interrupt" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "riscv-interrupt-m" is not supported on this target
-  --> $DIR/unsupported.rs:97:17
+  --> $DIR/unsupported.rs:96:17
    |
 LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -69,13 +69,13 @@ LL | fn riscv_ptr(f: extern "riscv-interrupt-m" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:108:1
+  --> $DIR/unsupported.rs:107:1
    |
 LL | extern "riscv-interrupt-m" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "thiscall" is not supported on this target
-  --> $DIR/unsupported.rs:142:20
+  --> $DIR/unsupported.rs:141:20
    |
 LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    |                    ^^^^^^^^^^^^^^^^^^^^^^
@@ -84,13 +84,13 @@ LL | fn thiscall_ptr(f: extern "thiscall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:155:1
+  --> $DIR/unsupported.rs:154:1
    |
 LL | extern "thiscall" {}
    | ^^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "stdcall" is not supported on this target
-  --> $DIR/unsupported.rs:168:19
+  --> $DIR/unsupported.rs:167:19
    |
 LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    |                   ^^^^^^^^^^^^^^^^^^^^^
@@ -99,13 +99,13 @@ LL | fn stdcall_ptr(f: extern "stdcall" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:181:1
+  --> $DIR/unsupported.rs:180:1
    |
 LL | extern "stdcall" {}
    | ^^^^^^^^^^^^^^^^^^^
 
 warning: the calling convention "C-cmse-nonsecure-call" is not supported on this target
-  --> $DIR/unsupported.rs:188:21
+  --> $DIR/unsupported.rs:187:21
    |
 LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -114,7 +114,7 @@ LL | fn cmse_call_ptr(f: extern "C-cmse-nonsecure-call" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 warning: the calling convention "C-cmse-nonsecure-entry" is not supported on this target
-  --> $DIR/unsupported.rs:196:22
+  --> $DIR/unsupported.rs:195:22
    |
 LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    |                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -123,61 +123,61 @@ LL | fn cmse_entry_ptr(f: extern "C-cmse-nonsecure-entry" fn()) {
    = note: for more information, see issue #130260 <https://github.com/rust-lang/rust/issues/130260>
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:201:1
+  --> $DIR/unsupported.rs:200:1
    |
 LL | extern "C-cmse-nonsecure-entry" {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"ptx-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:34:1
+  --> $DIR/unsupported.rs:33:1
    |
 LL | extern "ptx-kernel" fn ptx() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:43:1
+  --> $DIR/unsupported.rs:42:1
    |
 LL | extern "gpu-kernel" fn gpu() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"aapcs"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:46:1
+  --> $DIR/unsupported.rs:45:1
    |
 LL | extern "aapcs" fn aapcs() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"msp430-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:72:1
+  --> $DIR/unsupported.rs:71:1
    |
 LL | extern "msp430-interrupt" fn msp430() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"avr-interrupt"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:82:1
+  --> $DIR/unsupported.rs:81:1
    |
 LL | extern "avr-interrupt" fn avr() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"riscv-interrupt-m"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:92:1
+  --> $DIR/unsupported.rs:91:1
    |
 LL | extern "riscv-interrupt-m" fn riscv() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"thiscall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:136:1
+  --> $DIR/unsupported.rs:135:1
    |
 LL | extern "thiscall" fn thiscall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"stdcall"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:162:1
+  --> $DIR/unsupported.rs:161:1
    |
 LL | extern "stdcall" fn stdcall() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/unsupported.rs:194:1
+  --> $DIR/unsupported.rs:193:1
    |
 LL | extern "C-cmse-nonsecure-entry" fn cmse_entry() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/asm/conditionally-sized-ptr-fail.rs b/tests/ui/asm/conditionally-sized-ptr-fail.rs
new file mode 100644
index 000000000000..b0a93495ffaf
--- /dev/null
+++ b/tests/ui/asm/conditionally-sized-ptr-fail.rs
@@ -0,0 +1,19 @@
+//@ needs-asm-support
+
+use std::arch::asm;
+
+fn _f<T: ?Sized>(p: *mut T) {
+    unsafe {
+        asm!("/* {} */", in(reg) p);
+        //~^ ERROR cannot use value of unsized pointer type `*mut T` for inline assembly
+    }
+}
+
+fn _g(p: *mut [u8]) {
+    unsafe {
+        asm!("/* {} */", in(reg) p);
+        //~^ ERROR cannot use value of unsized pointer type `*mut [u8]` for inline assembly
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/asm/conditionally-sized-ptr-fail.stderr b/tests/ui/asm/conditionally-sized-ptr-fail.stderr
new file mode 100644
index 000000000000..b88f59f569c6
--- /dev/null
+++ b/tests/ui/asm/conditionally-sized-ptr-fail.stderr
@@ -0,0 +1,18 @@
+error: cannot use value of unsized pointer type `*mut T` for inline assembly
+  --> $DIR/conditionally-sized-ptr-fail.rs:7:34
+   |
+LL |         asm!("/* {} */", in(reg) p);
+   |                                  ^
+   |
+   = note: only sized pointers can be used in inline assembly
+
+error: cannot use value of unsized pointer type `*mut [u8]` for inline assembly
+  --> $DIR/conditionally-sized-ptr-fail.rs:14:34
+   |
+LL |         asm!("/* {} */", in(reg) p);
+   |                                  ^
+   |
+   = note: only sized pointers can be used in inline assembly
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/asm/conditionally-sized-ptr.rs b/tests/ui/asm/conditionally-sized-ptr.rs
new file mode 100644
index 000000000000..8ff18fd1da16
--- /dev/null
+++ b/tests/ui/asm/conditionally-sized-ptr.rs
@@ -0,0 +1,12 @@
+//@ check-pass
+//@ needs-asm-support
+
+use std::arch::asm;
+
+fn _f<T>(p: *mut T) {
+    unsafe {
+        asm!("/* {} */", in(reg) p);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/asm/const-resolve-error.rs b/tests/ui/asm/const-resolve-error.rs
new file mode 100644
index 000000000000..19c8af0d542e
--- /dev/null
+++ b/tests/ui/asm/const-resolve-error.rs
@@ -0,0 +1,10 @@
+//@ edition:2021
+//@ needs-asm-support
+
+use std::arch::asm;
+
+async unsafe fn foo<'a>() {
+    asm!("/* {0} */", const N); //~ ERROR E0425
+}
+
+fn main() {}
diff --git a/tests/ui/asm/const-resolve-error.stderr b/tests/ui/asm/const-resolve-error.stderr
new file mode 100644
index 000000000000..f02a7f0a6b12
--- /dev/null
+++ b/tests/ui/asm/const-resolve-error.stderr
@@ -0,0 +1,14 @@
+error[E0425]: cannot find value `N` in this scope
+  --> $DIR/const-resolve-error.rs:7:29
+   |
+LL |     asm!("/* {0} */", const N);
+   |                             ^ not found in this scope
+   |
+help: you might be missing a const parameter
+   |
+LL | async unsafe fn foo<'a, const N: /* Type */>() {
+   |                       +++++++++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0425`.
diff --git a/tests/ui/asm/fail-const-eval-issue-121099.rs b/tests/ui/asm/fail-const-eval-issue-121099.rs
index 36d00b1e5d23..c91bbfd1b73f 100644
--- a/tests/ui/asm/fail-const-eval-issue-121099.rs
+++ b/tests/ui/asm/fail-const-eval-issue-121099.rs
@@ -5,6 +5,6 @@ use std::arch::global_asm;
 
 fn main() {}
 
-global_asm!("/* {} */", const 1 << 500); //~ ERROR evaluation of constant value failed [E0080]
+global_asm!("/* {} */", const 1 << 500); //~ ERROR E0080
 
-global_asm!("/* {} */", const 1 / 0); //~ ERROR evaluation of constant value failed [E0080]
+global_asm!("/* {} */", const 1 / 0); //~ ERROR E0080
diff --git a/tests/ui/asm/fail-const-eval-issue-121099.stderr b/tests/ui/asm/fail-const-eval-issue-121099.stderr
index 5d86c3a5f7bd..eb662dadffb1 100644
--- a/tests/ui/asm/fail-const-eval-issue-121099.stderr
+++ b/tests/ui/asm/fail-const-eval-issue-121099.stderr
@@ -1,10 +1,10 @@
-error[E0080]: evaluation of constant value failed
+error[E0080]: evaluation of `{global_asm#0}::{constant#0}` failed
   --> $DIR/fail-const-eval-issue-121099.rs:8:31
    |
 LL | global_asm!("/* {} */", const 1 << 500);
    |                               ^^^^^^^^ attempt to shift left by `500_i32`, which would overflow
 
-error[E0080]: evaluation of constant value failed
+error[E0080]: evaluation of `{global_asm#1}::{constant#0}` failed
   --> $DIR/fail-const-eval-issue-121099.rs:10:31
    |
 LL | global_asm!("/* {} */", const 1 / 0);
diff --git a/tests/ui/asm/invalid-const-operand.stderr b/tests/ui/asm/invalid-const-operand.stderr
index 13bb10e84a53..1cedabeef289 100644
--- a/tests/ui/asm/invalid-const-operand.stderr
+++ b/tests/ui/asm/invalid-const-operand.stderr
@@ -80,7 +80,7 @@ error: invalid type for `const` operand
 LL |         asm!("{}", const &0);
    |                    ^^^^^^--
    |                          |
-   |                          is a `&i32`
+   |                          is a `&{integer}`
    |
    = help: `const` operands must be of an integer type
 
diff --git a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
new file mode 100644
index 000000000000..b90bb9ea4ddf
--- /dev/null
+++ b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.rs
@@ -0,0 +1,8 @@
+// Regression test for <https://github.com/rust-lang/rust/issues/137554>.
+
+fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
+    //~^ ERROR `?Trait` is not permitted in trait object types
+    //~| ERROR expected trait, found associated function `Iterator::advance_by`
+    //~| ERROR the value of the associated type `Item` in `Iterator` must be specified
+    todo!()
+}
diff --git a/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
new file mode 100644
index 000000000000..7f0fbc800ed1
--- /dev/null
+++ b/tests/ui/associated-item/missing-associated_item_or_field_def_ids.stderr
@@ -0,0 +1,25 @@
+error[E0658]: `?Trait` is not permitted in trait object types
+  --> $DIR/missing-associated_item_or_field_def_ids.rs:3:29
+   |
+LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
+   |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0404]: expected trait, found associated function `Iterator::advance_by`
+  --> $DIR/missing-associated_item_or_field_def_ids.rs:3:30
+   |
+LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
+   |                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a trait
+
+error[E0191]: the value of the associated type `Item` in `Iterator` must be specified
+  --> $DIR/missing-associated_item_or_field_def_ids.rs:3:18
+   |
+LL | fn main() -> dyn Iterator + ?Iterator::advance_by(usize) {
+   |                  ^^^^^^^^ help: specify the associated type: `Iterator<Item = Type>`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0191, E0404, E0658.
+For more information about an error, try `rustc --explain E0191`.
diff --git a/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.rs b/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.rs
index f00aaec1a8c2..90fd2c2b4f32 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.rs
+++ b/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.rs
@@ -21,6 +21,9 @@ fn foo_path<T: Trait>() where T::method(i32): Send {}
 fn bar_path<T: Trait>() where T::method() -> (): Send {}
 //~^ ERROR return type not allowed with return type notation
 
+fn bay_path<T: Trait>() where T::method(..) -> (): Send {}
+//~^ ERROR return type not allowed with return type notation
+
 fn baz_path<T: Trait>() where T::method(): Send {}
 //~^ ERROR return type notation arguments must be elided with `..`
 
diff --git a/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.stderr b/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.stderr
index c6b9f3eff90e..bd02b7d6534a 100644
--- a/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.stderr
+++ b/tests/ui/associated-type-bounds/return-type-notation/bad-inputs-and-output.stderr
@@ -1,17 +1,29 @@
+error: return type not allowed with return type notation
+  --> $DIR/bad-inputs-and-output.rs:24:45
+   |
+LL | fn bay_path<T: Trait>() where T::method(..) -> (): Send {}
+   |                                             ^^^^^
+   |
+help: remove the return type
+   |
+LL - fn bay_path<T: Trait>() where T::method(..) -> (): Send {}
+LL + fn bay_path<T: Trait>() where T::method(..): Send {}
+   |
+
 error[E0575]: expected associated type, found associated function `Trait::method`
-  --> $DIR/bad-inputs-and-output.rs:27:36
+  --> $DIR/bad-inputs-and-output.rs:30:36
    |
 LL | fn foo_qualified<T: Trait>() where <T as Trait>::method(i32): Send {}
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^ not a associated type
 
 error[E0575]: expected associated type, found associated function `Trait::method`
-  --> $DIR/bad-inputs-and-output.rs:30:36
+  --> $DIR/bad-inputs-and-output.rs:33:36
    |
 LL | fn bar_qualified<T: Trait>() where <T as Trait>::method() -> (): Send {}
    |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ not a associated type
 
 error[E0575]: expected associated type, found associated function `Trait::method`
-  --> $DIR/bad-inputs-and-output.rs:33:36
+  --> $DIR/bad-inputs-and-output.rs:36:36
    |
 LL | fn baz_qualified<T: Trait>() where <T as Trait>::method(): Send {}
    |                                    ^^^^^^^^^^^^^^^^^^^^^^ not a associated type
@@ -20,38 +32,72 @@ error: argument types not allowed with return type notation
   --> $DIR/bad-inputs-and-output.rs:9:23
    |
 LL | fn foo<T: Trait<method(i32): Send>>() {}
-   |                       ^^^^^ help: remove the input types: `()`
+   |                       ^^^^^
+   |
+help: remove the input types
+   |
+LL - fn foo<T: Trait<method(i32): Send>>() {}
+LL + fn foo<T: Trait<method(..): Send>>() {}
+   |
 
 error: return type not allowed with return type notation
   --> $DIR/bad-inputs-and-output.rs:12:25
    |
 LL | fn bar<T: Trait<method() -> (): Send>>() {}
-   |                         ^^^^^^ help: remove the return type
+   |                         ^^^^^^
+   |
+help: use the right argument notation and remove the return type
+   |
+LL - fn bar<T: Trait<method() -> (): Send>>() {}
+LL + fn bar<T: Trait<method(..): Send>>() {}
+   |
 
 error: return type notation arguments must be elided with `..`
   --> $DIR/bad-inputs-and-output.rs:15:23
    |
 LL | fn baz<T: Trait<method(): Send>>() {}
-   |                       ^^ help: add `..`: `(..)`
+   |                       ^^
+   |
+help: use the correct syntax by adding `..` to the arguments
+   |
+LL | fn baz<T: Trait<method(..): Send>>() {}
+   |                        ++
 
 error: argument types not allowed with return type notation
   --> $DIR/bad-inputs-and-output.rs:18:40
    |
 LL | fn foo_path<T: Trait>() where T::method(i32): Send {}
-   |                                        ^^^^^ help: remove the input types: `()`
+   |                                        ^^^^^
+   |
+help: remove the input types
+   |
+LL - fn foo_path<T: Trait>() where T::method(i32): Send {}
+LL + fn foo_path<T: Trait>() where T::method(..): Send {}
+   |
 
 error: return type not allowed with return type notation
   --> $DIR/bad-inputs-and-output.rs:21:42
    |
 LL | fn bar_path<T: Trait>() where T::method() -> (): Send {}
-   |                                          ^^^^^^ help: remove the return type
+   |                                          ^^^^^^
+   |
+help: use the right argument notation and remove the return type
+   |
+LL - fn bar_path<T: Trait>() where T::method() -> (): Send {}
+LL + fn bar_path<T: Trait>() where T::method(..): Send {}
+   |
 
 error: return type notation arguments must be elided with `..`
-  --> $DIR/bad-inputs-and-output.rs:24:40
+  --> $DIR/bad-inputs-and-output.rs:27:40
    |
 LL | fn baz_path<T: Trait>() where T::method(): Send {}
-   |                                        ^^ help: add `..`: `(..)`
+   |                                        ^^
+   |
+help: use the correct syntax by adding `..` to the arguments
+   |
+LL | fn baz_path<T: Trait>() where T::method(..): Send {}
+   |                                         ++
 
-error: aborting due to 9 previous errors
+error: aborting due to 10 previous errors
 
 For more information about this error, try `rustc --explain E0575`.
diff --git a/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.rs b/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.rs
index 707bcac78bf9..227860436931 100644
--- a/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.rs
+++ b/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 // Test that we do not ICE when the self type is `ty::err`, but rather
 // just propagate the error.
 
@@ -6,17 +7,8 @@
 #![feature(no_core)]
 #![no_core]
 
-#[lang="sized"]
-pub trait Sized {
-    // Empty.
-}
-
-#[lang = "add"]
-trait Add<RHS=Self> {
-    type Output;
-
-    fn add(self, _: RHS) -> Self::Output;
-}
+extern crate minicore;
+use minicore::*;
 
 fn ice<A>(a: A) {
     let r = loop {};
diff --git a/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr b/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr
index ebe56c8cd689..0bbb601a6d23 100644
--- a/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr
+++ b/tests/ui/associated-types/associated-types-ICE-when-projecting-out-of-err.stderr
@@ -1,14 +1,8 @@
 error[E0277]: the trait bound `(): Add<A>` is not satisfied
-  --> $DIR/associated-types-ICE-when-projecting-out-of-err.rs:23:11
+  --> $DIR/associated-types-ICE-when-projecting-out-of-err.rs:15:11
    |
 LL |     r = r + a;
    |           ^ the trait `Add<A>` is not implemented for `()`
-   |
-help: this trait has no implementations, consider adding one
-  --> $DIR/associated-types-ICE-when-projecting-out-of-err.rs:15:1
-   |
-LL | trait Add<RHS=Self> {
-   | ^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
new file mode 100644
index 000000000000..f6b749a5100b
--- /dev/null
+++ b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.rs
@@ -0,0 +1,12 @@
+// Fix for <https://github.com/rust-lang/rust/issues/137508>.
+
+trait Tr {
+    type Item;
+}
+
+fn main() {
+    let _: dyn Tr + ?Foo<Assoc = ()>;
+    //~^ ERROR: `?Trait` is not permitted in trait object types
+    //~| ERROR: cannot find trait `Foo` in this scope
+    //~| ERROR: the value of the associated type `Item` in `Tr` must be specified
+}
diff --git a/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
new file mode 100644
index 000000000000..f31a1de76a79
--- /dev/null
+++ b/tests/ui/associated-types/avoid-getting-associated-items-of-undefined-trait.stderr
@@ -0,0 +1,28 @@
+error[E0658]: `?Trait` is not permitted in trait object types
+  --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:21
+   |
+LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
+   |                     ^^^^^^^^^^^^^^^^
+   |
+   = help: add `#![feature(more_maybe_bounds)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error[E0405]: cannot find trait `Foo` in this scope
+  --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:22
+   |
+LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
+   |                      ^^^ not found in this scope
+
+error[E0191]: the value of the associated type `Item` in `Tr` must be specified
+  --> $DIR/avoid-getting-associated-items-of-undefined-trait.rs:8:16
+   |
+LL |     type Item;
+   |     --------- `Item` defined here
+...
+LL |     let _: dyn Tr + ?Foo<Assoc = ()>;
+   |                ^^ help: specify the associated type: `Tr<Item = Type>`
+
+error: aborting due to 3 previous errors
+
+Some errors have detailed explanations: E0191, E0405, E0658.
+For more information about an error, try `rustc --explain E0191`.
diff --git a/tests/ui/async-await/async-fn/suggest-constrain.rs b/tests/ui/async-await/async-fn/suggest-constrain.rs
new file mode 100644
index 000000000000..319dcc0084a7
--- /dev/null
+++ b/tests/ui/async-await/async-fn/suggest-constrain.rs
@@ -0,0 +1,11 @@
+// Ensure that we don't suggest constraining `CallRefFuture` here,
+// since that isn't stable.
+
+fn spawn<F: AsyncFn() + Send>(f: F) {
+    check_send(f());
+    //~^ ERROR cannot be sent between threads safely
+}
+
+fn check_send<T: Send>(_: T) {}
+
+fn main() {}
diff --git a/tests/ui/async-await/async-fn/suggest-constrain.stderr b/tests/ui/async-await/async-fn/suggest-constrain.stderr
new file mode 100644
index 000000000000..94270aad63e2
--- /dev/null
+++ b/tests/ui/async-await/async-fn/suggest-constrain.stderr
@@ -0,0 +1,18 @@
+error[E0277]: `<F as AsyncFnMut<()>>::CallRefFuture<'_>` cannot be sent between threads safely
+  --> $DIR/suggest-constrain.rs:5:16
+   |
+LL |     check_send(f());
+   |     ---------- ^^^ `<F as AsyncFnMut<()>>::CallRefFuture<'_>` cannot be sent between threads safely
+   |     |
+   |     required by a bound introduced by this call
+   |
+   = help: the trait `Send` is not implemented for `<F as AsyncFnMut<()>>::CallRefFuture<'_>`
+note: required by a bound in `check_send`
+  --> $DIR/suggest-constrain.rs:9:18
+   |
+LL | fn check_send<T: Send>(_: T) {}
+   |                  ^^^^ required by this bound in `check_send`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/attributes/arg-error-issue-121425.stderr b/tests/ui/attributes/arg-error-issue-121425.stderr
index 1beb99b1703c..6e71f15fdc87 100644
--- a/tests/ui/attributes/arg-error-issue-121425.stderr
+++ b/tests/ui/attributes/arg-error-issue-121425.stderr
@@ -1,3 +1,9 @@
+error[E0693]: incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
+  --> $DIR/arg-error-issue-121425.rs:16:8
+   |
+LL | #[repr(align())]
+   |        ^^^^^^^
+
 error[E0693]: incorrect `repr(align)` attribute format: `align` expects a literal integer as argument
   --> $DIR/arg-error-issue-121425.rs:4:14
    |
@@ -16,12 +22,6 @@ error[E0589]: invalid `repr(align)` attribute: not an unsuffixed integer
 LL | #[repr(align("str"))]
    |              ^^^^^
 
-error[E0693]: incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
-  --> $DIR/arg-error-issue-121425.rs:16:8
-   |
-LL | #[repr(align())]
-   |        ^^^^^^^
-
 error[E0552]: incorrect `repr(packed)` attribute format: `packed` expects a literal integer as argument
   --> $DIR/arg-error-issue-121425.rs:21:15
    |
diff --git a/tests/ui/attributes/auxiliary/used_pre_main_constructor.rs b/tests/ui/attributes/auxiliary/used_pre_main_constructor.rs
new file mode 100644
index 000000000000..686dcb277f89
--- /dev/null
+++ b/tests/ui/attributes/auxiliary/used_pre_main_constructor.rs
@@ -0,0 +1,32 @@
+//! Add a constructor that runs pre-main, similar to what the `ctor` crate does.
+//!
+//! #[ctor]
+//! fn constructor() {
+//!     println!("constructor");
+//! }
+
+//@ no-prefer-dynamic explicitly test with crates that are built as an archive
+#![crate_type = "rlib"]
+
+#[cfg_attr(
+    any(
+        target_os = "linux",
+        target_os = "android",
+        target_os = "freebsd",
+        target_os = "netbsd",
+        target_os = "openbsd",
+        target_os = "dragonfly",
+        target_os = "illumos",
+        target_os = "haiku"
+    ),
+    link_section = ".init_array"
+)]
+#[cfg_attr(target_vendor = "apple", link_section = "__DATA,__mod_init_func,mod_init_funcs")]
+#[cfg_attr(target_os = "windows", link_section = ".CRT$XCU")]
+#[used]
+static CONSTRUCTOR: extern "C" fn() = constructor;
+
+#[cfg_attr(any(target_os = "linux", target_os = "android"), link_section = ".text.startup")]
+extern "C" fn constructor() {
+    println!("constructor");
+}
diff --git a/tests/ui/attributes/crate-type-macro-empty.rs b/tests/ui/attributes/crate-type-macro-empty.rs
new file mode 100644
index 000000000000..5ff7fc002fde
--- /dev/null
+++ b/tests/ui/attributes/crate-type-macro-empty.rs
@@ -0,0 +1,7 @@
+// Tests for the issue in #137589
+#[crate_type = foo!()]
+//~^ ERROR cannot find macro `foo` in this scope
+
+macro_rules! foo {} //~ ERROR unexpected end of macro invocation
+
+fn main() {}
diff --git a/tests/ui/attributes/crate-type-macro-empty.stderr b/tests/ui/attributes/crate-type-macro-empty.stderr
new file mode 100644
index 000000000000..e48d3d95470d
--- /dev/null
+++ b/tests/ui/attributes/crate-type-macro-empty.stderr
@@ -0,0 +1,20 @@
+error: unexpected end of macro invocation
+  --> $DIR/crate-type-macro-empty.rs:5:1
+   |
+LL | macro_rules! foo {}
+   | ^^^^^^^^^^^^^^^^^^^ missing tokens in macro arguments
+
+error: cannot find macro `foo` in this scope
+  --> $DIR/crate-type-macro-empty.rs:2:16
+   |
+LL | #[crate_type = foo!()]
+   |                ^^^ consider moving the definition of `foo` before this call
+   |
+note: a macro with the same name exists, but it appears later
+  --> $DIR/crate-type-macro-empty.rs:5:14
+   |
+LL | macro_rules! foo {}
+   |              ^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/attributes/crate-type-macro-not-crate.rs b/tests/ui/attributes/crate-type-macro-not-crate.rs
new file mode 100644
index 000000000000..e5eb22d6f6e2
--- /dev/null
+++ b/tests/ui/attributes/crate-type-macro-not-crate.rs
@@ -0,0 +1,9 @@
+// Tests for the issue in #137589
+
+
+macro_rules! foo {
+    ($x:expr) => {"rlib"}
+}
+
+#[crate_type = foo!()] //~ ERROR unexpected end of macro invocation
+fn main() {}
diff --git a/tests/ui/attributes/crate-type-macro-not-crate.stderr b/tests/ui/attributes/crate-type-macro-not-crate.stderr
new file mode 100644
index 000000000000..ce188b3eef5f
--- /dev/null
+++ b/tests/ui/attributes/crate-type-macro-not-crate.stderr
@@ -0,0 +1,17 @@
+error: unexpected end of macro invocation
+  --> $DIR/crate-type-macro-not-crate.rs:8:16
+   |
+LL | macro_rules! foo {
+   | ---------------- when calling this macro
+...
+LL | #[crate_type = foo!()]
+   |                ^^^^^^ missing tokens in macro arguments
+   |
+note: while trying to match meta-variable `$x:expr`
+  --> $DIR/crate-type-macro-not-crate.rs:5:6
+   |
+LL |     ($x:expr) => {"rlib"}
+   |      ^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/attributes/crate-type-macro-not-found.rs b/tests/ui/attributes/crate-type-macro-not-found.rs
new file mode 100644
index 000000000000..824468c0e85b
--- /dev/null
+++ b/tests/ui/attributes/crate-type-macro-not-found.rs
@@ -0,0 +1,8 @@
+// Tests for the issue in #137589
+#[crate_type = foo!()] //~ ERROR cannot find macro `foo` in this scope
+
+macro_rules! foo {
+    ($x:expr) => {"rlib"}
+}
+
+fn main() {}
diff --git a/tests/ui/attributes/crate-type-macro-not-found.stderr b/tests/ui/attributes/crate-type-macro-not-found.stderr
new file mode 100644
index 000000000000..a4967e4f12e9
--- /dev/null
+++ b/tests/ui/attributes/crate-type-macro-not-found.stderr
@@ -0,0 +1,14 @@
+error: cannot find macro `foo` in this scope
+  --> $DIR/crate-type-macro-not-found.rs:2:16
+   |
+LL | #[crate_type = foo!()]
+   |                ^^^ consider moving the definition of `foo` before this call
+   |
+note: a macro with the same name exists, but it appears later
+  --> $DIR/crate-type-macro-not-found.rs:4:14
+   |
+LL | macro_rules! foo {
+   |              ^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/attributes/issue-100631.stderr b/tests/ui/attributes/issue-100631.stderr
index 6e8e4f3b418f..b2bd0a963251 100644
--- a/tests/ui/attributes/issue-100631.stderr
+++ b/tests/ui/attributes/issue-100631.stderr
@@ -1,8 +1,8 @@
 error[E0084]: unsupported representation for zero-variant enum
-  --> $DIR/issue-100631.rs:4:1
+  --> $DIR/issue-100631.rs:4:8
    |
 LL | #[repr(C)]
-   | ^^^^^^^^^^
+   |        ^
 LL | #[repr(C)]
 LL | enum Foo {}
    | -------- zero-variant enum
diff --git a/tests/ui/attributes/malformed-fn-align.rs b/tests/ui/attributes/malformed-fn-align.rs
new file mode 100644
index 000000000000..4aaad01b7235
--- /dev/null
+++ b/tests/ui/attributes/malformed-fn-align.rs
@@ -0,0 +1,7 @@
+#![feature(fn_align)]
+#![crate_type = "lib"]
+
+trait MyTrait {
+    #[repr(align)] //~ ERROR invalid `repr(align)` attribute: `align` needs an argument
+    fn myfun();
+}
diff --git a/tests/ui/attributes/malformed-fn-align.stderr b/tests/ui/attributes/malformed-fn-align.stderr
new file mode 100644
index 000000000000..57913c48ef78
--- /dev/null
+++ b/tests/ui/attributes/malformed-fn-align.stderr
@@ -0,0 +1,9 @@
+error[E0589]: invalid `repr(align)` attribute: `align` needs an argument
+  --> $DIR/malformed-fn-align.rs:5:12
+   |
+LL |     #[repr(align)]
+   |            ^^^^^ help: supply an argument here: `align(...)`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0589`.
diff --git a/tests/ui/attributes/mixed_export_name_and_no_mangle.fixed b/tests/ui/attributes/mixed_export_name_and_no_mangle.fixed
index 7224d4289e3f..d8b5235c52fb 100644
--- a/tests/ui/attributes/mixed_export_name_and_no_mangle.fixed
+++ b/tests/ui/attributes/mixed_export_name_and_no_mangle.fixed
@@ -3,7 +3,7 @@
 //@ check-pass
 
 #![warn(unused_attributes)]
-//~^ WARN `#[no_mangle]` attribute may not be used in combination with `#[export_name]` [unused_attributes]
+//~^ WARN `#[unsafe(no_mangle)]` attribute may not be used in combination with `#[export_name]` [unused_attributes]
 #[export_name = "foo"]
 pub fn bar() {}
 
diff --git a/tests/ui/attributes/mixed_export_name_and_no_mangle.rs b/tests/ui/attributes/mixed_export_name_and_no_mangle.rs
index 149a7904e1ea..83a673a7d132 100644
--- a/tests/ui/attributes/mixed_export_name_and_no_mangle.rs
+++ b/tests/ui/attributes/mixed_export_name_and_no_mangle.rs
@@ -4,7 +4,7 @@
 
 #![warn(unused_attributes)]
 #[no_mangle]
-//~^ WARN `#[no_mangle]` attribute may not be used in combination with `#[export_name]` [unused_attributes]
+//~^ WARN `#[unsafe(no_mangle)]` attribute may not be used in combination with `#[export_name]` [unused_attributes]
 #[export_name = "foo"]
 pub fn bar() {}
 
diff --git a/tests/ui/attributes/mixed_export_name_and_no_mangle.stderr b/tests/ui/attributes/mixed_export_name_and_no_mangle.stderr
index ba63127ba2db..c760d27db251 100644
--- a/tests/ui/attributes/mixed_export_name_and_no_mangle.stderr
+++ b/tests/ui/attributes/mixed_export_name_and_no_mangle.stderr
@@ -1,8 +1,8 @@
-warning: `#[no_mangle]` attribute may not be used in combination with `#[export_name]`
+warning: `#[unsafe(no_mangle)]` attribute may not be used in combination with `#[export_name]`
   --> $DIR/mixed_export_name_and_no_mangle.rs:6:1
    |
 LL | #[no_mangle]
-   | ^^^^^^^^^^^^ `#[no_mangle]` is ignored
+   | ^^^^^^^^^^^^ `#[unsafe(no_mangle)]` is ignored
    |
 note: `#[export_name]` takes precedence
   --> $DIR/mixed_export_name_and_no_mangle.rs:8:1
@@ -14,7 +14,7 @@ note: the lint level is defined here
    |
 LL | #![warn(unused_attributes)]
    |         ^^^^^^^^^^^^^^^^^
-help: remove the `#[no_mangle]` attribute
+help: remove the `#[unsafe(no_mangle)]` attribute
    |
 LL - #[no_mangle]
    |
diff --git a/tests/ui/attributes/nonterminal-expansion.rs b/tests/ui/attributes/nonterminal-expansion.rs
index 1b2e92a31703..83c8f00999a7 100644
--- a/tests/ui/attributes/nonterminal-expansion.rs
+++ b/tests/ui/attributes/nonterminal-expansion.rs
@@ -5,7 +5,8 @@
 macro_rules! pass_nonterminal {
     ($n:expr) => {
         #[repr(align($n))]
-        //~^ ERROR expected unsuffixed literal, found `n!()`
+        //~^ ERROR expected unsuffixed literal, found expression `n!()`
+        //~^^ ERROR incorrect `repr(align)` attribute format: `align` expects a literal integer as argument [E0693]
         struct S;
     };
 }
@@ -15,6 +16,5 @@ macro_rules! n {
 }
 
 pass_nonterminal!(n!());
-//~^ ERROR incorrect `repr(align)` attribute format: `align` expects a literal integer as argument [E0693]
 
 fn main() {}
diff --git a/tests/ui/attributes/nonterminal-expansion.stderr b/tests/ui/attributes/nonterminal-expansion.stderr
index b640575d17dc..8a85731bd5a1 100644
--- a/tests/ui/attributes/nonterminal-expansion.stderr
+++ b/tests/ui/attributes/nonterminal-expansion.stderr
@@ -1,4 +1,4 @@
-error: expected unsuffixed literal, found `n!()`
+error: expected unsuffixed literal, found expression `n!()`
   --> $DIR/nonterminal-expansion.rs:7:22
    |
 LL |         #[repr(align($n))]
@@ -10,10 +10,15 @@ LL | pass_nonterminal!(n!());
    = note: this error originates in the macro `pass_nonterminal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0693]: incorrect `repr(align)` attribute format: `align` expects a literal integer as argument
-  --> $DIR/nonterminal-expansion.rs:17:19
+  --> $DIR/nonterminal-expansion.rs:7:22
    |
+LL |         #[repr(align($n))]
+   |                      ^^
+...
 LL | pass_nonterminal!(n!());
-   |                   ^
+   | ----------------------- in this macro invocation
+   |
+   = note: this error originates in the macro `pass_nonterminal` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/attributes/repr-align-in-trait-issue-132391.rs b/tests/ui/attributes/repr-align-in-trait-issue-132391.rs
new file mode 100644
index 000000000000..b3b79e93e9bd
--- /dev/null
+++ b/tests/ui/attributes/repr-align-in-trait-issue-132391.rs
@@ -0,0 +1,6 @@
+trait MyTrait {
+    #[repr(align)] //~ ERROR invalid `repr(align)` attribute: `align` needs an argument
+    fn myfun();
+}
+
+pub fn main() {}
diff --git a/tests/ui/attributes/repr-align-in-trait-issue-132391.stderr b/tests/ui/attributes/repr-align-in-trait-issue-132391.stderr
new file mode 100644
index 000000000000..4208b018f52f
--- /dev/null
+++ b/tests/ui/attributes/repr-align-in-trait-issue-132391.stderr
@@ -0,0 +1,9 @@
+error[E0589]: invalid `repr(align)` attribute: `align` needs an argument
+  --> $DIR/repr-align-in-trait-issue-132391.rs:2:12
+   |
+LL |     #[repr(align)]
+   |            ^^^^^ help: supply an argument here: `align(...)`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0589`.
diff --git a/tests/ui/attributes/rustc_confusables.stderr b/tests/ui/attributes/rustc_confusables.stderr
index dc71d974daf5..55c9219a08a8 100644
--- a/tests/ui/attributes/rustc_confusables.stderr
+++ b/tests/ui/attributes/rustc_confusables.stderr
@@ -4,12 +4,6 @@ error: malformed `rustc_confusables` attribute input
 LL |     #[rustc_confusables]
    |     ^^^^^^^^^^^^^^^^^^^^ help: must be of the form: `#[rustc_confusables("name1", "name2", ...)]`
 
-error: attribute should be applied to an inherent method
-  --> $DIR/rustc_confusables.rs:45:1
-   |
-LL | #[rustc_confusables("blah")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error: expected at least one confusable name
   --> $DIR/rustc_confusables.rs:30:5
    |
@@ -27,6 +21,12 @@ help: consider surrounding this with quotes
 LL |     #[rustc_confusables("invalid_meta_item")]
    |                         +                 +
 
+error: attribute should be applied to an inherent method
+  --> $DIR/rustc_confusables.rs:45:1
+   |
+LL | #[rustc_confusables("blah")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0599]: no method named `inser` found for struct `rustc_confusables_across_crate::BTreeSet` in the current scope
   --> $DIR/rustc_confusables.rs:12:7
    |
diff --git a/tests/ui/attributes/used_with_archive.rs b/tests/ui/attributes/used_with_archive.rs
new file mode 100644
index 000000000000..ff29456b87d2
--- /dev/null
+++ b/tests/ui/attributes/used_with_archive.rs
@@ -0,0 +1,16 @@
+//! Ensure that `#[used]` in archives are correctly registered.
+//!
+//! Regression test for https://github.com/rust-lang/rust/issues/133491.
+
+//@ run-pass
+//@ check-run-results
+//@ aux-build: used_pre_main_constructor.rs
+
+//@ ignore-wasm ctor doesn't work on WASM
+
+// Make sure `rustc` links the archive, but intentionally do not import/use any items.
+extern crate used_pre_main_constructor as _;
+
+fn main() {
+    println!("main");
+}
diff --git a/tests/ui/attributes/used_with_archive.run.stdout b/tests/ui/attributes/used_with_archive.run.stdout
new file mode 100644
index 000000000000..212372b3e579
--- /dev/null
+++ b/tests/ui/attributes/used_with_archive.run.stdout
@@ -0,0 +1,2 @@
+constructor
+main
diff --git a/tests/ui/borrowck/issue-81899.rs b/tests/ui/borrowck/issue-81899.rs
index 1f1af5c7e050..380c03751f50 100644
--- a/tests/ui/borrowck/issue-81899.rs
+++ b/tests/ui/borrowck/issue-81899.rs
@@ -1,15 +1,14 @@
 // Regression test for #81899.
 // The `panic!()` below is important to trigger the fixed ICE.
 
-const _CONST: &[u8] = &f(&[], |_| {});
+const _CONST: &[u8] = &f(&[], |_| {}); //~ ERROR evaluation of constant value failed
 //~^ constant
 
 const fn f<F>(_: &[u8], _: F) -> &[u8]
 where
     F: FnMut(&u8),
 {
-    panic!() //~ ERROR evaluation of constant value failed
-    //~^ panic
+    panic!() //~ inside `f
 }
 
 fn main() {}
diff --git a/tests/ui/borrowck/issue-81899.stderr b/tests/ui/borrowck/issue-81899.stderr
index 1da573ea97c1..2e6e7511ec91 100644
--- a/tests/ui/borrowck/issue-81899.stderr
+++ b/tests/ui/borrowck/issue-81899.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/issue-81899.rs:11:5
+  --> $DIR/issue-81899.rs:4:24
    |
-LL |     panic!()
-   |     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-81899.rs:11:5
+LL | const _CONST: &[u8] = &f(&[], |_| {});
+   |                        ^^^^^^^^^^^^^^ evaluation panicked: explicit panic
    |
 note: inside `f::<{closure@$DIR/issue-81899.rs:4:31: 4:34}>`
   --> $DIR/issue-81899.rs:11:5
    |
 LL |     panic!()
-   |     ^^^^^^^^
-note: inside `_CONST`
-  --> $DIR/issue-81899.rs:4:24
-   |
-LL | const _CONST: &[u8] = &f(&[], |_| {});
-   |                        ^^^^^^^^^^^^^^
+   |     ^^^^^^^^ the failure occurred here
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: erroneous constant encountered
diff --git a/tests/ui/borrowck/issue-88434-minimal-example.rs b/tests/ui/borrowck/issue-88434-minimal-example.rs
index b75abcb731e2..ebaa9a92273b 100644
--- a/tests/ui/borrowck/issue-88434-minimal-example.rs
+++ b/tests/ui/borrowck/issue-88434-minimal-example.rs
@@ -1,14 +1,13 @@
 // Regression test related to issue 88434
 
-const _CONST: &() = &f(&|_| {});
+const _CONST: &() = &f(&|_| {}); //~ ERROR evaluation of constant value failed
 //~^ constant
 
 const fn f<F>(_: &F)
 where
     F: FnMut(&u8),
 {
-    panic!() //~ ERROR evaluation of constant value failed
-    //~^ panic
+    panic!() //~ inside `f
 }
 
 fn main() { }
diff --git a/tests/ui/borrowck/issue-88434-minimal-example.stderr b/tests/ui/borrowck/issue-88434-minimal-example.stderr
index b32331ce448e..c8ac13a3473d 100644
--- a/tests/ui/borrowck/issue-88434-minimal-example.stderr
+++ b/tests/ui/borrowck/issue-88434-minimal-example.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/issue-88434-minimal-example.rs:10:5
+  --> $DIR/issue-88434-minimal-example.rs:3:22
    |
-LL |     panic!()
-   |     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-88434-minimal-example.rs:10:5
+LL | const _CONST: &() = &f(&|_| {});
+   |                      ^^^^^^^^^^ evaluation panicked: explicit panic
    |
 note: inside `f::<{closure@$DIR/issue-88434-minimal-example.rs:3:25: 3:28}>`
   --> $DIR/issue-88434-minimal-example.rs:10:5
    |
 LL |     panic!()
-   |     ^^^^^^^^
-note: inside `_CONST`
-  --> $DIR/issue-88434-minimal-example.rs:3:22
-   |
-LL | const _CONST: &() = &f(&|_| {});
-   |                      ^^^^^^^^^^
+   |     ^^^^^^^^ the failure occurred here
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: erroneous constant encountered
diff --git a/tests/ui/borrowck/issue-88434-removal-index-should-be-less.rs b/tests/ui/borrowck/issue-88434-removal-index-should-be-less.rs
index f9134e669dca..8d042630424b 100644
--- a/tests/ui/borrowck/issue-88434-removal-index-should-be-less.rs
+++ b/tests/ui/borrowck/issue-88434-removal-index-should-be-less.rs
@@ -1,14 +1,13 @@
 // Regression test for issue 88434
 
-const _CONST: &[u8] = &f(&[], |_| {});
+const _CONST: &[u8] = &f(&[], |_| {}); //~ ERROR evaluation of constant value failed
 //~^ constant
 
 const fn f<F>(_: &[u8], _: F) -> &[u8]
 where
     F: FnMut(&u8),
 {
-    panic!() //~ ERROR evaluation of constant value failed
-    //~^ panic
+    panic!() //~ inside `f
 }
 
 fn main() { }
diff --git a/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr b/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr
index e3c881dd4650..0041759609ca 100644
--- a/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr
+++ b/tests/ui/borrowck/issue-88434-removal-index-should-be-less.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/issue-88434-removal-index-should-be-less.rs:10:5
+  --> $DIR/issue-88434-removal-index-should-be-less.rs:3:24
    |
-LL |     panic!()
-   |     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-88434-removal-index-should-be-less.rs:10:5
+LL | const _CONST: &[u8] = &f(&[], |_| {});
+   |                        ^^^^^^^^^^^^^^ evaluation panicked: explicit panic
    |
 note: inside `f::<{closure@$DIR/issue-88434-removal-index-should-be-less.rs:3:31: 3:34}>`
   --> $DIR/issue-88434-removal-index-should-be-less.rs:10:5
    |
 LL |     panic!()
-   |     ^^^^^^^^
-note: inside `_CONST`
-  --> $DIR/issue-88434-removal-index-should-be-less.rs:3:24
-   |
-LL | const _CONST: &[u8] = &f(&[], |_| {});
-   |                        ^^^^^^^^^^^^^^
+   |     ^^^^^^^^ the failure occurred here
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: erroneous constant encountered
diff --git a/tests/ui/borrowck/issue-92157.rs b/tests/ui/borrowck/issue-92157.rs
index a2b685cdf6ed..72f216e301df 100644
--- a/tests/ui/borrowck/issue-92157.rs
+++ b/tests/ui/borrowck/issue-92157.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 #![feature(no_core)]
 #![feature(lang_items)]
 
@@ -13,28 +14,7 @@ fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8) -> isize {
     40+2
 }
 
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-
-#[lang = "drop_in_place"]
-#[allow(unconditional_recursion)]
-pub unsafe fn drop_in_place<T: ?Sized>(to_drop: *mut T) {
-    drop_in_place(to_drop)
-}
-
-#[lang = "add"]
-trait Add<RHS> {
-    type Output;
-    fn add(self, other: RHS) -> Self::Output;
-}
-
-impl Add<isize> for isize {
-    type Output = isize;
-    fn add(self, other: isize) -> isize {
-        self + other
-    }
-}
+extern crate minicore;
+use minicore::*;
 
 fn main() {}
diff --git a/tests/ui/borrowck/issue-92157.stderr b/tests/ui/borrowck/issue-92157.stderr
index 0ffedccd6906..248d700ab4b9 100644
--- a/tests/ui/borrowck/issue-92157.stderr
+++ b/tests/ui/borrowck/issue-92157.stderr
@@ -1,5 +1,5 @@
 error[E0308]: lang item `start` function has wrong type
-  --> $DIR/issue-92157.rs:11:1
+  --> $DIR/issue-92157.rs:12:1
    |
 LL | fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8) -> isize {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ incorrect number of function parameters
diff --git a/tests/ui/c-variadic/variadic-ffi-1.rs b/tests/ui/c-variadic/variadic-ffi-1.rs
index e41ab2692111..9dcd55d13e3c 100644
--- a/tests/ui/c-variadic/variadic-ffi-1.rs
+++ b/tests/ui/c-variadic/variadic-ffi-1.rs
@@ -1,9 +1,11 @@
+//@ add-core-stubs
 //@ needs-llvm-components: x86
 //@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib
 #![no_core]
 #![feature(no_core, lang_items)]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 extern "stdcall" {
     fn printf(_: *const u8, ...);
diff --git a/tests/ui/c-variadic/variadic-ffi-1.stderr b/tests/ui/c-variadic/variadic-ffi-1.stderr
index 39dfb2548a3b..f99abed0a625 100644
--- a/tests/ui/c-variadic/variadic-ffi-1.stderr
+++ b/tests/ui/c-variadic/variadic-ffi-1.stderr
@@ -1,17 +1,17 @@
 error[E0045]: C-variadic function must have a compatible calling convention, like `C`, `cdecl`, `system`, `aapcs`, `win64`, `sysv64` or `efiapi`
-  --> $DIR/variadic-ffi-1.rs:9:5
+  --> $DIR/variadic-ffi-1.rs:11:5
    |
 LL |     fn printf(_: *const u8, ...);
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
 
 error[E0060]: this function takes at least 2 arguments but 0 arguments were supplied
-  --> $DIR/variadic-ffi-1.rs:22:9
+  --> $DIR/variadic-ffi-1.rs:24:9
    |
 LL |         foo();
    |         ^^^-- two arguments of type `isize` and `u8` are missing
    |
 note: function defined here
-  --> $DIR/variadic-ffi-1.rs:15:8
+  --> $DIR/variadic-ffi-1.rs:17:8
    |
 LL |     fn foo(f: isize, x: u8, ...);
    |        ^^^ -         -
@@ -21,13 +21,13 @@ LL |         foo(/* isize */, /* u8 */);
    |             +++++++++++++++++++++
 
 error[E0060]: this function takes at least 2 arguments but 1 argument was supplied
-  --> $DIR/variadic-ffi-1.rs:23:9
+  --> $DIR/variadic-ffi-1.rs:25:9
    |
 LL |         foo(1);
    |         ^^^--- argument #2 of type `u8` is missing
    |
 note: function defined here
-  --> $DIR/variadic-ffi-1.rs:15:8
+  --> $DIR/variadic-ffi-1.rs:17:8
    |
 LL |     fn foo(f: isize, x: u8, ...);
    |        ^^^           -
@@ -37,7 +37,7 @@ LL |         foo(1, /* u8 */);
    |              ++++++++++
 
 error[E0308]: mismatched types
-  --> $DIR/variadic-ffi-1.rs:25:56
+  --> $DIR/variadic-ffi-1.rs:27:56
    |
 LL |         let x: unsafe extern "C" fn(f: isize, x: u8) = foo;
    |                -------------------------------------   ^^^ expected non-variadic fn, found variadic function
@@ -48,7 +48,7 @@ LL |         let x: unsafe extern "C" fn(f: isize, x: u8) = foo;
                  found fn item `unsafe extern "C" fn(_, _, ...) {foo}`
 
 error[E0308]: mismatched types
-  --> $DIR/variadic-ffi-1.rs:26:54
+  --> $DIR/variadic-ffi-1.rs:28:54
    |
 LL |         let y: extern "C" fn(f: isize, x: u8, ...) = bar;
    |                -----------------------------------   ^^^ expected variadic fn, found non-variadic function
@@ -59,7 +59,7 @@ LL |         let y: extern "C" fn(f: isize, x: u8, ...) = bar;
                  found fn item `extern "C" fn(_, _) {bar}`
 
 error[E0617]: can't pass `f32` to variadic function
-  --> $DIR/variadic-ffi-1.rs:28:19
+  --> $DIR/variadic-ffi-1.rs:30:19
    |
 LL |         foo(1, 2, 3f32);
    |                   ^^^^
@@ -70,7 +70,7 @@ LL |         foo(1, 2, 3f32 as c_double);
    |                        +++++++++++
 
 error[E0617]: can't pass `bool` to variadic function
-  --> $DIR/variadic-ffi-1.rs:29:19
+  --> $DIR/variadic-ffi-1.rs:31:19
    |
 LL |         foo(1, 2, true);
    |                   ^^^^
@@ -81,7 +81,7 @@ LL |         foo(1, 2, true as c_int);
    |                        ++++++++
 
 error[E0617]: can't pass `i8` to variadic function
-  --> $DIR/variadic-ffi-1.rs:30:19
+  --> $DIR/variadic-ffi-1.rs:32:19
    |
 LL |         foo(1, 2, 1i8);
    |                   ^^^
@@ -92,7 +92,7 @@ LL |         foo(1, 2, 1i8 as c_int);
    |                       ++++++++
 
 error[E0617]: can't pass `u8` to variadic function
-  --> $DIR/variadic-ffi-1.rs:31:19
+  --> $DIR/variadic-ffi-1.rs:33:19
    |
 LL |         foo(1, 2, 1u8);
    |                   ^^^
@@ -103,7 +103,7 @@ LL |         foo(1, 2, 1u8 as c_uint);
    |                       +++++++++
 
 error[E0617]: can't pass `i16` to variadic function
-  --> $DIR/variadic-ffi-1.rs:32:19
+  --> $DIR/variadic-ffi-1.rs:34:19
    |
 LL |         foo(1, 2, 1i16);
    |                   ^^^^
@@ -114,7 +114,7 @@ LL |         foo(1, 2, 1i16 as c_int);
    |                        ++++++++
 
 error[E0617]: can't pass `u16` to variadic function
-  --> $DIR/variadic-ffi-1.rs:33:19
+  --> $DIR/variadic-ffi-1.rs:35:19
    |
 LL |         foo(1, 2, 1u16);
    |                   ^^^^
diff --git a/tests/ui/check-cfg/my-awesome-platform.json b/tests/ui/check-cfg/my-awesome-platform.json
index 5e9ab8f1a2d0..03b08b727bd3 100644
--- a/tests/ui/check-cfg/my-awesome-platform.json
+++ b/tests/ui/check-cfg/my-awesome-platform.json
@@ -1,6 +1,6 @@
 {
     "llvm-target": "x86_64-unknown-none-gnu",
-    "data-layout": "e-m:e-i64:64-f80:128-n8:16:32:64-S128",
+    "data-layout": "e-m:e-p270:32:32-p271:32:32-p272:64:64-i64:64-i128:128-f80:128-n8:16:32:64-S128",
     "arch": "x86_64",
     "target-endian": "little",
     "target-pointer-width": "64",
diff --git a/tests/ui/check-cfg/target_feature.stderr b/tests/ui/check-cfg/target_feature.stderr
index 51808c5c7bcd..8675f7a61c79 100644
--- a/tests/ui/check-cfg/target_feature.stderr
+++ b/tests/ui/check-cfg/target_feature.stderr
@@ -290,9 +290,14 @@ LL |     cfg!(target_feature = "_UNEXPECTED_VALUE");
 `xsavec`
 `xsaveopt`
 `xsaves`
+`za128rs`
+`za64rs`
 `zaamo`
 `zabha`
+`zacas`
 `zalrsc`
+`zama16b`
+`zawrs`
 `zba`
 `zbb`
 `zbc`
diff --git a/tests/ui/check-cfg/values-target-json.rs b/tests/ui/check-cfg/values-target-json.rs
index b52decdf6c0c..d473f39c3d6a 100644
--- a/tests/ui/check-cfg/values-target-json.rs
+++ b/tests/ui/check-cfg/values-target-json.rs
@@ -1,5 +1,6 @@
 // This test checks that we don't lint values defined by a custom target (target json)
 //
+//@ add-core-stubs
 //@ check-pass
 //@ no-auto-check-cfg
 //@ needs-llvm-components: x86
@@ -8,8 +9,8 @@
 #![feature(lang_items, no_core, auto_traits)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[cfg(target_os = "linux")]
 fn target_os_linux() {}
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/callback-as-argument.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/callback-as-argument.rs
index 37c8319d98d0..b25a81b858be 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/callback-as-argument.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/callback-as-argument.rs
@@ -1,13 +1,12 @@
+//@ add-core-stubs
 //@ build-pass
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(abi_c_cmse_nonsecure_call, cmse_nonsecure_entry, no_core, lang_items, intrinsics)]
 #![no_core]
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for u32 {}
+
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub extern "C-cmse-nonsecure-entry" fn test(
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
index 31782b05105f..18041b080617 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.rs
@@ -1,12 +1,11 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(abi_c_cmse_nonsecure_call, no_core, lang_items)]
 #![no_core]
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for u32 {}
+
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 struct Wrapper<T>(T);
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
index 0560f0eec1c0..ab7c9cee4f03 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/generics.stderr
@@ -1,11 +1,11 @@
 error: function pointer types may not have generic parameters
-  --> $DIR/generics.rs:15:42
+  --> $DIR/generics.rs:14:42
    |
 LL |     f1: extern "C-cmse-nonsecure-call" fn<U: Copy>(U, u32, u32, u32) -> u64,
    |                                          ^^^^^^^^^
 
 error[E0412]: cannot find type `U` in this scope
-  --> $DIR/generics.rs:15:52
+  --> $DIR/generics.rs:14:52
    |
 LL | struct Test<T: Copy> {
    |             - similarly named type parameter `T` defined here
@@ -23,7 +23,7 @@ LL | struct Test<T: Copy, U> {
    |                    +++
 
 error[E0562]: `impl Trait` is not allowed in `fn` pointer parameters
-  --> $DIR/generics.rs:18:43
+  --> $DIR/generics.rs:17:43
    |
 LL |     f2: extern "C-cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
    |                                           ^^^^^^^^^
@@ -31,19 +31,19 @@ LL |     f2: extern "C-cmse-nonsecure-call" fn(impl Copy, u32, u32, u32) -> u64,
    = note: `impl Trait` is only allowed in arguments and return types of functions and methods
 
 error[E0798]: function pointers with the `"C-cmse-nonsecure-call"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:20:9
+  --> $DIR/generics.rs:19:9
    |
 LL |     f3: extern "C-cmse-nonsecure-call" fn(T, u32, u32, u32) -> u64,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: function pointers with the `"C-cmse-nonsecure-call"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:21:9
+  --> $DIR/generics.rs:20:9
    |
 LL |     f4: extern "C-cmse-nonsecure-call" fn(Wrapper<T>, u32, u32, u32) -> u64,
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:27:73
+  --> $DIR/generics.rs:26:73
    |
 LL | type WithTraitObject = extern "C-cmse-nonsecure-call" fn(&dyn Trait) -> &dyn Trait;
    |                                                                         ^^^^^^^^^^ this type doesn't fit in the available registers
@@ -52,7 +52,7 @@ LL | type WithTraitObject = extern "C-cmse-nonsecure-call" fn(&dyn Trait) -> &dy
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:31:62
+  --> $DIR/generics.rs:30:62
    |
 LL |     extern "C-cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn Trait;
    |                                                              ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -61,7 +61,7 @@ LL |     extern "C-cmse-nonsecure-call" fn(&'static dyn Trait) -> &'static dyn T
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/generics.rs:38:62
+  --> $DIR/generics.rs:37:62
    |
 LL |     extern "C-cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTransparent;
    |                                                              ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -70,7 +70,7 @@ LL |     extern "C-cmse-nonsecure-call" fn(WrapperTransparent) -> WrapperTranspa
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0045]: C-variadic function must have a compatible calling convention, like `C`, `cdecl`, `system`, `aapcs`, `win64`, `sysv64` or `efiapi`
-  --> $DIR/generics.rs:41:20
+  --> $DIR/generics.rs:40:20
    |
 LL | type WithVarArgs = extern "C-cmse-nonsecure-call" fn(u32, ...);
    |                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ C-variadic function must have a compatible calling convention
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.rs
index 083a563bd7ba..8328f9b6dd55 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.rs
@@ -1,12 +1,11 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(abi_c_cmse_nonsecure_call, no_core, lang_items)]
 #![no_core]
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for u32 {}
+
+extern crate minicore;
+use minicore::*;
 
 #[repr(C, align(16))]
 #[allow(unused)]
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
index a5f5e1c3151d..10a5e8561075 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/params-via-stack.stderr
@@ -1,5 +1,5 @@
 error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:17:63
+  --> $DIR/params-via-stack.rs:16:63
    |
 LL |     f1: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u32),
    |                                                               ^^^^^^^^^^^^^^ these arguments don't fit in the available registers
@@ -7,7 +7,7 @@ LL |     f1: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u32, x: u32, y: u3
    = note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:18:63
+  --> $DIR/params-via-stack.rs:17:63
    |
 LL |     f2: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u16, u16),
    |                                                               ^^^ this argument doesn't fit in the available registers
@@ -15,7 +15,7 @@ LL |     f2: extern "C-cmse-nonsecure-call" fn(u32, u32, u32, u16, u16),
    = note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:19:53
+  --> $DIR/params-via-stack.rs:18:53
    |
 LL |     f3: extern "C-cmse-nonsecure-call" fn(u32, u64, u32),
    |                                                     ^^^ this argument doesn't fit in the available registers
@@ -23,7 +23,7 @@ LL |     f3: extern "C-cmse-nonsecure-call" fn(u32, u64, u32),
    = note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:20:58
+  --> $DIR/params-via-stack.rs:19:58
    |
 LL |     f4: extern "C-cmse-nonsecure-call" fn(AlignRelevant, u32),
    |                                                          ^^^ this argument doesn't fit in the available registers
@@ -31,7 +31,7 @@ LL |     f4: extern "C-cmse-nonsecure-call" fn(AlignRelevant, u32),
    = note: functions with the `"C-cmse-nonsecure-call"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:21:43
+  --> $DIR/params-via-stack.rs:20:43
    |
 LL |     f5: extern "C-cmse-nonsecure-call" fn([u32; 5]),
    |                                           ^^^^^^^^ this argument doesn't fit in the available registers
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.rs
index b052aabb499e..890ec4b00f6a 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 //@ add-core-stubs
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr
index 89f7f159d6e4..d2077352900a 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/return-via-stack.stderr
@@ -1,5 +1,5 @@
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:35:50
+  --> $DIR/return-via-stack.rs:36:50
    |
 LL |     u128: extern "C-cmse-nonsecure-call" fn() -> u128,
    |                                                  ^^^^ this type doesn't fit in the available registers
@@ -8,7 +8,7 @@ LL |     u128: extern "C-cmse-nonsecure-call" fn() -> u128,
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:36:50
+  --> $DIR/return-via-stack.rs:37:50
    |
 LL |     i128: extern "C-cmse-nonsecure-call" fn() -> i128,
    |                                                  ^^^^ this type doesn't fit in the available registers
@@ -17,7 +17,7 @@ LL |     i128: extern "C-cmse-nonsecure-call" fn() -> i128,
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:25:48
+  --> $DIR/return-via-stack.rs:26:48
    |
 LL |     f1: extern "C-cmse-nonsecure-call" fn() -> ReprCU64,
    |                                                ^^^^^^^^ this type doesn't fit in the available registers
@@ -26,7 +26,7 @@ LL |     f1: extern "C-cmse-nonsecure-call" fn() -> ReprCU64,
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:26:48
+  --> $DIR/return-via-stack.rs:27:48
    |
 LL |     f2: extern "C-cmse-nonsecure-call" fn() -> ReprCBytes,
    |                                                ^^^^^^^^^^ this type doesn't fit in the available registers
@@ -35,7 +35,7 @@ LL |     f2: extern "C-cmse-nonsecure-call" fn() -> ReprCBytes,
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:27:48
+  --> $DIR/return-via-stack.rs:28:48
    |
 LL |     f3: extern "C-cmse-nonsecure-call" fn() -> U64Compound,
    |                                                ^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -44,7 +44,7 @@ LL |     f3: extern "C-cmse-nonsecure-call" fn() -> U64Compound,
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:28:48
+  --> $DIR/return-via-stack.rs:29:48
    |
 LL |     f4: extern "C-cmse-nonsecure-call" fn() -> ReprCAlign16,
    |                                                ^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -53,7 +53,7 @@ LL |     f4: extern "C-cmse-nonsecure-call" fn() -> ReprCAlign16,
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:29:48
+  --> $DIR/return-via-stack.rs:30:48
    |
 LL |     f5: extern "C-cmse-nonsecure-call" fn() -> [u8; 5],
    |                                                ^^^^^^^ this type doesn't fit in the available registers
@@ -62,7 +62,7 @@ LL |     f5: extern "C-cmse-nonsecure-call" fn() -> [u8; 5],
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:51:48
+  --> $DIR/return-via-stack.rs:52:48
    |
 LL |     f1: extern "C-cmse-nonsecure-call" fn() -> ReprRustUnionU64,
    |                                                ^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -71,7 +71,7 @@ LL |     f1: extern "C-cmse-nonsecure-call" fn() -> ReprRustUnionU64,
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-call"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:52:48
+  --> $DIR/return-via-stack.rs:53:48
    |
 LL |     f2: extern "C-cmse-nonsecure-call" fn() -> ReprCUnionU64,
    |                                                ^^^^^^^^^^^^^ this type doesn't fit in the available registers
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/via-registers.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/via-registers.rs
index 9fda55c2a480..7dfe6cf9672a 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/via-registers.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/via-registers.rs
@@ -1,13 +1,12 @@
+//@ add-core-stubs
 //@ build-pass
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(abi_c_cmse_nonsecure_call, no_core, lang_items, intrinsics)]
 #![no_core]
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for u32 {}
+
+extern crate minicore;
+use minicore::*;
 
 #[repr(transparent)]
 pub struct ReprTransparentStruct<T> {
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.rs
index 3265cf4146dc..5a2d2db19c54 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.rs
@@ -1,8 +1,10 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(abi_c_cmse_nonsecure_call, lang_items, no_core)]
 #![no_core]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 pub extern "C-cmse-nonsecure-call" fn test() {} //~ ERROR [E0781]
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr
index 8d1b10eaeb5b..f49fab043a47 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-1.stderr
@@ -1,5 +1,5 @@
 error[E0781]: the `"C-cmse-nonsecure-call"` ABI is only allowed on function pointers
-  --> $DIR/wrong-abi-location-1.rs:8:1
+  --> $DIR/wrong-abi-location-1.rs:10:1
    |
 LL | pub extern "C-cmse-nonsecure-call" fn test() {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.rs
index b47471c6ad7c..e93b153949a3 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.rs
@@ -1,9 +1,11 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(abi_c_cmse_nonsecure_call, lang_items, no_core)]
 #![no_core]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 extern "C-cmse-nonsecure-call" { //~ ERROR [E0781]
     fn test();
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr
index 917098e21d82..bae8d20d81c5 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-call/wrong-abi-location-2.stderr
@@ -1,5 +1,5 @@
 error[E0781]: the `"C-cmse-nonsecure-call"` ABI is only allowed on function pointers
-  --> $DIR/wrong-abi-location-2.rs:8:1
+  --> $DIR/wrong-abi-location-2.rs:10:1
    |
 LL | / extern "C-cmse-nonsecure-call" {
 LL | |     fn test();
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
index a264bba6f3cd..19b6179dde75 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.rs
@@ -1,12 +1,11 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(cmse_nonsecure_entry, c_variadic, no_core, lang_items)]
 #![no_core]
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-impl Copy for u32 {}
+
+extern crate minicore;
+use minicore::*;
 
 #[repr(C)]
 struct Wrapper<T>(T);
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
index 9e67f881f75c..c314671dc297 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/generics.stderr
@@ -1,11 +1,11 @@
 error: only foreign, `unsafe extern "C"`, or `unsafe extern "C-unwind"` functions may have a C-variadic arg
-  --> $DIR/generics.rs:74:55
+  --> $DIR/generics.rs:73:55
    |
 LL | extern "C-cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
    |                                                       ^^^^^^
 
 error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:31:1
+  --> $DIR/generics.rs:30:1
    |
 LL | / extern "C-cmse-nonsecure-entry" fn introduced_generic<U: Copy>(
 LL | |
@@ -17,19 +17,19 @@ LL | | ) -> u64 {
    | |________^
 
 error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:41:1
+  --> $DIR/generics.rs:40:1
    |
 LL | extern "C-cmse-nonsecure-entry" fn impl_trait(_: impl Copy, _: u32, _: u32, _: u32) -> u64 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:15:5
+  --> $DIR/generics.rs:14:5
    |
 LL |     extern "C-cmse-nonsecure-entry" fn ambient_generic(_: T, _: u32, _: u32, _: u32) -> u64 {
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0798]: functions with the `"C-cmse-nonsecure-entry"` ABI cannot contain generics in their type
-  --> $DIR/generics.rs:20:5
+  --> $DIR/generics.rs:19:5
    |
 LL | /     extern "C-cmse-nonsecure-entry" fn ambient_generic_nested(
 LL | |
@@ -41,7 +41,7 @@ LL | |     ) -> u64 {
    | |____________^
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:52:67
+  --> $DIR/generics.rs:51:67
    |
 LL | extern "C-cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trait {
    |                                                                   ^^^^^^^^^^ this type doesn't fit in the available registers
@@ -50,7 +50,7 @@ LL | extern "C-cmse-nonsecure-entry" fn trait_object(x: &dyn Trait) -> &dyn Trai
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:59:6
+  --> $DIR/generics.rs:58:6
    |
 LL | ) -> &'static dyn Trait {
    |      ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -59,7 +59,7 @@ LL | ) -> &'static dyn Trait {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/generics.rs:69:6
+  --> $DIR/generics.rs:68:6
    |
 LL | ) -> WrapperTransparent {
    |      ^^^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -68,7 +68,7 @@ LL | ) -> WrapperTransparent {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error: requires `va_list` lang_item
-  --> $DIR/generics.rs:74:55
+  --> $DIR/generics.rs:73:55
    |
 LL | extern "C-cmse-nonsecure-entry" fn c_variadic(_: u32, _: ...) {
    |                                                       ^^^^^^
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.rs
index 572d792d5a5d..4c53f9422dab 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.rs
@@ -1,12 +1,11 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(cmse_nonsecure_entry, no_core, lang_items)]
 #![no_core]
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for u32 {}
+
+extern crate minicore;
+use minicore::*;
 
 #[repr(C, align(16))]
 #[allow(unused)]
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
index b77e64c6bfba..24e9ddf32feb 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/params-via-stack.stderr
@@ -1,5 +1,5 @@
 error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:16:78
+  --> $DIR/params-via-stack.rs:15:78
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _: u32, _: u32) {}
    |                                                                              ^^^^^^^^^^^ these arguments don't fit in the available registers
@@ -7,7 +7,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f1(_: u32, _: u32, _: u32, _: u32, _
    = note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:18:78
+  --> $DIR/params-via-stack.rs:17:78
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f2(_: u32, _: u32, _: u32, _: u16, _: u16) {}
    |                                                                              ^^^ this argument doesn't fit in the available registers
@@ -15,7 +15,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f2(_: u32, _: u32, _: u32, _: u16, _
    = note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:20:62
+  --> $DIR/params-via-stack.rs:19:62
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f3(_: u32, _: u64, _: u32) {}
    |                                                              ^^^ this argument doesn't fit in the available registers
@@ -23,7 +23,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f3(_: u32, _: u64, _: u32) {}
    = note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:22:64
+  --> $DIR/params-via-stack.rs:21:64
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {}
    |                                                                ^^^ this argument doesn't fit in the available registers
@@ -31,7 +31,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f4(_: AlignRelevant, _: u32) {}
    = note: functions with the `"C-cmse-nonsecure-entry"` ABI must pass all their arguments via the 4 32-bit available argument registers
 
 error[E0798]: arguments for `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/params-via-stack.rs:26:46
+  --> $DIR/params-via-stack.rs:25:46
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f5(_: [u32; 5]) {}
    |                                              ^^^^^^^^ this argument doesn't fit in the available registers
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.rs
index 23d55526e578..735eab10fa15 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 //@ add-core-stubs
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.stderr
index d37d9b5e8ff7..9c885d953181 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/return-via-stack.stderr
@@ -1,5 +1,5 @@
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:24:48
+  --> $DIR/return-via-stack.rs:25:48
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f1() -> ReprCU64 {
    |                                                ^^^^^^^^ this type doesn't fit in the available registers
@@ -8,7 +8,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f1() -> ReprCU64 {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:29:48
+  --> $DIR/return-via-stack.rs:30:48
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f2() -> ReprCBytes {
    |                                                ^^^^^^^^^^ this type doesn't fit in the available registers
@@ -17,7 +17,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f2() -> ReprCBytes {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:34:48
+  --> $DIR/return-via-stack.rs:35:48
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f3() -> U64Compound {
    |                                                ^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -26,7 +26,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f3() -> U64Compound {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:39:48
+  --> $DIR/return-via-stack.rs:40:48
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f4() -> ReprCAlign16 {
    |                                                ^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -35,7 +35,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f4() -> ReprCAlign16 {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:46:48
+  --> $DIR/return-via-stack.rs:47:48
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn f5() -> [u8; 5] {
    |                                                ^^^^^^^ this type doesn't fit in the available registers
@@ -44,7 +44,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn f5() -> [u8; 5] {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:52:50
+  --> $DIR/return-via-stack.rs:53:50
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn u128() -> u128 {
    |                                                  ^^^^ this type doesn't fit in the available registers
@@ -53,7 +53,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn u128() -> u128 {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:58:50
+  --> $DIR/return-via-stack.rs:59:50
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn i128() -> i128 {
    |                                                  ^^^^ this type doesn't fit in the available registers
@@ -62,7 +62,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn i128() -> i128 {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:75:56
+  --> $DIR/return-via-stack.rs:76:56
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn union_rust() -> ReprRustUnionU64 {
    |                                                        ^^^^^^^^^^^^^^^^ this type doesn't fit in the available registers
@@ -71,7 +71,7 @@ LL | pub extern "C-cmse-nonsecure-entry" fn union_rust() -> ReprRustUnionU64 {
    = note: the result must either be a (transparently wrapped) i64, u64 or f64, or be at most 4 bytes in size
 
 error[E0798]: return value of `"C-cmse-nonsecure-entry"` function too large to pass via registers
-  --> $DIR/return-via-stack.rs:80:53
+  --> $DIR/return-via-stack.rs:81:53
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn union_c() -> ReprCUnionU64 {
    |                                                     ^^^^^^^^^^^^^ this type doesn't fit in the available registers
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.aarch64.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.aarch64.stderr
index 26409279fbeb..6a90dc8d635b 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.aarch64.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.aarch64.stderr
@@ -1,5 +1,5 @@
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/trustzone-only.rs:20:1
+  --> $DIR/trustzone-only.rs:17:1
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.rs
index a4ea7a1757d2..6d84dab2166e 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: x86 aarch64 thumb7
 //
 //@[x86] compile-flags: --target x86_64-unknown-linux-gnu
@@ -9,12 +10,8 @@
 #![feature(no_core, lang_items, rustc_attrs, cmse_nonsecure_entry)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-
-impl Copy for u32 {}
+extern crate minicore;
+use minicore::*;
 
 #[no_mangle]
 pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.thumb7.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.thumb7.stderr
index 26409279fbeb..6a90dc8d635b 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.thumb7.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.thumb7.stderr
@@ -1,5 +1,5 @@
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/trustzone-only.rs:20:1
+  --> $DIR/trustzone-only.rs:17:1
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.x86.stderr b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.x86.stderr
index 26409279fbeb..6a90dc8d635b 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.x86.stderr
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/trustzone-only.x86.stderr
@@ -1,5 +1,5 @@
 error[E0570]: `"C-cmse-nonsecure-entry"` is not a supported ABI for the current target
-  --> $DIR/trustzone-only.rs:20:1
+  --> $DIR/trustzone-only.rs:17:1
    |
 LL | pub extern "C-cmse-nonsecure-entry" fn entry_function(input: u32) -> u32 {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/via-registers.rs b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/via-registers.rs
index 8978b35d356f..912fc8b85ebd 100644
--- a/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/via-registers.rs
+++ b/tests/ui/cmse-nonsecure/cmse-nonsecure-entry/via-registers.rs
@@ -1,15 +1,13 @@
+//@ add-core-stubs
 //@ build-pass
 //@ compile-flags: --target thumbv8m.main-none-eabi --crate-type lib
 //@ needs-llvm-components: arm
 #![feature(cmse_nonsecure_entry, no_core, lang_items)]
 #![no_core]
 #![crate_type = "lib"]
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for u32 {}
-impl Copy for u8 {}
+
+extern crate minicore;
+use minicore::*;
 
 #[repr(transparent)]
 pub struct ReprTransparentStruct<T> {
diff --git a/tests/ui/coercion/issue-26905.stderr b/tests/ui/coercion/issue-26905.stderr
index 86f6a14cd105..17387ae992b4 100644
--- a/tests/ui/coercion/issue-26905.stderr
+++ b/tests/ui/coercion/issue-26905.stderr
@@ -1,11 +1,16 @@
-error[E0375]: implementing the trait `CoerceUnsized` requires multiple coercions
+error[E0375]: implementing `CoerceUnsized` does not allow multiple fields to be coerced
   --> $DIR/issue-26905.rs:16:40
    |
 LL | impl<T: ?Sized + Unsize<U>, U: ?Sized> CoerceUnsized<MyRc<U>> for MyRc<T>{ }
-   |                                        ^^^^^^^^^^^^^^^^^^^^^^ requires multiple coercions
+   |                                        ^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced
-   = note: currently, 2 fields need coercions: `_ptr` (`*const T` to `*const U`), `_boo` (`NotPhantomData<T>` to `NotPhantomData<U>`)
+note: the trait `CoerceUnsized` may only be implemented when a single field is being coerced
+  --> $DIR/issue-26905.rs:12:5
+   |
+LL |     _ptr: *const T,
+   |     ^^^^^^^^^^^^^^
+LL |     _boo: NotPhantomData<T>,
+   |     ^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/coherence/coherence-unsafe-trait-object-impl.rs b/tests/ui/coherence/coherence-unsafe-trait-object-impl.rs
deleted file mode 100644
index 16baf0958a67..000000000000
--- a/tests/ui/coherence/coherence-unsafe-trait-object-impl.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Check that unsafe trait object do not implement themselves
-// automatically
-
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Trait: Sized {
-    fn call(&self);
-}
-
-fn takes_t<S: Trait>(s: S) {
-    s.call();
-}
-
-fn takes_t_obj(t: &dyn Trait) {
-    takes_t(t); //~ ERROR E0277
-}
-
-fn main() {}
diff --git a/tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr b/tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr
deleted file mode 100644
index 4f898ec127b9..000000000000
--- a/tests/ui/coherence/coherence-unsafe-trait-object-impl.stderr
+++ /dev/null
@@ -1,22 +0,0 @@
-error[E0277]: the trait bound `&dyn Trait: Trait` is not satisfied
-  --> $DIR/coherence-unsafe-trait-object-impl.rs:15:13
-   |
-LL |     takes_t(t);
-   |     ------- ^ the trait `Trait` is not implemented for `&dyn Trait`
-   |     |
-   |     required by a bound introduced by this call
-   |
-help: this trait has no implementations, consider adding one
-  --> $DIR/coherence-unsafe-trait-object-impl.rs:6:1
-   |
-LL | trait Trait: Sized {
-   | ^^^^^^^^^^^^^^^^^^
-note: required by a bound in `takes_t`
-  --> $DIR/coherence-unsafe-trait-object-impl.rs:10:15
-   |
-LL | fn takes_t<S: Trait>(s: S) {
-   |               ^^^^^ required by this bound in `takes_t`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/coherence/const-errs-dont-conflict-103369.rs b/tests/ui/coherence/const-errs-dont-conflict-103369.rs
index c7d46a8000d4..14937e0f02ec 100644
--- a/tests/ui/coherence/const-errs-dont-conflict-103369.rs
+++ b/tests/ui/coherence/const-errs-dont-conflict-103369.rs
@@ -2,13 +2,12 @@
 
 pub trait ConstGenericTrait<const N: u32> {}
 
-impl ConstGenericTrait<{my_fn(1)}> for () {}
+impl ConstGenericTrait<{my_fn(1)}> for () {} //~ ERROR E0080
 
-impl ConstGenericTrait<{my_fn(2)}> for () {}
+impl ConstGenericTrait<{my_fn(2)}> for () {} //~ ERROR E0080
 
 const fn my_fn(v: u32) -> u32 {
-    panic!("Some error occurred"); //~ ERROR E0080
-    //~| ERROR E0080
+    panic!("Some error occurred");
 }
 
 fn main() {}
diff --git a/tests/ui/coherence/const-errs-dont-conflict-103369.stderr b/tests/ui/coherence/const-errs-dont-conflict-103369.stderr
index 22066d6b6bde..4acaaf22ae8f 100644
--- a/tests/ui/coherence/const-errs-dont-conflict-103369.stderr
+++ b/tests/ui/coherence/const-errs-dont-conflict-103369.stderr
@@ -1,37 +1,27 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/const-errs-dont-conflict-103369.rs:10:5
-   |
-LL |     panic!("Some error occurred");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'Some error occurred', $DIR/const-errs-dont-conflict-103369.rs:10:5
-   |
-note: inside `my_fn`
-  --> $DIR/const-errs-dont-conflict-103369.rs:10:5
-   |
-LL |     panic!("Some error occurred");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `<() as ConstGenericTrait<{my_fn(1)}>>::{constant#0}`
   --> $DIR/const-errs-dont-conflict-103369.rs:5:25
    |
 LL | impl ConstGenericTrait<{my_fn(1)}> for () {}
-   |                         ^^^^^^^^
-   = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
-
-error[E0080]: evaluation of constant value failed
-  --> $DIR/const-errs-dont-conflict-103369.rs:10:5
-   |
-LL |     panic!("Some error occurred");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'Some error occurred', $DIR/const-errs-dont-conflict-103369.rs:10:5
+   |                         ^^^^^^^^ evaluation panicked: Some error occurred
    |
 note: inside `my_fn`
   --> $DIR/const-errs-dont-conflict-103369.rs:10:5
    |
 LL |     panic!("Some error occurred");
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `<() as ConstGenericTrait<{my_fn(2)}>>::{constant#0}`
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
+   = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/const-errs-dont-conflict-103369.rs:7:25
    |
 LL | impl ConstGenericTrait<{my_fn(2)}> for () {}
-   |                         ^^^^^^^^
+   |                         ^^^^^^^^ evaluation panicked: Some error occurred
+   |
+note: inside `my_fn`
+  --> $DIR/const-errs-dont-conflict-103369.rs:10:5
+   |
+LL |     panic!("Some error occurred");
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
index d88528124920..9a041557c7cc 100644
--- a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
+++ b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.rs
@@ -28,8 +28,8 @@ struct S9;
 macro_rules! generate_s10 {
     ($expr: expr) => {
         #[cfg(feature = $expr)]
-        //~^ ERROR expected unsuffixed literal, found `concat!("nonexistent")`
-        //~| ERROR expected unsuffixed literal, found `concat!("nonexistent")`
+        //~^ ERROR expected unsuffixed literal, found expression `concat!("nonexistent")`
+        //~| ERROR expected unsuffixed literal, found expression `concat!("nonexistent")`
         struct S10;
     }
 }
diff --git a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
index 3dd0823389cd..21a3712d9391 100644
--- a/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
+++ b/tests/ui/conditional-compilation/cfg-attr-syntax-validation.stderr
@@ -54,7 +54,7 @@ LL | #[cfg(a = b"hi")]
    |           |
    |           help: consider removing the prefix
 
-error: expected unsuffixed literal, found `concat!("nonexistent")`
+error: expected unsuffixed literal, found expression `concat!("nonexistent")`
   --> $DIR/cfg-attr-syntax-validation.rs:30:25
    |
 LL |         #[cfg(feature = $expr)]
@@ -65,7 +65,7 @@ LL | generate_s10!(concat!("nonexistent"));
    |
    = note: this error originates in the macro `generate_s10` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: expected unsuffixed literal, found `concat!("nonexistent")`
+error: expected unsuffixed literal, found expression `concat!("nonexistent")`
   --> $DIR/cfg-attr-syntax-validation.rs:30:25
    |
 LL |         #[cfg(feature = $expr)]
diff --git a/tests/ui/const-generics/const-param-type-depends-on-const-param.full.stderr b/tests/ui/const-generics/const-param-type-depends-on-const-param.full.stderr
index 539d840f0a80..f639e276f466 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-const-param.full.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-const-param.full.stderr
@@ -3,16 +3,12 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | pub struct Dependent<const N: usize, const X: [u8; N]>([(); N]);
    |                                                    ^ the type must not depend on the parameter `N`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error[E0770]: the type of const parameters must not depend on other generic parameters
   --> $DIR/const-param-type-depends-on-const-param.rs:15:40
    |
 LL | pub struct SelfDependent<const N: [u8; N]>;
    |                                        ^ the type must not depend on the parameter `N`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/const-param-type-depends-on-const-param.min.stderr b/tests/ui/const-generics/const-param-type-depends-on-const-param.min.stderr
index 18b899632678..44fcf9a13b12 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-const-param.min.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-const-param.min.stderr
@@ -3,16 +3,12 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | pub struct Dependent<const N: usize, const X: [u8; N]>([(); N]);
    |                                                    ^ the type must not depend on the parameter `N`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error[E0770]: the type of const parameters must not depend on other generic parameters
   --> $DIR/const-param-type-depends-on-const-param.rs:15:40
    |
 LL | pub struct SelfDependent<const N: [u8; N]>;
    |                                        ^ the type must not depend on the parameter `N`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error: `[u8; N]` is forbidden as the type of a const generic parameter
   --> $DIR/const-param-type-depends-on-const-param.rs:11:47
diff --git a/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr b/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
index 55bced29aff1..3075597895b0 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-type-param-ungated.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | struct B<T, const N: T>(PhantomData<[T; N]>);
    |                      ^ the type must not depend on the parameter `T`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr b/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr
index 49cf42813235..e8257ace692f 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-type-param.full.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | pub struct Dependent<T, const X: T>([(); X]);
    |                                  ^ the type must not depend on the parameter `T`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error[E0392]: type parameter `T` is never used
   --> $DIR/const-param-type-depends-on-type-param.rs:11:22
diff --git a/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr b/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr
index 49cf42813235..e8257ace692f 100644
--- a/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr
+++ b/tests/ui/const-generics/const-param-type-depends-on-type-param.min.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | pub struct Dependent<T, const X: T>([(); X]);
    |                                  ^ the type must not depend on the parameter `T`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error[E0392]: type parameter `T` is never used
   --> $DIR/const-param-type-depends-on-type-param.rs:11:22
diff --git a/tests/ui/const-generics/generic_const_parameter_types/bad_inference.rs b/tests/ui/const-generics/generic_const_parameter_types/bad_inference.rs
new file mode 100644
index 000000000000..de2e687e870c
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/bad_inference.rs
@@ -0,0 +1,23 @@
+#![feature(
+    adt_const_params,
+    unsized_const_params,
+    generic_const_parameter_types,
+    generic_arg_infer
+)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy_;
+
+fn foo<T: ConstParamTy_, const N: usize, const M: [T; N]>() -> [T; N] {
+    loop {}
+}
+
+fn main() {
+    // Requires inferring `T`/`N` from `12_u8` and `2` respectively.
+    let a = foo::<_, _, { [12_u8; 2] }>();
+    //~^ ERROR: anonymous constants with inferred types are not yet supported
+
+    // Requires inferring `T`/`N`/`12_?i`/`_` from `[u8; 2]`
+    let b: [u8; 2] = foo::<_, _, { [12; _] }>();
+    //~^ ERROR: anonymous constants with inferred types are not yet supported
+}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/bad_inference.stderr b/tests/ui/const-generics/generic_const_parameter_types/bad_inference.stderr
new file mode 100644
index 000000000000..1ac67fe622b5
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/bad_inference.stderr
@@ -0,0 +1,14 @@
+error: anonymous constants with inferred types are not yet supported
+  --> $DIR/bad_inference.rs:17:25
+   |
+LL |     let a = foo::<_, _, { [12_u8; 2] }>();
+   |                         ^^^^^^^^^^^^^^
+
+error: anonymous constants with inferred types are not yet supported
+  --> $DIR/bad_inference.rs:21:34
+   |
+LL |     let b: [u8; 2] = foo::<_, _, { [12; _] }>();
+   |                                  ^^^^^^^^^^^
+
+error: aborting due to 2 previous errors
+
diff --git a/tests/ui/const-generics/generic_const_parameter_types/evaluate_const_parameter_in_mir.rs b/tests/ui/const-generics/generic_const_parameter_types/evaluate_const_parameter_in_mir.rs
new file mode 100644
index 000000000000..910deb6632d7
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/evaluate_const_parameter_in_mir.rs
@@ -0,0 +1,19 @@
+//@ check-pass
+
+#![feature(
+    adt_const_params,
+    unsized_const_params,
+    generic_const_parameter_types,
+    generic_arg_infer
+)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy_;
+
+fn foo<T: ConstParamTy_, const N: usize, const M: [T; N]>() -> [T; N] {
+    M
+}
+
+fn main() {
+    let a: [u8; 2] = foo::<u8, 2, { [12; _] }>();
+}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/forward_declared_type.rs b/tests/ui/const-generics/generic_const_parameter_types/forward_declared_type.rs
new file mode 100644
index 000000000000..91c1c80e07c8
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/forward_declared_type.rs
@@ -0,0 +1,11 @@
+#![feature(adt_const_params, generic_const_parameter_types)]
+#![expect(incomplete_features)]
+
+use std::marker::PhantomData;
+
+struct UsesConst<const N: [u8; M], const M: usize>;
+//~^ ERROR: the type of const parameters must not depend on other generic parameters
+struct UsesType<const N: [T; 2], T>(PhantomData<T>);
+//~^ ERROR: the type of const parameters must not depend on other generic parameters
+
+fn main() {}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/forward_declared_type.stderr b/tests/ui/const-generics/generic_const_parameter_types/forward_declared_type.stderr
new file mode 100644
index 000000000000..b0dbdff84136
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/forward_declared_type.stderr
@@ -0,0 +1,15 @@
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/forward_declared_type.rs:6:32
+   |
+LL | struct UsesConst<const N: [u8; M], const M: usize>;
+   |                                ^ the type must not depend on the parameter `M`
+
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/forward_declared_type.rs:8:27
+   |
+LL | struct UsesType<const N: [T; 2], T>(PhantomData<T>);
+   |                           ^ the type must not depend on the parameter `T`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/const-generics/generic_const_parameter_types/inferred_from_arg.rs b/tests/ui/const-generics/generic_const_parameter_types/inferred_from_arg.rs
new file mode 100644
index 000000000000..d655fc174ee5
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/inferred_from_arg.rs
@@ -0,0 +1,13 @@
+//@ check-pass
+
+#![feature(adt_const_params, generic_arg_infer, generic_const_parameter_types)]
+#![expect(incomplete_features)]
+
+struct Bar<const N: usize, const M: [u8; N]>;
+
+fn foo<const N: usize, const M: [u8; N]>(_: Bar<N, M>) {}
+
+fn main() {
+    foo(Bar::<2, { [1; 2] }>);
+    foo::<_, _>(Bar::<2, { [1; 2] }>);
+}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/lifetime_dependent_const_param.rs b/tests/ui/const-generics/generic_const_parameter_types/lifetime_dependent_const_param.rs
new file mode 100644
index 000000000000..6b81ca743aa7
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/lifetime_dependent_const_param.rs
@@ -0,0 +1,20 @@
+#![feature(generic_const_parameter_types, adt_const_params, unsized_const_params)]
+#![expect(incomplete_features)]
+
+fn foo<'a, const N: &'a u32>() {}
+
+fn bar() {
+    foo::<'static, { &1_u32 }>();
+    //~^ ERROR: anonymous constants with lifetimes in their type are not yet supported
+    foo::<'_, { &1_u32 }>();
+    //~^ ERROR: anonymous constants with lifetimes in their type are not yet supported
+}
+
+fn borrowck<'a, const N: &'static u32, const M: &'a u32>() {
+    foo::<'a, M>();
+    foo::<'static, M>();
+    //~^ ERROR: lifetime may not live long enough
+    foo::<'static, N>();
+}
+
+fn main() {}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/lifetime_dependent_const_param.stderr b/tests/ui/const-generics/generic_const_parameter_types/lifetime_dependent_const_param.stderr
new file mode 100644
index 000000000000..be5f27bcbc0b
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/lifetime_dependent_const_param.stderr
@@ -0,0 +1,23 @@
+error: anonymous constants with lifetimes in their type are not yet supported
+  --> $DIR/lifetime_dependent_const_param.rs:7:20
+   |
+LL |     foo::<'static, { &1_u32 }>();
+   |                    ^^^^^^^^^^
+
+error: anonymous constants with lifetimes in their type are not yet supported
+  --> $DIR/lifetime_dependent_const_param.rs:9:15
+   |
+LL |     foo::<'_, { &1_u32 }>();
+   |               ^^^^^^^^^^
+
+error: lifetime may not live long enough
+  --> $DIR/lifetime_dependent_const_param.rs:15:5
+   |
+LL | fn borrowck<'a, const N: &'static u32, const M: &'a u32>() {
+   |             -- lifetime `'a` defined here
+LL |     foo::<'a, M>();
+LL |     foo::<'static, M>();
+   |     ^^^^^^^^^^^^^^^^^ requires that `'a` must outlive `'static`
+
+error: aborting due to 3 previous errors
+
diff --git a/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.rs b/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.rs
new file mode 100644
index 000000000000..df8a057b335a
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.rs
@@ -0,0 +1,15 @@
+#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy_;
+
+fn foo<const N: usize, const M: [u8; N]>() {}
+fn bar<T: ConstParamTy_, const M: [T; 2]>() {}
+
+fn main() {
+    foo::<3, { [1; 2] }>();
+    //~^ ERROR: mismatched type
+
+    bar::<u8, { [2_u16; 2] }>();
+    //~^ ERROR: mismatched type
+}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.stderr b/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.stderr
new file mode 100644
index 000000000000..2411d31b9801
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/mismatched_args_with_value.stderr
@@ -0,0 +1,21 @@
+error[E0308]: mismatched types
+  --> $DIR/mismatched_args_with_value.rs:10:16
+   |
+LL |     foo::<3, { [1; 2] }>();
+   |                ^^^^^^ expected an array with a size of 3, found one with a size of 2
+
+error[E0308]: mismatched types
+  --> $DIR/mismatched_args_with_value.rs:13:18
+   |
+LL |     bar::<u8, { [2_u16; 2] }>();
+   |                  ^^^^^ expected `u8`, found `u16`
+   |
+help: change the type of the numeric literal from `u16` to `u8`
+   |
+LL -     bar::<u8, { [2_u16; 2] }>();
+LL +     bar::<u8, { [2_u8; 2] }>();
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.rs b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.rs
new file mode 100644
index 000000000000..1a5ab46cda19
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.rs
@@ -0,0 +1,9 @@
+#![feature(adt_const_params, unsized_const_params, generic_const_parameter_types)]
+#![expect(incomplete_features)]
+
+use std::marker::{ConstParamTy_, PhantomData};
+
+struct UsesType<T, const N: usize, const M: [T; N]>(PhantomData<T>);
+//~^ ERROR: `[T; N]` can't be used as a const parameter type
+
+fn main() {}
diff --git a/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.stderr b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.stderr
new file mode 100644
index 000000000000..4ea323f4a5c8
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/no_const_param_ty_bound.stderr
@@ -0,0 +1,11 @@
+error[E0741]: `[T; N]` can't be used as a const parameter type
+  --> $DIR/no_const_param_ty_bound.rs:6:45
+   |
+LL | struct UsesType<T, const N: usize, const M: [T; N]>(PhantomData<T>);
+   |                                             ^^^^^^
+   |
+   = note: `T` must implement `UnsizedConstParamTy`, but it does not
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0741`.
diff --git a/tests/ui/const-generics/generic_const_parameter_types/unrelated_inferred_arg.rs b/tests/ui/const-generics/generic_const_parameter_types/unrelated_inferred_arg.rs
new file mode 100644
index 000000000000..b389e12884ea
--- /dev/null
+++ b/tests/ui/const-generics/generic_const_parameter_types/unrelated_inferred_arg.rs
@@ -0,0 +1,21 @@
+//@ check-pass
+
+#![feature(
+    adt_const_params,
+    unsized_const_params,
+    generic_const_parameter_types,
+    generic_arg_infer
+)]
+#![allow(incomplete_features)]
+
+use std::marker::ConstParamTy_;
+
+fn foo<U, T: ConstParamTy_, const N: usize, const M: [T; N]>(_: U) -> [T; N] {
+    loop {}
+}
+
+fn main() {
+    // Check that `_` doesnt cause a "Type of const argument is uninferred" error
+    // as it is not actually used by the type of `M`.
+    let a = foo::<_, u8, 2, { [12; _] }>(true);
+}
diff --git a/tests/ui/const-generics/issues/cg-in-dyn-issue-128176.rs b/tests/ui/const-generics/issues/cg-in-dyn-issue-128176.rs
index 5a67d34d6e5a..dac5429f678e 100644
--- a/tests/ui/const-generics/issues/cg-in-dyn-issue-128176.rs
+++ b/tests/ui/const-generics/issues/cg-in-dyn-issue-128176.rs
@@ -1,10 +1,7 @@
-//@ check-pass
-
 // Regression test for #128176. Previously we would call `type_of` on the `1` anon const
 // before the anon const had been lowered and had the `type_of` fed with a result.
 
 #![feature(generic_const_exprs)]
-#![feature(dyn_compatible_for_dispatch)]
 #![allow(incomplete_features)]
 
 trait X {
@@ -13,6 +10,7 @@ trait X {
 
 const _: () = {
     fn f2<'a>(arg: Box<dyn X<Y<1> = &'a ()>>) {}
+    //~^ ERROR the trait `X` is not dyn compatible
 };
 
 fn main() {}
diff --git a/tests/ui/const-generics/issues/cg-in-dyn-issue-128176.stderr b/tests/ui/const-generics/issues/cg-in-dyn-issue-128176.stderr
new file mode 100644
index 000000000000..7d563e3b6054
--- /dev/null
+++ b/tests/ui/const-generics/issues/cg-in-dyn-issue-128176.stderr
@@ -0,0 +1,19 @@
+error[E0038]: the trait `X` is not dyn compatible
+  --> $DIR/cg-in-dyn-issue-128176.rs:12:24
+   |
+LL |     fn f2<'a>(arg: Box<dyn X<Y<1> = &'a ()>>) {}
+   |                        ^^^^^^^^^^^^^^^^^^^^ `X` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/cg-in-dyn-issue-128176.rs:8:10
+   |
+LL | trait X {
+   |       - this trait is not dyn compatible...
+LL |     type Y<const N: i16>;
+   |          ^ ...because it contains the generic associated type `Y`
+   = help: consider moving `Y` to another trait
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/const-generics/issues/issue-100313.rs b/tests/ui/const-generics/issues/issue-100313.rs
index 553165f90b88..7ce2a3b908c5 100644
--- a/tests/ui/const-generics/issues/issue-100313.rs
+++ b/tests/ui/const-generics/issues/issue-100313.rs
@@ -6,15 +6,14 @@ struct T<const B: &'static bool>;
 impl<const B: &'static bool> T<B> {
     const fn set_false(&self) {
         unsafe {
-            *(B as *const bool as *mut bool) = false;
-            //~^ ERROR evaluation of constant value failed [E0080]
+            *(B as *const bool as *mut bool) = false; //~ inside `T
         }
     }
 }
 
 const _: () = {
     let x = T::<{ &true }>;
-    x.set_false();
+    x.set_false(); //~ ERROR evaluation of constant value failed [E0080]
 };
 
 fn main() {}
diff --git a/tests/ui/const-generics/issues/issue-100313.stderr b/tests/ui/const-generics/issues/issue-100313.stderr
index 6e419078e5ee..03a658a83aff 100644
--- a/tests/ui/const-generics/issues/issue-100313.stderr
+++ b/tests/ui/const-generics/issues/issue-100313.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/issue-100313.rs:9:13
+  --> $DIR/issue-100313.rs:16:5
    |
-LL |             *(B as *const bool as *mut bool) = false;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ writing to ALLOC0 which is read-only
+LL |     x.set_false();
+   |     ^^^^^^^^^^^^^ writing to ALLOC0 which is read-only
    |
 note: inside `T::<&true>::set_false`
   --> $DIR/issue-100313.rs:9:13
    |
 LL |             *(B as *const bool as *mut bool) = false;
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `_`
-  --> $DIR/issue-100313.rs:17:5
-   |
-LL |     x.set_false();
-   |     ^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-56445-1.full.stderr b/tests/ui/const-generics/issues/issue-56445-1.full.stderr
index 86eb57355bd6..392a125de67a 100644
--- a/tests/ui/const-generics/issues/issue-56445-1.full.stderr
+++ b/tests/ui/const-generics/issues/issue-56445-1.full.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | struct Bug<'a, const S: &'a str>(PhantomData<&'a ()>);
    |                          ^^ the type must not depend on the parameter `'a`
-   |
-   = note: lifetime parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-56445-1.min.stderr b/tests/ui/const-generics/issues/issue-56445-1.min.stderr
index 86eb57355bd6..392a125de67a 100644
--- a/tests/ui/const-generics/issues/issue-56445-1.min.stderr
+++ b/tests/ui/const-generics/issues/issue-56445-1.min.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | struct Bug<'a, const S: &'a str>(PhantomData<&'a ()>);
    |                          ^^ the type must not depend on the parameter `'a`
-   |
-   = note: lifetime parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-62878.full.stderr b/tests/ui/const-generics/issues/issue-62878.full.stderr
index 615bfeb65a51..5e6b3ad9f4c4 100644
--- a/tests/ui/const-generics/issues/issue-62878.full.stderr
+++ b/tests/ui/const-generics/issues/issue-62878.full.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | fn foo<const N: usize, const A: [u8; N]>() {}
    |                                      ^ the type must not depend on the parameter `N`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-62878.min.stderr b/tests/ui/const-generics/issues/issue-62878.min.stderr
index 1bb111b188df..d3d4fa438710 100644
--- a/tests/ui/const-generics/issues/issue-62878.min.stderr
+++ b/tests/ui/const-generics/issues/issue-62878.min.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | fn foo<const N: usize, const A: [u8; N]>() {}
    |                                      ^ the type must not depend on the parameter `N`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error: `[u8; N]` is forbidden as the type of a const generic parameter
   --> $DIR/issue-62878.rs:5:33
diff --git a/tests/ui/const-generics/issues/issue-71169.full.stderr b/tests/ui/const-generics/issues/issue-71169.full.stderr
index 9553be6fc07c..f600ecdab74a 100644
--- a/tests/ui/const-generics/issues/issue-71169.full.stderr
+++ b/tests/ui/const-generics/issues/issue-71169.full.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | fn foo<const LEN: usize, const DATA: [u8; LEN]>() {}
    |                                           ^^^ the type must not depend on the parameter `LEN`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-71169.min.stderr b/tests/ui/const-generics/issues/issue-71169.min.stderr
index 2ecbc3379516..c04a710eee9c 100644
--- a/tests/ui/const-generics/issues/issue-71169.min.stderr
+++ b/tests/ui/const-generics/issues/issue-71169.min.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | fn foo<const LEN: usize, const DATA: [u8; LEN]>() {}
    |                                           ^^^ the type must not depend on the parameter `LEN`
-   |
-   = note: const parameters may not be used in the type of const parameters
 
 error: `[u8; LEN]` is forbidden as the type of a const generic parameter
   --> $DIR/issue-71169.rs:5:38
diff --git a/tests/ui/const-generics/issues/issue-71381.full.stderr b/tests/ui/const-generics/issues/issue-71381.full.stderr
index b6460e0017fa..01bbe55415d4 100644
--- a/tests/ui/const-generics/issues/issue-71381.full.stderr
+++ b/tests/ui/const-generics/issues/issue-71381.full.stderr
@@ -3,16 +3,12 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL |     pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern "C" fn(Args)>(&self) {
    |                                                                                  ^^^^ the type must not depend on the parameter `Args`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error[E0770]: the type of const parameters must not depend on other generic parameters
   --> $DIR/issue-71381.rs:23:40
    |
 LL |         const FN: unsafe extern "C" fn(Args),
    |                                        ^^^^ the type must not depend on the parameter `Args`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/issues/issue-71381.min.stderr b/tests/ui/const-generics/issues/issue-71381.min.stderr
index 38d2cbe63683..2b0a671bc3fa 100644
--- a/tests/ui/const-generics/issues/issue-71381.min.stderr
+++ b/tests/ui/const-generics/issues/issue-71381.min.stderr
@@ -3,16 +3,12 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL |     pub fn call_me<Args: Sized, const IDX: usize, const FN: unsafe extern "C" fn(Args)>(&self) {
    |                                                                                  ^^^^ the type must not depend on the parameter `Args`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error[E0770]: the type of const parameters must not depend on other generic parameters
   --> $DIR/issue-71381.rs:23:40
    |
 LL |         const FN: unsafe extern "C" fn(Args),
    |                                        ^^^^ the type must not depend on the parameter `Args`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: using function pointers as const generic parameters is forbidden
   --> $DIR/issue-71381.rs:14:61
diff --git a/tests/ui/const-generics/issues/issue-71611.full.stderr b/tests/ui/const-generics/issues/issue-71611.full.stderr
index 6f6a9fc21a69..e115630b64e3 100644
--- a/tests/ui/const-generics/issues/issue-71611.full.stderr
+++ b/tests/ui/const-generics/issues/issue-71611.full.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | fn func<A, const F: fn(inner: A)>(outer: A) {
    |                               ^ the type must not depend on the parameter `A`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-generics/issues/issue-71611.min.stderr b/tests/ui/const-generics/issues/issue-71611.min.stderr
index 7252bfd1d6a7..b2e2e5cb445c 100644
--- a/tests/ui/const-generics/issues/issue-71611.min.stderr
+++ b/tests/ui/const-generics/issues/issue-71611.min.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | fn func<A, const F: fn(inner: A)>(outer: A) {
    |                               ^ the type must not depend on the parameter `A`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: using function pointers as const generic parameters is forbidden
   --> $DIR/issue-71611.rs:5:21
diff --git a/tests/ui/const-generics/issues/issue-88119.stderr b/tests/ui/const-generics/issues/issue-88119.stderr
index c497f1b6d0bd..94f06bbbbc45 100644
--- a/tests/ui/const-generics/issues/issue-88119.stderr
+++ b/tests/ui/const-generics/issues/issue-88119.stderr
@@ -6,30 +6,90 @@ LL | #![feature(const_trait_impl, generic_const_exprs)]
    |
    = help: remove one of these features
 
-error[E0284]: type annotations needed: cannot satisfy `the constant `name_len::<T>()` can be evaluated`
+error[E0275]: overflow evaluating the requirement `&T: ~const ConstName`
+  --> $DIR/issue-88119.rs:19:49
+   |
+LL | impl<T: ?Sized + ConstName> const ConstName for &T
+   |                                                 ^^
+
+error[E0275]: overflow evaluating the requirement `&T: ConstName`
+  --> $DIR/issue-88119.rs:19:49
+   |
+LL | impl<T: ?Sized + ConstName> const ConstName for &T
+   |                                                 ^^
+
+error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
   --> $DIR/issue-88119.rs:21:5
    |
 LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^ cannot satisfy `the constant `name_len::<T>()` can be evaluated`
+   |     ^^^^^^^^^^^^^^^^^^^^^
    |
 note: required by a bound in `<&T as ConstName>`
+  --> $DIR/issue-88119.rs:21:5
+   |
+LL |     [(); name_len::<T>()]:,
+   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&T as ConstName>`
+
+error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
   --> $DIR/issue-88119.rs:21:10
    |
 LL |     [(); name_len::<T>()]:,
-   |          ^^^^^^^^^^^^^^^ required by this bound in `<&T as ConstName>`
+   |          ^^^^^^^^^^^^^^^
+   |
+note: required by a bound in `<&T as ConstName>`
+  --> $DIR/issue-88119.rs:21:5
+   |
+LL |     [(); name_len::<T>()]:,
+   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&T as ConstName>`
 
-error[E0284]: type annotations needed: cannot satisfy `the constant `name_len::<T>()` can be evaluated`
+error[E0275]: overflow evaluating the requirement `&mut T: ~const ConstName`
+  --> $DIR/issue-88119.rs:26:49
+   |
+LL | impl<T: ?Sized + ConstName> const ConstName for &mut T
+   |                                                 ^^^^^^
+
+error[E0275]: overflow evaluating the requirement `&mut T: ConstName`
+  --> $DIR/issue-88119.rs:26:49
+   |
+LL | impl<T: ?Sized + ConstName> const ConstName for &mut T
+   |                                                 ^^^^^^
+
+error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
   --> $DIR/issue-88119.rs:28:5
    |
 LL |     [(); name_len::<T>()]:,
-   |     ^^^^^^^^^^^^^^^^^^^^^ cannot satisfy `the constant `name_len::<T>()` can be evaluated`
+   |     ^^^^^^^^^^^^^^^^^^^^^
    |
 note: required by a bound in `<&mut T as ConstName>`
+  --> $DIR/issue-88119.rs:28:5
+   |
+LL |     [(); name_len::<T>()]:,
+   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&mut T as ConstName>`
+
+error[E0275]: overflow evaluating the requirement `[(); name_len::<T>()] well-formed`
   --> $DIR/issue-88119.rs:28:10
    |
 LL |     [(); name_len::<T>()]:,
-   |          ^^^^^^^^^^^^^^^ required by this bound in `<&mut T as ConstName>`
+   |          ^^^^^^^^^^^^^^^
+   |
+note: required by a bound in `<&mut T as ConstName>`
+  --> $DIR/issue-88119.rs:28:5
+   |
+LL |     [(); name_len::<T>()]:,
+   |     ^^^^^^^^^^^^^^^^^^^^^ required by this bound in `<&mut T as ConstName>`
 
-error: aborting due to 3 previous errors
+error[E0275]: overflow evaluating the requirement `&&mut u8: ConstName`
+  --> $DIR/issue-88119.rs:33:35
+   |
+LL | pub const ICE_1: &'static [u8] = <&&mut u8 as ConstName>::NAME_BYTES;
+   |                                   ^^^^^^^^
 
-For more information about this error, try `rustc --explain E0284`.
+error[E0275]: overflow evaluating the requirement `&mut &u8: ConstName`
+  --> $DIR/issue-88119.rs:34:35
+   |
+LL | pub const ICE_2: &'static [u8] = <&mut &u8 as ConstName>::NAME_BYTES;
+   |                                   ^^^^^^^^
+
+error: aborting due to 11 previous errors
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/const-generics/issues/issue-88997.stderr b/tests/ui/const-generics/issues/issue-88997.stderr
index b49d52dd0bab..505ba0da2321 100644
--- a/tests/ui/const-generics/issues/issue-88997.stderr
+++ b/tests/ui/const-generics/issues/issue-88997.stderr
@@ -3,16 +3,12 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | struct Range<T: PartialOrd, const MIN: T, const MAX: T>(T)
    |                                        ^ the type must not depend on the parameter `T`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error[E0770]: the type of const parameters must not depend on other generic parameters
   --> $DIR/issue-88997.rs:8:54
    |
 LL | struct Range<T: PartialOrd, const MIN: T, const MAX: T>(T)
    |                                                      ^ the type must not depend on the parameter `T`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/const-generics/issues/issue-90364.stderr b/tests/ui/const-generics/issues/issue-90364.stderr
index 6c00a654cde7..384ce5da3e20 100644
--- a/tests/ui/const-generics/issues/issue-90364.stderr
+++ b/tests/ui/const-generics/issues/issue-90364.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | pub struct Foo<T, const H: T>(T)
    |                            ^ the type must not depend on the parameter `T`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/const-ptr/forbidden_slices.rs b/tests/ui/const-ptr/forbidden_slices.rs
index 59ea92c5ab38..001cfd66ad14 100644
--- a/tests/ui/const-ptr/forbidden_slices.rs
+++ b/tests/ui/const-ptr/forbidden_slices.rs
@@ -48,9 +48,11 @@ pub static S8: &[u64] = unsafe {
 pub static R0: &[u32] = unsafe { from_ptr_range(ptr::null()..ptr::null()) };
 //~^ ERROR it is undefined behavior to use this value
 pub static R1: &[()] = unsafe { from_ptr_range(ptr::null()..ptr::null()) }; // errors inside libcore
+//~^ ERROR could not evaluate static initializer
 pub static R2: &[u32] = unsafe {
     let ptr = &D0 as *const u32;
     from_ptr_range(ptr..ptr.add(2)) // errors inside libcore
+    //~^ ERROR could not evaluate static initializer
 };
 pub static R4: &[u8] = unsafe {
     //~^ ERROR: it is undefined behavior to use this value
@@ -74,13 +76,16 @@ pub static R7: &[u16] = unsafe {
 };
 pub static R8: &[u64] = unsafe {
     let ptr = (&D4 as *const [u32; 2] as *const u32).byte_add(1).cast::<u64>();
-    from_ptr_range(ptr..ptr.add(1)) //~ inside `R8`
+    from_ptr_range(ptr..ptr.add(1))
+    //~^ ERROR could not evaluate static initializer
 };
 
 // This is sneaky: &D0 and &D0 point to different objects
 // (even if at runtime they have the same address)
 pub static R9: &[u32] = unsafe { from_ptr_range(&D0..(&D0 as *const u32).add(1)) };
+//~^ ERROR could not evaluate static initializer
 pub static R10: &[u32] = unsafe { from_ptr_range(&D0..&D0) };
+//~^ ERROR could not evaluate static initializer
 
 const D0: u32 = 0x11111111; // Constant chosen for endianness-independent behavior.
 const D1: MaybeUninit<&u32> = MaybeUninit::uninit();
diff --git a/tests/ui/const-ptr/forbidden_slices.stderr b/tests/ui/const-ptr/forbidden_slices.stderr
index df588fcc5e10..a4e9c972cebb 100644
--- a/tests/ui/const-ptr/forbidden_slices.stderr
+++ b/tests/ui/const-ptr/forbidden_slices.stderr
@@ -100,36 +100,28 @@ LL | pub static R0: &[u32] = unsafe { from_ptr_range(ptr::null()..ptr::null()) }
            }
 
 error[E0080]: could not evaluate static initializer
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'assertion failed: 0 < pointee_size && pointee_size <= isize::MAX as usize', $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-note: inside `std::ptr::const_ptr::<impl *const ()>::offset_from_unsigned`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `from_ptr_range::<'_, ()>`
-  --> $SRC_DIR/core/src/slice/raw.rs:LL:COL
-note: inside `R1`
   --> $DIR/forbidden_slices.rs:50:33
    |
 LL | pub static R1: &[()] = unsafe { from_ptr_range(ptr::null()..ptr::null()) }; // errors inside libcore
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: assertion failed: 0 < pointee_size && pointee_size <= isize::MAX as usize
+   |
+note: inside `from_ptr_range::<'_, ()>`
+  --> $SRC_DIR/core/src/slice/raw.rs:LL:COL
+note: inside `std::ptr::const_ptr::<impl *const ()>::offset_from_unsigned`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0080]: could not evaluate static initializer
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+  --> $DIR/forbidden_slices.rs:54:25
    |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to 8 bytes of memory, but got ALLOC10 which is only 4 bytes from the end of the allocation
+LL |     from_ptr_range(ptr..ptr.add(2)) // errors inside libcore
+   |                         ^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to 8 bytes of memory, but got ALLOC10 which is only 4 bytes from the end of the allocation
    |
 note: inside `std::ptr::const_ptr::<impl *const u32>::add`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `R2`
-  --> $DIR/forbidden_slices.rs:53:25
-   |
-LL |     from_ptr_range(ptr..ptr.add(2)) // errors inside libcore
-   |                         ^^^^^^^^^^
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/forbidden_slices.rs:55:1
+  --> $DIR/forbidden_slices.rs:57:1
    |
 LL | pub static R4: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>[0]: encountered uninitialized memory, but expected an integer
@@ -140,7 +132,7 @@ LL | pub static R4: &[u8] = unsafe {
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/forbidden_slices.rs:60:1
+  --> $DIR/forbidden_slices.rs:62:1
    |
 LL | pub static R5: &[u8] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>[0]: encountered a pointer, but expected an integer
@@ -153,7 +145,7 @@ LL | pub static R5: &[u8] = unsafe {
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/forbidden_slices.rs:65:1
+  --> $DIR/forbidden_slices.rs:67:1
    |
 LL | pub static R6: &[bool] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<deref>[0]: encountered 0x11, but expected a boolean
@@ -164,7 +156,7 @@ LL | pub static R6: &[bool] = unsafe {
            }
 
 error[E0080]: it is undefined behavior to use this value
-  --> $DIR/forbidden_slices.rs:70:1
+  --> $DIR/forbidden_slices.rs:72:1
    |
 LL | pub static R7: &[u16] = unsafe {
    | ^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered an unaligned reference (required 2 byte alignment but found 1)
@@ -175,47 +167,35 @@ LL | pub static R7: &[u16] = unsafe {
            }
 
 error[E0080]: could not evaluate static initializer
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+  --> $DIR/forbidden_slices.rs:79:25
    |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to 8 bytes of memory, but got ALLOC11+0x1 which is only 7 bytes from the end of the allocation
+LL |     from_ptr_range(ptr..ptr.add(1))
+   |                         ^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to 8 bytes of memory, but got ALLOC11+0x1 which is only 7 bytes from the end of the allocation
    |
 note: inside `std::ptr::const_ptr::<impl *const u64>::add`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `R8`
-  --> $DIR/forbidden_slices.rs:77:25
-   |
-LL |     from_ptr_range(ptr..ptr.add(1))
-   |                         ^^^^^^^^^^
 
 error[E0080]: could not evaluate static initializer
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: `ptr_offset_from_unsigned` called on two different pointers that are not both derived from the same allocation
-   |
-note: inside `std::ptr::const_ptr::<impl *const u32>::offset_from_unsigned`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `from_ptr_range::<'_, u32>`
-  --> $SRC_DIR/core/src/slice/raw.rs:LL:COL
-note: inside `R9`
-  --> $DIR/forbidden_slices.rs:82:34
+  --> $DIR/forbidden_slices.rs:85:34
    |
 LL | pub static R9: &[u32] = unsafe { from_ptr_range(&D0..(&D0 as *const u32).add(1)) };
-   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: could not evaluate static initializer
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+   |                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from_unsigned` called on two different pointers that are not both derived from the same allocation
    |
-   = note: `ptr_offset_from_unsigned` called on two different pointers that are not both derived from the same allocation
-   |
-note: inside `std::ptr::const_ptr::<impl *const u32>::offset_from_unsigned`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 note: inside `from_ptr_range::<'_, u32>`
   --> $SRC_DIR/core/src/slice/raw.rs:LL:COL
-note: inside `R10`
-  --> $DIR/forbidden_slices.rs:83:35
+note: inside `std::ptr::const_ptr::<impl *const u32>::offset_from_unsigned`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+
+error[E0080]: could not evaluate static initializer
+  --> $DIR/forbidden_slices.rs:87:35
    |
 LL | pub static R10: &[u32] = unsafe { from_ptr_range(&D0..&D0) };
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from_unsigned` called on two different pointers that are not both derived from the same allocation
+   |
+note: inside `from_ptr_range::<'_, u32>`
+  --> $SRC_DIR/core/src/slice/raw.rs:LL:COL
+note: inside `std::ptr::const_ptr::<impl *const u32>::offset_from_unsigned`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 
 error: aborting due to 18 previous errors
 
diff --git a/tests/ui/const-ptr/out_of_bounds_read.stderr b/tests/ui/const-ptr/out_of_bounds_read.stderr
index 7f354963eb1f..899e151c9b81 100644
--- a/tests/ui/const-ptr/out_of_bounds_read.stderr
+++ b/tests/ui/const-ptr/out_of_bounds_read.stderr
@@ -1,45 +1,33 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0+0x4 which is at or beyond the end of the allocation of size 4 bytes
-   |
-note: inside `std::ptr::read::<u32>`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `_READ`
   --> $DIR/out_of_bounds_read.rs:10:33
    |
 LL |     const _READ: u32 = unsafe { ptr::read(PAST_END_PTR) };
-   |                                 ^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0+0x4 which is at or beyond the end of the allocation of size 4 bytes
+   |                                 ^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0+0x4 which is at or beyond the end of the allocation of size 4 bytes
    |
 note: inside `std::ptr::read::<u32>`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::const_ptr::<impl *const u32>::read`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `_CONST_READ`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/out_of_bounds_read.rs:11:39
    |
 LL |     const _CONST_READ: u32 = unsafe { PAST_END_PTR.read() };
-   |                                       ^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0+0x4 which is at or beyond the end of the allocation of size 4 bytes
+   |                                       ^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0+0x4 which is at or beyond the end of the allocation of size 4 bytes
    |
+note: inside `std::ptr::const_ptr::<impl *const u32>::read`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 note: inside `std::ptr::read::<u32>`
   --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::mut_ptr::<impl *mut u32>::read`
-  --> $SRC_DIR/core/src/ptr/mut_ptr.rs:LL:COL
-note: inside `_MUT_READ`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/out_of_bounds_read.rs:12:37
    |
 LL |     const _MUT_READ: u32 = unsafe { (PAST_END_PTR as *mut u32).read() };
-   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ memory access failed: expected a pointer to 4 bytes of memory, but got ALLOC0+0x4 which is at or beyond the end of the allocation of size 4 bytes
+   |
+note: inside `std::ptr::mut_ptr::<impl *mut u32>::read`
+  --> $SRC_DIR/core/src/ptr/mut_ptr.rs:LL:COL
+note: inside `std::ptr::read::<u32>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/consts/assert-type-intrinsics.stderr b/tests/ui/consts/assert-type-intrinsics.stderr
index 66c4f0f9cd65..92c0610a2480 100644
--- a/tests/ui/consts/assert-type-intrinsics.stderr
+++ b/tests/ui/consts/assert-type-intrinsics.stderr
@@ -2,19 +2,19 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/assert-type-intrinsics.rs:11:9
    |
 LL |         MaybeUninit::<!>::uninit().assume_init();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'aborted execution: attempted to instantiate uninhabited type `!`', $DIR/assert-type-intrinsics.rs:11:36
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: aborted execution: attempted to instantiate uninhabited type `!`
 
 error[E0080]: evaluation of constant value failed
   --> $DIR/assert-type-intrinsics.rs:15:9
    |
 LL |         intrinsics::assert_mem_uninitialized_valid::<&'static i32>();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'aborted execution: attempted to leave type `&i32` uninitialized, which is invalid', $DIR/assert-type-intrinsics.rs:15:9
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: aborted execution: attempted to leave type `&i32` uninitialized, which is invalid
 
 error[E0080]: evaluation of constant value failed
   --> $DIR/assert-type-intrinsics.rs:19:9
    |
 LL |         intrinsics::assert_zero_valid::<&'static i32>();
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'aborted execution: attempted to zero-initialize type `&i32`, which is invalid', $DIR/assert-type-intrinsics.rs:19:9
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: aborted execution: attempted to zero-initialize type `&i32`, which is invalid
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/consts/const-eval/const_fn_ptr_fail2.rs b/tests/ui/consts/const-eval/const_fn_ptr_fail2.rs
index 87f8b52a650b..7db8c6e81ab5 100644
--- a/tests/ui/consts/const-eval/const_fn_ptr_fail2.rs
+++ b/tests/ui/consts/const-eval/const_fn_ptr_fail2.rs
@@ -7,12 +7,18 @@ const X: fn(usize) -> usize = double;
 
 const fn bar(x: fn(usize) -> usize, y: usize) -> usize {
     x(y)
-    //~^ ERROR evaluation of constant value failed
-    //~| ERROR evaluation of constant value failed
+    //~^ NOTE inside `bar`
+    //~| NOTE the failure occurred here
+    //~| NOTE inside `bar`
+    //~| NOTE the failure occurred here
 }
 
 const Y: usize = bar(X, 2); // FIXME: should fail to typeck someday
+//~^ ERROR evaluation of constant value failed
+//~| NOTE calling non-const function `double`
 const Z: usize = bar(double, 2); // FIXME: should fail to typeck someday
+//~^ ERROR evaluation of constant value failed
+//~| NOTE calling non-const function `double`
 
 fn main() {
     assert_eq!(Y, 4);
diff --git a/tests/ui/consts/const-eval/const_fn_ptr_fail2.stderr b/tests/ui/consts/const-eval/const_fn_ptr_fail2.stderr
index 0734f479f989..a4d2e26c3afb 100644
--- a/tests/ui/consts/const-eval/const_fn_ptr_fail2.stderr
+++ b/tests/ui/consts/const-eval/const_fn_ptr_fail2.stderr
@@ -1,36 +1,26 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/const_fn_ptr_fail2.rs:9:5
-   |
-LL |     x(y)
-   |     ^^^^ calling non-const function `double`
-   |
-note: inside `bar`
-  --> $DIR/const_fn_ptr_fail2.rs:9:5
-   |
-LL |     x(y)
-   |     ^^^^
-note: inside `Y`
-  --> $DIR/const_fn_ptr_fail2.rs:14:18
+  --> $DIR/const_fn_ptr_fail2.rs:16:18
    |
 LL | const Y: usize = bar(X, 2); // FIXME: should fail to typeck someday
-   |                  ^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $DIR/const_fn_ptr_fail2.rs:9:5
-   |
-LL |     x(y)
-   |     ^^^^ calling non-const function `double`
+   |                  ^^^^^^^^^ calling non-const function `double`
    |
 note: inside `bar`
   --> $DIR/const_fn_ptr_fail2.rs:9:5
    |
 LL |     x(y)
-   |     ^^^^
-note: inside `Z`
-  --> $DIR/const_fn_ptr_fail2.rs:15:18
+   |     ^^^^ the failure occurred here
+
+error[E0080]: evaluation of constant value failed
+  --> $DIR/const_fn_ptr_fail2.rs:19:18
    |
 LL | const Z: usize = bar(double, 2); // FIXME: should fail to typeck someday
-   |                  ^^^^^^^^^^^^^^
+   |                  ^^^^^^^^^^^^^^ calling non-const function `double`
+   |
+note: inside `bar`
+  --> $DIR/const_fn_ptr_fail2.rs:9:5
+   |
+LL |     x(y)
+   |     ^^^^ the failure occurred here
 
 warning: skipping const checks
    |
diff --git a/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr b/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr
index 5f4af25611f0..64e227c4f45c 100644
--- a/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr
+++ b/tests/ui/consts/const-eval/const_panic-normalize-tabs-115498.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic-normalize-tabs-115498.rs:3:17
    |
 LL | struct Bug([u8; panic!{"\t"}]);
-   |                 ^^^^^^^^^^^^ the evaluated program panicked at '    ', $DIR/const_panic-normalize-tabs-115498.rs:3:17
+   |                 ^^^^^^^^^^^^ evaluation panicked:     
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/const-eval/const_panic.stderr b/tests/ui/consts/const-eval/const_panic.stderr
index 0f7be46072df..0816b04faca0 100644
--- a/tests/ui/consts/const-eval/const_panic.stderr
+++ b/tests/ui/consts/const-eval/const_panic.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:6:15
    |
 LL | const Z: () = std::panic!("cheese");
-   |               ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic.rs:6:15
+   |               ^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: cheese
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `std::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -10,7 +10,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:9:16
    |
 LL | const Z2: () = std::panic!();
-   |                ^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic.rs:9:16
+   |                ^^^^^^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `std::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -18,7 +18,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:12:15
    |
 LL | const Y: () = std::unreachable!();
-   |               ^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:12:15
+   |               ^^^^^^^^^^^^^^^^^^^ evaluation panicked: internal error: entered unreachable code
    |
    = note: this error originates in the macro `$crate::panic::unreachable_2015` which comes from the expansion of the macro `std::unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -26,7 +26,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:15:15
    |
 LL | const X: () = std::unimplemented!();
-   |               ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic.rs:15:15
+   |               ^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: not implemented
    |
    = note: this error originates in the macro `std::unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -34,7 +34,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:18:15
    |
 LL | const W: () = std::panic!(MSG);
-   |               ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:18:15
+   |               ^^^^^^^^^^^^^^^^ evaluation panicked: hello
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `std::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -42,7 +42,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:21:16
    |
 LL | const W2: () = std::panic!("{}", MSG);
-   |                ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:21:16
+   |                ^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: hello
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `std::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -50,7 +50,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:24:20
    |
 LL | const Z_CORE: () = core::panic!("cheese");
-   |                    ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic.rs:24:20
+   |                    ^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: cheese
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `core::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -58,7 +58,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:27:21
    |
 LL | const Z2_CORE: () = core::panic!();
-   |                     ^^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic.rs:27:21
+   |                     ^^^^^^^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `core::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -66,7 +66,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:30:20
    |
 LL | const Y_CORE: () = core::unreachable!();
-   |                    ^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic.rs:30:20
+   |                    ^^^^^^^^^^^^^^^^^^^^ evaluation panicked: internal error: entered unreachable code
    |
    = note: this error originates in the macro `$crate::panic::unreachable_2015` which comes from the expansion of the macro `core::unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -74,7 +74,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:33:20
    |
 LL | const X_CORE: () = core::unimplemented!();
-   |                    ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic.rs:33:20
+   |                    ^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: not implemented
    |
    = note: this error originates in the macro `core::unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -82,7 +82,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:36:20
    |
 LL | const W_CORE: () = core::panic!(MSG);
-   |                    ^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:36:20
+   |                    ^^^^^^^^^^^^^^^^^ evaluation panicked: hello
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `core::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -90,7 +90,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic.rs:39:21
    |
 LL | const W2_CORE: () = core::panic!("{}", MSG);
-   |                     ^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic.rs:39:21
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: hello
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `core::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/const-eval/const_panic_2021.stderr b/tests/ui/consts/const-eval/const_panic_2021.stderr
index 192fa3a12c25..4faa2a1e4cfd 100644
--- a/tests/ui/consts/const-eval/const_panic_2021.stderr
+++ b/tests/ui/consts/const-eval/const_panic_2021.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:6:15
    |
 LL | const A: () = std::panic!("blåhaj");
-   |               ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'blåhaj', $DIR/const_panic_2021.rs:6:15
+   |               ^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: blåhaj
    |
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `std::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -10,7 +10,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:9:15
    |
 LL | const B: () = std::panic!();
-   |               ^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic_2021.rs:9:15
+   |               ^^^^^^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `std::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -18,7 +18,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:12:15
    |
 LL | const C: () = std::unreachable!();
-   |               ^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_2021.rs:12:15
+   |               ^^^^^^^^^^^^^^^^^^^ evaluation panicked: internal error: entered unreachable code
    |
    = note: this error originates in the macro `$crate::panic::unreachable_2021` which comes from the expansion of the macro `std::unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -26,7 +26,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:15:15
    |
 LL | const D: () = std::unimplemented!();
-   |               ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_2021.rs:15:15
+   |               ^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: not implemented
    |
    = note: this error originates in the macro `std::unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -34,7 +34,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:18:15
    |
 LL | const E: () = std::panic!("{}", MSG);
-   |               ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic_2021.rs:18:15
+   |               ^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: hello
    |
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `std::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -42,7 +42,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:21:20
    |
 LL | const A_CORE: () = core::panic!("shark");
-   |                    ^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'shark', $DIR/const_panic_2021.rs:21:20
+   |                    ^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: shark
    |
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `core::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -50,7 +50,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:24:20
    |
 LL | const B_CORE: () = core::panic!();
-   |                    ^^^^^^^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/const_panic_2021.rs:24:20
+   |                    ^^^^^^^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `core::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -58,7 +58,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:27:20
    |
 LL | const C_CORE: () = core::unreachable!();
-   |                    ^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_2021.rs:27:20
+   |                    ^^^^^^^^^^^^^^^^^^^^ evaluation panicked: internal error: entered unreachable code
    |
    = note: this error originates in the macro `$crate::panic::unreachable_2021` which comes from the expansion of the macro `core::unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -66,7 +66,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:30:20
    |
 LL | const D_CORE: () = core::unimplemented!();
-   |                    ^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_2021.rs:30:20
+   |                    ^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: not implemented
    |
    = note: this error originates in the macro `core::unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -74,7 +74,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_2021.rs:33:20
    |
 LL | const E_CORE: () = core::panic!("{}", MSG);
-   |                    ^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'hello', $DIR/const_panic_2021.rs:33:20
+   |                    ^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: hello
    |
    = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `core::panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/const-eval/const_panic_libcore_bin.stderr b/tests/ui/consts/const-eval/const_panic_libcore_bin.stderr
index df19ed4a8986..11e70c484990 100644
--- a/tests/ui/consts/const-eval/const_panic_libcore_bin.stderr
+++ b/tests/ui/consts/const-eval/const_panic_libcore_bin.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_libcore_bin.rs:8:15
    |
 LL | const Z: () = panic!("cheese");
-   |               ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'cheese', $DIR/const_panic_libcore_bin.rs:8:15
+   |               ^^^^^^^^^^^^^^^^ evaluation panicked: cheese
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -10,7 +10,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_libcore_bin.rs:11:15
    |
 LL | const Y: () = unreachable!();
-   |               ^^^^^^^^^^^^^^ the evaluated program panicked at 'internal error: entered unreachable code', $DIR/const_panic_libcore_bin.rs:11:15
+   |               ^^^^^^^^^^^^^^ evaluation panicked: internal error: entered unreachable code
    |
    = note: this error originates in the macro `$crate::panic::unreachable_2015` which comes from the expansion of the macro `unreachable` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -18,7 +18,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const_panic_libcore_bin.rs:14:15
    |
 LL | const X: () = unimplemented!();
-   |               ^^^^^^^^^^^^^^^^ the evaluated program panicked at 'not implemented', $DIR/const_panic_libcore_bin.rs:14:15
+   |               ^^^^^^^^^^^^^^^^ evaluation panicked: not implemented
    |
    = note: this error originates in the macro `unimplemented` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/const-eval/const_panic_track_caller.rs b/tests/ui/consts/const-eval/const_panic_track_caller.rs
index 9cf7a3ba7dc1..799a59d16ca2 100644
--- a/tests/ui/consts/const-eval/const_panic_track_caller.rs
+++ b/tests/ui/consts/const-eval/const_panic_track_caller.rs
@@ -12,11 +12,10 @@ const fn b() -> u32 {
 }
 
 const fn c() -> u32 {
-    b()
-    //~^ ERROR evaluation of constant value failed
-    //~| NOTE the evaluated program panicked
-    //~| NOTE inside
+    b() //~ NOTE inside `c`
+    //~^ NOTE the failure occurred here
 }
 
 const X: u32 = c();
-//~^ NOTE inside
+//~^ ERROR evaluation of constant value failed
+//~| NOTE hey
diff --git a/tests/ui/consts/const-eval/const_panic_track_caller.stderr b/tests/ui/consts/const-eval/const_panic_track_caller.stderr
index a7df82705b88..8736a8c9409d 100644
--- a/tests/ui/consts/const-eval/const_panic_track_caller.stderr
+++ b/tests/ui/consts/const-eval/const_panic_track_caller.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/const_panic_track_caller.rs:15:5
+  --> $DIR/const_panic_track_caller.rs:19:16
    |
-LL |     b()
-   |     ^^^ the evaluated program panicked at 'hey', $DIR/const_panic_track_caller.rs:15:5
+LL | const X: u32 = c();
+   |                ^^^ evaluation panicked: hey
    |
 note: inside `c`
   --> $DIR/const_panic_track_caller.rs:15:5
    |
 LL |     b()
-   |     ^^^
-note: inside `X`
-  --> $DIR/const_panic_track_caller.rs:21:16
-   |
-LL | const X: u32 = c();
-   |                ^^^
+   |     ^^^ the failure occurred here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.rs b/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.rs
index 9cf9360dcbd0..c1a544031c2a 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.rs
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.rs
@@ -2,11 +2,10 @@
 #![feature(const_heap)]
 use std::intrinsics;
 
-const FOO: i32 = foo();
+const FOO: i32 = foo(); //~ error: evaluation of constant value failed
 const fn foo() -> i32 {
     unsafe {
-        let _ = intrinsics::const_allocate(4, 3) as *mut i32;
-        //~^ error: evaluation of constant value failed
+        let _ = intrinsics::const_allocate(4, 3) as *mut i32; //~ inside `foo`
     }
     1
 }
diff --git a/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr b/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr
index 2fd7222da521..e1cb7a839961 100644
--- a/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr
+++ b/tests/ui/consts/const-eval/heap/alloc_intrinsic_errors.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/alloc_intrinsic_errors.rs:8:17
+  --> $DIR/alloc_intrinsic_errors.rs:5:18
    |
-LL |         let _ = intrinsics::const_allocate(4, 3) as *mut i32;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ invalid align passed to `const_allocate`: 3 is not a power of 2
+LL | const FOO: i32 = foo();
+   |                  ^^^^^ invalid align passed to `const_allocate`: 3 is not a power of 2
    |
 note: inside `foo`
   --> $DIR/alloc_intrinsic_errors.rs:8:17
    |
 LL |         let _ = intrinsics::const_allocate(4, 3) as *mut i32;
-   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `FOO`
-  --> $DIR/alloc_intrinsic_errors.rs:5:18
-   |
-LL | const FOO: i32 = foo();
-   |                  ^^^^^
+   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/panic-assoc-never-type.stderr b/tests/ui/consts/const-eval/panic-assoc-never-type.stderr
index eef39255927a..efdbbe5698f0 100644
--- a/tests/ui/consts/const-eval/panic-assoc-never-type.stderr
+++ b/tests/ui/consts/const-eval/panic-assoc-never-type.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/panic-assoc-never-type.rs:9:21
    |
 LL |     const VOID: ! = panic!();
-   |                     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/panic-assoc-never-type.rs:9:21
+   |                     ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/const-eval/panic-never-type.stderr b/tests/ui/consts/const-eval/panic-never-type.stderr
index d3ba3eefb1ab..30a320f8db2f 100644
--- a/tests/ui/consts/const-eval/panic-never-type.stderr
+++ b/tests/ui/consts/const-eval/panic-never-type.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/panic-never-type.rs:4:17
    |
 LL | const VOID: ! = panic!();
-   |                 ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/panic-never-type.rs:4:17
+   |                 ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/const-eval/parse_ints.rs b/tests/ui/consts/const-eval/parse_ints.rs
index cb9a3eb43129..309b7ee5d27a 100644
--- a/tests/ui/consts/const-eval/parse_ints.rs
+++ b/tests/ui/consts/const-eval/parse_ints.rs
@@ -2,7 +2,7 @@ const _OK: () = match i32::from_str_radix("-1234", 10) {
     Ok(x) => assert!(x == -1234),
     Err(_) => panic!(),
 };
-const _TOO_LOW: () = { u64::from_str_radix("12345ABCD", 1); };
-const _TOO_HIGH: () = { u64::from_str_radix("12345ABCD", 37); };
+const _TOO_LOW: () = { u64::from_str_radix("12345ABCD", 1); }; //~ ERROR evaluation of constant value failed
+const _TOO_HIGH: () = { u64::from_str_radix("12345ABCD", 37); }; //~ ERROR evaluation of constant value failed
 
 fn main () {}
diff --git a/tests/ui/consts/const-eval/parse_ints.stderr b/tests/ui/consts/const-eval/parse_ints.stderr
index 189d3c3958bb..7a855bb9e5cc 100644
--- a/tests/ui/consts/const-eval/parse_ints.stderr
+++ b/tests/ui/consts/const-eval/parse_ints.stderr
@@ -1,33 +1,25 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'from_ascii_radix: radix must lie in the range `[2, 36]`', $SRC_DIR/core/src/num/mod.rs:LL:COL
-   |
-note: inside `core::num::<impl u64>::from_ascii_radix`
-  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
-note: inside `core::num::<impl u64>::from_str_radix`
-  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
-note: inside `_TOO_LOW`
   --> $DIR/parse_ints.rs:5:24
    |
 LL | const _TOO_LOW: () = { u64::from_str_radix("12345ABCD", 1); };
-   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: from_ascii_radix: radix must lie in the range `[2, 36]`
+   |
+note: inside `core::num::<impl u64>::from_str_radix`
+  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
+note: inside `core::num::<impl u64>::from_ascii_radix`
+  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
    = note: this error originates in the macro `from_str_int_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'from_ascii_radix: radix must lie in the range `[2, 36]`', $SRC_DIR/core/src/num/mod.rs:LL:COL
-   |
-note: inside `core::num::<impl u64>::from_ascii_radix`
-  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
-note: inside `core::num::<impl u64>::from_str_radix`
-  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
-note: inside `_TOO_HIGH`
   --> $DIR/parse_ints.rs:6:25
    |
 LL | const _TOO_HIGH: () = { u64::from_str_radix("12345ABCD", 37); };
-   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: from_ascii_radix: radix must lie in the range `[2, 36]`
+   |
+note: inside `core::num::<impl u64>::from_str_radix`
+  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
+note: inside `core::num::<impl u64>::from_ascii_radix`
+  --> $SRC_DIR/core/src/num/mod.rs:LL:COL
    = note: this error originates in the macro `from_str_int_impl` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/consts/const-eval/raw-pointer-ub.rs b/tests/ui/consts/const-eval/raw-pointer-ub.rs
index 5724293f145f..478e93a910e0 100644
--- a/tests/ui/consts/const-eval/raw-pointer-ub.rs
+++ b/tests/ui/consts/const-eval/raw-pointer-ub.rs
@@ -17,7 +17,10 @@ const MISALIGNED_COPY: () = unsafe {
     let y = x.as_ptr().cast::<u32>();
     let mut z = 123;
     y.copy_to_nonoverlapping(&mut z, 1);
-    //~^NOTE
+    //~^ ERROR evaluation of constant value failed
+    //~| NOTE inside `std::ptr::const_ptr
+    //~| NOTE inside `copy_nonoverlapping::<u32>`
+    //~| NOTE accessing memory with alignment 1, but alignment 4 is required
     // The actual error points into the implementation of `copy_to_nonoverlapping`.
 };
 
diff --git a/tests/ui/consts/const-eval/raw-pointer-ub.stderr b/tests/ui/consts/const-eval/raw-pointer-ub.stderr
index c3360c8b3e21..4fff293b2eef 100644
--- a/tests/ui/consts/const-eval/raw-pointer-ub.stderr
+++ b/tests/ui/consts/const-eval/raw-pointer-ub.stderr
@@ -11,28 +11,24 @@ LL |     *ptr = 0;
    |     ^^^^^^^^ accessing memory based on pointer with alignment 1, but alignment 4 is required
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
-   |
-   = note: accessing memory with alignment 1, but alignment 4 is required
-   |
-note: inside `copy_nonoverlapping::<u32>`
-  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
-note: inside `std::ptr::const_ptr::<impl *const u32>::copy_to_nonoverlapping`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `MISALIGNED_COPY`
   --> $DIR/raw-pointer-ub.rs:19:5
    |
 LL |     y.copy_to_nonoverlapping(&mut z, 1);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ accessing memory with alignment 1, but alignment 4 is required
+   |
+note: inside `std::ptr::const_ptr::<impl *const u32>::copy_to_nonoverlapping`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+note: inside `copy_nonoverlapping::<u32>`
+  --> $SRC_DIR/core/src/intrinsics/mod.rs:LL:COL
 
 error[E0080]: evaluation of constant value failed
-  --> $DIR/raw-pointer-ub.rs:31:16
+  --> $DIR/raw-pointer-ub.rs:34:16
    |
 LL |     let _val = (*ptr).0;
    |                ^^^^^^^^ accessing memory based on pointer with alignment 4, but alignment 16 is required
 
 error[E0080]: evaluation of constant value failed
-  --> $DIR/raw-pointer-ub.rs:38:16
+  --> $DIR/raw-pointer-ub.rs:41:16
    |
 LL |     let _val = *ptr;
    |                ^^^^ memory access failed: expected a pointer to 8 bytes of memory, but got ALLOC0 which is only 4 bytes from the end of the allocation
diff --git a/tests/ui/consts/const-eval/simd/insert_extract.rs b/tests/ui/consts/const-eval/simd/insert_extract.rs
index e5873ea26e8d..fc97f9ec1418 100644
--- a/tests/ui/consts/const-eval/simd/insert_extract.rs
+++ b/tests/ui/consts/const-eval/simd/insert_extract.rs
@@ -1,28 +1,19 @@
 //@ run-pass
 #![feature(repr_simd)]
-#![feature(intrinsics, rustc_attrs)]
+#![feature(intrinsics, core_intrinsics, rustc_attrs)]
 #![feature(staged_api)]
 #![stable(feature = "foo", since = "1.3.37")]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_extract, simd_insert};
+
 // repr(simd) now only supports array types
-#[repr(simd)] struct i8x1([i8; 1]);
-#[repr(simd)] struct u16x2([u16; 2]);
-#[repr(simd)] struct f32x4([f32; 4]);
-
-#[stable(feature = "foo", since = "1.3.37")]
-#[rustc_const_stable(feature = "foo", since = "1.3.37")]
-#[rustc_intrinsic]
-const unsafe fn simd_insert<T, U>(_x: T, _idx: u32, _val: U) -> T {
-    unimplemented!()
-}
-
-#[stable(feature = "foo", since = "1.3.37")]
-#[rustc_const_stable(feature = "foo", since = "1.3.37")]
-#[rustc_intrinsic]
-const unsafe fn simd_extract<T, U>(_x: T, _idx: u32) -> U {
-    unimplemented!()
-}
+#[repr(simd)]
+struct i8x1([i8; 1]);
+#[repr(simd)]
+struct u16x2([u16; 2]);
+#[repr(simd)]
+struct f32x4([f32; 4]);
 
 fn main() {
     {
diff --git a/tests/ui/consts/const-eval/transmute-size-mismatch.rs b/tests/ui/consts/const-eval/transmute-size-mismatch.rs
index 2410baea28c3..8a7fd8257b00 100644
--- a/tests/ui/consts/const-eval/transmute-size-mismatch.rs
+++ b/tests/ui/consts/const-eval/transmute-size-mismatch.rs
@@ -10,15 +10,19 @@ const unsafe fn mir_transmute<T, U>(x: T) -> U {
     mir!{
         {
             RET = CastTransmute(x);
-            //~^ ERROR evaluation of constant value failed
-            //~| ERROR evaluation of constant value failed
+            //~^ NOTE inside `mir_transmute
+            //~| NOTE inside `mir_transmute
+            //~| NOTE the failure occurred here
+            //~| NOTE the failure occurred here
             Return()
         }
     }
 }
 
-const FROM_BIGGER: u16 = unsafe { mir_transmute(123_i32) };
+const FROM_BIGGER: u16 = unsafe { mir_transmute(123_i32) }; //~ ERROR evaluation of constant value failed
+//~^ NOTE transmuting from 4-byte type to 2-byte type: `i32` -> `u16`
 
-const FROM_SMALLER: u32 = unsafe { mir_transmute(123_i16) };
+const FROM_SMALLER: u32 = unsafe { mir_transmute(123_i16) }; //~ ERROR evaluation of constant value failed
+//~^ NOTE transmuting from 2-byte type to 4-byte type: `i16` -> `u32`
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/transmute-size-mismatch.stderr b/tests/ui/consts/const-eval/transmute-size-mismatch.stderr
index e051491d3430..888df16ec4ee 100644
--- a/tests/ui/consts/const-eval/transmute-size-mismatch.stderr
+++ b/tests/ui/consts/const-eval/transmute-size-mismatch.stderr
@@ -1,36 +1,26 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/transmute-size-mismatch.rs:12:13
+  --> $DIR/transmute-size-mismatch.rs:22:35
    |
-LL |             RET = CastTransmute(x);
-   |             ^^^^^^^^^^^^^^^^^^^^^^ transmuting from 4-byte type to 2-byte type: `i32` -> `u16`
+LL | const FROM_BIGGER: u16 = unsafe { mir_transmute(123_i32) };
+   |                                   ^^^^^^^^^^^^^^^^^^^^^^ transmuting from 4-byte type to 2-byte type: `i32` -> `u16`
    |
 note: inside `mir_transmute::<i32, u16>`
   --> $DIR/transmute-size-mismatch.rs:12:13
    |
 LL |             RET = CastTransmute(x);
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-note: inside `FROM_BIGGER`
-  --> $DIR/transmute-size-mismatch.rs:20:35
-   |
-LL | const FROM_BIGGER: u16 = unsafe { mir_transmute(123_i32) };
-   |                                   ^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
 
 error[E0080]: evaluation of constant value failed
-  --> $DIR/transmute-size-mismatch.rs:12:13
+  --> $DIR/transmute-size-mismatch.rs:25:36
    |
-LL |             RET = CastTransmute(x);
-   |             ^^^^^^^^^^^^^^^^^^^^^^ transmuting from 2-byte type to 4-byte type: `i16` -> `u32`
+LL | const FROM_SMALLER: u32 = unsafe { mir_transmute(123_i16) };
+   |                                    ^^^^^^^^^^^^^^^^^^^^^^ transmuting from 2-byte type to 4-byte type: `i16` -> `u32`
    |
 note: inside `mir_transmute::<i16, u32>`
   --> $DIR/transmute-size-mismatch.rs:12:13
    |
 LL |             RET = CastTransmute(x);
-   |             ^^^^^^^^^^^^^^^^^^^^^^
-note: inside `FROM_SMALLER`
-  --> $DIR/transmute-size-mismatch.rs:22:36
-   |
-LL | const FROM_SMALLER: u32 = unsafe { mir_transmute(123_i16) };
-   |                                    ^^^^^^^^^^^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/const-eval/ub-enum.rs b/tests/ui/consts/const-eval/ub-enum.rs
index 11cd87023d17..5be444e667a1 100644
--- a/tests/ui/consts/const-eval/ub-enum.rs
+++ b/tests/ui/consts/const-eval/ub-enum.rs
@@ -101,7 +101,7 @@ const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe { mem:
 const TEST_ICE_89765: () = {
     // This is a regression test for https://github.com/rust-lang/rust/issues/89765.
     unsafe { std::mem::discriminant(&*(&() as *const () as *const Never)); };
-    //~^ inside `TEST_ICE_89765`
+    //~^ ERROR evaluation of constant value failed
 };
 
 fn main() {
diff --git a/tests/ui/consts/const-eval/ub-enum.stderr b/tests/ui/consts/const-eval/ub-enum.stderr
index a0712f64c7bc..cfb7eaf537ac 100644
--- a/tests/ui/consts/const-eval/ub-enum.stderr
+++ b/tests/ui/consts/const-eval/ub-enum.stderr
@@ -117,17 +117,13 @@ LL | const BAD_UNINHABITED_WITH_DATA2: Result<(i32, !), (i32, Never)> = unsafe {
    |                                                                             ^^^^^^^^^^^^^^^^^^^^ constructing invalid value at .<enum-tag>: encountered an uninhabited enum variant
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-   |
-   = note: read discriminant of an uninhabited enum variant
-   |
-note: inside `discriminant::<Never>`
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-note: inside `TEST_ICE_89765`
   --> $DIR/ub-enum.rs:103:14
    |
 LL |     unsafe { std::mem::discriminant(&*(&() as *const () as *const Never)); };
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ read discriminant of an uninhabited enum variant
+   |
+note: inside `discriminant::<Never>`
+  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
 
 error: aborting due to 14 previous errors
 
diff --git a/tests/ui/consts/const-eval/ub-invalid-values.rs b/tests/ui/consts/const-eval/ub-invalid-values.rs
index 1724a88dd3d9..c0b68d7619a0 100644
--- a/tests/ui/consts/const-eval/ub-invalid-values.rs
+++ b/tests/ui/consts/const-eval/ub-invalid-values.rs
@@ -1,11 +1,12 @@
 const fn bool_cast(ptr: *const bool) { unsafe {
-    let _val = *ptr as u32; //~ERROR: evaluation of constant value failed
-    //~^ interpreting an invalid 8-bit value as a bool
+    let _val = *ptr as u32; //~ NOTE inside `bool_cast`
+    //~^ NOTE the failure occurred here
 }}
 
 const _: () = {
     let v = 3_u8;
-    bool_cast(&v as *const u8 as *const bool);
+    bool_cast(&v as *const u8 as *const bool); //~ ERROR: evaluation of constant value failed
+    //~^ NOTE interpreting an invalid 8-bit value as a bool
 };
 
 fn main() {}
diff --git a/tests/ui/consts/const-eval/ub-invalid-values.stderr b/tests/ui/consts/const-eval/ub-invalid-values.stderr
index edf72f731e5a..76952c1f1a32 100644
--- a/tests/ui/consts/const-eval/ub-invalid-values.stderr
+++ b/tests/ui/consts/const-eval/ub-invalid-values.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/ub-invalid-values.rs:2:16
+  --> $DIR/ub-invalid-values.rs:8:5
    |
-LL |     let _val = *ptr as u32;
-   |                ^^^^^^^^^^^ interpreting an invalid 8-bit value as a bool: 0x03
+LL |     bool_cast(&v as *const u8 as *const bool);
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ interpreting an invalid 8-bit value as a bool: 0x03
    |
 note: inside `bool_cast`
   --> $DIR/ub-invalid-values.rs:2:16
    |
 LL |     let _val = *ptr as u32;
-   |                ^^^^^^^^^^^
-note: inside `_`
-  --> $DIR/ub-invalid-values.rs:8:5
-   |
-LL |     bool_cast(&v as *const u8 as *const bool);
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                ^^^^^^^^^^^ the failure occurred here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.rs b/tests/ui/consts/const-eval/ub-ref-ptr.rs
index 78d6fb5b65ba..50e510a3d546 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.rs
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.rs
@@ -63,7 +63,7 @@ const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
 const UNALIGNED_READ: () = unsafe {
     let x = &[0u8; 4];
     let ptr = x.as_ptr().cast::<u32>();
-    ptr.read(); //~ inside `UNALIGNED_READ`
+    ptr.read(); //~ ERROR evaluation of constant value failed
 };
 
 
diff --git a/tests/ui/consts/const-eval/ub-ref-ptr.stderr b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
index 3bbf2977392c..72a523282e6b 100644
--- a/tests/ui/consts/const-eval/ub-ref-ptr.stderr
+++ b/tests/ui/consts/const-eval/ub-ref-ptr.stderr
@@ -149,19 +149,15 @@ LL | const DATA_FN_PTR: fn() = unsafe { mem::transmute(&13) };
            }
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: accessing memory based on pointer with alignment 1, but alignment 4 is required
-   |
-note: inside `std::ptr::read::<u32>`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::const_ptr::<impl *const u32>::read`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `UNALIGNED_READ`
   --> $DIR/ub-ref-ptr.rs:66:5
    |
 LL |     ptr.read();
-   |     ^^^^^^^^^^
+   |     ^^^^^^^^^^ accessing memory based on pointer with alignment 1, but alignment 4 is required
+   |
+note: inside `std::ptr::const_ptr::<impl *const u32>::read`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+note: inside `std::ptr::read::<u32>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 
 error: aborting due to 15 previous errors
 
diff --git a/tests/ui/consts/const-eval/unwind-abort.rs b/tests/ui/consts/const-eval/unwind-abort.rs
index 8d5ed876e439..fee53f8528d6 100644
--- a/tests/ui/consts/const-eval/unwind-abort.rs
+++ b/tests/ui/consts/const-eval/unwind-abort.rs
@@ -1,8 +1,8 @@
 const extern "C" fn foo() {
-    panic!() //~ ERROR evaluation of constant value failed
+    panic!() //~ inside `foo`
 }
 
-const _: () = foo();
+const _: () = foo(); //~ ERROR evaluation of constant value failed
 // Ensure that the CTFE engine handles calls to `extern "C"` aborting gracefully
 
 fn main() {
diff --git a/tests/ui/consts/const-eval/unwind-abort.stderr b/tests/ui/consts/const-eval/unwind-abort.stderr
index 340f1dbe841f..96c0dd7c5e95 100644
--- a/tests/ui/consts/const-eval/unwind-abort.stderr
+++ b/tests/ui/consts/const-eval/unwind-abort.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/unwind-abort.rs:2:5
+  --> $DIR/unwind-abort.rs:5:15
    |
-LL |     panic!()
-   |     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/unwind-abort.rs:2:5
+LL | const _: () = foo();
+   |               ^^^^^ evaluation panicked: explicit panic
    |
 note: inside `foo`
   --> $DIR/unwind-abort.rs:2:5
    |
 LL |     panic!()
-   |     ^^^^^^^^
-note: inside `_`
-  --> $DIR/unwind-abort.rs:5:15
-   |
-LL | const _: () = foo();
-   |               ^^^^^
+   |     ^^^^^^^^ the failure occurred here
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/consts/const-eval/validate_uninhabited_zsts.rs b/tests/ui/consts/const-eval/validate_uninhabited_zsts.rs
index 261dea6182d3..c4df93b6239a 100644
--- a/tests/ui/consts/const-eval/validate_uninhabited_zsts.rs
+++ b/tests/ui/consts/const-eval/validate_uninhabited_zsts.rs
@@ -1,6 +1,5 @@
 const fn foo() -> ! {
-    unsafe { std::mem::transmute(()) }
-    //~^ ERROR evaluation of constant value failed
+    unsafe { std::mem::transmute(()) } //~ inside `foo`
 }
 
 // Type defined in a submodule, so that it is not "visibly"
@@ -14,6 +13,7 @@ pub mod empty {
 }
 
 const FOO: [empty::Empty; 3] = [foo(); 3];
+//~^ ERROR evaluation of constant value failed
 
 const BAR: [empty::Empty; 3] = [unsafe { std::mem::transmute(()) }; 3];
 //~^ ERROR evaluation of constant value failed
diff --git a/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr b/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr
index d9f1780f7b99..29311fdb25a2 100644
--- a/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr
+++ b/tests/ui/consts/const-eval/validate_uninhabited_zsts.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/validate_uninhabited_zsts.rs:2:14
+  --> $DIR/validate_uninhabited_zsts.rs:15:33
    |
-LL |     unsafe { std::mem::transmute(()) }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^ constructing invalid value: encountered a value of the never type `!`
+LL | const FOO: [empty::Empty; 3] = [foo(); 3];
+   |                                 ^^^^^ constructing invalid value: encountered a value of the never type `!`
    |
 note: inside `foo`
   --> $DIR/validate_uninhabited_zsts.rs:2:14
    |
 LL |     unsafe { std::mem::transmute(()) }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `FOO`
-  --> $DIR/validate_uninhabited_zsts.rs:16:33
-   |
-LL | const FOO: [empty::Empty; 3] = [foo(); 3];
-   |                                 ^^^^^
+   |              ^^^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
 
 error[E0080]: evaluation of constant value failed
   --> $DIR/validate_uninhabited_zsts.rs:18:42
diff --git a/tests/ui/consts/const-fn-in-vec.rs b/tests/ui/consts/const-fn-in-vec.rs
index 0483800efefd..d1430bc8e002 100644
--- a/tests/ui/consts/const-fn-in-vec.rs
+++ b/tests/ui/consts/const-fn-in-vec.rs
@@ -1,11 +1,16 @@
 static _MAYBE_STRINGS: [Option<String>; 5] = [None; 5];
 //~^ ERROR the trait bound `String: Copy` is not satisfied
 
-fn main() {
-    // should hint to create an inline `const` block
-    // or to create a new `const` item
+// should hint to create an inline `const` block
+// or to create a new `const` item
+fn foo() {
     let _strings: [String; 5] = [String::new(); 5];
     //~^ ERROR the trait bound `String: Copy` is not satisfied
+}
+
+fn bar() {
     let _maybe_strings: [Option<String>; 5] = [None; 5];
     //~^ ERROR the trait bound `String: Copy` is not satisfied
 }
+
+fn main() {}
diff --git a/tests/ui/consts/const-fn-in-vec.stderr b/tests/ui/consts/const-fn-in-vec.stderr
index b31e180fea2b..5be26d7c121b 100644
--- a/tests/ui/consts/const-fn-in-vec.stderr
+++ b/tests/ui/consts/const-fn-in-vec.stderr
@@ -22,7 +22,7 @@ LL |     let _strings: [String; 5] = [String::new(); 5];
    = note: the `Copy` trait is required because this value will be copied for each element of the array
 
 error[E0277]: the trait bound `String: Copy` is not satisfied
-  --> $DIR/const-fn-in-vec.rs:9:48
+  --> $DIR/const-fn-in-vec.rs:12:48
    |
 LL |     let _maybe_strings: [Option<String>; 5] = [None; 5];
    |                                                ^^^^
diff --git a/tests/ui/consts/const-ptr-is-null.rs b/tests/ui/consts/const-ptr-is-null.rs
index 0abd9afa4224..319f6b1a62ba 100644
--- a/tests/ui/consts/const-ptr-is-null.rs
+++ b/tests/ui/consts/const-ptr-is-null.rs
@@ -19,7 +19,7 @@ const MAYBE_NULL: () = {
     assert!(!ptr.wrapping_byte_sub(1).is_null());
     // ... but once we shift outside the allocation, with an offset divisible by 4,
     // we might become null.
-    assert!(!ptr.wrapping_sub(512).is_null()); //~inside `MAYBE_NULL`
+    assert!(!ptr.wrapping_sub(512).is_null()); //~ ERROR evaluation of constant value failed
 };
 
 fn main() {}
diff --git a/tests/ui/consts/const-ptr-is-null.stderr b/tests/ui/consts/const-ptr-is-null.stderr
index 5ef79790d93b..ff2db14a2f51 100644
--- a/tests/ui/consts/const-ptr-is-null.stderr
+++ b/tests/ui/consts/const-ptr-is-null.stderr
@@ -1,18 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: the evaluated program panicked at 'null-ness of this pointer cannot be determined in const context', $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-note: inside `std::ptr::const_ptr::<impl *const T>::is_null::compiletime`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `std::ptr::const_ptr::<impl *const i32>::is_null`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `MAYBE_NULL`
   --> $DIR/const-ptr-is-null.rs:22:14
    |
 LL |     assert!(!ptr.wrapping_sub(512).is_null());
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-   = note: this error originates in the macro `$crate::panic::panic_2021` which comes from the expansion of the macro `const_eval_select` (in Nightly builds, run with -Z macro-backtrace for more info)
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: null-ness of this pointer cannot be determined in const context
+   |
+note: inside `std::ptr::const_ptr::<impl *const i32>::is_null`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+note: inside `std::ptr::const_ptr::<impl *const T>::is_null::compiletime`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+   = note: this error originates in the macro `$crate::intrinsics::const_eval_select` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/const-unwrap.rs b/tests/ui/consts/const-unwrap.rs
index ea0a15af1be7..d48078a0834c 100644
--- a/tests/ui/consts/const-unwrap.rs
+++ b/tests/ui/consts/const-unwrap.rs
@@ -5,7 +5,7 @@ const FOO: i32 = Some(42i32).unwrap();
 
 const BAR: i32 = Option::<i32>::None.unwrap();
 //~^ ERROR: evaluation of constant value failed
-//~| NOTE: the evaluated program panicked
+//~| NOTE: called `Option::unwrap()` on a `None` value
 
 const BAZ: i32 = Option::<i32>::None.expect("absolutely not!");
 //~^ ERROR: evaluation of constant value failed
diff --git a/tests/ui/consts/const-unwrap.stderr b/tests/ui/consts/const-unwrap.stderr
index aa5dd9a5c36c..832c95992c87 100644
--- a/tests/ui/consts/const-unwrap.stderr
+++ b/tests/ui/consts/const-unwrap.stderr
@@ -2,13 +2,13 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/const-unwrap.rs:6:18
    |
 LL | const BAR: i32 = Option::<i32>::None.unwrap();
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'called `Option::unwrap()` on a `None` value', $DIR/const-unwrap.rs:6:38
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: called `Option::unwrap()` on a `None` value
 
 error[E0080]: evaluation of constant value failed
   --> $DIR/const-unwrap.rs:10:18
    |
 LL | const BAZ: i32 = Option::<i32>::None.expect("absolutely not!");
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'absolutely not!', $DIR/const-unwrap.rs:10:38
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: absolutely not!
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/consts/const_unsafe_unreachable_ub.rs b/tests/ui/consts/const_unsafe_unreachable_ub.rs
index 705e208b56d7..a3f7fd46a759 100644
--- a/tests/ui/consts/const_unsafe_unreachable_ub.rs
+++ b/tests/ui/consts/const_unsafe_unreachable_ub.rs
@@ -1,13 +1,14 @@
-//@ error-pattern: evaluation of constant value failed
-
 const unsafe fn foo(x: bool) -> bool {
     match x {
         true => true,
-        false => std::hint::unreachable_unchecked(),
+        false => std::hint::unreachable_unchecked(), //~ NOTE inside `foo`
     }
 }
 
 const BAR: bool = unsafe { foo(false) };
+//~^ ERROR evaluation of constant value failed
+//~| NOTE entering unreachable code
+//~| NOTE inside `unreachable_unchecked`
 
 fn main() {
     assert_eq!(BAR, true);
diff --git a/tests/ui/consts/const_unsafe_unreachable_ub.stderr b/tests/ui/consts/const_unsafe_unreachable_ub.stderr
index 6394563e2bb8..079ed77b219b 100644
--- a/tests/ui/consts/const_unsafe_unreachable_ub.stderr
+++ b/tests/ui/consts/const_unsafe_unreachable_ub.stderr
@@ -1,20 +1,16 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/hint.rs:LL:COL
+  --> $DIR/const_unsafe_unreachable_ub.rs:8:28
    |
-   = note: entering unreachable code
+LL | const BAR: bool = unsafe { foo(false) };
+   |                            ^^^^^^^^^^ entering unreachable code
    |
-note: inside `unreachable_unchecked`
-  --> $SRC_DIR/core/src/hint.rs:LL:COL
 note: inside `foo`
-  --> $DIR/const_unsafe_unreachable_ub.rs:6:18
+  --> $DIR/const_unsafe_unreachable_ub.rs:4:18
    |
 LL |         false => std::hint::unreachable_unchecked(),
    |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `BAR`
-  --> $DIR/const_unsafe_unreachable_ub.rs:10:28
-   |
-LL | const BAR: bool = unsafe { foo(false) };
-   |                            ^^^^^^^^^^
+note: inside `unreachable_unchecked`
+  --> $SRC_DIR/core/src/hint.rs:LL:COL
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/consts/control-flow/assert.stderr b/tests/ui/consts/control-flow/assert.stderr
index 2f863daf760d..fc378f57fa43 100644
--- a/tests/ui/consts/control-flow/assert.stderr
+++ b/tests/ui/consts/control-flow/assert.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/assert.rs:5:15
    |
 LL | const _: () = assert!(false);
-   |               ^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/assert.rs:5:15
+   |               ^^^^^^^^^^^^^^ evaluation panicked: assertion failed: false
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/issue-32829.stderr b/tests/ui/consts/issue-32829.stderr
index 8eee87af8e1b..0cbc73cfaa39 100644
--- a/tests/ui/consts/issue-32829.stderr
+++ b/tests/ui/consts/issue-32829.stderr
@@ -2,7 +2,7 @@ error[E0080]: could not evaluate static initializer
   --> $DIR/issue-32829.rs:1:22
    |
 LL | static S : u64 = { { panic!("foo"); 0 } };
-   |                      ^^^^^^^^^^^^^ the evaluated program panicked at 'foo', $DIR/issue-32829.rs:1:22
+   |                      ^^^^^^^^^^^^^ evaluation panicked: foo
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/issue-66693-panic-in-array-len.stderr b/tests/ui/consts/issue-66693-panic-in-array-len.stderr
index 1585ea317d9b..9cf5ad126f33 100644
--- a/tests/ui/consts/issue-66693-panic-in-array-len.stderr
+++ b/tests/ui/consts/issue-66693-panic-in-array-len.stderr
@@ -10,7 +10,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/issue-66693-panic-in-array-len.rs:10:21
    |
 LL |     let _ = [false; panic!()];
-   |                     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-66693-panic-in-array-len.rs:10:21
+   |                     ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/issue-66693.stderr b/tests/ui/consts/issue-66693.stderr
index a435ace47730..46f30a8cbab6 100644
--- a/tests/ui/consts/issue-66693.stderr
+++ b/tests/ui/consts/issue-66693.stderr
@@ -18,7 +18,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/issue-66693.rs:16:15
    |
 LL | const _: () = panic!();
-   |               ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-66693.rs:16:15
+   |               ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -26,7 +26,7 @@ error[E0080]: could not evaluate static initializer
   --> $DIR/issue-66693.rs:18:19
    |
 LL | static _BAR: () = panic!("panic in static");
-   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'panic in static', $DIR/issue-66693.rs:18:19
+   |                   ^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: panic in static
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/issue-76064.stderr b/tests/ui/consts/issue-76064.stderr
index fabebdb1a774..55059220388a 100644
--- a/tests/ui/consts/issue-76064.stderr
+++ b/tests/ui/consts/issue-76064.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/issue-76064.rs:1:17
    |
 LL | struct Bug([u8; panic!("panic")]);
-   |                 ^^^^^^^^^^^^^^^ the evaluated program panicked at 'panic', $DIR/issue-76064.rs:1:17
+   |                 ^^^^^^^^^^^^^^^ evaluation panicked: panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/issue-miri-1910.rs b/tests/ui/consts/issue-miri-1910.rs
index 107d9742b92a..d194dd3c78bb 100644
--- a/tests/ui/consts/issue-miri-1910.rs
+++ b/tests/ui/consts/issue-miri-1910.rs
@@ -5,6 +5,7 @@ const C: () = unsafe {
     let foo = Some(&42 as *const i32);
     let one_and_a_half_pointers = std::mem::size_of::<*const i32>()/2*3;
     (&foo as *const _ as *const u8).add(one_and_a_half_pointers).read();
+    //~^ ERROR evaluation of constant value failed
 };
 
 fn main() {
diff --git a/tests/ui/consts/issue-miri-1910.stderr b/tests/ui/consts/issue-miri-1910.stderr
index 32beed5dba09..59cbccc13a72 100644
--- a/tests/ui/consts/issue-miri-1910.stderr
+++ b/tests/ui/consts/issue-miri-1910.stderr
@@ -1,17 +1,13 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: unable to turn pointer into integer
-   |
-note: inside `std::ptr::read::<u8>`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::const_ptr::<impl *const u8>::read`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `C`
   --> $DIR/issue-miri-1910.rs:7:5
    |
 LL |     (&foo as *const _ as *const u8).add(one_and_a_half_pointers).read();
-   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ unable to turn pointer into integer
+   |
+note: inside `std::ptr::const_ptr::<impl *const u8>::read`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
+note: inside `std::ptr::read::<u8>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
 
diff --git a/tests/ui/consts/miri_unleashed/abi-mismatch.rs b/tests/ui/consts/miri_unleashed/abi-mismatch.rs
index da5b1dd5802d..ea640ae78d55 100644
--- a/tests/ui/consts/miri_unleashed/abi-mismatch.rs
+++ b/tests/ui/consts/miri_unleashed/abi-mismatch.rs
@@ -4,13 +4,12 @@
 const extern "C" fn c_fn() {}
 
 const fn call_rust_fn(my_fn: extern "Rust" fn()) {
-    my_fn();
-    //~^ ERROR could not evaluate static initializer
-    //~| NOTE calling a function with calling convention C using calling convention Rust
-    //~| NOTE inside `call_rust_fn`
+    my_fn(); //~ NOTE inside `call_rust_fn`
+    //~^ NOTE the failure occurred here
 }
 
 static VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) });
-//~^ NOTE inside `VAL`
+//~^ ERROR could not evaluate static initializer
+//~| NOTE calling a function with calling convention C using calling convention Rust
 
 fn main() {}
diff --git a/tests/ui/consts/miri_unleashed/abi-mismatch.stderr b/tests/ui/consts/miri_unleashed/abi-mismatch.stderr
index 639795efae79..88623b134b0b 100644
--- a/tests/ui/consts/miri_unleashed/abi-mismatch.stderr
+++ b/tests/ui/consts/miri_unleashed/abi-mismatch.stderr
@@ -1,19 +1,14 @@
 error[E0080]: could not evaluate static initializer
-  --> $DIR/abi-mismatch.rs:7:5
+  --> $DIR/abi-mismatch.rs:11:18
    |
-LL |     my_fn();
-   |     ^^^^^^^ calling a function with calling convention C using calling convention Rust
+LL | static VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) });
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ calling a function with calling convention C using calling convention Rust
    |
 note: inside `call_rust_fn`
   --> $DIR/abi-mismatch.rs:7:5
    |
 LL |     my_fn();
-   |     ^^^^^^^
-note: inside `VAL`
-  --> $DIR/abi-mismatch.rs:13:18
-   |
-LL | static VAL: () = call_rust_fn(unsafe { std::mem::transmute(c_fn as extern "C" fn()) });
-   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |     ^^^^^^^ the failure occurred here
 
 warning: skipping const checks
    |
diff --git a/tests/ui/consts/miri_unleashed/assoc_const.rs b/tests/ui/consts/miri_unleashed/assoc_const.rs
index db37197f1902..96b47ff4e5e2 100644
--- a/tests/ui/consts/miri_unleashed/assoc_const.rs
+++ b/tests/ui/consts/miri_unleashed/assoc_const.rs
@@ -9,7 +9,7 @@ trait Foo<T> {
 }
 
 trait Bar<T, U: Foo<T>> {
-    const F: u32 = (U::X, 42).1;
+    const F: u32 = (U::X, 42).1; //~ ERROR
 }
 
 impl Foo<u32> for () {
@@ -26,5 +26,5 @@ fn main() {
     // this is fine, but would have been forbidden by the static checks on `F`
     let x = <() as Bar<u32, ()>>::F;
     // this test only causes errors due to the line below, so post-monomorphization
-    let y = <String as Bar<Vec<u32>, String>>::F; //~ constant
+    let y = <String as Bar<Vec<u32>, String>>::F;
 }
diff --git a/tests/ui/consts/miri_unleashed/assoc_const.stderr b/tests/ui/consts/miri_unleashed/assoc_const.stderr
index 3303a7842653..f259765f6e57 100644
--- a/tests/ui/consts/miri_unleashed/assoc_const.stderr
+++ b/tests/ui/consts/miri_unleashed/assoc_const.stderr
@@ -1,17 +1,13 @@
-error[E0080]: evaluation of `<String as Bar<Vec<u32>, String>>::F` failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: calling non-const function `<Vec<u32> as Drop>::drop`
-   |
-note: inside `std::ptr::drop_in_place::<Vec<u32>> - shim(Some(Vec<u32>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_in_place::<(Vec<u32>, u32)> - shim(Some((Vec<u32>, u32)))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `<String as Bar<Vec<u32>, String>>::F`
+error[E0080]: evaluation of `std::ptr::drop_in_place::<Vec<u32>> - shim(Some(Vec<u32>))` failed
   --> $DIR/assoc_const.rs:12:31
    |
 LL |     const F: u32 = (U::X, 42).1;
-   |                               ^
+   |                               ^ calling non-const function `<Vec<u32> as Drop>::drop`
+   |
+note: inside `std::ptr::drop_in_place::<(Vec<u32>, u32)> - shim(Some((Vec<u32>, u32)))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `std::ptr::drop_in_place::<Vec<u32>> - shim(Some(Vec<u32>))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 
 note: erroneous constant encountered
   --> $DIR/assoc_const.rs:29:13
diff --git a/tests/ui/consts/miri_unleashed/drop.stderr b/tests/ui/consts/miri_unleashed/drop.stderr
index 5c415b5bac18..40a29d5a819a 100644
--- a/tests/ui/consts/miri_unleashed/drop.stderr
+++ b/tests/ui/consts/miri_unleashed/drop.stderr
@@ -1,15 +1,11 @@
 error[E0080]: could not evaluate static initializer
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: calling non-const function `<Vec<i32> as Drop>::drop`
-   |
-note: inside `std::ptr::drop_in_place::<Vec<i32>> - shim(Some(Vec<i32>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `TEST_BAD`
   --> $DIR/drop.rs:17:1
    |
 LL | };
-   | ^
+   | ^ calling non-const function `<Vec<i32> as Drop>::drop`
+   |
+note: inside `std::ptr::drop_in_place::<Vec<i32>> - shim(Some(Vec<i32>))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 
 warning: skipping const checks
    |
diff --git a/tests/ui/consts/missing_span_in_backtrace.rs b/tests/ui/consts/missing_span_in_backtrace.rs
index 703cc7fbf89b..c8c7453daa12 100644
--- a/tests/ui/consts/missing_span_in_backtrace.rs
+++ b/tests/ui/consts/missing_span_in_backtrace.rs
@@ -13,7 +13,7 @@ const X: () = {
 
     // Swap them, bytewise.
     unsafe {
-        ptr::swap_nonoverlapping(
+        ptr::swap_nonoverlapping( //~ ERROR evaluation of constant value failed
             &mut ptr1 as *mut _ as *mut MaybeUninit<u8>,
             &mut ptr2 as *mut _ as *mut MaybeUninit<u8>,
             mem::size_of::<&i32>(),
diff --git a/tests/ui/consts/missing_span_in_backtrace.stderr b/tests/ui/consts/missing_span_in_backtrace.stderr
index 05ae7305dbc0..2f3a65302bd5 100644
--- a/tests/ui/consts/missing_span_in_backtrace.stderr
+++ b/tests/ui/consts/missing_span_in_backtrace.stderr
@@ -1,17 +1,4 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: unable to copy parts of a pointer from memory at ALLOC0
-   |
-note: inside `std::ptr::read::<MaybeUninit<MaybeUninit<u8>>>`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::swap_nonoverlapping_simple_untyped::<MaybeUninit<u8>>`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `swap_nonoverlapping::compiletime::<MaybeUninit<u8>>`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `swap_nonoverlapping::<MaybeUninit<u8>>`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `X`
   --> $DIR/missing_span_in_backtrace.rs:16:9
    |
 16 | /         ptr::swap_nonoverlapping(
@@ -19,7 +6,16 @@ note: inside `X`
 18 | |             &mut ptr2 as *mut _ as *mut MaybeUninit<u8>,
 19 | |             mem::size_of::<&i32>(),
 20 | |         );
-   | |_________^
+   | |_________^ unable to copy parts of a pointer from memory at ALLOC0
+   |
+note: inside `swap_nonoverlapping::<MaybeUninit<u8>>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `swap_nonoverlapping::compiletime::<MaybeUninit<u8>>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `std::ptr::swap_nonoverlapping_simple_untyped::<MaybeUninit<u8>>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `std::ptr::read::<MaybeUninit<MaybeUninit<u8>>>`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
    = help: this code performed an operation that depends on the underlying bytes representing a pointer
    = help: the absolute address of a pointer is not known at compile-time, so such operations are not supported
    = note: this error originates in the macro `$crate::intrinsics::const_eval_select` which comes from the expansion of the macro `const_eval_select` (in Nightly builds, run with -Z macro-backtrace for more info)
diff --git a/tests/ui/consts/offset_from_ub.rs b/tests/ui/consts/offset_from_ub.rs
index 39384bf0c8b9..53d9c7a39da8 100644
--- a/tests/ui/consts/offset_from_ub.rs
+++ b/tests/ui/consts/offset_from_ub.rs
@@ -21,7 +21,7 @@ pub const DIFFERENT_ALLOC: usize = {
 };
 
 pub const NOT_PTR: usize = {
-    unsafe { (42 as *const u8).offset_from(&5u8) as usize }
+    unsafe { (42 as *const u8).offset_from(&5u8) as usize } //~ ERROR evaluation of constant value failed
 };
 
 pub const NOT_MULTIPLE_OF_SIZE: isize = {
@@ -107,13 +107,13 @@ pub const OFFSET_VERY_FAR1: isize = {
     let ptr1 = ptr::null::<u8>();
     let ptr2 = ptr1.wrapping_offset(isize::MAX);
     unsafe { ptr2.offset_from(ptr1) }
-    //~^ inside
+    //~^ ERROR evaluation of constant value failed
 };
 pub const OFFSET_VERY_FAR2: isize = {
     let ptr1 = ptr::null::<u8>();
     let ptr2 = ptr1.wrapping_offset(isize::MAX);
     unsafe { ptr1.offset_from(ptr2.wrapping_offset(1)) }
-    //~^ inside
+    //~^ ERROR evaluation of constant value failed
 };
 
 // If the pointers are the same, OOB/null/UAF is fine.
diff --git a/tests/ui/consts/offset_from_ub.stderr b/tests/ui/consts/offset_from_ub.stderr
index 8cfbdd131909..08e42c9f30ba 100644
--- a/tests/ui/consts/offset_from_ub.stderr
+++ b/tests/ui/consts/offset_from_ub.stderr
@@ -5,17 +5,13 @@ LL |     let offset = unsafe { ptr_offset_from(field_ptr, base_ptr) };
    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from` called on two different pointers that are not both derived from the same allocation
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: `ptr_offset_from` called on two different pointers that are not both derived from the same allocation
-   |
-note: inside `std::ptr::const_ptr::<impl *const u8>::offset_from`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `NOT_PTR`
   --> $DIR/offset_from_ub.rs:24:14
    |
 LL |     unsafe { (42 as *const u8).offset_from(&5u8) as usize }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from` called on two different pointers that are not both derived from the same allocation
+   |
+note: inside `std::ptr::const_ptr::<impl *const u8>::offset_from`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 
 error[E0080]: evaluation of constant value failed
   --> $DIR/offset_from_ub.rs:31:14
@@ -78,30 +74,22 @@ LL |     unsafe { ptr_offset_from_unsigned(ptr2, ptr1) }
    |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from_unsigned` called when first pointer is too far ahead of second
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: `ptr_offset_from` called on two different pointers that are not both derived from the same allocation
-   |
-note: inside `std::ptr::const_ptr::<impl *const u8>::offset_from`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `OFFSET_VERY_FAR1`
   --> $DIR/offset_from_ub.rs:109:14
    |
 LL |     unsafe { ptr2.offset_from(ptr1) }
-   |              ^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: `ptr_offset_from` called when first pointer is too far before second
+   |              ^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from` called on two different pointers that are not both derived from the same allocation
    |
 note: inside `std::ptr::const_ptr::<impl *const u8>::offset_from`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `OFFSET_VERY_FAR2`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_from_ub.rs:115:14
    |
 LL |     unsafe { ptr1.offset_from(ptr2.wrapping_offset(1)) }
-   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ `ptr_offset_from` called when first pointer is too far before second
+   |
+note: inside `std::ptr::const_ptr::<impl *const u8>::offset_from`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 
 error: aborting due to 14 previous errors
 
diff --git a/tests/ui/consts/offset_ub.rs b/tests/ui/consts/offset_ub.rs
index dda6dd388f28..8c52586c485f 100644
--- a/tests/ui/consts/offset_ub.rs
+++ b/tests/ui/consts/offset_ub.rs
@@ -5,21 +5,21 @@ use std::ptr;
 //@ normalize-stderr: "\d+ bytes" -> "$$BYTES bytes"
 
 
-pub const BEFORE_START: *const u8 = unsafe { (&0u8 as *const u8).offset(-1) }; //~NOTE
-pub const AFTER_END: *const u8 = unsafe { (&0u8 as *const u8).offset(2) }; //~NOTE
-pub const AFTER_ARRAY: *const u8 = unsafe { [0u8; 100].as_ptr().offset(101) }; //~NOTE
+pub const BEFORE_START: *const u8 = unsafe { (&0u8 as *const u8).offset(-1) }; //~ ERROR
+pub const AFTER_END: *const u8 = unsafe { (&0u8 as *const u8).offset(2) }; //~ ERROR
+pub const AFTER_ARRAY: *const u8 = unsafe { [0u8; 100].as_ptr().offset(101) }; //~ ERROR
 
-pub const OVERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MAX) }; //~NOTE
-pub const UNDERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MIN) }; //~NOTE
-pub const OVERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (usize::MAX as *const u8).offset(2) }; //~NOTE
-pub const UNDERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (1 as *const u8).offset(-2) }; //~NOTE
-pub const NEGATIVE_OFFSET: *const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) }; //~NOTE
+pub const OVERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MAX) }; //~ ERROR
+pub const UNDERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MIN) }; //~ ERROR
+pub const OVERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (usize::MAX as *const u8).offset(2) }; //~ ERROR
+pub const UNDERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (1 as *const u8).offset(-2) }; //~ ERROR
+pub const NEGATIVE_OFFSET: *const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) }; //~ ERROR
 
-pub const ZERO_SIZED_ALLOC: *const u8 = unsafe { [0u8; 0].as_ptr().offset(1) }; //~NOTE
-pub const DANGLING: *const u8 = unsafe { ptr::NonNull::<u8>::dangling().as_ptr().offset(4) }; //~NOTE
+pub const ZERO_SIZED_ALLOC: *const u8 = unsafe { [0u8; 0].as_ptr().offset(1) }; //~ ERROR
+pub const DANGLING: *const u8 = unsafe { ptr::NonNull::<u8>::dangling().as_ptr().offset(4) }; //~ ERROR
 
 // Make sure that we don't panic when computing abs(offset*size_of::<T>())
-pub const UNDERFLOW_ABS: *const u8 = unsafe { (usize::MAX as *const u8).offset(isize::MIN) }; //~NOTE
+pub const UNDERFLOW_ABS: *const u8 = unsafe { (usize::MAX as *const u8).offset(isize::MIN) }; //~ ERROR
 
 // Offset-by-zero is allowed.
 pub const NULL_OFFSET_ZERO: *const u8 = unsafe { ptr::null::<u8>().offset(0) };
diff --git a/tests/ui/consts/offset_ub.stderr b/tests/ui/consts/offset_ub.stderr
index 779cb9654f4d..a247ad254651 100644
--- a/tests/ui/consts/offset_ub.stderr
+++ b/tests/ui/consts/offset_ub.stderr
@@ -1,145 +1,101 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to the end of 1 byte of memory, but got ALLOC0 which is at the beginning of the allocation
-   |
-note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `BEFORE_START`
   --> $DIR/offset_ub.rs:8:46
    |
 LL | pub const BEFORE_START: *const u8 = unsafe { (&0u8 as *const u8).offset(-1) };
-   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got ALLOC1 which is only 1 byte from the end of the allocation
+   |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to the end of 1 byte of memory, but got ALLOC0 which is at the beginning of the allocation
    |
 note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `AFTER_END`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_ub.rs:9:43
    |
 LL | pub const AFTER_END: *const u8 = unsafe { (&0u8 as *const u8).offset(2) };
-   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got ALLOC2 which is only $BYTES bytes from the end of the allocation
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got ALLOC1 which is only 1 byte from the end of the allocation
    |
 note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `AFTER_ARRAY`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_ub.rs:10:45
    |
 LL | pub const AFTER_ARRAY: *const u8 = unsafe { [0u8; 100].as_ptr().offset(101) };
-   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got ALLOC2 which is only $BYTES bytes from the end of the allocation
+   |
+note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
-   |
-note: inside `std::ptr::const_ptr::<impl *const u16>::offset`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `OVERFLOW`
   --> $DIR/offset_ub.rs:12:43
    |
 LL | pub const OVERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MAX) };
-   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
+   |                                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
    |
 note: inside `std::ptr::const_ptr::<impl *const u16>::offset`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `UNDERFLOW`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_ub.rs:13:44
    |
 LL | pub const UNDERFLOW: *const u16 = unsafe { [0u16; 1].as_ptr().offset(isize::MIN) };
-   |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ overflowing pointer arithmetic: the total offset in bytes does not fit in an `isize`
+   |
+note: inside `std::ptr::const_ptr::<impl *const u16>::offset`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got 0xf..f[noalloc] which is a dangling pointer (it has no provenance)
-   |
-note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `OVERFLOW_ADDRESS_SPACE`
   --> $DIR/offset_ub.rs:14:56
    |
 LL | pub const OVERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (usize::MAX as *const u8).offset(2) };
-   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to the end of $BYTES bytes of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
+   |                                                        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got 0xf..f[noalloc] which is a dangling pointer (it has no provenance)
    |
 note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `UNDERFLOW_ADDRESS_SPACE`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_ub.rs:15:57
    |
 LL | pub const UNDERFLOW_ADDRESS_SPACE: *const u8 = unsafe { (1 as *const u8).offset(-2) };
-   |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to the end of $BYTES bytes of memory, but got ALLOC3-0x2 which points to before the beginning of the allocation
+   |                                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to the end of $BYTES bytes of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
    |
 note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `NEGATIVE_OFFSET`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_ub.rs:16:49
    |
 LL | pub const NEGATIVE_OFFSET: *const u8 = unsafe { [0u8; 1].as_ptr().wrapping_offset(-2).offset(-2) };
-   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to 1 byte of memory, but got ALLOC4 which is at or beyond the end of the allocation of size $BYTES bytes
+   |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to the end of $BYTES bytes of memory, but got ALLOC3-0x2 which points to before the beginning of the allocation
    |
 note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `ZERO_SIZED_ALLOC`
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_ub.rs:18:50
    |
 LL | pub const ZERO_SIZED_ALLOC: *const u8 = unsafe { [0u8; 0].as_ptr().offset(1) };
-   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mut_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
-   |
-note: inside `std::ptr::mut_ptr::<impl *mut u8>::offset`
-  --> $SRC_DIR/core/src/ptr/mut_ptr.rs:LL:COL
-note: inside `DANGLING`
-  --> $DIR/offset_ub.rs:19:42
-   |
-LL | pub const DANGLING: *const u8 = unsafe { ptr::NonNull::<u8>::dangling().as_ptr().offset(4) };
-   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-   |
-   = note: out-of-bounds pointer arithmetic: expected a pointer to the end of $BYTES bytes of memory, but got 0xf..f[noalloc] which is a dangling pointer (it has no provenance)
+   |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to 1 byte of memory, but got ALLOC4 which is at or beyond the end of the allocation of size $BYTES bytes
    |
 note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
   --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
-note: inside `UNDERFLOW_ABS`
+
+error[E0080]: evaluation of constant value failed
+  --> $DIR/offset_ub.rs:19:42
+   |
+LL | pub const DANGLING: *const u8 = unsafe { ptr::NonNull::<u8>::dangling().as_ptr().offset(4) };
+   |                                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to $BYTES bytes of memory, but got 0x1[noalloc] which is a dangling pointer (it has no provenance)
+   |
+note: inside `std::ptr::mut_ptr::<impl *mut u8>::offset`
+  --> $SRC_DIR/core/src/ptr/mut_ptr.rs:LL:COL
+
+error[E0080]: evaluation of constant value failed
   --> $DIR/offset_ub.rs:22:47
    |
 LL | pub const UNDERFLOW_ABS: *const u8 = unsafe { (usize::MAX as *const u8).offset(isize::MIN) };
-   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ out-of-bounds pointer arithmetic: expected a pointer to the end of $BYTES bytes of memory, but got 0xf..f[noalloc] which is a dangling pointer (it has no provenance)
+   |
+note: inside `std::ptr::const_ptr::<impl *const u8>::offset`
+  --> $SRC_DIR/core/src/ptr/const_ptr.rs:LL:COL
 
 error: aborting due to 11 previous errors
 
diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.rs b/tests/ui/consts/qualif-indirect-mutation-fail.rs
index 0f59a86b7cc0..4abb231c29f6 100644
--- a/tests/ui/consts/qualif-indirect-mutation-fail.rs
+++ b/tests/ui/consts/qualif-indirect-mutation-fail.rs
@@ -15,7 +15,7 @@ pub const A1: () = {
     let b = &mut y;
     std::mem::swap(a, b);
     std::mem::forget(y);
-};
+}; //~ ERROR evaluation of constant value failed
 
 // Mutable borrow of a type with drop impl.
 pub const A2: () = {
@@ -26,7 +26,7 @@ pub const A2: () = {
     std::mem::swap(a, b);
     std::mem::forget(y);
     let _z = x; //~ ERROR destructor of
-};
+}; //~ ERROR evaluation of constant value failed
 
 // Shared borrow of a type that might be !Freeze and Drop.
 pub const fn g1<T>() {
diff --git a/tests/ui/consts/qualif-indirect-mutation-fail.stderr b/tests/ui/consts/qualif-indirect-mutation-fail.stderr
index e76d7d3b6705..d3bb01af7547 100644
--- a/tests/ui/consts/qualif-indirect-mutation-fail.stderr
+++ b/tests/ui/consts/qualif-indirect-mutation-fail.stderr
@@ -8,21 +8,17 @@ LL | };
    | - value is dropped here
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: calling non-const function `<Vec<u8> as Drop>::drop`
-   |
-note: inside `std::ptr::drop_in_place::<Vec<u8>> - shim(Some(Vec<u8>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `A1`
   --> $DIR/qualif-indirect-mutation-fail.rs:18:1
    |
 LL | };
-   | ^
+   | ^ calling non-const function `<Vec<u8> as Drop>::drop`
+   |
+note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `std::ptr::drop_in_place::<Vec<u8>> - shim(Some(Vec<u8>))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 
 error[E0493]: destructor of `Option<String>` cannot be evaluated at compile-time
   --> $DIR/qualif-indirect-mutation-fail.rs:28:9
@@ -33,21 +29,17 @@ LL | };
    | - value is dropped here
 
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-   |
-   = note: calling non-const function `<Vec<u8> as Drop>::drop`
-   |
-note: inside `std::ptr::drop_in_place::<Vec<u8>> - shim(Some(Vec<u8>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
-  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
-note: inside `A2`
   --> $DIR/qualif-indirect-mutation-fail.rs:29:1
    |
 LL | };
-   | ^
+   | ^ calling non-const function `<Vec<u8> as Drop>::drop`
+   |
+note: inside `std::ptr::drop_in_place::<Option<String>> - shim(Some(Option<String>))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `std::ptr::drop_in_place::<String> - shim(Some(String))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
+note: inside `std::ptr::drop_in_place::<Vec<u8>> - shim(Some(Vec<u8>))`
+  --> $SRC_DIR/core/src/ptr/mod.rs:LL:COL
 
 error[E0493]: destructor of `(u32, Option<String>)` cannot be evaluated at compile-time
   --> $DIR/qualif-indirect-mutation-fail.rs:6:9
diff --git a/tests/ui/consts/recursive.rs b/tests/ui/consts/recursive.rs
index 5d736e31bcb4..b5703d11310f 100644
--- a/tests/ui/consts/recursive.rs
+++ b/tests/ui/consts/recursive.rs
@@ -2,9 +2,8 @@
 
 const fn f<T>(x: T) { //~ WARN function cannot return without recursing
     f(x);
-    //~^ ERROR evaluation of constant value failed
 }
 
-const X: () = f(1);
+const X: () = f(1); //~ ERROR evaluation of constant value failed
 
 fn main() {}
diff --git a/tests/ui/consts/recursive.stderr b/tests/ui/consts/recursive.stderr
index 0046005c74f0..fd38b078b94e 100644
--- a/tests/ui/consts/recursive.stderr
+++ b/tests/ui/consts/recursive.stderr
@@ -10,26 +10,21 @@ LL |     f(x);
    = note: `#[warn(unconditional_recursion)]` on by default
 
 error[E0080]: evaluation of constant value failed
-  --> $DIR/recursive.rs:4:5
+  --> $DIR/recursive.rs:7:15
    |
-LL |     f(x);
-   |     ^^^^ reached the configured maximum number of stack frames
+LL | const X: () = f(1);
+   |               ^^^^ reached the configured maximum number of stack frames
    |
-note: inside `f::<i32>`
-  --> $DIR/recursive.rs:4:5
-   |
-LL |     f(x);
-   |     ^^^^
 note: [... 126 additional calls inside `f::<i32>` ...]
   --> $DIR/recursive.rs:4:5
    |
 LL |     f(x);
    |     ^^^^
-note: inside `X`
-  --> $DIR/recursive.rs:8:15
+note: inside `f::<i32>`
+  --> $DIR/recursive.rs:4:5
    |
-LL | const X: () = f(1);
-   |               ^^^^
+LL |     f(x);
+   |     ^^^^ the failure occurred here
 
 error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/consts/required-consts/collect-in-called-fn.noopt.stderr b/tests/ui/consts/required-consts/collect-in-called-fn.noopt.stderr
index c3b641a899ac..08d0b338728f 100644
--- a/tests/ui/consts/required-consts/collect-in-called-fn.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-called-fn.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-called-fn.rs:10:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-called-fn.rs:10:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-called-fn.opt.stderr b/tests/ui/consts/required-consts/collect-in-called-fn.opt.stderr
index c3b641a899ac..08d0b338728f 100644
--- a/tests/ui/consts/required-consts/collect-in-called-fn.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-called-fn.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-called-fn.rs:10:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-called-fn.rs:10:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-closure.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-closure.noopt.stderr
index 75c3575a1106..41fe2cf84e49 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-closure.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-closure.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-closure.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-closure.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-closure.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-closure.opt.stderr
index 75c3575a1106..41fe2cf84e49 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-closure.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-closure.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-closure.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-closure.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-drop.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-drop.noopt.stderr
index 73790f7517db..b62b25bd3aa4 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-drop.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-drop.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-drop.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-drop.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-drop.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-drop.opt.stderr
index 73790f7517db..b62b25bd3aa4 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-drop.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-drop.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-drop.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-drop.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.noopt.stderr
index 706c0d55b622..c8a7cf983c41 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn-behind-assoc-type.rs:10:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn-behind-assoc-type.rs:10:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.opt.stderr
index 706c0d55b622..c8a7cf983c41 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-assoc-type.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn-behind-assoc-type.rs:10:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn-behind-assoc-type.rs:10:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.noopt.stderr
index 581edd2b7b8f..1e68d66cf5ea 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn-behind-generic.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn-behind-generic.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.opt.stderr
index 581edd2b7b8f..1e68d66cf5ea 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-generic.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn-behind-generic.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn-behind-generic.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.noopt.stderr
index 07e46b8a816f..a9cc56fba458 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `m::Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn-behind-opaque-type.rs:11:23
    |
 LL |         const C: () = panic!();
-   |                       ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn-behind-opaque-type.rs:11:23
+   |                       ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.opt.stderr
index 07e46b8a816f..a9cc56fba458 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn-behind-opaque-type.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `m::Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn-behind-opaque-type.rs:11:23
    |
 LL |         const C: () = panic!();
-   |                       ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn-behind-opaque-type.rs:11:23
+   |                       ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn.noopt.stderr
index 52462076ff90..ec549561a176 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fn.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fn.opt.stderr
index 52462076ff90..ec549561a176 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fn.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fn.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fn.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fn.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.noopt.stderr
index dea2a3423837..dfaf69d52b26 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Late::<i32>::FAIL` failed
   --> $DIR/collect-in-dead-fnptr-in-const.rs:9:22
    |
 LL |     const FAIL: () = panic!();
-   |                      ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fnptr-in-const.rs:9:22
+   |                      ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.opt.stderr
index dea2a3423837..dfaf69d52b26 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fnptr-in-const.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Late::<i32>::FAIL` failed
   --> $DIR/collect-in-dead-fnptr-in-const.rs:9:22
    |
 LL |     const FAIL: () = panic!();
-   |                      ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fnptr-in-const.rs:9:22
+   |                      ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fnptr.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fnptr.noopt.stderr
index 51c687826873..7cbd423cdc08 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fnptr.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fnptr.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fnptr.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fnptr.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-fnptr.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-fnptr.opt.stderr
index 51c687826873..7cbd423cdc08 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-fnptr.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-fnptr.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-fnptr.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-fnptr.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-move.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-move.noopt.stderr
index 2ab1f80e2d3b..58e9d7a2c9a6 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-move.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-move.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-move.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-move.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-move.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-move.opt.stderr
index 2ab1f80e2d3b..58e9d7a2c9a6 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-move.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-move.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-move.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-move.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-vtable.noopt.stderr b/tests/ui/consts/required-consts/collect-in-dead-vtable.noopt.stderr
index b4e187064892..6c78ca79fd6d 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-vtable.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-vtable.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-vtable.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-vtable.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-dead-vtable.opt.stderr b/tests/ui/consts/required-consts/collect-in-dead-vtable.opt.stderr
index b4e187064892..6c78ca79fd6d 100644
--- a/tests/ui/consts/required-consts/collect-in-dead-vtable.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-dead-vtable.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-dead-vtable.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-dead-vtable.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr b/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr
index a50c49d53625..fd231e1101d1 100644
--- a/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-promoted-const.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-promoted-const.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-promoted-const.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr b/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr
index cf0aa8ef7a73..0f3f77769adf 100644
--- a/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr
+++ b/tests/ui/consts/required-consts/collect-in-promoted-const.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<T>::C` failed
   --> $DIR/collect-in-promoted-const.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-promoted-const.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -16,7 +16,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/collect-in-promoted-const.rs:9:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/collect-in-promoted-const.rs:9:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/interpret-in-const-called-fn.noopt.stderr b/tests/ui/consts/required-consts/interpret-in-const-called-fn.noopt.stderr
index 0e3bbbcc2ec5..d2145089028e 100644
--- a/tests/ui/consts/required-consts/interpret-in-const-called-fn.noopt.stderr
+++ b/tests/ui/consts/required-consts/interpret-in-const-called-fn.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/interpret-in-const-called-fn.rs:8:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/interpret-in-const-called-fn.rs:8:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/interpret-in-const-called-fn.opt.stderr b/tests/ui/consts/required-consts/interpret-in-const-called-fn.opt.stderr
index 0e3bbbcc2ec5..d2145089028e 100644
--- a/tests/ui/consts/required-consts/interpret-in-const-called-fn.opt.stderr
+++ b/tests/ui/consts/required-consts/interpret-in-const-called-fn.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/interpret-in-const-called-fn.rs:8:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/interpret-in-const-called-fn.rs:8:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/interpret-in-promoted.noopt.stderr b/tests/ui/consts/required-consts/interpret-in-promoted.noopt.stderr
index 6ab991b64719..2bd0b92d4c22 100644
--- a/tests/ui/consts/required-consts/interpret-in-promoted.noopt.stderr
+++ b/tests/ui/consts/required-consts/interpret-in-promoted.noopt.stderr
@@ -1,20 +1,16 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/hint.rs:LL:COL
+  --> $DIR/interpret-in-promoted.rs:13:28
    |
-   = note: entering unreachable code
+LL |     let _x: &'static () = &ub();
+   |                            ^^^^ entering unreachable code
    |
-note: inside `unreachable_unchecked`
-  --> $SRC_DIR/core/src/hint.rs:LL:COL
 note: inside `ub`
   --> $DIR/interpret-in-promoted.rs:7:5
    |
 LL |     std::hint::unreachable_unchecked();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `FOO`
-  --> $DIR/interpret-in-promoted.rs:13:28
-   |
-LL |     let _x: &'static () = &ub();
-   |                            ^^^^
+note: inside `unreachable_unchecked`
+  --> $SRC_DIR/core/src/hint.rs:LL:COL
 
 note: erroneous constant encountered
   --> $DIR/interpret-in-promoted.rs:13:27
diff --git a/tests/ui/consts/required-consts/interpret-in-promoted.opt.stderr b/tests/ui/consts/required-consts/interpret-in-promoted.opt.stderr
index 6ab991b64719..2bd0b92d4c22 100644
--- a/tests/ui/consts/required-consts/interpret-in-promoted.opt.stderr
+++ b/tests/ui/consts/required-consts/interpret-in-promoted.opt.stderr
@@ -1,20 +1,16 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/hint.rs:LL:COL
+  --> $DIR/interpret-in-promoted.rs:13:28
    |
-   = note: entering unreachable code
+LL |     let _x: &'static () = &ub();
+   |                            ^^^^ entering unreachable code
    |
-note: inside `unreachable_unchecked`
-  --> $SRC_DIR/core/src/hint.rs:LL:COL
 note: inside `ub`
   --> $DIR/interpret-in-promoted.rs:7:5
    |
 LL |     std::hint::unreachable_unchecked();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-note: inside `FOO`
-  --> $DIR/interpret-in-promoted.rs:13:28
-   |
-LL |     let _x: &'static () = &ub();
-   |                            ^^^^
+note: inside `unreachable_unchecked`
+  --> $SRC_DIR/core/src/hint.rs:LL:COL
 
 note: erroneous constant encountered
   --> $DIR/interpret-in-promoted.rs:13:27
diff --git a/tests/ui/consts/required-consts/interpret-in-promoted.rs b/tests/ui/consts/required-consts/interpret-in-promoted.rs
index 48caece6ff56..2c7b3375054d 100644
--- a/tests/ui/consts/required-consts/interpret-in-promoted.rs
+++ b/tests/ui/consts/required-consts/interpret-in-promoted.rs
@@ -4,13 +4,13 @@
 //! Make sure we evaluate const fn calls even if they get promoted and their result ignored.
 
 const unsafe fn ub() {
-    std::hint::unreachable_unchecked();
+    std::hint::unreachable_unchecked(); //~ inside `ub`
 }
 
 pub const FOO: () = unsafe {
     // Make sure that this gets promoted and then fails to evaluate, and we deal with that
     // correctly.
-    let _x: &'static () = &ub(); //~ erroneous constant
+    let _x: &'static () = &ub(); //~ ERROR evaluation of constant value failed
 };
 
 fn main() {}
diff --git a/tests/ui/consts/required-consts/interpret-in-static.noopt.stderr b/tests/ui/consts/required-consts/interpret-in-static.noopt.stderr
index 5e8da609e766..f999bf370b85 100644
--- a/tests/ui/consts/required-consts/interpret-in-static.noopt.stderr
+++ b/tests/ui/consts/required-consts/interpret-in-static.noopt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/interpret-in-static.rs:8:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/interpret-in-static.rs:8:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/required-consts/interpret-in-static.opt.stderr b/tests/ui/consts/required-consts/interpret-in-static.opt.stderr
index 5e8da609e766..f999bf370b85 100644
--- a/tests/ui/consts/required-consts/interpret-in-static.opt.stderr
+++ b/tests/ui/consts/required-consts/interpret-in-static.opt.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `Fail::<i32>::C` failed
   --> $DIR/interpret-in-static.rs:8:19
    |
 LL |     const C: () = panic!();
-   |                   ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/interpret-in-static.rs:8:19
+   |                   ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/consts/uninhabited-const-issue-61744.rs b/tests/ui/consts/uninhabited-const-issue-61744.rs
index 19ee842c36bf..743aaf58ef5a 100644
--- a/tests/ui/consts/uninhabited-const-issue-61744.rs
+++ b/tests/ui/consts/uninhabited-const-issue-61744.rs
@@ -1,7 +1,7 @@
 //@ build-fail
 
 pub const unsafe fn fake_type<T>() -> T {
-    hint_unreachable() //~ ERROR evaluation of `<i32 as Const>::CONSTANT` failed
+    hint_unreachable() //~ inside
 }
 
 pub const unsafe fn hint_unreachable() -> ! {
@@ -9,7 +9,7 @@ pub const unsafe fn hint_unreachable() -> ! {
 }
 
 trait Const {
-    const CONSTANT: i32 = unsafe { fake_type() }; //~ inside
+    const CONSTANT: i32 = unsafe { fake_type() }; //~ ERROR evaluation of `fake_type::<!>` failed
 }
 
 impl<T> Const for T {}
diff --git a/tests/ui/consts/uninhabited-const-issue-61744.stderr b/tests/ui/consts/uninhabited-const-issue-61744.stderr
index 7575ad730b30..dd175b925934 100644
--- a/tests/ui/consts/uninhabited-const-issue-61744.stderr
+++ b/tests/ui/consts/uninhabited-const-issue-61744.stderr
@@ -1,649 +1,644 @@
-error[E0080]: evaluation of `<i32 as Const>::CONSTANT` failed
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+error[E0080]: evaluation of `fake_type::<!>` failed
+  --> $DIR/uninhabited-const-issue-61744.rs:12:36
    |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^ reached the configured maximum number of stack frames
+LL |     const CONSTANT: i32 = unsafe { fake_type() };
+   |                                    ^^^^^^^^^^^ reached the configured maximum number of stack frames
    |
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
-note: inside `fake_type::<!>`
-  --> $DIR/uninhabited-const-issue-61744.rs:4:5
-   |
-LL |     hint_unreachable()
-   |     ^^^^^^^^^^^^^^^^^^
-note: inside `hint_unreachable`
-  --> $DIR/uninhabited-const-issue-61744.rs:8:5
-   |
-LL |     fake_type()
-   |     ^^^^^^^^^^^
 note: inside `fake_type::<i32>`
   --> $DIR/uninhabited-const-issue-61744.rs:4:5
    |
 LL |     hint_unreachable()
    |     ^^^^^^^^^^^^^^^^^^
-note: inside `<i32 as Const>::CONSTANT`
-  --> $DIR/uninhabited-const-issue-61744.rs:12:36
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
    |
-LL |     const CONSTANT: i32 = unsafe { fake_type() };
-   |                                    ^^^^^^^^^^^
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^
+note: inside `hint_unreachable`
+  --> $DIR/uninhabited-const-issue-61744.rs:8:5
+   |
+LL |     fake_type()
+   |     ^^^^^^^^^^^
+note: inside `fake_type::<!>`
+  --> $DIR/uninhabited-const-issue-61744.rs:4:5
+   |
+LL |     hint_unreachable()
+   |     ^^^^^^^^^^^^^^^^^^ the failure occurred here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/deprecation/deprecation-sanity.rs b/tests/ui/deprecation/deprecation-sanity.rs
index 9ea75b68f81c..d5b149b18ed6 100644
--- a/tests/ui/deprecation/deprecation-sanity.rs
+++ b/tests/ui/deprecation/deprecation-sanity.rs
@@ -4,16 +4,16 @@ mod bogus_attribute_types_1 {
     #[deprecated(since = "a", note = "a", reason)] //~ ERROR unknown meta item 'reason'
     fn f1() { }
 
-    #[deprecated(since = "a", note)] //~ ERROR incorrect meta item
+    #[deprecated(since = "a", note)] //~ ERROR expected a quoted string literal
     fn f2() { }
 
-    #[deprecated(since, note = "a")] //~ ERROR incorrect meta item
+    #[deprecated(since, note = "a")] //~ ERROR expected a quoted string literal
     fn f3() { }
 
-    #[deprecated(since = "a", note(b))] //~ ERROR incorrect meta item
+    #[deprecated(since = "a", note(b))] //~ ERROR expected a quoted string literal
     fn f5() { }
 
-    #[deprecated(since(b), note = "a")] //~ ERROR incorrect meta item
+    #[deprecated(since(b), note = "a")] //~ ERROR expected a quoted string literal
     fn f6() { }
 
     #[deprecated(note = b"test")] //~ ERROR literal in `deprecated` value must be a string
diff --git a/tests/ui/deprecation/deprecation-sanity.stderr b/tests/ui/deprecation/deprecation-sanity.stderr
index 383212ad9b4b..53047d40cb2f 100644
--- a/tests/ui/deprecation/deprecation-sanity.stderr
+++ b/tests/ui/deprecation/deprecation-sanity.stderr
@@ -1,40 +1,28 @@
-error: multiple `deprecated` attributes
-  --> $DIR/deprecation-sanity.rs:27:1
-   |
-LL | #[deprecated(since = "a", note = "b")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/deprecation-sanity.rs:26:1
-   |
-LL | #[deprecated(since = "a", note = "b")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error[E0541]: unknown meta item 'reason'
   --> $DIR/deprecation-sanity.rs:4:43
    |
 LL |     #[deprecated(since = "a", note = "a", reason)]
    |                                           ^^^^^^ expected one of `since`, `note`
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/deprecation-sanity.rs:7:31
    |
 LL |     #[deprecated(since = "a", note)]
    |                               ^^^^
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/deprecation-sanity.rs:10:18
    |
 LL |     #[deprecated(since, note = "a")]
    |                  ^^^^^
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/deprecation-sanity.rs:13:31
    |
 LL |     #[deprecated(since = "a", note(b))]
    |                               ^^^^^^^
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/deprecation-sanity.rs:16:18
    |
 LL |     #[deprecated(since(b), note = "a")]
@@ -54,6 +42,18 @@ error[E0565]: item in `deprecated` must be a key/value pair
 LL |     #[deprecated("test")]
    |                  ^^^^^^
 
+error: multiple `deprecated` attributes
+  --> $DIR/deprecation-sanity.rs:27:1
+   |
+LL | #[deprecated(since = "a", note = "b")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/deprecation-sanity.rs:26:1
+   |
+LL | #[deprecated(since = "a", note = "b")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0538]: multiple 'since' items
   --> $DIR/deprecation-sanity.rs:30:27
    |
diff --git a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.rs b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.rs
index 6653bd15ddd2..c5433151a8fd 100644
--- a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.rs
+++ b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.rs
@@ -3,7 +3,7 @@
 // was a well-formed `MetaItem`.
 
 fn main() {
-    foo()
+    foo() //~ WARNING use of deprecated function `foo`
 }
 
 #[deprecated(note = test)]
diff --git a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
index a030da5068c2..2ff8534b276c 100644
--- a/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
+++ b/tests/ui/deprecation/issue-66340-deprecated-attr-non-meta-grammar.stderr
@@ -9,5 +9,13 @@ help: surround the identifier with quotation marks to make it into a string lite
 LL | #[deprecated(note = "test")]
    |                     +    +
 
-error: aborting due to 1 previous error
+warning: use of deprecated function `foo`
+  --> $DIR/issue-66340-deprecated-attr-non-meta-grammar.rs:6:5
+   |
+LL |     foo()
+   |     ^^^
+   |
+   = note: `#[warn(deprecated)]` on by default
+
+error: aborting due to 1 previous error; 1 warning emitted
 
diff --git a/tests/ui/deref-non-pointer.stderr b/tests/ui/deref-non-pointer.stderr
index 2e5e574fb6c7..3ee354819e5d 100644
--- a/tests/ui/deref-non-pointer.stderr
+++ b/tests/ui/deref-non-pointer.stderr
@@ -2,7 +2,7 @@ error[E0614]: type `{integer}` cannot be dereferenced
   --> $DIR/deref-non-pointer.rs:2:9
    |
 LL |   match *1 {
-   |         ^^
+   |         ^^ can't be dereferenced
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/deriving/deriving-coerce-pointee-neg.rs b/tests/ui/deriving/deriving-coerce-pointee-neg.rs
index 6577500d8eb0..2713366945e9 100644
--- a/tests/ui/deriving/deriving-coerce-pointee-neg.rs
+++ b/tests/ui/deriving/deriving-coerce-pointee-neg.rs
@@ -142,4 +142,27 @@ struct TryToWipeRepr<'a, #[pointee] T: ?Sized> {
     ptr: &'a T,
 }
 
+#[repr(transparent)]
+#[derive(CoercePointee)]
+//~^ ERROR for `RcWithId<T>` to have a valid implementation of `CoerceUnsized`, it must be possible to coerce the field of type `Rc<(i32, Box<T>)>`
+struct RcWithId<T: ?Sized> {
+    inner: std::rc::Rc<(i32, Box<T>)>,
+}
+
+#[repr(transparent)]
+#[derive(CoercePointee)]
+//~^ ERROR implementing `CoerceUnsized` does not allow multiple fields to be coerced
+struct MoreThanOneField<T: ?Sized> {
+    //~^ ERROR transparent struct needs at most one field with non-trivial size or alignment, but has 2
+    inner1: Box<T>,
+    inner2: Box<T>,
+}
+
+struct NotCoercePointeeData<T: ?Sized>(T);
+
+#[repr(transparent)]
+#[derive(CoercePointee)]
+//~^ ERROR for `UsingNonCoercePointeeData<T>` to have a valid implementation of `CoerceUnsized`, it must be possible to coerce the field of type `NotCoercePointeeData<T>`
+struct UsingNonCoercePointeeData<T: ?Sized>(NotCoercePointeeData<T>);
+
 fn main() {}
diff --git a/tests/ui/deriving/deriving-coerce-pointee-neg.stderr b/tests/ui/deriving/deriving-coerce-pointee-neg.stderr
index 999214bfa9fe..d3d731320781 100644
--- a/tests/ui/deriving/deriving-coerce-pointee-neg.stderr
+++ b/tests/ui/deriving/deriving-coerce-pointee-neg.stderr
@@ -118,7 +118,55 @@ error[E0802]: `derive(CoercePointee)` is only applicable to `struct` with `repr(
 LL | struct TryToWipeRepr<'a, #[pointee] T: ?Sized> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error: aborting due to 17 previous errors
+error: for `RcWithId<T>` to have a valid implementation of `CoerceUnsized`, it must be possible to coerce the field of type `Rc<(i32, Box<T>)>`
+  --> $DIR/deriving-coerce-pointee-neg.rs:146:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+...
+LL |     inner: std::rc::Rc<(i32, Box<T>)>,
+   |     --------------------------------- `Rc<(i32, Box<T>)>` must be a pointer, reference, or smart pointer that is allowed to be unsized
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-Some errors have detailed explanations: E0392, E0802.
-For more information about an error, try `rustc --explain E0392`.
+error[E0375]: implementing `CoerceUnsized` does not allow multiple fields to be coerced
+  --> $DIR/deriving-coerce-pointee-neg.rs:153:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+   |
+note: the trait `CoerceUnsized` may only be implemented when a single field is being coerced
+  --> $DIR/deriving-coerce-pointee-neg.rs:157:5
+   |
+LL |     inner1: Box<T>,
+   |     ^^^^^^^^^^^^^^
+LL |     inner2: Box<T>,
+   |     ^^^^^^^^^^^^^^
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: for `UsingNonCoercePointeeData<T>` to have a valid implementation of `CoerceUnsized`, it must be possible to coerce the field of type `NotCoercePointeeData<T>`
+  --> $DIR/deriving-coerce-pointee-neg.rs:164:10
+   |
+LL | #[derive(CoercePointee)]
+   |          ^^^^^^^^^^^^^
+LL |
+LL | struct UsingNonCoercePointeeData<T: ?Sized>(NotCoercePointeeData<T>);
+   |                                             ----------------------- `NotCoercePointeeData<T>` must be a pointer, reference, or smart pointer that is allowed to be unsized
+   |
+   = note: this error originates in the derive macro `CoercePointee` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error[E0690]: transparent struct needs at most one field with non-trivial size or alignment, but has 2
+  --> $DIR/deriving-coerce-pointee-neg.rs:155:1
+   |
+LL | struct MoreThanOneField<T: ?Sized> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ needs at most one field with non-trivial size or alignment, but has 2
+LL |
+LL |     inner1: Box<T>,
+   |     -------------- this field has non-zero size or requires alignment
+LL |     inner2: Box<T>,
+   |     -------------- this field has non-zero size or requires alignment
+
+error: aborting due to 21 previous errors
+
+Some errors have detailed explanations: E0375, E0392, E0690, E0802.
+For more information about an error, try `rustc --explain E0375`.
diff --git a/tests/ui/deriving/deriving-with-helper.rs b/tests/ui/deriving/deriving-with-helper.rs
index c71d553c8927..df98bb6beb9f 100644
--- a/tests/ui/deriving/deriving-with-helper.rs
+++ b/tests/ui/deriving/deriving-with-helper.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ check-pass
 //@ compile-flags: --crate-type=lib
 
@@ -8,6 +9,9 @@
 
 #![no_core]
 
+extern crate minicore;
+use minicore::*;
+
 #[rustc_builtin_macro]
 macro derive() {}
 
@@ -26,9 +30,6 @@ mod default {
     }
 }
 
-#[lang = "sized"]
-trait Sized {}
-
 #[derive(Default)]
 enum S {
     #[default] // OK
diff --git a/tests/ui/diagnostic-width/long-E0529.rs b/tests/ui/diagnostic-width/long-E0529.rs
new file mode 100644
index 000000000000..3ebc4f5f8c82
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0529.rs
@@ -0,0 +1,14 @@
+//@ compile-flags: --diagnostic-width=60 -Zwrite-long-types-to-disk=yes
+// The regex below normalizes the long type file name to make it suitable for compare-modes.
+//@ normalize-stderr: "'\$TEST_BUILD_DIR/.*\.long-type-\d+.txt'" -> "'$$TEST_BUILD_DIR/$$FILE.long-type-hash.txt'"
+type A = (i32, i32, i32, i32);
+type B = (A, A, A, A);
+type C = (B, B, B, B);
+type D = (C, C, C, C);
+
+fn foo(x: D) {
+    let [] = x; //~ ERROR expected an array or slice, found `(...
+    //~^ pattern cannot match with input type `(...
+}
+
+fn main() {}
diff --git a/tests/ui/diagnostic-width/long-E0529.stderr b/tests/ui/diagnostic-width/long-E0529.stderr
new file mode 100644
index 000000000000..da03e5fab2ca
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0529.stderr
@@ -0,0 +1,12 @@
+error[E0529]: expected an array or slice, found `(..., ..., ..., ...)`
+  --> $DIR/long-E0529.rs:10:9
+   |
+LL |     let [] = x;
+   |         ^^ pattern cannot match with input type `(..., ..., ..., ...)`
+   |
+   = note: the full name for the type has been written to '$TEST_BUILD_DIR/$FILE.long-type-hash.txt'
+   = note: consider using `--verbose` to print the full type name to the console
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0529`.
diff --git a/tests/ui/diagnostic-width/long-E0609.rs b/tests/ui/diagnostic-width/long-E0609.rs
new file mode 100644
index 000000000000..39442bdeae03
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0609.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: --diagnostic-width=60 -Zwrite-long-types-to-disk=yes
+// The regex below normalizes the long type file name to make it suitable for compare-modes.
+//@ normalize-stderr: "'\$TEST_BUILD_DIR/.*\.long-type-\d+.txt'" -> "'$$TEST_BUILD_DIR/$$FILE.long-type-hash.txt'"
+type A = (i32, i32, i32, i32);
+type B = (A, A, A, A);
+type C = (B, B, B, B);
+type D = (C, C, C, C);
+
+fn foo(x: D) {
+    x.field; //~ ERROR no field `field` on type `(...
+}
+
+fn main() {}
diff --git a/tests/ui/diagnostic-width/long-E0609.stderr b/tests/ui/diagnostic-width/long-E0609.stderr
new file mode 100644
index 000000000000..6815caa6b6ba
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0609.stderr
@@ -0,0 +1,12 @@
+error[E0609]: no field `field` on type `(..., ..., ..., ...)`
+  --> $DIR/long-E0609.rs:10:7
+   |
+LL |     x.field;
+   |       ^^^^^ unknown field
+   |
+   = note: the full name for the type has been written to '$TEST_BUILD_DIR/$FILE.long-type-hash.txt'
+   = note: consider using `--verbose` to print the full type name to the console
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0609`.
diff --git a/tests/ui/diagnostic-width/long-E0614.rs b/tests/ui/diagnostic-width/long-E0614.rs
new file mode 100644
index 000000000000..0b78444a00d2
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0614.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: --diagnostic-width=60 -Zwrite-long-types-to-disk=yes
+// The regex below normalizes the long type file name to make it suitable for compare-modes.
+//@ normalize-stderr: "'\$TEST_BUILD_DIR/.*\.long-type-\d+.txt'" -> "'$$TEST_BUILD_DIR/$$FILE.long-type-hash.txt'"
+type A = (i32, i32, i32, i32);
+type B = (A, A, A, A);
+type C = (B, B, B, B);
+type D = (C, C, C, C);
+
+fn foo(x: D) {
+    *x; //~ ERROR type `(...
+}
+
+fn main() {}
diff --git a/tests/ui/diagnostic-width/long-E0614.stderr b/tests/ui/diagnostic-width/long-E0614.stderr
new file mode 100644
index 000000000000..1c16ff617faa
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0614.stderr
@@ -0,0 +1,12 @@
+error[E0614]: type `(..., ..., ..., ...)` cannot be dereferenced
+  --> $DIR/long-E0614.rs:10:5
+   |
+LL |     *x;
+   |     ^^ can't be dereferenced
+   |
+   = note: the full name for the type has been written to '$TEST_BUILD_DIR/$FILE.long-type-hash.txt'
+   = note: consider using `--verbose` to print the full type name to the console
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0614`.
diff --git a/tests/ui/diagnostic-width/long-E0618.rs b/tests/ui/diagnostic-width/long-E0618.rs
new file mode 100644
index 000000000000..f8626ab9455e
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0618.rs
@@ -0,0 +1,13 @@
+//@ compile-flags: --diagnostic-width=60 -Zwrite-long-types-to-disk=yes
+// The regex below normalizes the long type file name to make it suitable for compare-modes.
+//@ normalize-stderr: "'\$TEST_BUILD_DIR/.*\.long-type-\d+.txt'" -> "'$$TEST_BUILD_DIR/$$FILE.long-type-hash.txt'"
+type A = (i32, i32, i32, i32);
+type B = (A, A, A, A);
+type C = (B, B, B, B);
+type D = (C, C, C, C);
+
+fn foo(x: D) { //~ `x` has type `(...
+    x(); //~ ERROR expected function, found `(...
+}
+
+fn main() {}
diff --git a/tests/ui/diagnostic-width/long-E0618.stderr b/tests/ui/diagnostic-width/long-E0618.stderr
new file mode 100644
index 000000000000..f0838cbddcc6
--- /dev/null
+++ b/tests/ui/diagnostic-width/long-E0618.stderr
@@ -0,0 +1,16 @@
+error[E0618]: expected function, found `(..., ..., ..., ...)`
+  --> $DIR/long-E0618.rs:10:5
+   |
+LL | fn foo(x: D) {
+   |        - `x` has type `(..., ..., ..., ...)`
+LL |     x();
+   |     ^--
+   |     |
+   |     call expression requires function
+   |
+   = note: the full name for the type has been written to '$TEST_BUILD_DIR/$FILE.long-type-hash.txt'
+   = note: consider using `--verbose` to print the full type name to the console
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0618`.
diff --git a/tests/ui/did_you_mean/recursion_limit_deref.stderr b/tests/ui/did_you_mean/recursion_limit_deref.stderr
index b0c493faf1ef..23341ec6bdc2 100644
--- a/tests/ui/did_you_mean/recursion_limit_deref.stderr
+++ b/tests/ui/did_you_mean/recursion_limit_deref.stderr
@@ -1,3 +1,7 @@
+error: reached the recursion limit finding the struct tail for `K`
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "20"]`
+
 error: reached the recursion limit finding the struct tail for `Bottom`
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "20"]`
@@ -21,7 +25,7 @@ LL |     let x: &Bottom = &t;
    = note: expected reference `&Bottom`
               found reference `&Top`
 
-error: aborting due to 3 previous errors
+error: aborting due to 4 previous errors
 
 Some errors have detailed explanations: E0055, E0308.
 For more information about an error, try `rustc --explain E0055`.
diff --git a/tests/ui/drop/drop-order-comparisons.e2021.stderr b/tests/ui/drop/drop-order-comparisons.e2021.stderr
index 158d18f68826..601b0a38412f 100644
--- a/tests/ui/drop/drop-order-comparisons.e2021.stderr
+++ b/tests/ui/drop/drop-order-comparisons.e2021.stderr
@@ -242,6 +242,15 @@ LL |     _ = (if let Ok(_) = e.ok(4).as_ref() {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:127:5
    |
@@ -267,6 +276,15 @@ LL |     _ = (if let Ok(_) = e.err(4).as_ref() {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:145:44
    |
@@ -291,6 +309,15 @@ LL |         if let Ok(_) = e.err(4).as_ref() {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:247:43
    |
@@ -315,6 +342,15 @@ LL |         if let true = e.err(9).is_ok() {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:352:41
    |
@@ -339,6 +375,15 @@ LL |         if let Ok(_v) = e.err(8) {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:355:35
    |
@@ -363,6 +408,15 @@ LL |         if let Ok(_) = e.err(7) {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:358:34
    |
@@ -387,6 +441,15 @@ LL |         if let Ok(_) = e.err(6).as_ref() {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:361:43
    |
@@ -411,6 +474,15 @@ LL |         if let Ok(_v) = e.err(5) {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:365:35
    |
@@ -435,6 +507,15 @@ LL |         if let Ok(_) = e.err(4) {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:368:34
    |
@@ -459,6 +540,15 @@ LL |         if let Ok(_) = e.err(4).as_ref() {} else {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/drop-order-comparisons.rs:571:1
+   |
+LL | / impl<'b> Drop for LogDrop<'b> {
+LL | |     fn drop(&mut self) {
+LL | |         self.0.mark(self.1);
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/drop-order-comparisons.rs:404:43
    |
diff --git a/tests/ui/drop/lint-if-let-rescope-false-positives.rs b/tests/ui/drop/lint-if-let-rescope-false-positives.rs
new file mode 100644
index 000000000000..77b7df4bc3ba
--- /dev/null
+++ b/tests/ui/drop/lint-if-let-rescope-false-positives.rs
@@ -0,0 +1,33 @@
+//@ edition: 2021
+//@ check-pass
+
+#![deny(if_let_rescope)]
+
+struct Drop;
+impl std::ops::Drop for Drop {
+    fn drop(&mut self) {
+        println!("drop")
+    }
+}
+
+impl Drop {
+    fn as_ref(&self) -> Option<i32> {
+        Some(1)
+    }
+}
+
+fn consume(_: impl Sized) -> Option<i32> { Some(1) }
+
+fn main() {
+    let drop = Drop;
+
+    // Make sure we don't drop if we don't actually make a temporary.
+    if let None = drop.as_ref() {} else {}
+
+    // Make sure we don't lint if we consume the droppy value.
+    if let None = consume(Drop) {} else {}
+
+    // Make sure we don't lint on field exprs of place exprs.
+    let tup_place = (Drop, ());
+    if let None = consume(tup_place.1) {} else {}
+}
diff --git a/tests/ui/drop/lint-if-let-rescope-gated.edition2021.stderr b/tests/ui/drop/lint-if-let-rescope-gated.edition2021.stderr
index 546a5fe0fd04..070ba1c6a4cf 100644
--- a/tests/ui/drop/lint-if-let-rescope-gated.edition2021.stderr
+++ b/tests/ui/drop/lint-if-let-rescope-gated.edition2021.stderr
@@ -8,6 +8,15 @@ LL |     if let Some(_value) = Droppy.get() {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope-gated.rs:14:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope-gated.rs:30:5
    |
diff --git a/tests/ui/drop/lint-if-let-rescope-with-macro.stderr b/tests/ui/drop/lint-if-let-rescope-with-macro.stderr
index 029d5c749293..f1ca0ba57de4 100644
--- a/tests/ui/drop/lint-if-let-rescope-with-macro.stderr
+++ b/tests/ui/drop/lint-if-let-rescope-with-macro.stderr
@@ -15,6 +15,15 @@ LL | |     };
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope-with-macro.rs:22:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope-with-macro.rs:12:38
    |
diff --git a/tests/ui/drop/lint-if-let-rescope.fixed b/tests/ui/drop/lint-if-let-rescope.fixed
index 182190aa323b..79858e6f225a 100644
--- a/tests/ui/drop/lint-if-let-rescope.fixed
+++ b/tests/ui/drop/lint-if-let-rescope.fixed
@@ -94,6 +94,12 @@ fn main() {
         //~| HELP: a `match` with a single arm can preserve the drop order up to Edition 2021
     }
 
+    match Some((droppy(), ()).1) { Some(_value) => {} _ => {}}
+    //~^ ERROR: `if let` assigns a shorter lifetime since Edition 2024
+    //~| WARN: this changes meaning in Rust 2024
+    //~| HELP: the value is now dropped here in Edition 2024
+    //~| HELP: a `match` with a single arm can preserve the drop order up to Edition 2021
+
     // We want to keep the `if let`s below as direct descendents of match arms,
     // so the formatting is suppressed.
     #[rustfmt::skip]
diff --git a/tests/ui/drop/lint-if-let-rescope.rs b/tests/ui/drop/lint-if-let-rescope.rs
index e1b38be0a0f5..9d873c65426f 100644
--- a/tests/ui/drop/lint-if-let-rescope.rs
+++ b/tests/ui/drop/lint-if-let-rescope.rs
@@ -94,6 +94,12 @@ fn main() {
         //~| HELP: a `match` with a single arm can preserve the drop order up to Edition 2021
     }
 
+    if let Some(_value) = Some((droppy(), ()).1) {} else {}
+    //~^ ERROR: `if let` assigns a shorter lifetime since Edition 2024
+    //~| WARN: this changes meaning in Rust 2024
+    //~| HELP: the value is now dropped here in Edition 2024
+    //~| HELP: a `match` with a single arm can preserve the drop order up to Edition 2021
+
     // We want to keep the `if let`s below as direct descendents of match arms,
     // so the formatting is suppressed.
     #[rustfmt::skip]
diff --git a/tests/ui/drop/lint-if-let-rescope.stderr b/tests/ui/drop/lint-if-let-rescope.stderr
index 2b0fcb7a938a..e95ec8fcea7f 100644
--- a/tests/ui/drop/lint-if-let-rescope.stderr
+++ b/tests/ui/drop/lint-if-let-rescope.stderr
@@ -8,6 +8,15 @@ LL |     if let Some(_value) = droppy().get() {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope.rs:32:5
    |
@@ -43,6 +52,24 @@ LL |     } else if let Some(_value) = droppy().get() {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope.rs:42:5
    |
@@ -75,6 +102,15 @@ LL |     } else if let Some(_value) = droppy().get() {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope.rs:54:5
    |
@@ -101,6 +137,15 @@ LL |     if let Some(1) = { if let Some(_value) = Droppy.get() { Some(1) } else
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope.rs:58:69
    |
@@ -122,6 +167,15 @@ LL |     if (if let Some(_value) = droppy().get() { true } else { false }) {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope.rs:72:53
    |
@@ -143,6 +197,15 @@ LL |     } else if (((if let Some(_value) = droppy().get() { true } else { false
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope.rs:78:62
    |
@@ -164,6 +227,15 @@ LL |     while (if let Some(_value) = droppy().get() { false } else { true }) {
    |
    = warning: this changes meaning in Rust 2024
    = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+note: value invokes this custom destructor
+  --> $DIR/lint-if-let-rescope.rs:11:1
+   |
+LL | / impl Drop for Droppy {
+LL | |     fn drop(&mut self) {
+LL | |         println!("dropped");
+LL | |     }
+LL | | }
+   | |_^
 help: the value is now dropped here in Edition 2024
   --> $DIR/lint-if-let-rescope.rs:90:57
    |
@@ -175,5 +247,26 @@ LL -     while (if let Some(_value) = droppy().get() { false } else { true }) {
 LL +     while (match droppy().get() { Some(_value) => { false } _ => { true }}) {
    |
 
-error: aborting due to 7 previous errors
+error: `if let` assigns a shorter lifetime since Edition 2024
+  --> $DIR/lint-if-let-rescope.rs:97:8
+   |
+LL |     if let Some(_value) = Some((droppy(), ()).1) {} else {}
+   |        ^^^^^^^^^^^^^^^^^^^^^^^^--------------^^^
+   |                                |
+   |                                this value has a significant drop implementation which may observe a major change in drop order and requires your discretion
+   |
+   = warning: this changes meaning in Rust 2024
+   = note: for more information, see <https://doc.rust-lang.org/nightly/edition-guide/rust-2024/temporary-if-let-scope.html>
+help: the value is now dropped here in Edition 2024
+  --> $DIR/lint-if-let-rescope.rs:97:51
+   |
+LL |     if let Some(_value) = Some((droppy(), ()).1) {} else {}
+   |                                                   ^
+help: a `match` with a single arm can preserve the drop order up to Edition 2021
+   |
+LL -     if let Some(_value) = Some((droppy(), ()).1) {} else {}
+LL +     match Some((droppy(), ()).1) { Some(_value) => {} _ => {}}
+   |
+
+error: aborting due to 8 previous errors
 
diff --git a/tests/ui/dropck/dropck-after-failed-type-lowering.rs b/tests/ui/dropck/dropck-after-failed-type-lowering.rs
new file mode 100644
index 000000000000..2441e26fec96
--- /dev/null
+++ b/tests/ui/dropck/dropck-after-failed-type-lowering.rs
@@ -0,0 +1,14 @@
+// Regression test for #137329
+
+trait B {
+    type C<'a>;
+    fn d<E>() -> F<E> {
+        todo!()
+    }
+}
+struct F<G> {
+    h: Option<<G as B>::C>,
+    //~^ ERROR missing generics for associated type `B::C`
+}
+
+fn main() {}
diff --git a/tests/ui/dropck/dropck-after-failed-type-lowering.stderr b/tests/ui/dropck/dropck-after-failed-type-lowering.stderr
new file mode 100644
index 000000000000..56ea72de0c5f
--- /dev/null
+++ b/tests/ui/dropck/dropck-after-failed-type-lowering.stderr
@@ -0,0 +1,19 @@
+error[E0107]: missing generics for associated type `B::C`
+  --> $DIR/dropck-after-failed-type-lowering.rs:10:25
+   |
+LL |     h: Option<<G as B>::C>,
+   |                         ^ expected 1 lifetime argument
+   |
+note: associated type defined here, with 1 lifetime parameter: `'a`
+  --> $DIR/dropck-after-failed-type-lowering.rs:4:10
+   |
+LL |     type C<'a>;
+   |          ^ --
+help: add missing lifetime argument
+   |
+LL |     h: Option<<G as B>::C<'a>>,
+   |                          ++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0107`.
diff --git a/tests/ui/dyn-compatibility/associated-consts.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/associated-consts.dyn_compatible_for_dispatch.stderr
deleted file mode 100644
index 704d833f00ba..000000000000
--- a/tests/ui/dyn-compatibility/associated-consts.dyn_compatible_for_dispatch.stderr
+++ /dev/null
@@ -1,20 +0,0 @@
-error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/associated-consts.rs:14:5
-   |
-LL |     t
-   |     ^ `Bar` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/associated-consts.rs:9:11
-   |
-LL | trait Bar {
-   |       --- this trait is not dyn compatible...
-LL |     const X: usize;
-   |           ^ ...because it contains this associated `const`
-   = help: consider moving `X` to another trait
-   = note: required for the cast from `&T` to `&dyn Bar`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/associated-consts.rs b/tests/ui/dyn-compatibility/associated-consts.rs
index fc7b372b782a..10d151d9a8b5 100644
--- a/tests/ui/dyn-compatibility/associated-consts.rs
+++ b/tests/ui/dyn-compatibility/associated-consts.rs
@@ -1,16 +1,12 @@
 // Check that we correctly prevent users from making trait objects
 // from traits with associated consts.
-//
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
 
 trait Bar {
     const X: usize;
 }
 
 fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     t
     //~^ ERROR E0038
 }
diff --git a/tests/ui/dyn-compatibility/generics.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/associated-consts.stderr
similarity index 61%
rename from tests/ui/dyn-compatibility/generics.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/associated-consts.stderr
index b3565a766fe1..beaf263af07e 100644
--- a/tests/ui/dyn-compatibility/generics.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/associated-consts.stderr
@@ -1,35 +1,34 @@
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/generics.rs:20:5
+  --> $DIR/associated-consts.rs:8:31
+   |
+LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
+   |                               ^^^^^^^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/associated-consts.rs:5:11
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     const X: usize;
+   |           ^ ...because it contains this associated `const`
+   = help: consider moving `X` to another trait
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/associated-consts.rs:10:5
    |
 LL |     t
    |     ^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/generics.rs:10:8
+  --> $DIR/associated-consts.rs:5:11
    |
 LL | trait Bar {
    |       --- this trait is not dyn compatible...
-LL |     fn bar<T>(&self, t: T);
-   |        ^^^ ...because method `bar` has generic type parameters
-   = help: consider moving `bar` to another trait
-   = note: required for the cast from `&T` to `&dyn Bar`
-
-error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/generics.rs:27:5
-   |
-LL |     t as &dyn Bar
-   |     ^ `Bar` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/generics.rs:10:8
-   |
-LL | trait Bar {
-   |       --- this trait is not dyn compatible...
-LL |     fn bar<T>(&self, t: T);
-   |        ^^^ ...because method `bar` has generic type parameters
-   = help: consider moving `bar` to another trait
+LL |     const X: usize;
+   |           ^ ...because it contains this associated `const`
+   = help: consider moving `X` to another trait
    = note: required for the cast from `&T` to `&dyn Bar`
 
 error: aborting due to 2 previous errors
diff --git a/tests/ui/dyn-compatibility/generics.rs b/tests/ui/dyn-compatibility/generics.rs
index b51555aa500c..dcce17f925bc 100644
--- a/tests/ui/dyn-compatibility/generics.rs
+++ b/tests/ui/dyn-compatibility/generics.rs
@@ -1,9 +1,6 @@
 // Check that we correctly prevent users from making trait objects
 // from traits with generic methods, unless `where Self : Sized` is
 // present.
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
 
 
 trait Bar {
@@ -16,18 +13,16 @@ trait Quux {
 }
 
 fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     t
-    //[dyn_compatible_for_dispatch]~^ ERROR E0038
-    //[curr]~^^ ERROR E0038
+    //~^ ERROR E0038
 }
 
 fn make_bar_explicit<T:Bar>(t: &T) -> &dyn Bar {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     t as &dyn Bar
-    //[dyn_compatible_for_dispatch]~^ ERROR E0038
-    //[curr]~^^ ERROR E0038
-    //[curr]~| ERROR E0038
+    //~^ ERROR E0038
+    //~| ERROR E0038
 }
 
 fn make_quux<T:Quux>(t: &T) -> &dyn Quux {
diff --git a/tests/ui/dyn-compatibility/generics.stderr b/tests/ui/dyn-compatibility/generics.stderr
new file mode 100644
index 000000000000..c01930105419
--- /dev/null
+++ b/tests/ui/dyn-compatibility/generics.stderr
@@ -0,0 +1,85 @@
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/generics.rs:15:31
+   |
+LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
+   |                               ^^^^^^^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/generics.rs:7:8
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar<T>(&self, t: T);
+   |        ^^^ ...because method `bar` has generic type parameters
+   = help: consider moving `bar` to another trait
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/generics.rs:21:40
+   |
+LL | fn make_bar_explicit<T:Bar>(t: &T) -> &dyn Bar {
+   |                                        ^^^^^^^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/generics.rs:7:8
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar<T>(&self, t: T);
+   |        ^^^ ...because method `bar` has generic type parameters
+   = help: consider moving `bar` to another trait
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/generics.rs:17:5
+   |
+LL |     t
+   |     ^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/generics.rs:7:8
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar<T>(&self, t: T);
+   |        ^^^ ...because method `bar` has generic type parameters
+   = help: consider moving `bar` to another trait
+   = note: required for the cast from `&T` to `&dyn Bar`
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/generics.rs:23:10
+   |
+LL |     t as &dyn Bar
+   |          ^^^^^^^^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/generics.rs:7:8
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar<T>(&self, t: T);
+   |        ^^^ ...because method `bar` has generic type parameters
+   = help: consider moving `bar` to another trait
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/generics.rs:23:5
+   |
+LL |     t as &dyn Bar
+   |     ^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/generics.rs:7:8
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar<T>(&self, t: T);
+   |        ^^^ ...because method `bar` has generic type parameters
+   = help: consider moving `bar` to another trait
+   = note: required for the cast from `&T` to `&dyn Bar`
+
+error: aborting due to 5 previous errors
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/mentions-Self.curr.stderr b/tests/ui/dyn-compatibility/mentions-Self.curr.stderr
index 2d3fe5ce636c..6d1ae90152e6 100644
--- a/tests/ui/dyn-compatibility/mentions-Self.curr.stderr
+++ b/tests/ui/dyn-compatibility/mentions-Self.curr.stderr
@@ -1,12 +1,12 @@
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/mentions-Self.rs:22:31
+  --> $DIR/mentions-Self.rs:18:31
    |
 LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
    |                               ^^^^^^^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/mentions-Self.rs:11:22
+  --> $DIR/mentions-Self.rs:7:22
    |
 LL | trait Bar {
    |       --- this trait is not dyn compatible...
@@ -15,14 +15,14 @@ LL |     fn bar(&self, x: &Self);
    = help: consider moving `bar` to another trait
 
 error[E0038]: the trait `Baz` is not dyn compatible
-  --> $DIR/mentions-Self.rs:28:31
+  --> $DIR/mentions-Self.rs:24:31
    |
 LL | fn make_baz<T:Baz>(t: &T) -> &dyn Baz {
    |                               ^^^^^^^ `Baz` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/mentions-Self.rs:15:22
+  --> $DIR/mentions-Self.rs:11:22
    |
 LL | trait Baz {
    |       --- this trait is not dyn compatible...
@@ -31,14 +31,14 @@ LL |     fn baz(&self) -> Self;
    = help: consider moving `baz` to another trait
 
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/mentions-Self.rs:24:5
+  --> $DIR/mentions-Self.rs:20:5
    |
 LL |     t
    |     ^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/mentions-Self.rs:11:22
+  --> $DIR/mentions-Self.rs:7:22
    |
 LL | trait Bar {
    |       --- this trait is not dyn compatible...
@@ -48,14 +48,14 @@ LL |     fn bar(&self, x: &Self);
    = note: required for the cast from `&T` to `&dyn Bar`
 
 error[E0038]: the trait `Baz` is not dyn compatible
-  --> $DIR/mentions-Self.rs:30:5
+  --> $DIR/mentions-Self.rs:26:5
    |
 LL |     t
    |     ^ `Baz` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/mentions-Self.rs:15:22
+  --> $DIR/mentions-Self.rs:11:22
    |
 LL | trait Baz {
    |       --- this trait is not dyn compatible...
diff --git a/tests/ui/dyn-compatibility/mentions-Self.rs b/tests/ui/dyn-compatibility/mentions-Self.rs
index 84c229e252d3..ce210f4776f7 100644
--- a/tests/ui/dyn-compatibility/mentions-Self.rs
+++ b/tests/ui/dyn-compatibility/mentions-Self.rs
@@ -1,10 +1,6 @@
 // Check that we correctly prevent users from making trait objects
 // form traits that make use of `Self` in an argument or return
 // position, unless `where Self : Sized` is present..
-//
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
 
 
 trait Bar {
@@ -20,13 +16,13 @@ trait Quux {
 }
 
 fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     t
     //~^ ERROR E0038
 }
 
 fn make_baz<T:Baz>(t: &T) -> &dyn Baz {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     t
     //~^ ERROR E0038
 }
diff --git a/tests/ui/dyn-compatibility/mentions-Self.stderr b/tests/ui/dyn-compatibility/mentions-Self.stderr
new file mode 100644
index 000000000000..6d1ae90152e6
--- /dev/null
+++ b/tests/ui/dyn-compatibility/mentions-Self.stderr
@@ -0,0 +1,69 @@
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/mentions-Self.rs:18:31
+   |
+LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
+   |                               ^^^^^^^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/mentions-Self.rs:7:22
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar(&self, x: &Self);
+   |                      ^^^^^ ...because method `bar` references the `Self` type in this parameter
+   = help: consider moving `bar` to another trait
+
+error[E0038]: the trait `Baz` is not dyn compatible
+  --> $DIR/mentions-Self.rs:24:31
+   |
+LL | fn make_baz<T:Baz>(t: &T) -> &dyn Baz {
+   |                               ^^^^^^^ `Baz` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/mentions-Self.rs:11:22
+   |
+LL | trait Baz {
+   |       --- this trait is not dyn compatible...
+LL |     fn baz(&self) -> Self;
+   |                      ^^^^ ...because method `baz` references the `Self` type in its return type
+   = help: consider moving `baz` to another trait
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/mentions-Self.rs:20:5
+   |
+LL |     t
+   |     ^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/mentions-Self.rs:7:22
+   |
+LL | trait Bar {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar(&self, x: &Self);
+   |                      ^^^^^ ...because method `bar` references the `Self` type in this parameter
+   = help: consider moving `bar` to another trait
+   = note: required for the cast from `&T` to `&dyn Bar`
+
+error[E0038]: the trait `Baz` is not dyn compatible
+  --> $DIR/mentions-Self.rs:26:5
+   |
+LL |     t
+   |     ^ `Baz` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/mentions-Self.rs:11:22
+   |
+LL | trait Baz {
+   |       --- this trait is not dyn compatible...
+LL |     fn baz(&self) -> Self;
+   |                      ^^^^ ...because method `baz` references the `Self` type in its return type
+   = help: consider moving `baz` to another trait
+   = note: required for the cast from `&T` to `&dyn Baz`
+
+error: aborting due to 4 previous errors
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/no-static.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/no-static.dyn_compatible_for_dispatch.stderr
deleted file mode 100644
index d5ad45103346..000000000000
--- a/tests/ui/dyn-compatibility/no-static.dyn_compatible_for_dispatch.stderr
+++ /dev/null
@@ -1,28 +0,0 @@
-error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/no-static.rs:22:27
-   |
-LL |     let b: Box<dyn Foo> = Box::new(Bar);
-   |                           ^^^^^^^^^^^^^ `Foo` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/no-static.rs:9:8
-   |
-LL | trait Foo {
-   |       --- this trait is not dyn compatible...
-LL |     fn foo() {}
-   |        ^^^ ...because associated function `foo` has no `self` parameter
-   = help: only type `Bar` implements `Foo`; consider using it directly instead.
-   = note: required for the cast from `Box<Bar>` to `Box<dyn Foo>`
-help: consider turning `foo` into a method by giving it a `&self` argument
-   |
-LL |     fn foo(&self) {}
-   |            +++++
-help: alternatively, consider constraining `foo` so it does not apply to trait objects
-   |
-LL |     fn foo() where Self: Sized {}
-   |              +++++++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/no-static.rs b/tests/ui/dyn-compatibility/no-static.rs
index 54af16fe18eb..9bd871619728 100644
--- a/tests/ui/dyn-compatibility/no-static.rs
+++ b/tests/ui/dyn-compatibility/no-static.rs
@@ -1,16 +1,12 @@
 // Check that we correctly prevent users from making trait objects
 // from traits with static methods.
-//
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
 
 trait Foo {
     fn foo() {}
 }
 
 fn diverges() -> Box<dyn Foo> {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     loop { }
 }
 
@@ -21,5 +17,5 @@ impl Foo for Bar {}
 fn main() {
     let b: Box<dyn Foo> = Box::new(Bar);
     //~^ ERROR E0038
-    //[curr]~| ERROR E0038
+    //~| ERROR E0038
 }
diff --git a/tests/ui/dyn-compatibility/no-static.stderr b/tests/ui/dyn-compatibility/no-static.stderr
new file mode 100644
index 000000000000..814ab0d53c3f
--- /dev/null
+++ b/tests/ui/dyn-compatibility/no-static.stderr
@@ -0,0 +1,76 @@
+error[E0038]: the trait `Foo` is not dyn compatible
+  --> $DIR/no-static.rs:8:22
+   |
+LL | fn diverges() -> Box<dyn Foo> {
+   |                      ^^^^^^^ `Foo` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/no-static.rs:5:8
+   |
+LL | trait Foo {
+   |       --- this trait is not dyn compatible...
+LL |     fn foo() {}
+   |        ^^^ ...because associated function `foo` has no `self` parameter
+   = help: only type `Bar` implements `Foo`; consider using it directly instead.
+help: consider turning `foo` into a method by giving it a `&self` argument
+   |
+LL |     fn foo(&self) {}
+   |            +++++
+help: alternatively, consider constraining `foo` so it does not apply to trait objects
+   |
+LL |     fn foo() where Self: Sized {}
+   |              +++++++++++++++++
+
+error[E0038]: the trait `Foo` is not dyn compatible
+  --> $DIR/no-static.rs:18:12
+   |
+LL |     let b: Box<dyn Foo> = Box::new(Bar);
+   |            ^^^^^^^^^^^^ `Foo` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/no-static.rs:5:8
+   |
+LL | trait Foo {
+   |       --- this trait is not dyn compatible...
+LL |     fn foo() {}
+   |        ^^^ ...because associated function `foo` has no `self` parameter
+   = help: only type `Bar` implements `Foo`; consider using it directly instead.
+help: consider turning `foo` into a method by giving it a `&self` argument
+   |
+LL |     fn foo(&self) {}
+   |            +++++
+help: alternatively, consider constraining `foo` so it does not apply to trait objects
+   |
+LL |     fn foo() where Self: Sized {}
+   |              +++++++++++++++++
+
+error[E0038]: the trait `Foo` is not dyn compatible
+  --> $DIR/no-static.rs:18:27
+   |
+LL |     let b: Box<dyn Foo> = Box::new(Bar);
+   |                           ^^^^^^^^^^^^^ `Foo` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/no-static.rs:5:8
+   |
+LL | trait Foo {
+   |       --- this trait is not dyn compatible...
+LL |     fn foo() {}
+   |        ^^^ ...because associated function `foo` has no `self` parameter
+   = help: only type `Bar` implements `Foo`; consider using it directly instead.
+   = note: required for the cast from `Box<Bar>` to `Box<dyn Foo>`
+help: consider turning `foo` into a method by giving it a `&self` argument
+   |
+LL |     fn foo(&self) {}
+   |            +++++
+help: alternatively, consider constraining `foo` so it does not apply to trait objects
+   |
+LL |     fn foo() where Self: Sized {}
+   |              +++++++++++++++++
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/sized-2.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/sized-2.dyn_compatible_for_dispatch.stderr
deleted file mode 100644
index 1fbc10c0c3f8..000000000000
--- a/tests/ui/dyn-compatibility/sized-2.dyn_compatible_for_dispatch.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/sized-2.rs:16:5
-   |
-LL |     t
-   |     ^ `Bar` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/sized-2.rs:9:18
-   |
-LL | trait Bar
-   |       --- this trait is not dyn compatible...
-LL |     where Self : Sized
-   |                  ^^^^^ ...because it requires `Self: Sized`
-   = note: required for the cast from `&T` to `&dyn Bar`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/sized-2.rs b/tests/ui/dyn-compatibility/sized-2.rs
index f5edd287f24d..f61d49ee8dff 100644
--- a/tests/ui/dyn-compatibility/sized-2.rs
+++ b/tests/ui/dyn-compatibility/sized-2.rs
@@ -1,9 +1,5 @@
 // Check that we correctly prevent users from making trait objects
 // from traits where `Self : Sized`.
-//
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
 
 trait Bar
     where Self : Sized
@@ -12,7 +8,7 @@ trait Bar
 }
 
 fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     t
     //~^ ERROR E0038
 }
diff --git a/tests/ui/dyn-compatibility/mentions-Self.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/sized-2.stderr
similarity index 52%
rename from tests/ui/dyn-compatibility/mentions-Self.dyn_compatible_for_dispatch.stderr
rename to tests/ui/dyn-compatibility/sized-2.stderr
index 91c26a860259..1834d906bb89 100644
--- a/tests/ui/dyn-compatibility/mentions-Self.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/dyn-compatibility/sized-2.stderr
@@ -1,37 +1,34 @@
 error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/mentions-Self.rs:24:5
+  --> $DIR/sized-2.rs:10:31
+   |
+LL | fn make_bar<T:Bar>(t: &T) -> &dyn Bar {
+   |                               ^^^^^^^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/sized-2.rs:5:18
+   |
+LL | trait Bar
+   |       --- this trait is not dyn compatible...
+LL |     where Self : Sized
+   |                  ^^^^^ ...because it requires `Self: Sized`
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/sized-2.rs:12:5
    |
 LL |     t
    |     ^ `Bar` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/mentions-Self.rs:11:22
+  --> $DIR/sized-2.rs:5:18
    |
-LL | trait Bar {
+LL | trait Bar
    |       --- this trait is not dyn compatible...
-LL |     fn bar(&self, x: &Self);
-   |                      ^^^^^ ...because method `bar` references the `Self` type in this parameter
-   = help: consider moving `bar` to another trait
+LL |     where Self : Sized
+   |                  ^^^^^ ...because it requires `Self: Sized`
    = note: required for the cast from `&T` to `&dyn Bar`
 
-error[E0038]: the trait `Baz` is not dyn compatible
-  --> $DIR/mentions-Self.rs:30:5
-   |
-LL |     t
-   |     ^ `Baz` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/mentions-Self.rs:15:22
-   |
-LL | trait Baz {
-   |       --- this trait is not dyn compatible...
-LL |     fn baz(&self) -> Self;
-   |                      ^^^^ ...because method `baz` references the `Self` type in its return type
-   = help: consider moving `baz` to another trait
-   = note: required for the cast from `&T` to `&dyn Baz`
-
 error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/sized.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/sized.dyn_compatible_for_dispatch.stderr
deleted file mode 100644
index 350c8992c6f9..000000000000
--- a/tests/ui/dyn-compatibility/sized.dyn_compatible_for_dispatch.stderr
+++ /dev/null
@@ -1,19 +0,0 @@
-error[E0038]: the trait `Bar` is not dyn compatible
-  --> $DIR/sized.rs:14:5
-   |
-LL |     t
-   |     ^ `Bar` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/sized.rs:8:12
-   |
-LL | trait Bar: Sized {
-   |       ---  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = note: required for the cast from `&T` to `&dyn Bar`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/sized.rs b/tests/ui/dyn-compatibility/sized.rs
index 4c4fe3f8f259..eb5279c17e62 100644
--- a/tests/ui/dyn-compatibility/sized.rs
+++ b/tests/ui/dyn-compatibility/sized.rs
@@ -1,16 +1,12 @@
 // Check that we correctly prevent users from making trait objects
 // from traits where `Self : Sized`.
-//
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
 
 trait Bar: Sized {
     fn bar<T>(&self, t: T);
 }
 
 fn make_bar<T: Bar>(t: &T) -> &dyn Bar {
-    //[curr]~^ ERROR E0038
+    //~^ ERROR E0038
     t
     //~^ ERROR E0038
 }
diff --git a/tests/ui/dyn-compatibility/sized.stderr b/tests/ui/dyn-compatibility/sized.stderr
new file mode 100644
index 000000000000..c66e299cf6f5
--- /dev/null
+++ b/tests/ui/dyn-compatibility/sized.stderr
@@ -0,0 +1,34 @@
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/sized.rs:8:32
+   |
+LL | fn make_bar<T: Bar>(t: &T) -> &dyn Bar {
+   |                                ^^^^^^^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/sized.rs:4:12
+   |
+LL | trait Bar: Sized {
+   |       ---  ^^^^^ ...because it requires `Self: Sized`
+   |       |
+   |       this trait is not dyn compatible...
+
+error[E0038]: the trait `Bar` is not dyn compatible
+  --> $DIR/sized.rs:10:5
+   |
+LL |     t
+   |     ^ `Bar` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/sized.rs:4:12
+   |
+LL | trait Bar: Sized {
+   |       ---  ^^^^^ ...because it requires `Self: Sized`
+   |       |
+   |       this trait is not dyn compatible...
+   = note: required for the cast from `&T` to `&dyn Bar`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/taint-const-eval.dyn_compatible_for_dispatch.stderr b/tests/ui/dyn-compatibility/taint-const-eval.dyn_compatible_for_dispatch.stderr
deleted file mode 100644
index 0bc7d0b14d3d..000000000000
--- a/tests/ui/dyn-compatibility/taint-const-eval.dyn_compatible_for_dispatch.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0038]: the trait `Qux` is not dyn compatible
-  --> $DIR/taint-const-eval.rs:11:33
-   |
-LL | static FOO: &(dyn Qux + Sync) = "desc";
-   |                                 ^^^^^^ `Qux` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/taint-const-eval.rs:8:8
-   |
-LL | trait Qux {
-   |       --- this trait is not dyn compatible...
-LL |     fn bar();
-   |        ^^^ ...because associated function `bar` has no `self` parameter
-   = note: required for the cast from `&'static str` to `&'static (dyn Qux + Sync + 'static)`
-help: consider turning `bar` into a method by giving it a `&self` argument
-   |
-LL |     fn bar(&self);
-   |            +++++
-help: alternatively, consider constraining `bar` so it does not apply to trait objects
-   |
-LL |     fn bar() where Self: Sized;
-   |              +++++++++++++++++
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/dyn-compatibility/taint-const-eval.rs b/tests/ui/dyn-compatibility/taint-const-eval.rs
index 2feae58080bc..7ea763e18469 100644
--- a/tests/ui/dyn-compatibility/taint-const-eval.rs
+++ b/tests/ui/dyn-compatibility/taint-const-eval.rs
@@ -1,16 +1,12 @@
 // Test that we do not attempt to create dyn-incompatible trait objects in const eval.
 
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
-
 trait Qux {
     fn bar();
 }
 
 static FOO: &(dyn Qux + Sync) = "desc";
 //~^ the trait `Qux` is not dyn compatible
-//[curr]~| the trait `Qux` is not dyn compatible
-//[curr]~| the trait `Qux` is not dyn compatible
+//~| the trait `Qux` is not dyn compatible
+//~| the trait `Qux` is not dyn compatible
 
 fn main() {}
diff --git a/tests/ui/dyn-compatibility/taint-const-eval.stderr b/tests/ui/dyn-compatibility/taint-const-eval.stderr
new file mode 100644
index 000000000000..942c20db6ce0
--- /dev/null
+++ b/tests/ui/dyn-compatibility/taint-const-eval.stderr
@@ -0,0 +1,74 @@
+error[E0038]: the trait `Qux` is not dyn compatible
+  --> $DIR/taint-const-eval.rs:7:15
+   |
+LL | static FOO: &(dyn Qux + Sync) = "desc";
+   |               ^^^^^^^^^^^^^^ `Qux` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/taint-const-eval.rs:4:8
+   |
+LL | trait Qux {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar();
+   |        ^^^ ...because associated function `bar` has no `self` parameter
+help: consider turning `bar` into a method by giving it a `&self` argument
+   |
+LL |     fn bar(&self);
+   |            +++++
+help: alternatively, consider constraining `bar` so it does not apply to trait objects
+   |
+LL |     fn bar() where Self: Sized;
+   |              +++++++++++++++++
+
+error[E0038]: the trait `Qux` is not dyn compatible
+  --> $DIR/taint-const-eval.rs:7:33
+   |
+LL | static FOO: &(dyn Qux + Sync) = "desc";
+   |                                 ^^^^^^ `Qux` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/taint-const-eval.rs:4:8
+   |
+LL | trait Qux {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar();
+   |        ^^^ ...because associated function `bar` has no `self` parameter
+   = note: required for the cast from `&'static str` to `&'static (dyn Qux + Sync + 'static)`
+help: consider turning `bar` into a method by giving it a `&self` argument
+   |
+LL |     fn bar(&self);
+   |            +++++
+help: alternatively, consider constraining `bar` so it does not apply to trait objects
+   |
+LL |     fn bar() where Self: Sized;
+   |              +++++++++++++++++
+
+error[E0038]: the trait `Qux` is not dyn compatible
+  --> $DIR/taint-const-eval.rs:7:15
+   |
+LL | static FOO: &(dyn Qux + Sync) = "desc";
+   |               ^^^^^^^^^^^^^^ `Qux` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/taint-const-eval.rs:4:8
+   |
+LL | trait Qux {
+   |       --- this trait is not dyn compatible...
+LL |     fn bar();
+   |        ^^^ ...because associated function `bar` has no `self` parameter
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+help: consider turning `bar` into a method by giving it a `&self` argument
+   |
+LL |     fn bar(&self);
+   |            +++++
+help: alternatively, consider constraining `bar` so it does not apply to trait objects
+   |
+LL |     fn bar() where Self: Sized;
+   |              +++++++++++++++++
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/error-codes/E0084.stderr b/tests/ui/error-codes/E0084.stderr
index f1fbe6c2532b..3df2e4a322b2 100644
--- a/tests/ui/error-codes/E0084.stderr
+++ b/tests/ui/error-codes/E0084.stderr
@@ -1,8 +1,8 @@
 error[E0084]: unsupported representation for zero-variant enum
-  --> $DIR/E0084.rs:1:1
+  --> $DIR/E0084.rs:1:8
    |
 LL | #[repr(i32)]
-   | ^^^^^^^^^^^^
+   |        ^^^
 LL | enum Foo {}
    | -------- zero-variant enum
 
diff --git a/tests/ui/error-codes/E0094.rs b/tests/ui/error-codes/E0094.rs
index da59d3decac7..2067179b26aa 100644
--- a/tests/ui/error-codes/E0094.rs
+++ b/tests/ui/error-codes/E0094.rs
@@ -1,10 +1,7 @@
 #![feature(intrinsics)]
 
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-fn size_of<T, U>() -> usize {
-    //~^ ERROR E0094
-    loop {}
-}
+fn size_of<T, U>() -> usize;
+//~^ ERROR E0094
 
 fn main() {}
diff --git a/tests/ui/error-codes/E0094.stderr b/tests/ui/error-codes/E0094.stderr
index e45cc0ea0639..da29987f8b1b 100644
--- a/tests/ui/error-codes/E0094.stderr
+++ b/tests/ui/error-codes/E0094.stderr
@@ -1,7 +1,7 @@
 error[E0094]: intrinsic has wrong number of type parameters: found 2, expected 1
-  --> $DIR/E0094.rs:5:11
+  --> $DIR/E0094.rs:4:11
    |
-LL | fn size_of<T, U>() -> usize {
+LL | fn size_of<T, U>() -> usize;
    |           ^^^^^^ expected 1 type parameter
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/error-codes/E0308.rs b/tests/ui/error-codes/E0308.rs
index f8f93d49a8ee..c27d42454718 100644
--- a/tests/ui/error-codes/E0308.rs
+++ b/tests/ui/error-codes/E0308.rs
@@ -2,10 +2,7 @@
 #![feature(rustc_attrs)]
 
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-fn size_of<T>() {
-    //~^ ERROR E0308
-    loop {}
-}
+fn size_of<T>();
+//~^ ERROR E0308
 
 fn main() {}
diff --git a/tests/ui/error-codes/E0308.stderr b/tests/ui/error-codes/E0308.stderr
index 77e5c06e06a7..a1077481a816 100644
--- a/tests/ui/error-codes/E0308.stderr
+++ b/tests/ui/error-codes/E0308.stderr
@@ -1,7 +1,7 @@
 error[E0308]: intrinsic has wrong type
-  --> $DIR/E0308.rs:6:16
+  --> $DIR/E0308.rs:5:16
    |
-LL | fn size_of<T>() {
+LL | fn size_of<T>();
    |                ^ expected `usize`, found `()`
    |
    = note: expected signature `fn() -> usize`
diff --git a/tests/ui/error-codes/E0374.stderr b/tests/ui/error-codes/E0374.stderr
index 71eec4c16fd3..95e6b95e0d56 100644
--- a/tests/ui/error-codes/E0374.stderr
+++ b/tests/ui/error-codes/E0374.stderr
@@ -6,7 +6,7 @@ LL | struct Foo<T: ?Sized> {
    |
    = help: consider removing `T`, referring to it in a field, or using a marker such as `PhantomData`
 
-error[E0374]: the trait `CoerceUnsized` may only be implemented for a coercion between structures
+error[E0374]: implementing `CoerceUnsized` requires a field to be coerced
   --> $DIR/E0374.rs:8:1
    |
 LL | / impl<T, U> CoerceUnsized<Foo<U>> for Foo<T>
diff --git a/tests/ui/error-codes/E0375.stderr b/tests/ui/error-codes/E0375.stderr
index af720bd40e7e..a797ba9d4612 100644
--- a/tests/ui/error-codes/E0375.stderr
+++ b/tests/ui/error-codes/E0375.stderr
@@ -23,14 +23,19 @@ help: the `Box` type always has a statically known size and allocates its conten
 LL |     b: Box<T>,
    |        ++++ +
 
-error[E0375]: implementing the trait `CoerceUnsized` requires multiple coercions
+error[E0375]: implementing `CoerceUnsized` does not allow multiple fields to be coerced
   --> $DIR/E0375.rs:10:12
    |
 LL | impl<T, U> CoerceUnsized<Foo<U, T>> for Foo<T, U> {}
-   |            ^^^^^^^^^^^^^^^^^^^^^^^^ requires multiple coercions
+   |            ^^^^^^^^^^^^^^^^^^^^^^^^
    |
-   = note: `CoerceUnsized` may only be implemented for a coercion between structures with one field being coerced
-   = note: currently, 2 fields need coercions: `b` (`T` to `U`), `c` (`U` to `T`)
+note: the trait `CoerceUnsized` may only be implemented when a single field is being coerced
+  --> $DIR/E0375.rs:6:5
+   |
+LL |     b: T,
+   |     ^^^^
+LL |     c: U,
+   |     ^^^^
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/error-codes/E0376.rs b/tests/ui/error-codes/E0376.rs
deleted file mode 100644
index f092eb02c2bc..000000000000
--- a/tests/ui/error-codes/E0376.rs
+++ /dev/null
@@ -1,10 +0,0 @@
-#![feature(coerce_unsized)]
-use std::ops::CoerceUnsized;
-
-struct Foo<T: ?Sized> {
-    a: T,
-}
-
-impl<T, U> CoerceUnsized<U> for Foo<T> {} //~ ERROR E0376
-
-fn main() {}
diff --git a/tests/ui/error-codes/E0376.stderr b/tests/ui/error-codes/E0376.stderr
deleted file mode 100644
index 46668e05a42f..000000000000
--- a/tests/ui/error-codes/E0376.stderr
+++ /dev/null
@@ -1,9 +0,0 @@
-error[E0376]: the trait `CoerceUnsized` may only be implemented for a coercion between structures
-  --> $DIR/E0376.rs:8:1
-   |
-LL | impl<T, U> CoerceUnsized<U> for Foo<T> {}
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0376`.
diff --git a/tests/ui/error-codes/E0511.rs b/tests/ui/error-codes/E0511.rs
index 81656c710882..c7e59c5c6c96 100644
--- a/tests/ui/error-codes/E0511.rs
+++ b/tests/ui/error-codes/E0511.rs
@@ -1,11 +1,11 @@
 //@ build-fail
 
-#![feature(intrinsics)]
+#![feature(core_intrinsics)]
 
-extern "rust-intrinsic" {
-    fn simd_add<T>(a: T, b: T) -> T;
-}
+use std::intrinsics::simd::simd_add;
 
 fn main() {
-    unsafe { simd_add(0, 1); } //~ ERROR E0511
+    unsafe {
+        simd_add(0, 1) //~ ERROR E0511
+    };
 }
diff --git a/tests/ui/error-codes/E0511.stderr b/tests/ui/error-codes/E0511.stderr
index 59eb19d2ee52..45f5b8d238da 100644
--- a/tests/ui/error-codes/E0511.stderr
+++ b/tests/ui/error-codes/E0511.stderr
@@ -1,8 +1,8 @@
 error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/E0511.rs:10:14
+  --> $DIR/E0511.rs:9:9
    |
-LL |     unsafe { simd_add(0, 1); }
-   |              ^^^^^^^^^^^^^^
+LL |         simd_add(0, 1)
+   |         ^^^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0565.stderr b/tests/ui/error-codes/E0565.stderr
index 68f4a37dcff3..6e56600133d7 100644
--- a/tests/ui/error-codes/E0565.stderr
+++ b/tests/ui/error-codes/E0565.stderr
@@ -1,8 +1,8 @@
 error[E0565]: meta item in `repr` must be an identifier
-  --> $DIR/E0565.rs:2:8
+  --> $DIR/E0565.rs:2:1
    |
 LL | #[repr("C")]
-   |        ^^^
+   | ^^^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0614.stderr b/tests/ui/error-codes/E0614.stderr
index ae7c2ce9a132..0bba0753980d 100644
--- a/tests/ui/error-codes/E0614.stderr
+++ b/tests/ui/error-codes/E0614.stderr
@@ -2,7 +2,7 @@ error[E0614]: type `u32` cannot be dereferenced
   --> $DIR/E0614.rs:3:5
    |
 LL |     *y;
-   |     ^^
+   |     ^^ can't be dereferenced
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/error-codes/E0771.stderr b/tests/ui/error-codes/E0771.stderr
index 5e829e6f6d2d..dfeaa347941c 100644
--- a/tests/ui/error-codes/E0771.stderr
+++ b/tests/ui/error-codes/E0771.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | fn function_with_str<'a, const STRING: &'a str>() {}
    |                                         ^^ the type must not depend on the parameter `'a`
-   |
-   = note: lifetime parameters may not be used in the type of const parameters
 
 warning: the feature `unsized_const_params` is incomplete and may not be safe to use and/or cause compiler crashes
   --> $DIR/E0771.rs:1:30
diff --git a/tests/ui/error-codes/E0789.rs b/tests/ui/error-codes/E0789.rs
index 08471e1b3f3e..4a55e1743158 100644
--- a/tests/ui/error-codes/E0789.rs
+++ b/tests/ui/error-codes/E0789.rs
@@ -8,5 +8,3 @@
 // #[stable(feature = "foo", since = "1.0")]
 struct Foo;
 //~^ ERROR `rustc_allowed_through_unstable_modules` attribute must be paired with a `stable` attribute
-//~^^ ERROR `rustc_allowed_through_unstable_modules` attribute must be paired with a `stable` attribute
-// FIXME: we shouldn't have two errors here, only occurs when using `-Zdeduplicate-diagnostics=no`
diff --git a/tests/ui/error-codes/E0789.stderr b/tests/ui/error-codes/E0789.stderr
index 6df9daafec76..23631ee1b03c 100644
--- a/tests/ui/error-codes/E0789.stderr
+++ b/tests/ui/error-codes/E0789.stderr
@@ -4,14 +4,6 @@ error[E0789]: `rustc_allowed_through_unstable_modules` attribute must be paired
 LL | struct Foo;
    | ^^^^^^^^^^^
 
-error[E0789]: `rustc_allowed_through_unstable_modules` attribute must be paired with a `stable` attribute
-  --> $DIR/E0789.rs:9:1
-   |
-LL | struct Foo;
-   | ^^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
 For more information about this error, try `rustc --explain E0789`.
diff --git a/tests/ui/explicit-tail-calls/ctfe-id-unlimited.return.stderr b/tests/ui/explicit-tail-calls/ctfe-id-unlimited.return.stderr
index 46769cdea8a7..8fb51f5b637c 100644
--- a/tests/ui/explicit-tail-calls/ctfe-id-unlimited.return.stderr
+++ b/tests/ui/explicit-tail-calls/ctfe-id-unlimited.return.stderr
@@ -1,29 +1,24 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/ctfe-id-unlimited.rs:17:42
+  --> $DIR/ctfe-id-unlimited.rs:28:20
    |
-LL |             #[cfg(r#return)] _ => return inner(acc + 1, n - 1),
-   |                                          ^^^^^^^^^^^^^^^^^^^^^ reached the configured maximum number of stack frames
+LL | const ID_ED: u32 = rec_id(ORIGINAL);
+   |                    ^^^^^^^^^^^^^^^^ reached the configured maximum number of stack frames
    |
-note: inside `inner`
-  --> $DIR/ctfe-id-unlimited.rs:17:42
+note: inside `rec_id`
+  --> $DIR/ctfe-id-unlimited.rs:21:5
    |
-LL |             #[cfg(r#return)] _ => return inner(acc + 1, n - 1),
-   |                                          ^^^^^^^^^^^^^^^^^^^^^
+LL |     inner(0, n)
+   |     ^^^^^^^^^^^
 note: [... 125 additional calls inside `inner` ...]
   --> $DIR/ctfe-id-unlimited.rs:17:42
    |
 LL |             #[cfg(r#return)] _ => return inner(acc + 1, n - 1),
    |                                          ^^^^^^^^^^^^^^^^^^^^^
-note: inside `rec_id`
-  --> $DIR/ctfe-id-unlimited.rs:22:5
+note: inside `inner`
+  --> $DIR/ctfe-id-unlimited.rs:17:42
    |
-LL |     inner(0, n)
-   |     ^^^^^^^^^^^
-note: inside `ID_ED`
-  --> $DIR/ctfe-id-unlimited.rs:29:20
-   |
-LL | const ID_ED: u32 = rec_id(ORIGINAL);
-   |                    ^^^^^^^^^^^^^^^^
+LL |             #[cfg(r#return)] _ => return inner(acc + 1, n - 1),
+   |                                          ^^^^^^^^^^^^^^^^^^^^^ the failure occurred here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/explicit-tail-calls/ctfe-id-unlimited.rs b/tests/ui/explicit-tail-calls/ctfe-id-unlimited.rs
index 2a04d4893e68..9e89f4066bb7 100644
--- a/tests/ui/explicit-tail-calls/ctfe-id-unlimited.rs
+++ b/tests/ui/explicit-tail-calls/ctfe-id-unlimited.rs
@@ -15,7 +15,6 @@ const fn rec_id(n: u32) -> u32 {
             0 => acc,
             #[cfg(r#become)] _ => become inner(acc + 1, n - 1),
             #[cfg(r#return)] _ => return inner(acc + 1, n - 1),
-            //[return]~^ error: evaluation of constant value failed
         }
     }
 
@@ -26,7 +25,7 @@ const fn rec_id(n: u32) -> u32 {
 const ORIGINAL: u32 = 12345;
 // Original number, but with identity function applied
 // (this is the same, but requires execution of the recursion)
-const ID_ED: u32 = rec_id(ORIGINAL);
+const ID_ED: u32 = rec_id(ORIGINAL); //[return]~ error: evaluation of constant value failed
 // Assert to make absolutely sure the computation actually happens
 const ASSERT: () = assert!(ORIGINAL == ID_ED);
 
diff --git a/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.rs b/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.rs
index fba4a2692afe..e7038a01d2de 100644
--- a/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.rs
+++ b/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.rs
@@ -6,14 +6,11 @@ pub const fn f() {
 }
 
 const fn g() {
-    panic!()
-    //~^ error: evaluation of constant value failed
-    //~| note: in this expansion of panic!
-    //~| note: inside `g`
-    //~| note: in this expansion of panic!
+    panic!() //~ NOTE inside `g`
+    //~^ NOTE in this expansion of panic!
 }
 
-const _: () = f();
-//~^ note: inside `_`
+const _: () = f(); //~ ERROR evaluation of constant value failed
+//~^ NOTE explicit panic
 
 fn main() {}
diff --git a/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.stderr b/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.stderr
index 8c0705121057..ef71722a0ab5 100644
--- a/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.stderr
+++ b/tests/ui/explicit-tail-calls/ctfe-tail-call-panic.stderr
@@ -1,19 +1,14 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/ctfe-tail-call-panic.rs:9:5
+  --> $DIR/ctfe-tail-call-panic.rs:13:15
    |
-LL |     panic!()
-   |     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/ctfe-tail-call-panic.rs:9:5
+LL | const _: () = f();
+   |               ^^^ evaluation panicked: explicit panic
    |
 note: inside `g`
   --> $DIR/ctfe-tail-call-panic.rs:9:5
    |
 LL |     panic!()
-   |     ^^^^^^^^
-note: inside `_`
-  --> $DIR/ctfe-tail-call-panic.rs:16:15
-   |
-LL | const _: () = f();
-   |               ^^^
+   |     ^^^^^^^^ the failure occurred here
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 error: aborting due to 1 previous error
diff --git a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs
index ce3d3fc645d7..6901a2ab9f18 100644
--- a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.rs
@@ -1,9 +1,11 @@
+//@ add-core-stubs
 //@ needs-llvm-components: avr
 //@ compile-flags: --target=avr-none -C target-cpu=atmega328p --crate-type=rlib
 #![no_core]
 #![feature(no_core, lang_items)]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 // Test that the AVR interrupt ABI cannot be used when avr_interrupt
 // feature gate is not used.
diff --git a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr
index d9f3c3adc7f0..768209eec632 100644
--- a/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-avr-interrupt.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:11:8
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:13:8
    |
 LL | extern "avr-non-blocking-interrupt" fn fu() {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | extern "avr-non-blocking-interrupt" fn fu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:13:8
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:15:8
    |
 LL | extern "avr-interrupt" fn f() {}
    |        ^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL | extern "avr-interrupt" fn f() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:17:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:19:12
    |
 LL |     extern "avr-interrupt" fn m();
    |            ^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     extern "avr-interrupt" fn m();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:19:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:21:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn mu();
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     extern "avr-non-blocking-interrupt" fn mu();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:22:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:24:12
    |
 LL |     extern "avr-interrupt" fn dm() {}
    |            ^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     extern "avr-interrupt" fn dm() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:24:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:26:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn dmu() {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL |     extern "avr-non-blocking-interrupt" fn dmu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:30:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:32:12
    |
 LL |     extern "avr-interrupt" fn m() {}
    |            ^^^^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL |     extern "avr-interrupt" fn m() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:32:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:34:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn mu() {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -79,7 +79,7 @@ LL |     extern "avr-non-blocking-interrupt" fn mu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:37:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:39:12
    |
 LL |     extern "avr-interrupt" fn im() {}
    |            ^^^^^^^^^^^^^^^
@@ -89,7 +89,7 @@ LL |     extern "avr-interrupt" fn im() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:39:12
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:41:12
    |
 LL |     extern "avr-non-blocking-interrupt" fn imu() {}
    |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -99,7 +99,7 @@ LL |     extern "avr-non-blocking-interrupt" fn imu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:43:18
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:45:18
    |
 LL | type TA = extern "avr-interrupt" fn();
    |                  ^^^^^^^^^^^^^^^
@@ -109,7 +109,7 @@ LL | type TA = extern "avr-interrupt" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:45:19
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:47:19
    |
 LL | type TAU = extern "avr-non-blocking-interrupt" fn();
    |                   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -119,7 +119,7 @@ LL | type TAU = extern "avr-non-blocking-interrupt" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:48:8
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:50:8
    |
 LL | extern "avr-interrupt" {}
    |        ^^^^^^^^^^^^^^^
@@ -129,7 +129,7 @@ LL | extern "avr-interrupt" {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "avr-non-blocking-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-avr-interrupt.rs:50:8
+  --> $DIR/feature-gate-abi-avr-interrupt.rs:52:8
    |
 LL | extern "avr-non-blocking-interrupt" {}
    |        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs
index bb69a638ceea..60bf69f597cc 100644
--- a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.rs
@@ -1,9 +1,11 @@
+//@ add-core-stubs
 //@ needs-llvm-components: msp430
 //@ compile-flags: --target=msp430-none-elf --crate-type=rlib
 #![no_core]
 #![feature(no_core, lang_items)]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 extern "msp430-interrupt" fn f() {}
 //~^ ERROR "msp430-interrupt" ABI is experimental
diff --git a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
index 21ddbf7a86df..4a995b4efa6f 100644
--- a/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-msp430-interrupt.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-msp430-interrupt.rs:8:8
+  --> $DIR/feature-gate-abi-msp430-interrupt.rs:10:8
    |
 LL | extern "msp430-interrupt" fn f() {}
    |        ^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | extern "msp430-interrupt" fn f() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-msp430-interrupt.rs:12:12
+  --> $DIR/feature-gate-abi-msp430-interrupt.rs:14:12
    |
 LL |     extern "msp430-interrupt" fn m();
    |            ^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     extern "msp430-interrupt" fn m();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-msp430-interrupt.rs:15:12
+  --> $DIR/feature-gate-abi-msp430-interrupt.rs:17:12
    |
 LL |     extern "msp430-interrupt" fn dm() {}
    |            ^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     extern "msp430-interrupt" fn dm() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-msp430-interrupt.rs:21:12
+  --> $DIR/feature-gate-abi-msp430-interrupt.rs:23:12
    |
 LL |     extern "msp430-interrupt" fn m() {}
    |            ^^^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     extern "msp430-interrupt" fn m() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-msp430-interrupt.rs:26:12
+  --> $DIR/feature-gate-abi-msp430-interrupt.rs:28:12
    |
 LL |     extern "msp430-interrupt" fn im() {}
    |            ^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     extern "msp430-interrupt" fn im() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-msp430-interrupt.rs:30:18
+  --> $DIR/feature-gate-abi-msp430-interrupt.rs:32:18
    |
 LL | type TA = extern "msp430-interrupt" fn();
    |                  ^^^^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL | type TA = extern "msp430-interrupt" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "msp430-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-msp430-interrupt.rs:33:8
+  --> $DIR/feature-gate-abi-msp430-interrupt.rs:35:8
    |
 LL | extern "msp430-interrupt" {}
    |        ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs
index 6f4989fbd9fe..006d01c55896 100644
--- a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.rs
@@ -1,9 +1,11 @@
+//@ add-core-stubs
 //@ needs-llvm-components: riscv
 //@ compile-flags: --target=riscv32imc-unknown-none-elf --crate-type=rlib
 #![no_core]
 #![feature(no_core, lang_items)]
-#[lang = "sized"]
-trait Sized {}
+
+extern crate minicore;
+use minicore::*;
 
 // Test that the riscv interrupt ABIs cannot be used when riscv_interrupt
 // feature gate is not used.
diff --git a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr
index 3c9e99aa1b9b..af956c35da6d 100644
--- a/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-riscv-interrupt.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-riscv-interrupt.rs:11:8
+  --> $DIR/feature-gate-abi-riscv-interrupt.rs:13:8
    |
 LL | extern "riscv-interrupt-m" fn f() {}
    |        ^^^^^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | extern "riscv-interrupt-m" fn f() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "riscv-interrupt-s" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-riscv-interrupt.rs:13:8
+  --> $DIR/feature-gate-abi-riscv-interrupt.rs:15:8
    |
 LL | extern "riscv-interrupt-s" fn f_s() {}
    |        ^^^^^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL | extern "riscv-interrupt-s" fn f_s() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-riscv-interrupt.rs:17:12
+  --> $DIR/feature-gate-abi-riscv-interrupt.rs:19:12
    |
 LL |     extern "riscv-interrupt-m" fn m();
    |            ^^^^^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     extern "riscv-interrupt-m" fn m();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-riscv-interrupt.rs:23:12
+  --> $DIR/feature-gate-abi-riscv-interrupt.rs:25:12
    |
 LL |     extern "riscv-interrupt-m" fn m() {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     extern "riscv-interrupt-m" fn m() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-riscv-interrupt.rs:28:12
+  --> $DIR/feature-gate-abi-riscv-interrupt.rs:30:12
    |
 LL |     extern "riscv-interrupt-m" fn im() {}
    |            ^^^^^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     extern "riscv-interrupt-m" fn im() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "riscv-interrupt-m" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-riscv-interrupt.rs:32:18
+  --> $DIR/feature-gate-abi-riscv-interrupt.rs:34:18
    |
 LL | type TA = extern "riscv-interrupt-m" fn();
    |                  ^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs
index 93c59364f10b..c4fdb5f427ca 100644
--- a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs
+++ b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.rs
@@ -1,9 +1,11 @@
+//@ add-core-stubs
 //@ needs-llvm-components: x86
 //@ compile-flags: --target=x86_64-unknown-linux-gnu --crate-type=rlib
 #![no_core]
 #![feature(no_core, lang_items)]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 extern "x86-interrupt" fn f7() {} //~ ERROR "x86-interrupt" ABI is experimental
 trait Tr {
diff --git a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr
index 231cf207c862..67211d402c6c 100644
--- a/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi-x86-interrupt.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-x86-interrupt.rs:8:8
+  --> $DIR/feature-gate-abi-x86-interrupt.rs:10:8
    |
 LL | extern "x86-interrupt" fn f7() {}
    |        ^^^^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | extern "x86-interrupt" fn f7() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-x86-interrupt.rs:10:12
+  --> $DIR/feature-gate-abi-x86-interrupt.rs:12:12
    |
 LL |     extern "x86-interrupt" fn m7();
    |            ^^^^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     extern "x86-interrupt" fn m7();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-x86-interrupt.rs:11:12
+  --> $DIR/feature-gate-abi-x86-interrupt.rs:13:12
    |
 LL |     extern "x86-interrupt" fn dm7() {}
    |            ^^^^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     extern "x86-interrupt" fn dm7() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-x86-interrupt.rs:18:12
+  --> $DIR/feature-gate-abi-x86-interrupt.rs:20:12
    |
 LL |     extern "x86-interrupt" fn m7() {}
    |            ^^^^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     extern "x86-interrupt" fn m7() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-x86-interrupt.rs:23:12
+  --> $DIR/feature-gate-abi-x86-interrupt.rs:25:12
    |
 LL |     extern "x86-interrupt" fn im7() {}
    |            ^^^^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     extern "x86-interrupt" fn im7() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-x86-interrupt.rs:26:18
+  --> $DIR/feature-gate-abi-x86-interrupt.rs:28:18
    |
 LL | type A7 = extern "x86-interrupt" fn();
    |                  ^^^^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL | type A7 = extern "x86-interrupt" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "x86-interrupt" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi-x86-interrupt.rs:28:8
+  --> $DIR/feature-gate-abi-x86-interrupt.rs:30:8
    |
 LL | extern "x86-interrupt" {}
    |        ^^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-abi.rs b/tests/ui/feature-gates/feature-gate-abi.rs
index 7ab05889c20a..2af623734ee8 100644
--- a/tests/ui/feature-gates/feature-gate-abi.rs
+++ b/tests/ui/feature-gates/feature-gate-abi.rs
@@ -1,14 +1,12 @@
 // gate-test-intrinsics
+//@ add-core-stubs
 //@ compile-flags: --crate-type=rlib
 
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang="sized"]
-trait Sized { }
-
-#[lang="tuple_trait"]
-trait Tuple { }
+extern crate minicore;
+use minicore::*;
 
 // Functions
 extern "rust-intrinsic" fn f1() {} //~ ERROR extern "rust-intrinsic" ABI is an implementation detail
diff --git a/tests/ui/feature-gates/feature-gate-abi.stderr b/tests/ui/feature-gates/feature-gate-abi.stderr
index 70ec64e5135e..a974c0099cbd 100644
--- a/tests/ui/feature-gates/feature-gate-abi.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:14:8
+  --> $DIR/feature-gate-abi.rs:12:8
    |
 LL | extern "rust-intrinsic" fn f1() {}
    |        ^^^^^^^^^^^^^^^^
@@ -8,7 +8,7 @@ LL | extern "rust-intrinsic" fn f1() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:16:8
+  --> $DIR/feature-gate-abi.rs:14:8
    |
 LL | extern "rust-intrinsic" fn f2() {}
    |        ^^^^^^^^^^^^^^^^
@@ -17,7 +17,7 @@ LL | extern "rust-intrinsic" fn f2() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-call" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi.rs:18:8
+  --> $DIR/feature-gate-abi.rs:16:8
    |
 LL | extern "rust-call" fn f4(_: ()) {}
    |        ^^^^^^^^^^^
@@ -27,7 +27,7 @@ LL | extern "rust-call" fn f4(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:22:12
+  --> $DIR/feature-gate-abi.rs:20:12
    |
 LL |     extern "rust-intrinsic" fn m1();
    |            ^^^^^^^^^^^^^^^^
@@ -36,7 +36,7 @@ LL |     extern "rust-intrinsic" fn m1();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:24:12
+  --> $DIR/feature-gate-abi.rs:22:12
    |
 LL |     extern "rust-intrinsic" fn m2();
    |            ^^^^^^^^^^^^^^^^
@@ -45,7 +45,7 @@ LL |     extern "rust-intrinsic" fn m2();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-call" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi.rs:26:12
+  --> $DIR/feature-gate-abi.rs:24:12
    |
 LL |     extern "rust-call" fn m4(_: ());
    |            ^^^^^^^^^^^
@@ -55,7 +55,7 @@ LL |     extern "rust-call" fn m4(_: ());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-call" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi.rs:28:12
+  --> $DIR/feature-gate-abi.rs:26:12
    |
 LL |     extern "rust-call" fn dm4(_: ()) {}
    |            ^^^^^^^^^^^
@@ -65,7 +65,7 @@ LL |     extern "rust-call" fn dm4(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:35:12
+  --> $DIR/feature-gate-abi.rs:33:12
    |
 LL |     extern "rust-intrinsic" fn m1() {}
    |            ^^^^^^^^^^^^^^^^
@@ -74,7 +74,7 @@ LL |     extern "rust-intrinsic" fn m1() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:37:12
+  --> $DIR/feature-gate-abi.rs:35:12
    |
 LL |     extern "rust-intrinsic" fn m2() {}
    |            ^^^^^^^^^^^^^^^^
@@ -83,7 +83,7 @@ LL |     extern "rust-intrinsic" fn m2() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-call" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi.rs:39:12
+  --> $DIR/feature-gate-abi.rs:37:12
    |
 LL |     extern "rust-call" fn m4(_: ()) {}
    |            ^^^^^^^^^^^
@@ -93,7 +93,7 @@ LL |     extern "rust-call" fn m4(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:44:12
+  --> $DIR/feature-gate-abi.rs:42:12
    |
 LL |     extern "rust-intrinsic" fn im1() {}
    |            ^^^^^^^^^^^^^^^^
@@ -102,7 +102,7 @@ LL |     extern "rust-intrinsic" fn im1() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:46:12
+  --> $DIR/feature-gate-abi.rs:44:12
    |
 LL |     extern "rust-intrinsic" fn im2() {}
    |            ^^^^^^^^^^^^^^^^
@@ -111,7 +111,7 @@ LL |     extern "rust-intrinsic" fn im2() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-call" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi.rs:48:12
+  --> $DIR/feature-gate-abi.rs:46:12
    |
 LL |     extern "rust-call" fn im4(_: ()) {}
    |            ^^^^^^^^^^^
@@ -121,7 +121,7 @@ LL |     extern "rust-call" fn im4(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:52:18
+  --> $DIR/feature-gate-abi.rs:50:18
    |
 LL | type A1 = extern "rust-intrinsic" fn();
    |                  ^^^^^^^^^^^^^^^^
@@ -130,7 +130,7 @@ LL | type A1 = extern "rust-intrinsic" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:53:18
+  --> $DIR/feature-gate-abi.rs:51:18
    |
 LL | type A2 = extern "rust-intrinsic" fn();
    |                  ^^^^^^^^^^^^^^^^
@@ -139,7 +139,7 @@ LL | type A2 = extern "rust-intrinsic" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-call" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi.rs:54:18
+  --> $DIR/feature-gate-abi.rs:52:18
    |
 LL | type A4 = extern "rust-call" fn(_: ());
    |                  ^^^^^^^^^^^
@@ -149,7 +149,7 @@ LL | type A4 = extern "rust-call" fn(_: ());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:57:8
+  --> $DIR/feature-gate-abi.rs:55:8
    |
 LL | extern "rust-intrinsic" {}
    |        ^^^^^^^^^^^^^^^^
@@ -158,7 +158,7 @@ LL | extern "rust-intrinsic" {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-intrinsic" ABI is an implementation detail and perma-unstable
-  --> $DIR/feature-gate-abi.rs:58:8
+  --> $DIR/feature-gate-abi.rs:56:8
    |
 LL | extern "rust-intrinsic" {}
    |        ^^^^^^^^^^^^^^^^
@@ -167,7 +167,7 @@ LL | extern "rust-intrinsic" {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "rust-call" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi.rs:59:8
+  --> $DIR/feature-gate-abi.rs:57:8
    |
 LL | extern "rust-call" {}
    |        ^^^^^^^^^^^
@@ -177,49 +177,49 @@ LL | extern "rust-call" {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:22:32
+  --> $DIR/feature-gate-abi.rs:20:32
    |
 LL |     extern "rust-intrinsic" fn m1();
    |                                ^^
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:24:32
+  --> $DIR/feature-gate-abi.rs:22:32
    |
 LL |     extern "rust-intrinsic" fn m2();
    |                                ^^
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:14:33
+  --> $DIR/feature-gate-abi.rs:12:33
    |
 LL | extern "rust-intrinsic" fn f1() {}
    |                                 ^^
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:16:33
+  --> $DIR/feature-gate-abi.rs:14:33
    |
 LL | extern "rust-intrinsic" fn f2() {}
    |                                 ^^
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:35:37
+  --> $DIR/feature-gate-abi.rs:33:37
    |
 LL |     extern "rust-intrinsic" fn m1() {}
    |                                     ^^
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:37:37
+  --> $DIR/feature-gate-abi.rs:35:37
    |
 LL |     extern "rust-intrinsic" fn m2() {}
    |                                     ^^
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:44:38
+  --> $DIR/feature-gate-abi.rs:42:38
    |
 LL |     extern "rust-intrinsic" fn im1() {}
    |                                      ^^
 
 error: intrinsic must be in `extern "rust-intrinsic" { ... }` block
-  --> $DIR/feature-gate-abi.rs:46:38
+  --> $DIR/feature-gate-abi.rs:44:38
    |
 LL |     extern "rust-intrinsic" fn im2() {}
    |                                      ^^
diff --git a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs
index fb04906dafe9..d9027b417b4d 100644
--- a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs
+++ b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.rs
@@ -1,13 +1,11 @@
+//@ add-core-stubs
 //@ compile-flags: --crate-type=rlib
 
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang="sized"]
-trait Sized { }
-
-#[lang="tuple_trait"]
-trait Tuple { }
+extern crate minicore;
+use minicore::*;
 
 // Functions
 extern "gpu-kernel" fn f1(_: ()) {} //~ ERROR "gpu-kernel" ABI is experimental and subject to change
diff --git a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr
index b05c16e3d9ee..d8dbd94696eb 100644
--- a/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi_gpu_kernel.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:13:8
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:11:8
    |
 LL | extern "gpu-kernel" fn f1(_: ()) {}
    |        ^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | extern "gpu-kernel" fn f1(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:18:12
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:16:12
    |
 LL |     extern "gpu-kernel" fn m1(_: ());
    |            ^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     extern "gpu-kernel" fn m1(_: ());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:20:12
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:18:12
    |
 LL |     extern "gpu-kernel" fn dm1(_: ()) {}
    |            ^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     extern "gpu-kernel" fn dm1(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:28:12
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:26:12
    |
 LL |     extern "gpu-kernel" fn m1(_: ()) {}
    |            ^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     extern "gpu-kernel" fn m1(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:34:12
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:32:12
    |
 LL |     extern "gpu-kernel" fn im1(_: ()) {}
    |            ^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     extern "gpu-kernel" fn im1(_: ()) {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:39:18
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:37:18
    |
 LL | type A1 = extern "gpu-kernel" fn(_: ());
    |                  ^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL | type A1 = extern "gpu-kernel" fn(_: ());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "gpu-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:44:8
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:42:8
    |
 LL | extern "gpu-kernel" {}
    |        ^^^^^^^^^^^^
@@ -69,7 +69,7 @@ LL | extern "gpu-kernel" {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 warning: the calling convention "gpu-kernel" is not supported on this target
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:39:11
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:37:11
    |
 LL | type A1 = extern "gpu-kernel" fn(_: ());
    |           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -79,31 +79,31 @@ LL | type A1 = extern "gpu-kernel" fn(_: ());
    = note: `#[warn(unsupported_fn_ptr_calling_conventions)]` on by default
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:44:1
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:42:1
    |
 LL | extern "gpu-kernel" {}
    | ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:13:1
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:11:1
    |
 LL | extern "gpu-kernel" fn f1(_: ()) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:20:5
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:18:5
    |
 LL |     extern "gpu-kernel" fn dm1(_: ()) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:28:5
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:26:5
    |
 LL |     extern "gpu-kernel" fn m1(_: ()) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0570]: `"gpu-kernel"` is not a supported ABI for the current target
-  --> $DIR/feature-gate-abi_gpu_kernel.rs:34:5
+  --> $DIR/feature-gate-abi_gpu_kernel.rs:32:5
    |
 LL |     extern "gpu-kernel" fn im1(_: ()) {}
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-abi_ptx.rs b/tests/ui/feature-gates/feature-gate-abi_ptx.rs
index e742492303ad..3cc2b7861924 100644
--- a/tests/ui/feature-gates/feature-gate-abi_ptx.rs
+++ b/tests/ui/feature-gates/feature-gate-abi_ptx.rs
@@ -1,9 +1,11 @@
+//@ add-core-stubs
 //@ needs-llvm-components: nvptx
 //@ compile-flags: --target=nvptx64-nvidia-cuda --crate-type=rlib
 #![no_core]
 #![feature(no_core, lang_items)]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 extern "ptx-kernel" fn fu() {} //~ ERROR extern "ptx-kernel" ABI is experimental
 
diff --git a/tests/ui/feature-gates/feature-gate-abi_ptx.stderr b/tests/ui/feature-gates/feature-gate-abi_ptx.stderr
index d128075919b0..cbe9fd8d834e 100644
--- a/tests/ui/feature-gates/feature-gate-abi_ptx.stderr
+++ b/tests/ui/feature-gates/feature-gate-abi_ptx.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_ptx.rs:8:8
+  --> $DIR/feature-gate-abi_ptx.rs:10:8
    |
 LL | extern "ptx-kernel" fn fu() {}
    |        ^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | extern "ptx-kernel" fn fu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_ptx.rs:11:12
+  --> $DIR/feature-gate-abi_ptx.rs:13:12
    |
 LL |     extern "ptx-kernel" fn mu();
    |            ^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     extern "ptx-kernel" fn mu();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_ptx.rs:12:12
+  --> $DIR/feature-gate-abi_ptx.rs:14:12
    |
 LL |     extern "ptx-kernel" fn dmu() {}
    |            ^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     extern "ptx-kernel" fn dmu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_ptx.rs:17:12
+  --> $DIR/feature-gate-abi_ptx.rs:19:12
    |
 LL |     extern "ptx-kernel" fn mu() {}
    |            ^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     extern "ptx-kernel" fn mu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_ptx.rs:21:12
+  --> $DIR/feature-gate-abi_ptx.rs:23:12
    |
 LL |     extern "ptx-kernel" fn imu() {}
    |            ^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     extern "ptx-kernel" fn imu() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_ptx.rs:24:19
+  --> $DIR/feature-gate-abi_ptx.rs:26:19
    |
 LL | type TAU = extern "ptx-kernel" fn();
    |                   ^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL | type TAU = extern "ptx-kernel" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "ptx-kernel" ABI is experimental and subject to change
-  --> $DIR/feature-gate-abi_ptx.rs:26:8
+  --> $DIR/feature-gate-abi_ptx.rs:28:8
    |
 LL | extern "ptx-kernel" {}
    |        ^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.rs b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.rs
index 8b13f1bf2788..81b7fe3db2ba 100644
--- a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.rs
+++ b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.rs
@@ -1,7 +1,9 @@
 // checks that this attribute is caught on non-macro items.
 // this needs a different test since this is done after expansion
 
-#[allow_internal_unstable()] //~ ERROR allow_internal_unstable side-steps
+// FIXME(jdonszelmann): empty attributes are currently ignored, since when its empty no actual
+// change is applied. This should be fixed when later moving this check to attribute parsing.
+#[allow_internal_unstable(something)] //~ ERROR allow_internal_unstable side-steps
 //~| ERROR attribute should
 struct S;
 
diff --git a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr
index 28f1a0d6ed5a..076f2df28e3f 100644
--- a/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr
+++ b/tests/ui/feature-gates/feature-gate-allow-internal-unstable-struct.stderr
@@ -1,17 +1,17 @@
 error[E0658]: allow_internal_unstable side-steps feature gating and stability checks
-  --> $DIR/feature-gate-allow-internal-unstable-struct.rs:4:1
+  --> $DIR/feature-gate-allow-internal-unstable-struct.rs:6:1
    |
-LL | #[allow_internal_unstable()]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[allow_internal_unstable(something)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
    = help: add `#![feature(allow_internal_unstable)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error: attribute should be applied to a macro
-  --> $DIR/feature-gate-allow-internal-unstable-struct.rs:4:1
+  --> $DIR/feature-gate-allow-internal-unstable-struct.rs:6:1
    |
-LL | #[allow_internal_unstable()]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL | #[allow_internal_unstable(something)]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 LL |
 LL | struct S;
    | --------- not a macro
diff --git a/tests/ui/feature-gates/feature-gate-asm_experimental_arch.rs b/tests/ui/feature-gates/feature-gate-asm_experimental_arch.rs
index a52fbbe4075e..a3b41e071954 100644
--- a/tests/ui/feature-gates/feature-gate-asm_experimental_arch.rs
+++ b/tests/ui/feature-gates/feature-gate-asm_experimental_arch.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --target mips-unknown-linux-gnu
 //@ needs-llvm-components: mips
 
@@ -5,15 +6,8 @@
 #![crate_type = "rlib"]
 #![no_core]
 
-#[rustc_builtin_macro]
-macro_rules! asm {
-    () => {};
-}
-
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 unsafe fn main() {
     asm!("");
diff --git a/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr b/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr
index d930429779c0..e59a10c11c3e 100644
--- a/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr
+++ b/tests/ui/feature-gates/feature-gate-asm_experimental_arch.stderr
@@ -1,5 +1,5 @@
 error[E0658]: inline assembly is not stable yet on this architecture
-  --> $DIR/feature-gate-asm_experimental_arch.rs:19:5
+  --> $DIR/feature-gate-asm_experimental_arch.rs:13:5
    |
 LL |     asm!("");
    |     ^^^^^^^^
diff --git a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs
index 7aec7455b2e6..6c53c2213a5e 100644
--- a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs
+++ b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ needs-asm-support
 //@ compile-flags: --target s390x-unknown-linux-gnu
 //@ needs-llvm-components: systemz
@@ -6,15 +7,8 @@
 #![crate_type = "rlib"]
 #![no_core]
 
-#[rustc_builtin_macro]
-macro_rules! asm {
-    () => {};
-}
-
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
+extern crate minicore;
+use minicore::*;
 
 unsafe fn main() {
     asm!("", in("v0") 0);
diff --git a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr
index 0791ce4543ca..6f2ea0ddaec1 100644
--- a/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr
+++ b/tests/ui/feature-gates/feature-gate-asm_experimental_reg.stderr
@@ -1,5 +1,5 @@
 error[E0658]: register class `vreg` can only be used as a clobber in stable
-  --> $DIR/feature-gate-asm_experimental_reg.rs:20:14
+  --> $DIR/feature-gate-asm_experimental_reg.rs:14:14
    |
 LL |     asm!("", in("v0") 0);
    |              ^^^^^^^^^^
@@ -9,7 +9,7 @@ LL |     asm!("", in("v0") 0);
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: type `i32` cannot be used with this register class in stable
-  --> $DIR/feature-gate-asm_experimental_reg.rs:20:23
+  --> $DIR/feature-gate-asm_experimental_reg.rs:14:23
    |
 LL |     asm!("", in("v0") 0);
    |                       ^
diff --git a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.rs b/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.rs
deleted file mode 100644
index e38ab66dbe54..000000000000
--- a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.rs
+++ /dev/null
@@ -1,41 +0,0 @@
-// Test that the use of the dyn-incompatible trait objects
-// are gated by the `dyn_compatible_for_dispatch` feature gate.
-
-trait DynIncompatible1: Sized {}
-
-trait DynIncompatible2 {
-    fn static_fn() {}
-}
-
-trait DynIncompatible3 {
-    fn foo<T>(&self);
-}
-
-trait DynIncompatible4 {
-    fn foo(&self, s: &Self);
-}
-
-fn takes_dyn_incompatible_ref<T>(obj: &dyn DynIncompatible1) {
-    //~^ ERROR E0038
-}
-
-fn return_dyn_incompatible_ref() -> &'static dyn DynIncompatible2 {
-    //~^ ERROR E0038
-    loop {}
-}
-
-fn takes_dyn_incompatible_box(obj: Box<dyn DynIncompatible3>) {
-    //~^ ERROR E0038
-}
-
-fn return_dyn_incompatible_rc() -> std::rc::Rc<dyn DynIncompatible4> {
-    //~^ ERROR E0038
-    loop {}
-}
-
-trait Trait {}
-
-impl Trait for dyn DynIncompatible1 {}
-//~^ ERROR E0038
-
-fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.stderr b/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.stderr
deleted file mode 100644
index 2c3edd6e6a5f..000000000000
--- a/tests/ui/feature-gates/feature-gate-dyn_compatible_for_dispatch.stderr
+++ /dev/null
@@ -1,88 +0,0 @@
-error[E0038]: the trait `DynIncompatible1` is not dyn compatible
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:18:40
-   |
-LL | fn takes_dyn_incompatible_ref<T>(obj: &dyn DynIncompatible1) {
-   |                                        ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible1` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:4:25
-   |
-LL | trait DynIncompatible1: Sized {}
-   |       ----------------  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-
-error[E0038]: the trait `DynIncompatible2` is not dyn compatible
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:22:46
-   |
-LL | fn return_dyn_incompatible_ref() -> &'static dyn DynIncompatible2 {
-   |                                              ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible2` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:7:8
-   |
-LL | trait DynIncompatible2 {
-   |       ---------------- this trait is not dyn compatible...
-LL |     fn static_fn() {}
-   |        ^^^^^^^^^ ...because associated function `static_fn` has no `self` parameter
-help: consider turning `static_fn` into a method by giving it a `&self` argument
-   |
-LL |     fn static_fn(&self) {}
-   |                  +++++
-help: alternatively, consider constraining `static_fn` so it does not apply to trait objects
-   |
-LL |     fn static_fn() where Self: Sized {}
-   |                    +++++++++++++++++
-
-error[E0038]: the trait `DynIncompatible3` is not dyn compatible
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:27:40
-   |
-LL | fn takes_dyn_incompatible_box(obj: Box<dyn DynIncompatible3>) {
-   |                                        ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible3` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:11:8
-   |
-LL | trait DynIncompatible3 {
-   |       ---------------- this trait is not dyn compatible...
-LL |     fn foo<T>(&self);
-   |        ^^^ ...because method `foo` has generic type parameters
-   = help: consider moving `foo` to another trait
-
-error[E0038]: the trait `DynIncompatible4` is not dyn compatible
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:31:48
-   |
-LL | fn return_dyn_incompatible_rc() -> std::rc::Rc<dyn DynIncompatible4> {
-   |                                                ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible4` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:15:22
-   |
-LL | trait DynIncompatible4 {
-   |       ---------------- this trait is not dyn compatible...
-LL |     fn foo(&self, s: &Self);
-   |                      ^^^^^ ...because method `foo` references the `Self` type in this parameter
-   = help: consider moving `foo` to another trait
-
-error[E0038]: the trait `DynIncompatible1` is not dyn compatible
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:38:16
-   |
-LL | impl Trait for dyn DynIncompatible1 {}
-   |                ^^^^^^^^^^^^^^^^^^^^ `DynIncompatible1` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/feature-gate-dyn_compatible_for_dispatch.rs:4:25
-   |
-LL | trait DynIncompatible1: Sized {}
-   |       ----------------  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-
-error: aborting due to 5 previous errors
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/feature-gates/feature-gate-fn_align.rs b/tests/ui/feature-gates/feature-gate-fn_align.rs
index 06784a45d76c..744877704dd1 100644
--- a/tests/ui/feature-gates/feature-gate-fn_align.rs
+++ b/tests/ui/feature-gates/feature-gate-fn_align.rs
@@ -4,6 +4,6 @@
 fn requires_alignment() {}
 
 trait MyTrait {
-    #[repr(align)] //~ ERROR `repr(align)` attributes on functions are unstable
+    #[repr(align)] //~ ERROR invalid `repr(align)` attribute: `align` needs an argument
     fn myfun();
 }
diff --git a/tests/ui/feature-gates/feature-gate-fn_align.stderr b/tests/ui/feature-gates/feature-gate-fn_align.stderr
index cd9900c60511..ff17c29fe029 100644
--- a/tests/ui/feature-gates/feature-gate-fn_align.stderr
+++ b/tests/ui/feature-gates/feature-gate-fn_align.stderr
@@ -1,3 +1,9 @@
+error[E0589]: invalid `repr(align)` attribute: `align` needs an argument
+  --> $DIR/feature-gate-fn_align.rs:7:12
+   |
+LL |     #[repr(align)]
+   |            ^^^^^ help: supply an argument here: `align(...)`
+
 error[E0658]: `repr(align)` attributes on functions are unstable
   --> $DIR/feature-gate-fn_align.rs:3:8
    |
@@ -8,16 +14,7 @@ LL | #[repr(align(16))]
    = help: add `#![feature(fn_align)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: `repr(align)` attributes on functions are unstable
-  --> $DIR/feature-gate-fn_align.rs:7:12
-   |
-LL |     #[repr(align)]
-   |            ^^^^^
-   |
-   = note: see issue #82232 <https://github.com/rust-lang/rust/issues/82232> for more information
-   = help: add `#![feature(fn_align)]` to the crate attributes to enable
-   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
-
 error: aborting due to 2 previous errors
 
-For more information about this error, try `rustc --explain E0658`.
+Some errors have detailed explanations: E0589, E0658.
+For more information about an error, try `rustc --explain E0589`.
diff --git a/tests/ui/feature-gates/feature-gate-generic-const-parameter-types.normal.stderr b/tests/ui/feature-gates/feature-gate-generic-const-parameter-types.normal.stderr
new file mode 100644
index 000000000000..1377f845d164
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-generic-const-parameter-types.normal.stderr
@@ -0,0 +1,21 @@
+error[E0770]: the type of const parameters must not depend on other generic parameters
+  --> $DIR/feature-gate-generic-const-parameter-types.rs:7:50
+   |
+LL | struct MyADT<const LEN: usize, const ARRAY: [u8; LEN]>;
+   |                                                  ^^^ the type must not depend on the parameter `LEN`
+
+error: `[u8; LEN]` is forbidden as the type of a const generic parameter
+  --> $DIR/feature-gate-generic-const-parameter-types.rs:7:45
+   |
+LL | struct MyADT<const LEN: usize, const ARRAY: [u8; LEN]>;
+   |                                             ^^^^^^^^^
+   |
+   = note: the only supported types are integers, `bool`, and `char`
+help: add `#![feature(adt_const_params)]` to the crate attributes to enable more complex and user defined types
+   |
+LL + #![feature(adt_const_params)]
+   |
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0770`.
diff --git a/tests/ui/feature-gates/feature-gate-generic-const-parameter-types.rs b/tests/ui/feature-gates/feature-gate-generic-const-parameter-types.rs
new file mode 100644
index 000000000000..cc374ea3eb2e
--- /dev/null
+++ b/tests/ui/feature-gates/feature-gate-generic-const-parameter-types.rs
@@ -0,0 +1,11 @@
+//@ [feature] check-pass
+//@ revisions: normal feature
+
+#![cfg_attr(feature, feature(adt_const_params, generic_const_parameter_types))]
+#![cfg_attr(feature, expect(incomplete_features))]
+
+struct MyADT<const LEN: usize, const ARRAY: [u8; LEN]>;
+//[normal]~^ ERROR: the type of const parameters must not depend on other generic parameters
+//[normal]~| ERROR: `[u8; LEN]` is forbidden as the type of a const generic parameter
+
+fn main() {}
diff --git a/tests/ui/feature-gates/feature-gate-vectorcall.rs b/tests/ui/feature-gates/feature-gate-vectorcall.rs
index aafa6a2ed629..b29fd08473a0 100644
--- a/tests/ui/feature-gates/feature-gate-vectorcall.rs
+++ b/tests/ui/feature-gates/feature-gate-vectorcall.rs
@@ -1,10 +1,12 @@
 // gate-test-abi_vectorcall
+//@ add-core-stubs
 //@ needs-llvm-components: x86
 //@ compile-flags: --target=i686-pc-windows-msvc --crate-type=rlib
 #![no_core]
 #![feature(no_core, lang_items)]
-#[lang="sized"]
-trait Sized { }
+
+extern crate minicore;
+use minicore::*;
 
 // Test that the "vectorcall" ABI is feature-gated, and cannot be used when
 // the `vectorcall` feature gate is not used.
diff --git a/tests/ui/feature-gates/feature-gate-vectorcall.stderr b/tests/ui/feature-gates/feature-gate-vectorcall.stderr
index 8f3f47a3d488..81dd10f5fe50 100644
--- a/tests/ui/feature-gates/feature-gate-vectorcall.stderr
+++ b/tests/ui/feature-gates/feature-gate-vectorcall.stderr
@@ -1,5 +1,5 @@
 error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
-  --> $DIR/feature-gate-vectorcall.rs:12:8
+  --> $DIR/feature-gate-vectorcall.rs:14:8
    |
 LL | extern "vectorcall" fn f() {}
    |        ^^^^^^^^^^^^
@@ -9,7 +9,7 @@ LL | extern "vectorcall" fn f() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
-  --> $DIR/feature-gate-vectorcall.rs:15:12
+  --> $DIR/feature-gate-vectorcall.rs:17:12
    |
 LL |     extern "vectorcall" fn m();
    |            ^^^^^^^^^^^^
@@ -19,7 +19,7 @@ LL |     extern "vectorcall" fn m();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
-  --> $DIR/feature-gate-vectorcall.rs:17:12
+  --> $DIR/feature-gate-vectorcall.rs:19:12
    |
 LL |     extern "vectorcall" fn dm() {}
    |            ^^^^^^^^^^^^
@@ -29,7 +29,7 @@ LL |     extern "vectorcall" fn dm() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
-  --> $DIR/feature-gate-vectorcall.rs:22:12
+  --> $DIR/feature-gate-vectorcall.rs:24:12
    |
 LL |     extern "vectorcall" fn m() {}
    |            ^^^^^^^^^^^^
@@ -39,7 +39,7 @@ LL |     extern "vectorcall" fn m() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
-  --> $DIR/feature-gate-vectorcall.rs:26:12
+  --> $DIR/feature-gate-vectorcall.rs:28:12
    |
 LL |     extern "vectorcall" fn im() {}
    |            ^^^^^^^^^^^^
@@ -49,7 +49,7 @@ LL |     extern "vectorcall" fn im() {}
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
-  --> $DIR/feature-gate-vectorcall.rs:29:18
+  --> $DIR/feature-gate-vectorcall.rs:31:18
    |
 LL | type TA = extern "vectorcall" fn();
    |                  ^^^^^^^^^^^^
@@ -59,7 +59,7 @@ LL | type TA = extern "vectorcall" fn();
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
 error[E0658]: the extern "vectorcall" ABI is experimental and subject to change
-  --> $DIR/feature-gate-vectorcall.rs:31:8
+  --> $DIR/feature-gate-vectorcall.rs:33:8
    |
 LL | extern "vectorcall" {}
    |        ^^^^^^^^^^^^
diff --git a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
index 648bafe64609..5c2a3ae699c0 100644
--- a/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
+++ b/tests/ui/feature-gates/issue-43106-gating-of-builtin-attrs-error.stderr
@@ -130,21 +130,6 @@ LL - #![rustc_main]
 LL + #[rustc_main]
    |
 
-error: `repr` attribute cannot be used at crate level
-  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:17:1
-   |
-LL | #![repr()]
-   | ^^^^^^^^^^
-...
-LL | mod inline {
-   |     ------ the inner attribute doesn't annotate this module
-   |
-help: perhaps you meant to use an outer attribute
-   |
-LL - #![repr()]
-LL + #[repr()]
-   |
-
 error: `path` attribute cannot be used at crate level
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:19:1
    |
@@ -175,6 +160,21 @@ LL - #![automatically_derived]
 LL + #[automatically_derived]
    |
 
+error: `repr` attribute cannot be used at crate level
+  --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:17:1
+   |
+LL | #![repr()]
+   | ^^^^^^^^^^
+...
+LL | mod inline {
+   |     ------ the inner attribute doesn't annotate this module
+   |
+help: perhaps you meant to use an outer attribute
+   |
+LL - #![repr()]
+LL + #[repr()]
+   |
+
 error[E0518]: attribute should be applied to function or closure
   --> $DIR/issue-43106-gating-of-builtin-attrs-error.rs:40:17
    |
diff --git a/tests/ui/force-inlining/asm.rs b/tests/ui/force-inlining/asm.rs
index 85014ffa5158..2b5f87c59d35 100644
--- a/tests/ui/force-inlining/asm.rs
+++ b/tests/ui/force-inlining/asm.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ build-fail
 //@ compile-flags: --crate-type=lib --target thumbv4t-none-eabi
 //@ needs-llvm-components: arm
@@ -9,17 +10,8 @@
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy {}
-#[lang = "freeze"]
-pub unsafe trait Freeze {}
-
-#[lang = "start"]
-fn start<T>(_main: fn() -> T, _argc: isize, _argv: *const *const u8, _sigpipe: u8) -> isize {
-    0
-}
+extern crate minicore;
+use minicore::*;
 
 #[rustc_builtin_macro]
 #[macro_export]
diff --git a/tests/ui/force-inlining/asm.stderr b/tests/ui/force-inlining/asm.stderr
index ef04688965bb..1744c0215bb4 100644
--- a/tests/ui/force-inlining/asm.stderr
+++ b/tests/ui/force-inlining/asm.stderr
@@ -1,5 +1,5 @@
 error: `instruction_set_a32` could not be inlined into `t32` but is required to be inlined
-  --> $DIR/asm.rs:53:5
+  --> $DIR/asm.rs:45:5
    |
 LL |     instruction_set_a32();
    |     ^^^^^^^^^^^^^^^^^^^^^ ...`instruction_set_a32` called here
@@ -7,7 +7,7 @@ LL |     instruction_set_a32();
    = note: could not be inlined due to: incompatible instruction set
 
 error: `inline_always_and_using_inline_asm` could not be inlined into `t32` but is required to be inlined
-  --> $DIR/asm.rs:57:5
+  --> $DIR/asm.rs:49:5
    |
 LL |     inline_always_and_using_inline_asm();
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ ...`inline_always_and_using_inline_asm` called here
@@ -15,7 +15,7 @@ LL |     inline_always_and_using_inline_asm();
    = note: could not be inlined due to: cannot move inline-asm across instruction sets
 
 error: `instruction_set_a32` could not be inlined into `default` but is required to be inlined
-  --> $DIR/asm.rs:62:5
+  --> $DIR/asm.rs:54:5
    |
 LL |     instruction_set_a32();
    |     ^^^^^^^^^^^^^^^^^^^^^ ...`instruction_set_a32` called here
@@ -23,7 +23,7 @@ LL |     instruction_set_a32();
    = note: could not be inlined due to: incompatible instruction set
 
 error: `instruction_set_t32` could not be inlined into `default` but is required to be inlined
-  --> $DIR/asm.rs:64:5
+  --> $DIR/asm.rs:56:5
    |
 LL |     instruction_set_t32();
    |     ^^^^^^^^^^^^^^^^^^^^^ ...`instruction_set_t32` called here
diff --git a/tests/ui/force-inlining/gate.rs b/tests/ui/force-inlining/gate.rs
index d6a01a74a44b..cea094c14f2d 100644
--- a/tests/ui/force-inlining/gate.rs
+++ b/tests/ui/force-inlining/gate.rs
@@ -2,11 +2,11 @@
 #![allow(internal_features)]
 
 #[rustc_force_inline]
-//~^ ERROR #![rustc_force_inline] forces a free function to be inlined
+//~^ ERROR #[rustc_force_inline] forces a free function to be inlined
 pub fn bare() {
 }
 
 #[rustc_force_inline = "the test requires it"]
-//~^ ERROR #![rustc_force_inline] forces a free function to be inlined
+//~^ ERROR #[rustc_force_inline] forces a free function to be inlined
 pub fn justified() {
 }
diff --git a/tests/ui/force-inlining/gate.stderr b/tests/ui/force-inlining/gate.stderr
index e3973a08c232..964d43fa18f6 100644
--- a/tests/ui/force-inlining/gate.stderr
+++ b/tests/ui/force-inlining/gate.stderr
@@ -1,4 +1,4 @@
-error[E0658]: #![rustc_force_inline] forces a free function to be inlined
+error[E0658]: #[rustc_force_inline] forces a free function to be inlined
   --> $DIR/gate.rs:4:1
    |
 LL | #[rustc_force_inline]
@@ -7,7 +7,7 @@ LL | #[rustc_force_inline]
    = help: add `#![feature(rustc_attrs)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
 
-error[E0658]: #![rustc_force_inline] forces a free function to be inlined
+error[E0658]: #[rustc_force_inline] forces a free function to be inlined
   --> $DIR/gate.rs:9:1
    |
 LL | #[rustc_force_inline = "the test requires it"]
diff --git a/tests/ui/generic-const-items/def-site-eval.fail.stderr b/tests/ui/generic-const-items/def-site-eval.fail.stderr
index 22a5f2916977..1ba4455c7beb 100644
--- a/tests/ui/generic-const-items/def-site-eval.fail.stderr
+++ b/tests/ui/generic-const-items/def-site-eval.fail.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `_::<'_>` failed
   --> $DIR/def-site-eval.rs:14:20
    |
 LL | const _<'_a>: () = panic!();
-   |                    ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/def-site-eval.rs:14:20
+   |                    ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/generic-const-items/wfcheck_err_leak_issue_118179.stderr b/tests/ui/generic-const-items/wfcheck_err_leak_issue_118179.stderr
index 654004571dbb..2b28e29421c9 100644
--- a/tests/ui/generic-const-items/wfcheck_err_leak_issue_118179.stderr
+++ b/tests/ui/generic-const-items/wfcheck_err_leak_issue_118179.stderr
@@ -3,8 +3,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | struct G<T, const N: Vec<T>>(T);
    |                          ^ the type must not depend on the parameter `T`
-   |
-   = note: type parameters may not be used in the type of const parameters
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/generics/post_monomorphization_error_backtrace.rs b/tests/ui/generics/post_monomorphization_error_backtrace.rs
index 2c18f2b233ad..f5f36ef03ae6 100644
--- a/tests/ui/generics/post_monomorphization_error_backtrace.rs
+++ b/tests/ui/generics/post_monomorphization_error_backtrace.rs
@@ -6,10 +6,10 @@ fn assert_zst<T>() {
         const V: () = assert!(std::mem::size_of::<T>() == 0);
         //~^ ERROR: evaluation of `assert_zst::F::<u32>::V` failed [E0080]
         //~| NOTE: in this expansion of assert!
-        //~| NOTE: the evaluated program panicked
+        //~| NOTE: assertion failed
         //~| ERROR: evaluation of `assert_zst::F::<i32>::V` failed [E0080]
         //~| NOTE: in this expansion of assert!
-        //~| NOTE: the evaluated program panicked
+        //~| NOTE: assertion failed
     }
     F::<T>::V;
     //~^NOTE: erroneous constant
diff --git a/tests/ui/generics/post_monomorphization_error_backtrace.stderr b/tests/ui/generics/post_monomorphization_error_backtrace.stderr
index 8a57979bca7d..1366d5491f40 100644
--- a/tests/ui/generics/post_monomorphization_error_backtrace.stderr
+++ b/tests/ui/generics/post_monomorphization_error_backtrace.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `assert_zst::F::<u32>::V` failed
   --> $DIR/post_monomorphization_error_backtrace.rs:6:23
    |
 LL |         const V: () = assert!(std::mem::size_of::<T>() == 0);
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/post_monomorphization_error_backtrace.rs:6:23
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: assertion failed: std::mem::size_of::<T>() == 0
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -22,7 +22,7 @@ error[E0080]: evaluation of `assert_zst::F::<i32>::V` failed
   --> $DIR/post_monomorphization_error_backtrace.rs:6:23
    |
 LL |         const V: () = assert!(std::mem::size_of::<T>() == 0);
-   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/post_monomorphization_error_backtrace.rs:6:23
+   |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: assertion failed: std::mem::size_of::<T>() == 0
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/impl-trait/method-suggestion-no-duplication.stderr b/tests/ui/impl-trait/method-suggestion-no-duplication.stderr
index c401269da83c..6bc57f89467d 100644
--- a/tests/ui/impl-trait/method-suggestion-no-duplication.stderr
+++ b/tests/ui/impl-trait/method-suggestion-no-duplication.stderr
@@ -8,8 +8,9 @@ LL |     foo(|s| s.is_empty());
    |               ^^^^^^^^ method not found in `Foo`
    |
    = help: items from traits can only be used if the trait is implemented and in scope
-   = note: the following trait defines an item `is_empty`, perhaps you need to implement it:
+   = note: the following traits define an item `is_empty`, perhaps you need to implement one of them:
            candidate #1: `ExactSizeIterator`
+           candidate #2: `RangeBounds`
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/imports/import-prefix-macro-2.rs b/tests/ui/imports/import-prefix-macro-2.rs
index 952d161e83fa..17898c0a6799 100644
--- a/tests/ui/imports/import-prefix-macro-2.rs
+++ b/tests/ui/imports/import-prefix-macro-2.rs
@@ -8,7 +8,7 @@ mod a {
 }
 
 macro_rules! import {
-    ($p: path) => (use ::$p {S, Z}); //~ERROR  expected identifier, found `a::b::c`
+    ($p: path) => (use ::$p {S, Z}); //~ERROR expected identifier, found metavariable
 }
 
 import! { a::b::c }
diff --git a/tests/ui/imports/import-prefix-macro-2.stderr b/tests/ui/imports/import-prefix-macro-2.stderr
index 070186f2bf2f..fbeca99b1380 100644
--- a/tests/ui/imports/import-prefix-macro-2.stderr
+++ b/tests/ui/imports/import-prefix-macro-2.stderr
@@ -1,8 +1,8 @@
-error: expected identifier, found `a::b::c`
+error: expected identifier, found metavariable
   --> $DIR/import-prefix-macro-2.rs:11:26
    |
 LL |     ($p: path) => (use ::$p {S, Z});
-   |                          ^^ expected identifier
+   |                          ^^ expected identifier, found metavariable
 ...
 LL | import! { a::b::c }
    | ------------------- in this macro invocation
diff --git a/tests/ui/infinite/infinite-recursion-const-fn.rs b/tests/ui/infinite/infinite-recursion-const-fn.rs
index 4209153116d9..7b7f6fafab5f 100644
--- a/tests/ui/infinite/infinite-recursion-const-fn.rs
+++ b/tests/ui/infinite/infinite-recursion-const-fn.rs
@@ -1,11 +1,11 @@
 //https://github.com/rust-lang/rust/issues/31364
 
 const fn a() -> usize {
-    b() //~ ERROR evaluation of constant value failed [E0080]
+    b()
 }
 const fn b() -> usize {
     a()
 }
-const ARR: [i32; a()] = [5; 6];
+const ARR: [i32; a()] = [5; 6]; //~ ERROR evaluation of constant value failed [E0080]
 
 fn main() {}
diff --git a/tests/ui/infinite/infinite-recursion-const-fn.stderr b/tests/ui/infinite/infinite-recursion-const-fn.stderr
index fd5a3c3c5464..524abdf4d7ad 100644
--- a/tests/ui/infinite/infinite-recursion-const-fn.stderr
+++ b/tests/ui/infinite/infinite-recursion-const-fn.stderr
@@ -1,649 +1,644 @@
 error[E0080]: evaluation of constant value failed
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^ reached the configured maximum number of stack frames
-   |
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `b`
-  --> $DIR/infinite-recursion-const-fn.rs:7:5
-   |
-LL |     a()
-   |     ^^^
-note: inside `a`
-  --> $DIR/infinite-recursion-const-fn.rs:4:5
-   |
-LL |     b()
-   |     ^^^
-note: inside `ARR::{constant#0}`
   --> $DIR/infinite-recursion-const-fn.rs:9:18
    |
 LL | const ARR: [i32; a()] = [5; 6];
-   |                  ^^^
+   |                  ^^^ reached the configured maximum number of stack frames
+   |
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^
+note: inside `b`
+  --> $DIR/infinite-recursion-const-fn.rs:7:5
+   |
+LL |     a()
+   |     ^^^
+note: inside `a`
+  --> $DIR/infinite-recursion-const-fn.rs:4:5
+   |
+LL |     b()
+   |     ^^^ the failure occurred here
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/inline-const/collect-scopes-in-pat.rs b/tests/ui/inline-const/collect-scopes-in-pat.rs
index 024fde537413..16baf920f584 100644
--- a/tests/ui/inline-const/collect-scopes-in-pat.rs
+++ b/tests/ui/inline-const/collect-scopes-in-pat.rs
@@ -1,4 +1,4 @@
-// @compile-flags: -Zlint-mir
+//@ compile-flags: -Zlint-mir
 //@ check-pass
 
 #![feature(inline_const_pat)]
diff --git a/tests/ui/inline-const/const-expr-generic-err.stderr b/tests/ui/inline-const/const-expr-generic-err.stderr
index dcd6b62bbfc1..e67c0b28e023 100644
--- a/tests/ui/inline-const/const-expr-generic-err.stderr
+++ b/tests/ui/inline-const/const-expr-generic-err.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `foo::<i32>::{constant#0}` failed
   --> $DIR/const-expr-generic-err.rs:4:13
    |
 LL |     const { assert!(std::mem::size_of::<T>() == 0); }
-   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: std::mem::size_of::<T>() == 0', $DIR/const-expr-generic-err.rs:4:13
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ evaluation panicked: assertion failed: std::mem::size_of::<T>() == 0
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/inline-const/required-const.stderr b/tests/ui/inline-const/required-const.stderr
index 6ca4c250223e..a6c630b5477a 100644
--- a/tests/ui/inline-const/required-const.stderr
+++ b/tests/ui/inline-const/required-const.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `foo::<i32>::{constant#0}` failed
   --> $DIR/required-const.rs:6:17
    |
 LL |         const { panic!() }
-   |                 ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/required-const.rs:6:17
+   |                 ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/internal/internal-unstable.rs b/tests/ui/internal/internal-unstable.rs
index 35a2941633a4..381c1337148c 100644
--- a/tests/ui/internal/internal-unstable.rs
+++ b/tests/ui/internal/internal-unstable.rs
@@ -7,7 +7,7 @@
 extern crate internal_unstable;
 
 struct Baz {
-    #[allow_internal_unstable]
+    #[allow_internal_unstable] //~ ERROR `allow_internal_unstable` expects a list of feature names
     baz: u8,
 }
 
@@ -56,7 +56,7 @@ fn main() {
     bar!(internal_unstable::unstable()); //~ ERROR use of unstable
 
     match true {
-        #[allow_internal_unstable]
+        #[allow_internal_unstable] //~ ERROR `allow_internal_unstable` expects a list of feature names
         _ => {}
     }
 
diff --git a/tests/ui/internal/internal-unstable.stderr b/tests/ui/internal/internal-unstable.stderr
index ea74175f09b2..bbf589d3f926 100644
--- a/tests/ui/internal/internal-unstable.stderr
+++ b/tests/ui/internal/internal-unstable.stderr
@@ -1,3 +1,15 @@
+error: `allow_internal_unstable` expects a list of feature names
+  --> $DIR/internal-unstable.rs:10:5
+   |
+LL |     #[allow_internal_unstable]
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: `allow_internal_unstable` expects a list of feature names
+  --> $DIR/internal-unstable.rs:59:9
+   |
+LL |         #[allow_internal_unstable]
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0658]: use of unstable library feature `function`
   --> $DIR/internal-unstable.rs:48:25
    |
@@ -47,6 +59,6 @@ LL |     bar!(internal_unstable::unstable());
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
    = note: this error originates in the macro `foo` which comes from the expansion of the macro `bar` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: aborting due to 5 previous errors
+error: aborting due to 7 previous errors
 
 For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/intrinsics/always-gets-overridden.rs b/tests/ui/intrinsics/always-gets-overridden.rs
index 2fb64f96d830..aaac5415c210 100644
--- a/tests/ui/intrinsics/always-gets-overridden.rs
+++ b/tests/ui/intrinsics/always-gets-overridden.rs
@@ -1,5 +1,5 @@
-//! Check that `vtable_size` gets overridden by llvm backend even if there is no
-//! `rustc_intrinsic_must_be_overridden` attribute on this usage.
+//! Check that `vtable_size` gets overridden by llvm backend even if there is a
+//! fallback body.
 #![feature(intrinsics)]
 //@run-pass
 
diff --git a/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs b/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs
index 254ac24f0b94..d68cbf26ef11 100644
--- a/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs
+++ b/tests/ui/intrinsics/bad-intrinsic-monomorphization.rs
@@ -7,10 +7,6 @@
 // Bad monomorphizations could previously cause LLVM asserts even though the
 // error was caught in the compiler.
 
-extern "rust-intrinsic" {
-    fn simd_add<T>(x: T, y: T) -> T;
-}
-
 use std::intrinsics;
 
 #[derive(Copy, Clone)]
@@ -27,6 +23,6 @@ pub unsafe fn test_fadd_fast(a: Foo, b: Foo) -> Foo {
 }
 
 pub unsafe fn test_simd_add(a: Foo, b: Foo) -> Foo {
-    simd_add(a, b)
+    intrinsics::simd::simd_add(a, b)
     //~^ ERROR `simd_add` intrinsic: expected SIMD input type, found non-SIMD `Foo`
 }
diff --git a/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr b/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr
index c070f0181819..f49d95e9cfcb 100644
--- a/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr
+++ b/tests/ui/intrinsics/bad-intrinsic-monomorphization.stderr
@@ -1,20 +1,20 @@
 error[E0511]: invalid monomorphization of `cttz` intrinsic: expected basic integer type, found `Foo`
-  --> $DIR/bad-intrinsic-monomorphization.rs:20:5
+  --> $DIR/bad-intrinsic-monomorphization.rs:16:5
    |
 LL |     intrinsics::cttz(v)
    |     ^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `fadd_fast` intrinsic: expected basic float type, found `Foo`
-  --> $DIR/bad-intrinsic-monomorphization.rs:25:5
+  --> $DIR/bad-intrinsic-monomorphization.rs:21:5
    |
 LL |     intrinsics::fadd_fast(a, b)
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `Foo`
-  --> $DIR/bad-intrinsic-monomorphization.rs:30:5
+  --> $DIR/bad-intrinsic-monomorphization.rs:26:5
    |
-LL |     simd_add(a, b)
-   |     ^^^^^^^^^^^^^^
+LL |     intrinsics::simd::simd_add(a, b)
+   |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 3 previous errors
 
diff --git a/tests/ui/invalid/issue-114435-layout-type-err.rs b/tests/ui/invalid/issue-114435-layout-type-err.rs
index f68744a13c15..2a86839e416f 100644
--- a/tests/ui/invalid/issue-114435-layout-type-err.rs
+++ b/tests/ui/invalid/issue-114435-layout-type-err.rs
@@ -1,6 +1,6 @@
-//@ build-fail
+//@ check-fail
 //@ compile-flags: --crate-type lib -Cdebuginfo=2
-//@ error-pattern: the type has an unknown layout
+//@ error-pattern: recursion limit
 
 #![recursion_limit = "10"]
 macro_rules! link {
@@ -28,7 +28,6 @@ impl Bottom {
     }
 }
 
-
 link!(A, B);
 link!(B, C);
 link!(C, D);
@@ -41,4 +40,4 @@ link!(I, J);
 link!(J, K);
 link!(K, Bottom);
 
-fn main() { }
+fn main() {}
diff --git a/tests/ui/invalid/issue-114435-layout-type-err.stderr b/tests/ui/invalid/issue-114435-layout-type-err.stderr
index a2db74ff8bd8..2fddc62f004f 100644
--- a/tests/ui/invalid/issue-114435-layout-type-err.stderr
+++ b/tests/ui/invalid/issue-114435-layout-type-err.stderr
@@ -2,7 +2,5 @@ error: reached the recursion limit finding the struct tail for `Bottom`
    |
    = help: consider increasing the recursion limit by adding a `#![recursion_limit = "20"]`
 
-error: the type has an unknown layout
-
-error: aborting due to 2 previous errors
+error: aborting due to 1 previous error
 
diff --git a/tests/ui/invalid_dispatch_from_dyn_impls.rs b/tests/ui/invalid_dispatch_from_dyn_impls.rs
index b7bc766fbe02..972465d71978 100644
--- a/tests/ui/invalid_dispatch_from_dyn_impls.rs
+++ b/tests/ui/invalid_dispatch_from_dyn_impls.rs
@@ -8,9 +8,10 @@ use std::{
 struct WrapperWithExtraField<T>(T, i32);
 
 impl<T, U> DispatchFromDyn<WrapperWithExtraField<U>> for WrapperWithExtraField<T>
+//~^ ERROR [E0378]
 where
     T: DispatchFromDyn<U>,
-{} //~^^^ ERROR [E0378]
+{}
 
 
 struct MultiplePointers<T: ?Sized>{
@@ -19,9 +20,10 @@ struct MultiplePointers<T: ?Sized>{
 }
 
 impl<T: ?Sized, U: ?Sized> DispatchFromDyn<MultiplePointers<U>> for MultiplePointers<T>
+//~^ implementing `DispatchFromDyn` does not allow multiple fields to be coerced
 where
     T: Unsize<U>,
-{} //~^^^ ERROR [E0378]
+{}
 
 
 struct NothingToCoerce<T: ?Sized> {
@@ -29,23 +31,25 @@ struct NothingToCoerce<T: ?Sized> {
 }
 
 impl<T: ?Sized, U: ?Sized> DispatchFromDyn<NothingToCoerce<T>> for NothingToCoerce<U> {}
-//~^ ERROR [E0378]
+//~^ ERROR implementing `DispatchFromDyn` requires a field to be coerced
 
 #[repr(C)]
 struct HasReprC<T: ?Sized>(Box<T>);
 
 impl<T: ?Sized, U: ?Sized> DispatchFromDyn<HasReprC<U>> for HasReprC<T>
+//~^ ERROR [E0378]
 where
     T: Unsize<U>,
-{} //~^^^ ERROR [E0378]
+{}
 
 #[repr(align(64))]
 struct OverAlignedZst;
 struct OverAligned<T: ?Sized>(Box<T>, OverAlignedZst);
 
 impl<T: ?Sized, U: ?Sized> DispatchFromDyn<OverAligned<U>> for OverAligned<T>
+//~^ ERROR [E0378]
     where
         T: Unsize<U>,
-{} //~^^^ ERROR [E0378]
+{}
 
 fn main() {}
diff --git a/tests/ui/invalid_dispatch_from_dyn_impls.stderr b/tests/ui/invalid_dispatch_from_dyn_impls.stderr
index 02718334c733..93ec6bbe0896 100644
--- a/tests/ui/invalid_dispatch_from_dyn_impls.stderr
+++ b/tests/ui/invalid_dispatch_from_dyn_impls.stderr
@@ -2,25 +2,32 @@ error[E0378]: the trait `DispatchFromDyn` may only be implemented for structs co
   --> $DIR/invalid_dispatch_from_dyn_impls.rs:10:1
    |
 LL | / impl<T, U> DispatchFromDyn<WrapperWithExtraField<U>> for WrapperWithExtraField<T>
+LL | |
 LL | | where
 LL | |     T: DispatchFromDyn<U>,
    | |__________________________^
    |
    = note: extra field `1` of type `i32` is not allowed
 
-error[E0378]: implementing the `DispatchFromDyn` trait requires multiple coercions
-  --> $DIR/invalid_dispatch_from_dyn_impls.rs:21:1
+error[E0375]: implementing `DispatchFromDyn` does not allow multiple fields to be coerced
+  --> $DIR/invalid_dispatch_from_dyn_impls.rs:22:1
    |
 LL | / impl<T: ?Sized, U: ?Sized> DispatchFromDyn<MultiplePointers<U>> for MultiplePointers<T>
+LL | |
 LL | | where
 LL | |     T: Unsize<U>,
    | |_________________^
    |
-   = note: the trait `DispatchFromDyn` may only be implemented for a coercion between structures with a single field being coerced
-   = note: currently, 2 fields need coercions: `ptr1` (`*const T` to `*const U`), `ptr2` (`*const T` to `*const U`)
+note: the trait `DispatchFromDyn` may only be implemented when a single field is being coerced
+  --> $DIR/invalid_dispatch_from_dyn_impls.rs:18:5
+   |
+LL |     ptr1: *const T,
+   |     ^^^^^^^^^^^^^^
+LL |     ptr2: *const T,
+   |     ^^^^^^^^^^^^^^
 
-error[E0378]: the trait `DispatchFromDyn` may only be implemented for a coercion between structures
-  --> $DIR/invalid_dispatch_from_dyn_impls.rs:31:1
+error[E0374]: implementing `DispatchFromDyn` requires a field to be coerced
+  --> $DIR/invalid_dispatch_from_dyn_impls.rs:33:1
    |
 LL | impl<T: ?Sized, U: ?Sized> DispatchFromDyn<NothingToCoerce<T>> for NothingToCoerce<U> {}
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -28,17 +35,19 @@ LL | impl<T: ?Sized, U: ?Sized> DispatchFromDyn<NothingToCoerce<T>> for NothingT
    = note: expected a single field to be coerced, none found
 
 error[E0378]: structs implementing `DispatchFromDyn` may not have `#[repr(packed)]` or `#[repr(C)]`
-  --> $DIR/invalid_dispatch_from_dyn_impls.rs:37:1
+  --> $DIR/invalid_dispatch_from_dyn_impls.rs:39:1
    |
 LL | / impl<T: ?Sized, U: ?Sized> DispatchFromDyn<HasReprC<U>> for HasReprC<T>
+LL | |
 LL | | where
 LL | |     T: Unsize<U>,
    | |_________________^
 
 error[E0378]: the trait `DispatchFromDyn` may only be implemented for structs containing the field being coerced, ZST fields with 1 byte alignment that don't mention type/const generics, and nothing else
-  --> $DIR/invalid_dispatch_from_dyn_impls.rs:46:1
+  --> $DIR/invalid_dispatch_from_dyn_impls.rs:49:1
    |
 LL | / impl<T: ?Sized, U: ?Sized> DispatchFromDyn<OverAligned<U>> for OverAligned<T>
+LL | |
 LL | |     where
 LL | |         T: Unsize<U>,
    | |_____________________^
@@ -47,4 +56,5 @@ LL | |         T: Unsize<U>,
 
 error: aborting due to 5 previous errors
 
-For more information about this error, try `rustc --explain E0378`.
+Some errors have detailed explanations: E0374, E0375, E0378.
+For more information about an error, try `rustc --explain E0374`.
diff --git a/tests/ui/issues/issue-17373.stderr b/tests/ui/issues/issue-17373.stderr
index 9438f5c6345d..0e16d08c87d3 100644
--- a/tests/ui/issues/issue-17373.stderr
+++ b/tests/ui/issues/issue-17373.stderr
@@ -2,7 +2,7 @@ error[E0614]: type `!` cannot be dereferenced
   --> $DIR/issue-17373.rs:2:5
    |
 LL |     *return
-   |     ^^^^^^^
+   |     ^^^^^^^ can't be dereferenced
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/issues/issue-43988.stderr b/tests/ui/issues/issue-43988.stderr
index 7bbb8ed2ca94..d629f199b223 100644
--- a/tests/ui/issues/issue-43988.stderr
+++ b/tests/ui/issues/issue-43988.stderr
@@ -10,22 +10,6 @@ error: malformed `repr` attribute input
 LL |     let _z = #[repr] 1;
    |              ^^^^^^^ help: must be of the form: `#[repr(C)]`
 
-error[E0518]: attribute should be applied to function or closure
-  --> $DIR/issue-43988.rs:5:5
-   |
-LL |     #[inline]
-   |     ^^^^^^^^^
-LL |     let _a = 4;
-   |     ----------- not a function or closure
-
-error[E0518]: attribute should be applied to function or closure
-  --> $DIR/issue-43988.rs:10:5
-   |
-LL |     #[inline(XYZ)]
-   |     ^^^^^^^^^^^^^^
-LL |     let _b = 4;
-   |     ----------- not a function or closure
-
 error[E0552]: unrecognized representation hint
   --> $DIR/issue-43988.rs:14:12
    |
@@ -42,6 +26,22 @@ LL |     #[repr(something_not_real)]
    |
    = help: valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
 
+error[E0518]: attribute should be applied to function or closure
+  --> $DIR/issue-43988.rs:5:5
+   |
+LL |     #[inline]
+   |     ^^^^^^^^^
+LL |     let _a = 4;
+   |     ----------- not a function or closure
+
+error[E0518]: attribute should be applied to function or closure
+  --> $DIR/issue-43988.rs:10:5
+   |
+LL |     #[inline(XYZ)]
+   |     ^^^^^^^^^^^^^^
+LL |     let _b = 4;
+   |     ----------- not a function or closure
+
 error[E0518]: attribute should be applied to function or closure
   --> $DIR/issue-43988.rs:30:5
    |
diff --git a/tests/ui/issues/issue-76191.stderr b/tests/ui/issues/issue-76191.stderr
index a397d0821420..de08fc4ed0d8 100644
--- a/tests/ui/issues/issue-76191.stderr
+++ b/tests/ui/issues/issue-76191.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/issue-76191.rs:8:37
    |
 LL | const RANGE2: RangeInclusive<i32> = panic!();
-   |                                     ^^^^^^^^ the evaluated program panicked at 'explicit panic', $DIR/issue-76191.rs:8:37
+   |                                     ^^^^^^^^ evaluation panicked: explicit panic
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/issues/issue-9814.stderr b/tests/ui/issues/issue-9814.stderr
index d647edaf37e2..fa23fb7c1762 100644
--- a/tests/ui/issues/issue-9814.stderr
+++ b/tests/ui/issues/issue-9814.stderr
@@ -2,7 +2,7 @@ error[E0614]: type `Foo` cannot be dereferenced
   --> $DIR/issue-9814.rs:7:13
    |
 LL |     let _ = *Foo::Bar(2);
-   |             ^^^^^^^^^^^^
+   |             ^^^^^^^^^^^^ can't be dereferenced
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/kindck/kindck-inherited-copy-bound.rs b/tests/ui/kindck/kindck-inherited-copy-bound.rs
index dda95229ddf0..20d54a3fb106 100644
--- a/tests/ui/kindck/kindck-inherited-copy-bound.rs
+++ b/tests/ui/kindck/kindck-inherited-copy-bound.rs
@@ -1,8 +1,4 @@
 // Test that Copy bounds inherited by trait are checked.
-//
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
 
 
 use std::any::Any;
@@ -18,17 +14,15 @@ fn take_param<T:Foo>(foo: &T) { }
 
 fn a() {
     let x: Box<_> = Box::new(3);
-    take_param(&x); //[curr]~ ERROR E0277
-    //[dyn_compatible_for_dispatch]~^ ERROR E0277
+    take_param(&x); //~ ERROR E0277
 }
 
 fn b() {
     let x: Box<_> = Box::new(3);
     let y = &x;
     let z = &x as &dyn Foo;
-    //[curr]~^ ERROR E0038
-    //[curr]~| ERROR E0038
-    //[dyn_compatible_for_dispatch]~^^^ ERROR E0038
+    //~^ ERROR E0038
+    //~| ERROR E0038
 }
 
 fn main() { }
diff --git a/tests/ui/kindck/kindck-inherited-copy-bound.dyn_compatible_for_dispatch.stderr b/tests/ui/kindck/kindck-inherited-copy-bound.stderr
similarity index 55%
rename from tests/ui/kindck/kindck-inherited-copy-bound.dyn_compatible_for_dispatch.stderr
rename to tests/ui/kindck/kindck-inherited-copy-bound.stderr
index 296f011193e9..edfa7ae7769d 100644
--- a/tests/ui/kindck/kindck-inherited-copy-bound.dyn_compatible_for_dispatch.stderr
+++ b/tests/ui/kindck/kindck-inherited-copy-bound.stderr
@@ -1,5 +1,5 @@
 error[E0277]: the trait bound `Box<{integer}>: Foo` is not satisfied
-  --> $DIR/kindck-inherited-copy-bound.rs:21:16
+  --> $DIR/kindck-inherited-copy-bound.rs:17:16
    |
 LL |     take_param(&x);
    |     ---------- ^^ the trait `Copy` is not implemented for `Box<{integer}>`
@@ -7,35 +7,50 @@ LL |     take_param(&x);
    |     required by a bound introduced by this call
    |
 note: required for `Box<{integer}>` to implement `Foo`
-  --> $DIR/kindck-inherited-copy-bound.rs:14:14
+  --> $DIR/kindck-inherited-copy-bound.rs:10:14
    |
 LL | impl<T:Copy> Foo for T {
    |        ----  ^^^     ^
    |        |
    |        unsatisfied trait bound introduced here
 note: required by a bound in `take_param`
-  --> $DIR/kindck-inherited-copy-bound.rs:17:17
+  --> $DIR/kindck-inherited-copy-bound.rs:13:17
    |
 LL | fn take_param<T:Foo>(foo: &T) { }
    |                 ^^^ required by this bound in `take_param`
 
 error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/kindck-inherited-copy-bound.rs:28:13
+  --> $DIR/kindck-inherited-copy-bound.rs:23:19
+   |
+LL |     let z = &x as &dyn Foo;
+   |                   ^^^^^^^^ `Foo` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/kindck-inherited-copy-bound.rs:6:13
+   |
+LL | trait Foo : Copy {
+   |       ---   ^^^^ ...because it requires `Self: Sized`
+   |       |
+   |       this trait is not dyn compatible...
+
+error[E0038]: the trait `Foo` is not dyn compatible
+  --> $DIR/kindck-inherited-copy-bound.rs:23:13
    |
 LL |     let z = &x as &dyn Foo;
    |             ^^ `Foo` is not dyn compatible
    |
 note: for a trait to be dyn compatible it needs to allow building a vtable
       for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/kindck-inherited-copy-bound.rs:10:13
+  --> $DIR/kindck-inherited-copy-bound.rs:6:13
    |
 LL | trait Foo : Copy {
    |       ---   ^^^^ ...because it requires `Self: Sized`
    |       |
    |       this trait is not dyn compatible...
-   = note: required for the cast from `&Box<i32>` to `&dyn Foo`
+   = note: required for the cast from `&Box<{integer}>` to `&dyn Foo`
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
 Some errors have detailed explanations: E0038, E0277.
 For more information about an error, try `rustc --explain E0038`.
diff --git a/tests/ui/layout/hexagon-enum.rs b/tests/ui/layout/hexagon-enum.rs
index 5fa12e479e7d..02833eb41fad 100644
--- a/tests/ui/layout/hexagon-enum.rs
+++ b/tests/ui/layout/hexagon-enum.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --target hexagon-unknown-linux-musl
 //@ normalize-stderr: "randomization_seed: \d+" -> "randomization_seed: $$SEED"
 //@ needs-llvm-components: hexagon
@@ -9,8 +10,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang="sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[rustc_layout(debug)]
 #[repr(C)]
diff --git a/tests/ui/layout/hexagon-enum.stderr b/tests/ui/layout/hexagon-enum.stderr
index 90c06ba1f834..b802b400b18b 100644
--- a/tests/ui/layout/hexagon-enum.stderr
+++ b/tests/ui/layout/hexagon-enum.stderr
@@ -71,7 +71,7 @@ error: layout_of(A) = Layout {
            unadjusted_abi_align: Align(1 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/hexagon-enum.rs:17:1
+  --> $DIR/hexagon-enum.rs:18:1
    |
 LL | enum A { Apple }
    | ^^^^^^
@@ -149,7 +149,7 @@ error: layout_of(B) = Layout {
            unadjusted_abi_align: Align(1 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/hexagon-enum.rs:21:1
+  --> $DIR/hexagon-enum.rs:22:1
    |
 LL | enum B { Banana = 255, }
    | ^^^^^^
@@ -227,7 +227,7 @@ error: layout_of(C) = Layout {
            unadjusted_abi_align: Align(2 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/hexagon-enum.rs:25:1
+  --> $DIR/hexagon-enum.rs:26:1
    |
 LL | enum C { Chaenomeles = 256, }
    | ^^^^^^
@@ -305,7 +305,7 @@ error: layout_of(P) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/hexagon-enum.rs:29:1
+  --> $DIR/hexagon-enum.rs:30:1
    |
 LL | enum P { Peach = 0x1000_0000isize, }
    | ^^^^^^
@@ -383,7 +383,7 @@ error: layout_of(T) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/hexagon-enum.rs:35:1
+  --> $DIR/hexagon-enum.rs:36:1
    |
 LL | enum T { Tangerine = TANGERINE as isize }
    | ^^^^^^
diff --git a/tests/ui/layout/invalid-unsized-in-always-sized-tail.rs b/tests/ui/layout/invalid-unsized-in-always-sized-tail.rs
index 5df97338710d..c6d5f2bfa0ee 100644
--- a/tests/ui/layout/invalid-unsized-in-always-sized-tail.rs
+++ b/tests/ui/layout/invalid-unsized-in-always-sized-tail.rs
@@ -12,6 +12,6 @@ struct P2 {
     //~^ ERROR: the size for values of type `[bool]` cannot be known at compilation time
 }
 
-static CHECK: () = assert!(align_of::<P2>() == 1);
+static CHECK: () = assert!(align_of::<P2>() == 1); //~ ERROR could not evaluate static initializer
 
 fn main() {}
diff --git a/tests/ui/layout/invalid-unsized-in-always-sized-tail.stderr b/tests/ui/layout/invalid-unsized-in-always-sized-tail.stderr
index f54e97e2a5c7..3a4735e4832f 100644
--- a/tests/ui/layout/invalid-unsized-in-always-sized-tail.stderr
+++ b/tests/ui/layout/invalid-unsized-in-always-sized-tail.stderr
@@ -19,17 +19,13 @@ LL | struct MySlice<T>(T);
    |                this could be changed to `T: ?Sized`...
 
 error[E0080]: could not evaluate static initializer
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-   |
-   = note: the type `MySlice<[bool]>` has an unknown layout
-   |
-note: inside `align_of::<P2>`
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-note: inside `CHECK`
   --> $DIR/invalid-unsized-in-always-sized-tail.rs:15:28
    |
 LL | static CHECK: () = assert!(align_of::<P2>() == 1);
-   |                            ^^^^^^^^^^^^^^^^
+   |                            ^^^^^^^^^^^^^^^^ the type `MySlice<[bool]>` has an unknown layout
+   |
+note: inside `align_of::<P2>`
+  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/layout/thumb-enum.rs b/tests/ui/layout/thumb-enum.rs
index 2381d9d02926..1c4fab812f96 100644
--- a/tests/ui/layout/thumb-enum.rs
+++ b/tests/ui/layout/thumb-enum.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ compile-flags: --target thumbv8m.main-none-eabihf
 //@ normalize-stderr: "randomization_seed: \d+" -> "randomization_seed: $$SEED"
 //@ needs-llvm-components: arm
@@ -9,8 +10,8 @@
 #![crate_type = "lib"]
 #![no_core]
 
-#[lang="sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[rustc_layout(debug)]
 #[repr(C)]
diff --git a/tests/ui/layout/thumb-enum.stderr b/tests/ui/layout/thumb-enum.stderr
index 0c3433185647..07153fee0273 100644
--- a/tests/ui/layout/thumb-enum.stderr
+++ b/tests/ui/layout/thumb-enum.stderr
@@ -71,7 +71,7 @@ error: layout_of(A) = Layout {
            unadjusted_abi_align: Align(1 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/thumb-enum.rs:17:1
+  --> $DIR/thumb-enum.rs:18:1
    |
 LL | enum A { Apple }
    | ^^^^^^
@@ -149,7 +149,7 @@ error: layout_of(B) = Layout {
            unadjusted_abi_align: Align(1 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/thumb-enum.rs:21:1
+  --> $DIR/thumb-enum.rs:22:1
    |
 LL | enum B { Banana = 255, }
    | ^^^^^^
@@ -227,7 +227,7 @@ error: layout_of(C) = Layout {
            unadjusted_abi_align: Align(2 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/thumb-enum.rs:25:1
+  --> $DIR/thumb-enum.rs:26:1
    |
 LL | enum C { Chaenomeles = 256, }
    | ^^^^^^
@@ -305,7 +305,7 @@ error: layout_of(P) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/thumb-enum.rs:29:1
+  --> $DIR/thumb-enum.rs:30:1
    |
 LL | enum P { Peach = 0x1000_0000isize, }
    | ^^^^^^
@@ -383,7 +383,7 @@ error: layout_of(T) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/thumb-enum.rs:35:1
+  --> $DIR/thumb-enum.rs:36:1
    |
 LL | enum T { Tangerine = TANGERINE as isize }
    | ^^^^^^
diff --git a/tests/ui/layout/too-big-with-padding.rs b/tests/ui/layout/too-big-with-padding.rs
index 8423ad2e1d60..0f03bd10fb63 100644
--- a/tests/ui/layout/too-big-with-padding.rs
+++ b/tests/ui/layout/too-big-with-padding.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ build-fail
 //@ compile-flags: --target i686-unknown-linux-gnu --crate-type lib
 //@ needs-llvm-components: x86
@@ -6,13 +7,11 @@
 #![no_std]
 #![no_core]
 
+extern crate minicore;
+use minicore::*;
+
 // 0x7fffffff is fine, but after rounding up it becomes too big
 #[repr(C, align(2))]
 pub struct Example([u8; 0x7fffffff]);
 
 pub fn lib(_x: Example) {} //~ERROR: too big for the target architecture
-
-#[lang = "sized"]
-pub trait Sized {}
-#[lang = "copy"]
-pub trait Copy: Sized {}
diff --git a/tests/ui/layout/too-big-with-padding.stderr b/tests/ui/layout/too-big-with-padding.stderr
index fc3b4db049ac..761ac7514ee3 100644
--- a/tests/ui/layout/too-big-with-padding.stderr
+++ b/tests/ui/layout/too-big-with-padding.stderr
@@ -1,5 +1,5 @@
 error: values of the type `Example` are too big for the target architecture
-  --> $DIR/too-big-with-padding.rs:13:1
+  --> $DIR/too-big-with-padding.rs:17:1
    |
 LL | pub fn lib(_x: Example) {}
    | ^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/layout/unknown-when-no-type-parameter.stderr b/tests/ui/layout/unknown-when-no-type-parameter.stderr
index d0456e2b3293..9e414d224bbc 100644
--- a/tests/ui/layout/unknown-when-no-type-parameter.stderr
+++ b/tests/ui/layout/unknown-when-no-type-parameter.stderr
@@ -1,15 +1,11 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-   |
-   = note: the type `<() as Project>::Assoc` has an unknown layout
-   |
-note: inside `std::mem::size_of::<<() as Project>::Assoc>`
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-note: inside `foo::{constant#0}`
   --> $DIR/unknown-when-no-type-parameter.rs:11:10
    |
 LL |     [(); size_of::<<() as Project>::Assoc>()];
-   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ the type `<() as Project>::Assoc` has an unknown layout
+   |
+note: inside `std::mem::size_of::<<() as Project>::Assoc>`
+  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/lifetimes/unusual-rib-combinations.stderr b/tests/ui/lifetimes/unusual-rib-combinations.stderr
index b7effdc8d61d..7373ca8cf843 100644
--- a/tests/ui/lifetimes/unusual-rib-combinations.stderr
+++ b/tests/ui/lifetimes/unusual-rib-combinations.stderr
@@ -9,8 +9,6 @@ error[E0770]: the type of const parameters must not depend on other generic para
    |
 LL | struct Bar<const N: &'a (dyn for<'a> Foo<'a>)>;
    |                      ^^ the type must not depend on the parameter `'a`
-   |
-   = note: lifetime parameters may not be used in the type of const parameters
 
 error[E0214]: parenthesized type parameters may only be used with a `Fn` trait
   --> $DIR/unusual-rib-combinations.rs:11:15
diff --git a/tests/ui/limits/issue-55878.stderr b/tests/ui/limits/issue-55878.stderr
index d2b5150c5561..d705b3daf79e 100644
--- a/tests/ui/limits/issue-55878.stderr
+++ b/tests/ui/limits/issue-55878.stderr
@@ -1,15 +1,11 @@
 error[E0080]: evaluation of constant value failed
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-   |
-   = note: values of the type `[u8; usize::MAX]` are too big for the target architecture
-   |
-note: inside `std::mem::size_of::<[u8; usize::MAX]>`
-  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
-note: inside `main`
   --> $DIR/issue-55878.rs:5:26
    |
 LL |     println!("Size: {}", std::mem::size_of::<[u8; u64::MAX as usize]>());
-   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |                          ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ values of the type `[u8; usize::MAX]` are too big for the target architecture
+   |
+note: inside `std::mem::size_of::<[u8; usize::MAX]>`
+  --> $SRC_DIR/core/src/mem/mod.rs:LL:COL
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/lint/type-overflow.rs b/tests/ui/lint/type-overflow.rs
index 1e74a8925f62..16a021da0658 100644
--- a/tests/ui/lint/type-overflow.rs
+++ b/tests/ui/lint/type-overflow.rs
@@ -41,8 +41,12 @@ fn main() {
 
     let fail = 0x8FFF_FFFF_FFFF_FFFE; //~WARNING literal out of range for `i32`
     //~| HELP consider using the type `u64` instead
-    //~| HELP
+    //~| HELP consider using the type `u64` for the literal and cast it to `i32`
 
     let fail = -0b1111_1111i8; //~WARNING literal out of range for `i8`
     //~| HELP consider using the type `i16` instead
+
+    let fail = 0x8000_0000_0000_0000_0000_0000_FFFF_FFFE; //~WARNING literal out of range for `i32`
+    //~| HELP consider using the type `u128` instead
+    //~| HELP consider using the type `u128` for the literal and cast it to `i32`
 }
diff --git a/tests/ui/lint/type-overflow.stderr b/tests/ui/lint/type-overflow.stderr
index 4d6403b1e7db..065c530adcf5 100644
--- a/tests/ui/lint/type-overflow.stderr
+++ b/tests/ui/lint/type-overflow.stderr
@@ -112,9 +112,9 @@ LL |     let fail = 0x8FFF_FFFF_FFFF_FFFE;
    |
    = note: the literal `0x8FFF_FFFF_FFFF_FFFE` (decimal `10376293541461622782`) does not fit into the type `i32` and will become `-2i32`
    = help: consider using the type `u64` instead
-help: to use as a negative number (decimal `-2`), consider using the type `u32` for the literal and cast it to `i32`
+help: to use as a negative number (decimal `-2`), consider using the type `u64` for the literal and cast it to `i32`
    |
-LL |     let fail = 0x8FFF_FFFF_FFFF_FFFEu32 as i32;
+LL |     let fail = 0x8FFF_FFFF_FFFF_FFFEu64 as i32;
    |                                     ++++++++++
 
 warning: literal out of range for `i8`
@@ -126,5 +126,18 @@ LL |     let fail = -0b1111_1111i8;
    = note: the literal `0b1111_1111i8` (decimal `255`) does not fit into the type `i8`
    = note: and the value `-0b1111_1111i8` will become `1i8`
 
-warning: 11 warnings emitted
+warning: literal out of range for `i32`
+  --> $DIR/type-overflow.rs:49:16
+   |
+LL |     let fail = 0x8000_0000_0000_0000_0000_0000_FFFF_FFFE;
+   |                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the literal `0x8000_0000_0000_0000_0000_0000_FFFF_FFFE` (decimal `170141183460469231731687303720179073022`) does not fit into the type `i32` and will become `-2i32`
+   = help: consider using the type `u128` instead
+help: to use as a negative number (decimal `-2`), consider using the type `u128` for the literal and cast it to `i32`
+   |
+LL |     let fail = 0x8000_0000_0000_0000_0000_0000_FFFF_FFFEu128 as i32;
+   |                                                         +++++++++++
+
+warning: 12 warnings emitted
 
diff --git a/tests/ui/macros/nonterminal-matching.rs b/tests/ui/macros/nonterminal-matching.rs
index a655b6651031..ca95e8fac050 100644
--- a/tests/ui/macros/nonterminal-matching.rs
+++ b/tests/ui/macros/nonterminal-matching.rs
@@ -31,7 +31,7 @@ macro_rules! foo {
     (tt $x:tt) => { bar!(tt $x); };
     (expr $x:expr) => { bar!(expr $x); }; //~ ERROR: no rules expected expression `3`
     (literal $x:literal) => { bar!(literal $x); }; //~ ERROR: no rules expected literal `4`
-    (path $x:path) => { bar!(path $x); }; //~ ERROR: no rules expected path `a::b::c`
+    (path $x:path) => { bar!(path $x); }; //~ ERROR: no rules expected `path` metavariable
     (stmt $x:stmt) => { bar!(stmt $x); }; //~ ERROR: no rules expected statement `let abc = 0`
 }
 
diff --git a/tests/ui/macros/nonterminal-matching.stderr b/tests/ui/macros/nonterminal-matching.stderr
index e283dfcb8fdc..ba2b3e213ad0 100644
--- a/tests/ui/macros/nonterminal-matching.stderr
+++ b/tests/ui/macros/nonterminal-matching.stderr
@@ -67,7 +67,7 @@ LL |     (literal 4) => {};
    = help: try using `:tt` instead in the macro definition
    = note: this error originates in the macro `foo` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: no rules expected path `a::b::c`
+error: no rules expected `path` metavariable
   --> $DIR/nonterminal-matching.rs:34:35
    |
 LL |     (path $x:path) => { bar!(path $x); };
diff --git a/tests/ui/macros/trace_faulty_macros.rs b/tests/ui/macros/trace_faulty_macros.rs
index 87036bb9c6f7..e0cbbd8f5c9e 100644
--- a/tests/ui/macros/trace_faulty_macros.rs
+++ b/tests/ui/macros/trace_faulty_macros.rs
@@ -46,7 +46,7 @@ macro_rules! test {
     (let $p:pat = $e:expr) => {test!(($p,$e))};
     // this should be expr
     //           vvv
-    (($p:pat, $e:pat)) => {let $p = $e;}; //~ ERROR expected expression, found pattern `1+1`
+    (($p:pat, $e:pat)) => {let $p = $e;}; //~ ERROR expected expression, found `pat` metavariable
 }
 
 fn foo() {
diff --git a/tests/ui/macros/trace_faulty_macros.stderr b/tests/ui/macros/trace_faulty_macros.stderr
index 10ad3faab161..73fed66e6190 100644
--- a/tests/ui/macros/trace_faulty_macros.stderr
+++ b/tests/ui/macros/trace_faulty_macros.stderr
@@ -50,7 +50,7 @@ LL |     my_recursive_macro!();
    = note: expanding `my_recursive_macro! {  }`
    = note: to `my_recursive_macro! ();`
 
-error: expected expression, found pattern `A { a : a, b : 0, c : _, .. }`
+error: expected expression, found `pat` metavariable
   --> $DIR/trace_faulty_macros.rs:16:9
    |
 LL |         $a
@@ -69,22 +69,15 @@ LL | #[derive(Debug)]
 LL | fn use_derive_macro_as_attr() {}
    | -------------------------------- not a `struct`, `enum` or `union`
 
-error: expected expression, found pattern `1+1`
+error: expected expression, found `pat` metavariable
   --> $DIR/trace_faulty_macros.rs:49:37
    |
-LL |     (let $p:pat = $e:expr) => {test!(($p,$e))};
-   |                                          -- this is interpreted as expression, but it is expected to be pattern
-...
 LL |     (($p:pat, $e:pat)) => {let $p = $e;};
    |                                     ^^ expected expression
 ...
 LL |     test!(let x = 1+1);
-   |     ------------------
-   |     |             |
-   |     |             this is expected to be expression
-   |     in this macro invocation
+   |     ------------------ in this macro invocation
    |
-   = note: when forwarding a matched fragment to another macro-by-example, matchers in the second macro will see an opaque AST of the fragment type, not the underlying tokens
    = note: this error originates in the macro `test` (in Nightly builds, run with -Z macro-backtrace for more info)
 
 note: trace_macro
diff --git a/tests/ui/mir/checks_without_panic_impl.rs b/tests/ui/mir/checks_without_panic_impl.rs
index 0dba5784daa5..11ab50a5f9af 100644
--- a/tests/ui/mir/checks_without_panic_impl.rs
+++ b/tests/ui/mir/checks_without_panic_impl.rs
@@ -2,6 +2,7 @@
 // does not prevent crates without a panic_impl from compiling.
 // See rust-lang/rust#109996
 
+//@ add-core-stubs
 //@ build-pass
 //@ compile-flags: -Cdebug-assertions=yes
 
@@ -11,7 +12,7 @@
 #![feature(no_core)]
 #![no_core]
 
-#[lang = "sized"]
-trait Foo {}
+extern crate minicore;
+use minicore::*;
 
 pub unsafe fn foo(x: *const i32) -> &'static i32 { unsafe { &*x } }
diff --git a/tests/ui/never_type/unused_trait_in_never_pattern_body.rs b/tests/ui/never_type/unused_trait_in_never_pattern_body.rs
new file mode 100644
index 000000000000..8179c94b72b2
--- /dev/null
+++ b/tests/ui/never_type/unused_trait_in_never_pattern_body.rs
@@ -0,0 +1,12 @@
+fn a() {
+    match 0 {
+        ! => || { //~ ERROR `!` patterns are experimental
+        //~^ ERROR a never pattern is always unreachable
+        //~^^ ERROR mismatched types
+            use std::ops::Add;
+            0.add(1)
+        },
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/never_type/unused_trait_in_never_pattern_body.stderr b/tests/ui/never_type/unused_trait_in_never_pattern_body.stderr
new file mode 100644
index 000000000000..18ca9f12b7e8
--- /dev/null
+++ b/tests/ui/never_type/unused_trait_in_never_pattern_body.stderr
@@ -0,0 +1,36 @@
+error[E0658]: `!` patterns are experimental
+  --> $DIR/unused_trait_in_never_pattern_body.rs:3:9
+   |
+LL |         ! => || {
+   |         ^
+   |
+   = note: see issue #118155 <https://github.com/rust-lang/rust/issues/118155> for more information
+   = help: add `#![feature(never_patterns)]` to the crate attributes to enable
+   = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+
+error: a never pattern is always unreachable
+  --> $DIR/unused_trait_in_never_pattern_body.rs:3:14
+   |
+LL |           ! => || {
+   |  ______________^
+LL | |
+LL | |
+LL | |             use std::ops::Add;
+LL | |             0.add(1)
+LL | |         },
+   | |         ^
+   | |         |
+   | |_________this will never be executed
+   |           help: remove this expression
+
+error: mismatched types
+  --> $DIR/unused_trait_in_never_pattern_body.rs:3:9
+   |
+LL |         ! => || {
+   |         ^ a never pattern must be used on an uninhabited type
+   |
+   = note: the matched value is of type `i32`
+
+error: aborting due to 3 previous errors
+
+For more information about this error, try `rustc --explain E0658`.
diff --git a/tests/ui/parser/attribute/attr-bad-meta-4.rs b/tests/ui/parser/attribute/attr-bad-meta-4.rs
index 2a69ae5ac063..2d0c6dbb50ab 100644
--- a/tests/ui/parser/attribute/attr-bad-meta-4.rs
+++ b/tests/ui/parser/attribute/attr-bad-meta-4.rs
@@ -1,8 +1,8 @@
 macro_rules! mac {
     ($attr_item: meta) => {
         #[cfg($attr_item)]
-        //~^ ERROR expected unsuffixed literal, found `an(arbitrary token stream)`
-        //~| ERROR expected unsuffixed literal, found `an(arbitrary token stream)`
+        //~^ ERROR expected unsuffixed literal, found `meta` metavariable
+        //~| ERROR expected unsuffixed literal, found `meta` metavariable
         struct S;
     }
 }
diff --git a/tests/ui/parser/attribute/attr-bad-meta-4.stderr b/tests/ui/parser/attribute/attr-bad-meta-4.stderr
index 192be28db3fb..dea574fd36d5 100644
--- a/tests/ui/parser/attribute/attr-bad-meta-4.stderr
+++ b/tests/ui/parser/attribute/attr-bad-meta-4.stderr
@@ -4,7 +4,7 @@ error: expected unsuffixed literal, found `-`
 LL | #[cfg(feature = -1)]
    |                 ^
 
-error: expected unsuffixed literal, found `an(arbitrary token stream)`
+error: expected unsuffixed literal, found `meta` metavariable
   --> $DIR/attr-bad-meta-4.rs:3:15
    |
 LL |         #[cfg($attr_item)]
@@ -15,7 +15,7 @@ LL | mac!(an(arbitrary token stream));
    |
    = note: this error originates in the macro `mac` (in Nightly builds, run with -Z macro-backtrace for more info)
 
-error: expected unsuffixed literal, found `an(arbitrary token stream)`
+error: expected unsuffixed literal, found `meta` metavariable
   --> $DIR/attr-bad-meta-4.rs:3:15
    |
 LL |         #[cfg($attr_item)]
diff --git a/tests/ui/parser/attribute/attr-unquoted-ident.rs b/tests/ui/parser/attribute/attr-unquoted-ident.rs
index 5b15b8d69fcf..396265f715e9 100644
--- a/tests/ui/parser/attribute/attr-unquoted-ident.rs
+++ b/tests/ui/parser/attribute/attr-unquoted-ident.rs
@@ -19,7 +19,7 @@ fn main() {
 
 macro_rules! make {
     ($name:ident) => { #[doc(alias = $name)] pub struct S; }
-    //~^ ERROR expected unsuffixed literal, found `nickname`
+    //~^ ERROR expected unsuffixed literal, found identifier `nickname`
 }
 
 make!(nickname); //~ NOTE in this expansion
diff --git a/tests/ui/parser/attribute/attr-unquoted-ident.stderr b/tests/ui/parser/attribute/attr-unquoted-ident.stderr
index e0f99459c44e..2d7997f1aea5 100644
--- a/tests/ui/parser/attribute/attr-unquoted-ident.stderr
+++ b/tests/ui/parser/attribute/attr-unquoted-ident.stderr
@@ -20,7 +20,7 @@ help: surround the identifier with quotation marks to make it into a string lite
 LL |     #[cfg(key="foo bar baz")]
    |               +           +
 
-error: expected unsuffixed literal, found `nickname`
+error: expected unsuffixed literal, found identifier `nickname`
   --> $DIR/attr-unquoted-ident.rs:21:38
    |
 LL |     ($name:ident) => { #[doc(alias = $name)] pub struct S; }
diff --git a/tests/ui/parser/expr-as-stmt.stderr b/tests/ui/parser/expr-as-stmt.stderr
index 76a83aa0161b..577c3455a718 100644
--- a/tests/ui/parser/expr-as-stmt.stderr
+++ b/tests/ui/parser/expr-as-stmt.stderr
@@ -133,7 +133,7 @@ error[E0614]: type `{integer}` cannot be dereferenced
   --> $DIR/expr-as-stmt.rs:25:11
    |
 LL |     { 3 } * 3
-   |           ^^^
+   |           ^^^ can't be dereferenced
    |
 help: parentheses are required to parse this as an expression
    |
diff --git a/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs b/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs
index 30f3781bf774..1a0833ebb2f6 100644
--- a/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs
+++ b/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.rs
@@ -12,7 +12,7 @@ macro_rules! mac2 {
     ($eval:pat) => {
         let mut $eval = ();
         //~^ ERROR `mut` must be followed by a named binding
-        //~| ERROR expected identifier, found `does_not_exist!()`
+        //~| ERROR expected identifier, found metavariable
     };
 }
 
diff --git a/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.stderr b/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.stderr
index dda37d83282c..59e1b64686b4 100644
--- a/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.stderr
+++ b/tests/ui/parser/issues/issue-65122-mac-invoc-in-mut-patterns.stderr
@@ -15,11 +15,11 @@ LL -         let mut $eval = ();
 LL +         let $eval = ();
    |
 
-error: expected identifier, found `does_not_exist!()`
+error: expected identifier, found metavariable
   --> $DIR/issue-65122-mac-invoc-in-mut-patterns.rs:13:17
    |
 LL |         let mut $eval = ();
-   |                 ^^^^^ expected identifier
+   |                 ^^^^^ expected identifier, found metavariable
 ...
 LL |     mac2! { does_not_exist!() }
    |     --------------------------- in this macro invocation
diff --git a/tests/ui/parser/mut-patterns.rs b/tests/ui/parser/mut-patterns.rs
index 45968a516e3d..ed33968c627e 100644
--- a/tests/ui/parser/mut-patterns.rs
+++ b/tests/ui/parser/mut-patterns.rs
@@ -45,7 +45,7 @@ pub fn main() {
     // Make sure we don't accidentally allow `mut $p` where `$p:pat`.
     macro_rules! foo {
         ($p:pat) => {
-            let mut $p = 0; //~ ERROR expected identifier, found `x`
+            let mut $p = 0; //~ ERROR expected identifier, found metavariable
         }
     }
     foo!(x);
diff --git a/tests/ui/parser/mut-patterns.stderr b/tests/ui/parser/mut-patterns.stderr
index 43f6a344bf39..9dda2499f03c 100644
--- a/tests/ui/parser/mut-patterns.stderr
+++ b/tests/ui/parser/mut-patterns.stderr
@@ -158,11 +158,11 @@ LL -     let mut W(mut a, W(b, W(ref c, W(d, B { box f }))))
 LL +     let W(mut a, W(mut b, W(ref c, W(mut d, B { box mut f }))))
    |
 
-error: expected identifier, found `x`
+error: expected identifier, found metavariable
   --> $DIR/mut-patterns.rs:48:21
    |
 LL |             let mut $p = 0;
-   |                     ^^ expected identifier
+   |                     ^^ expected identifier, found metavariable
 ...
 LL |     foo!(x);
    |     ------- in this macro invocation
diff --git a/tests/ui/pattern/bindings-after-at/nested-binding-modes-ref.stderr b/tests/ui/pattern/bindings-after-at/nested-binding-modes-ref.stderr
index b378fe356ce1..46477f16090b 100644
--- a/tests/ui/pattern/bindings-after-at/nested-binding-modes-ref.stderr
+++ b/tests/ui/pattern/bindings-after-at/nested-binding-modes-ref.stderr
@@ -2,13 +2,13 @@ error[E0614]: type `{integer}` cannot be dereferenced
   --> $DIR/nested-binding-modes-ref.rs:4:5
    |
 LL |     *is_val;
-   |     ^^^^^^^
+   |     ^^^^^^^ can't be dereferenced
 
 error[E0614]: type `{integer}` cannot be dereferenced
   --> $DIR/nested-binding-modes-ref.rs:9:5
    |
 LL |     *is_val;
-   |     ^^^^^^^
+   |     ^^^^^^^ can't be dereferenced
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/proc-macro/derive-cfg-nested-tokens.rs b/tests/ui/proc-macro/derive-cfg-nested-tokens.rs
new file mode 100644
index 000000000000..7d4e8d8373d6
--- /dev/null
+++ b/tests/ui/proc-macro/derive-cfg-nested-tokens.rs
@@ -0,0 +1,23 @@
+// A regression test for issue #81099.
+
+//@ check-pass
+//@ proc-macro:test-macros.rs
+
+#![feature(stmt_expr_attributes)]
+#![feature(proc_macro_hygiene)]
+
+#[macro_use]
+extern crate test_macros;
+
+#[derive(Clone, Copy)]
+struct S {
+    // `print_args` runs twice
+    // - on eagerly configured `S` (from `impl Copy`), only 11 should be printed
+    // - on non-configured `S` (from `struct S`), both 10 and 11 should be printed
+    field: [u8; #[print_attr] {
+        #[cfg(FALSE)] { 10 }
+        #[cfg(not(FALSE))]  { 11 }
+    }],
+}
+
+fn main() {}
diff --git a/tests/ui/proc-macro/derive-cfg-nested-tokens.stdout b/tests/ui/proc-macro/derive-cfg-nested-tokens.stdout
new file mode 100644
index 000000000000..05bf21ee8f9b
--- /dev/null
+++ b/tests/ui/proc-macro/derive-cfg-nested-tokens.stdout
@@ -0,0 +1,149 @@
+PRINT-ATTR INPUT (DISPLAY): { #[cfg(not(FALSE))] { 11 } }
+PRINT-ATTR INPUT (DEBUG): TokenStream [
+    Group {
+        delimiter: Brace,
+        stream: TokenStream [
+            Punct {
+                ch: '#',
+                spacing: Alone,
+                span: #0 bytes(491..492),
+            },
+            Group {
+                delimiter: Bracket,
+                stream: TokenStream [
+                    Ident {
+                        ident: "cfg",
+                        span: #0 bytes(493..496),
+                    },
+                    Group {
+                        delimiter: Parenthesis,
+                        stream: TokenStream [
+                            Ident {
+                                ident: "not",
+                                span: #0 bytes(497..500),
+                            },
+                            Group {
+                                delimiter: Parenthesis,
+                                stream: TokenStream [
+                                    Ident {
+                                        ident: "FALSE",
+                                        span: #0 bytes(501..506),
+                                    },
+                                ],
+                                span: #0 bytes(500..507),
+                            },
+                        ],
+                        span: #0 bytes(496..508),
+                    },
+                ],
+                span: #0 bytes(492..509),
+            },
+            Group {
+                delimiter: Brace,
+                stream: TokenStream [
+                    Literal {
+                        kind: Integer,
+                        symbol: "11",
+                        suffix: None,
+                        span: #0 bytes(513..515),
+                    },
+                ],
+                span: #0 bytes(511..517),
+            },
+        ],
+        span: #0 bytes(452..523),
+    },
+]
+PRINT-ATTR INPUT (DISPLAY): { #[cfg(FALSE)] { 10 } #[cfg(not(FALSE))] { 11 } }
+PRINT-ATTR INPUT (DEBUG): TokenStream [
+    Group {
+        delimiter: Brace,
+        stream: TokenStream [
+            Punct {
+                ch: '#',
+                spacing: Alone,
+                span: #0 bytes(462..463),
+            },
+            Group {
+                delimiter: Bracket,
+                stream: TokenStream [
+                    Ident {
+                        ident: "cfg",
+                        span: #0 bytes(464..467),
+                    },
+                    Group {
+                        delimiter: Parenthesis,
+                        stream: TokenStream [
+                            Ident {
+                                ident: "FALSE",
+                                span: #0 bytes(468..473),
+                            },
+                        ],
+                        span: #0 bytes(467..474),
+                    },
+                ],
+                span: #0 bytes(463..475),
+            },
+            Group {
+                delimiter: Brace,
+                stream: TokenStream [
+                    Literal {
+                        kind: Integer,
+                        symbol: "10",
+                        suffix: None,
+                        span: #0 bytes(478..480),
+                    },
+                ],
+                span: #0 bytes(476..482),
+            },
+            Punct {
+                ch: '#',
+                spacing: Alone,
+                span: #0 bytes(491..492),
+            },
+            Group {
+                delimiter: Bracket,
+                stream: TokenStream [
+                    Ident {
+                        ident: "cfg",
+                        span: #0 bytes(493..496),
+                    },
+                    Group {
+                        delimiter: Parenthesis,
+                        stream: TokenStream [
+                            Ident {
+                                ident: "not",
+                                span: #0 bytes(497..500),
+                            },
+                            Group {
+                                delimiter: Parenthesis,
+                                stream: TokenStream [
+                                    Ident {
+                                        ident: "FALSE",
+                                        span: #0 bytes(501..506),
+                                    },
+                                ],
+                                span: #0 bytes(500..507),
+                            },
+                        ],
+                        span: #0 bytes(496..508),
+                    },
+                ],
+                span: #0 bytes(492..509),
+            },
+            Group {
+                delimiter: Brace,
+                stream: TokenStream [
+                    Literal {
+                        kind: Integer,
+                        symbol: "11",
+                        suffix: None,
+                        span: #0 bytes(513..515),
+                    },
+                ],
+                span: #0 bytes(511..517),
+            },
+        ],
+        span: #0 bytes(452..523),
+    },
+]
diff --git a/tests/ui/process/win-command-child-path.rs b/tests/ui/process/win-command-child-path.rs
new file mode 100644
index 000000000000..7ec2679749fb
--- /dev/null
+++ b/tests/ui/process/win-command-child-path.rs
@@ -0,0 +1,72 @@
+//@ run-pass
+//@ only-windows
+//@ needs-subprocess
+//@ no-prefer-dynamic
+
+// Test Windows std::process::Command search path semantics when setting PATH on the child process.
+// NOTE: The exact semantics here are (possibly) subject to change.
+
+use std::process::Command;
+use std::{env, fs, path};
+
+fn main() {
+    if env::args().skip(1).any(|s| s == "--child") {
+        child();
+    } else if env::args().skip(1).any(|s| s == "--parent") {
+        parent();
+    } else {
+        setup();
+    }
+}
+
+// Set up the directories so that there are three app dirs:
+// app: Where the parent app is run from
+// parent: In the parent's PATH env var
+// child: In the child's PATH env var
+fn setup() {
+    let exe = env::current_exe().unwrap();
+
+    fs::create_dir_all("app").unwrap();
+    fs::copy(&exe, "app/myapp.exe").unwrap();
+    fs::create_dir_all("parent").unwrap();
+    fs::copy(&exe, "parent/myapp.exe").unwrap();
+    fs::create_dir_all("child").unwrap();
+    fs::copy(&exe, "child/myapp.exe").unwrap();
+
+    let parent_path = path::absolute("parent").unwrap();
+    let status =
+        Command::new("./app/myapp.exe").env("PATH", parent_path).arg("--parent").status().unwrap();
+    // print the status in case of abnormal exit
+    dbg!(status);
+    assert!(status.success());
+}
+
+// The child simply prints the name of its parent directory.
+fn child() {
+    let exe = env::current_exe().unwrap();
+    let parent = exe.parent().unwrap().file_name().unwrap();
+    println!("{}", parent.display());
+}
+
+fn parent() {
+    let exe = env::current_exe().unwrap();
+    let name = exe.file_name().unwrap();
+
+    // By default, the application dir will be search first for the exe
+    let output = Command::new(&name).arg("--child").output().unwrap();
+    assert_eq!(output.stdout, b"app\n");
+
+    // Setting an environment variable should not change the above.
+    let output = Command::new(&name).arg("--child").env("a", "b").output().unwrap();
+    assert_eq!(output.stdout, b"app\n");
+
+    // Setting a child path means that path will be searched first.
+    let child_path = path::absolute("child").unwrap();
+    let output = Command::new(&name).arg("--child").env("PATH", child_path).output().unwrap();
+    assert_eq!(output.stdout, b"child\n");
+
+    // Setting a child path that does not contain the exe (currently) means
+    // we fallback to searching the app dir.
+    let output = Command::new(&name).arg("--child").env("PATH", "").output().unwrap();
+    assert_eq!(output.stdout, b"app\n");
+}
diff --git a/tests/ui/reachable/expr_unary.stderr b/tests/ui/reachable/expr_unary.stderr
index 0a763087c6f1..7deca1b86021 100644
--- a/tests/ui/reachable/expr_unary.stderr
+++ b/tests/ui/reachable/expr_unary.stderr
@@ -2,7 +2,7 @@ error[E0614]: type `!` cannot be dereferenced
   --> $DIR/expr_unary.rs:8:16
    |
 LL |     let x: ! = * { return; };
-   |                ^^^^^^^^^^^^^
+   |                ^^^^^^^^^^^^^ can't be dereferenced
 
 error: unreachable expression
   --> $DIR/expr_unary.rs:8:16
diff --git a/tests/ui/repeat-expr/copy-check-deferred-after-fallback.rs b/tests/ui/repeat-expr/copy-check-deferred-after-fallback.rs
new file mode 100644
index 000000000000..d9ad93541ecf
--- /dev/null
+++ b/tests/ui/repeat-expr/copy-check-deferred-after-fallback.rs
@@ -0,0 +1,37 @@
+#![feature(generic_arg_infer)]
+
+// Test that would start passing if we defer repeat expr copy checks to end of
+// typechecking and they're checked after integer fallback occurs. We accomplish
+// this by contriving a situation where integer fallback allows progress to be
+// made on a trait goal that infers the length of a repeat expr.
+
+use std::marker::PhantomData;
+
+struct NotCopy;
+
+trait Trait<const N: usize> {}
+
+impl Trait<2> for u32 {}
+impl Trait<1> for i32 {}
+
+fn make_goal<T: Trait<N>, const N: usize>(_: &T, _: [NotCopy; N]) {}
+
+fn main() {
+    let a = 1;
+    let b = [NotCopy; _];
+    //~^ ERROR: type annotations needed
+
+    // a is of type `?y`
+    // b is of type `[NotCopy; ?x]`
+    // there is a goal ?y: Trait<?x>` with two candidates:
+    // - `i32: Trait<1>`, ?y=i32 ?x=1 which doesnt require `NotCopy: Copy`
+    // - `u32: Trait<2>` ?y=u32 ?x=2 which requires `NotCopy: Copy`
+    make_goal(&a, b);
+
+    // final repeat expr checks:
+    //
+    // `NotCopy; ?x`
+    // - succeeds if fallback happens before repeat exprs as `i32: Trait<?x>` infers `?x=1`
+    // - fails if repeat expr checks happen first as `?x` is unconstrained so cannot be
+    //    structurally resolved
+}
diff --git a/tests/ui/repeat-expr/copy-check-deferred-after-fallback.stderr b/tests/ui/repeat-expr/copy-check-deferred-after-fallback.stderr
new file mode 100644
index 000000000000..2a0cb3fb7a39
--- /dev/null
+++ b/tests/ui/repeat-expr/copy-check-deferred-after-fallback.stderr
@@ -0,0 +1,14 @@
+error[E0282]: type annotations needed for `[NotCopy; _]`
+  --> $DIR/copy-check-deferred-after-fallback.rs:21:9
+   |
+LL |     let b = [NotCopy; _];
+   |         ^    ------- type must be known at this point
+   |
+help: consider giving `b` an explicit type, where the value of const parameter `N` is specified
+   |
+LL |     let b: [_; N] = [NotCopy; _];
+   |          ++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/repeat-expr/copy-check-deferred-before-fallback.rs b/tests/ui/repeat-expr/copy-check-deferred-before-fallback.rs
new file mode 100644
index 000000000000..4654d7483a64
--- /dev/null
+++ b/tests/ui/repeat-expr/copy-check-deferred-before-fallback.rs
@@ -0,0 +1,59 @@
+//@ check-pass
+
+#![feature(generic_arg_infer)]
+
+// Test that if we defer repeat expr copy checks to end of typechecking they're
+// checked before integer fallback occurs. We accomplish this by contriving a
+// situation where we have a goal that can be proven either via another repeat expr
+// check or by integer fallback. In the integer fallback case an array length would
+// be inferred to `2` requiring `NotCopy: Copy`, and in the repeat expr case it would
+// be inferred to `1`.
+
+use std::marker::PhantomData;
+
+struct NotCopy;
+
+struct Foo<T>(PhantomData<T>);
+
+impl Clone for Foo<u32> {
+    fn clone(&self) -> Self {
+        Foo(PhantomData)
+    }
+}
+
+impl Copy for Foo<u32> {}
+
+fn tie<T>(_: &T, _: [Foo<T>; 2]) {}
+
+trait Trait<const N: usize> {}
+
+impl Trait<2> for i32 {}
+impl Trait<1> for u32 {}
+
+fn make_goal<T: Trait<N>, const N: usize>(_: &T, _: [NotCopy; N]) {}
+
+fn main() {
+    let a = 1;
+    let b: [Foo<_>; 2] = [Foo(PhantomData); _];
+    tie(&a, b);
+    let c = [NotCopy; _];
+
+    // a is of type `?y`
+    // b is of type `[Foo<?y>; 2]`
+    // c is of type `[NotCopy; ?x]`
+    // there is a goal ?y: Trait<?x>` with two candidates:
+    // - `i32: Trait<2>`, ?y=i32 ?x=2 which requires `NotCopy: Copy` when expr checks happen
+    // - `u32: Trait<1>` ?y=u32 ?x=1 which doesnt require `NotCopy: Copy`
+    make_goal(&a, c);
+
+    // final repeat expr checks:
+    //
+    // `Foo<?y>; 2`
+    // - Foo<?y>: Copy
+    // - requires ?y=u32
+    //
+    // `NotCopy; ?x`
+    // - fails if fallback happens before repeat exprs as `i32: Trait<?x>` infers `?x=2`
+    // - succeeds if repeat expr checks happen first as `?y=u32` means `u32: Trait<?x>`
+    //    infers `?x=1`
+}
diff --git a/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.gai.stderr b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.gai.stderr
new file mode 100644
index 000000000000..de38476c82b3
--- /dev/null
+++ b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.gai.stderr
@@ -0,0 +1,17 @@
+error[E0282]: type annotations needed for `[Foo<_>; 2]`
+  --> $DIR/copy-inference-side-effects-are-lazy.rs:22:9
+   |
+LL |     let x = [Foo(PhantomData); 2];
+   |         ^
+LL |
+LL |     _ = extract(x).max(2);
+   |         ---------- type must be known at this point
+   |
+help: consider giving `x` an explicit type, where the type for type parameter `T` is specified
+   |
+LL |     let x: [Foo<T>; 2] = [Foo(PhantomData); 2];
+   |          +++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.rs b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.rs
new file mode 100644
index 000000000000..0b0672d9c2b5
--- /dev/null
+++ b/tests/ui/repeat-expr/copy-inference-side-effects-are-lazy.rs
@@ -0,0 +1,25 @@
+//@revisions: current gai
+//@[current] check-pass
+
+#![cfg_attr(gai, feature(generic_arg_infer))]
+
+use std::marker::PhantomData;
+
+struct Foo<T>(PhantomData<T>);
+
+impl Clone for Foo<u8> {
+    fn clone(&self) -> Self {
+        Foo(PhantomData)
+    }
+}
+impl Copy for Foo<u8> {}
+
+fn extract<T, const N: usize>(_: [Foo<T>; N]) -> T {
+    loop {}
+}
+
+fn main() {
+    let x = [Foo(PhantomData); 2];
+    //[gai]~^ ERROR: type annotations needed
+    _ = extract(x).max(2);
+}
diff --git a/tests/ui/repeat-expr/infer.rs b/tests/ui/repeat-expr/copy-inference-side-effects.rs
similarity index 100%
rename from tests/ui/repeat-expr/infer.rs
rename to tests/ui/repeat-expr/copy-inference-side-effects.rs
diff --git a/tests/ui/repeat-expr/dont-require-copy-on-infer.rs b/tests/ui/repeat-expr/dont-require-copy-on-infer.rs
new file mode 100644
index 000000000000..e81bf1595be1
--- /dev/null
+++ b/tests/ui/repeat-expr/dont-require-copy-on-infer.rs
@@ -0,0 +1,6 @@
+//@ check-pass
+#![feature(generic_arg_infer)]
+
+fn main() {
+    let a: [_; 1] = [String::new(); _];
+}
diff --git a/tests/ui/repeat-expr/no-conservative-copy-impl-requirement.rs b/tests/ui/repeat-expr/no-conservative-copy-impl-requirement.rs
new file mode 100644
index 000000000000..eb70df62996f
--- /dev/null
+++ b/tests/ui/repeat-expr/no-conservative-copy-impl-requirement.rs
@@ -0,0 +1,20 @@
+#![feature(generic_arg_infer)]
+
+struct Foo<const N: usize>;
+
+impl Clone for Foo<1> {
+    fn clone(&self) -> Self {
+        Foo
+    }
+}
+impl Copy for Foo<1> {}
+
+fn unify<const N: usize>(_: &[Foo<N>; N]) {
+    loop {}
+}
+
+fn main() {
+    let x = &[Foo::<_>; _];
+    //~^ ERROR: type annotations needed for `&[Foo<_>; _]`
+    _ = unify(x);
+}
diff --git a/tests/ui/repeat-expr/no-conservative-copy-impl-requirement.stderr b/tests/ui/repeat-expr/no-conservative-copy-impl-requirement.stderr
new file mode 100644
index 000000000000..04f8ff33fdab
--- /dev/null
+++ b/tests/ui/repeat-expr/no-conservative-copy-impl-requirement.stderr
@@ -0,0 +1,14 @@
+error[E0282]: type annotations needed for `&[Foo<_>; _]`
+  --> $DIR/no-conservative-copy-impl-requirement.rs:17:9
+   |
+LL |     let x = &[Foo::<_>; _];
+   |         ^     -------- type must be known at this point
+   |
+help: consider giving `x` an explicit type, where the value of const parameter `N` is specified
+   |
+LL |     let x: &[Foo<N>; N] = &[Foo::<_>; _];
+   |          ++++++++++++++
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0282`.
diff --git a/tests/ui/repr/16-bit-repr-c-enum.rs b/tests/ui/repr/16-bit-repr-c-enum.rs
index 011076882d24..d4d5a086dcc0 100644
--- a/tests/ui/repr/16-bit-repr-c-enum.rs
+++ b/tests/ui/repr/16-bit-repr-c-enum.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ build-pass
 //@ revisions: avr msp430
 //
@@ -11,6 +12,9 @@
 #![stable(feature = "intrinsics_for_test", since = "3.3.3")]
 #![allow(dead_code)]
 
+extern crate minicore;
+use minicore::*;
+
 // Test that the repr(C) attribute doesn't break compilation
 // Previous bad assumption was that 32-bit enum default width is fine on msp430, avr
 // But the width of the C int on these platforms is 16 bits, and C enums <= C int range
@@ -24,15 +28,7 @@ enum Foo {
 #[stable(feature = "intrinsics_for_test", since = "3.3.3")]
 #[rustc_const_stable(feature = "intrinsics_for_test", since = "3.3.3")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-const fn size_of<T>() -> usize {
-    loop {}
-}
-
-#[lang="sized"]
-trait Sized {}
-#[lang="copy"]
-trait Copy {}
+const fn size_of<T>() -> usize;
 
 const EXPECTED: usize = 2;
 const ACTUAL: usize = size_of::<Foo>();
diff --git a/tests/ui/repr/invalid_repr_list_help.stderr b/tests/ui/repr/invalid_repr_list_help.stderr
index e87cbd37a993..763ad9c27958 100644
--- a/tests/ui/repr/invalid_repr_list_help.stderr
+++ b/tests/ui/repr/invalid_repr_list_help.stderr
@@ -30,14 +30,6 @@ LL | #[repr(uwu, u8)]
    |
    = help: valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
 
-error: unknown `doc` attribute `owo`
-  --> $DIR/invalid_repr_list_help.rs:20:7
-   |
-LL | #[doc(owo)]
-   |       ^^^
-   |
-   = note: `#[deny(invalid_doc_attributes)]` on by default
-
 error[E0552]: unrecognized representation hint
   --> $DIR/invalid_repr_list_help.rs:19:8
    |
@@ -46,6 +38,14 @@ LL | #[repr(uwu)]
    |
    = help: valid reprs are `Rust` (default), `C`, `align`, `packed`, `transparent`, `simd`, `i8`, `u8`, `i16`, `u16`, `i32`, `u32`, `i64`, `u64`, `i128`, `u128`, `isize`, `usize`
 
+error: unknown `doc` attribute `owo`
+  --> $DIR/invalid_repr_list_help.rs:20:7
+   |
+LL | #[doc(owo)]
+   |       ^^^
+   |
+   = note: `#[deny(invalid_doc_attributes)]` on by default
+
 error: aborting due to 6 previous errors
 
 For more information about this error, try `rustc --explain E0552`.
diff --git a/tests/ui/repr/issue-83505-repr-simd.stderr b/tests/ui/repr/issue-83505-repr-simd.stderr
index 44e154b4bb61..57cfbeb95de8 100644
--- a/tests/ui/repr/issue-83505-repr-simd.stderr
+++ b/tests/ui/repr/issue-83505-repr-simd.stderr
@@ -26,10 +26,10 @@ LL | enum Es {}
    | ---------- not a struct
 
 error[E0084]: unsupported representation for zero-variant enum
-  --> $DIR/issue-83505-repr-simd.rs:5:1
+  --> $DIR/issue-83505-repr-simd.rs:5:8
    |
 LL | #[repr(simd)]
-   | ^^^^^^^^^^^^^
+   |        ^^^^
 ...
 LL | enum Es {}
    | ------- zero-variant enum
diff --git a/tests/ui/repr/malformed-repr-hints.stderr b/tests/ui/repr/malformed-repr-hints.stderr
index 6fb927557619..7a6e9ccc73eb 100644
--- a/tests/ui/repr/malformed-repr-hints.stderr
+++ b/tests/ui/repr/malformed-repr-hints.stderr
@@ -1,15 +1,3 @@
-error[E0552]: incorrect `repr(packed)` attribute format: `packed` takes exactly one parenthesized argument, or no parentheses at all
-  --> $DIR/malformed-repr-hints.rs:6:8
-   |
-LL | #[repr(packed())]
-   |        ^^^^^^^^
-
-error[E0589]: invalid `repr(align)` attribute: `align` needs an argument
-  --> $DIR/malformed-repr-hints.rs:10:8
-   |
-LL | #[repr(align)]
-   |        ^^^^^ help: supply an argument here: `align(...)`
-
 error[E0693]: incorrect `repr(align)` attribute format: `align` takes exactly one argument in parentheses
   --> $DIR/malformed-repr-hints.rs:14:8
    |
@@ -22,6 +10,18 @@ error[E0693]: incorrect `repr(align)` attribute format: `align` takes exactly on
 LL | #[repr(align())]
    |        ^^^^^^^
 
+error[E0552]: incorrect `repr(packed)` attribute format: `packed` takes exactly one parenthesized argument, or no parentheses at all
+  --> $DIR/malformed-repr-hints.rs:6:8
+   |
+LL | #[repr(packed())]
+   |        ^^^^^^^^
+
+error[E0589]: invalid `repr(align)` attribute: `align` needs an argument
+  --> $DIR/malformed-repr-hints.rs:10:8
+   |
+LL | #[repr(align)]
+   |        ^^^^^ help: supply an argument here: `align(...)`
+
 error[E0552]: invalid representation hint: `Rust` does not take a parenthesized argument list
   --> $DIR/malformed-repr-hints.rs:23:8
    |
diff --git a/tests/ui/repr/repr-align-assign.fixed b/tests/ui/repr/repr-align-assign.fixed
index d40fcadf57b1..96f9866611bc 100644
--- a/tests/ui/repr/repr-align-assign.fixed
+++ b/tests/ui/repr/repr-align-assign.fixed
@@ -3,11 +3,9 @@
 #![allow(dead_code)]
 
 #[repr(align(8))] //~ ERROR incorrect `repr(align)` attribute format
-                 //~| ERROR incorrect `repr(align)` attribute format
 struct A(u64);
 
 #[repr(align(8))] //~ ERROR incorrect `repr(align)` attribute format
-                   //~| ERROR incorrect `repr(align)` attribute format
 struct B(u64);
 
 fn main() {}
diff --git a/tests/ui/repr/repr-align-assign.rs b/tests/ui/repr/repr-align-assign.rs
index 3aff84a91f71..0b30ee656646 100644
--- a/tests/ui/repr/repr-align-assign.rs
+++ b/tests/ui/repr/repr-align-assign.rs
@@ -3,11 +3,9 @@
 #![allow(dead_code)]
 
 #[repr(align=8)] //~ ERROR incorrect `repr(align)` attribute format
-                 //~| ERROR incorrect `repr(align)` attribute format
 struct A(u64);
 
 #[repr(align="8")] //~ ERROR incorrect `repr(align)` attribute format
-                   //~| ERROR incorrect `repr(align)` attribute format
 struct B(u64);
 
 fn main() {}
diff --git a/tests/ui/repr/repr-align-assign.stderr b/tests/ui/repr/repr-align-assign.stderr
index 3606d02210ba..cc046e04de54 100644
--- a/tests/ui/repr/repr-align-assign.stderr
+++ b/tests/ui/repr/repr-align-assign.stderr
@@ -5,27 +5,11 @@ LL | #[repr(align=8)]
    |        ^^^^^^^ help: use parentheses instead: `align(8)`
 
 error[E0693]: incorrect `repr(align)` attribute format
-  --> $DIR/repr-align-assign.rs:9:8
+  --> $DIR/repr-align-assign.rs:8:8
    |
 LL | #[repr(align="8")]
    |        ^^^^^^^^^ help: use parentheses instead: `align(8)`
 
-error[E0693]: incorrect `repr(align)` attribute format
-  --> $DIR/repr-align-assign.rs:5:8
-   |
-LL | #[repr(align=8)]
-   |        ^^^^^^^ help: use parentheses instead: `align(8)`
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0693]: incorrect `repr(align)` attribute format
-  --> $DIR/repr-align-assign.rs:9:8
-   |
-LL | #[repr(align="8")]
-   |        ^^^^^^^^^ help: use parentheses instead: `align(8)`
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 4 previous errors
+error: aborting due to 2 previous errors
 
 For more information about this error, try `rustc --explain E0693`.
diff --git a/tests/ui/repr/repr-align.rs b/tests/ui/repr/repr-align.rs
index 33aa727d4bd0..6b60a765461a 100644
--- a/tests/ui/repr/repr-align.rs
+++ b/tests/ui/repr/repr-align.rs
@@ -1,41 +1,33 @@
 #![allow(dead_code)]
 
 #[repr(align(16.0))] //~ ERROR: invalid `repr(align)` attribute: not an unsuffixed integer
-                     //~| ERROR: invalid `repr(align)` attribute: not an unsuffixed integer
 struct S0(i32);
 
 #[repr(align(15))] //~ ERROR: invalid `repr(align)` attribute: not a power of two
-                   //~| ERROR: invalid `repr(align)` attribute: not a power of two
 struct S1(i32);
 
 #[repr(align(4294967296))] //~ ERROR: invalid `repr(align)` attribute: larger than 2^29
-                           //~| ERROR: invalid `repr(align)` attribute: larger than 2^29
 struct S2(i32);
 
 #[repr(align(536870912))] // ok: this is the largest accepted alignment
 struct S3(i32);
 
 #[repr(align(0))] //~ ERROR: invalid `repr(align)` attribute: not a power of two
-                  //~| ERROR: invalid `repr(align)` attribute: not a power of two
 struct S4(i32);
 
 #[repr(align(16.0))] //~ ERROR: invalid `repr(align)` attribute: not an unsuffixed integer
-                     //~| ERROR: invalid `repr(align)` attribute: not an unsuffixed integer
 enum E0 { A, B }
 
 #[repr(align(15))] //~ ERROR: invalid `repr(align)` attribute: not a power of two
-                   //~| ERROR: invalid `repr(align)` attribute: not a power of two
 enum E1 { A, B }
 
 #[repr(align(4294967296))] //~ ERROR: invalid `repr(align)` attribute: larger than 2^29
-                           //~| ERROR: invalid `repr(align)` attribute: larger than 2^29
 enum E2 { A, B }
 
 #[repr(align(536870912))] // ok: this is the largest accepted alignment
 enum E3 { A, B }
 
 #[repr(align(0))] //~ ERROR: invalid `repr(align)` attribute: not a power of two
-                  //~| ERROR: invalid `repr(align)` attribute: not a power of two
 enum E4 { A, B }
 
 fn main() {}
diff --git a/tests/ui/repr/repr-align.stderr b/tests/ui/repr/repr-align.stderr
index 660247840c48..fe919e30b153 100644
--- a/tests/ui/repr/repr-align.stderr
+++ b/tests/ui/repr/repr-align.stderr
@@ -5,111 +5,47 @@ LL | #[repr(align(16.0))]
    |              ^^^^
 
 error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/repr-align.rs:7:14
+  --> $DIR/repr-align.rs:6:14
    |
 LL | #[repr(align(15))]
    |              ^^
 
 error[E0589]: invalid `repr(align)` attribute: larger than 2^29
-  --> $DIR/repr-align.rs:11:14
+  --> $DIR/repr-align.rs:9:14
    |
 LL | #[repr(align(4294967296))]
    |              ^^^^^^^^^^
 
 error[E0589]: invalid `repr(align)` attribute: not a power of two
+  --> $DIR/repr-align.rs:15:14
+   |
+LL | #[repr(align(0))]
+   |              ^
+
+error[E0589]: invalid `repr(align)` attribute: not an unsuffixed integer
   --> $DIR/repr-align.rs:18:14
    |
-LL | #[repr(align(0))]
-   |              ^
-
-error[E0589]: invalid `repr(align)` attribute: not an unsuffixed integer
-  --> $DIR/repr-align.rs:22:14
-   |
 LL | #[repr(align(16.0))]
    |              ^^^^
 
 error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/repr-align.rs:26:14
+  --> $DIR/repr-align.rs:21:14
    |
 LL | #[repr(align(15))]
    |              ^^
 
 error[E0589]: invalid `repr(align)` attribute: larger than 2^29
+  --> $DIR/repr-align.rs:24:14
+   |
+LL | #[repr(align(4294967296))]
+   |              ^^^^^^^^^^
+
+error[E0589]: invalid `repr(align)` attribute: not a power of two
   --> $DIR/repr-align.rs:30:14
    |
-LL | #[repr(align(4294967296))]
-   |              ^^^^^^^^^^
-
-error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/repr-align.rs:37:14
-   |
 LL | #[repr(align(0))]
    |              ^
 
-error[E0589]: invalid `repr(align)` attribute: not an unsuffixed integer
-  --> $DIR/repr-align.rs:3:14
-   |
-LL | #[repr(align(16.0))]
-   |              ^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/repr-align.rs:7:14
-   |
-LL | #[repr(align(15))]
-   |              ^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0589]: invalid `repr(align)` attribute: larger than 2^29
-  --> $DIR/repr-align.rs:11:14
-   |
-LL | #[repr(align(4294967296))]
-   |              ^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/repr-align.rs:18:14
-   |
-LL | #[repr(align(0))]
-   |              ^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0589]: invalid `repr(align)` attribute: not an unsuffixed integer
-  --> $DIR/repr-align.rs:22:14
-   |
-LL | #[repr(align(16.0))]
-   |              ^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/repr-align.rs:26:14
-   |
-LL | #[repr(align(15))]
-   |              ^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0589]: invalid `repr(align)` attribute: larger than 2^29
-  --> $DIR/repr-align.rs:30:14
-   |
-LL | #[repr(align(4294967296))]
-   |              ^^^^^^^^^^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error[E0589]: invalid `repr(align)` attribute: not a power of two
-  --> $DIR/repr-align.rs:37:14
-   |
-LL | #[repr(align(0))]
-   |              ^
-   |
-   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
-
-error: aborting due to 16 previous errors
+error: aborting due to 8 previous errors
 
 For more information about this error, try `rustc --explain E0589`.
diff --git a/tests/ui/repr/repr-c-dead-variants.aarch64-unknown-linux-gnu.stderr b/tests/ui/repr/repr-c-dead-variants.aarch64-unknown-linux-gnu.stderr
index 204db30786ee..42fcaee2d4aa 100644
--- a/tests/ui/repr/repr-c-dead-variants.aarch64-unknown-linux-gnu.stderr
+++ b/tests/ui/repr/repr-c-dead-variants.aarch64-unknown-linux-gnu.stderr
@@ -81,7 +81,7 @@ error: layout_of(Univariant) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:39:1
+  --> $DIR/repr-c-dead-variants.rs:43:1
    |
 LL | enum Univariant {
    | ^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ error: layout_of(TwoVariants) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:46:1
+  --> $DIR/repr-c-dead-variants.rs:50:1
    |
 LL | enum TwoVariants {
    | ^^^^^^^^^^^^^^^^
@@ -327,7 +327,7 @@ error: layout_of(DeadBranchHasOtherField) = Layout {
            unadjusted_abi_align: Align(8 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:58:1
+  --> $DIR/repr-c-dead-variants.rs:62:1
    |
 LL | enum DeadBranchHasOtherField {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/repr/repr-c-dead-variants.armebv7r-none-eabi.stderr b/tests/ui/repr/repr-c-dead-variants.armebv7r-none-eabi.stderr
index 1fab00bf50c4..bb2c6e70dc7a 100644
--- a/tests/ui/repr/repr-c-dead-variants.armebv7r-none-eabi.stderr
+++ b/tests/ui/repr/repr-c-dead-variants.armebv7r-none-eabi.stderr
@@ -81,7 +81,7 @@ error: layout_of(Univariant) = Layout {
            unadjusted_abi_align: Align(1 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:39:1
+  --> $DIR/repr-c-dead-variants.rs:43:1
    |
 LL | enum Univariant {
    | ^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ error: layout_of(TwoVariants) = Layout {
            unadjusted_abi_align: Align(1 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:46:1
+  --> $DIR/repr-c-dead-variants.rs:50:1
    |
 LL | enum TwoVariants {
    | ^^^^^^^^^^^^^^^^
@@ -327,7 +327,7 @@ error: layout_of(DeadBranchHasOtherField) = Layout {
            unadjusted_abi_align: Align(8 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:58:1
+  --> $DIR/repr-c-dead-variants.rs:62:1
    |
 LL | enum DeadBranchHasOtherField {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/repr/repr-c-dead-variants.i686-pc-windows-msvc.stderr b/tests/ui/repr/repr-c-dead-variants.i686-pc-windows-msvc.stderr
index 204db30786ee..42fcaee2d4aa 100644
--- a/tests/ui/repr/repr-c-dead-variants.i686-pc-windows-msvc.stderr
+++ b/tests/ui/repr/repr-c-dead-variants.i686-pc-windows-msvc.stderr
@@ -81,7 +81,7 @@ error: layout_of(Univariant) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:39:1
+  --> $DIR/repr-c-dead-variants.rs:43:1
    |
 LL | enum Univariant {
    | ^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ error: layout_of(TwoVariants) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:46:1
+  --> $DIR/repr-c-dead-variants.rs:50:1
    |
 LL | enum TwoVariants {
    | ^^^^^^^^^^^^^^^^
@@ -327,7 +327,7 @@ error: layout_of(DeadBranchHasOtherField) = Layout {
            unadjusted_abi_align: Align(8 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:58:1
+  --> $DIR/repr-c-dead-variants.rs:62:1
    |
 LL | enum DeadBranchHasOtherField {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/repr/repr-c-dead-variants.rs b/tests/ui/repr/repr-c-dead-variants.rs
index 99f20982a996..7f2743085623 100644
--- a/tests/ui/repr/repr-c-dead-variants.rs
+++ b/tests/ui/repr/repr-c-dead-variants.rs
@@ -4,8 +4,12 @@
 #![no_std]
 #![no_core]
 
+extern crate minicore;
+use minicore::*;
+
 // See also: repr-c-int-dead-variants.rs
 
+//@ add-core-stubs
 //@ normalize-stderr: "pref: Align\([1-8] bytes\)" -> "pref: $$SOME_ALIGN"
 //@ normalize-stderr: "randomization_seed: \d+" -> "randomization_seed: $$SEED"
 
@@ -59,6 +63,3 @@ enum DeadBranchHasOtherField { //~ ERROR layout_of
     Variant1(Void, Align8U64),
     Variant2(u8),
 }
-
-#[lang = "sized"]
-trait Sized {}
diff --git a/tests/ui/repr/repr-c-dead-variants.x86_64-unknown-linux-gnu.stderr b/tests/ui/repr/repr-c-dead-variants.x86_64-unknown-linux-gnu.stderr
index 204db30786ee..42fcaee2d4aa 100644
--- a/tests/ui/repr/repr-c-dead-variants.x86_64-unknown-linux-gnu.stderr
+++ b/tests/ui/repr/repr-c-dead-variants.x86_64-unknown-linux-gnu.stderr
@@ -81,7 +81,7 @@ error: layout_of(Univariant) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:39:1
+  --> $DIR/repr-c-dead-variants.rs:43:1
    |
 LL | enum Univariant {
    | ^^^^^^^^^^^^^^^
@@ -219,7 +219,7 @@ error: layout_of(TwoVariants) = Layout {
            unadjusted_abi_align: Align(4 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:46:1
+  --> $DIR/repr-c-dead-variants.rs:50:1
    |
 LL | enum TwoVariants {
    | ^^^^^^^^^^^^^^^^
@@ -327,7 +327,7 @@ error: layout_of(DeadBranchHasOtherField) = Layout {
            unadjusted_abi_align: Align(8 bytes),
            randomization_seed: $SEED,
        }
-  --> $DIR/repr-c-dead-variants.rs:58:1
+  --> $DIR/repr-c-dead-variants.rs:62:1
    |
 LL | enum DeadBranchHasOtherField {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/repr/repr-transparent.stderr b/tests/ui/repr/repr-transparent.stderr
index d0c78a8418a0..2cafb989bce5 100644
--- a/tests/ui/repr/repr-transparent.stderr
+++ b/tests/ui/repr/repr-transparent.stderr
@@ -35,10 +35,10 @@ LL | struct GenericAlign<T>(ZstAlign32<T>, u32);
    | needs at most one field with non-trivial size or alignment, but has 2
 
 error[E0084]: unsupported representation for zero-variant enum
-  --> $DIR/repr-transparent.rs:47:1
+  --> $DIR/repr-transparent.rs:47:8
    |
 LL | #[repr(transparent)]
-   | ^^^^^^^^^^^^^^^^^^^^
+   |        ^^^^^^^^^^^
 LL | enum Void {}
    | --------- zero-variant enum
 
diff --git a/tests/ui/repr/repr_align_greater_usize.msp430.stderr b/tests/ui/repr/repr_align_greater_usize.msp430.stderr
index 7c85249c0099..db25cb1b5f2e 100644
--- a/tests/ui/repr/repr_align_greater_usize.msp430.stderr
+++ b/tests/ui/repr/repr_align_greater_usize.msp430.stderr
@@ -1,5 +1,5 @@
 error[E0589]: alignment must not be greater than `isize::MAX` bytes
-  --> $DIR/repr_align_greater_usize.rs:21:8
+  --> $DIR/repr_align_greater_usize.rs:22:8
    |
 LL | #[repr(align(32768))]
    |        ^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL | #[repr(align(32768))]
    = note: `isize::MAX` is 32767 for the current target
 
 error[E0589]: alignment must not be greater than `isize::MAX` bytes
-  --> $DIR/repr_align_greater_usize.rs:24:8
+  --> $DIR/repr_align_greater_usize.rs:25:8
    |
 LL | #[repr(align(65536))]
    |        ^^^^^^^^^^^^
diff --git a/tests/ui/repr/repr_align_greater_usize.rs b/tests/ui/repr/repr_align_greater_usize.rs
index b47320b6d9b6..7499e242d597 100644
--- a/tests/ui/repr/repr_align_greater_usize.rs
+++ b/tests/ui/repr/repr_align_greater_usize.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: msp430 aarch32
 //@[msp430] needs-llvm-components: msp430
 //@[msp430] compile-flags: --target=msp430-none-elf
@@ -12,8 +13,8 @@
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 #[repr(align(16384))]
 struct Kitten;
diff --git a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/downcast-unsafe-trait-objects.rs b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/downcast-unsafe-trait-objects.rs
deleted file mode 100644
index b1b2dcf3eb9f..000000000000
--- a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/downcast-unsafe-trait-objects.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Check that we if we get ahold of a dyn-incompatible trait
-// object with auto traits and lifetimes, we can downcast it
-//
-//@ check-pass
-
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Trait: Sized {}
-
-fn downcast_auto(t: &(dyn Trait + Send)) -> &dyn Trait {
-    t
-}
-
-fn downcast_lifetime<'a, 'b, 't>(t: &'a (dyn Trait + 't))
-                                 -> &'b (dyn Trait + 't)
-where
-    'a: 'b,
-    't: 'a + 'b,
-{
-    t
-}
-
-fn main() {}
diff --git a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.current.stderr b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.current.stderr
deleted file mode 100644
index 1489791b20d6..000000000000
--- a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.current.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-warning: methods `good_virt` and `good_indirect` are never used
-  --> $DIR/manual-self-impl-for-unsafe-obj.rs:23:8
-   |
-LL | trait Good {
-   |       ---- methods in this trait
-LL |     fn good_virt(&self) -> char {
-   |        ^^^^^^^^^
-...
-LL |     fn good_indirect(&self) -> char {
-   |        ^^^^^^^^^^^^^
-   |
-   = note: `#[warn(dead_code)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.next.stderr b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.next.stderr
deleted file mode 100644
index 1489791b20d6..000000000000
--- a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.next.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-warning: methods `good_virt` and `good_indirect` are never used
-  --> $DIR/manual-self-impl-for-unsafe-obj.rs:23:8
-   |
-LL | trait Good {
-   |       ---- methods in this trait
-LL |     fn good_virt(&self) -> char {
-   |        ^^^^^^^^^
-...
-LL |     fn good_indirect(&self) -> char {
-   |        ^^^^^^^^^^^^^
-   |
-   = note: `#[warn(dead_code)]` on by default
-
-warning: 1 warning emitted
-
diff --git a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.rs b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.rs
deleted file mode 100644
index 425dc130d458..000000000000
--- a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/manual-self-impl-for-unsafe-obj.rs
+++ /dev/null
@@ -1,69 +0,0 @@
-// Check that we can manually implement a dyn-incompatible trait for its trait object.
-
-//@ revisions: current next
-//@ ignore-compare-mode-next-solver (explicit revisions)
-//@[next] compile-flags: -Znext-solver
-//@ run-pass
-
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Bad {
-    fn stat() -> char {
-        'A'
-    }
-    fn virt(&self) -> char {
-        'B'
-    }
-    fn indirect(&self) -> char {
-        Self::stat()
-    }
-}
-
-trait Good {
-    fn good_virt(&self) -> char { //~ WARN methods `good_virt` and `good_indirect` are never used
-        panic!()
-    }
-    fn good_indirect(&self) -> char {
-        panic!()
-    }
-}
-
-impl<'a> Bad for dyn Bad + 'a {
-    fn stat() -> char {
-        'C'
-    }
-    fn virt(&self) -> char {
-        'D'
-    }
-}
-
-struct Struct {}
-
-impl Bad for Struct {}
-
-impl Good for Struct {}
-
-fn main() {
-    let s = Struct {};
-
-    let mut res = String::new();
-
-    // Directly call static.
-    res.push(Struct::stat()); // "A"
-    res.push(<dyn Bad>::stat()); // "AC"
-
-    let good: &dyn Good = &s;
-
-    // These look similar enough...
-    let bad = unsafe { std::mem::transmute::<&dyn Good, &dyn Bad>(good) };
-
-    // Call virtual.
-    res.push(s.virt()); // "ACB"
-    res.push(bad.virt()); // "ACBD"
-
-    // Indirectly call static.
-    res.push(s.indirect()); // "ACBDA"
-    res.push(bad.indirect()); // "ACBDAC"
-
-    assert_eq!(&res, "ACBDAC");
-}
diff --git a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/static-dispatch-unsafe-object.rs b/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/static-dispatch-unsafe-object.rs
deleted file mode 100644
index c38928a9f44e..000000000000
--- a/tests/ui/rfcs/rfc-2027-dyn-compatible-for-dispatch/static-dispatch-unsafe-object.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-// Check that we can statically dispatch methods for object
-// unsafe trait objects, directly and indirectly
-//
-//@ check-pass
-
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Statics {
-    fn plain() {}
-    fn generic<T>() {}
-}
-
-trait Trait: Sized {}
-
-impl<'a> Statics for dyn Trait + 'a {}
-
-fn static_poly<T: Statics + ?Sized>() {
-    T::plain();
-    T::generic::<usize>();
-}
-
-fn inferred_poly<T: Statics + ?Sized>(t: &T) {
-    static_poly::<T>();
-    T::plain();
-    T::generic::<usize>();
-}
-
-fn call(t: &dyn Trait) {
-    static_poly::<dyn Trait>();
-    inferred_poly(t);
-}
-
-fn main() {
-    static_poly::<dyn Trait>();
-    <dyn Trait>::plain();
-    <dyn Trait>::generic::<usize>()
-}
diff --git a/tests/ui/rust-2021/ice-return-unsized-can-impl-2.rs b/tests/ui/rust-2021/ice-return-unsized-can-impl-2.rs
index e57e9ce4844a..567d37e1b820 100644
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl-2.rs
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl-2.rs
@@ -1,15 +1,17 @@
 // Doesn't trigger ICE when returning unsized trait that can be impl
 // issue https://github.com/rust-lang/rust/issues/125512
 //@ edition:2021
-#![feature(dyn_compatible_for_dispatch)]
+
 trait B {
     fn f(a: A) -> A;
     //~^ ERROR: expected a type, found a trait
     //~| ERROR: expected a type, found a trait
 }
+
 trait A {
     fn concrete(b: B) -> B;
     //~^ ERROR: expected a type, found a trait
     //~| ERROR: expected a type, found a trait
 }
+
 fn main() {}
diff --git a/tests/ui/rust-2021/ice-return-unsized-can-impl-2.stderr b/tests/ui/rust-2021/ice-return-unsized-can-impl-2.stderr
index ac19f91881df..f2942820e288 100644
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl-2.stderr
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl-2.stderr
@@ -1,5 +1,5 @@
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-return-unsized-can-impl-2.rs:11:20
+  --> $DIR/ice-return-unsized-can-impl-2.rs:12:20
    |
 LL |     fn concrete(b: B) -> B;
    |                    ^
@@ -16,7 +16,7 @@ LL |     fn concrete(b: impl B) -> B;
    |                    ++++
 
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-return-unsized-can-impl-2.rs:11:26
+  --> $DIR/ice-return-unsized-can-impl-2.rs:12:26
    |
 LL |     fn concrete(b: B) -> B;
    |                          ^
diff --git a/tests/ui/rust-2021/ice-return-unsized-can-impl.rs b/tests/ui/rust-2021/ice-return-unsized-can-impl.rs
index 055b11b4424a..8b83b7b537a2 100644
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl.rs
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl.rs
@@ -1,7 +1,6 @@
 // Doesn't trigger ICE when returning unsized trait that can be impl
 // issue https://github.com/rust-lang/rust/issues/120482
 //@ edition:2021
-#![feature(dyn_compatible_for_dispatch)]
 
 trait B {
     fn bar(&self, x: &Self);
diff --git a/tests/ui/rust-2021/ice-return-unsized-can-impl.stderr b/tests/ui/rust-2021/ice-return-unsized-can-impl.stderr
index 463c6892ca26..cfee506e29b7 100644
--- a/tests/ui/rust-2021/ice-return-unsized-can-impl.stderr
+++ b/tests/ui/rust-2021/ice-return-unsized-can-impl.stderr
@@ -1,5 +1,5 @@
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-return-unsized-can-impl.rs:11:15
+  --> $DIR/ice-return-unsized-can-impl.rs:10:15
    |
 LL |     fn g(new: B) -> B;
    |               ^
@@ -16,7 +16,7 @@ LL |     fn g(new: impl B) -> B;
    |               ++++
 
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-return-unsized-can-impl.rs:11:21
+  --> $DIR/ice-return-unsized-can-impl.rs:10:21
    |
 LL |     fn g(new: B) -> B;
    |                     ^
diff --git a/tests/ui/rust-2021/ice-unsized-fn-params-2.rs b/tests/ui/rust-2021/ice-unsized-fn-params-2.rs
index 2b4f7bd088fb..8af56ffe80de 100644
--- a/tests/ui/rust-2021/ice-unsized-fn-params-2.rs
+++ b/tests/ui/rust-2021/ice-unsized-fn-params-2.rs
@@ -1,7 +1,7 @@
 //@ edition:2021
 // Test that it doesn't trigger an ICE when using an unsized fn params.
 // https://github.com/rust-lang/rust/issues/120241
-#![feature(dyn_compatible_for_dispatch)]
+
 #![feature(unsized_fn_params)]
 
 fn guard(_s: Copy) -> bool {
diff --git a/tests/ui/rust-2021/ice-unsized-fn-params.rs b/tests/ui/rust-2021/ice-unsized-fn-params.rs
index 6d8c1c3f152f..6ed67698e96e 100644
--- a/tests/ui/rust-2021/ice-unsized-fn-params.rs
+++ b/tests/ui/rust-2021/ice-unsized-fn-params.rs
@@ -1,7 +1,6 @@
 //@ edition:2021
 // Test that it doesn't trigger an ICE when using an unsized fn params.
 // https://github.com/rust-lang/rust/issues/120241
-#![feature(dyn_compatible_for_dispatch)]
 
 trait B {
     fn f(a: A) -> A;
diff --git a/tests/ui/rust-2021/ice-unsized-fn-params.stderr b/tests/ui/rust-2021/ice-unsized-fn-params.stderr
index c31500ba8004..4d900711ed6e 100644
--- a/tests/ui/rust-2021/ice-unsized-fn-params.stderr
+++ b/tests/ui/rust-2021/ice-unsized-fn-params.stderr
@@ -1,5 +1,5 @@
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-unsized-fn-params.rs:13:13
+  --> $DIR/ice-unsized-fn-params.rs:12:13
    |
 LL |     fn g(b: B) -> B;
    |             ^
@@ -16,7 +16,7 @@ LL |     fn g(b: impl B) -> B;
    |             ++++
 
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-unsized-fn-params.rs:13:19
+  --> $DIR/ice-unsized-fn-params.rs:12:19
    |
 LL |     fn g(b: B) -> B;
    |                   ^
@@ -27,7 +27,7 @@ LL |     fn g(b: B) -> impl B;
    |                   ++++
 
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-unsized-fn-params.rs:7:13
+  --> $DIR/ice-unsized-fn-params.rs:6:13
    |
 LL |     fn f(a: A) -> A;
    |             ^
@@ -44,7 +44,7 @@ LL |     fn f(a: impl A) -> A;
    |             ++++
 
 error[E0782]: expected a type, found a trait
-  --> $DIR/ice-unsized-fn-params.rs:7:19
+  --> $DIR/ice-unsized-fn-params.rs:6:19
    |
 LL |     fn f(a: A) -> A;
    |                   ^
diff --git a/tests/ui/sanitizer/cfg-kasan.rs b/tests/ui/sanitizer/cfg-kasan.rs
index 491eaf3acc17..ba0abf605707 100644
--- a/tests/ui/sanitizer/cfg-kasan.rs
+++ b/tests/ui/sanitizer/cfg-kasan.rs
@@ -1,6 +1,7 @@
 // Verifies that when compiling with -Zsanitizer=kernel-address,
 // the `#[cfg(sanitize = "address")]` attribute is configured.
 
+//@ add-core-stubs
 //@ check-pass
 //@ compile-flags: -Zsanitizer=kernel-address
 //@ revisions: aarch64 riscv64imac riscv64gc x86_64
@@ -17,8 +18,8 @@
 #![feature(cfg_sanitize, no_core, lang_items)]
 #![no_core]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 const _: fn() -> () = main;
 
diff --git a/tests/ui/sanitizer/cfg.rs b/tests/ui/sanitizer/cfg.rs
index 7b8f285e41a8..a43813c04469 100644
--- a/tests/ui/sanitizer/cfg.rs
+++ b/tests/ui/sanitizer/cfg.rs
@@ -1,6 +1,7 @@
 // Verifies that when compiling with -Zsanitizer=option,
 // the `#[cfg(sanitize = "option")]` attribute is configured.
 
+//@ add-core-stubs
 //@ check-pass
 //@ revisions: address cfi kcfi leak memory thread
 //@compile-flags: -Ctarget-feature=-crt-static
@@ -23,10 +24,8 @@
 #![crate_type="lib"]
 #![no_core]
 
-#[lang="sized"]
-trait Sized { }
-#[lang="copy"]
-trait Copy { }
+extern crate minicore;
+use minicore::*;
 
 #[cfg(all(sanitize = "address", address))]
 fn main() {}
diff --git a/tests/ui/self/arbitrary-self-types-dyn-incompatible.dyn_compatible_for_dispatch.stderr b/tests/ui/self/arbitrary-self-types-dyn-incompatible.dyn_compatible_for_dispatch.stderr
deleted file mode 100644
index d324f4641cf2..000000000000
--- a/tests/ui/self/arbitrary-self-types-dyn-incompatible.dyn_compatible_for_dispatch.stderr
+++ /dev/null
@@ -1,23 +0,0 @@
-error[E0038]: the trait `Foo` is not dyn compatible
-  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:33:13
-   |
-LL |     fn foo(self: &Rc<Self>) -> usize;
-   |                  --------- help: consider changing method `foo`'s `self` parameter to be `&self`: `&Self`
-...
-LL |     let x = Rc::new(5usize) as Rc<dyn Foo>;
-   |             ^^^^^^^^^^^^^^^ `Foo` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:8:18
-   |
-LL | trait Foo {
-   |       --- this trait is not dyn compatible...
-LL |     fn foo(self: &Rc<Self>) -> usize;
-   |                  ^^^^^^^^^ ...because method `foo`'s `self` parameter cannot be dispatched on
-   = help: only type `usize` implements `Foo`; consider using it directly instead.
-   = note: required for the cast from `Rc<usize>` to `Rc<dyn Foo>`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/self/arbitrary-self-types-dyn-incompatible.rs b/tests/ui/self/arbitrary-self-types-dyn-incompatible.rs
index 940b2f1e8e2f..0477d9d79c77 100644
--- a/tests/ui/self/arbitrary-self-types-dyn-incompatible.rs
+++ b/tests/ui/self/arbitrary-self-types-dyn-incompatible.rs
@@ -1,7 +1,3 @@
-//@ revisions: curr dyn_compatible_for_dispatch
-
-#![cfg_attr(dyn_compatible_for_dispatch, feature(dyn_compatible_for_dispatch))]
-
 use std::rc::Rc;
 
 trait Foo {
@@ -31,9 +27,8 @@ impl Bar for usize {
 
 fn make_foo() {
     let x = Rc::new(5usize) as Rc<dyn Foo>;
-    //[curr]~^ ERROR E0038
-    //[curr]~| ERROR E0038
-    //[dyn_compatible_for_dispatch]~^^^ ERROR E0038
+    //~^ ERROR E0038
+    //~| ERROR E0038
 }
 
 fn make_bar() {
diff --git a/tests/ui/self/arbitrary-self-types-dyn-incompatible.stderr b/tests/ui/self/arbitrary-self-types-dyn-incompatible.stderr
new file mode 100644
index 000000000000..9fb4c80329d5
--- /dev/null
+++ b/tests/ui/self/arbitrary-self-types-dyn-incompatible.stderr
@@ -0,0 +1,42 @@
+error[E0038]: the trait `Foo` is not dyn compatible
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:29:32
+   |
+LL |     fn foo(self: &Rc<Self>) -> usize;
+   |                  --------- help: consider changing method `foo`'s `self` parameter to be `&self`: `&Self`
+...
+LL |     let x = Rc::new(5usize) as Rc<dyn Foo>;
+   |                                ^^^^^^^^^^^ `Foo` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:4:18
+   |
+LL | trait Foo {
+   |       --- this trait is not dyn compatible...
+LL |     fn foo(self: &Rc<Self>) -> usize;
+   |                  ^^^^^^^^^ ...because method `foo`'s `self` parameter cannot be dispatched on
+   = help: only type `usize` implements `Foo`; consider using it directly instead.
+
+error[E0038]: the trait `Foo` is not dyn compatible
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:29:13
+   |
+LL |     fn foo(self: &Rc<Self>) -> usize;
+   |                  --------- help: consider changing method `foo`'s `self` parameter to be `&self`: `&Self`
+...
+LL |     let x = Rc::new(5usize) as Rc<dyn Foo>;
+   |             ^^^^^^^^^^^^^^^ `Foo` is not dyn compatible
+   |
+note: for a trait to be dyn compatible it needs to allow building a vtable
+      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
+  --> $DIR/arbitrary-self-types-dyn-incompatible.rs:4:18
+   |
+LL | trait Foo {
+   |       --- this trait is not dyn compatible...
+LL |     fn foo(self: &Rc<Self>) -> usize;
+   |                  ^^^^^^^^^ ...because method `foo`'s `self` parameter cannot be dispatched on
+   = help: only type `usize` implements `Foo`; consider using it directly instead.
+   = note: required for the cast from `Rc<usize>` to `Rc<dyn Foo>`
+
+error: aborting due to 2 previous errors
+
+For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.rs b/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.rs
index 71f198f7dc70..94b76fe96854 100644
--- a/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.rs
+++ b/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.rs
@@ -15,7 +15,7 @@ struct Dispatchable<T: ?Sized, Z> {
 }
 
 impl<T, U> DispatchFromDyn<Dispatchable<U, i32>> for Dispatchable<T, ()>
-//~^ ERROR implementing the `DispatchFromDyn` trait requires multiple coercions
+//~^ ERROR implementing `DispatchFromDyn` does not allow multiple fields to be coerced
 where
     T: Unsize<U> + ?Sized,
     U: ?Sized,
diff --git a/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.stderr b/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.stderr
index 1f13c51f6799..91760b9e2eab 100644
--- a/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.stderr
+++ b/tests/ui/self/dispatch-from-dyn-zst-transmute-zst-nonzst.stderr
@@ -1,4 +1,4 @@
-error[E0378]: implementing the `DispatchFromDyn` trait requires multiple coercions
+error[E0375]: implementing `DispatchFromDyn` does not allow multiple fields to be coerced
   --> $DIR/dispatch-from-dyn-zst-transmute-zst-nonzst.rs:17:1
    |
 LL | / impl<T, U> DispatchFromDyn<Dispatchable<U, i32>> for Dispatchable<T, ()>
@@ -8,9 +8,14 @@ LL | |     T: Unsize<U> + ?Sized,
 LL | |     U: ?Sized,
    | |______________^
    |
-   = note: the trait `DispatchFromDyn` may only be implemented for a coercion between structures with a single field being coerced
-   = note: currently, 2 fields need coercions: `_ptr` (`Box<T>` to `Box<U>`), `z` (`()` to `i32`)
+note: the trait `DispatchFromDyn` may only be implemented when a single field is being coerced
+  --> $DIR/dispatch-from-dyn-zst-transmute-zst-nonzst.rs:13:5
+   |
+LL |     _ptr: Box<T>,
+   |     ^^^^^^^^^^^^
+LL |     z: Z,
+   |     ^^^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0378`.
+For more information about this error, try `rustc --explain E0375`.
diff --git a/tests/ui/self/dispatch-from-dyn-zst-transmute.rs b/tests/ui/self/dispatch-from-dyn-zst-transmute.rs
index 57c255b4d7bc..967958ab4869 100644
--- a/tests/ui/self/dispatch-from-dyn-zst-transmute.rs
+++ b/tests/ui/self/dispatch-from-dyn-zst-transmute.rs
@@ -15,7 +15,7 @@ struct Foo<'a, U: ?Sized> {
 }
 
 impl<'a, T, U> DispatchFromDyn<Foo<'a, U>> for Foo<'a, T>
-//~^ ERROR implementing the `DispatchFromDyn` trait requires multiple coercions
+//~^ ERROR implementing `DispatchFromDyn` does not allow multiple fields to be coerced
 where
     T: Unsize<U> + ?Sized,
     U: ?Sized {}
diff --git a/tests/ui/self/dispatch-from-dyn-zst-transmute.stderr b/tests/ui/self/dispatch-from-dyn-zst-transmute.stderr
index 5a8ae88b5f1b..cc8be45e99d8 100644
--- a/tests/ui/self/dispatch-from-dyn-zst-transmute.stderr
+++ b/tests/ui/self/dispatch-from-dyn-zst-transmute.stderr
@@ -1,4 +1,4 @@
-error[E0378]: implementing the `DispatchFromDyn` trait requires multiple coercions
+error[E0375]: implementing `DispatchFromDyn` does not allow multiple fields to be coerced
   --> $DIR/dispatch-from-dyn-zst-transmute.rs:17:1
    |
 LL | / impl<'a, T, U> DispatchFromDyn<Foo<'a, U>> for Foo<'a, T>
@@ -8,9 +8,14 @@ LL | |     T: Unsize<U> + ?Sized,
 LL | |     U: ?Sized {}
    | |_____________^
    |
-   = note: the trait `DispatchFromDyn` may only be implemented for a coercion between structures with a single field being coerced
-   = note: currently, 2 fields need coercions: `token` (`IsSendToken<T>` to `IsSendToken<U>`), `ptr` (`&'a T` to `&'a U`)
+note: the trait `DispatchFromDyn` may only be implemented when a single field is being coerced
+  --> $DIR/dispatch-from-dyn-zst-transmute.rs:13:5
+   |
+LL |     token: IsSendToken<U>,
+   |     ^^^^^^^^^^^^^^^^^^^^^
+LL |     ptr: &'a U,
+   |     ^^^^^^^^^^
 
 error: aborting due to 1 previous error
 
-For more information about this error, try `rustc --explain E0378`.
+For more information about this error, try `rustc --explain E0375`.
diff --git a/tests/ui/simd/array-trait.rs b/tests/ui/simd/array-trait.rs
index 32cbf01428ca..262188567713 100644
--- a/tests/ui/simd/array-trait.rs
+++ b/tests/ui/simd/array-trait.rs
@@ -1,11 +1,11 @@
 // Figuring out the size of a vector type that depends on traits doesn't ICE
 
 #![allow(dead_code)]
-
-
-#![feature(repr_simd, intrinsics, generic_const_exprs)]
+#![feature(repr_simd, core_intrinsics, generic_const_exprs)]
 #![allow(non_camel_case_types, incomplete_features)]
 
+use std::intrinsics::simd::{simd_extract, simd_insert};
+
 pub trait Simd {
     type Lane: Clone + Copy;
     const SIZE: usize;
@@ -24,13 +24,6 @@ pub struct T<S: Simd>([S::Lane; S::SIZE]);
 //~| ERROR SIMD vector element type should be a primitive scalar
 //~| ERROR unconstrained generic constant
 
-#[rustc_intrinsic]
-unsafe fn simd_insert<T, E>(x: T, idx: u32, y: E) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_extract<T, E>(x: T, idx: u32) -> E;
-
-
 pub fn main() {
     let mut t = T::<i32x4>([0; 4]);
     unsafe {
diff --git a/tests/ui/simd/array-type.rs b/tests/ui/simd/array-type.rs
index d1de70044169..468e0b2f9b50 100644
--- a/tests/ui/simd/array-type.rs
+++ b/tests/ui/simd/array-type.rs
@@ -1,8 +1,8 @@
 //@ run-pass
 #![allow(dead_code)]
+#![feature(repr_simd, core_intrinsics)]
 
-
-#![feature(repr_simd, intrinsics)]
+use std::intrinsics::simd::{simd_extract, simd_insert};
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
@@ -12,13 +12,6 @@ struct S([i32; 4]);
 #[derive(Copy, Clone)]
 struct T<const N: usize>([i32; N]);
 
-#[rustc_intrinsic]
-unsafe fn simd_insert<T, E>(x: T, idx: u32, y: E) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_extract<T, E>(x: T, idx: u32) -> E;
-
-
 pub fn main() {
     let mut s = S([0; 4]);
 
diff --git a/tests/ui/simd/const-err-trumps-simd-err.stderr b/tests/ui/simd/const-err-trumps-simd-err.stderr
index 11cbcad227ff..e88c277885e3 100644
--- a/tests/ui/simd/const-err-trumps-simd-err.stderr
+++ b/tests/ui/simd/const-err-trumps-simd-err.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of `get_elem::<4>::{constant#0}` failed
   --> $DIR/const-err-trumps-simd-err.rs:16:13
    |
 LL |     const { assert!(LANE < 4); } // the error should be here...
-   |             ^^^^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: LANE < 4', $DIR/const-err-trumps-simd-err.rs:16:13
+   |             ^^^^^^^^^^^^^^^^^ evaluation panicked: assertion failed: LANE < 4
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/simd/generics.rs b/tests/ui/simd/generics.rs
index 453ed86c14a9..1ae08fef7cdf 100644
--- a/tests/ui/simd/generics.rs
+++ b/tests/ui/simd/generics.rs
@@ -1,7 +1,8 @@
 //@ run-pass
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
+use std::intrinsics::simd::simd_add;
 use std::ops;
 
 #[repr(simd)]
@@ -20,11 +21,7 @@ struct B<T>([T; 4]);
 #[derive(Copy, Clone)]
 struct C<T, const N: usize>([T; N]);
 
-
-#[rustc_intrinsic]
-unsafe fn simd_add<T>(x: T, y: T) -> T;
-
-fn add<T: ops::Add<Output=T>>(lhs: T, rhs: T) -> T {
+fn add<T: ops::Add<Output = T>>(lhs: T, rhs: T) -> T {
     lhs + rhs
 }
 
@@ -60,7 +57,6 @@ impl ops::Add for C<f32, 4> {
     }
 }
 
-
 pub fn main() {
     let x = [1.0f32, 2.0f32, 3.0f32, 4.0f32];
     let y = [2.0f32, 4.0f32, 6.0f32, 8.0f32];
diff --git a/tests/ui/simd/intrinsic/float-math-pass.rs b/tests/ui/simd/intrinsic/float-math-pass.rs
index 74cb51a06068..4c28568a739b 100644
--- a/tests/ui/simd/intrinsic/float-math-pass.rs
+++ b/tests/ui/simd/intrinsic/float-math-pass.rs
@@ -8,83 +8,30 @@
 
 // Test that the simd floating-point math intrinsics produce correct results.
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, intrinsics, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct f32x4(pub [f32; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_fsqrt<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fabs<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fsin<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fcos<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fexp<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fexp2<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fma<T>(x: T, y: T, z: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_relaxed_fma<T>(x: T, y: T, z: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_flog<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_flog10<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_flog2<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fpow<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_fpowi<T>(x: T, y: i32) -> T;
-
-
-// rounding functions
-#[rustc_intrinsic]
-unsafe fn simd_ceil<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_floor<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_round<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_trunc<T>(x: T) -> T;
-
+use std::intrinsics::simd::*;
 
 macro_rules! assert_approx_eq_f32 {
-    ($a:expr, $b:expr) => ({
+    ($a:expr, $b:expr) => {{
         let (a, b) = (&$a, &$b);
-        assert!((*a - *b).abs() < 1.0e-6,
-                "{} is not approximately equal to {}", *a, *b);
-    })
+        assert!((*a - *b).abs() < 1.0e-6, "{} is not approximately equal to {}", *a, *b);
+    }};
 }
 macro_rules! assert_approx_eq {
-    ($a:expr, $b:expr) => ({
+    ($a:expr, $b:expr) => {{
         let a = $a;
         let b = $b;
         assert_approx_eq_f32!(a.0[0], b.0[0]);
         assert_approx_eq_f32!(a.0[1], b.0[1]);
         assert_approx_eq_f32!(a.0[2], b.0[2]);
         assert_approx_eq_f32!(a.0[3], b.0[3]);
-    })
+    }};
 }
 
 fn main() {
@@ -125,12 +72,6 @@ fn main() {
         let r = simd_flog10(x);
         assert_approx_eq!(z, r);
 
-        let r = simd_fpow(h, x);
-        assert_approx_eq!(h, r);
-
-        let r = simd_fpowi(h, 1);
-        assert_approx_eq!(h, r);
-
         let r = simd_fsin(z);
         assert_approx_eq!(z, r);
 
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
index 0fcff8584c85..fdf06b7882ed 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.rs
@@ -1,7 +1,10 @@
 //@ build-fail
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
+
+use std::intrinsics::simd::*;
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct i32x4(pub [i32; 4]);
@@ -14,55 +17,6 @@ pub struct u32x4(pub [u32; 4]);
 #[derive(Copy, Clone)]
 pub struct f32x4(pub [f32; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_add<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_sub<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_mul<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_div<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_rem<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_shl<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_shr<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_and<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_or<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_xor<T>(x: T, y: T) -> T;
-
-
-#[rustc_intrinsic]
-unsafe fn simd_neg<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_bswap<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_bitreverse<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_ctlz<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_ctpop<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_cttz<T>(x: T) -> T;
-
 fn main() {
     let x = i32x4([0, 0, 0, 0]);
     let y = u32x4([0, 0, 0, 0]);
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
index e67de2fe9034..76db6d5328f5 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-2.stderr
@@ -1,143 +1,143 @@
 error[E0511]: invalid monomorphization of `simd_add` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:110:9
+  --> $DIR/generic-arithmetic-2.rs:64:9
    |
 LL |         simd_add(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_sub` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:112:9
+  --> $DIR/generic-arithmetic-2.rs:66:9
    |
 LL |         simd_sub(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_mul` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:114:9
+  --> $DIR/generic-arithmetic-2.rs:68:9
    |
 LL |         simd_mul(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_div` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:116:9
+  --> $DIR/generic-arithmetic-2.rs:70:9
    |
 LL |         simd_div(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shl` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:118:9
+  --> $DIR/generic-arithmetic-2.rs:72:9
    |
 LL |         simd_shl(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shr` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:120:9
+  --> $DIR/generic-arithmetic-2.rs:74:9
    |
 LL |         simd_shr(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_and` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:122:9
+  --> $DIR/generic-arithmetic-2.rs:76:9
    |
 LL |         simd_and(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_or` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:124:9
+  --> $DIR/generic-arithmetic-2.rs:78:9
    |
 LL |         simd_or(0, 0);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_xor` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:126:9
+  --> $DIR/generic-arithmetic-2.rs:80:9
    |
 LL |         simd_xor(0, 0);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_neg` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:129:9
+  --> $DIR/generic-arithmetic-2.rs:83:9
    |
 LL |         simd_neg(0);
    |         ^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:131:9
+  --> $DIR/generic-arithmetic-2.rs:85:9
    |
 LL |         simd_bswap(0);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:133:9
+  --> $DIR/generic-arithmetic-2.rs:87:9
    |
 LL |         simd_bitreverse(0);
    |         ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:135:9
+  --> $DIR/generic-arithmetic-2.rs:89:9
    |
 LL |         simd_ctlz(0);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-arithmetic-2.rs:137:9
+  --> $DIR/generic-arithmetic-2.rs:91:9
    |
 LL |         simd_cttz(0);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shl` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:140:9
+  --> $DIR/generic-arithmetic-2.rs:94:9
    |
 LL |         simd_shl(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shr` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:142:9
+  --> $DIR/generic-arithmetic-2.rs:96:9
    |
 LL |         simd_shr(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_and` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:144:9
+  --> $DIR/generic-arithmetic-2.rs:98:9
    |
 LL |         simd_and(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_or` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:146:9
+  --> $DIR/generic-arithmetic-2.rs:100:9
    |
 LL |         simd_or(z, z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_xor` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:148:9
+  --> $DIR/generic-arithmetic-2.rs:102:9
    |
 LL |         simd_xor(z, z);
    |         ^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bswap` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:150:9
+  --> $DIR/generic-arithmetic-2.rs:104:9
    |
 LL |         simd_bswap(z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitreverse` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:152:9
+  --> $DIR/generic-arithmetic-2.rs:106:9
    |
 LL |         simd_bitreverse(z);
    |         ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctlz` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:154:9
+  --> $DIR/generic-arithmetic-2.rs:108:9
    |
 LL |         simd_ctlz(z);
    |         ^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ctpop` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:156:9
+  --> $DIR/generic-arithmetic-2.rs:110:9
    |
 LL |         simd_ctpop(z);
    |         ^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cttz` intrinsic: unsupported operation on `f32x4` with element `f32`
-  --> $DIR/generic-arithmetic-2.rs:158:9
+  --> $DIR/generic-arithmetic-2.rs:112:9
    |
 LL |         simd_cttz(z);
    |         ^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
index 4a18c0164e4b..3f0325d690b5 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-pass.rs
@@ -1,7 +1,6 @@
 //@ run-pass
 #![allow(non_camel_case_types)]
-//@ ignore-emscripten FIXME(#45351) hits an LLVM assert
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
@@ -23,54 +22,7 @@ macro_rules! all_eq {
     }};
 }
 
-#[rustc_intrinsic]
-unsafe fn simd_add<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_sub<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_mul<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_div<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_rem<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_shl<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_shr<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_and<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_or<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_xor<T>(x: T, y: T) -> T;
-
-
-#[rustc_intrinsic]
-unsafe fn simd_neg<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_bswap<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_bitreverse<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_ctlz<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_ctpop<T>(x: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_cttz<T>(x: T) -> T;
+use std::intrinsics::simd::*;
 
 fn main() {
     let x1 = i32x4([1, 2, 3, 4]);
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.rs b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.rs
index 85464402d6af..ca170f2d8502 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.rs
@@ -1,7 +1,10 @@
 //@ build-fail
 //@ ignore-emscripten
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
+
+use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct i32x4(pub [i32; 4]);
@@ -14,13 +17,6 @@ pub struct x4<T>(pub [T; 4]);
 #[derive(Copy, Clone)]
 pub struct f32x4(pub [f32; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_saturating_add<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_saturating_sub<T>(x: T, y: T) -> T;
-
-
 fn main() {
     let x = i32x4([0, 0, 0, 0]);
     let y = x4([0_usize, 0, 0, 0]);
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.stderr b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.stderr
index cf275db7e435..f78745823402 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.stderr
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-2.stderr
@@ -1,11 +1,11 @@
 error[E0511]: invalid monomorphization of `simd_saturating_add` intrinsic: expected element type `f32` of vector type `f32x4` to be a signed or unsigned integer type
-  --> $DIR/generic-arithmetic-saturating-2.rs:35:9
+  --> $DIR/generic-arithmetic-saturating-2.rs:31:9
    |
 LL |         simd_saturating_add(z, z);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_saturating_sub` intrinsic: expected element type `f32` of vector type `f32x4` to be a signed or unsigned integer type
-  --> $DIR/generic-arithmetic-saturating-2.rs:37:9
+  --> $DIR/generic-arithmetic-saturating-2.rs:33:9
    |
 LL |         simd_saturating_sub(z, z);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs
index 5fe65257d15f..4d12a312331a 100644
--- a/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-arithmetic-saturating-pass.rs
@@ -2,7 +2,9 @@
 //@ ignore-emscripten
 
 #![allow(non_camel_case_types)]
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
+
+use std::intrinsics::simd::{simd_saturating_add, simd_saturating_sub};
 
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -12,13 +14,6 @@ struct u32x4(pub [u32; 4]);
 #[derive(Copy, Clone)]
 struct I32<const N: usize>([i32; N]);
 
-#[rustc_intrinsic]
-unsafe fn simd_saturating_add<T>(x: T, y: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_saturating_sub<T>(x: T, y: T) -> T;
-
-
 fn main() {
     // unsigned
     {
diff --git a/tests/ui/simd/intrinsic/generic-as.rs b/tests/ui/simd/intrinsic/generic-as.rs
index 124ca56bc889..da53211cbc74 100644
--- a/tests/ui/simd/intrinsic/generic-as.rs
+++ b/tests/ui/simd/intrinsic/generic-as.rs
@@ -1,10 +1,8 @@
 //@ run-pass
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-
-#[rustc_intrinsic]
-unsafe fn simd_as<T, U>(x: T) -> U;
+use std::intrinsics::simd::simd_as;
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
diff --git a/tests/ui/simd/intrinsic/generic-bitmask-pass.rs b/tests/ui/simd/intrinsic/generic-bitmask-pass.rs
index 08526991fbe1..cb3221e21d53 100644
--- a/tests/ui/simd/intrinsic/generic-bitmask-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-bitmask-pass.rs
@@ -1,13 +1,12 @@
 //@ run-pass
 #![allow(non_camel_case_types)]
-
 //@ ignore-emscripten
 //@ ignore-endian-big behavior of simd_bitmask is endian-specific
 
 // Test that the simd_bitmask intrinsic produces correct results.
+#![feature(repr_simd, core_intrinsics)]
 
-#![feature(repr_simd, intrinsics)]
-#[allow(non_camel_case_types)]
+use std::intrinsics::simd::simd_bitmask;
 
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -21,9 +20,6 @@ struct u8x4(pub [u8; 4]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct Tx4<T>(pub [T; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_bitmask<T, U>(x: T) -> U;
-
 fn main() {
     let z = u32x4([0, 0, 0, 0]);
     let ez = 0_u8;
@@ -56,6 +52,5 @@ fn main() {
 
         let r: u8 = simd_bitmask(msize);
         assert_eq!(r, e);
-
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-bitmask.rs b/tests/ui/simd/intrinsic/generic-bitmask.rs
index 49589d22bbfa..9f5e806337eb 100644
--- a/tests/ui/simd/intrinsic/generic-bitmask.rs
+++ b/tests/ui/simd/intrinsic/generic-bitmask.rs
@@ -3,9 +3,11 @@
 // Test that the simd_bitmask intrinsic produces ok-ish error
 // messages when misused.
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_bitmask;
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct u32x2([u32; 2]);
@@ -30,9 +32,6 @@ struct u8x32([u8; 32]);
 #[derive(Copy, Clone)]
 struct u8x64([u8; 64]);
 
-#[rustc_intrinsic]
-unsafe fn simd_bitmask<T, U>(x: T) -> U;
-
 fn main() {
     let m2 = u32x2([0; 2]);
     let m4 = u32x4([0; 4]);
@@ -63,6 +62,5 @@ fn main() {
 
         let _: u128 = simd_bitmask(m64);
         //~^ ERROR invalid monomorphization of `simd_bitmask` intrinsic
-
-   }
+    }
 }
diff --git a/tests/ui/simd/intrinsic/generic-bitmask.stderr b/tests/ui/simd/intrinsic/generic-bitmask.stderr
index c217bb2d8f1a..3c4878f39cc9 100644
--- a/tests/ui/simd/intrinsic/generic-bitmask.stderr
+++ b/tests/ui/simd/intrinsic/generic-bitmask.stderr
@@ -1,29 +1,29 @@
 error[E0511]: invalid monomorphization of `simd_bitmask` intrinsic: cannot return `u16`, expected `u8` or `[u8; 1]`
-  --> $DIR/generic-bitmask.rs:52:22
+  --> $DIR/generic-bitmask.rs:51:22
    |
 LL |         let _: u16 = simd_bitmask(m2);
    |                      ^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitmask` intrinsic: cannot return `u16`, expected `u8` or `[u8; 1]`
-  --> $DIR/generic-bitmask.rs:55:22
+  --> $DIR/generic-bitmask.rs:54:22
    |
 LL |         let _: u16 = simd_bitmask(m8);
    |                      ^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitmask` intrinsic: cannot return `u32`, expected `u16` or `[u8; 2]`
-  --> $DIR/generic-bitmask.rs:58:22
+  --> $DIR/generic-bitmask.rs:57:22
    |
 LL |         let _: u32 = simd_bitmask(m16);
    |                      ^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitmask` intrinsic: cannot return `u64`, expected `u32` or `[u8; 4]`
-  --> $DIR/generic-bitmask.rs:61:22
+  --> $DIR/generic-bitmask.rs:60:22
    |
 LL |         let _: u64 = simd_bitmask(m32);
    |                      ^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_bitmask` intrinsic: cannot return `u128`, expected `u64` or `[u8; 8]`
-  --> $DIR/generic-bitmask.rs:64:23
+  --> $DIR/generic-bitmask.rs:63:23
    |
 LL |         let _: u128 = simd_bitmask(m64);
    |                       ^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-bswap-byte.rs b/tests/ui/simd/intrinsic/generic-bswap-byte.rs
index 4521573636c0..903a07656a70 100644
--- a/tests/ui/simd/intrinsic/generic-bswap-byte.rs
+++ b/tests/ui/simd/intrinsic/generic-bswap-byte.rs
@@ -1,7 +1,9 @@
 //@ run-pass
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_bswap;
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct i8x4([i8; 4]);
@@ -10,9 +12,6 @@ struct i8x4([i8; 4]);
 #[derive(Copy, Clone)]
 struct u8x4([u8; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_bswap<T>(x: T) -> T;
-
 fn main() {
     unsafe {
         assert_eq!(simd_bswap(i8x4([0, 1, 2, 3])).0, [0, 1, 2, 3]);
diff --git a/tests/ui/simd/intrinsic/generic-cast-pass.rs b/tests/ui/simd/intrinsic/generic-cast-pass.rs
index 2155d8458647..7a4663bcad2b 100644
--- a/tests/ui/simd/intrinsic/generic-cast-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-cast-pass.rs
@@ -1,11 +1,8 @@
 //@ run-pass
-//@ ignore-emscripten FIXME(#45351) hits an LLVM assert
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-
-#[rustc_intrinsic]
-unsafe fn simd_cast<T, U>(x: T) -> U;
+use std::intrinsics::simd::simd_cast;
 
 use std::cmp::{max, min};
 
diff --git a/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs b/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs
index 9f28898654f2..ea34e9ffeb8e 100644
--- a/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs
+++ b/tests/ui/simd/intrinsic/generic-cast-pointer-width.rs
@@ -1,8 +1,7 @@
 //@ run-pass
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-#[rustc_intrinsic]
-unsafe fn simd_cast<T, U>(x: T) -> U;
+use std::intrinsics::simd::simd_cast;
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
diff --git a/tests/ui/simd/intrinsic/generic-cast.rs b/tests/ui/simd/intrinsic/generic-cast.rs
index 7f398804eb4f..4b13a93f323f 100644
--- a/tests/ui/simd/intrinsic/generic-cast.rs
+++ b/tests/ui/simd/intrinsic/generic-cast.rs
@@ -1,6 +1,8 @@
 //@ build-fail
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
+
+use std::intrinsics::simd::simd_cast;
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
@@ -20,10 +22,6 @@ struct f32x4([f32; 4]);
 #[allow(non_camel_case_types)]
 struct f32x8([f32; 8]);
 
-
-#[rustc_intrinsic]
-unsafe fn simd_cast<T, U>(x: T) -> U;
-
 fn main() {
     let x = i32x4([0, 0, 0, 0]);
 
@@ -35,6 +33,6 @@ fn main() {
         simd_cast::<i32x4, i32>(x);
         //~^ ERROR expected SIMD return type, found non-SIMD `i32`
         simd_cast::<_, i32x8>(x);
-//~^ ERROR return type with length 4 (same as input type `i32x4`), found `i32x8` with length 8
+        //~^ ERROR return type with length 4 (same as input type `i32x4`), found `i32x8` with length 8
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-cast.stderr b/tests/ui/simd/intrinsic/generic-cast.stderr
index 1b6ac03f8c96..192aa13216b1 100644
--- a/tests/ui/simd/intrinsic/generic-cast.stderr
+++ b/tests/ui/simd/intrinsic/generic-cast.stderr
@@ -1,23 +1,23 @@
 error[E0511]: invalid monomorphization of `simd_cast` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-cast.rs:31:9
+  --> $DIR/generic-cast.rs:29:9
    |
 LL |         simd_cast::<i32, i32>(0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cast` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-cast.rs:33:9
+  --> $DIR/generic-cast.rs:31:9
    |
 LL |         simd_cast::<i32, i32x4>(0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cast` intrinsic: expected SIMD return type, found non-SIMD `i32`
-  --> $DIR/generic-cast.rs:35:9
+  --> $DIR/generic-cast.rs:33:9
    |
 LL |         simd_cast::<i32x4, i32>(x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_cast` intrinsic: expected return type with length 4 (same as input type `i32x4`), found `i32x8` with length 8
-  --> $DIR/generic-cast.rs:37:9
+  --> $DIR/generic-cast.rs:35:9
    |
 LL |         simd_cast::<_, i32x8>(x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-comparison-pass.rs b/tests/ui/simd/intrinsic/generic-comparison-pass.rs
index 68f98372e1dc..2ee164cdfd80 100644
--- a/tests/ui/simd/intrinsic/generic-comparison-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-comparison-pass.rs
@@ -1,9 +1,10 @@
 //@ run-pass
-//@ ignore-emscripten FIXME(#45351) hits an LLVM assert
 
-#![feature(repr_simd, intrinsics, concat_idents)]
+#![feature(repr_simd, core_intrinsics, concat_idents)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_eq, simd_ge, simd_gt, simd_le, simd_lt, simd_ne};
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 struct i32x4([i32; 4]);
@@ -14,36 +15,17 @@ struct u32x4(pub [u32; 4]);
 #[derive(Copy, Clone)]
 struct f32x4(pub [f32; 4]);
 
-
-#[rustc_intrinsic]
-unsafe fn simd_eq<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_ne<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_lt<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_le<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_gt<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_ge<T, U>(x: T, y: T) -> U;
-
 macro_rules! cmp {
     ($method: ident($lhs: expr, $rhs: expr)) => {{
         let lhs = $lhs;
         let rhs = $rhs;
         let e: u32x4 = concat_idents!(simd_, $method)($lhs, $rhs);
         // assume the scalar version is correct/the behaviour we want.
-        assert!((e.0[0] != 0) == lhs.0[0] .$method(&rhs.0[0]));
-        assert!((e.0[1] != 0) == lhs.0[1] .$method(&rhs.0[1]));
-        assert!((e.0[2] != 0) == lhs.0[2] .$method(&rhs.0[2]));
-        assert!((e.0[3] != 0) == lhs.0[3] .$method(&rhs.0[3]));
-    }}
+        assert!((e.0[0] != 0) == lhs.0[0].$method(&rhs.0[0]));
+        assert!((e.0[1] != 0) == lhs.0[1].$method(&rhs.0[1]));
+        assert!((e.0[2] != 0) == lhs.0[2].$method(&rhs.0[2]));
+        assert!((e.0[3] != 0) == lhs.0[3].$method(&rhs.0[3]));
+    }};
 }
 macro_rules! tests {
     ($($lhs: ident, $rhs: ident;)*) => {{
@@ -75,9 +57,9 @@ fn main() {
     let i2 = i32x4([5, -5, 20, -100]);
     let i3 = i32x4([10, -11, 20, -100]);
 
-    let u1 = u32x4([10, !11+1, 12, 13]);
-    let u2 = u32x4([5, !5+1, 20, !100+1]);
-    let u3 = u32x4([10, !11+1, 20, !100+1]);
+    let u1 = u32x4([10, !11 + 1, 12, 13]);
+    let u2 = u32x4([5, !5 + 1, 20, !100 + 1]);
+    let u3 = u32x4([10, !11 + 1, 20, !100 + 1]);
 
     let f1 = f32x4([10.0, -11.0, 12.0, 13.0]);
     let f2 = f32x4([5.0, -5.0, 20.0, -100.0]);
diff --git a/tests/ui/simd/intrinsic/generic-comparison.rs b/tests/ui/simd/intrinsic/generic-comparison.rs
index e5adb49f6a3b..ebd1f629be47 100644
--- a/tests/ui/simd/intrinsic/generic-comparison.rs
+++ b/tests/ui/simd/intrinsic/generic-comparison.rs
@@ -1,6 +1,6 @@
 //@ build-fail
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
@@ -11,24 +11,7 @@ struct i32x4([i32; 4]);
 #[allow(non_camel_case_types)]
 struct i16x8([i16; 8]);
 
-
-#[rustc_intrinsic]
-unsafe fn simd_eq<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_ne<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_lt<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_le<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_gt<T, U>(x: T, y: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_ge<T, U>(x: T, y: T) -> U;
+use std::intrinsics::simd::{simd_eq, simd_ge, simd_gt, simd_le, simd_lt, simd_ne};
 
 fn main() {
     let x = i32x4([0, 0, 0, 0]);
@@ -61,16 +44,16 @@ fn main() {
         //~^ ERROR expected SIMD return type, found non-SIMD `i32`
 
         simd_eq::<_, i16x8>(x, x);
-//~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
+        //~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
         simd_ne::<_, i16x8>(x, x);
-//~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
+        //~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
         simd_lt::<_, i16x8>(x, x);
-//~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
+        //~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
         simd_le::<_, i16x8>(x, x);
-//~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
+        //~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
         simd_gt::<_, i16x8>(x, x);
-//~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
+        //~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
         simd_ge::<_, i16x8>(x, x);
-//~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
+        //~^ ERROR return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-comparison.stderr b/tests/ui/simd/intrinsic/generic-comparison.stderr
index cc66d2ce40a9..a6e91bf6a36b 100644
--- a/tests/ui/simd/intrinsic/generic-comparison.stderr
+++ b/tests/ui/simd/intrinsic/generic-comparison.stderr
@@ -1,107 +1,107 @@
 error[E0511]: invalid monomorphization of `simd_eq` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:37:9
+  --> $DIR/generic-comparison.rs:20:9
    |
 LL |         simd_eq::<i32, i32>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ne` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:39:9
+  --> $DIR/generic-comparison.rs:22:9
    |
 LL |         simd_ne::<i32, i32>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_lt` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:41:9
+  --> $DIR/generic-comparison.rs:24:9
    |
 LL |         simd_lt::<i32, i32>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_le` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:43:9
+  --> $DIR/generic-comparison.rs:26:9
    |
 LL |         simd_le::<i32, i32>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_gt` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:45:9
+  --> $DIR/generic-comparison.rs:28:9
    |
 LL |         simd_gt::<i32, i32>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ge` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:47:9
+  --> $DIR/generic-comparison.rs:30:9
    |
 LL |         simd_ge::<i32, i32>(0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_eq` intrinsic: expected SIMD return type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:50:9
+  --> $DIR/generic-comparison.rs:33:9
    |
 LL |         simd_eq::<_, i32>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ne` intrinsic: expected SIMD return type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:52:9
+  --> $DIR/generic-comparison.rs:35:9
    |
 LL |         simd_ne::<_, i32>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_lt` intrinsic: expected SIMD return type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:54:9
+  --> $DIR/generic-comparison.rs:37:9
    |
 LL |         simd_lt::<_, i32>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_le` intrinsic: expected SIMD return type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:56:9
+  --> $DIR/generic-comparison.rs:39:9
    |
 LL |         simd_le::<_, i32>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_gt` intrinsic: expected SIMD return type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:58:9
+  --> $DIR/generic-comparison.rs:41:9
    |
 LL |         simd_gt::<_, i32>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ge` intrinsic: expected SIMD return type, found non-SIMD `i32`
-  --> $DIR/generic-comparison.rs:60:9
+  --> $DIR/generic-comparison.rs:43:9
    |
 LL |         simd_ge::<_, i32>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_eq` intrinsic: expected return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
-  --> $DIR/generic-comparison.rs:63:9
+  --> $DIR/generic-comparison.rs:46:9
    |
 LL |         simd_eq::<_, i16x8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ne` intrinsic: expected return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
-  --> $DIR/generic-comparison.rs:65:9
+  --> $DIR/generic-comparison.rs:48:9
    |
 LL |         simd_ne::<_, i16x8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_lt` intrinsic: expected return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
-  --> $DIR/generic-comparison.rs:67:9
+  --> $DIR/generic-comparison.rs:50:9
    |
 LL |         simd_lt::<_, i16x8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_le` intrinsic: expected return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
-  --> $DIR/generic-comparison.rs:69:9
+  --> $DIR/generic-comparison.rs:52:9
    |
 LL |         simd_le::<_, i16x8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_gt` intrinsic: expected return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
-  --> $DIR/generic-comparison.rs:71:9
+  --> $DIR/generic-comparison.rs:54:9
    |
 LL |         simd_gt::<_, i16x8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_ge` intrinsic: expected return type with length 4 (same as input type `i32x4`), found `i16x8` with length 8
-  --> $DIR/generic-comparison.rs:73:9
+  --> $DIR/generic-comparison.rs:56:9
    |
 LL |         simd_ge::<_, i16x8>(x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-elements-pass.rs b/tests/ui/simd/intrinsic/generic-elements-pass.rs
index 8cb600bc9e45..4dc2e4d5a80a 100644
--- a/tests/ui/simd/intrinsic/generic-elements-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-elements-pass.rs
@@ -1,7 +1,8 @@
 //@ run-pass
-//@ ignore-emscripten FIXME(#45351) hits an LLVM assert
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
+
+use std::intrinsics::simd::{simd_extract, simd_insert, simd_shuffle};
 
 #[repr(simd)]
 #[derive(Copy, Clone, Debug, PartialEq)]
@@ -16,16 +17,6 @@ struct i32x4([i32; 4]);
 #[allow(non_camel_case_types)]
 struct i32x8([i32; 8]);
 
-#[rustc_intrinsic]
-unsafe fn simd_insert<T, E>(x: T, idx: u32, y: E) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_extract<T, E>(x: T, idx: u32) -> E;
-
-
-#[rustc_intrinsic]
-unsafe fn simd_shuffle<T, I, U>(x: T, y: T, idx: I) -> U;
-
 #[repr(simd)]
 struct SimdShuffleIdx<const LEN: usize>([u32; LEN]);
 
diff --git a/tests/ui/simd/intrinsic/generic-elements.rs b/tests/ui/simd/intrinsic/generic-elements.rs
index 4be6645f029c..905299a92897 100644
--- a/tests/ui/simd/intrinsic/generic-elements.rs
+++ b/tests/ui/simd/intrinsic/generic-elements.rs
@@ -1,8 +1,20 @@
 //@ build-fail
 
-#![feature(repr_simd, intrinsics, rustc_attrs, adt_const_params, unsized_const_params)]
+#![feature(
+    repr_simd,
+    intrinsics,
+    core_intrinsics,
+    rustc_attrs,
+    adt_const_params,
+    unsized_const_params
+)]
 #![allow(incomplete_features)]
 
+use std::intrinsics::simd::{simd_extract, simd_insert, simd_shuffle};
+
+#[rustc_intrinsic]
+unsafe fn simd_shuffle_const_generic<T, U, const IDX: &'static [u32]>(x: T, y: T) -> U;
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 #[allow(non_camel_case_types)]
@@ -29,21 +41,6 @@ struct f32x4([f32; 4]);
 #[allow(non_camel_case_types)]
 struct f32x8([f32; 8]);
 
-
-#[rustc_intrinsic]
-unsafe fn simd_insert<T, E>(x: T, idx: u32, y: E) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_extract<T, E>(x: T, idx: u32) -> E;
-
-
-#[rustc_intrinsic]
-unsafe fn simd_shuffle<T, I, U>(x: T, y: T, idx: I) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_shuffle_generic<T, U, const IDX: &'static [u32]>(x: T, y: T) -> U;
-
-
 #[repr(simd)]
 struct SimdShuffleIdx<const LEN: usize>([u32; LEN]);
 
@@ -83,27 +80,27 @@ fn main() {
         //~^ ERROR expected return type of length 8, found `i32x2` with length 2
 
         const I2: &[u32] = &[0; 2];
-        simd_shuffle_generic::<i32, i32, I2>(0, 0);
+        simd_shuffle_const_generic::<i32, i32, I2>(0, 0);
         //~^ ERROR expected SIMD input type, found non-SIMD `i32`
         const I4: &[u32] = &[0; 4];
-        simd_shuffle_generic::<i32, i32, I4>(0, 0);
+        simd_shuffle_const_generic::<i32, i32, I4>(0, 0);
         //~^ ERROR expected SIMD input type, found non-SIMD `i32`
         const I8: &[u32] = &[0; 8];
-        simd_shuffle_generic::<i32, i32, I8>(0, 0);
+        simd_shuffle_const_generic::<i32, i32, I8>(0, 0);
         //~^ ERROR expected SIMD input type, found non-SIMD `i32`
 
-        simd_shuffle_generic::<_, f32x2, I2>(x, x);
+        simd_shuffle_const_generic::<_, f32x2, I2>(x, x);
         //~^ ERROR element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32`
-        simd_shuffle_generic::<_, f32x4, I4>(x, x);
+        simd_shuffle_const_generic::<_, f32x4, I4>(x, x);
         //~^ ERROR element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32`
-        simd_shuffle_generic::<_, f32x8, I8>(x, x);
+        simd_shuffle_const_generic::<_, f32x8, I8>(x, x);
         //~^ ERROR element type `i32` (element of input `i32x4`), found `f32x8` with element type `f32`
 
-        simd_shuffle_generic::<_, i32x8, I2>(x, x);
+        simd_shuffle_const_generic::<_, i32x8, I2>(x, x);
         //~^ ERROR expected return type of length 2, found `i32x8` with length 8
-        simd_shuffle_generic::<_, i32x8, I4>(x, x);
+        simd_shuffle_const_generic::<_, i32x8, I4>(x, x);
         //~^ ERROR expected return type of length 4, found `i32x8` with length 8
-        simd_shuffle_generic::<_, i32x2, I8>(x, x);
+        simd_shuffle_const_generic::<_, i32x2, I8>(x, x);
         //~^ ERROR expected return type of length 8, found `i32x2` with length 2
     }
 }
diff --git a/tests/ui/simd/intrinsic/generic-elements.stderr b/tests/ui/simd/intrinsic/generic-elements.stderr
index 8104c3ba5a2e..3779aa86cee1 100644
--- a/tests/ui/simd/intrinsic/generic-elements.stderr
+++ b/tests/ui/simd/intrinsic/generic-elements.stderr
@@ -1,128 +1,128 @@
 error[E0511]: invalid monomorphization of `simd_insert` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:54:9
+  --> $DIR/generic-elements.rs:51:9
    |
 LL |         simd_insert(0, 0, 0);
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_insert` intrinsic: expected inserted type `i32` (element of input `i32x4`), found `f64`
-  --> $DIR/generic-elements.rs:56:9
+  --> $DIR/generic-elements.rs:53:9
    |
 LL |         simd_insert(x, 0, 1.0);
    |         ^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_extract` intrinsic: expected return type `i32` (element of input `i32x4`), found `f32`
-  --> $DIR/generic-elements.rs:58:9
+  --> $DIR/generic-elements.rs:55:9
    |
 LL |         simd_extract::<_, f32>(x, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:62:9
+  --> $DIR/generic-elements.rs:59:9
    |
 LL |         simd_shuffle::<i32, _, i32>(0, 0, IDX2);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:65:9
+  --> $DIR/generic-elements.rs:62:9
    |
 LL |         simd_shuffle::<i32, _, i32>(0, 0, IDX4);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected SIMD input type, found non-SIMD `i32`
-  --> $DIR/generic-elements.rs:68:9
+  --> $DIR/generic-elements.rs:65:9
    |
 LL |         simd_shuffle::<i32, _, i32>(0, 0, IDX8);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32`
-  --> $DIR/generic-elements.rs:71:9
+  --> $DIR/generic-elements.rs:68:9
    |
 LL |         simd_shuffle::<_, _, f32x2>(x, x, IDX2);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32`
-  --> $DIR/generic-elements.rs:73:9
+  --> $DIR/generic-elements.rs:70:9
    |
 LL |         simd_shuffle::<_, _, f32x4>(x, x, IDX4);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x8` with element type `f32`
-  --> $DIR/generic-elements.rs:75:9
+  --> $DIR/generic-elements.rs:72:9
    |
 LL |         simd_shuffle::<_, _, f32x8>(x, x, IDX8);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return type of length 2, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:78:9
+  --> $DIR/generic-elements.rs:75:9
    |
 LL |         simd_shuffle::<_, _, i32x8>(x, x, IDX2);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return type of length 4, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:80:9
+  --> $DIR/generic-elements.rs:77:9
    |
 LL |         simd_shuffle::<_, _, i32x8>(x, x, IDX4);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return type of length 8, found `i32x2` with length 2
-  --> $DIR/generic-elements.rs:82:9
+  --> $DIR/generic-elements.rs:79:9
    |
 LL |         simd_shuffle::<_, _, i32x2>(x, x, IDX8);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
+  --> $DIR/generic-elements.rs:83:9
+   |
+LL |         simd_shuffle_const_generic::<i32, i32, I2>(0, 0);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
   --> $DIR/generic-elements.rs:86:9
    |
-LL |         simd_shuffle_generic::<i32, i32, I2>(0, 0);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<i32, i32, I4>(0, 0);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
   --> $DIR/generic-elements.rs:89:9
    |
-LL |         simd_shuffle_generic::<i32, i32, I4>(0, 0);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<i32, i32, I8>(0, 0);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected SIMD input type, found non-SIMD `i32`
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32`
   --> $DIR/generic-elements.rs:92:9
    |
-LL |         simd_shuffle_generic::<i32, i32, I8>(0, 0);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<_, f32x2, I2>(x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x2` with element type `f32`
-  --> $DIR/generic-elements.rs:95:9
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32`
+  --> $DIR/generic-elements.rs:94:9
    |
-LL |         simd_shuffle_generic::<_, f32x2, I2>(x, x);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<_, f32x4, I4>(x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x4` with element type `f32`
-  --> $DIR/generic-elements.rs:97:9
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x8` with element type `f32`
+  --> $DIR/generic-elements.rs:96:9
    |
-LL |         simd_shuffle_generic::<_, f32x4, I4>(x, x);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<_, f32x8, I8>(x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected return element type `i32` (element of input `i32x4`), found `f32x8` with element type `f32`
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return type of length 2, found `i32x8` with length 8
   --> $DIR/generic-elements.rs:99:9
    |
-LL |         simd_shuffle_generic::<_, f32x8, I8>(x, x);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<_, i32x8, I2>(x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected return type of length 2, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:102:9
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return type of length 4, found `i32x8` with length 8
+  --> $DIR/generic-elements.rs:101:9
    |
-LL |         simd_shuffle_generic::<_, i32x8, I2>(x, x);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<_, i32x8, I4>(x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected return type of length 4, found `i32x8` with length 8
-  --> $DIR/generic-elements.rs:104:9
+error[E0511]: invalid monomorphization of `simd_shuffle_const_generic` intrinsic: expected return type of length 8, found `i32x2` with length 2
+  --> $DIR/generic-elements.rs:103:9
    |
-LL |         simd_shuffle_generic::<_, i32x8, I4>(x, x);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error[E0511]: invalid monomorphization of `simd_shuffle_generic` intrinsic: expected return type of length 8, found `i32x2` with length 2
-  --> $DIR/generic-elements.rs:106:9
-   |
-LL |         simd_shuffle_generic::<_, i32x2, I8>(x, x);
-   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+LL |         simd_shuffle_const_generic::<_, i32x2, I8>(x, x);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 21 previous errors
 
diff --git a/tests/ui/simd/intrinsic/generic-gather-pass.rs b/tests/ui/simd/intrinsic/generic-gather-pass.rs
index 0b2cf47e9898..b98d4d6575bb 100644
--- a/tests/ui/simd/intrinsic/generic-gather-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-gather-pass.rs
@@ -3,19 +3,15 @@
 
 // Test that the simd_{gather,scatter} intrinsics produce the correct results.
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_gather, simd_scatter};
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct x4<T>(pub [T; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_gather<T, U, V>(x: T, y: U, z: V) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_scatter<T, U, V>(x: T, y: U, z: V) -> ();
-
 fn main() {
     let mut x = [0_f32, 1., 2., 3., 4., 5., 6., 7.];
 
@@ -26,12 +22,8 @@ fn main() {
     // reading from *const
     unsafe {
         let pointer = x.as_ptr();
-        let pointers =  x4([
-            pointer.offset(0),
-            pointer.offset(2),
-            pointer.offset(4),
-            pointer.offset(6)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -41,12 +33,8 @@ fn main() {
     // reading from *mut
     unsafe {
         let pointer = x.as_mut_ptr();
-        let pointers = x4([
-            pointer.offset(0),
-            pointer.offset(2),
-            pointer.offset(4),
-            pointer.offset(6)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -56,12 +44,8 @@ fn main() {
     // writing to *mut
     unsafe {
         let pointer = x.as_mut_ptr();
-        let pointers = x4([
-            pointer.offset(0),
-            pointer.offset(2),
-            pointer.offset(4),
-            pointer.offset(6)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
 
         let values = x4([42_f32, 43_f32, 44_f32, 45_f32]);
         simd_scatter(values, pointers, mask);
@@ -78,7 +62,7 @@ fn main() {
         &x[4] as *const f32,
         &x[5] as *const f32,
         &x[6] as *const f32,
-        &x[7] as *const f32
+        &x[7] as *const f32,
     ];
 
     let default = x4([y[0], y[0], y[0], y[0]]);
@@ -87,12 +71,8 @@ fn main() {
     // reading from *const
     unsafe {
         let pointer = y.as_ptr();
-        let pointers = x4([
-            pointer.offset(0),
-            pointer.offset(2),
-            pointer.offset(4),
-            pointer.offset(6)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -102,12 +82,8 @@ fn main() {
     // reading from *mut
     unsafe {
         let pointer = y.as_mut_ptr();
-        let pointers = x4([
-            pointer.offset(0),
-            pointer.offset(2),
-            pointer.offset(4),
-            pointer.offset(6)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
 
         let r_strided = simd_gather(default, pointers, mask);
 
@@ -117,12 +93,8 @@ fn main() {
     // writing to *mut
     unsafe {
         let pointer = y.as_mut_ptr();
-        let pointers = x4([
-            pointer.offset(0),
-            pointer.offset(2),
-            pointer.offset(4),
-            pointer.offset(6)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(2), pointer.offset(4), pointer.offset(6)]);
 
         let values = x4([y[7], y[6], y[5], y[1]]);
         simd_scatter(values, pointers, mask);
@@ -135,7 +107,7 @@ fn main() {
             &x[4] as *const f32,
             &x[5] as *const f32,
             &x[1] as *const f32,
-            &x[7] as *const f32
+            &x[7] as *const f32,
         ];
         assert_eq!(y, s);
     }
diff --git a/tests/ui/simd/intrinsic/generic-reduction-pass.rs b/tests/ui/simd/intrinsic/generic-reduction-pass.rs
index 8408d0f203bf..2d5d75447b66 100644
--- a/tests/ui/simd/intrinsic/generic-reduction-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-reduction-pass.rs
@@ -1,12 +1,11 @@
 //@ run-pass
 #![allow(non_camel_case_types)]
-
 //@ ignore-emscripten
 
 // Test that the simd_reduce_{op} intrinsics produce the correct results.
+#![feature(repr_simd, core_intrinsics)]
 
-#![feature(repr_simd, intrinsics)]
-#[allow(non_camel_case_types)]
+use std::intrinsics::simd::*;
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
@@ -24,39 +23,6 @@ struct f32x4(pub [f32; 4]);
 #[derive(Copy, Clone)]
 struct b8x4(pub [i8; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_reduce_add_unordered<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_mul_unordered<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_add_ordered<T, U>(x: T, acc: U) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_mul_ordered<T, U>(x: T, acc: U) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_min<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_max<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_and<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_or<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_xor<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_all<T>(x: T) -> bool;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_any<T>(x: T) -> bool;
-
 fn main() {
     unsafe {
         let x = i32x4([1, -2, 3, 4]);
diff --git a/tests/ui/simd/intrinsic/generic-reduction.rs b/tests/ui/simd/intrinsic/generic-reduction.rs
index ead13250643c..49a33ac35e74 100644
--- a/tests/ui/simd/intrinsic/generic-reduction.rs
+++ b/tests/ui/simd/intrinsic/generic-reduction.rs
@@ -4,9 +4,11 @@
 // Test that the simd_reduce_{op} intrinsics produce ok-ish error
 // messages when misused.
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::*;
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct f32x4(pub [f32; 4]);
@@ -15,27 +17,6 @@ pub struct f32x4(pub [f32; 4]);
 #[derive(Copy, Clone)]
 pub struct u32x4(pub [u32; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_reduce_add_ordered<T, U>(x: T, y: U) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_mul_ordered<T, U>(x: T, y: U) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_and<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_or<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_xor<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_all<T>(x: T) -> bool;
-
-#[rustc_intrinsic]
-unsafe fn simd_reduce_any<T>(x: T) -> bool;
-
 fn main() {
     let x = u32x4([0, 0, 0, 0]);
     let z = f32x4([0.0, 0.0, 0.0, 0.0]);
diff --git a/tests/ui/simd/intrinsic/generic-reduction.stderr b/tests/ui/simd/intrinsic/generic-reduction.stderr
index 302b9ae1d778..eaa7b8d48eb3 100644
--- a/tests/ui/simd/intrinsic/generic-reduction.stderr
+++ b/tests/ui/simd/intrinsic/generic-reduction.stderr
@@ -1,59 +1,59 @@
 error[E0511]: invalid monomorphization of `simd_reduce_add_ordered` intrinsic: expected return type `f32` (element of input `f32x4`), found `i32`
-  --> $DIR/generic-reduction.rs:44:9
+  --> $DIR/generic-reduction.rs:25:9
    |
 LL |         simd_reduce_add_ordered(z, 0);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_mul_ordered` intrinsic: expected return type `f32` (element of input `f32x4`), found `i32`
-  --> $DIR/generic-reduction.rs:46:9
+  --> $DIR/generic-reduction.rs:27:9
    |
 LL |         simd_reduce_mul_ordered(z, 1);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_and` intrinsic: expected return type `u32` (element of input `u32x4`), found `f32`
-  --> $DIR/generic-reduction.rs:49:22
+  --> $DIR/generic-reduction.rs:30:22
    |
 LL |         let _: f32 = simd_reduce_and(x);
    |                      ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_or` intrinsic: expected return type `u32` (element of input `u32x4`), found `f32`
-  --> $DIR/generic-reduction.rs:51:22
+  --> $DIR/generic-reduction.rs:32:22
    |
 LL |         let _: f32 = simd_reduce_or(x);
    |                      ^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_xor` intrinsic: expected return type `u32` (element of input `u32x4`), found `f32`
-  --> $DIR/generic-reduction.rs:53:22
+  --> $DIR/generic-reduction.rs:34:22
    |
 LL |         let _: f32 = simd_reduce_xor(x);
    |                      ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_and` intrinsic: unsupported simd_reduce_and from `f32x4` with element `f32` to `f32`
-  --> $DIR/generic-reduction.rs:56:22
+  --> $DIR/generic-reduction.rs:37:22
    |
 LL |         let _: f32 = simd_reduce_and(z);
    |                      ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_or` intrinsic: unsupported simd_reduce_or from `f32x4` with element `f32` to `f32`
-  --> $DIR/generic-reduction.rs:58:22
+  --> $DIR/generic-reduction.rs:39:22
    |
 LL |         let _: f32 = simd_reduce_or(z);
    |                      ^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_xor` intrinsic: unsupported simd_reduce_xor from `f32x4` with element `f32` to `f32`
-  --> $DIR/generic-reduction.rs:60:22
+  --> $DIR/generic-reduction.rs:41:22
    |
 LL |         let _: f32 = simd_reduce_xor(z);
    |                      ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_all` intrinsic: unsupported simd_reduce_all from `f32x4` with element `f32` to `bool`
-  --> $DIR/generic-reduction.rs:63:23
+  --> $DIR/generic-reduction.rs:44:23
    |
 LL |         let _: bool = simd_reduce_all(z);
    |                       ^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_reduce_any` intrinsic: unsupported simd_reduce_any from `f32x4` with element `f32` to `bool`
-  --> $DIR/generic-reduction.rs:65:23
+  --> $DIR/generic-reduction.rs:46:23
    |
 LL |         let _: bool = simd_reduce_any(z);
    |                       ^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-select-pass.rs b/tests/ui/simd/intrinsic/generic-select-pass.rs
index 6b1b6cb79dbc..0e5f7c4902f3 100644
--- a/tests/ui/simd/intrinsic/generic-select-pass.rs
+++ b/tests/ui/simd/intrinsic/generic-select-pass.rs
@@ -1,13 +1,12 @@
 //@ run-pass
 #![allow(non_camel_case_types)]
-
 //@ ignore-emscripten
 //@ ignore-endian-big behavior of simd_select_bitmask is endian-specific
 
 // Test that the simd_select intrinsics produces correct results.
+#![feature(repr_simd, core_intrinsics)]
 
-#![feature(repr_simd, intrinsics)]
-#[allow(non_camel_case_types)]
+use std::intrinsics::simd::{simd_select, simd_select_bitmask};
 
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
@@ -29,13 +28,6 @@ struct f32x4(pub [f32; 4]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct b8x4(pub [i8; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_select<T, U>(x: T, a: U, b: U) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_select_bitmask<T, U>(x: T, a: U, b: U) -> U;
-
-
 fn main() {
     let m0 = b8x4([!0, !0, !0, !0]);
     let m1 = b8x4([0, 0, 0, 0]);
diff --git a/tests/ui/simd/intrinsic/generic-select.rs b/tests/ui/simd/intrinsic/generic-select.rs
index 340fe3f35929..917ad3ca6046 100644
--- a/tests/ui/simd/intrinsic/generic-select.rs
+++ b/tests/ui/simd/intrinsic/generic-select.rs
@@ -3,9 +3,11 @@
 // Test that the simd_select intrinsic produces ok-ish error
 // messages when misused.
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_select, simd_select_bitmask};
+
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct f32x4(pub [f32; 4]);
@@ -22,14 +24,6 @@ struct b8x4(pub [i8; 4]);
 #[derive(Copy, Clone, PartialEq)]
 struct b8x8(pub [i8; 8]);
 
-
-#[rustc_intrinsic]
-unsafe fn simd_select<T, U>(x: T, a: U, b: U) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_select_bitmask<T, U>(x: T, a: U, b: U) -> U;
-
-
 fn main() {
     let m4 = b8x4([0, 0, 0, 0]);
     let m8 = b8x8([0, 0, 0, 0, 0, 0, 0, 0]);
diff --git a/tests/ui/simd/intrinsic/generic-select.stderr b/tests/ui/simd/intrinsic/generic-select.stderr
index a97fc91f951d..c46584d117ce 100644
--- a/tests/ui/simd/intrinsic/generic-select.stderr
+++ b/tests/ui/simd/intrinsic/generic-select.stderr
@@ -1,47 +1,47 @@
 error[E0511]: invalid monomorphization of `simd_select` intrinsic: mismatched lengths: mask length `8` != other vector length `4`
-  --> $DIR/generic-select.rs:42:9
+  --> $DIR/generic-select.rs:36:9
    |
 LL |         simd_select(m8, x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_select` intrinsic: mask element type is `u32`, expected `i_`
-  --> $DIR/generic-select.rs:45:9
+  --> $DIR/generic-select.rs:39:9
    |
 LL |         simd_select(x, x, x);
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_select` intrinsic: mask element type is `f32`, expected `i_`
-  --> $DIR/generic-select.rs:48:9
+  --> $DIR/generic-select.rs:42:9
    |
 LL |         simd_select(z, z, z);
    |         ^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_select` intrinsic: expected SIMD argument type, found non-SIMD `u32`
-  --> $DIR/generic-select.rs:51:9
+  --> $DIR/generic-select.rs:45:9
    |
 LL |         simd_select(m4, 0u32, 1u32);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: invalid bitmask `u16`, expected `u8` or `[u8; 1]`
-  --> $DIR/generic-select.rs:54:9
+  --> $DIR/generic-select.rs:48:9
    |
 LL |         simd_select_bitmask(0u16, x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: expected SIMD argument type, found non-SIMD `u32`
-  --> $DIR/generic-select.rs:57:9
+  --> $DIR/generic-select.rs:51:9
    |
 LL |         simd_select_bitmask(0u8, 1u32, 2u32);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: invalid bitmask `f32`, expected `u8` or `[u8; 1]`
-  --> $DIR/generic-select.rs:60:9
+  --> $DIR/generic-select.rs:54:9
    |
 LL |         simd_select_bitmask(0.0f32, x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_select_bitmask` intrinsic: invalid bitmask `&str`, expected `u8` or `[u8; 1]`
-  --> $DIR/generic-select.rs:63:9
+  --> $DIR/generic-select.rs:57:9
    |
 LL |         simd_select_bitmask("x", x, x);
    |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/generic-shuffle.rs b/tests/ui/simd/intrinsic/generic-shuffle.rs
index 1223b8ebe190..7cfd764f5d5e 100644
--- a/tests/ui/simd/intrinsic/generic-shuffle.rs
+++ b/tests/ui/simd/intrinsic/generic-shuffle.rs
@@ -3,16 +3,14 @@
 // Test that the simd_shuffle intrinsic produces ok-ish error
 // messages when misused.
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
+
+use std::intrinsics::simd::simd_shuffle;
 
 #[repr(simd)]
 #[derive(Copy, Clone)]
 pub struct Simd<T, const N: usize>([T; N]);
 
-#[rustc_intrinsic]
-unsafe fn simd_shuffle<T, I, U>(a: T, b: T, i: I) -> U;
-
-
 fn main() {
     const I: Simd<u32, 2> = Simd([0; 2]);
     const I2: Simd<f32, 2> = Simd([0.; 2]);
diff --git a/tests/ui/simd/intrinsic/generic-shuffle.stderr b/tests/ui/simd/intrinsic/generic-shuffle.stderr
index 7e6d51a5f655..e8cd528b7020 100644
--- a/tests/ui/simd/intrinsic/generic-shuffle.stderr
+++ b/tests/ui/simd/intrinsic/generic-shuffle.stderr
@@ -1,23 +1,23 @@
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: simd_shuffle index must be a SIMD vector of `u32`, got `[u32; 2]`
-  --> $DIR/generic-shuffle.rs:24:31
+  --> $DIR/generic-shuffle.rs:22:31
    |
 LL |         let _: Simd<u32, 2> = simd_shuffle(v, v, const { [0u32; 2] });
    |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return type of length 2, found `Simd<u32, 4>` with length 4
-  --> $DIR/generic-shuffle.rs:27:31
+  --> $DIR/generic-shuffle.rs:25:31
    |
 LL |         let _: Simd<u32, 4> = simd_shuffle(v, v, I);
    |                               ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: expected return element type `u32` (element of input `Simd<u32, 4>`), found `Simd<f32, 2>` with element type `f32`
-  --> $DIR/generic-shuffle.rs:30:31
+  --> $DIR/generic-shuffle.rs:28:31
    |
 LL |         let _: Simd<f32, 2> = simd_shuffle(v, v, I);
    |                               ^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_shuffle` intrinsic: simd_shuffle index must be a SIMD vector of `u32`, got `Simd<f32, 2>`
-  --> $DIR/generic-shuffle.rs:33:31
+  --> $DIR/generic-shuffle.rs:31:31
    |
 LL |         let _: Simd<u32, 2> = simd_shuffle(v, v, I2);
    |                               ^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/simd/intrinsic/inlining-issue67557-ice.rs b/tests/ui/simd/intrinsic/inlining-issue67557-ice.rs
index b324ac40749f..49a26ff57341 100644
--- a/tests/ui/simd/intrinsic/inlining-issue67557-ice.rs
+++ b/tests/ui/simd/intrinsic/inlining-issue67557-ice.rs
@@ -3,10 +3,9 @@
 //
 //@ run-pass
 //@ compile-flags: -Zmir-opt-level=4
-#![feature(intrinsics, repr_simd)]
+#![feature(core_intrinsics, repr_simd)]
 
-#[rustc_intrinsic]
-unsafe fn simd_shuffle<T, I, U>(x: T, y: T, idx: I) -> U;
+use std::intrinsics::simd::simd_shuffle;
 
 #[repr(simd)]
 #[derive(Debug, PartialEq)]
diff --git a/tests/ui/simd/intrinsic/inlining-issue67557.rs b/tests/ui/simd/intrinsic/inlining-issue67557.rs
index 319bb15c0157..13e7266b2a56 100644
--- a/tests/ui/simd/intrinsic/inlining-issue67557.rs
+++ b/tests/ui/simd/intrinsic/inlining-issue67557.rs
@@ -3,10 +3,9 @@
 //
 //@ run-pass
 //@ compile-flags: -Zmir-opt-level=4
-#![feature(intrinsics, repr_simd)]
+#![feature(core_intrinsics, repr_simd)]
 
-#[rustc_intrinsic]
-unsafe fn simd_shuffle<T, I, U>(x: T, y: T, idx: I) -> U;
+use std::intrinsics::simd::simd_shuffle;
 
 #[repr(simd)]
 #[derive(Debug, PartialEq)]
@@ -36,7 +35,6 @@ fn assert_10_13(x: Simd2) {
     assert_eq!(x, Simd2([10, 13]));
 }
 
-
 #[inline(always)]
 unsafe fn inline_me() -> Simd2 {
     const IDX: SimdShuffleIdx<2> = SimdShuffleIdx([0, 3]);
diff --git a/tests/ui/simd/intrinsic/issue-85855.rs b/tests/ui/simd/intrinsic/issue-85855.rs
index daeea793d1bc..cbaa8f046bee 100644
--- a/tests/ui/simd/intrinsic/issue-85855.rs
+++ b/tests/ui/simd/intrinsic/issue-85855.rs
@@ -3,8 +3,7 @@
 // that no ICE occurs in these cases.
 
 #![feature(intrinsics)]
-#![crate_type="lib"]
-
+#![crate_type = "lib"]
 
 #[rustc_intrinsic]
 unsafe fn simd_saturating_add<'a, T: 'a>(x: T, y: T);
diff --git a/tests/ui/simd/intrinsic/issue-85855.stderr b/tests/ui/simd/intrinsic/issue-85855.stderr
index b91a606ba68a..af61c6fcdc13 100644
--- a/tests/ui/simd/intrinsic/issue-85855.stderr
+++ b/tests/ui/simd/intrinsic/issue-85855.stderr
@@ -1,17 +1,17 @@
 error[E0094]: intrinsic has wrong number of lifetime parameters: found 1, expected 0
-  --> $DIR/issue-85855.rs:10:30
+  --> $DIR/issue-85855.rs:9:30
    |
 LL | unsafe fn simd_saturating_add<'a, T: 'a>(x: T, y: T);
    |                              ^^^^^^^^^^^ expected 0 lifetime parameters
 
 error[E0094]: intrinsic has wrong number of type parameters: found 2, expected 1
-  --> $DIR/issue-85855.rs:17:19
+  --> $DIR/issue-85855.rs:16:19
    |
 LL | unsafe fn simd_sub<T, U>(x: T, y: U);
    |                   ^^^^^^ expected 1 type parameter
 
 error[E0094]: intrinsic has wrong number of const parameters: found 1, expected 0
-  --> $DIR/issue-85855.rs:21:19
+  --> $DIR/issue-85855.rs:20:19
    |
 LL | unsafe fn simd_mul<T, const N: usize>(x: T, y: T);
    |                   ^^^^^^^^^^^^^^^^^^^ expected 0 const parameters
diff --git a/tests/ui/simd/intrinsic/ptr-cast.rs b/tests/ui/simd/intrinsic/ptr-cast.rs
index 559b8ba1b5c2..3a73c0273e1a 100644
--- a/tests/ui/simd/intrinsic/ptr-cast.rs
+++ b/tests/ui/simd/intrinsic/ptr-cast.rs
@@ -1,16 +1,8 @@
 //@ run-pass
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-
-#[rustc_intrinsic]
-unsafe fn simd_cast_ptr<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_expose_provenance<T, U>(x: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_with_exposed_provenance<T, U>(x: T) -> U;
+use std::intrinsics::simd::{simd_cast_ptr, simd_expose_provenance, simd_with_exposed_provenance};
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
diff --git a/tests/ui/simd/issue-105439.rs b/tests/ui/simd/issue-105439.rs
index 108bb282df2a..0a44f36fb2ec 100644
--- a/tests/ui/simd/issue-105439.rs
+++ b/tests/ui/simd/issue-105439.rs
@@ -1,17 +1,13 @@
 //@ run-pass
 //@ compile-flags: -O -Zverify-llvm-ir
 
-#![feature(repr_simd)]
-#![feature(intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
 #[allow(non_camel_case_types)]
 #[derive(Clone, Copy)]
 #[repr(simd)]
 struct i32x4([i32; 4]);
 
-#[rustc_intrinsic]
-pub(crate) unsafe fn simd_add<T>(x: T, y: T) -> T;
-
 #[inline(always)]
 fn to_array(a: i32x4) -> [i32; 4] {
     a.0
@@ -19,6 +15,6 @@ fn to_array(a: i32x4) -> [i32; 4] {
 
 fn main() {
     let a = i32x4([1, 2, 3, 4]);
-    let b = unsafe { simd_add(a, a) };
+    let b = unsafe { std::intrinsics::simd::simd_add(a, a) };
     assert_eq!(to_array(b), [2, 4, 6, 8]);
 }
diff --git a/tests/ui/simd/issue-32947.rs b/tests/ui/simd/issue-32947.rs
index dc5e7a4ec915..b34484b2d3b5 100644
--- a/tests/ui/simd/issue-32947.rs
+++ b/tests/ui/simd/issue-32947.rs
@@ -1,5 +1,4 @@
 //@ run-pass
-//@ ignore-emscripten FIXME(#45351)
 
 #![feature(repr_simd, test)]
 
@@ -15,9 +14,7 @@ fn main() {
     // non-optimized builds
     unsafe {
         let memory = &mut [0u64; 8] as *mut _ as *mut u8;
-        let misaligned_ptr: &mut [u8; 32] = {
-            std::mem::transmute(memory.offset(1))
-        };
+        let misaligned_ptr: &mut [u8; 32] = { std::mem::transmute(memory.offset(1)) };
         *misaligned_ptr = std::mem::transmute(Mu64([1, 1, 1, 1]));
         test::black_box(memory);
     }
diff --git a/tests/ui/simd/issue-39720.rs b/tests/ui/simd/issue-39720.rs
index 8d7666faaf93..db441e551679 100644
--- a/tests/ui/simd/issue-39720.rs
+++ b/tests/ui/simd/issue-39720.rs
@@ -1,7 +1,6 @@
 //@ run-pass
-//@ ignore-emscripten FIXME(#45351)
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
 #[repr(simd)]
 #[derive(Copy, Clone, Debug)]
@@ -11,11 +10,8 @@ pub struct Char3(pub [i8; 3]);
 #[derive(Copy, Clone, Debug)]
 pub struct Short3(pub [i16; 3]);
 
-#[rustc_intrinsic]
-unsafe fn simd_cast<T, U>(x: T) -> U;
-
 fn main() {
-    let cast: Short3 = unsafe { simd_cast(Char3([10, -3, -9])) };
+    let cast: Short3 = unsafe { std::intrinsics::simd::simd_cast(Char3([10, -3, -9])) };
 
     println!("{:?}", cast);
 }
diff --git a/tests/ui/simd/issue-85915-simd-ptrs.rs b/tests/ui/simd/issue-85915-simd-ptrs.rs
index 2e7baf48ee32..4e2379d05251 100644
--- a/tests/ui/simd/issue-85915-simd-ptrs.rs
+++ b/tests/ui/simd/issue-85915-simd-ptrs.rs
@@ -3,9 +3,11 @@
 
 // Short form of the generic gather/scatter tests,
 // verifying simd([*const T; N]) and simd([*mut T; N]) pass typeck and work.
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::{simd_gather, simd_scatter};
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct cptrx4<T>([*const T; 4]);
@@ -22,13 +24,6 @@ struct f32x4([f32; 4]);
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct i32x4([i32; 4]);
 
-
-#[rustc_intrinsic]
-unsafe fn simd_gather<T, U, V>(x: T, y: U, z: V) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_scatter<T, U, V>(x: T, y: U, z: V) -> ();
-
 fn main() {
     let mut x = [0_f32, 1., 2., 3., 4., 5., 6., 7.];
 
@@ -39,11 +34,11 @@ fn main() {
     // reading from *const
     unsafe {
         let pointer = &x as *const f32;
-        let pointers =  cptrx4([
+        let pointers = cptrx4([
             pointer.offset(0) as *const f32,
             pointer.offset(2),
             pointer.offset(4),
-            pointer.offset(6)
+            pointer.offset(6),
         ]);
 
         let r_strided = simd_gather(default, pointers, mask);
@@ -58,7 +53,7 @@ fn main() {
             pointer.offset(0) as *mut f32,
             pointer.offset(2),
             pointer.offset(4),
-            pointer.offset(6)
+            pointer.offset(6),
         ]);
 
         let values = f32x4([42_f32, 43_f32, 44_f32, 45_f32]);
diff --git a/tests/ui/simd/issue-89193.rs b/tests/ui/simd/issue-89193.rs
index 4b4fb9d91696..a6c3017572a1 100644
--- a/tests/ui/simd/issue-89193.rs
+++ b/tests/ui/simd/issue-89193.rs
@@ -3,16 +3,15 @@
 // Test that simd gather instructions on slice of usize don't cause crash
 // See issue #89183 - https://github.com/rust-lang/rust/issues/89193
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_gather;
+
 #[repr(simd)]
 #[derive(Copy, Clone, PartialEq, Debug)]
 struct x4<T>(pub [T; 4]);
 
-#[rustc_intrinsic]
-unsafe fn simd_gather<T, U, V>(x: T, y: U, z: V) -> T;
-
 fn main() {
     let x: [usize; 4] = [10, 11, 12, 13];
     let default = x4([0_usize, 1, 2, 3]);
@@ -22,12 +21,8 @@ fn main() {
 
     unsafe {
         let pointer = x.as_ptr();
-        let pointers =  x4([
-            pointer.offset(0),
-            pointer.offset(1),
-            pointer.offset(2),
-            pointer.offset(3)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(1), pointer.offset(2), pointer.offset(3)]);
         let result = simd_gather(default, pointers, mask);
         assert_eq!(result, expected);
     }
@@ -39,12 +34,8 @@ fn main() {
 
     unsafe {
         let pointer = x.as_ptr();
-        let pointers =  x4([
-            pointer.offset(0),
-            pointer.offset(1),
-            pointer.offset(2),
-            pointer.offset(3)
-        ]);
+        let pointers =
+            x4([pointer.offset(0), pointer.offset(1), pointer.offset(2), pointer.offset(3)]);
         let result = simd_gather(default, pointers, mask);
         assert_eq!(result, expected);
     }
diff --git a/tests/ui/simd/masked-load-store-build-fail.rs b/tests/ui/simd/masked-load-store-build-fail.rs
index b8742184eb02..ad2de5561033 100644
--- a/tests/ui/simd/masked-load-store-build-fail.rs
+++ b/tests/ui/simd/masked-load-store-build-fail.rs
@@ -1,12 +1,7 @@
 //@ build-fail
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-
-#[rustc_intrinsic]
-unsafe fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_masked_store<M, P, T>(mask: M, pointer: P, values: T) -> ();
+use std::intrinsics::simd::{simd_masked_load, simd_masked_store};
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
@@ -17,60 +12,28 @@ fn main() {
         let mut arr = [4u8, 5, 6, 7];
         let default = Simd::<u8, 4>([9; 4]);
 
-        simd_masked_load(
-            Simd::<i8, 8>([-1, 0, -1, -1, 0, 0, 0, 0]),
-            arr.as_ptr(),
-            default
-        );
-        //~^^^^^ ERROR expected third argument with length 8 (same as input type `Simd<i8, 8>`), found `Simd<u8, 4>` with length 4
+        simd_masked_load(Simd::<i8, 8>([-1, 0, -1, -1, 0, 0, 0, 0]), arr.as_ptr(), default);
+        //~^ ERROR expected third argument with length 8 (same as input type `Simd<i8, 8>`), found `Simd<u8, 4>` with length 4
 
-        simd_masked_load(
-            Simd::<i8, 4>([-1, 0, -1, -1]),
-            arr.as_ptr() as *const i8,
-            default
-        );
-        //~^^^^^ ERROR expected element type `u8` of second argument `*const i8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*_ u8`
+        simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr() as *const i8, default);
+        //~^ ERROR expected element type `u8` of second argument `*const i8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*_ u8`
 
-        simd_masked_load(
-            Simd::<i8, 4>([-1, 0, -1, -1]),
-            arr.as_ptr(),
-            Simd::<u32, 4>([9; 4])
-        );
-        //~^^^^^ ERROR expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*_ u32`
+        simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u32, 4>([9; 4]));
+        //~^ ERROR expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*_ u32`
 
-        simd_masked_load(
-            Simd::<u8, 4>([1, 0, 1, 1]),
-            arr.as_ptr(),
-            default
-        );
-        //~^^^^^ ERROR expected element type `u8` of third argument `Simd<u8, 4>` to be a signed integer type
+        simd_masked_load(Simd::<u8, 4>([1, 0, 1, 1]), arr.as_ptr(), default);
+        //~^ ERROR expected element type `u8` of third argument `Simd<u8, 4>` to be a signed integer type
 
-        simd_masked_store(
-            Simd([-1i8; 4]),
-            arr.as_ptr(),
-            Simd([5u32; 4])
-        );
-        //~^^^^^ ERROR expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*mut u32`
+        simd_masked_store(Simd([-1i8; 4]), arr.as_ptr(), Simd([5u32; 4]));
+        //~^ ERROR expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*mut u32`
 
-        simd_masked_store(
-            Simd([-1i8; 4]),
-            arr.as_ptr(),
-            Simd([5u8; 4])
-        );
-        //~^^^^^ ERROR expected element type `u8` of second argument `*const u8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*mut u8`
+        simd_masked_store(Simd([-1i8; 4]), arr.as_ptr(), Simd([5u8; 4]));
+        //~^ ERROR expected element type `u8` of second argument `*const u8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*mut u8`
 
-        simd_masked_store(
-            Simd([-1i8; 4]),
-            arr.as_mut_ptr(),
-            Simd([5u8; 2])
-        );
-        //~^^^^^ ERROR expected third argument with length 4 (same as input type `Simd<i8, 4>`), found `Simd<u8, 2>` with length 2
+        simd_masked_store(Simd([-1i8; 4]), arr.as_mut_ptr(), Simd([5u8; 2]));
+        //~^ ERROR expected third argument with length 4 (same as input type `Simd<i8, 4>`), found `Simd<u8, 2>` with length 2
 
-        simd_masked_store(
-            Simd([1u32; 4]),
-            arr.as_mut_ptr(),
-            Simd([5u8; 4])
-        );
-        //~^^^^^ ERROR expected element type `u8` of third argument `Simd<u32, 4>` to be a signed integer type
+        simd_masked_store(Simd([1u32; 4]), arr.as_mut_ptr(), Simd([5u8; 4]));
+        //~^ ERROR expected element type `u8` of third argument `Simd<u32, 4>` to be a signed integer type
     }
 }
diff --git a/tests/ui/simd/masked-load-store-build-fail.stderr b/tests/ui/simd/masked-load-store-build-fail.stderr
index 8a8d8eb99e27..d57e0aa539f5 100644
--- a/tests/ui/simd/masked-load-store-build-fail.stderr
+++ b/tests/ui/simd/masked-load-store-build-fail.stderr
@@ -1,82 +1,50 @@
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected third argument with length 8 (same as input type `Simd<i8, 8>`), found `Simd<u8, 4>` with length 4
-  --> $DIR/masked-load-store-build-fail.rs:20:9
+  --> $DIR/masked-load-store-build-fail.rs:15:9
    |
-LL | /         simd_masked_load(
-LL | |             Simd::<i8, 8>([-1, 0, -1, -1, 0, 0, 0, 0]),
-LL | |             arr.as_ptr(),
-LL | |             default
-LL | |         );
-   | |_________^
+LL |         simd_masked_load(Simd::<i8, 8>([-1, 0, -1, -1, 0, 0, 0, 0]), arr.as_ptr(), default);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected element type `u8` of second argument `*const i8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*_ u8`
-  --> $DIR/masked-load-store-build-fail.rs:27:9
+  --> $DIR/masked-load-store-build-fail.rs:18:9
    |
-LL | /         simd_masked_load(
-LL | |             Simd::<i8, 4>([-1, 0, -1, -1]),
-LL | |             arr.as_ptr() as *const i8,
-LL | |             default
-LL | |         );
-   | |_________^
+LL |         simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr() as *const i8, default);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*_ u32`
-  --> $DIR/masked-load-store-build-fail.rs:34:9
+  --> $DIR/masked-load-store-build-fail.rs:21:9
    |
-LL | /         simd_masked_load(
-LL | |             Simd::<i8, 4>([-1, 0, -1, -1]),
-LL | |             arr.as_ptr(),
-LL | |             Simd::<u32, 4>([9; 4])
-LL | |         );
-   | |_________^
+LL |         simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u32, 4>([9; 4]));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_load` intrinsic: expected element type `u8` of third argument `Simd<u8, 4>` to be a signed integer type
-  --> $DIR/masked-load-store-build-fail.rs:41:9
+  --> $DIR/masked-load-store-build-fail.rs:24:9
    |
-LL | /         simd_masked_load(
-LL | |             Simd::<u8, 4>([1, 0, 1, 1]),
-LL | |             arr.as_ptr(),
-LL | |             default
-LL | |         );
-   | |_________^
+LL |         simd_masked_load(Simd::<u8, 4>([1, 0, 1, 1]), arr.as_ptr(), default);
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected element type `u32` of second argument `*const u8` to be a pointer to the element type `u32` of the first argument `Simd<u32, 4>`, found `u32` != `*mut u32`
-  --> $DIR/masked-load-store-build-fail.rs:48:9
+  --> $DIR/masked-load-store-build-fail.rs:27:9
    |
-LL | /         simd_masked_store(
-LL | |             Simd([-1i8; 4]),
-LL | |             arr.as_ptr(),
-LL | |             Simd([5u32; 4])
-LL | |         );
-   | |_________^
+LL |         simd_masked_store(Simd([-1i8; 4]), arr.as_ptr(), Simd([5u32; 4]));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected element type `u8` of second argument `*const u8` to be a pointer to the element type `u8` of the first argument `Simd<u8, 4>`, found `u8` != `*mut u8`
-  --> $DIR/masked-load-store-build-fail.rs:55:9
+  --> $DIR/masked-load-store-build-fail.rs:30:9
    |
-LL | /         simd_masked_store(
-LL | |             Simd([-1i8; 4]),
-LL | |             arr.as_ptr(),
-LL | |             Simd([5u8; 4])
-LL | |         );
-   | |_________^
+LL |         simd_masked_store(Simd([-1i8; 4]), arr.as_ptr(), Simd([5u8; 4]));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected third argument with length 4 (same as input type `Simd<i8, 4>`), found `Simd<u8, 2>` with length 2
-  --> $DIR/masked-load-store-build-fail.rs:62:9
+  --> $DIR/masked-load-store-build-fail.rs:33:9
    |
-LL | /         simd_masked_store(
-LL | |             Simd([-1i8; 4]),
-LL | |             arr.as_mut_ptr(),
-LL | |             Simd([5u8; 2])
-LL | |         );
-   | |_________^
+LL |         simd_masked_store(Simd([-1i8; 4]), arr.as_mut_ptr(), Simd([5u8; 2]));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error[E0511]: invalid monomorphization of `simd_masked_store` intrinsic: expected element type `u8` of third argument `Simd<u32, 4>` to be a signed integer type
-  --> $DIR/masked-load-store-build-fail.rs:69:9
+  --> $DIR/masked-load-store-build-fail.rs:36:9
    |
-LL | /         simd_masked_store(
-LL | |             Simd([1u32; 4]),
-LL | |             arr.as_mut_ptr(),
-LL | |             Simd([5u8; 4])
-LL | |         );
-   | |_________^
+LL |         simd_masked_store(Simd([1u32; 4]), arr.as_mut_ptr(), Simd([5u8; 4]));
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: aborting due to 8 previous errors
 
diff --git a/tests/ui/simd/masked-load-store-check-fail.rs b/tests/ui/simd/masked-load-store-check-fail.rs
index 0f36bf6443f9..3ed47cd9ed40 100644
--- a/tests/ui/simd/masked-load-store-check-fail.rs
+++ b/tests/ui/simd/masked-load-store-check-fail.rs
@@ -1,11 +1,7 @@
 //@ check-fail
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-#[rustc_intrinsic]
-unsafe fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_masked_store<M, P, T>(mask: M, pointer: P, values: T) -> ();
+use std::intrinsics::simd::{simd_masked_load, simd_masked_store};
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
@@ -16,18 +12,11 @@ fn main() {
         let mut arr = [4u8, 5, 6, 7];
         let default = Simd::<u8, 4>([9; 4]);
 
-        let _x: Simd<u8, 2> = simd_masked_load(
-            Simd::<i8, 4>([-1, 0, -1, -1]),
-            arr.as_ptr(),
-            Simd::<u8, 4>([9; 4])
-        );
-        //~^^ ERROR mismatched types
+        let _x: Simd<u8, 2> =
+            simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u8, 4>([9; 4]));
+        //~^ ERROR mismatched types
 
-        let _x: Simd<u32, 4> = simd_masked_load(
-            Simd::<u8, 4>([1, 0, 1, 1]),
-            arr.as_ptr(),
-            default
-        );
-        //~^^ ERROR mismatched types
+        let _x: Simd<u32, 4> = simd_masked_load(Simd::<u8, 4>([1, 0, 1, 1]), arr.as_ptr(), default);
+        //~^ ERROR mismatched types
     }
 }
diff --git a/tests/ui/simd/masked-load-store-check-fail.stderr b/tests/ui/simd/masked-load-store-check-fail.stderr
index fa65798fc94d..1c9f9d246df5 100644
--- a/tests/ui/simd/masked-load-store-check-fail.stderr
+++ b/tests/ui/simd/masked-load-store-check-fail.stderr
@@ -1,58 +1,38 @@
 error[E0308]: mismatched types
-  --> $DIR/masked-load-store-check-fail.rs:22:13
+  --> $DIR/masked-load-store-check-fail.rs:16:76
    |
-LL |         let _x: Simd<u8, 2> = simd_masked_load(
-   |                               ---------------- arguments to this function are incorrect
-...
-LL |             Simd::<u8, 4>([9; 4])
-   |             ^^^^^^^^^^^^^^^^^^^^^ expected `2`, found `4`
+LL |             simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u8, 4>([9; 4]));
+   |             ---------------- arguments to this function are incorrect      ^^^^^^^^^^^^^^^^^^^^^ expected `2`, found `4`
    |
    = note: expected struct `Simd<_, 2>`
               found struct `Simd<_, 4>`
 help: the return type of this call is `Simd<u8, 4>` due to the type of the argument passed
-  --> $DIR/masked-load-store-check-fail.rs:19:31
+  --> $DIR/masked-load-store-check-fail.rs:16:13
    |
-LL |           let _x: Simd<u8, 2> = simd_masked_load(
-   |  _______________________________^
-LL | |             Simd::<i8, 4>([-1, 0, -1, -1]),
-LL | |             arr.as_ptr(),
-LL | |             Simd::<u8, 4>([9; 4])
-   | |             --------------------- this argument influences the return type of `simd_masked_load`
-LL | |         );
-   | |_________^
+LL |             simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), arr.as_ptr(), Simd::<u8, 4>([9; 4]));
+   |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^---------------------^
+   |                                                                            |
+   |                                                                            this argument influences the return type of `simd_masked_load`
 note: function defined here
-  --> $DIR/masked-load-store-check-fail.rs:5:11
-   |
-LL | unsafe fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
-   |           ^^^^^^^^^^^^^^^^                               ---------
+  --> $SRC_DIR/core/src/intrinsics/simd.rs:LL:COL
 
 error[E0308]: mismatched types
-  --> $DIR/masked-load-store-check-fail.rs:29:13
+  --> $DIR/masked-load-store-check-fail.rs:19:92
    |
-LL |         let _x: Simd<u32, 4> = simd_masked_load(
-   |                                ---------------- arguments to this function are incorrect
-...
-LL |             default
-   |             ^^^^^^^ expected `Simd<u32, 4>`, found `Simd<u8, 4>`
+LL |         let _x: Simd<u32, 4> = simd_masked_load(Simd::<u8, 4>([1, 0, 1, 1]), arr.as_ptr(), default);
+   |                                ---------------- arguments to this function are incorrect   ^^^^^^^ expected `Simd<u32, 4>`, found `Simd<u8, 4>`
    |
    = note: expected struct `Simd<u32, _>`
               found struct `Simd<u8, _>`
 help: the return type of this call is `Simd<u8, 4>` due to the type of the argument passed
-  --> $DIR/masked-load-store-check-fail.rs:26:32
+  --> $DIR/masked-load-store-check-fail.rs:19:32
    |
-LL |           let _x: Simd<u32, 4> = simd_masked_load(
-   |  ________________________________^
-LL | |             Simd::<u8, 4>([1, 0, 1, 1]),
-LL | |             arr.as_ptr(),
-LL | |             default
-   | |             ------- this argument influences the return type of `simd_masked_load`
-LL | |         );
-   | |_________^
+LL |         let _x: Simd<u32, 4> = simd_masked_load(Simd::<u8, 4>([1, 0, 1, 1]), arr.as_ptr(), default);
+   |                                ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^-------^
+   |                                                                                            |
+   |                                                                                            this argument influences the return type of `simd_masked_load`
 note: function defined here
-  --> $DIR/masked-load-store-check-fail.rs:5:11
-   |
-LL | unsafe fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
-   |           ^^^^^^^^^^^^^^^^                               ---------
+  --> $SRC_DIR/core/src/intrinsics/simd.rs:LL:COL
 
 error: aborting due to 2 previous errors
 
diff --git a/tests/ui/simd/masked-load-store.rs b/tests/ui/simd/masked-load-store.rs
index 4b4195f51f18..69ea76581ee6 100644
--- a/tests/ui/simd/masked-load-store.rs
+++ b/tests/ui/simd/masked-load-store.rs
@@ -1,11 +1,7 @@
 //@ run-pass
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 
-#[rustc_intrinsic]
-unsafe fn simd_masked_load<M, P, T>(mask: M, pointer: P, values: T) -> T;
-
-#[rustc_intrinsic]
-unsafe fn simd_masked_store<M, P, T>(mask: M, pointer: P, values: T) -> ();
+use std::intrinsics::simd::{simd_masked_load, simd_masked_store};
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
@@ -16,11 +12,8 @@ fn main() {
         let a = Simd::<u8, 4>([0, 1, 2, 3]);
         let b_src = [4u8, 5, 6, 7];
         let b_default = Simd::<u8, 4>([9; 4]);
-        let b: Simd::<u8, 4> = simd_masked_load(
-            Simd::<i8, 4>([-1, 0, -1, -1]),
-            b_src.as_ptr(),
-            b_default
-        );
+        let b: Simd<u8, 4> =
+            simd_masked_load(Simd::<i8, 4>([-1, 0, -1, -1]), b_src.as_ptr(), b_default);
 
         assert_eq!(&b.0, &[4, 9, 6, 7]);
 
diff --git a/tests/ui/simd/monomorphize-shuffle-index.generic.stderr b/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
index b0a8da59fac1..b0742bc5ef80 100644
--- a/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
+++ b/tests/ui/simd/monomorphize-shuffle-index.generic.stderr
@@ -1,10 +1,10 @@
 error: overly complex generic constant
-  --> $DIR/monomorphize-shuffle-index.rs:32:45
+  --> $DIR/monomorphize-shuffle-index.rs:36:51
    |
-LL |         return simd_shuffle_generic::<_, _, { &Self::I.0 }>(a, b);
-   |                                             ^^----------^^
-   |                                               |
-   |                                               pointer casts are not allowed in generic constants
+LL |         return simd_shuffle_const_generic::<_, _, { &Self::I.0 }>(a, b);
+   |                                                   ^^----------^^
+   |                                                     |
+   |                                                     pointer casts are not allowed in generic constants
    |
    = help: consider moving this anonymous constant into a `const` function
 
diff --git a/tests/ui/simd/monomorphize-shuffle-index.rs b/tests/ui/simd/monomorphize-shuffle-index.rs
index 01926408a2ce..3a074dfd432c 100644
--- a/tests/ui/simd/monomorphize-shuffle-index.rs
+++ b/tests/ui/simd/monomorphize-shuffle-index.rs
@@ -1,18 +1,22 @@
+//@ revisions: old generic generic_with_fn
 //@[old]run-pass
 //@[generic_with_fn]run-pass
-//@ revisions: old generic generic_with_fn
-#![feature(repr_simd, intrinsics, adt_const_params, unsized_const_params, generic_const_exprs)]
+#![feature(
+    repr_simd,
+    core_intrinsics,
+    intrinsics,
+    adt_const_params,
+    unsized_const_params,
+    generic_const_exprs
+)]
 #![allow(incomplete_features)]
 
-
-#[rustc_intrinsic]
 #[cfg(old)]
-unsafe fn simd_shuffle<T, I, U>(a: T, b: T, i: I) -> U;
+use std::intrinsics::simd::simd_shuffle;
 
-#[rustc_intrinsic]
 #[cfg(any(generic, generic_with_fn))]
-unsafe fn simd_shuffle_generic<T, U, const I: &'static [u32]>(a: T, b: T) -> U;
-
+#[rustc_intrinsic]
+unsafe fn simd_shuffle_const_generic<T, U, const I: &'static [u32]>(a: T, b: T) -> U;
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
@@ -29,10 +33,10 @@ trait Shuffle<const N: usize> {
         #[cfg(old)]
         return simd_shuffle(a, b, Self::I);
         #[cfg(generic)]
-        return simd_shuffle_generic::<_, _, { &Self::I.0 }>(a, b);
+        return simd_shuffle_const_generic::<_, _, { &Self::I.0 }>(a, b);
         //[generic]~^ overly complex generic constant
         #[cfg(generic_with_fn)]
-        return simd_shuffle_generic::<_, _, { Self::J }>(a, b);
+        return simd_shuffle_const_generic::<_, _, { Self::J }>(a, b);
     }
 }
 
diff --git a/tests/ui/simd/repr_packed.rs b/tests/ui/simd/repr_packed.rs
index a666892226ea..cc54477ae713 100644
--- a/tests/ui/simd/repr_packed.rs
+++ b/tests/ui/simd/repr_packed.rs
@@ -1,8 +1,10 @@
 //@ run-pass
 
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(non_camel_case_types)]
 
+use std::intrinsics::simd::simd_add;
+
 #[repr(simd, packed)]
 struct Simd<T, const N: usize>([T; N]);
 
@@ -22,9 +24,6 @@ fn check_ty<T>() {
     check_size_align::<T, 15>();
 }
 
-#[rustc_intrinsic]
-unsafe fn simd_add<T>(a: T, b: T) -> T;
-
 fn main() {
     check_ty::<u8>();
     check_ty::<i16>();
diff --git a/tests/ui/simd/shuffle.rs b/tests/ui/simd/shuffle.rs
index 2cae5a1e7de2..cd270edcf00c 100644
--- a/tests/ui/simd/shuffle.rs
+++ b/tests/ui/simd/shuffle.rs
@@ -2,14 +2,13 @@
 //@ revisions: opt noopt
 //@[noopt] compile-flags: -Copt-level=0
 //@[opt] compile-flags: -O
-#![feature(repr_simd, intrinsics)]
+#![feature(repr_simd, core_intrinsics)]
 #![allow(incomplete_features)]
 #![feature(adt_const_params)]
 
 use std::marker::ConstParamTy;
 
-#[rustc_intrinsic]
-unsafe fn simd_shuffle<T, I, U>(a: T, b: T, i: I) -> U;
+use std::intrinsics::simd::simd_shuffle;
 
 #[derive(Copy, Clone, ConstParamTy, PartialEq, Eq)]
 #[repr(simd)]
diff --git a/tests/ui/simd/simd-bitmask-notpow2.rs b/tests/ui/simd/simd-bitmask-notpow2.rs
index d7572ef4a2a4..4935097065ea 100644
--- a/tests/ui/simd/simd-bitmask-notpow2.rs
+++ b/tests/ui/simd/simd-bitmask-notpow2.rs
@@ -2,14 +2,9 @@
 // FIXME: broken codegen on big-endian (https://github.com/rust-lang/rust/issues/127205)
 // This should be merged into `simd-bitmask` once that's fixed.
 //@ ignore-endian-big
-#![feature(repr_simd, intrinsics)]
-
-#[rustc_intrinsic]
-unsafe fn simd_bitmask<T, U>(v: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_select_bitmask<T, U>(m: T, a: U, b: U) -> U;
+#![feature(repr_simd, core_intrinsics)]
 
+use std::intrinsics::simd::{simd_bitmask, simd_select_bitmask};
 
 fn main() {
     // Non-power-of-2 multi-byte mask.
diff --git a/tests/ui/simd/simd-bitmask.rs b/tests/ui/simd/simd-bitmask.rs
index 4275ab0f40c9..6fcceeaa24bb 100644
--- a/tests/ui/simd/simd-bitmask.rs
+++ b/tests/ui/simd/simd-bitmask.rs
@@ -1,12 +1,7 @@
 //@run-pass
-#![feature(repr_simd, intrinsics)]
-
-#[rustc_intrinsic]
-unsafe fn simd_bitmask<T, U>(v: T) -> U;
-
-#[rustc_intrinsic]
-unsafe fn simd_select_bitmask<T, U>(m: T, a: U, b: U) -> U;
+#![feature(repr_simd, core_intrinsics)]
 
+use std::intrinsics::simd::{simd_bitmask, simd_select_bitmask};
 
 #[derive(Copy, Clone)]
 #[repr(simd)]
diff --git a/tests/ui/sized/coinductive-1.rs b/tests/ui/sized/coinductive-1.rs
index 3c1ee557af77..42dd8d1f6042 100644
--- a/tests/ui/sized/coinductive-1.rs
+++ b/tests/ui/sized/coinductive-1.rs
@@ -1,4 +1,7 @@
 //@ check-pass
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
 struct Node<C: Trait<Self>>(C::Assoc);
 
 trait Trait<T> {
diff --git a/tests/ui/stability-attribute/stability-attribute-sanity.rs b/tests/ui/stability-attribute/stability-attribute-sanity.rs
index 7857a0603bd4..f46e35e1a72a 100644
--- a/tests/ui/stability-attribute/stability-attribute-sanity.rs
+++ b/tests/ui/stability-attribute/stability-attribute-sanity.rs
@@ -8,16 +8,16 @@ mod bogus_attribute_types_1 {
     #[stable(feature = "a", since = "4.4.4", reason)] //~ ERROR unknown meta item 'reason' [E0541]
     fn f1() { }
 
-    #[stable(feature = "a", since)] //~ ERROR incorrect meta item [E0539]
+    #[stable(feature = "a", since)] //~ ERROR expected a quoted string literal [E0539]
     fn f2() { }
 
-    #[stable(feature, since = "3.3.3")] //~ ERROR incorrect meta item [E0539]
+    #[stable(feature, since = "3.3.3")] //~ ERROR expected a quoted string literal [E0539]
     fn f3() { }
 
-    #[stable(feature = "a", since(b))] //~ ERROR incorrect meta item [E0539]
+    #[stable(feature = "a", since(b))] //~ ERROR expected a quoted string literal [E0539]
     fn f5() { }
 
-    #[stable(feature(b), since = "3.3.3")] //~ ERROR incorrect meta item [E0539]
+    #[stable(feature(b), since = "3.3.3")] //~ ERROR expected a quoted string literal [E0539]
     fn f6() { }
 }
 
diff --git a/tests/ui/stability-attribute/stability-attribute-sanity.stderr b/tests/ui/stability-attribute/stability-attribute-sanity.stderr
index c614fc2b9f7f..2e2b5b509c89 100644
--- a/tests/ui/stability-attribute/stability-attribute-sanity.stderr
+++ b/tests/ui/stability-attribute/stability-attribute-sanity.stderr
@@ -1,40 +1,28 @@
-error: multiple `deprecated` attributes
-  --> $DIR/stability-attribute-sanity.rs:62:1
-   |
-LL | #[deprecated(since = "5.5.5", note = "text")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
-   |
-note: attribute also specified here
-  --> $DIR/stability-attribute-sanity.rs:61:1
-   |
-LL | #[deprecated(since = "5.5.5", note = "text")]
-   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
 error[E0541]: unknown meta item 'reason'
   --> $DIR/stability-attribute-sanity.rs:8:46
    |
 LL |     #[stable(feature = "a", since = "4.4.4", reason)]
    |                                              ^^^^^^ expected one of `feature`, `since`
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/stability-attribute-sanity.rs:11:29
    |
 LL |     #[stable(feature = "a", since)]
    |                             ^^^^^
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/stability-attribute-sanity.rs:14:14
    |
 LL |     #[stable(feature, since = "3.3.3")]
    |              ^^^^^^^
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/stability-attribute-sanity.rs:17:29
    |
 LL |     #[stable(feature = "a", since(b))]
    |                             ^^^^^^^^
 
-error[E0539]: incorrect meta item
+error[E0539]: expected a quoted string literal
   --> $DIR/stability-attribute-sanity.rs:20:14
    |
 LL |     #[stable(feature(b), since = "3.3.3")]
@@ -100,6 +88,18 @@ error: 'since' must be a Rust version number, such as "1.31.0"
 LL | #[stable(feature = "e", since = "b")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
+error: multiple `deprecated` attributes
+  --> $DIR/stability-attribute-sanity.rs:62:1
+   |
+LL | #[deprecated(since = "5.5.5", note = "text")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ help: remove this attribute
+   |
+note: attribute also specified here
+  --> $DIR/stability-attribute-sanity.rs:61:1
+   |
+LL | #[deprecated(since = "5.5.5", note = "text")]
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
 error[E0544]: multiple stability levels
   --> $DIR/stability-attribute-sanity.rs:64:1
    |
diff --git a/tests/ui/static/static_sized_requirement.rs b/tests/ui/static/static_sized_requirement.rs
index 80f93dea0544..25e1359607c9 100644
--- a/tests/ui/static/static_sized_requirement.rs
+++ b/tests/ui/static/static_sized_requirement.rs
@@ -1,11 +1,12 @@
-//@ build-pass (FIXME(62277): could be check-pass?)
+//@ add-core-stubs
+//@ check-pass
 
 #![feature(no_core, lang_items)]
 #![no_core]
 #![crate_type = "lib"]
 
-#[lang = "sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 extern "C" {
     pub static A: u32;
diff --git a/tests/ui/structs/default-field-values/invalid-const.stderr b/tests/ui/structs/default-field-values/invalid-const.stderr
index f4a3437031bd..56d20d8d7111 100644
--- a/tests/ui/structs/default-field-values/invalid-const.stderr
+++ b/tests/ui/structs/default-field-values/invalid-const.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/invalid-const.rs:5:19
    |
 LL |     pub bax: u8 = panic!("asdf"),
-   |                   ^^^^^^^^^^^^^^ the evaluated program panicked at 'asdf', $DIR/invalid-const.rs:5:19
+   |                   ^^^^^^^^^^^^^^ evaluation panicked: asdf
    |
    = note: this error originates in the macro `$crate::panic::panic_2015` which comes from the expansion of the macro `panic` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/suggestions/abi-typo.stderr b/tests/ui/suggestions/abi-typo.stderr
index 5195c43220b4..4d89ac16570e 100644
--- a/tests/ui/suggestions/abi-typo.stderr
+++ b/tests/ui/suggestions/abi-typo.stderr
@@ -2,12 +2,14 @@ error[E0703]: invalid ABI: found `cdedl`
   --> $DIR/abi-typo.rs:2:8
    |
 LL | extern "cdedl" fn cdedl() {}
-   |        ^^^^^^^
-   |        |
-   |        invalid ABI
-   |        help: did you mean: `"cdecl"`
+   |        ^^^^^^^ invalid ABI
    |
    = note: invoke `rustc --print=calling-conventions` for a full list of supported calling conventions
+help: there's a similarly named valid ABI `cdecl`
+   |
+LL - extern "cdedl" fn cdedl() {}
+LL + extern "cdecl" fn cdedl() {}
+   |
 
 error: aborting due to 1 previous error
 
diff --git a/tests/ui/suggestions/issue-104328.rs b/tests/ui/suggestions/issue-104328.rs
deleted file mode 100644
index 2b0fbdb8d35b..000000000000
--- a/tests/ui/suggestions/issue-104328.rs
+++ /dev/null
@@ -1,12 +0,0 @@
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Foo {
-    fn f() {}
-}
-
-impl Foo for dyn Sized {}
-
-fn main() {
-    Foo::f();
-    //~^ ERROR cannot call associated function on trait without specifying the corresponding `impl` type
-}
diff --git a/tests/ui/suggestions/issue-104328.stderr b/tests/ui/suggestions/issue-104328.stderr
deleted file mode 100644
index 3c5e6f16289e..000000000000
--- a/tests/ui/suggestions/issue-104328.stderr
+++ /dev/null
@@ -1,17 +0,0 @@
-error[E0790]: cannot call associated function on trait without specifying the corresponding `impl` type
-  --> $DIR/issue-104328.rs:10:5
-   |
-LL |     fn f() {}
-   |     --------- `Foo::f` defined here
-...
-LL |     Foo::f();
-   |     ^^^^^^^^ cannot call associated function of trait
-   |
-help: use the fully-qualified path to the only available implementation
-   |
-LL |     <(dyn Sized + 'static) as Foo>::f();
-   |     +++++++++++++++++++++++++    +
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0790`.
diff --git a/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr b/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
index 83a5441e3c0c..19a0e4b17d02 100644
--- a/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
+++ b/tests/ui/suggestions/let-binding-init-expr-as-ty.stderr
@@ -10,11 +10,16 @@ error: argument types not allowed with return type notation
   --> $DIR/let-binding-init-expr-as-ty.rs:2:26
    |
 LL |     let foo: i32::from_be(num);
-   |                          ^^^^^ help: remove the input types: `()`
+   |                          ^^^^^
    |
    = note: see issue #109417 <https://github.com/rust-lang/rust/issues/109417> for more information
    = help: add `#![feature(return_type_notation)]` to the crate attributes to enable
    = note: this compiler was built on YYYY-MM-DD; consider upgrading it if it is out of date
+help: remove the input types
+   |
+LL -     let foo: i32::from_be(num);
+LL +     let foo: i32::from_be(..);
+   |
 
 error: return type notation not allowed in this position yet
   --> $DIR/let-binding-init-expr-as-ty.rs:2:14
diff --git a/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.rs b/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.rs
new file mode 100644
index 000000000000..2ebbed3c740f
--- /dev/null
+++ b/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.rs
@@ -0,0 +1,11 @@
+struct T(String);
+
+impl PartialEq<String> for T {
+    fn eq(&self, other: &String) -> bool {
+        &self.0 == other
+    }
+}
+
+fn main() {
+    String::from("Girls Band Cry") == T(String::from("Girls Band Cry")); //~ can't compare `String` with `T` [E0277]
+}
diff --git a/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.stderr b/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.stderr
new file mode 100644
index 000000000000..ebe103ef19a1
--- /dev/null
+++ b/tests/ui/suggestions/partialeq_suggest_swap_on_e0277.stderr
@@ -0,0 +1,24 @@
+error[E0277]: can't compare `String` with `T`
+  --> $DIR/partialeq_suggest_swap_on_e0277.rs:10:36
+   |
+LL |     String::from("Girls Band Cry") == T(String::from("Girls Band Cry"));
+   |                                    ^^ no implementation for `String == T`
+   |
+   = help: the trait `PartialEq<T>` is not implemented for `String`
+   = help: the following other types implement trait `PartialEq<Rhs>`:
+             `String` implements `PartialEq<&str>`
+             `String` implements `PartialEq<ByteStr>`
+             `String` implements `PartialEq<ByteString>`
+             `String` implements `PartialEq<Cow<'_, str>>`
+             `String` implements `PartialEq<str>`
+             `String` implements `PartialEq`
+   = note: `T` implements `PartialEq<String>`
+help: consider swapping the equality
+   |
+LL -     String::from("Girls Band Cry") == T(String::from("Girls Band Cry"));
+LL +     T(String::from("Girls Band Cry")) == String::from("Girls Band Cry");
+   |
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0277`.
diff --git a/tests/ui/target-feature/feature-hierarchy.rs b/tests/ui/target-feature/feature-hierarchy.rs
index d62b86693c2c..315ec983a19a 100644
--- a/tests/ui/target-feature/feature-hierarchy.rs
+++ b/tests/ui/target-feature/feature-hierarchy.rs
@@ -21,10 +21,7 @@ impl Copy for bool {}
 #[stable(feature = "test", since = "1.0.0")]
 #[rustc_const_stable(feature = "test", since = "1.0.0")]
 #[rustc_intrinsic]
-#[rustc_intrinsic_must_be_overridden]
-const unsafe fn unreachable() -> ! {
-    loop {}
-}
+const unsafe fn unreachable() -> !;
 
 #[rustc_builtin_macro]
 macro_rules! cfg {
diff --git a/tests/ui/target-feature/no-llvm-leaks.rs b/tests/ui/target-feature/no-llvm-leaks.rs
index d4f70fe70694..50544b97a96d 100644
--- a/tests/ui/target-feature/no-llvm-leaks.rs
+++ b/tests/ui/target-feature/no-llvm-leaks.rs
@@ -1,3 +1,4 @@
+//@ add-core-stubs
 //@ revisions: aarch64 x86-64
 //@ [aarch64] compile-flags: -Ctarget-feature=+neon,+fp16,+fhm --target=aarch64-unknown-linux-gnu
 //@ [aarch64] needs-llvm-components: aarch64
@@ -9,12 +10,8 @@
 #![feature(intrinsics, rustc_attrs, no_core, lang_items, staged_api)]
 #![stable(feature = "test", since = "1.0.0")]
 
-// Supporting minimal rust core code
-#[lang = "sized"]
-trait Sized {}
-#[lang = "copy"]
-trait Copy {}
-impl Copy for bool {}
+extern crate minicore;
+use minicore::*;
 
 #[stable(feature = "test", since = "1.0.0")]
 #[rustc_const_stable(feature = "test", since = "1.0.0")]
diff --git a/tests/ui/target-feature/tied-features.rs b/tests/ui/target-feature/tied-features.rs
index c6cdf21a3e3f..9aa5291e68cb 100644
--- a/tests/ui/target-feature/tied-features.rs
+++ b/tests/ui/target-feature/tied-features.rs
@@ -1,10 +1,11 @@
+//@ add-core-stubs
 //@ compile-flags: --crate-type=rlib --target=aarch64-unknown-linux-gnu
 //@ needs-llvm-components: aarch64
 #![feature(no_core, lang_items)]
 #![no_core]
 
-#[lang="sized"]
-trait Sized {}
+extern crate minicore;
+use minicore::*;
 
 pub fn main() {
     #[target_feature(enable = "pacg")]
diff --git a/tests/ui/target-feature/tied-features.stderr b/tests/ui/target-feature/tied-features.stderr
index 8d677735e846..49df4f109ba7 100644
--- a/tests/ui/target-feature/tied-features.stderr
+++ b/tests/ui/target-feature/tied-features.stderr
@@ -1,5 +1,5 @@
 error: the target features paca, pacg must all be either enabled or disabled together
-  --> $DIR/tied-features.rs:10:5
+  --> $DIR/tied-features.rs:11:5
    |
 LL |     #[target_feature(enable = "pacg")]
    |     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -7,7 +7,7 @@ LL |     #[target_feature(enable = "pacg")]
    = help: add the missing features in a `target_feature` attribute
 
 error: the target features paca, pacg must all be either enabled or disabled together
-  --> $DIR/tied-features.rs:22:1
+  --> $DIR/tied-features.rs:23:1
    |
 LL | #[target_feature(enable = "paca")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
@@ -15,7 +15,7 @@ LL | #[target_feature(enable = "paca")]
    = help: add the missing features in a `target_feature` attribute
 
 error: the target features paca, pacg must all be either enabled or disabled together
-  --> $DIR/tied-features.rs:35:1
+  --> $DIR/tied-features.rs:36:1
    |
 LL | #[target_feature(enable = "paca")]
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
diff --git a/tests/ui/traits/const-traits/staged-api.rs b/tests/ui/traits/const-traits/staged-api.rs
index 9a030dafd6bc..8dd7226fc298 100644
--- a/tests/ui/traits/const-traits/staged-api.rs
+++ b/tests/ui/traits/const-traits/staged-api.rs
@@ -85,4 +85,36 @@ const fn implicitly_stable_const_context() {
     //~^ ERROR cannot use `#[feature(const_trait_impl)]`
 }
 
+// check that const stability of impls and traits must match
+#[const_trait]
+#[rustc_const_unstable(feature = "beef", issue = "none")]
+trait U {}
+
+#[const_trait]
+#[rustc_const_stable(since = "0.0.0", feature = "beef2")]
+trait S {}
+
+// implied stable
+impl const U for u8 {}
+//~^ const stability on the impl does not match the const stability on the trait
+
+#[rustc_const_stable(since = "0.0.0", feature = "beef2")]
+impl const U for u16 {}
+//~^ const stability on the impl does not match the const stability on the trait
+//~| trait implementations cannot be const stable yet
+
+#[rustc_const_unstable(feature = "beef", issue = "none")]
+impl const U for u32 {}
+
+// implied stable
+impl const S for u8 {}
+
+#[rustc_const_stable(since = "0.0.0", feature = "beef2")]
+impl const S for u16 {}
+//~^ trait implementations cannot be const stable yet
+
+#[rustc_const_unstable(feature = "beef", issue = "none")]
+impl const S for u32 {}
+//~^ const stability on the impl does not match the const stability on the trait
+
 fn main() {}
diff --git a/tests/ui/traits/const-traits/staged-api.stderr b/tests/ui/traits/const-traits/staged-api.stderr
index a7a7a1ee7215..cdf577287eec 100644
--- a/tests/ui/traits/const-traits/staged-api.stderr
+++ b/tests/ui/traits/const-traits/staged-api.stderr
@@ -1,3 +1,70 @@
+error: const stability on the impl does not match the const stability on the trait
+  --> $DIR/staged-api.rs:98:1
+   |
+LL | impl const U for u8 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: this impl is (implicitly) stable...
+  --> $DIR/staged-api.rs:98:1
+   |
+LL | impl const U for u8 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^
+note: ...but the trait is unstable
+  --> $DIR/staged-api.rs:91:7
+   |
+LL | trait U {}
+   |       ^
+
+error: trait implementations cannot be const stable yet
+  --> $DIR/staged-api.rs:102:1
+   |
+LL | impl const U for u16 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+
+error: const stability on the impl does not match the const stability on the trait
+  --> $DIR/staged-api.rs:102:1
+   |
+LL | impl const U for u16 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: this impl is (implicitly) stable...
+  --> $DIR/staged-api.rs:102:1
+   |
+LL | impl const U for u16 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+note: ...but the trait is unstable
+  --> $DIR/staged-api.rs:91:7
+   |
+LL | trait U {}
+   |       ^
+
+error: trait implementations cannot be const stable yet
+  --> $DIR/staged-api.rs:113:1
+   |
+LL | impl const S for u16 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: see issue #67792 <https://github.com/rust-lang/rust/issues/67792> for more information
+
+error: const stability on the impl does not match the const stability on the trait
+  --> $DIR/staged-api.rs:117:1
+   |
+LL | impl const S for u32 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: this impl is unstable...
+  --> $DIR/staged-api.rs:117:1
+   |
+LL | impl const S for u32 {}
+   | ^^^^^^^^^^^^^^^^^^^^^^^
+note: ...but the trait is stable
+  --> $DIR/staged-api.rs:95:7
+   |
+LL | trait S {}
+   |       ^
+
 error: const function that might be (indirectly) exposed to stable cannot use `#[feature(const_trait_impl)]`
   --> $DIR/staged-api.rs:38:5
    |
@@ -323,5 +390,5 @@ LL + #[rustc_allow_const_fn_unstable(const_trait_impl)]
 LL | const fn implicitly_stable_const_context() {
    |
 
-error: aborting due to 19 previous errors
+error: aborting due to 24 previous errors
 
diff --git a/tests/ui/traits/const-traits/unconstrained-var-specialization.rs b/tests/ui/traits/const-traits/unconstrained-var-specialization.rs
new file mode 100644
index 000000000000..43a331144501
--- /dev/null
+++ b/tests/ui/traits/const-traits/unconstrained-var-specialization.rs
@@ -0,0 +1,36 @@
+//@ check-pass
+//@ compile-flags: --crate-type=lib
+#![no_std]
+#![allow(internal_features)]
+#![feature(rustc_attrs, min_specialization, const_trait_impl)]
+
+// In the default impl below, `A` is constrained by the projection predicate, and if the host effect
+// predicate for `const Foo` doesn't resolve vars, then specialization will fail.
+
+#[const_trait]
+trait Foo {}
+
+pub trait Iterator {
+    type Item;
+}
+
+#[rustc_unsafe_specialization_marker]
+pub trait MoreSpecificThanIterator: Iterator {}
+
+pub trait Tr {
+    fn foo();
+}
+
+impl<A: const Foo, Iter> Tr for Iter
+    where
+        Iter: Iterator<Item = A>,
+{
+    default fn foo() {}
+}
+
+impl<A: const Foo, Iter> Tr for Iter
+    where
+        Iter: MoreSpecificThanIterator<Item = A>,
+{
+    fn foo() {}
+}
diff --git a/tests/ui/traits/const-traits/variance.rs b/tests/ui/traits/const-traits/variance.rs
new file mode 100644
index 000000000000..90b5c50161d5
--- /dev/null
+++ b/tests/ui/traits/const-traits/variance.rs
@@ -0,0 +1,13 @@
+#![feature(rustc_attrs, const_trait_impl)]
+#![allow(internal_features)]
+#![rustc_variance_of_opaques]
+
+#[const_trait]
+trait Foo {}
+
+impl const Foo for () {}
+
+fn foo<'a: 'a>() -> impl const Foo {}
+//~^ ERROR ['a: *]
+
+fn main() {}
diff --git a/tests/ui/traits/const-traits/variance.stderr b/tests/ui/traits/const-traits/variance.stderr
new file mode 100644
index 000000000000..f55069311848
--- /dev/null
+++ b/tests/ui/traits/const-traits/variance.stderr
@@ -0,0 +1,8 @@
+error: ['a: *]
+  --> $DIR/variance.rs:10:21
+   |
+LL | fn foo<'a: 'a>() -> impl const Foo {}
+   |                     ^^^^^^^^^^^^^^
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/traits/issue-78372.stderr b/tests/ui/traits/issue-78372.stderr
index d4dfba4f039f..fbc60ce5d83e 100644
--- a/tests/ui/traits/issue-78372.stderr
+++ b/tests/ui/traits/issue-78372.stderr
@@ -65,7 +65,7 @@ LL |     fn foo(self: Smaht<Self, T>);
    = note: type of `self` must be `Self` or a type that dereferences to it
    = help: consider changing to `self`, `&self`, `&mut self`, `self: Box<Self>`, `self: Rc<Self>`, `self: Arc<Self>`, or `self: Pin<P>` (where P is one of the previous types except `Self`)
 
-error[E0378]: the trait `DispatchFromDyn` may only be implemented for a coercion between structures
+error[E0377]: the trait `DispatchFromDyn` may only be implemented for a coercion between structures
   --> $DIR/issue-78372.rs:3:1
    |
 LL | impl<T> DispatchFromDyn<Smaht<U, MISC>> for T {}
@@ -73,5 +73,5 @@ LL | impl<T> DispatchFromDyn<Smaht<U, MISC>> for T {}
 
 error: aborting due to 7 previous errors
 
-Some errors have detailed explanations: E0307, E0378, E0412, E0658.
+Some errors have detailed explanations: E0307, E0377, E0412, E0658.
 For more information about an error, try `rustc --explain E0307`.
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.current.stderr b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.current.stderr
new file mode 100644
index 000000000000..dd9f7d89aa10
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.current.stderr
@@ -0,0 +1,23 @@
+error[E0275]: overflow evaluating the requirement `Vec<u8>: Trait<String>`
+  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
+   |
+LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: required for `Vec<u8>` to implement `Trait<String>`
+  --> $DIR/item-bound-via-impl-where-clause.rs:22:12
+   |
+LL | impl<L, R> Trait<R> for L
+   |            ^^^^^^^^     ^
+LL | where
+LL |     L: Trait<R>,
+   |        -------- unsatisfied trait bound introduced here
+note: required by a bound in `transmute`
+  --> $DIR/item-bound-via-impl-where-clause.rs:29:17
+   |
+LL | fn transmute<L: Trait<R>, R>(r: L) -> <L::Proof as Trait<R>>::Proof { r }
+   |                 ^^^^^^^^ required by this bound in `transmute`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr
new file mode 100644
index 000000000000..451c1442ed29
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.next.stderr
@@ -0,0 +1,49 @@
+error[E0275]: overflow evaluating the requirement `Vec<u8>: Trait<String>`
+  --> $DIR/item-bound-via-impl-where-clause.rs:31:33
+   |
+LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+   |                                 ^
+   |
+note: required by a bound in `transmute`
+  --> $DIR/item-bound-via-impl-where-clause.rs:29:17
+   |
+LL | fn transmute<L: Trait<R>, R>(r: L) -> <L::Proof as Trait<R>>::Proof { r }
+   |                 ^^^^^^^^ required by this bound in `transmute`
+
+error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
+  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
+   |
+LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == String`
+  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
+   |
+LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof: Sized`
+  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
+   |
+LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: the return type of a function must have a statically known size
+
+error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof well-formed`
+  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
+   |
+LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error[E0275]: overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
+  --> $DIR/item-bound-via-impl-where-clause.rs:31:21
+   |
+LL |     let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 6 previous errors
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs
new file mode 100644
index 000000000000..39381d17f7af
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/coinduction/item-bound-via-impl-where-clause.rs
@@ -0,0 +1,39 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
+// A variation of #135246 where the cyclic bounds are part of
+// the impl instead of the impl associated item.
+
+trait Trait<R>: Sized {
+    type Proof: Trait<R, Proof = Self>;
+}
+
+// We need to use indirection here as we otherwise normalize
+// `<L::Proof as Trait<R>>::Proof` before recursing into
+// `R: Trait<R, Proof = <L::Proof as Trait<R>>::Proof>`.
+trait Indir<L: Trait<R>, R>: Trait<R, Proof = <L::Proof as Trait<R>>::Proof> {}
+impl<L, R> Indir<L, R> for R
+where
+    L: Trait<R>,
+    R: Trait<R, Proof = <L::Proof as Trait<R>>::Proof>,
+{}
+
+impl<L, R> Trait<R> for L
+where
+    L: Trait<R>,
+    R: Indir<L, R>,
+ {
+    type Proof = R;
+}
+fn transmute<L: Trait<R>, R>(r: L) -> <L::Proof as Trait<R>>::Proof { r }
+fn main() {
+    let s: String = transmute::<_, String>(vec![65_u8, 66, 67]);
+    //~^ ERROR overflow evaluating the requirement `Vec<u8>: Trait<String>`
+    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
+    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == String`
+    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof: Sized`
+    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof well-formed`
+    //[next]~| ERROR overflow evaluating the requirement `<<Vec<u8> as Trait<String>>::Proof as Trait<String>>::Proof == _`
+    println!("{}", s); // ABC
+}
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed-trait.current.stderr b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed-trait.current.stderr
new file mode 100644
index 000000000000..89b8b53c3f4d
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed-trait.current.stderr
@@ -0,0 +1,22 @@
+error[E0275]: overflow evaluating the requirement `u32: SendIndir<Foo<u32>>`
+  --> $DIR/only-one-coinductive-step-needed-trait.rs:24:5
+   |
+LL |     is_send::<Foo<u32>>();
+   |     ^^^^^^^^^^^^^^^^^^^^^
+   |
+note: required for `Foo<u32>` to implement `Send`
+  --> $DIR/only-one-coinductive-step-needed-trait.rs:17:35
+   |
+LL | unsafe impl<T: SendIndir<Foo<T>>> Send for Foo<T> {}
+   |                -----------------  ^^^^     ^^^^^^
+   |                |
+   |                unsatisfied trait bound introduced here
+note: required by a bound in `is_send`
+  --> $DIR/only-one-coinductive-step-needed-trait.rs:22:15
+   |
+LL | fn is_send<T: Send>() {}
+   |               ^^^^ required by this bound in `is_send`
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed-trait.rs b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed-trait.rs
new file mode 100644
index 000000000000..294156869284
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed-trait.rs
@@ -0,0 +1,26 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@[next] check-pass
+
+// #136824 changed cycles to be coinductive if they have at least
+// one productive step, causing this test to pass with the new solver.
+//
+// The cycle in the test is the following:
+// - `Foo<T>: Send`, impl requires
+// - `T: SendIndir<Foo<T>>`, impl requires
+// - `Foo<T>: Send` cycle
+//
+// The old solver treats this cycle as inductive due to the `T: SendIndir` step.
+
+struct Foo<T>(T);
+unsafe impl<T: SendIndir<Foo<T>>> Send for Foo<T> {}
+
+trait SendIndir<T> {}
+impl<T, U: Send> SendIndir<U> for T {}
+
+fn is_send<T: Send>() {}
+fn main() {
+    is_send::<Foo<u32>>();
+    //[current]~^ ERROR overflow evaluating the requirement `u32: SendIndir<Foo<u32>>`
+}
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed.current.stderr b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed.current.stderr
new file mode 100644
index 000000000000..ec2198780586
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed.current.stderr
@@ -0,0 +1,17 @@
+error[E0275]: overflow evaluating the requirement `Foo<T>: SendIndir`
+  --> $DIR/only-one-coinductive-step-needed.rs:17:15
+   |
+LL | struct Foo<T>(<Foo<T> as Trait>::Assoc);
+   |               ^^^^^^^^^^^^^^^^^^^^^^^^
+   |
+note: required for `Foo<T>` to implement `Trait`
+  --> $DIR/only-one-coinductive-step-needed.rs:26:20
+   |
+LL | impl<T: SendIndir> Trait for T {
+   |         ---------  ^^^^^     ^
+   |         |
+   |         unsatisfied trait bound introduced here
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed.rs b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed.rs
new file mode 100644
index 000000000000..e41f7d7f3ceb
--- /dev/null
+++ b/tests/ui/traits/next-solver/cycles/coinduction/only-one-coinductive-step-needed.rs
@@ -0,0 +1,34 @@
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+//@[next] check-pass
+
+// #136824 changed cycles to be coinductive if they have at least
+// one productive step, causing this test to pass with the new solver.
+//
+// The cycle in the test is the following:
+// - `Foo<T>: Send`, builtin auto-trait impl requires
+// - `<Foo<T> as Trait>::Assoc: Send`, requires normalizing self type via impl, requires
+// - `Foo<T>: SendIndir`, via impl requires
+// - `Foo<T>: Send` cycle
+//
+// The old solver treats this cycle as inductive due to the `Foo<T>: SendIndir` step.
+
+struct Foo<T>(<Foo<T> as Trait>::Assoc);
+//[current]~^ ERROR overflow evaluating the requirement `Foo<T>: SendIndir`
+
+trait SendIndir {}
+impl<T: Send> SendIndir for T {}
+
+trait Trait {
+    type Assoc;
+}
+impl<T: SendIndir> Trait for T {
+    type Assoc = ();
+}
+
+fn is_send<T: Send>() {}
+
+fn main() {
+    is_send::<Foo<u32>>();
+}
diff --git a/tests/ui/traits/next-solver/cycles/double-cycle-inductive-coinductive.rs b/tests/ui/traits/next-solver/cycles/double-cycle-inductive-coinductive.rs
deleted file mode 100644
index 0d3872142087..000000000000
--- a/tests/ui/traits/next-solver/cycles/double-cycle-inductive-coinductive.rs
+++ /dev/null
@@ -1,37 +0,0 @@
-//@ compile-flags: -Znext-solver
-#![feature(rustc_attrs)]
-
-// Test that having both an inductive and a coinductive cycle
-// is handled correctly.
-
-#[rustc_coinductive]
-trait Trait {}
-impl<T: Inductive + Coinductive> Trait for T {}
-
-trait Inductive {}
-impl<T: Trait> Inductive for T {}
-#[rustc_coinductive]
-trait Coinductive {}
-impl<T: Trait> Coinductive for T {}
-
-fn impls_trait<T: Trait>() {}
-
-#[rustc_coinductive]
-trait TraitRev {}
-impl<T: CoinductiveRev + InductiveRev> TraitRev for T {}
-
-trait InductiveRev {}
-impl<T: TraitRev> InductiveRev for T {}
-#[rustc_coinductive]
-trait CoinductiveRev {}
-impl<T: TraitRev> CoinductiveRev for T {}
-
-fn impls_trait_rev<T: TraitRev>() {}
-
-fn main() {
-    impls_trait::<()>();
-    //~^ ERROR overflow evaluating the requirement
-
-    impls_trait_rev::<()>();
-    //~^ ERROR overflow evaluating the requirement
-}
diff --git a/tests/ui/traits/next-solver/cycles/double-cycle-inductive-coinductive.stderr b/tests/ui/traits/next-solver/cycles/double-cycle-inductive-coinductive.stderr
deleted file mode 100644
index 7cedb4d36c98..000000000000
--- a/tests/ui/traits/next-solver/cycles/double-cycle-inductive-coinductive.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0275]: overflow evaluating the requirement `(): Trait`
-  --> $DIR/double-cycle-inductive-coinductive.rs:32:19
-   |
-LL |     impls_trait::<()>();
-   |                   ^^
-   |
-note: required by a bound in `impls_trait`
-  --> $DIR/double-cycle-inductive-coinductive.rs:17:19
-   |
-LL | fn impls_trait<T: Trait>() {}
-   |                   ^^^^^ required by this bound in `impls_trait`
-
-error[E0275]: overflow evaluating the requirement `(): TraitRev`
-  --> $DIR/double-cycle-inductive-coinductive.rs:35:23
-   |
-LL |     impls_trait_rev::<()>();
-   |                       ^^
-   |
-note: required by a bound in `impls_trait_rev`
-  --> $DIR/double-cycle-inductive-coinductive.rs:29:23
-   |
-LL | fn impls_trait_rev<T: TraitRev>() {}
-   |                       ^^^^^^^^ required by this bound in `impls_trait_rev`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/inductive-not-on-stack.rs b/tests/ui/traits/next-solver/cycles/inductive-not-on-stack.rs
deleted file mode 100644
index 78683372580b..000000000000
--- a/tests/ui/traits/next-solver/cycles/inductive-not-on-stack.rs
+++ /dev/null
@@ -1,46 +0,0 @@
-//@ compile-flags: -Znext-solver
-#![feature(rustc_attrs, trivial_bounds)]
-
-// We have to be careful here:
-//
-// We either have the provisional result of `A -> B -> A` on the
-// stack, which is a fully coinductive cycle. Accessing the
-// provisional result for `B` as part of the `A -> C -> B -> A` cycle
-// has to make sure we don't just use the result of `A -> B -> A` as the
-// new cycle is inductive.
-//
-// Alternatively, if we have `A -> C -> A` first, then `A -> B -> A` has
-// a purely inductive stack, so something could also go wrong here.
-
-#[rustc_coinductive]
-trait A {}
-#[rustc_coinductive]
-trait B {}
-trait C {}
-
-impl<T: B + C> A for T {}
-impl<T: A> B for T {}
-impl<T: B> C for T {}
-
-fn impls_a<T: A>() {}
-
-// The same test with reordered where clauses to make sure we're actually testing anything.
-#[rustc_coinductive]
-trait AR {}
-#[rustc_coinductive]
-trait BR {}
-trait CR {}
-
-impl<T: CR + BR> AR for T {}
-impl<T: AR> BR for T {}
-impl<T: BR> CR for T {}
-
-fn impls_ar<T: AR>() {}
-
-fn main() {
-    impls_a::<()>();
-    //~^ ERROR overflow evaluating the requirement `(): A`
-
-    impls_ar::<()>();
-    //~^ ERROR overflow evaluating the requirement `(): AR`
-}
diff --git a/tests/ui/traits/next-solver/cycles/inductive-not-on-stack.stderr b/tests/ui/traits/next-solver/cycles/inductive-not-on-stack.stderr
deleted file mode 100644
index e9cc6bc6c81a..000000000000
--- a/tests/ui/traits/next-solver/cycles/inductive-not-on-stack.stderr
+++ /dev/null
@@ -1,27 +0,0 @@
-error[E0275]: overflow evaluating the requirement `(): A`
-  --> $DIR/inductive-not-on-stack.rs:41:15
-   |
-LL |     impls_a::<()>();
-   |               ^^
-   |
-note: required by a bound in `impls_a`
-  --> $DIR/inductive-not-on-stack.rs:25:15
-   |
-LL | fn impls_a<T: A>() {}
-   |               ^ required by this bound in `impls_a`
-
-error[E0275]: overflow evaluating the requirement `(): AR`
-  --> $DIR/inductive-not-on-stack.rs:44:16
-   |
-LL |     impls_ar::<()>();
-   |                ^^
-   |
-note: required by a bound in `impls_ar`
-  --> $DIR/inductive-not-on-stack.rs:38:16
-   |
-LL | fn impls_ar<T: AR>() {}
-   |                ^^ required by this bound in `impls_ar`
-
-error: aborting due to 2 previous errors
-
-For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/mixed-cycles-1.rs b/tests/ui/traits/next-solver/cycles/mixed-cycles-1.rs
deleted file mode 100644
index 6d75d2418643..000000000000
--- a/tests/ui/traits/next-solver/cycles/mixed-cycles-1.rs
+++ /dev/null
@@ -1,39 +0,0 @@
-//@ compile-flags: -Znext-solver
-#![feature(rustc_attrs)]
-
-// A test intended to check how we handle provisional results
-// for a goal computed with an inductive and a coinductive stack.
-//
-// Unfortunately this doesn't really detect whether we've done
-// something wrong but instead only showcases that we thought of
-// this.
-//
-// FIXME(-Znext-solver=coinductive): With the new coinduction approach
-// the same goal stack can be both inductive and coinductive, depending
-// on why we're proving a specific nested goal. Rewrite this test
-// at that point instead of relying on `BInd`.
-
-
-#[rustc_coinductive]
-trait A {}
-
-#[rustc_coinductive]
-trait B {}
-trait BInd {}
-impl<T: ?Sized + B> BInd for T {}
-
-#[rustc_coinductive]
-trait C {}
-trait CInd {}
-impl<T: ?Sized + C> CInd for T {}
-
-impl<T: ?Sized + BInd + C> A for T {}
-impl<T: ?Sized + CInd + C> B for T {}
-impl<T: ?Sized + B + A> C for T {}
-
-fn impls_a<T: A>() {}
-
-fn main() {
-    impls_a::<()>();
-    //~^ ERROR overflow evaluating the requirement `(): A`
-}
diff --git a/tests/ui/traits/next-solver/cycles/mixed-cycles-1.stderr b/tests/ui/traits/next-solver/cycles/mixed-cycles-1.stderr
deleted file mode 100644
index 17544eb1da52..000000000000
--- a/tests/ui/traits/next-solver/cycles/mixed-cycles-1.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0275]: overflow evaluating the requirement `(): A`
-  --> $DIR/mixed-cycles-1.rs:37:15
-   |
-LL |     impls_a::<()>();
-   |               ^^
-   |
-note: required by a bound in `impls_a`
-  --> $DIR/mixed-cycles-1.rs:34:15
-   |
-LL | fn impls_a<T: A>() {}
-   |               ^ required by this bound in `impls_a`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/next-solver/cycles/mixed-cycles-2.rs b/tests/ui/traits/next-solver/cycles/mixed-cycles-2.rs
deleted file mode 100644
index c939a6e5ef2f..000000000000
--- a/tests/ui/traits/next-solver/cycles/mixed-cycles-2.rs
+++ /dev/null
@@ -1,32 +0,0 @@
-//@ compile-flags: -Znext-solver
-#![feature(rustc_attrs)]
-
-// A test showcasing that the solver may need to
-// compute a goal which is already in the provisional
-// cache.
-//
-// However, given that `(): BInd` and `(): B` are currently distinct
-// goals, this is actually not possible right now.
-//
-// FIXME(-Znext-solver=coinductive): With the new coinduction approach
-// the same goal stack can be both inductive and coinductive, depending
-// on why we're proving a specific nested goal. Rewrite this test
-// at that point.
-
-#[rustc_coinductive]
-trait A {}
-
-#[rustc_coinductive]
-trait B {}
-trait BInd {}
-impl<T: ?Sized + B> BInd for T {}
-
-impl<T: ?Sized + BInd + B> A for T {}
-impl<T: ?Sized + BInd> B for T {}
-
-fn impls_a<T: A>() {}
-
-fn main() {
-    impls_a::<()>();
-    //~^ ERROR overflow evaluating the requirement `(): A`
-}
diff --git a/tests/ui/traits/next-solver/cycles/mixed-cycles-2.stderr b/tests/ui/traits/next-solver/cycles/mixed-cycles-2.stderr
deleted file mode 100644
index a9be1016c741..000000000000
--- a/tests/ui/traits/next-solver/cycles/mixed-cycles-2.stderr
+++ /dev/null
@@ -1,15 +0,0 @@
-error[E0275]: overflow evaluating the requirement `(): A`
-  --> $DIR/mixed-cycles-2.rs:30:15
-   |
-LL |     impls_a::<()>();
-   |               ^^
-   |
-note: required by a bound in `impls_a`
-  --> $DIR/mixed-cycles-2.rs:27:15
-   |
-LL | fn impls_a<T: A>() {}
-   |               ^ required by this bound in `impls_a`
-
-error: aborting due to 1 previous error
-
-For more information about this error, try `rustc --explain E0275`.
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.stderr b/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.current.stderr
similarity index 100%
rename from tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.stderr
rename to tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.current.stderr
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.next.stderr b/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.next.stderr
new file mode 100644
index 000000000000..50dcea0bfac6
--- /dev/null
+++ b/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.next.stderr
@@ -0,0 +1,10 @@
+error[E0391]: cycle detected when computing layout of `<[Hello] as Normalize>::Assoc`
+   |
+   = note: ...which requires computing layout of `Hello`...
+   = note: ...which again requires computing layout of `<[Hello] as Normalize>::Assoc`, completing the cycle
+   = note: cycle used when computing layout of `Hello`
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.rs b/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.rs
index 197207dfb4be..5b7bf5f3404c 100644
--- a/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.rs
+++ b/tests/ui/traits/solver-cycles/129541-recursive-enum-and-array-impl.rs
@@ -1,6 +1,10 @@
 // Regression test for #129541
 //~^ ERROR cycle detected when computing layout of `<[Hello] as Normalize>::Assoc` [E0391]
 
+//@ revisions: current next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[next] compile-flags: -Znext-solver
+
 trait Bound {}
 trait Normalize {
     type Assoc;
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-struct.multiple_curr.stderr b/tests/ui/traits/solver-cycles/129541-recursive-struct.multiple_curr.stderr
new file mode 100644
index 000000000000..93b064cdce2a
--- /dev/null
+++ b/tests/ui/traits/solver-cycles/129541-recursive-struct.multiple_curr.stderr
@@ -0,0 +1,6 @@
+error: reached the recursion limit finding the struct tail for `<[Hello] as Normalize>::Assoc`
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-struct.multiple_next.stderr b/tests/ui/traits/solver-cycles/129541-recursive-struct.multiple_next.stderr
new file mode 100644
index 000000000000..93b064cdce2a
--- /dev/null
+++ b/tests/ui/traits/solver-cycles/129541-recursive-struct.multiple_next.stderr
@@ -0,0 +1,6 @@
+error: reached the recursion limit finding the struct tail for `<[Hello] as Normalize>::Assoc`
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-struct.rs b/tests/ui/traits/solver-cycles/129541-recursive-struct.rs
index 4fbcbefec913..1f5d0a772a2b 100644
--- a/tests/ui/traits/solver-cycles/129541-recursive-struct.rs
+++ b/tests/ui/traits/solver-cycles/129541-recursive-struct.rs
@@ -1,14 +1,17 @@
 // Regression test for #129541
 
-//@ revisions: unique multiple
-//@ check-pass
+//@ revisions: unique_curr unique_next multiple_curr multiple_next
+//@ ignore-compare-mode-next-solver (explicit revisions)
+//@[unique_next] compile-flags: -Znext-solver
+//@[multiple_next] compile-flags: -Znext-solver
+//@ error-pattern: reached the recursion limit finding the struct tail for `<[Hello] as Normalize>::Assoc`
 
 trait Bound {}
 trait Normalize {
     type Assoc;
 }
 
-#[cfg(multiple)]
+#[cfg(any(multiple_curr, multiple_next))]
 impl<T: Bound> Normalize for T {
     type Assoc = T;
 }
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-struct.unique_curr.stderr b/tests/ui/traits/solver-cycles/129541-recursive-struct.unique_curr.stderr
new file mode 100644
index 000000000000..93b064cdce2a
--- /dev/null
+++ b/tests/ui/traits/solver-cycles/129541-recursive-struct.unique_curr.stderr
@@ -0,0 +1,6 @@
+error: reached the recursion limit finding the struct tail for `<[Hello] as Normalize>::Assoc`
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/traits/solver-cycles/129541-recursive-struct.unique_next.stderr b/tests/ui/traits/solver-cycles/129541-recursive-struct.unique_next.stderr
new file mode 100644
index 000000000000..93b064cdce2a
--- /dev/null
+++ b/tests/ui/traits/solver-cycles/129541-recursive-struct.unique_next.stderr
@@ -0,0 +1,6 @@
+error: reached the recursion limit finding the struct tail for `<[Hello] as Normalize>::Assoc`
+   |
+   = help: consider increasing the recursion limit by adding a `#![recursion_limit = "256"]`
+
+error: aborting due to 1 previous error
+
diff --git a/tests/ui/traits/trivial_impl_sized.rs b/tests/ui/traits/trivial_impl_sized.rs
index 501a3405090e..59cc079c2682 100644
--- a/tests/ui/traits/trivial_impl_sized.rs
+++ b/tests/ui/traits/trivial_impl_sized.rs
@@ -1,5 +1,5 @@
-//! This test checks that we currently need to implement
-//! members, even if their where bounds don't hold for the impl type.
+//! This test checks that we do not need to implement
+//! members, whose `where Self: Sized` bounds don't hold for the impl type.
 
 trait Foo {
     fn foo()
@@ -15,12 +15,28 @@ impl Foo for () {
 impl Foo for i32 {}
 //~^ ERROR: not all trait items implemented, missing: `foo`
 
-// Should be allowed
 impl Foo for dyn std::fmt::Debug {}
-//~^ ERROR: not all trait items implemented, missing: `foo`
 
+#[deny(dead_code)]
 impl Foo for dyn std::fmt::Display {
     fn foo() {}
+    //~^ ERROR this item cannot be used as its where bounds are not satisfied
 }
 
+struct Struct {
+    i: i32,
+    tail: [u8],
+}
+
+impl Foo for Struct {}
+
+// Ensure we only allow known-unsized types to be skipped
+trait Trait {
+    fn foo(self)
+    where
+        Self: Sized;
+}
+impl<T: ?Sized> Trait for T {}
+//~^ ERROR: not all trait items implemented, missing: `foo`
+
 fn main() {}
diff --git a/tests/ui/traits/trivial_impl_sized.stderr b/tests/ui/traits/trivial_impl_sized.stderr
index ebf6dfc9dd2d..95cab3371826 100644
--- a/tests/ui/traits/trivial_impl_sized.stderr
+++ b/tests/ui/traits/trivial_impl_sized.stderr
@@ -9,17 +9,29 @@ LL | |         Self: Sized;
 LL |   impl Foo for i32 {}
    |   ^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error[E0046]: not all trait items implemented, missing: `foo`
-  --> $DIR/trivial_impl_sized.rs:19:1
+error: this item cannot be used as its where bounds are not satisfied for the `Self` type
+  --> $DIR/trivial_impl_sized.rs:22:5
    |
-LL | /     fn foo()
+LL |     fn foo() {}
+   |     ^^^^^^^^
+   |
+note: the lint level is defined here
+  --> $DIR/trivial_impl_sized.rs:20:8
+   |
+LL | #[deny(dead_code)]
+   |        ^^^^^^^^^
+
+error[E0046]: not all trait items implemented, missing: `foo`
+  --> $DIR/trivial_impl_sized.rs:39:1
+   |
+LL | /     fn foo(self)
 LL | |     where
 LL | |         Self: Sized;
    | |____________________- `foo` from trait
-...
-LL |   impl Foo for dyn std::fmt::Debug {}
-   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `foo` in implementation
+LL |   }
+LL |   impl<T: ?Sized> Trait for T {}
+   |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^ missing `foo` in implementation
 
-error: aborting due to 2 previous errors
+error: aborting due to 3 previous errors
 
 For more information about this error, try `rustc --explain E0046`.
diff --git a/tests/ui/transmutability/uninhabited.stderr b/tests/ui/transmutability/uninhabited.stderr
index b8b7b67f7816..39f8bf19c363 100644
--- a/tests/ui/transmutability/uninhabited.stderr
+++ b/tests/ui/transmutability/uninhabited.stderr
@@ -2,7 +2,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/uninhabited.rs:41:9
    |
 LL |         assert!(false);
-   |         ^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/uninhabited.rs:41:9
+   |         ^^^^^^^^^^^^^^ evaluation panicked: assertion failed: false
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -10,7 +10,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/uninhabited.rs:63:9
    |
 LL |         assert!(false);
-   |         ^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/uninhabited.rs:63:9
+   |         ^^^^^^^^^^^^^^ evaluation panicked: assertion failed: false
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
@@ -18,7 +18,7 @@ error[E0080]: evaluation of constant value failed
   --> $DIR/uninhabited.rs:87:9
    |
 LL |         assert!(false);
-   |         ^^^^^^^^^^^^^^ the evaluated program panicked at 'assertion failed: false', $DIR/uninhabited.rs:87:9
+   |         ^^^^^^^^^^^^^^ evaluation panicked: assertion failed: false
    |
    = note: this error originates in the macro `assert` (in Nightly builds, run with -Z macro-backtrace for more info)
 
diff --git a/tests/ui/type/type-check/missing_trait_impl.stderr b/tests/ui/type/type-check/missing_trait_impl.stderr
index 033b42e6736d..28ffae2d5e55 100644
--- a/tests/ui/type/type-check/missing_trait_impl.stderr
+++ b/tests/ui/type/type-check/missing_trait_impl.stderr
@@ -50,7 +50,7 @@ error[E0614]: type `T` cannot be dereferenced
   --> $DIR/missing_trait_impl.rs:15:13
    |
 LL |     let y = *x;
-   |             ^^
+   |             ^^ can't be dereferenced
 
 error: aborting due to 5 previous errors
 
diff --git a/tests/ui/typeck/auxiliary/derive-demo-issue-136343.rs b/tests/ui/typeck/auxiliary/derive-demo-issue-136343.rs
new file mode 100644
index 000000000000..65be439b49a9
--- /dev/null
+++ b/tests/ui/typeck/auxiliary/derive-demo-issue-136343.rs
@@ -0,0 +1,7 @@
+extern crate proc_macro;
+use proc_macro::TokenStream;
+
+#[proc_macro_derive(Sample)]
+pub fn sample(_: TokenStream) -> TokenStream {
+    "fn bad<T: Into<U>, U>(a: T) -> U { a }".parse().unwrap()
+}
diff --git a/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.rs b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.rs
new file mode 100644
index 000000000000..c08030fc5c15
--- /dev/null
+++ b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.rs
@@ -0,0 +1,9 @@
+//@ proc-macro: derive-demo-issue-136343.rs
+
+#[macro_use]
+extern crate derive_demo_issue_136343;
+
+#[derive(Sample)] //~ ERROR mismatched types
+struct Test;
+
+fn main() {}
diff --git a/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.stderr b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.stderr
new file mode 100644
index 000000000000..0b9c1d9123aa
--- /dev/null
+++ b/tests/ui/typeck/invalid-sugg-for-derive-macro-issue-136343.stderr
@@ -0,0 +1,19 @@
+error[E0308]: mismatched types
+  --> $DIR/invalid-sugg-for-derive-macro-issue-136343.rs:6:10
+   |
+LL | #[derive(Sample)]
+   |          ^^^^^^
+   |          |
+   |          expected type parameter `U`, found type parameter `T`
+   |          expected `U` because of return type
+   |
+   = note: expected type parameter `U`
+              found type parameter `T`
+   = note: a type parameter was expected, but a different one was found; you might be missing a type parameter or trait bound
+   = note: for more information, visit https://doc.rust-lang.org/book/ch10-02-traits.html#traits-as-parameters
+   = note: the caller chooses a type for `U` which can be different from `T`
+   = note: this error originates in the derive macro `Sample` (in Nightly builds, run with -Z macro-backtrace for more info)
+
+error: aborting due to 1 previous error
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/unsafe-binders/binder-sized-crit.rs b/tests/ui/unsafe-binders/binder-sized-crit.rs
new file mode 100644
index 000000000000..37677c0ef69b
--- /dev/null
+++ b/tests/ui/unsafe-binders/binder-sized-crit.rs
@@ -0,0 +1,18 @@
+//@ check-pass
+
+#![feature(unsafe_binders)]
+//~^ WARN the feature `unsafe_binders` is incomplete
+
+use std::unsafe_binder::wrap_binder;
+
+struct A {
+    b: unsafe<> (),
+}
+
+fn main() {
+    unsafe {
+        let _ = A {
+            b: wrap_binder!(()),
+        };
+    }
+}
diff --git a/tests/ui/unsafe-binders/binder-sized-crit.stderr b/tests/ui/unsafe-binders/binder-sized-crit.stderr
new file mode 100644
index 000000000000..3ba6cf2ef8c1
--- /dev/null
+++ b/tests/ui/unsafe-binders/binder-sized-crit.stderr
@@ -0,0 +1,11 @@
+warning: the feature `unsafe_binders` is incomplete and may not be safe to use and/or cause compiler crashes
+  --> $DIR/binder-sized-crit.rs:3:12
+   |
+LL | #![feature(unsafe_binders)]
+   |            ^^^^^^^^^^^^^^
+   |
+   = note: see issue #130516 <https://github.com/rust-lang/rust/issues/130516> for more information
+   = note: `#[warn(incomplete_features)]` on by default
+
+warning: 1 warning emitted
+
diff --git a/tests/ui/virtual-call-attrs-issue-137646.rs b/tests/ui/virtual-call-attrs-issue-137646.rs
new file mode 100644
index 000000000000..e80bd5768a42
--- /dev/null
+++ b/tests/ui/virtual-call-attrs-issue-137646.rs
@@ -0,0 +1,45 @@
+//! Regression test for https://github.com/rust-lang/rust/issues/137646.
+//! The parameter value at all calls to `check` should be `(1, 1, 1)`.
+
+//@ run-pass
+
+use std::hint::black_box;
+
+type T = (i32, i32, i32);
+
+pub trait Trait {
+    fn m(&self, _: T, _: T) {}
+}
+
+impl Trait for () {
+    fn m(&self, mut _v1: T, v2: T) {
+        _v1 = (0, 0, 0);
+        check(v2);
+    }
+}
+
+pub fn run_1(trait_: &dyn Trait) {
+    let v1 = (1, 1, 1);
+    let v2 = (1, 1, 1);
+    trait_.m(v1, v2);
+}
+
+pub fn run_2(trait_: &dyn Trait) {
+    let v1 = (1, 1, 1);
+    let v2 = (1, 1, 1);
+    trait_.m(v1, v2);
+    check(v1);
+    check(v2);
+}
+
+#[inline(never)]
+fn check(v: T) {
+    assert_eq!(v, (1, 1, 1));
+}
+
+fn main() {
+    black_box(run_1 as fn(&dyn Trait));
+    black_box(run_2 as fn(&dyn Trait));
+    run_1(&());
+    run_2(&());
+}
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
index 997bee1e6008..89e4b77b6cd4 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.rs
@@ -3,6 +3,7 @@ trait Foo<const N: Bar<2>> {
     //~^ WARN trait objects without an explicit `dyn` are deprecated
     //~| WARN this is accepted in the current edition (Rust 2015) but is a hard error in Rust 2021!
     //~| ERROR cycle detected when computing type of `Foo::N`
+    //~| ERROR cycle detected when computing type of `Foo::N`
     fn func() {}
 }
 
diff --git a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
index 733b729faf07..a381f2acdce4 100644
--- a/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
+++ b/tests/ui/wf/ice-hir-wf-check-anon-const-issue-122989.stderr
@@ -13,7 +13,7 @@ LL | trait Foo<const N: dyn Bar<2>> {
    |                    +++
 
 warning: trait objects without an explicit `dyn` are deprecated
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:9:20
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:10:20
    |
 LL | trait Bar<const M: Foo<2>> {}
    |                    ^^^^^^
@@ -32,7 +32,7 @@ LL | trait Foo<const N: Bar<2>> {
    |           ^^^^^^^^^^^^^^^
    |
 note: ...which requires computing type of `Bar::M`...
-  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:9:11
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:10:11
    |
 LL | trait Bar<const M: Foo<2>> {}
    |           ^^^^^^^^^^^^^^^
@@ -44,6 +44,26 @@ LL | trait Foo<const N: Bar<2>> {
    | ^^^^^^^^^^^^^^^^^^^^^^^^^^
    = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
 
-error: aborting due to 1 previous error; 2 warnings emitted
+error[E0391]: cycle detected when computing type of `Foo::N`
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:2:11
+   |
+LL | trait Foo<const N: Bar<2>> {
+   |           ^^^^^^^^^^^^^^^
+   |
+note: ...which requires computing type of `Bar::M`...
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:10:11
+   |
+LL | trait Bar<const M: Foo<2>> {}
+   |           ^^^^^^^^^^^^^^^
+   = note: ...which again requires computing type of `Foo::N`, completing the cycle
+note: cycle used when computing explicit predicates of trait `Foo`
+  --> $DIR/ice-hir-wf-check-anon-const-issue-122989.rs:2:1
+   |
+LL | trait Foo<const N: Bar<2>> {
+   | ^^^^^^^^^^^^^^^^^^^^^^^^^^
+   = note: see https://rustc-dev-guide.rust-lang.org/overview.html#queries and https://rustc-dev-guide.rust-lang.org/query.html for more information
+   = note: duplicate diagnostic emitted due to `-Z deduplicate-diagnostics=no`
+
+error: aborting due to 2 previous errors; 2 warnings emitted
 
 For more information about this error, try `rustc --explain E0391`.
diff --git a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.rs b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.rs
deleted file mode 100644
index 26292a1d218c..000000000000
--- a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Check that we do not allow casts or coercions
-// to dyn-incompatible trait objects inside a Box
-
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Trait: Sized {}
-
-struct S;
-
-impl Trait for S {}
-
-fn takes_box(t: Box<dyn Trait>) {}
-
-fn main() {
-    Box::new(S) as Box<dyn Trait>; //~ ERROR E0038
-    let t_box: Box<dyn Trait> = Box::new(S); //~ ERROR E0038
-    takes_box(Box::new(S)); //~ ERROR E0038
-}
diff --git a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.stderr b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.stderr
deleted file mode 100644
index f3e4f2a63e98..000000000000
--- a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj-box.stderr
+++ /dev/null
@@ -1,54 +0,0 @@
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:16:33
-   |
-LL |     let t_box: Box<dyn Trait> = Box::new(S);
-   |                                 ^^^^^^^^^^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: only type `S` implements `Trait`; consider using it directly instead.
-   = note: required for the cast from `Box<S>` to `Box<dyn Trait>`
-
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:17:15
-   |
-LL |     takes_box(Box::new(S));
-   |               ^^^^^^^^^^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: only type `S` implements `Trait`; consider using it directly instead.
-   = note: required for the cast from `Box<S>` to `Box<(dyn Trait + 'static)>`
-
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:15:5
-   |
-LL |     Box::new(S) as Box<dyn Trait>;
-   |     ^^^^^^^^^^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-convert-dyn-incompat-trait-obj-box.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: only type `S` implements `Trait`; consider using it directly instead.
-   = note: required for the cast from `Box<S>` to `Box<dyn Trait>`
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.rs b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.rs
deleted file mode 100644
index ec4bb2897f9d..000000000000
--- a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.rs
+++ /dev/null
@@ -1,18 +0,0 @@
-// Check that we do not allow casts or coercions
-// to dyn-incompatible trait objects by ref
-
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Trait: Sized {}
-
-struct S;
-
-impl Trait for S {}
-
-fn takes_trait(t: &dyn Trait) {}
-
-fn main() {
-    &S as &dyn Trait; //~ ERROR E0038
-    let t: &dyn Trait = &S; //~ ERROR E0038
-    takes_trait(&S); //~ ERROR E0038
-}
diff --git a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.stderr b/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.stderr
deleted file mode 100644
index 716d0e78ff11..000000000000
--- a/tests/ui/wf/wf-convert-dyn-incompat-trait-obj.stderr
+++ /dev/null
@@ -1,54 +0,0 @@
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:16:25
-   |
-LL |     let t: &dyn Trait = &S;
-   |                         ^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: only type `S` implements `Trait`; consider using it directly instead.
-   = note: required for the cast from `&S` to `&dyn Trait`
-
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:17:17
-   |
-LL |     takes_trait(&S);
-   |                 ^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: only type `S` implements `Trait`; consider using it directly instead.
-   = note: required for the cast from `&S` to `&dyn Trait`
-
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:15:5
-   |
-LL |     &S as &dyn Trait;
-   |     ^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-convert-dyn-incompat-trait-obj.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: only type `S` implements `Trait`; consider using it directly instead.
-   = note: required for the cast from `&S` to `&dyn Trait`
-
-error: aborting due to 3 previous errors
-
-For more information about this error, try `rustc --explain E0038`.
diff --git a/tests/ui/wf/wf-dyn-incompat-trait-obj-match.rs b/tests/ui/wf/wf-dyn-incompat-trait-obj-match.rs
deleted file mode 100644
index 6eba6b7abecd..000000000000
--- a/tests/ui/wf/wf-dyn-incompat-trait-obj-match.rs
+++ /dev/null
@@ -1,29 +0,0 @@
-// Check that we do not allow coercions to object
-// unsafe trait objects in match arms
-
-#![feature(dyn_compatible_for_dispatch)]
-
-trait Trait: Sized {}
-
-struct S;
-
-impl Trait for S {}
-
-struct R;
-
-impl Trait for R {}
-
-fn opt() -> Option<()> {
-    Some(())
-}
-
-fn main() {
-    match opt() {
-        Some(()) => &S,
-        None => &R,  //~ ERROR E0308
-    }
-    let t: &dyn Trait = match opt() {
-        Some(()) => &S, //~ ERROR E0038
-        None => &R, //~ ERROR E0038
-    };
-}
diff --git a/tests/ui/wf/wf-dyn-incompat-trait-obj-match.stderr b/tests/ui/wf/wf-dyn-incompat-trait-obj-match.stderr
deleted file mode 100644
index a7405ce4caa9..000000000000
--- a/tests/ui/wf/wf-dyn-incompat-trait-obj-match.stderr
+++ /dev/null
@@ -1,60 +0,0 @@
-error[E0308]: `match` arms have incompatible types
-  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:23:17
-   |
-LL | /     match opt() {
-LL | |         Some(()) => &S,
-   | |                     -- this is found to be of type `&S`
-LL | |         None => &R,
-   | |                 ^^ expected `&S`, found `&R`
-LL | |     }
-   | |_____- `match` arms have incompatible types
-   |
-   = note: expected reference `&S`
-              found reference `&R`
-
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:26:21
-   |
-LL |         Some(()) => &S,
-   |                     ^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: the following types implement `Trait`:
-             S
-             R
-           consider defining an enum where each variant holds one of these types,
-           implementing `Trait` for this new enum and using it instead
-   = note: required for the cast from `&S` to `&dyn Trait`
-
-error[E0038]: the trait `Trait` is not dyn compatible
-  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:27:17
-   |
-LL |         None => &R,
-   |                 ^^ `Trait` is not dyn compatible
-   |
-note: for a trait to be dyn compatible it needs to allow building a vtable
-      for more information, visit <https://doc.rust-lang.org/reference/items/traits.html#dyn-compatibility>
-  --> $DIR/wf-dyn-incompat-trait-obj-match.rs:6:14
-   |
-LL | trait Trait: Sized {}
-   |       -----  ^^^^^ ...because it requires `Self: Sized`
-   |       |
-   |       this trait is not dyn compatible...
-   = help: the following types implement `Trait`:
-             S
-             R
-           consider defining an enum where each variant holds one of these types,
-           implementing `Trait` for this new enum and using it instead
-   = note: required for the cast from `&R` to `&dyn Trait`
-
-error: aborting due to 3 previous errors
-
-Some errors have detailed explanations: E0038, E0308.
-For more information about an error, try `rustc --explain E0038`.
diff --git a/triagebot.toml b/triagebot.toml
index f9eb09ff3438..7702d4133aca 100644
--- a/triagebot.toml
+++ b/triagebot.toml
@@ -706,7 +706,11 @@ cc = ["@antoyo", "@GuillaumeGomez"]
 
 [mentions."compiler/rustc_const_eval/src/"]
 message = "Some changes occurred to the CTFE machinery"
-cc = ["@rust-lang/wg-const-eval"]
+cc = ["@RalfJung", "@oli-obk", "@lcnr"]
+
+[mentions."compiler/rustc_const_eval/src/check_consts"]
+message = "Some changes occurred to constck"
+cc = ["@fee1-dead"]
 
 [mentions."compiler/rustc_const_eval/src/interpret"]
 message = "Some changes occurred to the CTFE / Miri interpreter"
@@ -730,7 +734,7 @@ cc = ["@compiler-errors", "@lcnr"]
 
 [mentions."compiler/rustc_middle/src/mir/interpret"]
 message = "Some changes occurred to the CTFE / Miri interpreter"
-cc = ["@rust-lang/miri", "@rust-lang/wg-const-eval"]
+cc = ["@rust-lang/miri", "@RalfJung", "@oli-obk", "@lcnr"]
 
 [mentions."compiler/rustc_mir_transform/src/"]
 message = "Some changes occurred to MIR optimizations"
@@ -803,7 +807,7 @@ message = """
 Some changes occurred to the intrinsics. Make sure the CTFE / Miri interpreter
 gets adapted for the changes, if necessary.
 """
-cc = ["@rust-lang/miri", "@rust-lang/wg-const-eval"]
+cc = ["@rust-lang/miri", "@RalfJung", "@oli-obk", "@lcnr"]
 
 [mentions."library/portable-simd"]
 message = """